Spring Recipes - A Problem-Solution Approach

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Author

About the Technical Reviewers

Acknowledgments

Introduction

Who This Book Is For

How This Book Is Structured

Conventions

Prerequisites

Downloading the Code

Contacting the Author

PART 1 Core

CHAPTER 1 Inversion of Control and Containers

1-1.Using a Container toManageYour Components

Problem

Solution

How It Works

Separating Interface from Implementation

Employing a Container

1-2.Using a Service Locator to Reduce Lookup Complexity

Problem

Solution

How It Works

1-3. Applying Inversion of Control and Dependency Injection

Problem

Solution

How It Works

1-4.Understanding Different Types of Dependency Injection

Problem

Solution

How It Works

Setter Injection (Type 2 IoC)

Constructor Injection (Type 3 IoC)

Interface Injection (Type 1 IoC)

1-5. Configuring a Container with a Configuration File

Problem

Solution

How It Works

1-6. Summary

CHAPTER 2 Introduction to Spring

2-1. Introducing the Spring Framework

Introducing Spring’s Modules

Introducing Spring’s Releases

Introducing Spring’s Projects

2-2. Installing the Spring Framework

Problem

Solution

How It Works

Installing JDK

Installing a Java IDE

Downloading and Installing Spring

Exploring Spring’s Installation Directory

2-3. Setting Up a Spring Project

Problem

Solution

How It Works

Setting Up the Classpath

Creating the Bean Configuration File

Using Beans from the Spring IoC Container

2-4. Installing Spring IDE

Problem

Solution

How It Works

2-5.Using Spring IDE’s Bean-Supporting Features

Problem

Solution

How It Works

Creating a Spring Project

Creating a Spring Bean Configuration File

Viewing Spring Beans in Spring Explorer

Viewing Spring Beans in Spring Beans Graph

Using Content Assist in Bean Configuration Files

Validating Bean Configuration Files

Searching Spring Beans

2-6. Summary

CHAPTER 3 Bean Configuration in Spring

3-1. Configuring Beans in the Spring IoC Container

Problem

Solution

How It Works

Creating the Bean Class

Creating the Bean Configuration File

Declaring Beans in the Bean Configuration File

Defining Bean Properties by Shortcut

3-2. Instantiating the Spring IoC Container

Problem

Solution

How It Works

Instantiating a Bean Factory

Instantiating an Application Context

Getting Beans from the IoC Container

3-3. Resolving Constructor Ambiguity

Problem

Solution

How It Works

3-4. Specifying Bean References

Problem

Solution

How It Works

Specifying Bean References for Setter Methods

Declaring Inner Beans

3-5. Checking Properties with Dependency Checking

Problem

Solution

How It Works

Checking Properties of the Simple Types

Checking Properties of the Object Types

Checking Properties of All Types

Dependency Checking and Constructor Injection

3-6. Checking Properties with the @Required Annotation

Problem

Solution

How It Works

3-7. Auto-Wiring Beans with XML Configuration

Problem

Solution

How It Works

Auto-Wiring by Type

Auto-Wiring by Name

Auto-Wiring by Constructor

Auto-Wiring by Auto-Detection

Auto-Wiring and Dependency Checking

3-8. Auto-Wiring Beans with @Autowired and @Resource

Problem

Solution

How It Works

Auto-Wiring a Single Bean of Compatible Type

Auto-Wiring All Beans of Compatible Type

Auto-Wiring by Type with Qualifiers

Auto-Wiring by Name

3-9. Inheriting Bean Configuration

Problem

Solution

How It Works

3-10.Defining Collections for Bean Properties

Problem

Solution

How It Works

Lists, Arrays, and Sets

Maps and Properties

Merging the Collection of the Parent Bean

3-11. Specifying the Data Type for Collection Elements

Problem

Solution

How It Works

3-12.Defining Collections Using Factory Beans and the Utility Schema

Problem

Solution

How It Works

Specifying the Concrete Class for Collections

Defining Stand-Alone Collections

3-13. Scanning Components from the Classpath

Problem

Solution

How It Works

Scanning Components Automatically

Filtering Components to Scan

Naming Detected Components

3-14. Summary

CHAPTER 4 Advanced Spring IoC Container

4-1. Creating Beans by Invoking a Constructor

