REST Microservices with Spring Boot, Maven, JPA and Docker

Install the Java development kit from Oracle's Java SE download center (Windows, Java 17) and set PATH to include the JDK 17 bin; verify with Java C.

Install the IntelliJ community edition on Windows, configure the JDK, and set path to enable Java development for your projects, then create a Java project and run hello world.

Install Maven as a build automation tool that manages dependencies for multi-module applications. Set PATH and JAVA_HOME, then verify with mvn -version (Maven 3.8.2, JDK 17).

Install and set up postman to create new APIs, collections, and environments, and learn to send get, post, delete, and patch requests.

Explore the Spring framework basics, including inversion of control and dependency injection, and see how abstractions and interfaces enable decoupled, testable components via constructor injection.

Explore Spring framework's design for enterprise Java apps, featuring security with authentication and JWT, core container with beans and inversion of control, data access with JDBC/ORM, transactions, and web APIs.

Create your Spring application in IntelliJ with Maven, then switch to Spring Boot for power. Define a student bean in an XML context and let Spring manage the bean lifecycle.

Explore how the Spring container uses inversion of control to manage beans from Java code and metadata, compare bean factory and application context, and learn why application context is standard.

Explain the concept of bean scopes in Spring. Compare singleton and prototype scopes, noting that singleton caches one instance by default while prototype creates a new instance on each request.

Learn how the Spring container manages bean lifecycles, invoking init and destroy methods for singleton beans while explaining why destroy is not called for prototype beans to avoid memory leaks.

Explore dependency injection in Spring through a student and address example, showcasing composition, constructor injection, and bean wiring with XML definitions, addressing default constructor issues and upcoming annotation configuration.

Explore how to replace constructor-based dependency injection with annotations in Spring, using @Autowired and context annotation configuration, and understand the differences between XML and annotation-based setups.

Transition from XML to annotation-based configuration using @Configuration and @Bean to define beans in an annotation-driven application context, explore bean scopes and move toward the component annotation for auto scanning.

Use the qualifier annotation to resolve multiple beans of the same type; name beans (address first, address second) and combine with qualifier to control which instance Spring injects.

Explore why Spring Boot enables rapid development through auto configuration. Create standalone apps with embedded servers, jar packaging, and no XML configuration.

Create your first Spring Boot application using Spring Initializr, Maven, and Java, and a Rest controller. Expose a hello world endpoint with get mapping at localhost:8080/udemy via embedded Tomcat.

Explore how Spring Boot uses component scanning and dependency injection with annotations to register controllers and auto wire address and student beans, enabling RESTful services.

Explore how Spring manages scopes like singleton and prototype, why injecting a prototype into a singleton fails, and how ObjectFactory ensures fresh prototype instances.

Explore building a Spring Boot app with Maven, configuring dependencies and plugins in pom.xml, and packaging as a jar for container-friendly microservices that run with mvn or java -jar.

Learn how project Lombok reduces boilerplate by generating getters, setters, and constructors, enables the builder pattern, and how to install and enable annotation processing and the Lombok plugin in IntelliJ.

Explore how Lombok's @Getter and @Setter annotations generate getters and setters for class fields, with class-level usage and customizable setter visibility for name, age, and gender.

Explore how Lombok generates constructors—no-args, all-args, and required-args—to enable constructor-based dependency injection in Spring Boot, including final fields and automatic wiring.

Explore Lombok annotations such as @ToString, @EqualsAndHashCode, and especially @Data, which generate getters, setters, toString, equals, hashCode, and constructors to reduce boilerplate.

Compare monolithic and microservice architectures by analyzing a single jar deployment, modular Maven components (model, repository, service, UI), testing ease, and scalability trade-offs.

Learn how web services enable machine-to-machine interactions with interoperability across languages, using soap or rest over http, with requests and responses in xml or json.

Explore soap, the simple object access protocol, using XML messaging with header and body to define requests, responses, endpoints, HTTP transport, and WSDL, contrasting with RESTful services.

Learn how the hypertext transfer protocol enables client–server communication through stateless, connectionless requests and responses. Explore HTTP methods, request/response structure, status codes, and how restful services rely on HTTP.

Learn about rest, representational state transfer, and http as the transport. Identify resources by uri, representations in json or xml, noting rest is an architectural style.

Explore microservice architecture that splits a monolithic application into independent services with separate databases, deployed on different servers, communicating via HTTP REST APIs. Enable independent deployment and language diversity.

Initialize a Spring Boot user service project with the initializer, Maven, and Java, packaging as a jar. Create a REST API to create, list, and fetch a user using Lombok.

Learn to handle http get requests with spring boot by building a REST controller, mapping /users/hello with @GetMapping, and returning JSON.

Explore the four-layer microservice architecture: presentation controllers, business services, persistence repositories, and the database. Model a user with long id, Lombok, and a builder pattern with JPA and MySQL.

Explore a Spring Boot get mapping that returns all users from an in-memory user repository, demonstrated with constructor injection, a repository layer, and JSON serialization via Jackson.

