Building Microservices with Spring
Dinesh Rajput Rajesh R V更新时间：2021-07-02 14:55:09
最新章节：Leave a review - let other readers know what you thinkcoverpage
Title Page
Copyright
Building Microservices with Spring
About Packt
Why subscribe?
Packt.com
Contributors
About the authors
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
Getting Started with Spring Framework 5.0 and Design Patterns
Introducing Spring Framework
Simplifying application development using Spring and its pattern
Using the power of the POJO pattern
Injecting dependencies between POJOs
How DI works and makes things easy for development and testing
Using factory helper pattern for dependent components
Using DI pattern for dependent components
Applying aspects for cross cutting concerns
How Spring AOP works
Applying the template pattern to eliminate boilerplate code
The Template Design pattern in Spring
Using a Spring container to manage beans with the Factory pattern
Bean factory
Application contexts
Creating a container with an application context
Life of a bean in the container
Spring modules
Core Spring container
Spring's AOP module
Spring DAO - data access and integration
Spring's ORM
Spring web MVC
New features in Spring Framework 5.0
Summary
Overview of GOF Design Patterns - Core Design Patterns
Introducing the power of design patterns
Common GoF Design Pattern overview
Creational design patterns
Factory design pattern
Implementing the Factory design pattern in Spring Framework
Sample implementation of the Factory design pattern
Abstract factory design pattern
Common problems where you should apply the Abstract factory design pattern
Implementing the Abstract factory design pattern in the Spring Framework
Sample implementation of the Abstract Factory design pattern
Singleton design pattern
Common problems where you should apply Singleton pattern
Singleton design pattern implementation in the Spring Framework
Sample implementation of the Singleton design pattern
Prototype design pattern
Benefits of the Prototype design pattern
UML class structure
Sample implementation of the Prototype design pattern
Builder design pattern
Benefits of the Builder pattern:
UML class structure
Implementing the Builder pattern in the Spring Framework
Common problems where you should apply Builder pattern
Sample implementation of the Builder design pattern
Summary
Wiring Beans using the Dependency Injection Pattern
The dependency injection pattern
Solving problems using the dependencies injection pattern
Without dependency injection
With dependency injection pattern
Types of dependency injection patterns
Constructor-based dependency injection pattern
Setter-based dependency injection
Configuring the dependency injection pattern with Spring
Dependency injection pattern with Java-based configuration
Creating a Java configuration class - AppConfig.java
Declaring Spring beans into configuration class
Injecting Spring beans
Best approach to configure the dependency injection pattern with Java
Dependency injection pattern with XML-based configuration
Creating an XML configuration file
Declaring Spring beans in an XML file
Injecting Spring beans
Using constructor injection
Using setter injection
Dependency injection pattern with Annotation-based configuration
What are Stereotype annotations?
Creating auto searchable beans using Stereotype annotations
Searching beans using component scanning
Annotating beans for autowiring
Using @Autowired with setter method
Using @Autowired with the fields
The Autowiring DI pattern and disambiguation
Resolving disambiguation in Autowiring DI pattern
Implementing the Abstract Factory Pattern in Spring (FactoryBean interface)
Implementation of FactoryBean interface in Spring
Sample implementation of FactoryBean interface
Best practices for configuring the DI pattern
Summary
Spring Aspect Oriented Programming with Proxy and Decorator pattern
Proxy pattern in Spring
Proxying classes using Decorator pattern in Spring
What are cross-cutting concerns?
What is Aspect-Oriented Programming?
Problems resolved by AOP
Code tangling
Code scattering
How AOP Works to solve problems
Core AOP terminology and concepts
Advice
Join Point
Pointcut
Aspect
Weaving
Defining pointcuts
Writing pointcuts
Creating aspects
Define aspects using Annotation
Implementing Advice
Advice type - Before
Before Advice example
Advice Types: After Returning
After Returning Advice example
Advice Types: After Throwing
After Throwing Advice example
Advice Types: After
After Advice example
Advice Types - Around
Around Advice example
Define aspects using XML configuration
Understanding AOP proxies
Summary
Accessing a Database with Spring and JDBC Template Patterns
The best approach to designing your data-access
The resource management problem
Implementing the template design pattern
Problems with the traditional JDBC
Solving problems with Spring's JdbcTemplate
Configuring the data source and object pool pattern
Configuring a data source using a JDBC driver
Configuring the data source using pool connections
Implementing the Builder pattern to create an embedded data source
Abstracting database access using the DAO pattern
The DAO pattern with the Spring Framework
Working with JdbcTemplate
When to use JdbcTemplate
Creating a JdbcTemplate in an application
Implementing a JDBC-based repository
Jdbc callback interfaces
Creating a RowMapper class
Implementing RowCallbackHandler
Implementing ResultSetExtractor
Best practices for Jdbc and configuring JdbcTemplate
Summary
Improving Application Performance Using Caching Patterns
What is cache?
Where do we use caching?
Understanding cache abstraction
Enabling caching via the Proxy pattern
Enabling the caching proxy using Annotation
Enabling the Caching Proxy using the XML namespace
Declarative Annotation-based caching
The @Cacheable annotation
The @CachePut annotation
Customizing the cache key
Conditional caching
The @CacheEvict annotation
The @Caching annotation
The @CacheConfig annotation
Declarative XML-based caching
Configuring the cache storage
Setting up the CacheManager
Third-party cache implementations
Ehcache-based cache
XML-based configuration
Creating custom caching annotations
Top caching best practices to be used in a web application
Summary
Implementing Reactive Design Patterns
Understanding application requirement over the years
Understanding the reactive pattern
The reactive pattern traits
Responsiveness
Resilience
Scalable
Message-driven architecture
Blocking calls
Non-blocking calls
Back-pressure
Implementing reactive with the Spring 5 Framework
Reactive Streams
Spring Web reactive module
Implementing a reactive web application at the server side
The Annotation-based programming model
The functional programming model
Implementing a Reactive Client-Side application
Request and response body conversion
Summary
Implementing Concurrency Patterns
Active object pattern
Monitor object pattern
Half-Sync/Half-Async patterns
Leader/follower pattern
Reactor pattern
Thread-specific storage pattern
Best practices for concurrency module
Summary
Demystifying Microservices
Evolution of microservices
Business demand as a catalyst for microservices evolution
Technology as a catalyst for microservices evolution
Imperative architecture evolution
What are Microservices?
Microservices - The honeycomb analogy
Principles of microservices
Single responsibility per service
Microservices are autonomous
Characteristics of microservices
Services are first class citizens
Characteristics of service in a microservice
Microservices are lightweight
Microservices with polyglot architecture
Automation in microservices environment
Microservices with a supporting ecosystem
Microservices are distributed and dynamic
Antifragility fail fast and self healing
Microservices examples
An example of a holiday portal
An example of a travel agent portal
Microservices benefits
Supports polyglot architecture
Enables experimentation and innovation
Elastically and selectively scalable
Allows substitution
Enables to build organic systems
Helps managing technology debt
Allowing co-existence of different versions
Supporting building self-organizing systems
Supporting event-driven architecture
Enables DevOps
Summary
Related Architecture Styles and Use Cases
Service-Oriented Architecture (SOA)
Service-oriented integration
Legacy modernization
Service-oriented application
Monolithic migration using SOA
Twelve-Factor Apps
Single code base
Bundle dependencies
Externalizing configurations
Backing services are addressable
Isolation between build release and run
Stateless shared nothing processes
Expose services through port bindings
Concurrency for scale out
Disposability with minimal overhead
Development production parity
Externalizing logs
Package admin processes
Serverless computing
Lambda architecture
DevOps Cloud and Containers
DevOps as the practice and process for microservices
Cloud and Containers as the self-service infrastructure for microservices
Reactive microservices
A reactive microservice-based order management system
Microservice use cases
Microservices early adopters - Is there a common theme?
Monolithic migration as the common use case
Microservice frameworks
Summary
Building Microservices with Spring Boot
Setting up a development environment
Spring Boot for building RESTful microservices
Getting started with Spring Boot
Developing a Spring Boot microservice
Developing our first Spring Boot microservice
Testing Spring Boot microservice
HATEOAS-enabled Spring Boot microservice
Reactive Spring Boot microservices
Reactive microservices using Spring WebFlux
Understanding Reactive Streams
Publisher
Subscriber
Subscription
Processor
Reactive microservices using Spring Boot and RabbitMQ
Implementing security
Securing a microservice with basic security
Securing microservice with OAuth2
Enabling cross origin for microservices interactions
Spring Boot actuators for microservices instrumentation
Monitoring using JConsole
Monitoring using ssh
Adding a custom health module
Building custom metrics
Documenting microservices
Putting it all together - Developing a customer registration microservice example
Summary
Scale Microservices with Spring Cloud Components
What is Spring Cloud?
Spring Cloud releases
Setting up the environment for the BrownField PSS
Spring Cloud Config
Building microservices with Config Server
Setting up the Config Server
Understanding the Config Server URL
Accessing the Config Server from clients
Handling configuration changes
Spring Cloud Bus for propagating configuration changes
Setting up high availability for the Config Server
Monitoring Config Server health
Config Server for configuration files
Completing changes to use Config Server
Eureka for registration and discovery
Understanding dynamic service registration and discovery
Understanding Eureka
Setting up the Eureka Server
High availability for Eureka
Zuul proxy as the API Gateway
Setting up Zuul
High availability of Zuul
High availability of Zuul when the client is also a Eureka Client
High availability when client is not a Eureka Client
Completing Zuul for all other services
Streams for reactive microservices
Protecting microservices with Spring Cloud Security
Summarising the BrownField PSS architecture
Summary
Logging and Monitoring Microservices
Understanding log management challenges
Centralized logging solution
Selection of logging solutions
Cloud services
Off-the-shelf solutions
Best of the breed integration
Log shippers
Log stream processors
Log storage
Dashboards
Custom logging implementation
Distributed tracing with Spring Cloud Sleuth
Monitoring microservices
Monitoring challenges
Monitoring tools
Monitoring microservice dependency
Spring Cloud Hystrix for fault-tolerant microservices
Aggregate Hystrix streams with Turbine
Data analysis using Data Lake
Summary
Containerizing Microservices with Docker
Understanding gaps in the BrownField PSS microservices
What are containers?
Difference between VM and containers
Benefits of containers
Microservices and containers
Introduction to Docker
Key components of Docker
The Docker daemon
The Docker client
The Docker image
The Docker container
The Docker registry
Dockerfile
Deploying microservices into Docker
Running RabbitMQ on Docker
Using the Docker registry
Setting up the Docker Hub
Publish microservices to the Docker Hub
Microservices on Cloud
Installing Docker on AWS EC2
Running BrownField services on EC2
Future of containerization
Summary
Scaling Dockerized Microservices with Mesos and Marathon
Scaling microservices
Understanding autoscaling
The missing pieces
Container orchestration
Why is container orchestration is important
What does container orchestration do?
Relationship with microservices
Relationship with virtualization
Container orchestration solutions
Docker Swarm
Kubernetes
Apache Mesos
HashiCorp Nomad
CoreOS Fleet
Container orchestration with Mesos and Marathon
Mesos in details
Mesos architecture
Marathon
Implementing Mesos and Marathon with DCOS
Implementing Mesos and Marathon for BrownField microservices
Installing Mesos Marathon and related components
Running Mesos and Marathon
Preparing BrownField PSS services
Deploying BrownField PSS services
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think
更新时间：2021-07-02 14:55:09