This chapter will be using ch07 again to implement services that use ConnectableFlux<T> and Processor<T>.
- Preface
- Getting Started with Spring
- Installing Java Development Kit 1.8
- Installing Tomcat 9 and configuring HTTP/2
- Installing STS Eclipse 3.8 IDE
- Creating Eclipse projects using Maven
- Creating Spring STS Eclipse projects using Gradle
- Deploying Spring projects using Maven
- Deploying Spring projects using Gradle
- Installing the MySQL 5.7 database server
- Installing the MongoDB 3.2 database server
- Learning Dependency Injection (DI)
- Implementing a Spring container using XML
- Implementing a Spring container using JavaConfig
- Managing beans in an XML-based container
- Managing beans in the JavaConfig container
- Creating Singleton and Prototype beans
- Defining eager and lazy spring beans
- Creating an inner bean
- Injecting Collections and Properties
- Creating a Spring MVC using an XML-based approach
- Creating a Spring MVC using the JavaConfig approach
- Generating multiple ApplicationContexts
- Using ResourceBundleMessageSource for Views
- Implementing MVC Design Patterns
- Creating the simple @Controller
- Creating a simple @Controller with method-level URL mapping
- Designing a simple form @Controller
- Creating a multi-action @Controller
- Form validation and parameter type conversion
- Creating request- and session-scoped beans
- Implementing page redirection and Flash-scoped beans
- Creating database connection pooling
- Implementing the DAO layer using the Spring JDBC Framework
- Creating a service layer in an MVC application
- Securing Spring MVC Applications
- Configuring Spring Security 4.2.2
- Mapping sessions to channels and ports
- Customizing the authentication process
- Implementing authentication filters, login success, and failure handlers
- Creating user details
- Generating encrypted passwords
- Applying Security to MVC methods
- Creating roles and permissions from the database
- Managing and storing sessions
- Solving Cross-Site Request Forgery (CSRF) and session fixation attacks
- Solving Cross-Site Scripting (XSS) and clickjacking attacks
- Creating interceptors for login data validation
- Cross-Cutting the MVC
- Logging and auditing service methods
- Managing DAO transactions
- Monitoring services and request handlers
- Validating parameters and arguments
- Managing exceptions
- Implementing the caching mechanism
- Intercepting request transactions
- Implementing user authentication
- Accessing with restrictions
- Controlling concurrent user access
- Implementing a mini-workflow using AOP
- Functional Programming
- Implementing lambda expressions using anonymous inner classes
- Implementing lambda expression using @FunctionInterface
- Applying the built-in functional interfaces
- Applying method and constructor references
- Using the Stream API
- Applying streams to collections
- Applying streams to NIO 2.0
- Using parallel streams
- Reactive Programming
- Applying the observer design pattern using Reactive Streams
- Creating Mono<T> and Flux<T> publishers
- Implementing the Subscriber<T> interface
- Applying backpressure to Mono<T> and Flux<T>
- Managing task executions using Schedulers
- Creating concurrent and parallel emissions
- Managing continuous data emission
- Implementing Stream manipulation and transformation
- Testing Reactive data transactions
- Implementing Reactive events using RxJava 2.x
- Reactive Web Applications
- Configuring the TaskExecutor
- Implementing @Async services
- Creating asynchronous controllers
- Creating @Scheduled services
- Using Future<T> and CallableFuture<T>
- Using Mono<T> and Flux<T> publishers for services
- Creating Mono<T> and Flux<T> HTTP response
- Integrating RxJava 2.0
- Using FreeMarker to render Publisher<T> stream
- Using Thymeleaf to render a Publisher<T> stream
- Applying security on TaskExecutors
- Spring Boot 2.0
- Building a non-reactive Spring MVC application
- Configuring Logging
- Adding JDBC Connectivity
- Building a reactive Spring MVC application
- Configuring Spring Security 5.x
- Using reactive view resolvers
- Using RouterFunction and HandlerFunction
- Implementing Spring Data with JPA
- Implementing REST services using @RestController and Spring REST
- Applying Spring Cache
- The Microservices
- Exposing RESTful services in Spring 5
- Using the actuator REST endpoints
- Building a client-side application with RestTemplate, AsyncRestTemplate and, WebClient
- Configuring the Eureka server for service registration
- Implementing the Eureka service discovery and client-side load balancing
- Applying resiliency to client applications
- Consuming endpoints using a declarative method
- Using Docker for deployment
- Batch and Message-Driven Processes
- Building synchronous batch processes
- Implementing batch processes with a database
- Constructing asynchronous batch processes
- Building synchronous interprocess communication using AMQP
- Creating asynchronous send-receive communication
- Creating an event-driven asynchronous communication using AMQP
- Creating stream communication with Spring Cloud Stream
- Implementing batch processes using Spring Cloud Task
- Other Spring 5 Features
- Using Hibernate 5 object-relational mapping
- Applying Hazelcast distributed caching
- Building client-server communications with WebSocket
- Implementing Reactive WebSocket communication
- Implementing asynchronous Spring Data JPA properties
- Implementing Reactive Spring Data JPA repositories
- Using Spring Data MongoDB
- Building applications for big data storage
- Building a Spring 5 application using Kotlin
- Testing Spring 5 Components
- Creating tests for Spring MVC components
- Building standalone controller tests
- Creating tests for DAO and service layers
- Creating tests on secured applications
- Creating tests using Spring Boot 2.0
- Creating tests for Spring Data JPA
- Building tests for blocking, asynchronous and reactive RESTful services
- Building tests for Kotlin components
Getting ready
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.