Intercepts the http requests and routes them to the correct rest controller methods via get mapping and request mapping annotations, with the dispatcher servlet acting as the front controller.

Discover how to fetch a single user with @PathVariable in a Spring Boot get endpoint, mapping the URL id to a Java variable and returning that user.

Implement a delete operation using @DeleteMapping, map the id from the URL to a service method, which removes the user via the repository from an ArrayList.

Learn how to implement partial updates with patch mapping and @RequestBody in Spring Boot, updating only selected user fields via a patch user request.

Explain how to use @PathVariable and @RequestParam to handle path variables and optional query parameters, including mapping, type matching, and filtering.

Learn how http post creates a new user by sending first name, last name, and email in json; Jackson maps to a dto and returns created user with 201.

Discover how to read HTTP header values in Spring Boot via the request header annotation, including host, port, authorization tokens, and using a header map for all parameters.

Understand how status codes reflect http request outcomes, with 200 ok for getting users and 201 created when creating a new user, using the post mapping response status annotation.

Learn to fully customize an http response in spring using the rest controller and response body annotations, and manage status, headers, and json body with response entity.

Explore json representation in rest web services, mapping json to java objects with Jackson data bind in Spring Boot, including name, age, and children arrays such as John Smith.

Apply jackson annotations to control json serialization by ignoring fields and properties and using json include non-null.

Configure Jackson in the application YAML to fail on unknown properties in REST post requests, triggering a bad request for unrecognized fields and setting up later customized error handling.

Explain how @JsonProperty maps camelCase Java fields to snake_case JSON properties using Jackson, ensuring serialization and deserialization align for user data.

Explore representing Java dates as strings with the JSON format annotation, customizing patterns for the created date in a Spring Boot REST microservice.

Install MySQL on Windows by downloading the community server, running the installer, and configuring root access and port 3306. Update environment variables, then verify databases via the mysql command.

Learn how JDBC enables Java applications to connect to databases using drivers for MySQL and Oracle, navigate connections and exceptions, and see Java Persistence API with annotations simplifies object-relational mapping.

Explore the standard JDBC approach to storing users in MySQL with Spring Boot Starter JDBC and JDBC Template, creating the Udemy database and a user table with an auto-incremented id.

Explore the Java Persistence API, a specification that maps Java objects to relational tables via object-relational mapping, simplifying database access with annotations and implementations like Hibernate.

Map a user entity to a MySQL table using Java Persistence API and Hibernate, with @Entity, @Table, @Id, @GeneratedValue for auto-generated IDs, and @Column for fields, enabling automatic schema updates.

Explore mapping embedded value types with @Embeddable and @Embedded in JPA, using attribute overrides to flatten fields like gender and phone into the owning entity table.

Use Hibernate's creational and update timestamps to auto-populate a user's created and last-modified dates, replacing manual date setting and transient fields as the app shifts from an ArrayList to MySQL.

Update the service by implementing the user repository as a JPA repository extending CrudRepository, enabling default operations and automatic query methods like find by first name.

Update the user service to use a MySQL repository, implement get all and get by id with response entities and optional handling, leveraging Stream API, and delete by id.

Update a user by id via patch, validate existence, and persist changes with Spring Data JPA's save, while created and modified timestamps are managed by Hibernate.

Learn how JPQL queries target entity fields rather than database columns, use the Java Persistence Query Language with @Query annotations, and balance object-relational mapping with performance considerations.

Explore jpql and native queries via the query annotation to run sql against the user table, filtering by email patterns like gmail.com and preparing for queries with specifications and criteria.

Explore the evolution from JDBC and SQL to the Java Persistence API and JPQL, and the trade-offs of object-relational mapping. See how the Criteria API enables runtime dynamic queries.

Learn to build dynamic, type-safe queries with the JPA criteria API using a criteria builder, root, and predicates via the entity manager, with upcoming specification integration.

Construct dynamic queries by combining the criteria API with specification, using optional request parameters to build predicates and merge them with and, returning all users when no filters apply.

Learn to use the Java Persistence API specification executor with the criteria API to build dynamic user queries via repository specifications, filtering by first name, last name, and email.

Add the Spring validation dependency to enable input validation in a Spring Boot app. Use not null, not blank, and email annotations, and @Valid to produce clear error messages.

Learn how to catch and customize validation errors in a Spring Boot rest controller using @ExceptionHandler, handling method argument not valid exception, and returning a JSON error response.

Implement centralized exception handling by using a base controller and a json error message, returning 400 or 404 status codes for bad requests and not found.

define a custom user not found exception extending runtime exception, throw it when a user is missing, and catch it with an exception handler to return a not found response.

Leverage global exception handling with controller advice and rest controller advice to return JSON via the response body and centralize exceptions with an application exception handler.

Create a private constructor in an application constants class to prevent instantiation, expose a public static final email regular expression, then apply the pattern annotation to validate emails.

Learn runtime patch request validation in a spring boot rest service by manually validating first_name, last_name, and email, throwing IllegalArgumentException and returning 400 via an exception handler.