Spring Boot 2.0 Projects: Build production-grade reactive applications and microservices with Spring Boot (English Edition)

Cover
Title Page
Copyright and Credits
Dedication
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 1: Introduction
Technical requirements
Generating Spring Boot Projects
Opening the generated project with IntelliJ
Opening the generated project with STS
Getting started with Spring Boot
Learning about Spring Boot
Anatomy of a Spring Boot application
Supporting the Spring Framework ecosystem in Spring Boot
Changes since Spring Boot 1.x
Registering a Spring Bean using ApplicationContextInitializer
Configuration property binding
New property binding API
Property origin
Tightened rules for governing relaxed property binding
Environment variables with indices
Direct binding of property type java.time.Duration in the ISO-8601 form
Custom endpoints for Spring Boot Actuator using annotations
Exposing a custom Spring Boot Actuator endpoint
Extending a custom endpoint with a specialized implementation for the web
Connecting to a custom endpoint using monitoring and management tools
Custom metrics using Micrometer
Custom health indicator
Using the HTTP/2 protocol
Securing applications with Spring Security
The next milestone
Migration
Using the correct JDK and JVM
Running on Java 9
Tackling JAXBException
Using the correct AspectJ version
Being aware of limitations on Apache Cassandra drivers
Being aware of issues with the Maven Surefire Plugin
Using the upgraded Spring Framework 5.0
Modified CORS support behavior
Removed packages, classes, and methods
Dropped support for frameworks
Using the updated configuration properties
Using the changed servlet-specific server properties
Using the modified template engine extension handling
Using the changed actuator configuration properties
Using the changed actuator base path
Using the renamed actuator endpoints
Using the changed Embedded Container Configuration 
Using the changed default behavior for path mapping
Using the changed default dispatcher types for the servlet filter 
Using the modified transitive dependency to spring-boot-web-starter
Using the changed default proxying strategy 
Using the modified configuration location strategy
Using the changed Jackson/JSON support
Using the changed Spring Boot Actuator security
Using the changed HikariCP default connection pool for JPA
Using the changed default database initialization strategy
Using the changed database schema creation strategy
Using the changed testing support
Using the revised Spring Security
Using the changed default security auto-configuration strategy
Spring Security OAuth2 is migrated to Spring Security core 
Using the AuthenticationManager bean 
Understanding removed features
Summary
Questions
Further reading
Chapter 2: Building a Basic Web Application
Technical requirements
Getting started
Web application architecture
Workflow of Spring Web MVC 
Requirements for our web application
The use case diagram 
Using Spring Data JPA for persistence
Understanding the Java Persistence API (JPA)
Understanding Spring Data JPA
Class diagram for the domain model
Implementation of the domain model using JPA annotations
Setting up dependencies and configuration
Implementing the domain model
Implementation of Spring Data JPA repositories
Testing Spring Data JPA repositories
Using Spring Boot Devtools for database visualization
Using Services to encapsulate business logic
Testing Services
Using Spring Thymeleaf for the view
Understanding template engines
Spring Thymeleaf 
UI design for the Retro Board
UI implementation for the Retro Board using Spring Thymeleaf
Using Spring Web MVC with servlet 3.x for the controller
Implementation of Controllers annotations
Testing controllers
Using Spring Security for authentication and authorization
Demonstrating the Retro Board
Summary
Questions
Further reading
Chapter 3: Building a Simple Blog Management System
Technical requirements
Getting started
Web application architecture
Workflow of Spring WebFlux
Requirements of the Bloggest system
The use case diagram 
Using Spring Data Elasticsearch for persistence
Understanding Elasticsearch
Understanding Spring Data Elasticsearch
Class diagram for the domain model
Implementation of the domain model using Spring Data Elasticsearch annotations
Setting up dependencies and configuration classes
Implementing the domain model
Implementation of Spring Data Elasticsearch repositories
Using Apache FreeMarker for the view
Understanding template engines
Apache FreeMarker
UI design for Bloggest
UI implementation for Bloggest using Apache FreeMarker
Implementing a common layout using Apache FreeMarker
Implementing a List Articles page
Implementing a Create Article page
Implementing a Show Article page
Implementing an error page
Using Spring WebFlux for controller
Implementation of controllers
Implementation of ControllerAdvice
Using Spring Security for authentication and authorization
Demonstrating Bloggest
Summary
Questions
Further reading
Chapter 4: Introduction to Kotlin
Technical requirements
Getting started with Kotlin
Default imports
Basic data types
Numeric data types
Learning numeric literals
Numeric representation
Numeric operations
String literals
The syntax for Kotlin code
The Kotlin packages
String interpolation
Functions in Kotlin
Variables in Kotlin
Conditional statements
The if statement
The when statement 
Type checking and automatic casting
Nullable values and compile-time null safety 
The for loop
The for loop with an array
The for loop with a collection
The for loop with a value range
The while loop
Object-oriented programming with Kotlin
Learning about visibility modifiers
Classes in Kotlin
Abstract classes
Concrete classes
The concept of interfaces in Kotlin
Learning about extensions
Generic types in Kotlin
Enums in Kotlin
Objects in Kotlin
Object expressions
Object declarations
Companion objects
Advanced programming with Kotlin
Functions
Infix notation in functions
Local functions in Kotlin
Default arguments in functions
Named arguments in functions
Generics in functions
Variable number of arguments (vararg) in functions
Summary
Questions
Further reading
Chapter 5: Building a Reactive Movie Rating API Using Kotlin
Technical requirements
Getting started
REST architecture
Requirements of REST architecture
The use case diagram
Using Spring Data MongoDB for persistence
Understanding MongoDB 
Understanding Spring Data MongoDB
Class diagram for the domain model
Implementation of the domain model using Spring Data MongoDB annotations
Setting up dependencies and configuration
Implementing the domain model
Implementing of Spring Data MongoDB repositories
Using a service to encapsulate business logic
Testing Services
Using Spring WebFlux for controllers
Implementation of controllers
Testing controllers
Using Spring Security for basic authorization
Demonstrating Moviee
Integration testing
Demonstrating the use of Postman
Accessing the List Movies endpoint
Accessing the Get Movie endpoint
Accessing the Get Movie endpoint with an invalid Movie ID
Accessing the Rate Movie endpoint
Summary
Questions
Further reading
Chapter 6: Building an API with Reactive Microservices
Technical requirements
Getting started
Microservices architecture
The requirements of microservices architecture
The use case diagram
The project structure to develop microservices
Using Spring Data Redis for persistence
Understanding Redis
Understanding Spring Data Redis
Class diagram for the domain model
Implementation of domain model using Spring Data Redis annotations
Setting up dependencies and configuration
 Implementing the domain model
