book

Mastering Spring Boot 3.0

by Ahmet Meric

June 2024

Intermediate to advanced

256 pages

6h 41m

English

Packt Publishing

Read now

Unlock full access

ContributorsAbout the authorAbout the reviewers
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Technical requirementsWhy use Spring Boot for advanced projects?The complexity of modern software developmentThe advantages of Spring BootEmbracing the new era – the innovations of Spring Boot 3.0Wrapping up – why Spring Boot 3.0 is your advanced project allyA brief overview of what’s to comeChapter 2, Key Architectural Patterns in Microservices – DDD, CQRS, and Event SourcingChapter 3, Reactive REST Development and Asynchronous SystemsChapter 4, Spring Data: SQL, NoSQL, Cache Abstraction, and Batch ProcessingChapter 5, Securing Your Spring Boot ApplicationsChapter 6, Advanced Testing StrategiesChapter 7, Spring Boot 3.0 Features for Containerization and OrchestrationChapter 8, Exploring Event-Driven Systems with KafkaChapter 9, Enhancing Productivity and Development SimplificationSummary
Technical requirementsIntroduction to architectural patterns in microservicesWhy do we need an architectural design in the first place?What are design patterns?What are microservices?What are the principles behind microservices?Microservices design patternsExploring DDDWhat is a domain exactly?What is DDD?How to define DDD structure?Learning about CQRSWhat is the context of CQRS?What are best practices and common pitfalls?What are the benefits of the CQRS design pattern?Understanding Event SourcingEvent-Driven ArchitectureWhat is Event Sourcing?Differences between Event-Driven Architecture and Event SourcingA real-world example of the Event Sourcing patternThe relation of Event Sourcing with CQRSA real-world example of CQRS with Event SourcingBrief overview of other architectural patternsService Oriented Architecture (SOA) design patternThe Circuit Breaker patternThe Layered design patternThe MVC design patternThe Saga design patternSummary
Technical requirementsIntroduction to reactive programmingIntroducing reactive programming basicsContrasting paradigms – reactive versus traditional programmingExploring the dictionary of reactive programmingIdentifying opportunities for reactive programmingLearning from the field – reactive programming in actionLeveraging Spring Boot 3.0 for reactive solutionsWrapping up and looking forwardBuilding a reactive REST APISetting up the development environmentImplementing the repository layerBuilding the reactive REST controllerAdding advanced Mono operationsRunning the Spring Boot application with Gradle and Java 17ConclusionAsynchronous systems and backpressureDiving into backpressureImplementing backpressure in the projectObservations and conclusionsSummary
Technical requirementsIntroduction to Spring DataUnderstanding the fundamentals and benefits of Spring DataSetting up your Spring Boot projectUsing Spring Data with SQL databasesIntegrating PostgreSQL with Spring Boot using DockerDeveloping complex relationships between entitiesImplementing practical CRUD operations in the online bookstoreNoSQL databases in Spring BootExploring the integration of NoSQL databases in Spring BootSetting up and configuring MongoDBBuilding the Review object and its repositoryImplementing a hybrid data model in the online bookstoreSpring Boot cache abstractionUnderstanding cache abstractionConfiguring and using cache abstraction in the applicationIn conclusionSpring Boot batch processingUnderstanding the role of batch processing in Spring BootImplementing Spring BatchExecuting the batch jobData migration and consistencyExploring data migration strategies and tools like LiquibasePractical steps for implementing data migration using LiquibaseImplementing migration strategies in the online bookstoreSummary
Technical requirementsIntroducing security in Spring Boot 3.0Exploring Spring Boot 3.0’s security featuresSetting up a basic security configurationImplementing OAuth2 and JWTConfiguring OAuth2 with KeycloakTesting our endpoints with an access tokenImplementing RBAC in Spring BootDefining roles and permissions in KeycloakTailoring the book store application for role-based accessSummary

Technical requirementsTDD in Spring BootImplementing TDDDiscussing terminology for unit testsUnit testing of controllers with a security layerKey annotations for Spring MVC controller testingCrafting controller tests with Spring annotationsIntegration testing – bridging components togetherSetting up the testing environmentConfiguring application properties for integration testingInitializing the database with TestcontainersMocking external services with WireMockWriting integration tests for Author ControllerTesting reactive componentsSetting up the testing environmentPreparing mock componentsWriting test casesSummary
Technical requirementsContainerization and orchestration in Spring BootUnderstanding containerization – your app in a boxReaping the benefits – lighter loads, quicker startsGetting Spring Boot in the game – container-friendly from the startUnleashing Spring Boot superpowers – portability, efficiency, and controlSpring Boot and DockerCrafting efficient Docker images with layered jarsSimplifying Dockerization with Cloud Native BuildpacksEnhancing graceful shutdown capabilitiesOptimizing Spring Boot apps for KubernetesIntegrating Kubernetes probes for application healthManaging configurations and Secrets with KubernetesUtilizing profile-specific configurations in KubernetesSpring Boot Actuator with Prometheus and GrafanaIntegrating Prometheus for metrics collectionVisualizing metrics with GrafanaSummary
Technical requirementsIntroduction to event-driven architectureSetting up Kafka and ZooKeeper for local developmentUnderstanding Kafka brokers and their role in event-driven systemsRunning Kafka and ZooKeeper with DockerBuilding an event-driven application with Spring Boot messagingCreating a Spring Boot project for Kafka integrationBuilding the producer applicationBuilding the consumer applicationTesting the whole stack – bringing your event-driven architecture to lifeMonitoring event-driven systemsMonitoring your Kafka infrastructureUsing CMAK to monitor the Kafka serverSummary
Technical requirementsIntroducing AOP in Spring BootExploring the basics of AOP – join points, pointcuts, advice declarations, and weavingCrafting a logging aspect – a step-by-step exampleSimplifying HTTP API with the Feign ClientWhat is the Feign Client?Implementing the Feign Client in Spring BootAdvanced Spring Boot auto-configurationWhat is advanced auto-configuration?Understanding conditional configurationCommon pitfalls and best practicesEmbracing best practices in Spring Boot – AOP, the Feign Client, and advanced auto-configurationNavigating common pitfalls in Spring Boot – AOP, the Feign Client, and advanced auto-configurationReal-world example – incorrectly scoped proxies in AOPSummary
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Mastering Spring Boot 3.0

8 Exploring Event-Driven Systems with Kafka

In this chapter, we will delve into the mechanics of creating an event-driven system using Kafka and Spring Boot. Here, we’ll discover how to configure Kafka and ZooKeeper on your computer using Docker, laying the foundation for developing microservices that can seamlessly communicate through events. You’ll get hands-on experience with building two Spring Boot applications: one for generating events and the other for consuming them, simulating the functions of a sender and receiver in a messaging framework.

The ultimate aim of this chapter is to equip you with the skills to design, deploy, and monitor an event-driven architecture (EDA) that harnesses the capabilities of Kafka combined with the simplicity ...