Problem

Solution

How It Works

4-2. Creating Beans by Invoking a Static Factory Method

Problem

Solution

How It Works

4-3. Creating Beans by Invoking an Instance Factory Method

Problem

Solution

How It Works

4-4. Creating Beans Using Spring’s Factory Bean

Problem

Solution

How It Works

4-5.Declaring Beans from Static Fields

Problem

Solution

How It Works

4-6.Declaring Beans from Object Properties

Problem

Solution

How It Works

4-7. Setting Bean Scopes

Problem

Solution

How It Works

4-8. Customizing Bean Initialization and Destruction

Problem

Solution

How It Works

Implementing the InitializingBean and DisposableBean Interfaces

Annotating the @PostConstruct and @PreDestroy Annotations

4-9.Making Beans Aware of the Container

Problem

Solution

How It Works

4-10. Creating Bean Post Processors

Problem

Solution

How It Works

4-11. Externalizing Bean Configurations

Problem

Solution

How It Works

4-12. Resolving Text Messages

Problem

Solution

How It Works

4-13. Communicating with Application Events

Problem

Solution

How It Works

Defining Events

Publishing Events

Listening to Events

4-14. Registering Property Editors in Spring

Problem

Solution

How It Works

4-15. Creating Custom Property Editors

Problem

Solution

How It Works

4-16. Loading External Resources

Problem

Solution

How It Works

Resource Prefixes

Injecting Resources

4-17. Summary

CHAPTER 5 Dynamic Proxy and Classic Spring AOP

5-1. Problems with Non-Modularized Crosscutting Concerns

Tracing the Methods

Validating the Arguments

Identifying the Problems

5-2.Modularizing Crosscutting Concerns with Dynamic Proxy

Problem

Solution

How It Works

Creating the Logging Proxy

Creating the Validation Proxy

5-3.Modularizing Crosscutting Concerns with Classic Spring Advices

Problem

Solution

How It Works

Before Advices

After Returning Advices

After Throwing Advices

Around Advices

5-4.Matching Methods with Classic Spring Pointcuts

Problem

Solution

How It Works

Method Name Pointcuts

Regular Expression Pointcuts

AspectJ Expression Pointcuts

5-5. Creating Proxies for Your Beans Automatically

Problem

Solution

How It Works

5-6. Summary

CHAPTER 6 Spring 2.x AOP and AspectJ Support

6-1. Enabling AspectJ Annotation Support in Spring

Problem

Solution

How It Works

6-2.Declaring Aspects with AspectJ Annotations

Problem

Solution

How It Works

Before Advices

After Advices

After Returning Advices

After Throwing Advices

Around Advices

6-3. Accessing the Join Point Information

Problem

Solution

How It Works

6-4. Specifying Aspect Precedence

Problem

Solution

How It Works

6-5. Reusing Pointcut Definitions

Problem

Solution

How It Works

6-6.Writing AspectJ Pointcut Expressions

Problem

Solution

How It Works

Method Signature Patterns

Type Signature Patterns

Bean Name Patterns

Combining Pointcut Expressions

Declaring Pointcut Parameters

6-7. Introducing Behaviors to Your Beans

Problem

Solution

How It Works

6-8. Introducing States to Your Beans

Problem

Solution

How It Works

6-9.Declaring Aspects with XML-Based Configurations

Problem

Solution

How It Works

Declaring Aspects

Declaring Pointcuts

Declaring Advices

Declaring Introductions

6-10. Load-Time Weaving AspectJ Aspects in Spring

Problem

Solution

How It Works

Load-Time Weaving by the AspectJ Weaver

Load-Time Weaving by Spring 2.5 Load-Time Weaver

6-11. Configuring AspectJ Aspects in Spring

Problem

Solution

How It Works

6-12. Injecting Spring Beans into Domain Objects

Problem

Solution

How It Works

6-13. Summary

PART 2 Fundamentals

CHAPTER 7 Spring JDBC Support

7-1. Problems with Direct JDBC

Setting Up the Application Database

Understanding the Data Access Object Design Pattern

Implementing the DAO with JDBC

Configuring a Data Source in Spring

Running the DAO

7-2.Using a JDBC Template to Update a Database

Problem

Solution

How It Works