Implementation of Spring Data Redis repositories
Using a Service to encapsulate business logic 
Using Spring WebFlux for a controller
Implementation of controllers
Using asynchronous data transfer for cross-microservice communication
Asynchronous data transfer using Redis
Using Docker to support microservices
Understanding Docker
Using Maven to build Docker images
Building a system of microservices with Docker
Deploying microservices with Docker
Demonstrating Saber
Submitting to the Register Taxi endpoint
Submitting location to update Taxi Location endpoint
Submitting to Update Taxi Status endpoint
Accessing the Get Taxi Status endpoint
Accessing the GET available Taxis endpoint
Submitting to Book Taxi endpoint
Submitting to Accept Taxi Booking endpoint
Submitting to cancel Taxi Booking endpoint
Accessing Taxi Bookings endpoint
Summary 
Questions
Further reading
Chapter 7: Building a Twitter Clone with Spring Boot
Technical requirements
Getting started
Beginning with the Tweety architecture
Tweety requirements
The use case diagram
Using Spring Data JPA for persistence
Class diagram for the domain model
Implementation of the domain model using Spring Data JPA annotations
Setting up dependencies and configuration
Implementing the domain model
Implementing Spring Data JPA repositories
Caveat for going reactive with blocking JDBC 
Using Service to encapsulate business logic 
Using Angular 5 for the frontend
Getting started with Angular 5 application development
Generating Angular services
Generating the users service
Generating Angular page components
Generating the Tweets Add page
Generating the User Profile page
Using Spring Web Flux for the REST controller
Implementing controllers
Enabling Angular frontend access to controllers
Using Spring Security for authentication and authorization
Understanding OAuth2 
Setting up dependencies and configuration
Configuring the Resource Server
Configuring the Authorization Server
Configuring web security
Using an Angular service for OAuth2 authentication and authorization
Demonstrating Tweety
Accessing the login page
Accessing the List Tweets page
Accessing the Send Tweet page
Accessing the User Profile page
Summary
Questions
Further reading
Chapter 8: Introducing Spring Boot 2.0 Asynchronous
Technical requirements
Getting started
Synchronous applications
Asynchronous applications
The requirement of asynchronous applications
The use case diagram
The architecture of an image resizing application
Using Spring Kafka for communication
Understanding Apache Kafka
Setting up dependencies and configuration
Configuration for the Image Resize Request Producer
Configuration for Image Resize Request Consumer
Starting Spring Boot applications in a non-web mode
Using Quartz for scheduling
Understanding Quartz
Setting up dependencies and configuration
Configuration for Quartz scheduling
Demonstrating Image Resizer
Building all dependencies 
Running Apache Kafka
Running Apache ZooKeeper on Windows
Running Apache Kafka on Linux/Unix
Running Apache Kafka on Windows
Running Image Resize Request Consumer
Running Image Resize Request Producer
Summary
Questions
Further reading
Chapter 9: Building an Asynchronous Email Formatter
Technical requirements
Getting started
Why Email Formatter is useful
The use case diagram
The architecture of the Email Formatter application
Using Spring Data JPA for persistence
Class diagram for the domain model
Implementation of the domain model using JPA annotations
Setting up dependencies and the configuration class
Implementing the domain model
Implementation of Spring Data JPA repositories
Using Services to encapsulate business logic
Using Apache FreeMarker for templates
Using Spring Kafka for communication
Setting up dependencies and the configuration class
Configuration for User Registration
Configuration for the Email Formatter consumer
Configuring Java Mail
Using Spring Web MVC for the REST controller
Implementation of controller annotations
Using Spring Security for authentication and authorization
Demonstrating Email Formatter
Building all dependencies 
Running Apache Kafka
Running Apache ZooKeeper on Windows
Running Apache Kafka on Linux/Unix
Running Apache Kafka on Windows
Running SMTP server
Running the Email Formatter consumer
Running the User Registration microservice
Summary
Questions
Further reading
Assessments
Other Books You May Enjoy
Index