最新章節

• Summary
• Best practices for concurrency module
• Thread-specific storage pattern
• Reactor pattern
• Leader/follower pattern
• Half-Sync/Half-Async patterns

• Summary 更新時間：2021-07-08 10:00:27
• Best practices for concurrency module
• Thread-specific storage pattern
• Reactor pattern
• Leader/follower pattern
• Half-Sync/Half-Async patterns
• Monitor object pattern
• Active object pattern
• Implementing Concurrency Patterns
• Summary
• Request and response body conversion
• Implementing a Reactive Client-Side application
• The functional programming model
• The Annotation-based programming model
• Implementing a reactive web application at the server side
• Spring Web reactive module
• Reactive Streams
• Implementing reactive with the Spring 5 Framework
• Back-pressure
• Non-blocking calls
• Blocking calls
• Message-driven architecture
• Scalable
• Resilience
• Responsiveness
• The reactive pattern traits
• Understanding the reactive pattern
• Understanding application requirement over the years
• Implementing Reactive Design Patterns
• Summary
• Best practices for web application design
• Configuring a Tiles ViewResolver
• Composite View pattern using Apache tile view resolver
• The View Helper pattern
• Register ViewResolver with Spring MVC
• Implement the View
• Defining ViewResolver in the Spring MVC
• Implementing View in the MVC pattern
• Validating forms input parameters
• Using @ModelAttributes for customizing data binding
• Data binding with Command Design pattern
• Implementing a form handling controller
• Processing forms of a web page
• Taking request parameters via path variables
• Taking query parameters
• Accepting request parameters
• Passing model data to the view
• Defining @RequestMapping handler methods
• @RequestMapping at the class level
• @RequestMapping at method level
• Mapping requests with @RequestMapping
• Defining a controller with @Controller
• Implementing controllers
• Enabling the Spring MVC
• Defined by Java configuration
• Defined by XML configuration
• Configuring DispatcherServlet as the Front Controller
• Processing the life of a request
• The Front Controller design pattern
• Model 2 architecture MVC pattern with Spring
• Implementing the MVC pattern in a web application
• Implementing the MVC Pattern in a Web Application using Spring
• Summary
• Top caching best practices to be used in a web application
• Creating custom caching annotations
• XML-based configuration
• Ehcache-based cache
• Third-party cache implementations
• Setting up the CacheManager
• Configuring the cache storage
• Declarative XML-based caching
• The @CacheConfig annotation
• The @Caching annotation
• The @CacheEvict annotation
• Conditional caching
• Customizing the cache key
• The @CachePut annotation
• The @Cacheable annotation
• Declarative Annotation-based caching
• Enabling the Caching Proxy using the XML namespace
• Enabling the caching proxy using Annotation
• Enabling caching via the Proxy pattern
• Understanding cache abstraction
• Where do we use caching?
• What is cache?
• Improving Application Performance Using Caching Patterns
• Summary
• Best practices for Spring ORM and transaction module in an application
• Programmatic transaction demarcation and implementation
• Step 2 - Declaring the transaction demarcation
• Step 1 - Implementing the transaction manager
• Deploying the transaction manager
• Declarative transaction demarcation and implementation
• Transaction management strategies in Spring
• Implementing DAOs based on the plain Hibernate API
• Configuring Hibernate's SessionFactory in a Spring container
• Integrating Hibernate with Spring
• Spring's Hibernate template pattern
• Proxy for the lazy loading pattern
• The domain model pattern
• The Data Mapper pattern
• Creating DAOs using the Factory design pattern in Spring
• The data access object pattern
• Consistent exception handling and translation
• Resource and transaction management
• ORM Framework and the patterns used
• Accessing Database with Spring ORM and Transactions Implementing Patterns
• Summary
• Best practices for Jdbc and configuring JdbcTemplate
• Implementing ResultSetExtractor
• Implementing RowCallbackHandler
• Creating a RowMapper class
• Jdbc callback interfaces
• Implementing a JDBC-based repository
• Creating a JdbcTemplate in an application
• When to use JdbcTemplate
• Working with JdbcTemplate
• The DAO pattern with the Spring Framework
• Abstracting database access using the DAO pattern
• Implementing the Builder pattern to create an embedded data source
• Configuring the data source using pool connections
• Configuring a data source using a JDBC driver
• Configuring the data source and object pool pattern
• Solving problems with Spring's JdbcTemplate
• Problems with the traditional JDBC
• Implementing the template design pattern
• The resource management problem
• The best approach to designing your data-access
• Accessing a Database with Spring and JDBC Template Patterns
• Summary
• Understanding AOP proxies
• Define aspects using XML configuration
• Around Advice example
• Advice Types - Around
• After Advice example
• Advice Types: After
• After Throwing Advice example
• Advice Types: After Throwing
• After Returning Advice example
• Advice Types: After Returning
• Before Advice example
• Advice type - Before
• Implementing Advice
• Define aspects using Annotation
• Creating aspects
• Writing pointcuts
• Defining pointcuts
• Weaving
• Aspect
• Pointcut
• Join Point
• Advice
• Core AOP terminology and concepts
• How AOP Works to solve problems
• Code scattering
• Code tangling
• Problems resolved by AOP
• What is Aspect-Oriented Programming?
• What are cross-cutting concerns?
• Proxying classes using Decorator pattern in Spring
• Proxy pattern in Spring
• Spring Aspect Oriented Programming with Proxy and Decorator pattern
• Summary
• Creating custom scopes
• Custom scopes
• Other scopes in Spring
• The request bean scope
• The session bean scope
• The prototype bean scope
• The singleton bean scope
• Understanding bean scopes
• The destruction phase of the beans
• Implementing the Decorator and Proxy patterns in Spring using Proxies
• The Use phase of beans
• The Initializer extension point
• Customizing beans using a BeanPostProcessor
• Initializing bean instances
• Load bean definitions
• Creating the application context from configuration
• The initialization phase
• The Spring bean life cycle and its phases
• Understanding the Bean Life Cycle and Used Patterns
• Summary
• Best practices for configuring the DI pattern
• Sample implementation of FactoryBean interface
• Implementation of FactoryBean interface in Spring
• Implementing the Abstract Factory Pattern in Spring (FactoryBean interface)
• Resolving disambiguation in Autowiring DI pattern
• The Autowiring DI pattern and disambiguation
• Using @Autowired with the fields
• Using @Autowired with setter method
• Annotating beans for autowiring
• Searching beans using component scanning
• Creating auto searchable beans using Stereotype annotations
• What are Stereotype annotations?
• Dependency injection pattern with Annotation-based configuration
• Using setter injection
• Using constructor injection
• Injecting Spring beans
• Declaring Spring beans in an XML file
• Creating an XML configuration file
• Dependency injection pattern with XML-based configuration
• Best approach to configure the dependency injection pattern with Java
• Injecting Spring beans
• Declaring Spring beans into configuration class
• Creating a Java configuration class - AppConfig.java
• Dependency injection pattern with Java-based configuration
• Configuring the dependency injection pattern with Spring
• Setter-based dependency injection
• Constructor-based dependency injection pattern
• Types of dependency injection patterns
• With dependency injection pattern
• Without dependency injection
• Solving problems using the dependencies injection pattern
• The dependency injection pattern
• Wiring Beans using the Dependency Injection Pattern
• Summary
• JEE design patterns
• Template Design Pattern
• Observer pattern in the Spring Framework
• Iterator design pattern in the Spring Framework
• Iterator Design Pattern
• Interpreter design pattern in the Spring Framework
• Interpreter Design pattern
• Command design pattern in the Spring Framework
• Command design pattern
• Chain of Responsibility pattern in the Spring Framework
• Chain of Responsibility design pattern
• Behavioral design patterns
• Proxy pattern in the Spring Framework
• Implementing the Proxy design pattern
• UML structure for the Proxy design pattern
• Purpose of the Proxy pattern
• Proxy design pattern
• Facade Pattern in the Spring Framework
• The UML structure for the Facade design pattern
• Implementing the Facade design pattern
• Knowing when to use the Facade Pattern
• Facade Design Pattern
• Decorator design pattern in the Spring Framework
• Implementing the Decorator pattern
• Common problems solved by the Decorator pattern
• Decorator design pattern
• Sample implementation of the Composite design pattern
• UML structure of the Composite design pattern
• Common problems solved by the composite pattern
• Composite design pattern
• Sample implementation of the Bridge design pattern
• Implementing the Bridge design pattern in the Spring Framework
• Common problems solved by the Bridge design pattern
• Benefits of the Bridge pattern
• The Bridge design pattern
• Sample implementation of the adapter design pattern
• Implementation of the adapter design pattern in the Spring Framework
• Common requirements for the adapter pattern
• Benefits of the adapter pattern
• The adapter design pattern
• Structural design patterns
• Examining the core design patterns
• Consideration of Structural and Behavioral Patterns
• Summary
• Sample implementation of the Builder design pattern
• Common problems where you should apply Builder pattern
• Implementing the Builder pattern in the Spring Framework
• UML class structure
• Benefits of the Builder pattern:
• Builder design pattern
• Sample implementation of the Prototype design pattern
• UML class structure
• Benefits of the Prototype design pattern
• Prototype design pattern
• Sample implementation of the Singleton design pattern
• Singleton design pattern implementation in the Spring Framework
• Common problems where you should apply Singleton pattern
• Singleton design pattern
• Sample implementation of the Abstract Factory design pattern
• Implementing the Abstract factory design pattern in the Spring Framework
• Common problems where you should apply the Abstract factory design pattern
• Abstract factory design pattern
• Sample implementation of the Factory design pattern
• Implementing the Factory design pattern in Spring Framework
• Factory design pattern
• Creational design patterns
• Common GoF Design Pattern overview
• Introducing the power of design patterns
• Overview of GOF Design Patterns - Core Design Patterns
• Summary
• New features in Spring Framework 5.0
• Spring web MVC
• Spring's ORM
• Spring DAO - data access and integration
• Spring's AOP module
• Core Spring container
• Spring modules
• Life of a bean in the container
• Creating a container with an application context
• Application contexts
• Bean factory
• Using a Spring container to manage beans with the Factory pattern
• The Template Design pattern in Spring
• Applying the template pattern to eliminate boilerplate code
• How Spring AOP works
• Applying aspects for cross cutting concerns
• Using DI pattern for dependent components
• Using factory helper pattern for dependent components
• How DI works and makes things easy for development and testing
• Injecting dependencies between POJOs
• Using the power of the POJO pattern
• Simplifying application development using Spring and its pattern
• Introducing Spring Framework
• Getting Started with Spring Framework 5.0 and Design Patterns
• Questions
• Piracy
• Errata
• Downloading the example code
• Customer support
• Reader feedback
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Dedication
• Customer Feedback
• Why subscribe?
• www.PacktPub.com
• About the Reviewer
• About the Author
• Credits
• Spring 5 Design Patterns
• Copyright
• Title Page
• coverpage

