目錄(333章)
倒序
- 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
推薦閱讀
- 區塊鏈架構與實現：Cosmos詳解
- Java程序設計與計算思維
- Swift 3 New Features
- C語言程序設計案例式教程
- 微信小程序開發解析
- 重學Java設計模式
- C＃程序設計
- Windows Server 2016 Automation with PowerShell Cookbook（Second Edition）
- Mastering Android Development with Kotlin
- Asynchronous Android Programming（Second Edition）
- Learning Continuous Integration with TeamCity
- Mastering HTML5 Forms
- Mastering PowerCLI
- Mastering Leap Motion
- Android從入門到精通
- 鋁合金陽極氧化與表面處理技術（第三版）
- R Data Visualization Cookbook
- Learning Behavior：driven Development with JavaScript
- 精通Spring MVC 4
- CentOS High Performance
- D3.js：Cutting-edge Data Visualization
- 數據庫管理與開發項目教程：MySQL（微課版·第4版）
- Python科學與工程數據分析實戰
- Force.com Enterprise Architecture
- INSTANT Spring Tool Suite
- INSTANT RSpec Test-Driven Development How-to
- Mastering Selenium WebDriver 3.0
- Practical Game AI Programming
- Java修煉指南：高頻源碼解析
- Python Data Visualization Cookbook
