
Building Microservices with Spring
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions

Content
- Cover
- Title Page
- Copyright
- About Packt
- Contributors
- Table of Contents
- Preface
- Chapter 1: 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 Chapter 2: 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
- Chapter 3: 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
- Chapter 4: 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
- Chapter 5: 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
- Chapter 6: 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
- Chapter 7: 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
- Chapter 8: 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
- Chapter 9: 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
- Chapter 10: 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
- Chapter 11: 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
- Chapter 12: 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
- Chapter 13: 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
- Chapter 14: 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
- Chapter 15: 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
- Index
System requirements
File format: ePUB
Copy protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (not Kindle).
The file format ePub works well for novels and non-fiction books – i.e., „flowing” text without complex layout. On an e-reader or smartphone, line and page breaks automatically adjust to fit the small displays.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our ebook Help page.