Updating a Database with a Statement Creator

Updating a Database with a Statement Setter

Updating a Database with a SQL Statement and Parameter Values

Batch Updating a Database

7-3.Using a JDBC Template to Query a Database

Problem

Solution

How It Works

Extracting Data with a Row Callback Handler

Extracting Data with a Row Mapper

Querying for Multiple Rows

Querying for a Single Value

7-4. Simplifying JDBC Template Creation

Problem

Solution

How It Works

Injecting a JDBC Template

Extending the JdbcDaoSupport Class

7-5.Using the Simple JDBC Template with Java 1.5

Problem

Solution

How It Works

Using a Simple JDBC Template to Update a Database

Using a Simple JDBC Template to Query a Database

7-6.Using Named Parameters in a JDBC Template

Problem

Solution

How It Works

7-7.Modeling JDBC Operations As Fine-Grained Objects

Problem

Solution

How It Works

Update Operation Objects

Query Operation Objects

Function Operation Objects

7-8.Handling Exceptions in the Spring JDBC Framework

Problem

Solution

How It Works

Understanding Exception Handling in the Spring JDBC Framework

Customizing Data Access Exception Handling

7-9. Summary

CHAPTER 8 Transaction Management in Spring

8-1. Problems with TransactionManagement

Managing Transactions with JDBC Commit and Rollback

8-2. Choosing a TransactionManager Implementation

Problem

Solution

How It Works

8-3.Managing Transactions Programmatically with the Transaction Manager API

Problem

Solution

How It Works

8-4.Managing Transactions Programmatically with a Transaction Template

Problem

Solution

How It Works

8-5.Managing Transactions Declaratively with Classic Spring AOP

Problem

Solution

How It Works

8-6.Managing Transactions Declaratively with Transaction Advices

Problem

Solution

How It Works

8-7.Managing Transactions Declaratively with the @Transactional Annotation

Problem

Solution

How It Works

8-8. Setting the Propagation Transaction Attribute

Problem

Solution

How It Works

The REQUIRED Propagation Behavior

The REQUIRES_NEWPropagation Behavior

Setting the Propagation Attribute in Transaction Advices, Proxies, and APIs

8-9. Setting the Isolation Transaction Attribute

Problem

Solution

How It Works

The READ_UNCOMMITTED and READ_COMMITTED Isolation Levels

The REPEATABLE_READ Isolation Level

The SERIALIZABLE Isolation Level

Setting the Isolation Level Attribute in Transaction Advices, Proxies, and APIs

8-10. Setting the Rollback Transaction Attribute

Problem

Solution

How It Works

8-11. Setting the Timeout and Read-Only Transaction Attributes

Problem

Solution

How It Works

8-12.Managing Transactions with Load-TimeWeaving

Problem

Solution

How It Works

8-13. Summary

CHAPTER 9 Spring ORM Support

9-1. Problems with Using ORM Frameworks Directly

Persisting Objects Using the Hibernate API with Hibernate XML Mappings

Persisting Objects Using the Hibernate API with JPA Annotations

Persisting Objects Using JPA with Hibernate As the Engine

9-2. Configuring ORM Resource Factories in Spring

Problem

Solution

How It Works

Configuring a Hibernate Session Factory in Spring

Configuring a JPA EntityManager Factory in Spring

9-3. Persisting Objects with Spring’s ORMTemplates

Problem

Solution

How It Works

Using a Hibernate Template and a JPA Template

Extending the Hibernate and JPA DAO Support Classes

9-4. Persisting Objects with Hibernate’s Contextual Sessions

Problem

Solution

How It Works

9-5. Persisting Objects with JPA’s Context Injection

Problem

Solution

How It Works

9-6. Summary

CHAPTER 10 Spring MVC Framework

10-1.Developing a Simple Web Application with Spring MVC

Problem

Solution

How It Works

Setting Up a Spring MVC Application

Creating the Configuration Files

Creating Spring MVC Controllers

Creating JSP Views

Deploying the Web Application

10-2.Mapping Requests to Handlers

Problem

Solution

How It Works

Mapping Requests by Bean Names

Mapping Requests by Controller Class Names

Mapping Requests with Custom Mapping Definitions

Mapping Requests by Multiple Strategies

10-3. Intercepting Requests with Handler Interceptors

