Spring Boot Microservices with Spring Cloud Beginner to Guru

Explore REST services, the HTTP protocol, and the role of RESTful communication in microservices, then preview building and consuming REST services with Spring MVC in this course.

Explore HTTP request methods and status codes, learning verbs like GET, POST, PUT, DELETE, and understanding safe, idempotent behavior across 200, 300, 400, and 500 series responses.

Explore RESTful services basics, including common HTTP verbs, URI concepts, and idempotence, and learn how statelessness, HATEOAS, and JSON representations guide resource interactions.

Learn the Richardson maturity model for REST, from the swamp of POX to level 3 with hypermedia controls, noting that most RESTful APIs conform to level 2.

Conclude the course segment on restful web services by contrasting REST and SOAP, highlighting the lack of a formal REST standard and the need to adapt when integrating third-party services.

Build RESTful endpoints on the server side using Spring MVC with Spring Boot. Explore REST terminology, producer side methods, and how Spring Framework enables client-server communication.

Introducing the SFG Beer Works microservices demo, a beer distribution supply chain built with Spring Boot and Spring Cloud, featuring four services: Beer Consumer, Pub, Distributor, and Breweries.

Learn to create a spring mvc rest get endpoint that returns a beer dto via a dedicated beer service and controller, in a spring boot 2.1.4 project.

Implement a Spring MVC post endpoint to create a new BeerDto, save it via the BeerService, and return a 201 created response with a Location header.

implement put mapping in spring mvc to update an existing beer via its id and a beer dto, then return a 204 no-content response indicating a successful, idempotent update.

Learn how the @RequestBody annotation binds JSON to a beerDto in Spring MVC, and why omitting it yields an empty object, with MockMvc, JUnit 4, Mockito, and ObjectMapper tests.

Implement a Spring MVC delete endpoint for beer, binding beerId as UUID with @DeleteMapping and @PathVariable, log with Lombok @Slf4j, call beerService.deleteById, and return 204 no content via @ResponseStatus.

Learn how API versioning lets you evolve microservices without breaking existing clients, using semantic versioning (major, minor, patch), deprecation, and URL-based versioning.

Learn how to implement a major api version change within a spring boot microservice by evolving beer model from string to enum, creating v2 packages and controllers, and routing api/v2/beer.

Learn how to manage api versioning with source control using feature and release branches, track breaking and non-breaking changes, and maintain multiple api versions across microservices.

Develop the beer service data model by creating BeerDto with id, version, createdDate, lastModifiedDate, beerName, beerStyle, upc, quantityOnHand, and price, using Lombok builders. Add a BeerPageList for paging.

Explore how to use Spring RestTemplate to call RESTful services, configure an externalized api host with configuration properties via Spring Boot and RestTemplateBuilder, and test with integration tests.

Learn to post a new beer with Spring RestTemplate by implementing saveNewBeer that returns the location URI via postForLocation, and verify the flow with integration tests using the BreweryClient.

Practice test-driven development by live-coding a customer service client with four CRUD operations (get, save, update, delete) using restTemplate and getForObject, validating tests turn green for github submission.

Explore HTTP clients for REST in Java, covering TCP/IP, sockets, blocking vs non-blocking I/O, connection pooling, and HTTP/2 support with popular clients like Apache, Jersey, OkHTTP, and Netty.

Configure Spring Boot to use the Apache HttpClient via RestTemplateCustomizer, set up a pooling connection manager with timeouts, and inject a ClosableHttpClient into a ClientHttpRequestFactory for efficient rest calls.

Configure Apache HttpClient request logging at debug level in Spring Boot to see headers, url, and wire data for troubleshooting, while noting performance costs and sensitive data risks.

Implement a bootstrap data loader that runs on startup to seed beer objects via a command line runner, using a beer repository with Spring Data JPA for testing and development.

Master the restful client basics and its versatile role for consuming a restful application programming interface in the Spring Framework, highlighting its methods and overloading as a foundational tool.

Transition into Spring validation, introducing bean validation and validation constraints for data entering controller methods, replacing hand-rolled validation with a consistent Java ecosystem approach.

Enable bean validation in Spring Boot by adding the starter validation dependency, apply javax validation constraints on the dto, and trigger validation with @Valid to produce a 400 on errors.

Learn bean validation error handling in spring boot microservices by returning a structured list of constraint violation messages from a v2 controller via a custom exception handler and response entity.

Enforce not blank and size 3 to 100 on the customer name with bean validation, using @Valid and @RequestBody in REST post and put methods, and return detailed validation errors.

Use controller advice to create a global exception handler, eliminating duplicate code across controllers, handle bind exceptions via BindException, and return a detailed error list as JSON with ResponseEntity.

Implement bean validation in the beer microservice by annotating BeerDto with @NotBlank, @NotNull, and @Positive. Enforce null on read-only fields like beerId, version, createdDate, and lastModifiedDate to prevent binding.

Apply bean validation with annotations and custom constraints in production-grade Spring Boot microservices, and craft clear error messages that align with API documentation for robust defensive coding.

Discover project Lombok's annotation processing that generates boilerplate code, including getters, setters, toString, EqualsAndHashCode, and constructors, plus builder support and lazy getters.

Explore MapStruct, a code generator and annotation processor that maps between Java bean types, follows convention over configuration, and supports custom mappings, Spring components, and Lombok builder integration.