• coverpage
• Title Page
• Copyright
• Spring 5 Design Patterns
• Credits
• About the Author
• About the Reviewer
• www.PacktPub.com
• Why subscribe?
• Customer Feedback
• Dedication
• Preface
• What this book covers
• What you need for this book
• Who this book is for
• Conventions
• Reader feedback
• Customer support
• Downloading the example code
• Errata
• Piracy
• Questions
• 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
• Consideration of Structural and Behavioral Patterns
• Examining the core design patterns
• Structural design patterns
• The adapter design pattern
• Benefits of the adapter pattern
• Common requirements for the adapter pattern
• Implementation of the adapter design pattern in the Spring Framework
• Sample implementation of the adapter design pattern
• The Bridge design pattern
• Benefits of the Bridge pattern
• Common problems solved by the Bridge design pattern
• Implementing the Bridge design pattern in the Spring Framework
• Sample implementation of the Bridge design pattern
• Composite design pattern
• Common problems solved by the composite pattern
• UML structure of the Composite design pattern
• Sample implementation of the Composite design pattern
• Decorator design pattern
• Common problems solved by the Decorator pattern
• Implementing the Decorator pattern
• Decorator design pattern in the Spring Framework
• Facade Design Pattern
• Knowing when to use the Facade Pattern
• Implementing the Facade design pattern
• The UML structure for the Facade design pattern
• Facade Pattern in the Spring Framework
• Proxy design pattern
• Purpose of the Proxy pattern
• UML structure for the Proxy design pattern
• Implementing the Proxy design pattern
• Proxy pattern in the Spring Framework
• Behavioral design patterns
• Chain of Responsibility design pattern
• Chain of Responsibility pattern in the Spring Framework
• Command design pattern
• Command design pattern in the Spring Framework
• Interpreter Design pattern
• Interpreter design pattern in the Spring Framework
• Iterator Design Pattern
• Iterator design pattern in the Spring Framework
• Observer pattern in the Spring Framework
• Template Design Pattern
• JEE design patterns
• 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
• Understanding the Bean Life Cycle and Used Patterns
• The Spring bean life cycle and its phases
• The initialization phase
• Creating the application context from configuration
• Load bean definitions
• Initializing bean instances
• Customizing beans using a BeanPostProcessor
• The Initializer extension point
• The Use phase of beans
• Implementing the Decorator and Proxy patterns in Spring using Proxies
• The destruction phase of the beans
• Understanding bean scopes
• The singleton bean scope
• The prototype bean scope
• The session bean scope
• The request bean scope
• Other scopes in Spring
• Custom scopes
• Creating custom scopes
• 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
• Accessing Database with Spring ORM and Transactions Implementing Patterns
• ORM Framework and the patterns used
• Resource and transaction management
• Consistent exception handling and translation
• The data access object pattern
• Creating DAOs using the Factory design pattern in Spring
• The Data Mapper pattern
• The domain model pattern
• Proxy for the lazy loading pattern
• Spring's Hibernate template pattern
• Integrating Hibernate with Spring
• Configuring Hibernate's SessionFactory in a Spring container
• Implementing DAOs based on the plain Hibernate API
• Transaction management strategies in Spring
• Declarative transaction demarcation and implementation
• Deploying the transaction manager
• Step 1 - Implementing the transaction manager
• Step 2 - Declaring the transaction demarcation
• Programmatic transaction demarcation and implementation
• Best practices for Spring ORM and transaction module in an application
• 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 the MVC Pattern in a Web Application using Spring
• Implementing the MVC pattern in a web application
• Model 2 architecture MVC pattern with Spring
• The Front Controller design pattern
• Processing the life of a request
• Configuring DispatcherServlet as the Front Controller
• Defined by XML configuration
• Defined by Java configuration
• Enabling the Spring MVC
• Implementing controllers
• Defining a controller with @Controller
• Mapping requests with @RequestMapping
• @RequestMapping at method level
• @RequestMapping at the class level
• Defining @RequestMapping handler methods
• Passing model data to the view
• Accepting request parameters
• Taking query parameters
• Taking request parameters via path variables
• Processing forms of a web page
• Implementing a form handling controller
• Data binding with Command Design pattern
• Using @ModelAttributes for customizing data binding
• Validating forms input parameters
• Implementing View in the MVC pattern
• Defining ViewResolver in the Spring MVC
• Implement the View
• Register ViewResolver with Spring MVC
• The View Helper pattern
• Composite View pattern using Apache tile view resolver
• Configuring a Tiles ViewResolver
• Best practices for web application design
• 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 更新時間：2021-07-08 10:00:27