Problem

Solution

How It Works

10-4. Resolving User Locales

Problem

Solution

How It Works

Resolving Locales by an HTTP Request Header

Resolving Locales by a Session Attribute

Resolving Locales by a Cookie

Changing a User’s Locale

10-5. Externalizing Locale-Sensitive Text Messages

Problem

Solution

How It Works

10-6. Resolving Views by Names

Problem

Solution

How It Works

Resolving Views Based on URLs

Resolving Views from an XML Configuration File

Resolving Views from a Resource Bundle

Resolving Views with Multiple Resolvers

The Redirect Prefix

10-7.Mapping Exceptions to Views

Problem

Solution

How It Works

10-8. Constructing ModelAndView Objects

Problem

Solution

How It Works

10-9. Creating a Controller with a Parameterized View

Problem

Solution

How It Works

10-10.Handling Forms with Form Controllers

Problem

Solution

How It Works

Creating a Form Controller

Applying the Post/Redirect/Get Design Pattern

Initializing the Command Object

Providing Form Reference Data

Binding Properties of Custom Types

Validating Form Data

10-11.Handling Multipage Forms with Wizard Form Controllers

Problem

Solution

How It Works

Creating Wizard Form Pages

Creating a Wizard Form Controller

Validating Wizard FormData

10-12.Grouping Multiple Actions into a Controller

Problem

Solution

How It Works

Creating a Multi-Action Controller

Mapping URLs to Handler Methods

10-13. Creating Excel and PDF Views

Problem

Solution

How It Works

Creating Excel Views

Creating PDF Views

10-14.Developing Controllers with Annotations

Problem

Solution

How It Works

Developing Single-Action and Multi-Action Controllers

Developing a Form Controller

Comparison with the Traditional Controller Approach

10-15. Summary

CHAPTER 11 Integrating Spring with Other Web Frameworks

11-1. Accessing Spring in Generic Web Applications

Problem

Solution

How It Works

11-2. Integrating Spring with Struts 1.x

Problem

Solution

How It Works

Loading Spring’s Application Context into a Struts Application

Accessing Spring’s Application Context in Struts Actions

Declaring Struts Actions in Spring’s Bean Configuration File

11-3. Integrating Spring with JSF

Problem

Solution

How It Works

Resolving Spring Beans in JSF

Declaring JSF Managed Beans in Spring’s Bean Configuration File

11-4. Integrating Spring with DWR

Problem

Solution

How It Works

Exposing Spring Beans for Remote Invocation

Configuring DWR in Spring’s Bean Configuration File

11-5. Summary

CHAPTER 12 Spring Testing Support

12-1. Creating Tests with JUnit and TestNG

Problem

Solution

How It Works

Testing with JUnit 3.8

Testing with JUnit 4

Testing with TestNG

12-2. Creating Unit Tests and Integration Tests

Problem

Solution

How It Works

Creating Unit Tests for Isolated Classes

Creating Unit Tests for Dependent Classes Using Stubs and Mock Objects

Creating Integration Tests

12-3.Unit Testing Spring MVC Controllers

Problem

Solution

How It Works

Unit Testing Classic Spring MVC Controllers

Unit Testing Annotation-Based Spring MVC Controllers

12-4.Managing Application Contexts in Integration Tests

Problem

Solution

How It Works

Accessing the Context with JUnit 3.8 Legacy Support

Accessing the Context with the TestContext Framework in JUnit 4.4

Accessing the Context with the TestContext Framework in JUnit 3.8

Accessing the Context with the TestContext Framework in TestNG

12-5. Injecting Test Fixtures into Integration Tests

Problem

Solution

How It Works

Injecting Test Fixtures with JUnit 3.8 Legacy Support

Injecting Test Fixtures with the TestContext Framework in JUnit 4.4

Injecting Test Fixtures with the TestContext Framework in JUnit 3.8

Injecting Test Fixtures with the TestContext Framework in TestNG

12-6.Managing Transactions in Integration Tests

Problem

Solution

How It Works

Managing Transactions with JUnit 3.8 Legacy Support

Managing Transactions with the TestContext Framework in JUnit 4.4

Managing Transactions with the TestContext Framework in JUnit 3.8

Managing Transactions with the TestContext Framework in TestNG