Learn to configure MapStruct with Lombok in a Spring Boot project, including adding MapStruct and Maven compiler plugin settings and annotation processing paths, and handling version-specific Lombok MapStruct binding.

Explore building a two-way mapper with MapStruct by converting between Beer domain entities and BeerDto objects, generating a mapper implementation and ensuring simple, error-free persistence model transfers.

Build a MapStruct mapper that converts between Customer and CustomerDTO, using a @Mapper interface and a Lombok domain class, then compile and inspect the generated code.

Set up MapStruct to map between CustomerDTO and a domain Customer, implementing a mapper interface with two methods for dto-to-domain and domain-to-dto conversion, using Lombok and Spring components.

Discover how MapStruct handles date conversions between OffsetDateTime and SQL timestamp using a Spring component date mapper, enabling seamless mapping for BeerDto and domain classes.

Fix failing tests by adding a getValidBeerDto helper, set required properties (enable, price, upc) and not-null constraints, refactor tests, rerun to green, and commit the delta to GitHub.

Explore how Project Lombok and MapStruct save time by automating the builder pattern and logging configuration. This introduction to MapStruct highlights capabilities and sets up complex examples for Java development.

Review the beer service project for Spring REST Docs, covering Java 11, Spring Boot 2.1.5, JPA with H2, Lombok, and MapStruct.

Configure maven to support spring rest docs by adding the rest docs dependency and asciidoctor plugin, create asciidoctor directory with index.adoc, and generate snippets into an html document during prepare-package.

Configure spring rest docs to document a path parameter for the getBeerById endpoint, using pathParameters and parameterWithName to describe beerId as a UUID.

Document the getBeerId response by adding responseFields with fieldWithPath, ensuring all returned properties are documented for REST Docs.

Customize uri properties in Spring REST Docs for Spring Boot microservices, using AutoConfigureRestDocs to set uriScheme, host, and port, and regenerate documentation against a development server.

Generate and validate spring rest documentation by configuring maven and asciidoctor to produce generated-snippets and generated-docs. Fix identifier uniqueness for operations like v1/beer-new to ensure complete, error-free documentation.

Reviewing the Spring REST Docs integration: switch to JUnit 5, add Spring REST Docs and Asciidoctor, configure MockMvc, document beer endpoints and constraints, and generate accessible docs.

Explore the capabilities of Spring REST Docs for accurate API documentation, its unit-test integration, and Asciidoctor customization, and compare it with OpenAPI as another robust option.

Learn how Spring Boot handles JSON serialization and deserialization, converting Java objects to JSON and back, with auto configuration for Jackson, Gson, and JSON-B.

Set up a Spring Boot json test with @JsonTest and an ObjectMapper to serialize a BeerDto to json and deserialize it back, using Jackson as the binding engine.

Configure Jackson to use kebab naming strategy by creating application-kebab.properties, run @JsonTest with the kebab profile, and verify beer-name and beer-style JSON fields across camel, snake, and kebab conventions.

Create a custom local date deserializer with Jackson by extending StdDeserializer, implement deserialize to parse using a BASIC_ISO_DATE formatter, annotate the POJO, and update tests and JSON accordingly.

Apply Jackson configuration to the BeerDto with json format annotations for price and dates. Ensure price is serialized as a string and createdDate and lastModifiedDate are properly formatted.

Implement controller methods for the beer service, wire a BeerService via constructor, map between Beer and BeerDto, and throw NotFoundException via orElseThrow.

Conclude the module on processing JSON with Jackson, highlighting production and consumption of JSON, Jackson’s popularity surpassing Guava, and the importance of keeping libraries current for security.

Explore moving from monolith to microservices using a brewery application model, and learn architectural decisions, dependency management, and deployment considerations.

Deconstruct the Beer Works monolith into microservices using Spring Boot and Spring Framework, modeling beers, inventory, orders, and customers with event-driven messaging and tasting room demand.

Deconstruct a monolith into microservices using domain driven design and bounded contexts, outlining entities, value objects, domain events, aggregates, and repositories within a ubiquitous language.

Explore plans to deconstruct a monolith into bounded contexts with BeerOrderService, beers, and BeerInventoryService, defining aggregates and life cycle as we split into true microservices.

Review the beer-order-service code, detailing the domain setup (BeerOrder, BeerOrderLine, Customer, OrderStatusEnum), UPC-based data seeding, and cross-service coordination.

Review the beer inventory microservice code, exploring the BeerInventory entity, repository, dto mapping with Mapstruct, and a simple controller, while setting up ci pipelines and seed data for integration.

Review and implement the showInventoryOnHand query parameter across list beers and get beer by id endpoints, updating BeerController, BeerService, and BeerMapper to optionally include inventory data for API consumers.

Cache beer data with Ehcache in a Spring Boot app, configuring beerCache and beerListCache, and apply conditional caching when inventory is off to boost get and list beer performance.

Implement a new get beer by upc endpoint at /v1/beerUpc, wiring it through beerController, beerService, and beerRepository with a findByUpc method and enabling caching via beerUpcCache.

Enhance the order response by fetching beer data from the beer service and updating order lines with beer name and style using a rest template call and a custom mapper.

Deconstruct the monolith into three microservices with independent databases, enable inter-service communication, and implement a Maven BOM, JMS messaging, and saga coordination.

Building on the monolith-to-microservices transition, this lecture highlights progress, notes upcoming steps, and frames the challenges of splitting a single application into individual microservices and databases.