REST API's RESTFul from 0 to AWS with Spring Boot and Docker

Explore rest theoretical foundations, including soap vs rest, request and response concepts, verbs, status codes, and parameters, plus hateoas, jwt security, and endpoint versioning.

Compare SOAP and REST architectures, highlighting SOAP envelopes and RPC over HTTP versus REST's HTTP requests with JSON, XML, and other formats. Explore readability, performance, and data transfer differences.

Explore the representational state transfer model, its six constraints, and formats like JSON and XML; recognize REST's lightweight, scalable nature and its ubiquity in top apps.

Understand how the http protocol underpins rest, with client requests to servers and the server returns the response, including request line, header, empty line, and body, plus status code.

Learn how path, query, header, and body parameters drive REST API requests, with examples from paginated book lists and search filters.

Discover how an api uses http status codes to communicate request results, focusing on 200, 201, 202, 204, 400, 401, 403, 404, 405, 409, and 500.

Explains http verbs like get, post, put, patch, and delete in rest, with crud analogy, plus how to use headers, path param, query param, or body, and relevant status codes.

Explore less known HTTP verbs beyond the main four, including patch for partial updates to save bandwidth, and note head, trace, options, and connect uses.

Explore Richardson's four levels of REST maturity, from the xml swamp at level 0 to level 3's hateoas-driven hypermedia, and learn how verbs and resources define a truly restful API.

Explore HATEOAS, the hypermedia as the engine of application state, a REST constraint that delivers links to navigate endpoints and perform next steps.

document how swagger documents rest apis, detailing parameters, responses, models, and media types such as json, xml, csv, binary, and explain swagger’s evolution into the Open API Initiative.

Learn authentication and authorization using JSON Web Tokens (JWT). Clients obtain a token after valid credentials and pass it in the Authorization header; tokens expire, with refresh options discussed.

Learn how to version your REST APIs to evolve safely, comparing path, subdomain, and query string approaches with header options, and adopting path versioning for clean, dev-friendly URLs.

Go beyond RESTful by adding subscription-based request limits and billing options for your API. Create an SDK and sandbox with mocks to simplify integration for developers.

Adopt RESTful best practices by paginating and filtering data, caching for performance, defining logical resources, and ensuring fault tolerance, timeouts, and rich Swagger and HATEOAS documentation.

Master REST theory foundations: contrast web services and SOAP, and cover requests, responses, parameters, status codes, verbs, Richardson's maturity levels, HATEOAS, Swagger, authentication, API versioning, and best practices.

Identify and install the required development tools for Windows, including Java 11, Maven, and Eclipse, plus database clients like MySQL Workbench or HeidiSQL, Postman, and Docker.

Identify the tools you need for this course, including Java 11, Maven, Eclipse, MySQL Workbench, Postman, Docker, and Docker Compose. Linux users should consult Appendix 2 for setup guidance.

Begin the practical part by creating a Github repository, cloning code, scaffolding a Spring Boot project via Spring Initializr, importing it into Eclipse, and pushing to Github.

Create a GitHub repository and initialize it with a readme, then clone it locally to version your project and prepare for Spring Boot development.

Explore creating a Spring Boot project with Spring Initializr, using Maven in Java 11, and import into Eclipse to work from a ready skeleton.

Add Spring Boot to a Maven project by updating pom.xml, wiring dependencies, and building a Spring Boot app with a greeting rest controller at /greeting.

Push your Spring Boot project to GitHub, track and commit changes with git status and git add, ignore jar files with gitignore, then preview a rest calculator using get.

Learn how to use gitignore to ignore directories and files, edit the gitignore directly or via command line, and version the file for clean project commits.

Review section five essentials: create and clone a GitHub repository, scaffold Spring Initializr and Eclipse projects, and learn Git basics for versioning code ahead of implementing a REST calculator.

Build a REST calculator from the ground up using Spring Boot in Eclipse, implementing the GET verb with path and query params, data validation, exception handling, and Postman testing.

Implement a Spring Boot calculator controller using path variables for numberOne and numberTwo with a sum get endpoint, illustrating binding, conversion, and handling mandatory parameters.

Refactor and implement numeric validation in the calculator, add isNumeric and convertToDouble, prepare for the sum, handle exceptions with a custom message, and rename the controller to math controller.

Implement numeric validation by adding IsNumeric and ConvertToDouble, renaming input to strNumber and replacing commas with dots for locale consistency. Validate with a regex and parse to double.

Run and debug a Spring Boot project, correctly configure path parameters with braces, and trace a loop pointer and numeric conversion error using breakpoints and debugging steps.

Explore robust exception handling in a Spring Boot REST API by implementing a custom exception and handler, returning elegant, informative messages for bad requests via a structured exceptional response.

Implement additional calculator operations—subtraction, multiplication, division, mean, and square root—within a Spring Boot REST API, test in the browser, and refactor into converter and math classes for better organization.

Implement a calculator by using get with path and query parameters, validate data, and handle exceptions while learning to use Postman; build a foundation for other verbs.

Explore the four main http verbs: get, post, put, and delete; understand the concepts behind each verb and when to use them, with hands-on practice using post in code.

Create and inject a person service into the controller using Spring's dependency injection. Generate incremental ids and return a person object via get requests, expanding beyond the initial get-only implementation.

Expose a mock list of people via a rest endpoint, generate sample users with a loop, and fix duplicate mappings so the app runs and returns the list.

Learn to implement create, update, and delete operations using post, put, and delete verbs in a Spring Boot REST API, including controller and service persistence with JSON requests.

Master the four main http verbs through a people CRUD, exploring get, post, put, and delete with dependency injection and postman, as you prepare to connect to a MySQL database.

Connect your application to a MySQL database using JPA and Hibernate, learn essential database concepts, practice SQL scripts, and test endpoints with Postman.

Create and connect your database by configuring Spring Boot's application.properties with the MySQL driver, URL, user, and password, then set the Hibernate dialect, hbm2ddl.auto, and show_sql accordingly.

Add Spring Boot starter data JPA and MySQL driver to connect to the database, then map a parasol class to a table with entity, table, generated value, and column annotations.

Refactor a spring boot service to support create, find, update, and delete operations using spring data, with custom not-found handling and refined exception messaging.

refactor our controller to streamline the delete operation and handle updated data, then validate the full create-read-delete flow using postman and a persisting person table with json requests.

Integrate spring boot REST API with a MySQL database using Hibernate and JPA; configure connections in application properties, apply dependency injection, handle exceptions, and support get, post, put, and delete.

Explore the value object design pattern, its importance, and practical concepts, including using Dozer for security, deeper Hibernate concepts, and separating large data from presentation.

Explore the value object design pattern to decouple API views from database schemas, using adapters and a mediation service to convert value objects into entities for persistence.

Implement the VO design pattern with the Dozer framework by building a converter that maps between model and view, using a Dozer mapper for single and list transformations, with tests.

Refactor the service and controller by adding a converter to map between the personal view and database entities, enabling safe save, update, and delete operations via the api.

Implement the value object design pattern and its role in shaping the application architecture, including using a factory to adapt architecture, encapsulation, and converting between value objects and entities.

Explore API versioning strategies, learn how controllers implement versioned endpoints, and examine the architectural importance of the view design pattern in REST APIs with Spring Boot and Docker.

Version your API by introducing v2 alongside v1, giving clients time to adapt before deprecating the original endpoint.

Learn to create a custom converter for a new endpoint, wire it into a controller, and support v1 and v2 without breaking existing clients.

Explore API versioning strategies and how to implement versioning via a controller, and learn conversion techniques without using Dozer. Look ahead to migrations in the next session.