12-7. Accessing a Database in Integration Tests

Problem

Solution

How It Works

Accessing a Database with JUnit 3.8 Legacy Support

Accessing a Database with the TestContext Framework

12-8.Using Spring’s Common Testing Annotations

Problem

Solution

How It Works

Using Common Testing Annotations with JUnit 3.8 Legacy Support

Using Common Testing Annotations with the TestContext Framework

12-9. Summary

PART 3 Advanced

CHAPTER 13 Spring Security

13-1. Securing URL Access

Problem

Solution

How It Works

Setting Up a Spring MVC Application That Uses Spring Security

Creating the Configuration Files

Creating the Controllers and Page Views

Securing URL Access

13-2. Logging In to Web Applications

Problem

Solution

How It Works

HTTP Basic Authentication

Form-Based Login

The Logout Service

Anonymous Login

Remember-Me Support

13-3. Authenticating Users

Problem

Solution

How It Works

Authenticating Users with In-Memory Definitions

Authenticating Users Against a Database

Encrypting Passwords

Authenticating Users Against an LDAP Repository

Caching User Details

13-4.Making Access Control Decisions

Problem

Solution

How It Works

13-5. Securing Method Invocations

Problem

Solution

How It Works

Securing Methods by Embedding a Security Interceptor

Securing Methods with Pointcuts

Securing Methods with Annotations

13-6.Handling Security in Views

Problem

Solution

How It Works

Displaying Authentication Information

Rendering View Contents Conditionally

13-7.Handling Domain Object Security

Problem

Solution

How It Works

Setting Up an ACL Service

Maintaining ACLs for Domain Objects

Making Access Control Decisions Based on ACLs

Handling Domain Objects Returned from Methods

13-8. Summary

CHAPTER 14 Spring Portlet MVC Framework

14-1.Developing a Simple Portlet with Spring Portlet MVC

Problem

Solution

How It Works

Setting Up a Portlet Application

Creating the Configuration Files

Creating Portlet Controllers

Mapping Portlet Requests to Handlers

Resolving View Names into Views

Creating Portlet Views

Deploying the Portlet Application

14-2.Mapping Portlet Requests to Handlers

Problem

Solution

How It Works

Mapping Requests by the Portlet Mode

Mapping Requests by a Parameter

Mapping Requests by Both the Portlet Mode and Parameter

14-3.Handling Portlet Forms with Simple Form Controllers

Problem

Solution

How It Works

Creating Form Controllers

Validating Form Data

14-4.Developing Portlet Controllers with Annotations

Problem

Solution

How It Works

Developing Multi-Action Controllers

Developing Form Controllers

14-5. Summary

CHAPTER 15 Spring Web Flow

15-1.Managing a Simple UI Flow with Spring Web Flow

Problem

Solution

How It Works

Setting Up a Spring MVC Application That Uses Spring Web Flow

Creating the Configuration Files

Creating Web Flow Definitions

15-2.Modeling Web Flows with Different State Types

Problem

Solution

How It Works

Defining View States

Defining Action States

Defining Decision States

Defining End States

Defining Subflow States

15-3. Securing Web Flows

Problem

Solution

How It Works

15-4. Persisting Objects in Web Flows

Problem

Solution

How It Works

Configuring JPA in Spring’s Application Context

Setting Up JPA for Spring Web Flow

Using JPA in Web Flows

15-5. Integrating Spring Web Flow with JSF

Problem

Solution

How It Works

Rendering JSF Views for Spring Web Flow

Using the JSF Components of Spring Faces

15-6. Summary

CHAPTER 16 Spring Remoting and Web Services

16-1. Exposing and Invoking Services Through RMI

Problem

Solution

How It Works

Exposing an RMI Service

Invoking an RMI Service

16-2. Exposing and Invoking Services Through HTTP

Problem

Solution

How It Works

Exposing a Hessian Service

Invoking a Hessian Service

Exposing a Burlap Service

Invoking a Burlap Service

Exposing an HTTP Invoker Service

Invoking an HTTP Invoker Service

16-3. Choosing aWeb Service Development Approach

Problem

Solution

How It Works

Contract-LastWeb Services

Contract-FirstWeb Services

Comparison

16-4. Exposing and InvokingWeb Services Using XFire

