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