Spring Framework Reference Manual

Rod Johnson

Juergen Hoeller

Keith Donald

Colin Sampaleanu

Rob Harrop

Thomas Risberg

Alef Arendsen

Darren Davison

Dmitriy Kopylenko

Mark Pollack

Thierry Templier

Erwin Vervaet

Portia Tung

Ben Hale

Adrian Colyer

John Lewis

Costin Leau

Mark Fisher

Sam Brannen

Ramnivas Laddad

Arjen Poutsma

Chris Beams

Tareq Abedrabbo

Andy Clement

Dave Syer

Oliver Gierke

Rossen Stoyanchev


Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.

Table of Contents

I. Overview of Spring Framework
1. Introduction to Spring Framework
1.1. Dependency Injection and Inversion of Control
1.2. Modules
1.2.1. Core Container
1.2.2. Data Access/Integration
1.2.3. Web
1.2.4. AOP and Instrumentation
1.2.5. Test
1.3. Usage scenarios
1.3.1. Dependency Management and Naming Conventions
Spring Dependencies and Depending on Spring
Maven Dependency Management
Ivy Dependency Management
1.3.2. Logging
Not Using Commons Logging
Using SLF4J
Using Log4J
II. What's New in Spring 3
2. New Features and Enhancements in Spring 3.0
2.1. Java 5
2.2. Improved documentation
2.3. New articles and tutorials
2.4. New module organization and build system
2.5. Overview of new features
2.5.1. Core APIs updated for Java 5
2.5.2. Spring Expression Language
2.5.3. The Inversion of Control (IoC) container
Java based bean metadata
Defining bean metadata within components
2.5.4. General purpose type conversion system and field formatting system
2.5.5. The Data Tier
2.5.6. The Web Tier
Comprehensive REST support
@MVC additions
2.5.7. Declarative model validation
2.5.8. Early support for Java EE 6
2.5.9. Support for embedded databases
3. New Features and Enhancements in Spring 3.1
3.1. Overview of new features
3.1.1. Cache Abstraction
3.1.2. Bean Definition Profiles
3.1.3. Environment Abstraction
3.1.4. PropertySource Abstraction
3.1.5. Code equivalents for Spring's XML namespaces
3.1.6. Support for Hibernate 4.x
3.1.7. TestContext framework support for @Configuration classes and bean definition profiles
3.1.8. c: namespace for more concise constructor injection
3.1.9. Support for injection against non-standard JavaBeans setters
3.1.10. Support for Servlet 3 code-based configuration of Servlet Container
3.1.11. Support for Servlet 3 MultipartResolver
3.1.12. JPA EntityManagerFactory bootstrapping without persistence.xml
3.1.13. New HandlerMethod-based Support Classes For Annotated Controller Processing
3.1.14. "consumes" and "produces" conditions in @RequestMapping
3.1.15. Flash Attributes and RedirectAttributes
3.1.16. URI Template Variable Enhancements
3.1.17. @Valid On @RequestBody Controller Method Arguments
3.1.18. @RequestPart Annotation On Controller Method Arguments
3.1.19. UriComponentsBuilder and UriComponents
III. Core Technologies
4. The IoC container
4.1. Introduction to the Spring IoC container and beans
4.2. Container overview
4.2.1. Configuration metadata
4.2.2. Instantiating a container
Composing XML-based configuration metadata
4.2.3. Using the container
4.3. Bean overview
4.3.1. Naming beans
Aliasing a bean outside the bean definition
4.3.2. Instantiating beans
Instantiation with a constructor
Instantiation with a static factory method
Instantiation using an instance factory method
4.4. Dependencies
4.4.1. Dependency injection
Constructor-based dependency injection
Setter-based dependency injection
Dependency resolution process
Examples of dependency injection
4.4.2. Dependencies and configuration in detail
Straight values (primitives, Strings, and so on)
References to other beans (collaborators)
Inner beans
Null and empty string values
XML shortcut with the p-namespace
XML shortcut with the c-namespace
Compound property names
4.4.3. Using depends-on
4.4.4. Lazy-initialized beans
4.4.5. Autowiring collaborators
Limitations and disadvantages of autowiring
Excluding a bean from autowiring
4.4.6. Method injection
Lookup method injection
Arbitrary method replacement
4.5. Bean scopes
4.5.1. The singleton scope
4.5.2. The prototype scope
4.5.3. Singleton beans with prototype-bean dependencies
4.5.4. Request, session, and global session scopes
Initial web configuration
Request scope
Session scope
Global session scope
Scoped beans as dependencies
4.5.5. Custom scopes
Creating a custom scope
Using a custom scope
4.6. Customizing the nature of a bean
4.6.1. Lifecycle callbacks
Initialization callbacks
Destruction callbacks
Default initialization and destroy methods
Combining lifecycle mechanisms
Startup and shutdown callbacks
Shutting down the Spring IoC container gracefully in non-web applications
4.6.2. ApplicationContextAware and BeanNameAware
4.6.3. Other Aware interfaces
4.7. Bean definition inheritance
4.8. Container Extension Points
4.8.1. Customizing beans using a BeanPostProcessor
Example: Hello World, BeanPostProcessor-style
Example: The RequiredAnnotationBeanPostProcessor
4.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor
Example: the PropertyPlaceholderConfigurer
Example: the PropertyOverrideConfigurer
4.8.3. Customizing instantiation logic with a FactoryBean
4.9. Annotation-based container configuration
4.9.1. @Required
4.9.2. @Autowired
4.9.3. Fine-tuning annotation-based autowiring with qualifiers
4.9.4. CustomAutowireConfigurer
4.9.5. @Resource
4.9.6. @PostConstruct and @PreDestroy
4.10. Classpath scanning and managed components
4.10.1. @Component and further stereotype annotations
4.10.2. Automatically detecting classes and registering bean definitions
4.10.3. Using filters to customize scanning
4.10.4. Defining bean metadata within components
4.10.5. Naming autodetected components
4.10.6. Providing a scope for autodetected components
4.10.7. Providing qualifier metadata with annotations
4.11. Using JSR 330 Standard Annotations
4.11.1. Dependency Injection with @Inject and @Named
4.11.2. @Named: a standard equivalent to the @Component annotation
4.11.3. Limitations of the standard approach
4.12. Java-based container configuration
4.12.1. Basic concepts: @Configuration and @Bean
4.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
Simple construction
Building the container programmatically using register(Class<?>...)
Enabling component scanning with scan(String...)
Support for web applications with AnnotationConfigWebApplicationContext
4.12.3. Composing Java-based configurations
Using the @Import annotation
Combining Java and XML configuration
4.12.4. Using the @Bean annotation
Declaring a bean
Injecting dependencies
Receiving lifecycle callbacks
Specifying bean scope
Customizing bean naming
Bean aliasing
4.12.5. Further information about how Java-based configuration works internally
4.13. Registering a LoadTimeWeaver
4.14. Additional Capabilities of the ApplicationContext
4.14.1. Internationalization using MessageSource
4.14.2. Standard and Custom Events
4.14.3. Convenient access to low-level resources
4.14.4. Convenient ApplicationContext instantiation for web applications
4.14.5. Deploying a Spring ApplicationContext as a J2EE RAR file
4.15. The BeanFactory
4.15.1. BeanFactory or ApplicationContext?
4.15.2. Glue code and the evil singleton
5. Resources
5.1. Introduction
5.2. The Resource interface
5.3. Built-in Resource implementations
5.3.1. UrlResource
5.3.2. ClassPathResource
5.3.3. FileSystemResource
5.3.4. ServletContextResource
5.3.5. InputStreamResource
5.3.6. ByteArrayResource
5.4. The ResourceLoader
5.5. The ResourceLoaderAware interface
5.6. Resources as dependencies
5.7. Application contexts and Resource paths
5.7.1. Constructing application contexts
Constructing ClassPathXmlApplicationContext instances - shortcuts
5.7.2. Wildcards in application context constructor resource paths
Ant-style Patterns
The classpath*: prefix
Other notes relating to wildcards
5.7.3. FileSystemResource caveats
6. Validation, Data Binding, and Type Conversion
6.1. Introduction
6.2. Validation using Spring's Validator interface
6.3. Resolving codes to error messages
6.4. Bean manipulation and the BeanWrapper
6.4.1. Setting and getting basic and nested properties
6.4.2. Built-in PropertyEditor implementations
Registering additional custom PropertyEditors
6.5. Spring 3 Type Conversion
6.5.1. Converter SPI
6.5.2. ConverterFactory
6.5.3. GenericConverter
6.5.4. ConversionService API
6.5.5. Configuring a ConversionService
6.5.6. Using a ConversionService programmatically
6.6. Spring 3 Field Formatting
6.6.1. Formatter SPI
6.6.2. Annotation-driven Formatting
Format Annotation API
6.6.3. FormatterRegistry SPI
6.6.4. FormatterRegistrar SPI
6.6.5. Configuring Formatting in Spring MVC
6.7. Spring 3 Validation
6.7.1. Overview of the JSR-303 Bean Validation API
6.7.2. Configuring a Bean Validation Implementation
Injecting a Validator
Configuring Custom Constraints
Additional Configuration Options
6.7.3. Configuring a DataBinder
6.7.4. Spring MVC 3 Validation
Triggering @Controller Input Validation
Configuring a Validator for use by Spring MVC
Configuring a JSR-303 Validator for use by Spring MVC
7. Spring Expression Language (SpEL)
7.1. Introduction
7.2. Feature Overview
7.3. Expression Evaluation using Spring's Expression Interface
7.3.1. The EvaluationContext interface
Type Conversion
7.4. Expression support for defining bean definitions
7.4.1. XML based configuration
7.4.2. Annotation-based configuration
7.5. Language Reference
7.5.1. Literal expressions
7.5.2. Properties, Arrays, Lists, Maps, Indexers
7.5.3. Inline lists
7.5.4. Array construction
7.5.5. Methods
7.5.6. Operators
Relational operators
Logical operators
Mathematical operators
7.5.7. Assignment
7.5.8. Types
7.5.9. Constructors
7.5.10. Variables
The #this and #root variables
7.5.11. Functions
7.5.12. Bean references
7.5.13. Ternary Operator (If-Then-Else)
7.5.14. The Elvis Operator
7.5.15. Safe Navigation operator
7.5.16. Collection Selection
7.5.17. Collection Projection
7.5.18. Expression templating
7.6. Classes used in the examples
8. Aspect Oriented Programming with Spring
8.1. Introduction
8.1.1. AOP concepts
8.1.2. Spring AOP capabilities and goals
8.1.3. AOP Proxies
8.2. @AspectJ support
8.2.1. Enabling @AspectJ Support
8.2.2. Declaring an aspect
8.2.3. Declaring a pointcut
Supported Pointcut Designators
Combining pointcut expressions
Sharing common pointcut definitions
Writing good pointcuts
8.2.4. Declaring advice
Before advice
After returning advice
After throwing advice
After (finally) advice
Around advice
Advice parameters
Advice ordering
8.2.5. Introductions
8.2.6. Aspect instantiation models
8.2.7. Example
8.3. Schema-based AOP support
8.3.1. Declaring an aspect
8.3.2. Declaring a pointcut
8.3.3. Declaring advice
Before advice
After returning advice
After throwing advice
After (finally) advice
Around advice
Advice parameters
Advice ordering
8.3.4. Introductions
8.3.5. Aspect instantiation models
8.3.6. Advisors
8.3.7. Example
8.4. Choosing which AOP declaration style to use
8.4.1. Spring AOP or full AspectJ?
8.4.2. @AspectJ or XML for Spring AOP?
8.5. Mixing aspect types
8.6. Proxying mechanisms
8.6.1. Understanding AOP proxies
8.7. Programmatic creation of @AspectJ Proxies
8.8. Using AspectJ with Spring applications
8.8.1. Using AspectJ to dependency inject domain objects with Spring
Unit testing @Configurable objects
Working with multiple application contexts
8.8.2. Other Spring aspects for AspectJ
8.8.3. Configuring AspectJ aspects using Spring IoC
8.8.4. Load-time weaving with AspectJ in the Spring Framework
A first example
Required libraries (JARS)
Spring configuration
Environment-specific configuration
8.9. Further Resources
9. Spring AOP APIs
9.1. Introduction
9.2. Pointcut API in Spring
9.2.1. Concepts
9.2.2. Operations on pointcuts
9.2.3. AspectJ expression pointcuts
9.2.4. Convenience pointcut implementations
Static pointcuts
Dynamic pointcuts
9.2.5. Pointcut superclasses
9.2.6. Custom pointcuts
9.3. Advice API in Spring
9.3.1. Advice lifecycles
9.3.2. Advice types in Spring
Interception around advice
Before advice
Throws advice
After Returning advice
Introduction advice
9.4. Advisor API in Spring
9.5. Using the ProxyFactoryBean to create AOP proxies
9.5.1. Basics
9.5.2. JavaBean properties
9.5.3. JDK- and CGLIB-based proxies
9.5.4. Proxying interfaces
9.5.5. Proxying classes
9.5.6. Using 'global' advisors
9.6. Concise proxy definitions
9.7. Creating AOP proxies programmatically with the ProxyFactory
9.8. Manipulating advised objects
9.9. Using the "autoproxy" facility
9.9.1. Autoproxy bean definitions
9.9.2. Using metadata-driven auto-proxying
9.10. Using TargetSources
9.10.1. Hot swappable target sources
9.10.2. Pooling target sources
9.10.3. Prototype target sources
9.10.4. ThreadLocal target sources
9.11. Defining new Advice types
9.12. Further resources
10. Testing
10.1. Introduction to Spring Testing
10.2. Unit Testing
10.2.1. Mock Objects
Servlet API
Portlet API
10.2.2. Unit Testing support Classes
General utilities
Spring MVC
10.3. Integration Testing
10.3.1. Overview
10.3.2. Goals of Integration Testing
Context management and caching
Dependency Injection of test fixtures
Transaction management
Support classes for integration testing
10.3.3. JDBC Testing Support
10.3.4. Annotations
Spring Testing Annotations
Standard Annotation Support
Spring JUnit Testing Annotations
10.3.5. Spring TestContext Framework
Key abstractions
Context management
Dependency injection of test fixtures
Transaction management
TestContext support classes
10.3.6. PetClinic Example
10.4. Further Resources
IV. Data Access
11. Transaction Management
11.1. Introduction to Spring Framework transaction management
11.2. Advantages of the Spring Framework's transaction support model
11.2.1. Global transactions
11.2.2. Local transactions
11.2.3. Spring Framework's consistent programming model
11.3. Understanding the Spring Framework transaction abstraction
11.4. Synchronizing resources with transactions
11.4.1. High-level synchronization approach
11.4.2. Low-level synchronization approach
11.4.3. TransactionAwareDataSourceProxy
11.5. Declarative transaction management
11.5.1. Understanding the Spring Framework's declarative transaction implementation
11.5.2. Example of declarative transaction implementation
11.5.3. Rolling back a declarative transaction
11.5.4. Configuring different transactional semantics for different beans
11.5.5. <tx:advice/> settings
11.5.6. Using @Transactional
@Transactional settings
Multiple Transaction Managers with @Transactional
Custom shortcut annotations
11.5.7. Transaction propagation
11.5.8. Advising transactional operations
11.5.9. Using @Transactional with AspectJ
11.6. Programmatic transaction management
11.6.1. Using the TransactionTemplate
Specifying transaction settings
11.6.2. Using the PlatformTransactionManager
11.7. Choosing between programmatic and declarative transaction management
11.8. Application server-specific integration
11.8.1. IBM WebSphere
11.8.2. BEA WebLogic Server
11.8.3. Oracle OC4J
11.9. Solutions to common problems
11.9.1. Use of the wrong transaction manager for a specific DataSource
11.10. Further Resources
12. DAO support
12.1. Introduction
12.2. Consistent exception hierarchy
12.3. Annotations used for configuring DAO or Repository classes
13. Data access with JDBC
13.1. Introduction to Spring Framework JDBC
13.1.1. Choosing an approach for JDBC database access
13.1.2. Package hierarchy
13.2. Using the JDBC core classes to control basic JDBC processing and error handling
13.2.1. JdbcTemplate
Examples of JdbcTemplate class usage
JdbcTemplate best practices
13.2.2. NamedParameterJdbcTemplate
13.2.3. SimpleJdbcTemplate
13.2.4. SQLExceptionTranslator
13.2.5. Executing statements
13.2.6. Running queries
13.2.7. Updating the database
13.2.8. Retrieving auto-generated keys
13.3. Controlling database connections
13.3.1. DataSource
13.3.2. DataSourceUtils
13.3.3. SmartDataSource
13.3.4. AbstractDataSource
13.3.5. SingleConnectionDataSource
13.3.6. DriverManagerDataSource
13.3.7. TransactionAwareDataSourceProxy
13.3.8. DataSourceTransactionManager
13.3.9. NativeJdbcExtractor
13.4. JDBC batch operations
13.4.1. Basic batch operations with the JdbcTemplate
13.4.2. Batch operations with a List of objects
13.4.3. Batch operations with multiple batches
13.5. Simplifying JDBC operations with the SimpleJdbc classes
13.5.1. Inserting data using SimpleJdbcInsert
13.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
13.5.3. Specifying columns for a SimpleJdbcInsert
13.5.4. Using SqlParameterSource to provide parameter values
13.5.5. Calling a stored procedure with SimpleJdbcCall
13.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall
13.5.7. How to define SqlParameters
13.5.8. Calling a stored function using SimpleJdbcCall
13.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
13.6. Modeling JDBC operations as Java objects
13.6.1. SqlQuery
13.6.2. MappingSqlQuery
13.6.3. SqlUpdate
13.6.4. StoredProcedure
13.7. Common problems with parameter and data value handling
13.7.1. Providing SQL type information for parameters
13.7.2. Handling BLOB and CLOB objects
13.7.3. Passing in lists of values for IN clause
13.7.4. Handling complex types for stored procedure calls
13.8. Embedded database support
13.8.1. Why use an embedded database?
13.8.2. Creating an embedded database instance using Spring XML
13.8.3. Creating an embedded database instance programmatically
13.8.4. Extending the embedded database support
13.8.5. Using HSQL
13.8.6. Using H2
13.8.7. Using Derby
13.8.8. Testing data access logic with an embedded database
13.9. Initializing a DataSource
13.9.1. Initializing a database instance using Spring XML
Initialization of Other Components that Depend on the Database
14. Object Relational Mapping (ORM) Data Access
14.1. Introduction to ORM with Spring
14.2. General ORM integration considerations
14.2.1. Resource and transaction management
14.2.2. Exception translation
14.3. Hibernate
14.3.1. SessionFactory setup in a Spring container
14.3.2. Implementing DAOs based on plain Hibernate 3 API
14.3.3. Declarative transaction demarcation
14.3.4. Programmatic transaction demarcation
14.3.5. Transaction management strategies
14.3.6. Comparing container-managed and locally defined resources
14.3.7. Spurious application server warnings with Hibernate
14.4. JDO
14.4.1. PersistenceManagerFactory setup
14.4.2. Implementing DAOs based on the plain JDO API
14.4.3. Transaction management
14.4.4. JdoDialect
14.5. JPA
14.5.1. Three options for JPA setup in a Spring environment
Obtaining an EntityManagerFactory from JNDI
Dealing with multiple persistence units
14.5.2. Implementing DAOs based on plain JPA
14.5.3. Transaction Management
14.5.4. JpaDialect
14.6. iBATIS SQL Maps
14.6.1. Setting up the SqlMapClient
14.6.2. Using SqlMapClientTemplate and SqlMapClientDaoSupport
14.6.3. Implementing DAOs based on plain iBATIS API
15. Marshalling XML using O/X Mappers
15.1. Introduction
15.2. Marshaller and Unmarshaller
15.2.1. Marshaller
15.2.2. Unmarshaller
15.2.3. XmlMappingException
15.3. Using Marshaller and Unmarshaller
15.4. XML Schema-based Configuration
15.5. JAXB
15.5.1. Jaxb2Marshaller
XML Schema-based Configuration
15.6. Castor
15.6.1. CastorMarshaller
15.6.2. Mapping
15.7. XMLBeans
15.7.1. XmlBeansMarshaller
XML Schema-based Configuration
15.8. JiBX
15.8.1. JibxMarshaller
XML Schema-based Configuration
15.9. XStream
15.9.1. XStreamMarshaller
V. The Web
16. Web MVC framework
16.1. Introduction to Spring Web MVC framework
16.1.1. Features of Spring Web MVC
16.1.2. Pluggability of other MVC implementations
16.2. The DispatcherServlet
16.2.1. Special Bean Types In the WebApplicationContext
16.2.2. Default DispatcherServlet Configuration
16.2.3. DispatcherServlet Processing Sequence
16.3. Implementing Controllers
16.3.1. Defining a controller with @Controller
16.3.2. Mapping Requests With @RequestMapping
New Support Classes for @RequestMapping methods in Spring MVC 3.1
URI Template Patterns
URI Template Patterns with Regular Expressions
Path Patterns
Consumable Media Types
Producible Media Types
Request Parameters and Header Values
16.3.3. Defining @RequestMapping handler methods
Supported method argument types
Supported method return types
Binding request parameters to method parameters with @RequestParam
Mapping the request body with the @RequestBody annotation
Mapping the response body with the @ResponseBody annotation
Using HttpEntity<?>
Using @ModelAttribute on a method
Using @ModelAttribute on a method argument
Using @SessionAttributes to store model attributes in the HTTP session between requests
Specifying redirect and flash attributes
Working with "application/x-www-form-urlencoded" data
Mapping cookie values with the @CookieValue annotation
Mapping request header attributes with the @RequestHeader annotation
Method Parameters And Type Conversion
Customizing WebDataBinder initialization
Support for the 'Last-Modified' Response Header To Facilitate Content Caching
16.4. Handler mappings
16.4.1. Intercepting requests with a HandlerInterceptor
16.5. Resolving views
16.5.1. Resolving views with the ViewResolver interface
16.5.2. Chaining ViewResolvers
16.5.3. Redirecting to views
The redirect: prefix
The forward: prefix
16.5.4. ContentNegotiatingViewResolver
16.6. Using flash attributes
16.7. Building URIs
16.8. Using locales
16.8.1. AcceptHeaderLocaleResolver
16.8.2. CookieLocaleResolver
16.8.3. SessionLocaleResolver
16.8.4. LocaleChangeInterceptor
16.9. Using themes
16.9.1. Overview of themes
16.9.2. Defining themes
16.9.3. Theme resolvers
16.10. Spring's multipart (file upload) support
16.10.1. Introduction
16.10.2. Using a MultipartResolver with Commons FileUpload
16.10.3. Using a MultipartResolver with Servlet 3.0
16.10.4. Handling a file upload in a form
16.10.5. Handling a file upload request from programmatic clients
16.11. Handling exceptions
16.11.1. HandlerExceptionResolver
16.11.2. @ExceptionHandler
16.12. Convention over configuration support
16.12.1. The Controller ControllerClassNameHandlerMapping
16.12.2. The Model ModelMap (ModelAndView)
16.12.3. The View - RequestToViewNameTranslator
16.13. ETag support
16.14. Configuring Spring MVC
16.14.1. Enabling MVC Java Config or the MVC XML Namespace
16.14.2. Customizing the Provided Configuration
16.14.3. Configuring Interceptors
16.14.4. Configuring View Controllers
16.14.5. Configuring Serving of Resources
16.14.6. mvc:default-servlet-handler
16.14.7. More Spring Web MVC Resources
16.14.8. Advanced Customizations with MVC Java Config
16.14.9. Advanced Customizations with the MVC Namespace
17. View technologies
17.1. Introduction
17.2. JSP & JSTL
17.2.1. View resolvers
17.2.2. 'Plain-old' JSPs versus JSTL
17.2.3. Additional tags facilitating development
17.2.4. Using Spring's form tag library
The form tag
The input tag
The checkbox tag
The checkboxes tag
The radiobutton tag
The radiobuttons tag
The password tag
The select tag
The option tag
The options tag
The textarea tag
The hidden tag
The errors tag
HTTP Method Conversion
HTML5 Tags
17.3. Tiles
17.3.1. Dependencies
17.3.2. How to integrate Tiles
SimpleSpringPreparerFactory and SpringBeanPreparerFactory
17.4. Velocity & FreeMarker
17.4.1. Dependencies
17.4.2. Context configuration
17.4.3. Creating templates
17.4.4. Advanced configuration
17.4.5. Bind support and form handling
The bind macros
Simple binding
Form input generation macros
HTML escaping and XHTML compliance
17.5. XSLT
17.5.1. My First Words
Bean definitions
Standard MVC controller code
Convert the model data to XML
Defining the view properties
Document transformation
17.5.2. Summary
17.6. Document views (PDF/Excel)
17.6.1. Introduction
17.6.2. Configuration and setup
Document view definitions
Controller code
Subclassing for Excel views
Subclassing for PDF views
17.7. JasperReports
17.7.1. Dependencies
17.7.2. Configuration
Configuring the ViewResolver
Configuring the Views
About Report Files
Using JasperReportsMultiFormatView
17.7.3. Populating the ModelAndView
17.7.4. Working with Sub-Reports
Configuring Sub-Report Files
Configuring Sub-Report Data Sources
17.7.5. Configuring Exporter Parameters
17.8. Feed Views
17.9. XML Marshalling View
17.10. JSON Mapping View
18. Integrating with other web frameworks
18.1. Introduction
18.2. Common configuration
18.3. JavaServer Faces 1.1 and 1.2
18.3.1. DelegatingVariableResolver (JSF 1.1/1.2)
18.3.2. SpringBeanVariableResolver (JSF 1.1/1.2)
18.3.3. SpringBeanFacesELResolver (JSF 1.2+)
18.3.4. FacesContextUtils
18.4. Apache Struts 1.x and 2.x
18.4.1. ContextLoaderPlugin
18.4.2. ActionSupport Classes
18.5. WebWork 2.x
18.6. Tapestry 3.x and 4.x
18.6.1. Injecting Spring-managed beans
Dependency Injecting Spring Beans into Tapestry pages
Component definition files
Adding abstract accessors
Dependency Injecting Spring Beans into Tapestry pages - Tapestry 4.x style
18.7. Further Resources
19. Portlet MVC Framework
19.1. Introduction
19.1.1. Controllers - The C in MVC
19.1.2. Views - The V in MVC
19.1.3. Web-scoped beans
19.2. The DispatcherPortlet
19.3. The ViewRendererServlet
19.4. Controllers
19.4.1. AbstractController and PortletContentGenerator
19.4.2. Other simple controllers
19.4.3. Command Controllers
19.4.4. PortletWrappingController
19.5. Handler mappings
19.5.1. PortletModeHandlerMapping
19.5.2. ParameterHandlerMapping
19.5.3. PortletModeParameterHandlerMapping
19.5.4. Adding HandlerInterceptors
19.5.5. HandlerInterceptorAdapter
19.5.6. ParameterMappingInterceptor
19.6. Views and resolving them
19.7. Multipart (file upload) support
19.7.1. Using the PortletMultipartResolver
19.7.2. Handling a file upload in a form
19.8. Handling exceptions
19.9. Annotation-based controller configuration
19.9.1. Setting up the dispatcher for annotation support
19.9.2. Defining a controller with @Controller
19.9.3. Mapping requests with @RequestMapping
19.9.4. Supported handler method arguments
19.9.5. Binding request parameters to method parameters with @RequestParam
19.9.6. Providing a link to data from the model with @ModelAttribute
19.9.7. Specifying attributes to store in a Session with @SessionAttributes
19.9.8. Customizing WebDataBinder initialization
Customizing data binding with @InitBinder
Configuring a custom WebBindingInitializer
19.10. Portlet application deployment
VI. Integration
20. Remoting and web services using Spring
20.1. Introduction
20.2. Exposing services using RMI
20.2.1. Exporting the service using the RmiServiceExporter
20.2.2. Linking in the service at the client
20.3. Using Hessian or Burlap to remotely call services via HTTP
20.3.1. Wiring up the DispatcherServlet for Hessian and co.
20.3.2. Exposing your beans by using the HessianServiceExporter
20.3.3. Linking in the service on the client
20.3.4. Using Burlap
20.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
20.4. Exposing services using HTTP invokers
20.4.1. Exposing the service object
20.4.2. Linking in the service at the client
20.5. Web services
20.5.1. Exposing servlet-based web services using JAX-RPC
20.5.2. Accessing web services using JAX-RPC
20.5.3. Registering JAX-RPC Bean Mappings
20.5.4. Registering your own JAX-RPC Handler
20.5.5. Exposing servlet-based web services using JAX-WS
20.5.6. Exporting standalone web services using JAX-WS
20.5.7. Exporting web services using the JAX-WS RI's Spring support
20.5.8. Accessing web services using JAX-WS
20.6. JMS
20.6.1. Server-side configuration
20.6.2. Client-side configuration
20.7. Auto-detection is not implemented for remote interfaces
20.8. Considerations when choosing a technology
20.9. Accessing RESTful services on the Client
20.9.1. RestTemplate
Working with the URI
Dealing with request and response headers
20.9.2. HTTP Message Conversion
MappingJackson2HttpMessageConverter (or MappingJacksonHttpMessageConverter with Jackson 1.x)
21. Enterprise JavaBeans (EJB) integration
21.1. Introduction
21.2. Accessing EJBs
21.2.1. Concepts
21.2.2. Accessing local SLSBs
21.2.3. Accessing remote SLSBs
21.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
21.3. Using Spring's EJB implementation support classes
21.3.1. EJB 2.x base classes
21.3.2. EJB 3 injection interceptor
22. JMS (Java Message Service)
22.1. Introduction
22.2. Using Spring JMS
22.2.1. JmsTemplate
22.2.2. Connections
Caching Messaging Resources
22.2.3. Destination Management
22.2.4. Message Listener Containers
22.2.5. Transaction management
22.3. Sending a Message
22.3.1. Using Message Converters
22.3.2. SessionCallback and ProducerCallback
22.4. Receiving a message
22.4.1. Synchronous Reception
22.4.2. Asynchronous Reception - Message-Driven POJOs
22.4.3. The SessionAwareMessageListener interface
22.4.4. The MessageListenerAdapter
22.4.5. Processing messages within transactions
22.5. Support for JCA Message Endpoints
22.6. JMS Namespace Support
23. JMX
23.1. Introduction
23.2. Exporting your beans to JMX
23.2.1. Creating an MBeanServer
23.2.2. Reusing an existing MBeanServer
23.2.3. Lazy-initialized MBeans
23.2.4. Automatic registration of MBeans
23.2.5. Controlling the registration behavior
23.3. Controlling the management interface of your beans
23.3.1. The MBeanInfoAssembler Interface
23.3.2. Using Source-Level Metadata (JDK 5.0 annotations)
23.3.3. Source-Level Metadata Types
23.3.4. The AutodetectCapableMBeanInfoAssembler interface
23.3.5. Defining management interfaces using Java interfaces
23.3.6. Using MethodNameBasedMBeanInfoAssembler
23.4. Controlling the ObjectNames for your beans
23.4.1. Reading ObjectNames from Properties
23.4.2. Using the MetadataNamingStrategy
23.4.3. The <context:mbean-export/> element
23.5. JSR-160 Connectors
23.5.1. Server-side Connectors
23.5.2. Client-side Connectors
23.5.3. JMX over Burlap/Hessian/SOAP
23.6. Accessing MBeans via Proxies
23.7. Notifications
23.7.1. Registering Listeners for Notifications
23.7.2. Publishing Notifications
23.8. Further Resources
24.1. Introduction
24.2. Configuring CCI
24.2.1. Connector configuration
24.2.2. ConnectionFactory configuration in Spring
24.2.3. Configuring CCI connections
24.2.4. Using a single CCI connection
24.3. Using Spring's CCI access support
24.3.1. Record conversion
24.3.2. The CciTemplate
24.3.3. DAO support
24.3.4. Automatic output record generation
24.3.5. Summary
24.3.6. Using a CCI Connection and Interaction directly
24.3.7. Example for CciTemplate usage
24.4. Modeling CCI access as operation objects
24.4.1. MappingRecordOperation
24.4.2. MappingCommAreaOperation
24.4.3. Automatic output record generation
24.4.4. Summary
24.4.5. Example for MappingRecordOperation usage
24.4.6. Example for MappingCommAreaOperation usage
24.5. Transactions
25. Email
25.1. Introduction
25.2. Usage
25.2.1. Basic MailSender and SimpleMailMessage usage
25.2.2. Using the JavaMailSender and the MimeMessagePreparator
25.3. Using the JavaMail MimeMessageHelper
25.3.1. Sending attachments and inline resources
Inline resources
25.3.2. Creating email content using a templating library
A Velocity-based example
26. Task Execution and Scheduling
26.1. Introduction
26.2. The Spring TaskExecutor abstraction
26.2.1. TaskExecutor types
26.2.2. Using a TaskExecutor
26.3. The Spring TaskScheduler abstraction
26.3.1. The Trigger interface
26.3.2. Trigger implementations
26.3.3. TaskScheduler implementations
26.4. The Task Namespace
26.4.1. The 'scheduler' element
26.4.2. The 'executor' element
26.4.3. The 'scheduled-tasks' element
26.5. Annotation Support for Scheduling and Asynchronous Execution
26.5.1. The @Scheduled Annotation
26.5.2. The @Async Annotation
26.5.3. The <annotation-driven> Element
26.5.4. Executor qualification with @Async
26.6. Using the Quartz Scheduler
26.6.1. Using the JobDetailBean
26.6.2. Using the MethodInvokingJobDetailFactoryBean
26.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean
26.7. Using JDK Timer support
26.7.1. Creating custom timers
26.7.2. Using the MethodInvokingTimerTaskFactoryBean
26.7.3. Wrapping up: setting up the tasks using the TimerFactoryBean
27. Dynamic language support
27.1. Introduction
27.2. A first example
27.3. Defining beans that are backed by dynamic languages
27.3.1. Common concepts
The <lang:language/> element
Refreshable beans
Inline dynamic language source files
Understanding Constructor Injection in the context of dynamic-language-backed beans
27.3.2. JRuby beans
27.3.3. Groovy beans
Customising Groovy objects via a callback
27.3.4. BeanShell beans
27.4. Scenarios
27.4.1. Scripted Spring MVC Controllers
27.4.2. Scripted Validators
27.5. Bits and bobs
27.5.1. AOP - advising scripted beans
27.5.2. Scoping
27.6. Further Resources
28. Cache Abstraction
28.1. Introduction
28.2. Understanding the cache abstraction
28.3. Declarative annotation-based caching
28.3.1. @Cacheable annotation
Default Key Generation
Custom Key Generation Declaration
Conditional caching
Available caching SpEL evaluation context
28.3.2. @CachePut annotation
28.3.3. @CacheEvict annotation
28.3.4. @Caching annotation
28.3.5. Enable caching annotations
28.3.6. Using custom annotations
28.4. Declarative XML-based caching
28.5. Configuring the cache storage
28.5.1. JDK ConcurrentMap-based Cache
28.5.2. Ehcache-based Cache
28.5.3. Dealing with caches without a backing store
28.6. Plugging-in different back-end caches
28.7. How can I set the TTL/TTI/Eviction policy/XXX feature?
VII. Appendices
A. Classic Spring Usage
A.1. Classic ORM usage
A.1.1. Hibernate
The HibernateTemplate
Implementing Spring-based DAOs without callbacks
A.1.2. JDO
JdoTemplate and JdoDaoSupport
A.1.3. JPA
JpaTemplate and JpaDaoSupport
A.2. Classic Spring MVC
A.3. JMS Usage
A.3.1. JmsTemplate
A.3.2. Asynchronous Message Reception
A.3.3. Connections
A.3.4. Transaction Management
B. Classic Spring AOP Usage
B.1. Pointcut API in Spring
B.1.1. Concepts
B.1.2. Operations on pointcuts
B.1.3. AspectJ expression pointcuts
B.1.4. Convenience pointcut implementations
Static pointcuts
Dynamic pointcuts
B.1.5. Pointcut superclasses
B.1.6. Custom pointcuts
B.2. Advice API in Spring
B.2.1. Advice lifecycles
B.2.2. Advice types in Spring
Interception around advice
Before advice
Throws advice
After Returning advice
Introduction advice
B.3. Advisor API in Spring
B.4. Using the ProxyFactoryBean to create AOP proxies
B.4.1. Basics
B.4.2. JavaBean properties
B.4.3. JDK- and CGLIB-based proxies
B.4.4. Proxying interfaces
B.4.5. Proxying classes
B.4.6. Using 'global' advisors
B.5. Concise proxy definitions
B.6. Creating AOP proxies programmatically with the ProxyFactory
B.7. Manipulating advised objects
B.8. Using the "autoproxy" facility
B.8.1. Autoproxy bean definitions
B.8.2. Using metadata-driven auto-proxying
B.9. Using TargetSources
B.9.1. Hot swappable target sources
B.9.2. Pooling target sources
B.9.3. Prototype target sources
B.9.4. ThreadLocal target sources
B.10. Defining new Advice types
B.11. Further resources
C. XML Schema-based configuration
C.1. Introduction
C.2. XML Schema-based configuration
C.2.1. Referencing the schemas
C.2.2. The util schema
C.2.3. The jee schema
<jee:jndi-lookup/> (simple)
<jee:jndi-lookup/> (with single JNDI environment setting)
<jee:jndi-lookup/> (with multiple JNDI environment settings)
<jee:jndi-lookup/> (complex)
<jee:local-slsb/> (simple)
<jee:local-slsb/> (complex)
C.2.4. The lang schema
C.2.5. The jms schema
C.2.6. The tx (transaction) schema
C.2.7. The aop schema
C.2.8. The context schema
C.2.9. The tool schema
C.2.10. The beans schema
D. Extensible XML authoring
D.1. Introduction
D.2. Authoring the schema
D.3. Coding a NamespaceHandler
D.4. Coding a BeanDefinitionParser
D.5. Registering the handler and the schema
D.5.1. 'META-INF/spring.handlers'
D.5.2. 'META-INF/spring.schemas'
D.6. Using a custom extension in your Spring XML configuration
D.7. Meatier examples
D.7.1. Nesting custom tags within custom tags
D.7.2. Custom attributes on 'normal' elements
D.8. Further Resources
E. spring-beans-2.0.dtd
F. spring.tld
F.1. Introduction
F.2. The bind tag
F.3. The escapeBody tag
F.4. The hasBindErrors tag
F.5. The htmlEscape tag
F.6. The message tag
F.7. The nestedPath tag
F.8. The theme tag
F.9. The transform tag
F.10. The url tag
F.11. The eval tag
G. spring-form.tld
G.1. Introduction
G.2. The checkbox tag
G.3. The checkboxes tag
G.4. The errors tag
G.5. The form tag
G.6. The hidden tag
G.7. The input tag
G.8. The label tag
G.9. The option tag
G.10. The options tag
G.11. The password tag
G.12. The radiobutton tag
G.13. The radiobuttons tag
G.14. The select tag
G.15. The textarea tag