Problem

Solution

How It Works

Exposing aWeb Service Using XFire

Inspecting the GeneratedWSDL File

Invoking aWeb Service Using XFire

Exposing an Annotation-BasedWeb Service Using XFire

16-5.Defining the Contract ofWeb Services

Problem

Solution

How It Works

Creating Sample XMLMessages

Generating an XSD File from Sample XMLMessages

Optimizing the Generated XSD File

Previewing the GeneratedWSDL File

16-6. ImplementingWeb Services Using Spring-WS

Problem

Solution

How It Works

Setting Up a Spring-WS Application

MappingWeb Service Requests to Endpoints

Creating Service Endpoints

Publishing theWSDL File

16-7. InvokingWeb Services Using Spring-WS

Problem

Solution

How It Works

16-8.DevelopingWeb Services with XMLMarshalling

Problem

Solution

How It Works

Creating Service Endpoints with XMLMarshalling

InvokingWeb Services with XMLMarshalling

16-9. Creating Service Endpoints with Annotations

Problem

Solution

How It Works

16-10. Summary

CHAPTER 17 Spring Support for EJB and JMS

17-1. Creating EJB 2.x Components with Spring

Problem

Solution

How It Works

Creating EJB 2.x Components with Spring’s Support

17-2. Accessing EJB 2.x Components in Spring

Problem

Solution

How It Works

Accessing EJB 2.x Components Without Spring’s Support

Accessing EJB 2.x Components with Spring’s Support

17-3. Accessing EJB 3.0 Components in Spring

Problem

Solution

How It Works

Accessing EJB 3.0 Components Without Spring’s Support

Accessing EJB 3.0 Components with Spring’s Support

17-4. Sending and Receiving JMSMessages with Spring

Problem

Solution

How It Works

Sending and ReceivingMessages with Spring’s JMS Template

Sending and ReceivingMessages to and from a Default Destination

Extending the JmsGatewaySupport Class

Converting JMSMessages

Managing JMS Transactions

17-5. CreatingMessage-Driven POJOs in Spring

Problem

Solution

How It Works

Listening for JMSMessages withMessage Listeners

Listening for JMSMessages with POJOs

Converting JMSMessages

Managing JMS Transactions

Using Spring’s JMS Schema

17-6. Summary

CHAPTER 18 Spring Support for JMX, E-mail, and Scheduling

18-1. Exporting Spring Beans As JMX MBeans

Problem

Solution

How It Works

Registering MBeansWithout Spring’s Support

Exporting Spring Beans As MBeans

Exposing MBeans for Remote Access

Assembling theManagement Interface of MBeans

Auto-Detecting MBeans by Annotations

18-2. Publishing and Listening to JMX Notifications

Problem

Solution

How It Works

Publishing JMX Notifications

Listening to JMX Notifications

18-3. Accessing Remote JMX MBeans in Spring

Problem

Solution

How It Works

Accessing Remote MBeans Through an MBean Server Connection

Accessing Remote MBeans Through an MBean Proxy

18-4. Sending E-mail with Spring’s E-mail Support

Problem

Solution

How It Works

Sending E-mail Using the JavaMail API

Sending E-mail with Spring’sMailSender

Defining an E-mail Template

Sending MIMEMessages

18-5. Scheduling with Spring’s JDK Timer Support

Problem

Solution

How It Works

Creating a Timer Task

Using JDK Timer Without Spring’s Support

Using JDK Timer with Spring’s Support

18-6. Scheduling with Spring’s Quartz Support

Problem

Solution

How It Works

Using Quartz Without Spring’s Support

Using Quartz with Spring’s Support

18-7. Summary

CHAPTER 19 Scripting in Spring

19-1. Implementing Beans with Scripting Languages

Problem

Solution

How It Works

Scripting Beans with JRuby

Scripting Beans with Groovy

Scripting Beans with BeanShell

19-2. Injecting Spring Beans into Scripts

Problem

Solution

How It Works

Injecting Spring Beans into JRuby

Injecting Spring Beans into Groovy

Injecting Spring Beans into BeanShell

19-3. Refreshing Beans from Scripts

Problem

Solution

How It Works

19-4.Defining Script Sources Inline

Problem

Solution

How It Works

19-5. Summary

Index