Mastering Spring Framework Fundamentals

Table of contents

1. Getting Started
   1. Section Introduction
   2. Key Spring Resources you Need to Know
   3. Configuring a project’s dependencies to use Spring
   4. Adding the Spring BOM to Better Manage Dependency Versions
2. Creating the Spring Container with Application Contexts
   1. Section Introduction
   2. A Look at the Application Context (aka The Spring Container)
   3. Creating the File System XML Application Context
   4. Configuring Autocomplete when Writing Spring XML Configuration Files
3. Creating, Retrieving and Using Spring-Managed Beans
   1. Section Introduction
   2. Creating a Bean Managed with Spring’s XML Container Configuration
   3. Retrieving and Using a Bean from the Spring Container
   4. Using the Classpath XML Application Context
   5. Understanding Singleton Scope
   6. Understanding Prototype Scope
   7. Understanding How Spring Creates Stateless Beans
4. Understanding Dependency Injection and Inversion of Control
   1. Section Introduction
   2. Coding Beans to Use Constructor Dependency Injection
   3. Interpreting a Spring Container Exception
   4. Applying Constructor Dependency Injection to XML Configuration
   5. Verifying the Constructor Dependency Injection with the Debugger
   6. The Shareability of Beans in an IoC Container
   7. The Benefits of Dependency Injection in an IoC Container
   8. The Hollywood Principle
   9. Coding Beans to Use Setter Dependency Injection
   10. Applying Setter Dependency Injection in XML Configuration
   11. Verifying the Setter Dependency Injection with the Debugger
5. Autowiring Dependencies in the Spring Container
   1. Section Introduction
   2. Adding Component Scanning to Autodetect Spring Managed Bean Annotations
   3. Coding Beans to be Automanaged and Autowired by Spring via Annotations
   4. The Advantage of Annotation-based Configuration over XML Configuration
   5. Verifying the Annotation-driven Autowired Beans
   6. Spring’s Stereotype Annotations for Better Code Readability
   7. Setter Dependency Injection with Annotations
   8. Constructor Dependency Injection with Annotations
   9. Using the Annotation-Based Application Context
   10. Creating a Java Configuration Class
   11. Applying Java-based configuration with @Bean
   12. Using Scopes with Java-based Configuration
   13. Modeling a More Complex Application to Demonstrate Autowiring Ambiguity Issues
   14. Resolving Ambiguous Arguments of the Same Type by Narrowing the Reference Type
   15. Resolving Ambiguous Arguments of the Same Type by Using @Qualifier
6. Using Properties and Profiles in Spring Projects
   1. Section Introduction
   2. Injecting Properties read from a File with @Value in Spring Managed Beans
   3. Exploring Property Overriding in Spring
   4. Accessing and using properties with Property Placeholder in XML Configuration
   5. Specifying default properties for property values
   6. Exceptions for Missing property keys in Spring
   7. Resolving and Using a Property Value in a Bean definition in XML Configuration
   8. Accessing the Current Active Profiles with the Environment interface
   9. Setting current active profile programmatically and through a property switch
   10. Creating Profile-specific bean configuration
   11. Conditional Beans with @Profile
7. Getting to Know the Spring Container
   1. The Proxy Design Pattern
   2. Seeing Proxies in Action
   3. The Disadvantages of a Regular Proxy
   4. Understanding JDK Dynamic Proxies
   5. Dynamic Proxies in Spring
   6. Understanding How Spring Makes Service Methods Transactional using Proxies
   7. Spring Managed Bean Lifecycle Callback Methods
   8. JDK Standard Lifecycle Annotations (@PostConstruct and @PreDestroy)
   9. The Sequence of Spring Container Callbacks on a Spring Managed Bean
   10. Application Container Callbacks and Events
   11. Using the Aware Interfaces to Access Lower-Level Spring Framework Components
8. Accessing Databases with Spring
   1. Creating and Configuring Data Sources
   2. Creating a Data Acces Object to Access a Database
   3. Connection Pool Data Sources in Spring
   4. Creating a JDBC Template to Access a Database
   5. Using JDBC Templates to Insert and Query Data
   6. Using JDBC DAO Support to Remove Boilerplate JDBC Code
9. Aspect-Oriented Programming with Spring
   1. Preparing a Spring Project to Use Aspects
   2. Creating a Spring Managed Bean to be Intercepted
   3. Advising Beans in Spring
   4. Understanding Pointcuts and Joinpoints
   5. Accessing Joinpoints Programmatically within an Aspect
   6. Coding Dynamic Advice with Around
10. Web Application Development in Spring
    1. Preparing a Maven Project to Use Spring MVC
    2. Registering the Dispatcher Servlet as Front Controller
    3. Creating the Web Application Context
    4. Creating a Controller Class
    5. Configuring the Jetty Plugin in Maven to Run a Web App
    6. Setting Up Remote Debugging of a Web App
    7. Understanding the Dispatcher Servlet Processing Flow
    8. Writing a Controller to Service Web Requests
    9. Rendering a JSP-Based View with View Resolvers
    10. Understanding How a Request is Serviced
    11. Passing a Model to the View for More Dynamic Pages
    12. Injecting the HTTP Servlet Request and Response into a Controller
    13. Passing Request Parameters and Query Strings to a Controller
    14. Using Path Variables to Access Parts of the Request Path