100% found this document useful (1 vote)

6K views973 pages

Spring Framework

Spring Framework Reference documentation 3 (www.springframework.org) Spring Framework is a web-based application development framework. This document contains the Spring Framework Reference documentation.

Uploaded by

babith

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

100% found this document useful (1 vote)

6K views973 pages

Spring Framework

Uploaded by

babith

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as DOC, PDF, TXT or read online on Scribd

You are on page 1/ 973

Spring Framework

Reference Documentation
3.0

Copyright © 2004-2010 Rod Johnson, Juergen Hoeller, Keith Donald, Colin

Sampaleanu, Rob Harrop, Alef Arendsen, Thomas Risberg, 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
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
1.3.1.1. Spring Dependencies and Depending on Spring
1.3.1.2. Maven Dependency Management
1.3.1.3. Ivy Dependency Management
1.3.2. Logging
1.3.2.1. Not Using Commons Logging
1.3.2.2. Using SLF4J
1.3.2.3. Using Log4J
II. What's New in Spring 3.0
2. New Features and Enhancements in Spring 3.0

1
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
2.5.3.1. Java based bean metadata
2.5.3.2. 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
2.5.6.1. Comprehensive REST support
2.5.6.2. @MVC additions
2.5.7. Declarative model validation
2.5.8. Early support for Java EE 6
2.5.9. Support for embedded databases
III. Core Technologies
3. The IoC container
3.1. Introduction to the Spring IoC container and beans
3.2. Container overview
3.2.1. Configuration metadata
3.2.2. Instantiating a container
3.2.2.1. Composing XML-based configuration metadata
3.2.3. Using the container
3.3. Bean overview
3.3.1. Naming beans
3.3.1.1. Aliasing a bean outside the bean definition
3.3.2. Instantiating beans
3.3.2.1. Instantiation with a constructor
3.3.2.2. Instantiation with a static factory method
3.3.2.3. Instantiation using an instance factory method
3.4. Dependencies
3.4.1. Dependency injection
3.4.1.1. Constructor-based dependency injection
3.4.1.2. Setter-based dependency injection
3.4.1.3. Dependency resolution process
3.4.1.4. Examples of dependency injection
3.4.2. Dependencies and configuration in detail
3.4.2.1. Straight values (primitives, Strings, and so on)

2
3.4.2.2. References to other beans (collaborators)
3.4.2.3. Inner beans
3.4.2.4. Collections
3.4.2.5. Null and empty string values
3.4.2.6. XML shortcut with the p-namespace
3.4.2.7. Compound property names
3.4.3. Using depends-on
3.4.4. Lazy-initialized beans
3.4.5. Autowiring collaborators
3.4.5.1. Limitations and disadvantages of autowiring
3.4.5.2. Excluding a bean from autowiring
3.4.6. Method injection
3.4.6.1. Lookup method injection
3.4.6.2. Arbitrary method replacement
3.5. Bean scopes
3.5.1. The singleton scope
3.5.2. The prototype scope
3.5.3. Singleton beans with prototype-bean dependencies
3.5.4. Request, session, and global session scopes
3.5.4.1. Initial web configuration
3.5.4.2. Request scope
3.5.4.3. Session scope
3.5.4.4. Global session scope
3.5.4.5. Scoped beans as dependencies
3.5.5. Custom scopes
3.5.5.1. Creating a custom scope
3.5.5.2. Using a custom scope
3.6. Customizing the nature of a bean
3.6.1. Lifecycle callbacks
3.6.1.1. Initialization callbacks
3.6.1.2. Destruction callbacks
3.6.1.3. Default initialization and destroy methods
3.6.1.4. Combining lifecycle mechanisms
3.6.1.5. Startup and shutdown callbacks
3.6.1.6. Shutting down the Spring IoC container gracefully in non-web
applications
3.6.2. ApplicationContextAware and BeanNameAware
3.6.3. Other Aware interfaces
3.7. Bean definition inheritance
3.8. Container extension points
3.8.1. Customizing beans using the BeanPostProcessor Interface

3
3.8.1.1. Example: Hello World, BeanPostProcessor-style
3.8.1.2. Example: The RequiredAnnotationBeanPostProcessor
3.8.2. Customizing configuration metadata with BeanFactoryPostProcessor
interface
3.8.2.1. Example: the PropertyPlaceholderConfigurer
3.8.2.2. Example: the PropertyOverrideConfigurer
3.8.3. Customizing instantiation logic with the FactoryBean Interface
3.9. Annotation-based container configuration
3.9.1. @Required
3.9.2. @Autowired and @Inject
3.9.3. Fine-tuning annotation-based autowiring with qualifiers
3.9.4. CustomAutowireConfigurer
3.9.5. @Resource
3.9.6. @PostConstruct and @PreDestroy
3.10. Classpath scanning and managed components
3.10.1. @Component and further stereotype annotations
3.10.2. Automatically detecting classes and registering bean definitions
3.10.3. Using filters to customize scanning
3.10.4. Defining bean metadata within components
3.10.5. Naming autodetected components
3.10.6. Providing a scope for autodetected components
3.10.7. Providing qualifier metadata with annotations
3.11. Java-based container configuration
3.11.1. Basic concepts: @Configuration and @Bean
3.11.2. Instantiating the Spring container using
AnnotationConfigApplicationContext
3.11.2.1. Simple construction
3.11.2.2. Building the container programmatically using register(Class<?>...)
3.11.2.3. Enabling component scanning with scan(String...)
3.11.2.4. Support for web applications with
AnnotationConfigWebApplicationContext
3.11.3. Composing Java-based configurations
3.11.3.1. Using the @Import annotation
3.11.3.2. Combining Java and XML configuration
3.11.4. Using the @Bean annotation
3.11.4.1. Declaring a bean
3.11.4.2. Injecting dependencies
3.11.4.3. Receiving lifecycle callbacks
3.11.4.4. Specifying bean scope
3.11.4.5. Customizing bean naming
3.11.4.6. Bean aliasing

4
3.11.5. Further information about how Java-based configuration works
internally
3.12. Registering a LoadTimeWeaver
3.13. Additional Capabilities of the ApplicationContext
3.13.1. Internationalization using MessageSource
3.13.2. Standard and Custom Events
3.13.3. Convenient access to low-level resources
3.13.4. Convenient ApplicationContext instantiation for web applications
3.13.5. Deploying a Spring ApplicationContext as a J2EE RAR file
3.14. The BeanFactory
3.14.1. BeanFactory or ApplicationContext?
3.14.2. Glue code and the evil singleton
4. Resources
4.1. Introduction
4.2. The Resource interface
4.3. Built-in Resource implementations
4.3.1. UrlResource
4.3.2. ClassPathResource
4.3.3. FileSystemResource
4.3.4. ServletContextResource
4.3.5. InputStreamResource
4.3.6. ByteArrayResource
4.4. The ResourceLoader
4.5. The ResourceLoaderAware interface
4.6. Resources as dependencies
4.7. Application contexts and Resource paths
4.7.1. Constructing application contexts
4.7.1.1. Constructing ClassPathXmlApplicationContext instances - shortcuts
4.7.2. Wildcards in application context constructor resource paths
4.7.2.1. Ant-style Patterns
4.7.2.2. The classpath*: prefix
4.7.2.3. Other notes relating to wildcards
4.7.3. FileSystemResource caveats
5. Validation, Data Binding, and Type Conversion
5.1. Introduction
5.2. Validation using Spring's Validator interface
5.3. Resolving codes to error messages
5.4. Bean manipulation and the BeanWrapper
5.4.1. Setting and getting basic and nested properties
5.4.2. Built-in PropertyEditor implementations
5.4.2.1. Registering additional custom PropertyEditors

5
5.5. Spring 3 Type Conversion
5.5.1. Converter SPI
5.5.2. ConverterFactory
5.5.3. GenericConverter
5.5.3.1. ConditionalGenericConverter
5.5.4. ConversionService API
5.5.5. Configuring a ConversionService
5.5.6. Using a ConversionService programatically
5.6. Spring 3 Field Formatting
5.6.1. Formatter SPI
5.6.2. Annotation-driven Formatting
5.6.2.1. Format Annotation API
5.6.3. FormatterRegistry SPI
5.6.4. Configuring Formatting in Spring MVC
5.7. Spring 3 Validation
5.7.1. Overview of the JSR-303 Bean Validation API
5.7.2. Configuring a Bean Validation Implementation
5.7.2.1. Injecting a Validator
5.7.2.2. Configuring Custom Constraints
5.7.2.3. Additional Configuration Options
5.7.3. Configuring a DataBinder
5.7.4. Spring MVC 3 Validation
5.7.4.1. Triggering @Controller Input Validation
5.7.4.2. Configuring a Validator for use by Spring MVC
5.7.4.3. Configuring a JSR-303 Validator for use by Spring MVC
6. Spring Expression Language (SpEL)
6.1. Introduction
6.2. Feature Overview
6.3. Expression Evaluation using Spring's Expression Interface
6.3.1. The EvaluationContext interface
6.3.1.1. Type Conversion
6.4. Expression support for defining bean definitions
6.4.1. XML based configuration
6.4.2. Annotation-based configuration
6.5. Language Reference
6.5.1. Literal expressions
6.5.2. Properties, Arrays, Lists, Maps, Indexers
6.5.3. Inline lists
6.5.4. Array construction
6.5.5. Methods
6.5.6. Operators

6
6.5.6.1. Relational operators
6.5.6.2. Logical operators
6.5.6.3. Mathematical operators
6.5.7. Assignment
6.5.8. Types
6.5.9. Constructors
6.5.10. Variables
6.5.10.1. The #this and #root variables
6.5.11. Functions
6.5.12. Bean references
6.5.13. Ternary Operator (If-Then-Else)
6.5.14. The Elvis Operator
6.5.15. Safe Navigation operator
6.5.16. Collection Selection
6.5.17. Collection Projection
6.5.18. Expression templating
6.6. Classes used in the examples
7. Aspect Oriented Programming with Spring
7.1. Introduction
7.1.1. AOP concepts
7.1.2. Spring AOP capabilities and goals
7.1.3. AOP Proxies
7.2. @AspectJ support
7.2.1. Enabling @AspectJ Support
7.2.2. Declaring an aspect
7.2.3. Declaring a pointcut
7.2.3.1. Supported Pointcut Designators
7.2.3.2. Combining pointcut expressions
7.2.3.3. Sharing common pointcut definitions
7.2.3.4. Examples
7.2.3.5. Writing good pointcuts
7.2.4. Declaring advice
7.2.4.1. Before advice
7.2.4.2. After returning advice
7.2.4.3. After throwing advice
7.2.4.4. After (finally) advice
7.2.4.5. Around advice
7.2.4.6. Advice parameters
7.2.4.7. Advice ordering
7.2.5. Introductions
7.2.6. Aspect instantiation models

7
7.2.7. Example
7.3. Schema-based AOP support
7.3.1. Declaring an aspect
7.3.2. Declaring a pointcut
7.3.3. Declaring advice
7.3.3.1. Before advice
7.3.3.2. After returning advice
7.3.3.3. After throwing advice
7.3.3.4. After (finally) advice
7.3.3.5. Around advice
7.3.3.6. Advice parameters
7.3.3.7. Advice ordering
7.3.4. Introductions
7.3.5. Aspect instantiation models
7.3.6. Advisors
7.3.7. Example
7.4. Choosing which AOP declaration style to use
7.4.1. Spring AOP or full AspectJ?
7.4.2. @AspectJ or XML for Spring AOP?
7.5. Mixing aspect types
7.6. Proxying mechanisms
7.6.1. Understanding AOP proxies
7.7. Programmatic creation of @AspectJ Proxies
7.8. Using AspectJ with Spring applications
7.8.1. Using AspectJ to dependency inject domain objects with Spring
7.8.1.1. Unit testing @Configurable objects
7.8.1.2. Working with multiple application contexts
7.8.2. Other Spring aspects for AspectJ
7.8.3. Configuring AspectJ aspects using Spring IoC
7.8.4. Load-time weaving with AspectJ in the Spring Framework
7.8.4.1. A first example
7.8.4.2. Aspects
7.8.4.3. 'META-INF/aop.xml'
7.8.4.4. Required libraries (JARS)
7.8.4.5. Spring configuration
7.8.4.6. Environment-specific configuration
7.9. Further Resources
8. Spring AOP APIs
8.1. Introduction
8.2. Pointcut API in Spring
8.2.1. Concepts

8
8.2.2. Operations on pointcuts
8.2.3. AspectJ expression pointcuts
8.2.4. Convenience pointcut implementations
8.2.4.1. Static pointcuts
8.2.4.2. Dynamic pointcuts
8.2.5. Pointcut superclasses
8.2.6. Custom pointcuts
8.3. Advice API in Spring
8.3.1. Advice lifecycles
8.3.2. Advice types in Spring
8.3.2.1. Interception around advice
8.3.2.2. Before advice
8.3.2.3. Throws advice
8.3.2.4. After Returning advice
8.3.2.5. Introduction advice
8.4. Advisor API in Spring
8.5. Using the ProxyFactoryBean to create AOP proxies
8.5.1. Basics
8.5.2. JavaBean properties
8.5.3. JDK- and CGLIB-based proxies
8.5.4. Proxying interfaces
8.5.5. Proxying classes
8.5.6. Using 'global' advisors
8.6. Concise proxy definitions
8.7. Creating AOP proxies programmatically with the ProxyFactory
8.8. Manipulating advised objects
8.9. Using the "autoproxy" facility
8.9.1. Autoproxy bean definitions
8.9.1.1. BeanNameAutoProxyCreator
8.9.1.2. DefaultAdvisorAutoProxyCreator
8.9.1.3. AbstractAdvisorAutoProxyCreator
8.9.2. Using metadata-driven auto-proxying
8.10. Using TargetSources
8.10.1. Hot swappable target sources
8.10.2. Pooling target sources
8.10.3. Prototype target sources
8.10.4. ThreadLocal target sources
8.11. Defining new Advice types
8.12. Further resources
9. Testing
9.1. Introduction to testing

9
9.2. Unit testing
9.2.1. Mock objects
9.2.1.1. JNDI
9.2.1.2. Servlet API
9.2.1.3. Portlet API
9.2.2. Unit testing support classes
9.2.2.1. General utilities
9.2.2.2. Spring MVC
9.3. Integration testing
9.3.1. Overview
9.3.2. Goals of integration testing
9.3.2.1. Context management and caching
9.3.2.2. Dependency Injection of test fixtures
9.3.2.3. Transaction management
9.3.2.4. Support classes for integration testing
9.3.3. JDBC testing support
9.3.4. Annotations
9.3.5. Spring TestContext Framework
9.3.5.1. Key abstractions
9.3.5.2. Context management and caching
9.3.5.3. Dependency Injection of test fixtures
9.3.5.4. Transaction management
9.3.5.5. TestContext support classes
9.3.6. PetClinic example
9.4. Further Resources
IV. Data Access
10. Transaction Management
10.1. Introduction to Spring Framework transaction management
10.2. Advantages of the Spring Framework's transaction support model
10.2.1. Global transactions
10.2.2. Local transactions
10.2.3. Spring Framework's consistent programming model
10.3. Understanding the Spring Framework transaction abstraction
10.4. Synchronizing resources with transactions
10.4.1. High-level synchronization approach
10.4.2. Low-level synchronization approach
10.4.3. TransactionAwareDataSourceProxy
10.5. Declarative transaction management
10.5.1. Understanding the Spring Framework's declarative transaction
implementation
10.5.2. Example of declarative transaction implementation

10
10.5.3. Rolling back a declarative transaction
10.5.4. Configuring different transactional semantics for different beans
10.5.5. <tx:advice/> settings
10.5.6. Using @Transactional
10.5.6.1. @Transactional settings
10.5.6.2. Multiple Transaction Managers with @Transactional
10.5.6.3. Custom shortcut annotations
10.5.7. Transaction propagation
10.5.7.1. Required
10.5.7.2. RequiresNew
10.5.7.3. Nested
10.5.8. Advising transactional operations
10.5.9. Using @Transactional with AspectJ
10.6. Programmatic transaction management
10.6.1. Using the TransactionTemplate
10.6.1.1. Specifying transaction settings
10.6.2. Using the PlatformTransactionManager
10.7. Choosing between programmatic and declarative transaction
management
10.8. Application server-specific integration
10.8.1. IBM WebSphere
10.8.2. BEA WebLogic Server
10.8.3. Oracle OC4J
10.9. Solutions to common problems
10.9.1. Use of the wrong transaction manager for a specific DataSource
10.10. Further Resources
11. DAO support
11.1. Introduction
11.2. Consistent exception hierarchy
11.3. Annotations used for configuring DAO or Repository classes
12. Data access with JDBC
12.1. Introduction to Spring Framework JDBC
12.1.1. Choosing an approach for JDBC database access
12.1.2. Package hierarchy
12.2. Using the JDBC core classes to control basic JDBC processing and
error handling
12.2.1. JdbcTemplate
12.2.1.1. Examples of JdbcTemplate class usage
12.2.1.2. JdbcTemplate best practices
12.2.2. NamedParameterJdbcTemplate
12.2.3. SimpleJdbcTemplate

11
12.2.4. SQLExceptionTranslator
12.2.5. Executing statements
12.2.6. Running queries
12.2.7. Updating the database
12.2.8. Retrieving auto-generated keys
12.3. Controlling database connections
12.3.1. DataSource
12.3.2. DataSourceUtils
12.3.3. SmartDataSource
12.3.4. AbstractDataSource
12.3.5. SingleConnectionDataSource
12.3.6. DriverManagerDataSource
12.3.7. TransactionAwareDataSourceProxy
12.3.8. DataSourceTransactionManager
12.3.9. NativeJdbcExtractor
12.4. JDBC batch operations
12.4.1. Batch operations with the JdbcTemplate
12.4.2. Batch operations with the SimpleJdbcTemplate
12.5. Simplifying JDBC operations with the SimpleJdbc classes
12.5.1. Inserting data using SimpleJdbcInsert
12.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
12.5.3. Specifying columns for a SimpleJdbcInsert
12.5.4. Using SqlParameterSource to provide parameter values
12.5.5. Calling a stored procedure with SimpleJdbcCall
12.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall
12.5.7. How to define SqlParameters
12.5.8. Calling a stored function using SimpleJdbcCall
12.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
12.6. Modeling JDBC operations as Java objects
12.6.1. SqlQuery
12.6.2. MappingSqlQuery
12.6.3. SqlUpdate
12.6.4. StoredProcedure
12.7. Common problems with parameter and data value handling
12.7.1. Providing SQL type information for parameters
12.7.2. Handling BLOB and CLOB objects
12.7.3. Passing in lists of values for IN clause
12.7.4. Handling complex types for stored procedure calls
12.8. Embedded database support
12.8.1. Why use an embedded database?
12.8.2. Creating an embedded database instance using Spring XML

12
12.8.3. Creating an embedded database instance programmatically
12.8.4. Extending the embedded database support
12.8.5. Using HSQL
12.8.6. Using H2
12.8.7. Using Derby
12.8.8. Testing data access logic with an embedded database
12.9. Initializing a DataSource
12.9.1. Initializing a database instance using Spring XML
12.9.1.1. Initialization of Other Components that Depend on the Database
13. Object Relational Mapping (ORM) Data Access
13.1. Introduction to ORM with Spring
13.2. General ORM integration considerations
13.2.1. Resource and transaction management
13.2.2. Exception translation
13.3. Hibernate
13.3.1. SessionFactory setup in a Spring container
13.3.2. Implementing DAOs based on plain Hibernate 3 API
13.3.3. Declarative transaction demarcation
13.3.4. Programmatic transaction demarcation
13.3.5. Transaction management strategies
13.3.6. Comparing container-managed and locally defined resources
13.3.7. Spurious application server warnings with Hibernate
13.4. JDO
13.4.1. PersistenceManagerFactory setup
13.4.2. Implementing DAOs based on the plain JDO API
13.4.3. Transaction management
13.4.4. JdoDialect
13.5. JPA
13.5.1. Three options for JPA setup in a Spring environment
13.5.1.1. LocalEntityManagerFactoryBean
13.5.1.2. Obtaining an EntityManagerFactory from JNDI
13.5.1.3. LocalContainerEntityManagerFactoryBean
13.5.1.4. Dealing with multiple persistence units
13.5.2. Implementing DAOs based on plain JPA
13.5.3. Transaction Management
13.5.4. JpaDialect
13.6. iBATIS SQL Maps
13.6.1. Setting up the SqlMapClient
13.6.2. Using SqlMapClientTemplate and SqlMapClientDaoSupport
13.6.3. Implementing DAOs based on plain iBATIS API
14. Marshalling XML using O/X Mappers

13
14.1. Introduction
14.2. Marshaller and Unmarshaller
14.2.1. Marshaller
14.2.2. Unmarshaller
14.2.3. XmlMappingException
14.3. Using Marshaller and Unmarshaller
14.4. XML Schema-based Configuration
14.5. JAXB
14.5.1. Jaxb2Marshaller
14.5.1.1. XML Schema-based Configuration
14.6. Castor
14.6.1. CastorMarshaller
14.6.2. Mapping
14.7. XMLBeans
14.7.1. XmlBeansMarshaller
14.7.1.1. XML Schema-based Configuration
14.8. JiBX
14.8.1. JibxMarshaller
14.8.1.1. XML Schema-based Configuration
14.9. XStream
14.9.1. XStreamMarshaller
V. The Web
15. Web MVC framework
15.1. Introduction to Spring Web MVC framework
15.1.1. Features of Spring Web MVC
15.1.2. Pluggability of other MVC implementations
15.2. The DispatcherServlet
15.3. Implementing Controllers
15.3.1. Defining a controller with @Controller
15.3.2. Mapping requests with @RequestMapping
15.3.2.1. URI Templates
15.3.2.2. Advanced @RequestMapping options
15.3.2.3. Supported handler method arguments and return types
15.3.2.4. Binding request parameters to method parameters with
@RequestParam
15.3.2.5. Mapping the request body with the @RequestBody annotation
15.3.2.6. Mapping the response body with the @ResponseBody annotation
15.3.2.7. Using HttpEntity<?>
15.3.2.8. Providing a link to data from the model with @ModelAttribute
15.3.2.9. Specifying attributes to store in a session with @SessionAttributes
15.3.2.10. Mapping cookie values with the @CookieValue annotation

14
15.3.2.11. Mapping request header attributes with the @RequestHeader
annotation
15.3.2.12. Customizing WebDataBinder initialization
15.4. Handler mappings
15.4.1. Intercepting requests - the HandlerInterceptor interface
15.5. Resolving views
15.5.1. Resolving views with the ViewResolver interface
15.5.2. Chaining ViewResolvers
15.5.3. Redirecting to views
15.5.3.1. RedirectView
15.5.3.2. The redirect: prefix
15.5.3.3. The forward: prefix
15.5.4. ContentNegotiatingViewResolver
15.6. Using locales
15.6.1. AcceptHeaderLocaleResolver
15.6.2. CookieLocaleResolver
15.6.3. SessionLocaleResolver
15.6.4. LocaleChangeInterceptor
15.7. Using themes
15.7.1. Overview of themes
15.7.2. Defining themes
15.7.3. Theme resolvers
15.8. Spring's multipart (fileupload) support
15.8.1. Introduction
15.8.2. Using the MultipartResolver
15.8.3. Handling a file upload in a form
15.9. Handling exceptions
15.9.1. HandlerExceptionResolver
15.9.2. @ExceptionHandler
15.10. Convention over configuration support
15.10.1. The Controller ControllerClassNameHandlerMapping
15.10.2. The Model ModelMap (ModelAndView)
15.10.3. The View - RequestToViewNameTranslator
15.11. ETag support
15.12. Configuring Spring MVC
15.12.1. mvc:annotation-driven
15.12.2. mvc:interceptors
15.12.3. mvc:view-controller
15.12.4. mvc:resources
15.12.5. mvc:default-servlet-handler
15.13. More Spring Web MVC Resources

15
16. View technologies
16.1. Introduction
16.2. JSP & JSTL
16.2.1. View resolvers
16.2.2. 'Plain-old' JSPs versus JSTL
16.2.3. Additional tags facilitating development
16.2.4. Using Spring's form tag library
16.2.4.1. Configuration
16.2.4.2. The form tag
16.2.4.3. The input tag
16.2.4.4. The checkbox tag
16.2.4.5. The checkboxes tag
16.2.4.6. The radiobutton tag
16.2.4.7. The radiobuttons tag
16.2.4.8. The password tag
16.2.4.9. The select tag
16.2.4.10. The option tag
16.2.4.11. The options tag
16.2.4.12. The textarea tag
16.2.4.13. The hidden tag
16.2.4.14. The errors tag
16.2.4.15. HTTP Method Conversion
16.3. Tiles
16.3.1. Dependencies
16.3.2. How to integrate Tiles
16.3.2.1. UrlBasedViewResolver
16.3.2.2. ResourceBundleViewResolver
16.3.2.3. SimpleSpringPreparerFactory and SpringBeanPreparerFactory
16.4. Velocity & FreeMarker
16.4.1. Dependencies
16.4.2. Context configuration
16.4.3. Creating templates
16.4.4. Advanced configuration
16.4.4.1. velocity.properties
16.4.4.2. FreeMarker
16.4.5. Bind support and form handling
16.4.5.1. The bind macros
16.4.5.2. Simple binding
16.4.5.3. Form input generation macros
16.4.5.4. HTML escaping and XHTML compliance
16.5. XSLT

16
16.5.1. My First Words
16.5.1.1. Bean definitions
16.5.1.2. Standard MVC controller code
16.5.1.3. Convert the model data to XML
16.5.1.4. Defining the view properties
16.5.1.5. Document transformation
16.5.2. Summary
16.6. Document views (PDF/Excel)
16.6.1. Introduction
16.6.2. Configuration and setup
16.6.2.1. Document view definitions
16.6.2.2. Controller code
16.6.2.3. Subclassing for Excel views
16.6.2.4. Subclassing for PDF views
16.7. JasperReports
16.7.1. Dependencies
16.7.2. Configuration
16.7.2.1. Configuring the ViewResolver
16.7.2.2. Configuring the Views
16.7.2.3. About Report Files
16.7.2.4. Using JasperReportsMultiFormatView
16.7.3. Populating the ModelAndView
16.7.4. Working with Sub-Reports
16.7.4.1. Configuring Sub-Report Files
16.7.4.2. Configuring Sub-Report Data Sources
16.7.5. Configuring Exporter Parameters
16.8. Feed Views
16.9. XML Marshalling View
16.10. JSON Mapping View
17. Integrating with other web frameworks
17.1. Introduction
17.2. Common configuration
17.3. JavaServer Faces 1.1 and 1.2
17.3.1. DelegatingVariableResolver (JSF 1.1/1.2)
17.3.2. SpringBeanVariableResolver (JSF 1.1/1.2)
17.3.3. SpringBeanFacesELResolver (JSF 1.2+)
17.3.4. FacesContextUtils
17.4. Apache Struts 1.x and 2.x
17.4.1. ContextLoaderPlugin
17.4.1.1. DelegatingRequestProcessor
17.4.1.2. DelegatingActionProxy

17
17.4.2. ActionSupport Classes
17.5. WebWork 2.x
17.6. Tapestry 3.x and 4.x
17.6.1. Injecting Spring-managed beans
17.6.1.1. Dependency Injecting Spring Beans into Tapestry pages
17.6.1.2. Component definition files
17.6.1.3. Adding abstract accessors
17.6.1.4. Dependency Injecting Spring Beans into Tapestry pages - Tapestry
4.x style
17.7. Further Resources
18. Portlet MVC Framework
18.1. Introduction
18.1.1. Controllers - The C in MVC
18.1.2. Views - The V in MVC
18.1.3. Web-scoped beans
18.2. The DispatcherPortlet
18.3. The ViewRendererServlet
18.4. Controllers
18.4.1. AbstractController and PortletContentGenerator
18.4.2. Other simple controllers
18.4.3. Command Controllers
18.4.4. PortletWrappingController
18.5. Handler mappings
18.5.1. PortletModeHandlerMapping
18.5.2. ParameterHandlerMapping
18.5.3. PortletModeParameterHandlerMapping
18.5.4. Adding HandlerInterceptors
18.5.5. HandlerInterceptorAdapter
18.5.6. ParameterMappingInterceptor
18.6. Views and resolving them
18.7. Multipart (file upload) support
18.7.1. Using the PortletMultipartResolver
18.7.2. Handling a file upload in a form
18.8. Handling exceptions
18.9. Annotation-based controller configuration
18.9.1. Setting up the dispatcher for annotation support
18.9.2. Defining a controller with @Controller
18.9.3. Mapping requests with @RequestMapping
18.9.4. Supported handler method arguments
18.9.5. Binding request parameters to method parameters with
@RequestParam

18
18.9.6. Providing a link to data from the model with @ModelAttribute
18.9.7. Specifying attributes to store in a Session with @SessionAttributes
18.9.8. Customizing WebDataBinder initialization
18.9.8.1. Customizing data binding with @InitBinder
18.9.8.2. Configuring a custom WebBindingInitializer
18.10. Portlet application deployment
VI. Integration
19. Remoting and web services using Spring
19.1. Introduction
19.2. Exposing services using RMI
19.2.1. Exporting the service using the RmiServiceExporter
19.2.2. Linking in the service at the client
19.3. Using Hessian or Burlap to remotely call services via HTTP
19.3.1. Wiring up the DispatcherServlet for Hessian and co.
19.3.2. Exposing your beans by using the HessianServiceExporter
19.3.3. Linking in the service on the client
19.3.4. Using Burlap
19.3.5. Applying HTTP basic authentication to a service exposed through
Hessian or Burlap
19.4. Exposing services using HTTP invokers
19.4.1. Exposing the service object
19.4.2. Linking in the service at the client
19.5. Web services
19.5.1. Exposing servlet-based web services using JAX-RPC
19.5.2. Accessing web services using JAX-RPC
19.5.3. Registering JAX-RPC Bean Mappings
19.5.4. Registering your own JAX-RPC Handler
19.5.5. Exposing servlet-based web services using JAX-WS
19.5.6. Exporting standalone web services using JAX-WS
19.5.7. Exporting web services using the JAX-WS RI's Spring support
19.5.8. Accessing web services using JAX-WS
19.6. JMS
19.6.1. Server-side configuration
19.6.2. Client-side configuration
19.7. Auto-detection is not implemented for remote interfaces
19.8. Considerations when choosing a technology
19.9. Accessing RESTful services on the Client
19.9.1. RestTemplate
19.9.1.1. Dealing with request and response headers
19.9.2. HTTP Message Conversion
19.9.2.1. StringHttpMessageConverter

19
19.9.2.2. FormHttpMessageConverter
19.9.2.3. ByteArrayMessageConverter
19.9.2.4. MarshallingHttpMessageConverter
19.9.2.5. MappingJacksonHttpMessageConverter
19.9.2.6. SourceHttpMessageConverter
19.9.2.7. BufferedImageHttpMessageConverter
20. Enterprise JavaBeans (EJB) integration
20.1. Introduction
20.2. Accessing EJBs
20.2.1. Concepts
20.2.2. Accessing local SLSBs
20.2.3. Accessing remote SLSBs
20.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
20.3. Using Spring's EJB implementation support classes
20.3.1. EJB 2.x base classes
20.3.2. EJB 3 injection interceptor
21. JMS (Java Message Service)
21.1. Introduction
21.2. Using Spring JMS
21.2.1. JmsTemplate
21.2.2. Connections
21.2.2.1. Caching Messaging Resources
21.2.2.2. SingleConnectionFactory
21.2.2.3. CachingConnectionFactory
21.2.3. Destination Management
21.2.4. Message Listener Containers
21.2.4.1. SimpleMessageListenerContainer
21.2.4.2. DefaultMessageListenerContainer
21.2.5. Transaction management
21.3. Sending a Message
21.3.1. Using Message Converters
21.3.2. SessionCallback and ProducerCallback
21.4. Receiving a message
21.4.1. Synchronous Reception
21.4.2. Asynchronous Reception - Message-Driven POJOs
21.4.3. The SessionAwareMessageListener interface
21.4.4. The MessageListenerAdapter
21.4.5. Processing messages within transactions
21.5. Support for JCA Message Endpoints
21.6. JMS Namespace Support
22. JMX

20
22.1. Introduction
22.2. Exporting your beans to JMX
22.2.1. Creating an MBeanServer
22.2.2. Reusing an existing MBeanServer
22.2.3. Lazy-initialized MBeans
22.2.4. Automatic registration of MBeans
22.2.5. Controlling the registration behavior
22.3. Controlling the management interface of your beans
22.3.1. The MBeanInfoAssembler Interface
22.3.2. Using Source-Level Metadata (JDK 5.0 annotations)
22.3.3. Source-Level Metadata Types
22.3.4. The AutodetectCapableMBeanInfoAssembler interface
22.3.5. Defining management interfaces using Java interfaces
22.3.6. Using MethodNameBasedMBeanInfoAssembler
22.4. Controlling the ObjectNames for your beans
22.4.1. Reading ObjectNames from Properties
22.4.2. Using the MetadataNamingStrategy
22.4.3. The <context:mbean-export/> element
22.5. JSR-160 Connectors
22.5.1. Server-side Connectors
22.5.2. Client-side Connectors
22.5.3. JMX over Burlap/Hessian/SOAP
22.6. Accessing MBeans via Proxies
22.7. Notifications
22.7.1. Registering Listeners for Notifications
22.7.2. Publishing Notifications
22.8. Further Resources
23. JCA CCI
23.1. Introduction
23.2. Configuring CCI
23.2.1. Connector configuration
23.2.2. ConnectionFactory configuration in Spring
23.2.3. Configuring CCI connections
23.2.4. Using a single CCI connection
23.3. Using Spring's CCI access support
23.3.1. Record conversion
23.3.2. The CciTemplate
23.3.3. DAO support
23.3.4. Automatic output record generation
23.3.5. Summary
23.3.6. Using a CCI Connection and Interaction directly

21
23.3.7. Example for CciTemplate usage
23.4. Modeling CCI access as operation objects
23.4.1. MappingRecordOperation
23.4.2. MappingCommAreaOperation
23.4.3. Automatic output record generation
23.4.4. Summary
23.4.5. Example for MappingRecordOperation usage
23.4.6. Example for MappingCommAreaOperation usage
23.5. Transactions
24. Email
24.1. Introduction
24.2. Usage
24.2.1. Basic MailSender and SimpleMailMessage usage
24.2.2. Using the JavaMailSender and the MimeMessagePreparator
24.3. Using the JavaMail MimeMessageHelper
24.3.1. Sending attachments and inline resources
24.3.1.1. Attachments
24.3.1.2. Inline resources
24.3.2. Creating email content using a templating library
24.3.2.1. A Velocity-based example
25. Task Execution and Scheduling
25.1. Introduction
25.2. The Spring TaskExecutor abstraction
25.2.1. TaskExecutor types
25.2.2. Using a TaskExecutor
25.3. The Spring TaskScheduler abstraction
25.3.1. The Trigger interface
25.3.2. Trigger implementations
25.3.3. TaskScheduler implementations
25.4. The Task Namespace
25.4.1. The 'scheduler' element
25.4.2. The 'executor' element
25.4.3. The 'scheduled-tasks' element
25.5. Annotation Support for Scheduling and Asynchronous Execution
25.5.1. The @Scheduled Annotation
25.5.2. The @Async Annotation
25.5.3. The <annotation-driven> Element
25.6. Using the OpenSymphony Quartz Scheduler
25.6.1. Using the JobDetailBean
25.6.2. Using the MethodInvokingJobDetailFactoryBean
25.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean

22
25.7. Using JDK Timer support
25.7.1. Creating custom timers
25.7.2. Using the MethodInvokingTimerTaskFactoryBean
25.7.3. Wrapping up: setting up the tasks using the TimerFactoryBean
26. Dynamic language support
26.1. Introduction
26.2. A first example
26.3. Defining beans that are backed by dynamic languages
26.3.1. Common concepts
26.3.1.1. The <lang:language/> element
26.3.1.2. Refreshable beans
26.3.1.3. Inline dynamic language source files
26.3.1.4. Understanding Constructor Injection in the context of dynamic-
language-backed beans
26.3.2. JRuby beans
26.3.3. Groovy beans
26.3.3.1. Customising Groovy objects via a callback
26.3.4. BeanShell beans
26.4. Scenarios
26.4.1. Scripted Spring MVC Controllers
26.4.2. Scripted Validators
26.5. Bits and bobs
26.5.1. AOP - advising scripted beans
26.5.2. Scoping
26.6. Further Resources
VII. Appendices
A. Classic Spring Usage
A.1. Classic ORM usage
A.1.1. Hibernate
A.1.1.1. The HibernateTemplate
A.1.1.2. Implementing Spring-based DAOs without callbacks
A.1.2. JDO
A.1.2.1. JdoTemplate and JdoDaoSupport
A.1.3. JPA
A.1.3.1. 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

23
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
B.1.4.1. Static pointcuts
B.1.4.2. 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
B.2.2.1. Interception around advice
B.2.2.2. Before advice
B.2.2.3. Throws advice
B.2.2.4. After Returning advice
B.2.2.5. 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.1.1. BeanNameAutoProxyCreator
B.8.1.2. DefaultAdvisorAutoProxyCreator
B.8.1.3. AbstractAdvisorAutoProxyCreator
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

24
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.2.1. <util:constant/>
C.2.2.2. <util:property-path/>
C.2.2.3. <util:properties/>
C.2.2.4. <util:list/>
C.2.2.5. <util:map/>
C.2.2.6. <util:set/>
C.2.3. The jee schema
C.2.3.1. <jee:jndi-lookup/> (simple)
C.2.3.2. <jee:jndi-lookup/> (with single JNDI environment setting)
C.2.3.3. <jee:jndi-lookup/> (with multiple JNDI environment settings)
C.2.3.4. <jee:jndi-lookup/> (complex)
C.2.3.5. <jee:local-slsb/> (simple)
C.2.3.6. <jee:local-slsb/> (complex)
C.2.3.7. <jee:remote-slsb/>
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.8.1. <property-placeholder/>
C.2.8.2. <annotation-config/>
C.2.8.3. <component-scan/>
C.2.8.4. <load-time-weaver/>
C.2.8.5. <spring-configured/>
C.2.8.6. <mbean-export/>
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'

25
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

26
Part I. Overview of Spring Framework
The Spring Framework is a lightweight solution and a potential one-stop-shop for
building your enterprise-ready applications. However, Spring is modular, allowing
you to use only those parts that you need, without having to bring in the rest. You
can use the IoC container, with Struts on top, but you can also use only
the Hibernate integration code or the JDBC abstraction layer. The Spring
Framework supports declarative transaction management, remote access to your
logic through RMI or web services, and various options for persisting your data. It
offers a full-featured MVC framework, and enables you to
integrate AOP transparently into your software.

Spring is designed to be non-intrusive, meaning that your domain logic code

generally has no dependencies on the framework itself. In your integration layer
(such as the data access layer), some dependencies on the data access
technology and the Spring libraries will exist. However, it should be easy to isolate
these dependencies from the rest of your code base.

This document is a reference guide to Spring Framework features. If you have any
requests, comments, or questions on this document, please post them on the user
mailing list or on the support forums at http://forum.springsource.org/.

1. Introduction to Spring Framework

Spring Framework is a Java platform that provides comprehensive infrastructure

support for developing Java applications. Spring handles the infrastructure so you
can focus on your application.

Spring enables you to build applications from “plain old Java objects” (POJOs) and
to apply enterprise services non-invasively to POJOs. This capability applies to the
Java SE programming model and to full and partial Java EE.

Examples of how you, as an application developer, can use the Spring platform
advantage:

 Make a Java method execute in a database transaction without having to

deal with transaction APIs.
 Make a local Java method a remote procedure without having to deal with
remote APIs.

27
 Make a local Java method a management operation without having to deal
with JMX APIs.

 Make a local Java method a message handler without having to deal with
JMS APIs.

1.1 Dependency Injection and Inversion of Control

Background

“The question is, what aspect of control are [they] inverting?” Martin Fowler posed this question about
Inversion of Control (IoC) on his site in 2004. Fowler suggested renaming the principle to make it more
self-explanatory and came up with Dependency Injection.

For insight into IoC and DI, refer to Fowler's article athttp://martinfowler.com/articles/injection.html.

Java applications -- a loose term that runs the gamut from constrained applets to
n-tier server-side enterprise applications -- typically consist of objects that
collaborate to form the application proper. Thus the objects in an application
have dependencies on each other.

Although the Java platform provides a wealth of application development

functionality, it lacks the means to organize the basic building blocks into a
coherent whole, leaving that task to architects and developers. True, you can use
design patterns such as Factory,Abstract Factory, Builder, Decorator, and Service
Locator to compose the various classes and object instances that make up an
application. However, these patterns are simply that: best practices given a name,
with a description of what the pattern does, where to apply it, the problems it
addresses, and so forth. Patterns are formalized best practices that you must
implement yourself in your application.

The Spring Framework Inversion of Control (IoC) component addresses this

concern by providing a formalized means of composing disparate components into
a fully working application ready for use. The Spring Framework codifies
formalized design patterns as first-class objects that you can integrate into your
own application(s). Numerous organizations and institutions use the Spring
Framework in this manner to engineer robust,maintainable applications.

1.2 Modules

The Spring Framework consists of features organized into about 20 modules.

These modules are grouped into Core Container, Data Access/Integration, Web,

28
AOP (Aspect Oriented Programming), Instrumentation, and Test, as shown in the
following diagram.

Overview of the Spring Framework

1.2.1 Core Container

The Core Container consists of the Core, Beans, Context, and Expression

Language modules.

The Core and Beans modules provide the fundamental parts of the framework,

including the IoC and Dependency Injection features. TheBeanFactory is a
sophisticated implementation of the factory pattern. It removes the need for
programmatic singletons and allows you to decouple the configuration and
specification of dependencies from your actual program logic.

The Context module builds on the solid base provided by the Core and

Beans modules: it is a means to access objects in a framework-style manner that
is similar to a JNDI registry. The Context module inherits its features from the

29
Beans module and adds support for internationalization (using, for example,
resource bundles), event-propagation, resource-loading, and the transparent
creation of contexts by, for example, a servlet container. The Context module also
supports Java EE features such as EJB, JMX ,and basic remoting.
The ApplicationContext interface is the focal point of the Context module.

The Expression Language module provides a powerful expression language for

querying and manipulating an object graph at runtime. It is an extension of the
unified expression language (unified EL) as specified in the JSP 2.1 specification.
The language supports setting and getting property values, property assignment,
method invocation, accessing the context of arrays, collections and indexers,
logical and arithmetic operators, named variables, and retrieval of objects by name
from Spring's IoC container. It also supports list projection and selection as well as
common list aggregations.

1.2.2 Data Access/Integration

The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and

Transaction modules.

The JDBC module provides a JDBC-abstraction layer that removes the need to do

tedious JDBC coding and parsing of database-vendor specific error codes.

The ORM module provides integration layers for popular object-relational mapping

APIs, including JPA, JDO, Hibernate, and iBatis. Using the ORM package you can
use all of these O/R-mapping frameworks in combination with all of the other
features Spring offers, such as the simple declarative transaction management
feature mentioned previously.

The OXM module provides an abstraction layer that supports Object/XML mapping

implementations for JAXB, Castor, XMLBeans, JiBX and XStream.

The Java Messaging Service (JMS) module contains features for producing and
consuming messages.

The Transaction module supports programmatic and declarative transaction

management for classes that implement special interfaces and for all your POJOs
(plain old Java objects).

30
1.2.3 Web

The Web layer consists of the Web, Web-Servlet, Web-Struts, and Web-Portlet

modules.

Spring's Web module provides basic web-oriented integration features such as

multipart file-upload functionality and the initialization of the IoC container using
servlet listeners and a web-oriented application context. It also contains the web-
related parts of Spring's remoting support.

The Web-Servlet module contains Spring's model-view-controller (MVC)

implementation for web applications. Spring's MVC framework provides a clean
separation between domain model code and web forms, and integrates with all the
other features of the Spring Framework.

The Web-Struts module contains the support classes for integrating a classic

Struts web tier within a Spring application. Note that this support is now
deprecated as of Spring 3.0. Consider migrating your application to Struts 2.0 and
its Spring integration or to a Spring MVC solution.

The Web-Portlet module provides the MVC implementation to be used in a portlet

environment and mirrors the functionality of Web-Servlet module.

1.2.4 AOP and Instrumentation

Spring's AOP module provides an AOP Alliance-compliant aspect-oriented

programming implementation allowing you to define, for example, method-
interceptors and pointcuts to cleanly decouple code that implements functionality
that should be separated. Using source-level metadata functionality, you can also
incorporate behavioral information into your code, in a manner similar to that of
.NET attributes.

The separate Aspects module provides integration with AspectJ.

The Instrumentation module provides class instrumentation support and

classloader implementations to be used in certain application servers.

1.2.5 Test

The Test module supports the testing of Spring components with JUnit or TestNG.

It provides consistent loading of Spring ApplicationContexts and caching of those

31
contexts. It also provides mock objects that you can use to test your code in
isolation.

1.3 Usage scenarios

The building blocks described previously make Spring a logical choice in many
scenarios, from applets to full-fledged enterprise applications that use Spring's
transaction management functionality and web framework integration.

Typical full-fledged Spring web application

Spring's declarative transaction management features make the web application

fully transactional, just as it would be if you used EJB container-managed
transactions. All your custom business logic can be implemented with simple
POJOs and managed by Spring's IoC container. Additional services include
support for sending email and validation that is independent of the web layer,

32
which lets you choose where to execute validation rules. Spring's ORM support is
integrated with JPA, Hibernate, JDO and iBatis; for example, when using
Hibernate, you can continue to use your existing mapping files and standard
Hibernate SessionFactory configuration. Form controllers seamlessly integrate the
web-layer with the domain model, removing the need for ActionForms or other
classes that transform HTTP parameters to values for your domain model.

Spring middle-tier using a third-party web framework

Sometimes circumstances do not allow you to completely switch to a different

framework. The Spring Framework does not force you to use everything within it; it
is not an all-or-nothing solution. Existing front-ends built with WebWork, Struts,
Tapestry, or other UI frameworks can be integrated with a Spring-based middle-
tier, which allows you to use Spring transaction features. You simply need to wire
up your business logic using an ApplicationContext and use
a WebApplicationContext to integrate your web layer.

33
Remoting usage scenario

When you need to access existing code through web services, you can use
Spring's Hessian-, Burlap-, Rmi- or JaxRpcProxyFactory classes. Enabling remote
access to existing applications is not difficult.

34
EJBs - Wrapping existing POJOs

The Spring Framework also provides an access and abstraction layer for

Enterprise JavaBeans, enabling you to reuse your existing POJOs and wrap them
in stateless session beans for use in scalable, fail-safe web applications that might
need declarative security.

1.3.1 Dependency Management and Naming Conventions

Dependency management and dependency injection are different things. To get

those nice features of Spring into your application (like dependency injection) you
need to assemble all the libraries needed (jar files) and get them onto your
classpath at runtime, and possibly at compile time. These dependencies are not
virtual components that are injected, but physical resources in a file system
(typically). The process of dependency management involves locating those
resources, storing them and adding them to classpaths. Dependencies can be
direct (e.g. my application depends on Spring at runtime), or indirect (e.g. my
application depends on commons-dbcp which depends on commons-pool). The indirect
dependencies are also known as "transitive" and it is those dependencies that are
hardest to identify and manage.

35
If you are going to use Spring you need to get a copy of the jar libraries that
comprise the pieces of Spring that you need. To make this easier Spring is
packaged as a set of modules that separate the dependencies as much as
possible, so for example if you don't want to write a web application you don't need
the spring-web modules. To refer to Spring library modules in this guide we use a
shorthand naming convention spring-* or spring-*.jar, where "*" represents the
short name for the module (e.g. spring-core, spring-webmvc, spring-jms, etc.). The
actual jar file name that you use may be in this form (see below) or it may not, and
normally it also has a version number in the file name (e.g. spring-core-
3.0.0.RELEASE.jar).

In general, Spring publishes its artifacts to four different places:

 On the community download

site http://www.springsource.org/downloads/community. Here you find all the
Spring jars bundled together into a zip file for easy download. The names of
the jars here since version 3.0 are in the form org.springframework.*-
<version>.jar.
 Maven Central, which is the default repository that Maven queries, and does
not require any special configuration to use. Many of the common libraries
that Spring depends on also are available from Maven Central and a large
section of the Spring community uses Maven for dependency management,
so this is convenient for them. The names of the jars here are in the
form spring-*-<version>.jar and the Maven groupId is org.springframework.

 The Enterprise Bundle Repository (EBR), which is run by SpringSource and

also hosts all the libraries that integrate with Spring. Both Maven and Ivy
repositories are available here for all Spring jars and their dependencies,
plus a large number of other common libraries that people use in
applications with Spring. Both full releases and also milestones and
development snapshots are deployed here. The names of the jar files are in
the same form as the community download (org.springframework.*-
<version>.jar), and the dependencies are also in this "long" form, with
external libraries (not from SpringSource) having the prefix com.springsource.
See the FAQ for more information.

 In a public Maven repository hosted on Amazon S3 for development

snapshots and milestone releases (a copy of the final releases is also held
here). The jar file names are in the same form as Maven Central, so this is a
useful place to get development versions of Spring to use with other libraries
depoyed in Maven Central.

36
So the first thing you need to decide is how to manage your dependencies: most
people use an automated system like Maven or Ivy, but you can also do it
manually by downloading all the jars yourself. When obtaining Spring with Maven
or Ivy you have then to decide which place you'll get it from. In general, if you care
about OSGi, use the EBR, since it houses OSGi compatible artifacts for all of
Spring's dependencies, such as Hibernate and Freemarker. If OSGi does not
matter to you, either place works, though there are some pros and cons between
them. In general, pick one place or the other for your project; do not mix them. This
is particularly important since EBR artifacts necessarily use a different naming
convention than Maven Central artifacts.

Table 1.1. Comparison of Maven Central and SpringSource EBR Repositories

Maven Central EBR

e Not explicit Yes
Tens of thousands; all kinds Hundreds; those that Spring integrates with

No Yes

Varies. Newer artifacts often use domain name,

e.g. org.slf4j. Older ones often just use the Domain name of origin or main package root, e.g. org.springframework
artifact name, e.g. log4j.
Bundle Symbolic Name, derived from the main package root, e.g.
Varies. Generally the project or module name,
org.springframework.beans. If the jar had to be patched to ensure OSGi
using a hyphen "-" separator, e.g. spring-core,
compliance then com.springsource is appended, e.g.
logj4.
com.springsource.org.apache.log4j
Varies. Many new artifacts use m.m.m or
m.m.m.X (with m=digit, X=text). Older ones OSGi version number m.m.m.X, e.g. 3.0.0.RC3. The text qualifier imposes
use m.m. Some neither. Ordering is defined but alphabetic ordering on versions with the same numeric values.
not often relied on, so not strictly reliable.
Usually automatic via rsync or source control
updates. Project authors can upload individual Manual (JIRA processed by SpringSource)
jars to JIRA.
Extensive for OSGi manifest, Maven POM and Ivy metadata. QA performed
By policy. Accuracy is responsibility of authors.
Spring team.
Contegix. Funded by Sonatype with several
S3 funded by SpringSource.
mirrors.
Various http://www.springsource.com/repository
Integration through STS with Maven
Extensive integration through STS with Maven, Roo, CloudFoundry
dependency management

37
1.3.1.1 Spring Dependencies and Depending on Spring

Although Spring provides integration and support for a huge range of enterprise
and other external tools, it intentionally keeps its mandatory dependencies to an
absolute minimum: you shouldn't have to locate and download (even
automatically) a large number of jar libraries in order to use Spring for simple use
cases. For basic dependency injection there is only one mandatory external
dependency, and that is for logging (see below for a more detailed description of
logging options).

Next we outline the basic steps needed to configure an application that depends
on Spring, first with Maven and then with Ivy. In all cases, if anything is unclear,
refer to the documentation of your dependency management system, or look at
some sample code - Spring itself uses Ivy to manage dependencies when it is
building, and our samples mostly use Maven.

1.3.1.2 Maven Dependency Management

If you are using Maven for dependency management you don't even need to
supply the logging dependency explicitly. For example, to create an application
context and use dependency injection to configure an application, your Maven
dependencies will look like this:

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.0.0.RELEASE</version>
<scope>runtime</scope>
</dependency>
</dependencies>

That's it. Note the scope can be declared as runtime if you don't need to compile
against Spring APIs, which is typically the case for basic dependency injection use
cases.

We used the Maven Central naming conventions in the example above, so that
works with Maven Central or the SpringSource S3 Maven repository. To use the
S3 Maven repository (e.g. for milestones or developer snaphots), you need to
specify the repository location in your Maven configuration. For full releases:

38
<repositories>
<repository>
<id>com.springsource.repository.maven.release</id>
<url>http://maven.springframework.org/release/</url>
<snapshots><enabled>false</enabled></snapshots>
</repository>
</repositories>

For milestones:

<repositories>
<repository>
<id>com.springsource.repository.maven.milestone</id>
<url>http://maven.springframework.org/milestone/</url>
<snapshots><enabled>false</enabled></snapshots>
</repository>
</repositories>

And for snapshots:

<repositories>
<repository>
<id>com.springsource.repository.maven.snapshot</id>
<url>http://maven.springframework.org/snapshot/</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
</repositories>

To use the SpringSource EBR you would need to use a different naming
convention for the dependencies. The names are usually easy to guess, e.g. in
this case it is:

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>org.springframework.context</artifactId>
<version>3.0.0.RELEASE</version>
<scope>runtime</scope>
</dependency>
</dependencies>

You also need to declare the location of the repository explicitly (only the URL is
important):

39
<repository>
<id>com.springsource.repository.bundles.release</id>
<url>http://repository.springsource.com/maven/bundles/release/</url>
</repository>
</repositories>

If you are managing your dependencies by hand, the URL in the repository
declaration above is not browseable, but there is a user interface
athttp://www.springsource.com/repository that can be used to search for and
download dependencies. It also has handy snippets of Maven and Ivy
configuration that you can copy and paste if you are using those tools.

1.3.1.3 Ivy Dependency Management

If you prefer to use Ivy to manage dependencies then there are similar names and
configuration options.

To configure Ivy to point to the SpringSource EBR add the following resolvers to
your ivysettings.xml:

</url>

</url>

</resolvers>

The XML above is not valid because the lines are too long - if you copy-paste then
remove the extra line endings in the middle of the url patterns.

Once Ivy is configured to look in the EBR adding a dependency is easy. Simply
pull up the details page for the bundle in question in the repository browser and

40
you'll find an Ivy snippet ready for you to include in your dependencies section. For
example (in ivy.xml):

<dependency org="org.springframework"
name="org.springframework.core" rev="3.0.0.RELEASE" conf="compile-
>runtime"/>

1.3.2 Logging

Logging is a very important dependency for Spring because a) it is the only

mandatory external dependency, b) everyone likes to see some output from the
tools they are using, and c) Spring integrates with lots of other tools all of which
have also made a choice of logging dependency. One of the goals of an
application developer is often to have unified logging configured in a central place
for the whole application, including all external components. This is more difficult
than it might have been since there are so many choices of logging framework.

The mandatory logging dependency in Spring is the Jakarta Commons Logging

API (JCL). We compile against JCL and we also make JCL Logobjects visible for
classes that extend the Spring Framework. It's important to users that all versions
of Spring use the same logging library: migration is easy because backwards
compatibility is preserved even with applications that extend Spring. The way we
do this is to make one of the modules in Spring depend explicitly on commons-
logging (the canonical implementation of JCL), and then make all the other
modules depend on that at compile time. If you are using Maven for example, and
wondering where you picked up the dependency on commons-logging, then it is from
Spring and specifically from the central module called spring-core.

The nice thing about commons-logging is that you don't need anything else to make
your application work. It has a runtime discovery algorithm that looks for other
logging frameworks in well known places on the classpath and uses one that it
thinks is appropriate (or you can tell it which one if you need to). If nothing else is
available you get pretty nice looking logs just from the JDK (java.util.logging or JUL
for short). You should find that your Spring application works and logs happily to
the console out of the box in most situations, and that's important.

1.3.2.1 Not Using Commons Logging

Unfortunately, the runtime discovery algorithm in commons-logging, while convenient

for the end-user, is problematic. If we could turn back the clock and start Spring
now as a new project it would use a different logging dependency. The first choice

41
would probably be the Simple Logging Facade for Java (SLF4J), which is also
used by a lot of other tools that people use with Spring inside their applications.

Switching off commons-logging is easy: just make sure it isn't on the classpath at

runtime. In Maven terms you exclude the dependency, and because of the way
that the Spring dependencies are declared, you only have to do that once.

Now this application is probably broken because there is no implementation of the

JCL API on the classpath, so to fix it a new one has to be provided. In the next
section we show you how to provide an alternative implementation of JCL using
SLF4J as an example.

1.3.2.2 Using SLF4J

SLF4J is a cleaner dependency and more efficient at runtime than commons-

logging because it uses compile-time bindings instead of runtime discovery of the
other logging frameworks it integrates. This also means that you have to be more
explicit about what you want to happen at runtime, and declare it or configure it
accordingly. SLF4J provides bindings to many common logging frameworks, so
you can usually choose one that you already use, and bind to that for configuration
and management.

SLF4J provides bindings to many common logging frameworks, including JCL, and
it also does the reverse: bridges between other logging frameworks and itself. So
to use SLF4J with Spring you need to replace the commons-logging dependency with
the SLF4J-JCL bridge. Once you have done that then logging calls from within
Spring will be translated into logging calls to the SLF4J API, so if other libraries in
your application use that API, then you have a single place to configure and
manage logging.

42
A common choice might be to bridge Spring to SLF4J, and then provide explicit
binding from SLF4J to Log4J. You need to supply 4 dependencies (and exclude
the existing commons-logging): the bridge, the SLF4J API, the binding to Log4J, and
the Log4J implementation itself. In Maven you would do that like this

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.0.0.RELEASE</version>
<scope>runtime</scope>
<exclusions>
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.5.8</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.5.8</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.5.8</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
<scope>runtime</scope>
</dependency>
</dependencies>

That might seem like a lot of dependencies just to get some logging. Well it is, but
it is optional, and it should behave better than the vanilla commons-logging with
respect to classloader issues, notably if you are in a strict container like an OSGi
platform. Allegedly there is also a performance benefit because the bindings are at
compile-time not runtime.

43
A more common choice amongst SLF4J users, which uses fewer steps and
generates fewer dependencies, is to bind directly to Logback. This removes the
extra binding step because Logback implements SLF4J directly, so you only need
to depend on two libaries not four (jcl-over-slf4jand logback). If you do that you
might also need to exlude the slf4j-api dependency from other external
dependencies (not Spring), because you only want one version of that API on the
classpath.

1.3.2.3 Using Log4J

Many people use Log4j as a logging framework for configuration and management

purposes. It's efficient and well-established, and in fact it's what we use at runtime
when we build and test Spring. Spring also provides some utilities for configuring
and initializing Log4j, so it has an optional compile-time dependency on Log4j in
some modules.

To make Log4j work with the default JCL dependency ( commons-logging) all you
need to do is put Log4j on the classpath, and provide it with a configuration file
(log4j.properties or log4j.xml in the root of the classpath). So for Maven users this
is your dependency declaration:

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.0.0.RELEASE</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
<scope>runtime</scope>
</dependency>
</dependencies>

And here's a sample log4j.properties for logging to the console:

log4j.rootCategory=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n

log4j.category.org.springframework.beans.factory=DEBUG

44
Runtime Containers with Native JCL

Many people run their Spring applications in a container that itself provides an
implementation of JCL. IBM Websphere Application Server (WAS) is the
archetype. This often causes problems, and unfortunately there is no silver bullet
solution; simply excluding commons-logging from your application is not enough in
most situations.

To be clear about this: the problems reported are usually not with JCL per se, or
even with commons-logging: rather they are to do with binding commons-logging to
another framework (often Log4J). This can fail because commons-logging changed
the way they do the runtime discovery in between the older versions (1.0) found in
some containers and the modern versions that most people use now (1.1). Spring
does not use any unusual parts of the JCL API, so nothing breaks there, but as
soon as Spring or your application tries to do any logging you can find that the
bindings to Log4J are not working.

In such cases with WAS the easiest thing to do is to invert the class loader
hierarchy (IBM calls it "parent last") so that the application controls the JCL
dependency, not the container. That option isn't always open, but there are plenty
of other suggestions in the public domain for alternative approaches, and your
mileage may vary depending on the exact version and feature set of the container.

Part II. What's New in Spring 3.0

2. New Features and Enhancements in Spring 3.0

If you have been using the Spring Framework for some time, you will be aware
that Spring has undergone two major revisions: Spring 2.0, released in October
2006, and Spring 2.5, released in November 2007. It is now time for a third
overhaul resulting in Spring 3.0.
Java SE and Java EE Support

The Spring Framework is now based on Java 5, and Java 6 is fully supported.

Furthermore, Spring is compatible with J2EE 1.4 and Java EE 5, while at the same time introducing some
early support for Java EE 6.

45
2.1 Java 5

The entire framework code has been revised to take advantage of Java 5 features
like generics, varargs and other language improvements. We have done our best
to still keep the code backwards compatible. We now have consistent use of
generic Collections and Maps, consistent use of generic FactoryBeans, and also
consistent resolution of bridge methods in the Spring AOP API. Generic
ApplicationListeners automatically receive specific event types only. All callback
interfaces such as TransactionCallback and HibernateCallback declare a generic
result value now. Overall, the Spring core codebase is now freshly revised and
optimized for Java 5.

Spring's TaskExecutor abstraction has been updated for close integration with
Java 5's java.util.concurrent facilities. We provide first-class support for Callables
and Futures now, as well as ExecutorService adapters, ThreadFactory integration,
etc. This has been aligned with JSR-236 (Concurrency Utilities for Java EE 6) as
far as possible. Furthermore, we provide support for asynchronous method
invocations through the use of the new @Async annotation (or EJB 3.1's
@Asynchronous annotation).

2.2 Improved documentation

The Spring reference documentation has also substantially been updated to reflect
all of the changes and new features for Spring 3.0. While every effort has been
made to ensure that there are no errors in this documentation, some errors may
nevertheless have crept in. If you do spot any typos or even more serious errors,
and you can spare a few cycles during lunch, please do bring the error to the
attention of the Spring team by raising an issue.

2.3 New articles and tutorials

There are many excellent articles and tutorials that show how to get started with
Spring 3 features. Read them at the Spring Documentation page.

The samples have been improved and updated to take advantage of the new
features in Spring 3. Additionally, the samples have been moved out of the source
tree into a dedicated SVN repository available at:
https://anonsvn.springframework.org/svn/spring-samples/

As such, the samples are no longer distributed alongside Spring 3 and need to be downloaded
separately from the repository mentioned above. However, this documentation will continue to refer to
some samples (in particular Petclinic) to illustrate various features.

46
Note
For more information on Subversion (or in short SVN), see the project homepage
at: http://subversion.apache.org/

2.4 New module organization and build system

The framework modules have been revised and are now managed separately with
one source-tree per module jar:

 org.springframework.aop
 org.springframework.beans

 org.springframework.context

 org.springframework.context.support

 org.springframework.expression

 org.springframework.instrument

 org.springframework.jdbc

 org.springframework.jms

 org.springframework.orm

 org.springframework.oxm

 org.springframework.test

 org.springframework.transaction

 org.springframework.web

 org.springframework.web.portlet

 org.springframework.web.servlet

 org.springframework.web.struts
Note:

The spring.jar artifact that contained almost the entire framework is no longer provided.

47
We are now using a new Spring build system as known from Spring Web Flow 2.0.
This gives us:

 Ivy-based "Spring Build" system

 consistent deployment procedure

 consistent dependency management

 consistent generation of OSGi manifests

2.5 Overview of new features

This is a list of new features for Spring 3.0. We will cover these features in more
detail later in this section.

 Spring Expression Language

 IoC enhancements/Java based bean metadata

 General-purpose type conversion system and field formatting system

 Object to XML mapping functionality (OXM) moved from Spring Web

Services project

 Comprehensive REST support

 @MVC additions

 Declarative model validation

 Early support for Java EE 6

 Embedded database support

2.5.1 Core APIs updated for Java 5

BeanFactory interface returns typed bean instances as far as possible:

 T getBean(Class<T> requiredType)
 T getBean(String name, Class<T> requiredType)

 Map<String, T> getBeansOfType(Class<T> type)

Spring's TaskExecutor interface now extends java.util.concurrent.Executor:

48
 extended AsyncTaskExecutor supports standard Callables with Futures

New Java 5 based converter API and SPI:

 stateless ConversionService and Converters

 superseding standard JDK PropertyEditors

Typed ApplicationListener<E>

2.5.2 Spring Expression Language

Spring introduces an expression language which is similar to Unified EL in its

syntax but offers significantly more features. The expression language can be
used when defining XML and Annotation based bean definitions and also serves
as the foundation for expression language support across the Spring portfolio.
Details of this new functionality can be found in the chapter Spring Expression
Language (SpEL).

The Spring Expression Language was created to provide the Spring community a
single, well supported expression language that can be used across all the
products in the Spring portfolio. Its language features are driven by the
requirements of the projects in the Spring portfolio, including tooling requirements
for code completion support within the Eclipse based SpringSource Tool Suite.

The following is an example of how the Expression Language can be used to

configure some properties of a database setup

This functionality is also available if you prefer to configure your components using
annotations:

@Repository
public class RewardsTestDatabase {

@Value("#{systemProperties.databaseName}")
public void setDatabaseName(String dbName) { … }

@Value("#{strategyBean.databaseKeyGenerator}")

49
public void setKeyGenerator(KeyGenerator kg) { … }
}

2.5.3 The Inversion of Control (IoC) container

2.5.3.1 Java based bean metadata

Some core features from the JavaConfig project have been added to the Spring
Framework now. This means that the following annotations are now directly
supported:

 @Configuration
 @Bean

 @DependsOn

 @Primary

 @Lazy

 @Import

 @ImportResource

 @Value

Here is an example of a Java class providing basic configuration using the new
JavaConfig features:

package org.example.config;

@Configuration
public class AppConfig {
private @Value("#{jdbcProperties.url}") String jdbcUrl;
private @Value("#{jdbcProperties.username}") String username;
private @Value("#{jdbcProperties.password}") String password;

@Bean
public FooService fooService() {
return new FooServiceImpl(fooRepository());
}

@Bean
public FooRepository fooRepository() {
return new HibernateFooRepository(sessionFactory());
}

50
@Bean
public SessionFactory sessionFactory() {
// wire up a session factory
AnnotationSessionFactoryBean asFactoryBean =
new AnnotationSessionFactoryBean();
asFactoryBean.setDataSource(dataSource());
// additional config
return asFactoryBean.getObject();
}

@Bean
public DataSource dataSource() {
return new DriverManagerDataSource(jdbcUrl, username, password);
}
}

To get this to work you need to add the following component scanning entry in
your minimal application context XML file.

<context:component-scan base-package="org.example.config"/>
<util:properties id="jdbcProperties"
location="classpath:org/example/config/jdbc.properties"/>

Or you can bootstrap a @Configuration class directly

using AnnotationConfigApplicationContext:

public static void main(String[] args) {

ApplicationContext ctx = new
AnnotationConfigApplicationContext(AppConfig.class);
FooService fooService = ctx.getBean(FooService.class);
fooService.doStuff();
}

See Section 3.11.2, “Instantiating the Spring container using

AnnotationConfigApplicationContext” for full information
onAnnotationConfigApplicationContext.

2.5.3.2 Defining bean metadata within components

@Bean annotated methods are also supported inside Spring components. They

contribute a factory bean definition to the container. See Defining bean metadata
within components for more information

51
2.5.4 General purpose type conversion system and field formatting system

A general purpose type conversion system has been introduced. The system is

currently used by SpEL for type conversion, and may also be used by a Spring
Container and DataBinder when binding bean property values.

In addition, a formatter SPI has been introduced for formatting field values. This
SPI provides a simpler and more robust alternative to JavaBean PropertyEditors
for use in client environments such as Spring MVC.

2.5.5 The Data Tier

Object to XML mapping functionality (OXM) from the Spring Web Services project
has been moved to the core Spring Framework now. The functionality is found in
the org.springframework.oxm package. More information on the use of
the OXM module can be found in the Marshalling XML using O/X Mappers chapter.

2.5.6 The Web Tier

The most exciting new feature for the Web Tier is the support for building RESTful
web services and web applications. There are also some new annotations that can
be used in any web application.

2.5.6.1 Comprehensive REST support

Server-side support for building RESTful applications has been provided as an

extension of the existing annotation driven MVC web framework. Client-side
support is provided by the RestTemplate class in the spirit of other template classes
such as JdbcTemplate and JmsTemplate. Both server and client side REST
functionality make use of HttpConverters to facilitate the conversion between
objects and their representation in HTTP requests and responses.

The MarshallingHttpMessageConverter uses the Object to XML mapping functionality

mentioned earlier.

Refer to the sections on MVC and the RestTemplate for more information.

2.5.6.2 @MVC additions

A mvc namespace has been introduced that greatly simplifies Spring MVC

configuration.

52
Additional annotations such as @CookieValue and @RequestHeaders have been added.
See Mapping cookie values with the @CookieValue annotation and Mapping
request header attributes with the @RequestHeader annotation for more
information.

2.5.7 Declarative model validation

Several validation enhancements, including JSR 303 support that uses Hibernate

Validator as the default provider.

2.5.8 Early support for Java EE 6

We provide support for asynchronous method invocations through the use of the
new @Async annotation (or EJB 3.1's @Asynchronous annotation).

JSR 303, JSF 2.0, JPA 2.0, etc

2.5.9 Support for embedded databases

Convenient support for embedded Java database engines, including HSQL, H2,

and Derby, is now provided.

Part III. Core Technologies
This part of the reference documentation covers all of those technologies that are
absolutely integral to the Spring Framework.

Foremost amongst these is the Spring Framework's Inversion of Control (IoC)

container. A thorough treatment of the Spring Framework's IoC container is closely
followed by comprehensive coverage of Spring's Aspect-Oriented Programming
(AOP) technologies. The Spring Framework has its own AOP framework, which is
conceptually easy to understand, and which successfully addresses the 80%
sweet spot of AOP requirements in Java enterprise programming.

Coverage of Spring's integration with AspectJ (currently the richest - in terms of

features - and certainly most mature AOP implementation in the Java enterprise
space) is also provided.

Finally, the adoption of the test-driven-development (TDD) approach to software

development is certainly advocated by the Spring team, and so coverage of
Spring's support for integration testing is covered (alongside best practices for unit
testing). The Spring team has found that the correct use of IoC certainly does

53
make both unit and integration testing easier (in that the presence of setter
methods and appropriate constructors on classes makes them easier to wire
together in a test without having to set up service locator registries and suchlike)...
the chapter dedicated solely to testing will hopefully convince you of this as well.

 Chapter 3, The IoC container

 Chapter 4, Resources

 Chapter 5, Validation, Data Binding, and Type Conversion

 Chapter 6, Spring Expression Language (SpEL)

 Chapter 7, Aspect Oriented Programming with Spring

 Chapter 8, Spring AOP APIs

 Chapter 9, Testing

3. The IoC container

3.1 Introduction to the Spring IoC container and beans

This chapter covers the Spring Framework implementation of the Inversion of

Control (IoC) [1]principle. IoC is also known as dependency injection(DI). It is a
process whereby objects define their dependencies, that is, the other objects they
work with, only through constructor arguments, arguments to a factory method, or
properties that are set on the object instance after it is constructed or returned
from a factory method. The container then injects those dependencies when it
creates the bean. This process is fundamentally the inverse, hence the
name Inversion of Control (IoC), of the bean itself controlling the instantiation or
location of its dependencies by using direct construction of classes, or a
mechanism such as the Service Locator pattern.

The org.springframework.beans and org.springframework.context packages are the

basis for Spring Framework's IoC container. TheBeanFactory interface provides an
advanced configuration mechanism capable of managing any type of
object. ApplicationContext is a sub-interface of BeanFactory. It adds easier
integration with Spring's AOP features; message resource handling (for use in
internationalization), event publication; and application-layer specific contexts such
as the WebApplicationContext for use in web applications.

54
In short, the BeanFactory provides the configuration framework and basic
functionality, and the ApplicationContext adds more enterprise-specific
functionality. The ApplicationContext is a complete superset of the BeanFactory, and
is used exclusively in this chapter in descriptions of Spring's IoC container. For
more information on using the BeanFactory instead of the ApplicationContext, refer
to Section 3.14, “The BeanFactory”.

In Spring, the objects that form the backbone of your application and that are
managed by the Spring IoC container are called beans. A bean is an object that is
instantiated, assembled, and otherwise managed by a Spring IoC container.
Otherwise, a bean is simply one of many objects in your application. Beans, and
the dependencies among them, are reflected in the configuration metadata used
by a container.

3.2 Container overview

The interface org.springframework.context.ApplicationContext represents the Spring

IoC container and is responsible for instantiating, configuring, and assembling the
aforementioned beans. The container gets its instructions on what objects to
instantiate, configure, and assemble by reading configuration metadata. The
configuration metadata is represented in XML, Java annotations, or Java code. It
allows you to express the objects that compose your application and the rich
interdependencies between such objects.

Several implementations of the ApplicationContext interface are supplied out-of-

the-box with Spring. In standalone applications it is common to create an instance
of ClassPathXmlApplicationContext or FileSystemXmlApplicationContext. While XML
has been the traditional format for defining configuration metadata you can instruct
the container to use Java annotations or code as the metadata format by providng
a small amount of XML configuration to declaratively enable support for these
additional metadata formats.

In most application scenarios, explicit user code is not required to instantiate one
or more instances of a Spring IoC container. For example, in a web application
scenario, a simple eight (or so) lines of boilerplate J2EE web descriptor XML in
the web.xml file of the application will typically suffice (see Section 3.13.4,
“Convenient ApplicationContext instantiation for web applications”). If you are
using the SpringSource Tool SuiteEclipse-powered development environment
or Spring Roo this boilerplate configuration can be easily created with few mouse
clicks or keystrokes.

55
The following diagram is a high-level view of how Spring works. Your application
classes are combined with configuration metadata so that after
theApplicationContext is created and initialized, you have a fully configured and
executable system or application.

The Spring IoC container

3.2.1 Configuration metadata

As the preceding diagram shows, the Spring IoC container consumes a form
of configuration metadata; this configuration metadata represents how you as an
application developer tell the Spring container to instantiate, configure, and
assemble the objects in your application.

Configuration metadata is traditionally supplied in a simple and intuitive XML format, which is what
most of this chapter uses to convey key concepts and features of the Spring IoC container.

Note

XML-based metadata is not the only allowed form of configuration metadata. The Spring IoC
container itself is totallydecoupled from the format in which this configuration metadata is
actually written.

For information about using other forms of metadata with the Spring container,
see:

56
 Annotation-based configuration: Spring 2.5 introduced support for
annotation-based configuration metadata.
 Java-based configuration: Starting with Spring 3.0, many features provided
by the Spring JavaConfig project became part of the core Spring
Framework. Thus you can define beans external to your application classes
by using Java rather than XML files. To use these new features, see
the @Configuration, @Bean, @Import and @DependsOn annotations.

Spring configuration consists of at least one and typically more than one bean
definition that the container must manage. XML-based configuration metadata
shows these beans configured as <bean/> elements inside a top-
level <beans/> element.

These bean definitions correspond to the actual objects that make up your
application. Typically you define service layer objects, data access objects
(DAOs), presentation objects such as Struts Action instances, infrastructure
objects such as Hibernate SessionFactories, JMS Queues, and so forth. Typically one
does not configure fine-grained domain objects in the container, because it is
usually the responsibility of DAOs and business logic to create and load domain
objects. However, you can use Spring's integration with AspectJ to configure
objects that have been created outside the control of an IoC container. See Using
AspectJ to dependency-inject domain objects with Spring.

The following example shows the basic structure of XML-based configuration

metadata:

<?xml version="1.0" encoding="UTF-8"?>

<bean id="..." class="...">

</bean>

<bean id="..." class="...">

</bean>

</beans>

57
The id attribute is a string that you use to identify the individual bean definition.
The class attribute defines the type of the bean and uses the fully qualified
classname. The value of the id attribute refers to collaborating objects. The XML
for referring to collaborating objects is not shown in this example;
see Dependencies for more information.

3.2.2 Instantiating a container

Instantiating a Spring IoC container is straightforward. The location path or paths

supplied to an ApplicationContext constructor are actually resource strings that
allow the container to load configuration metadata from a variety of external
resources such as the local file system, from the Java CLASSPATH, and so on.

ApplicationContext context =
new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});

Note

After you learn about Spring's IoC container, you may want to know more about
Spring's Resource abstraction, as described inChapter 4, Resources, which provides a convenient
mechanism for reading an InputSream from locations defined in a URI syntax. In
particular, Resource paths are used to construct applications contexts as described in Section 4.7,
“Application contexts and Resource paths”.

The following example shows the service layer objects (services.xml) configuration

file:

<?xml version="1.0" encoding="UTF-8"?>

<bean id="petStore"

class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl">
<property name="accountDao" ref="accountDao"/>
<property name="itemDao" ref="itemDao"/>

</bean>

</beans>

58
The following example shows the data access objects daos.xml file:

<?xml version="1.0" encoding="UTF-8"?>

</beans>

In the preceding example, the service layer consists of the

class PetStoreServiceImpl, and two data access objects of the
type SqlMapAccountDaoand SqlMapItemDao are based on
the iBatis Object/Relational mapping framework. The property name element refers
to the name of the JavaBean property, and the ref element refers to the name of
another bean definition. This linkage between id and ref elements expresses the
dependency between collaborating objects. For details of configuring an object's
dependencies, see Dependencies.

3.2.2.1 Composing XML-based configuration metadata

It can be useful to have bean definitions span multiple XML files. Often each
individual XML configuration file represents a logical layer or module in your
architecture.

You can use the application context constructor to load bean definitions from all
these XML fragments. This constructor takes multiple Resourcelocations, as was
shown in the previous section. Alternatively, use one or more occurrences of
the <import/> element to load bean definitions from another file or files. For
example:

<beans>

59
<import resource="resources/messageSource.xml"/>
<import resource="/resources/themeSource.xml"/>

<bean id="bean1" class="..."/>

</beans>

In the preceding example, external bean definitions are loaded from three
files, services.xml, messageSource.xml, and themeSource.xml. All location paths
are relative to the definition file doing the importing, so services.xml must be in the
same directory or classpath location as the file doing the importing,
while messageSource.xml and themeSource.xml must be in a resources location
below the location of the importing file. As you can see, a leading slash is ignored,
but given that these paths are relative, it is better form not to use the slash at all.
The contents of the files being imported, including the top level <beans/> element,
must be valid XML bean definitions according to the Spring Schema or DTD.

Note
It is possible, but not recommended, to reference files in parent directories using a relative "../"
path. Doing so creates a dependency on a file that is outside the current application. In particular,
this reference is not recommended for "classpath:" URLs (for example,
"classpath:../services.xml"), where the runtime resolution process chooses the "nearest" classpath
root and then looks into its parent directory. Classpath configuration changes may lead to the
choice of a different, incorrect directory.

You can always use fully qualified resource locations instead of relative paths: for example,
"file:C:/config/services.xml" or "classpath:/config/services.xml". However, be aware that you are
coupling your application's configuration to specific absolute locations. It is generally preferable
to keep an indirection for such absolute locations, for example, through "${...}" placeholders that
are resolved against JVM system properties at runtime.

3.2.3 Using the container

The ApplicationContext is the interface for an advanced factory capable of

maintaining a registry of different beans and their dependencies. Using the
method T getBean(Stringname, Class<T> requiredType) you can retrieve instances of
your beans.

The ApplicationContext enables you to read bean definitions and access them as

follows:

// create and configure beans

ApplicationContext context =

60
new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});

// retrieve configured instance

PetStoreServiceImpl service = context.getBean("petStore",
PetStoreServiceImpl.class);

// use configured instance

List userList service.getUsernameList();

You use getBean() to retrieve instances of your beans.

The ApplicationContext interface has a few other methods for retrieving beans, but
ideally your application code should never use them. Indeed, your application code
should have no calls to the getBean() method at all, and thus no dependency on
Spring APIs at all. For example, Spring's integration with web frameworks provides
for dependency injection for various web framework classes such as controllers
and JSF-managed beans.

3.3 Bean overview

A Spring IoC container manages one or more beans. These beans are created
with the configuration metadata that you supply to the container, for example, in
the form of XML <bean/> definitions.

Within the container itself, these bean definitions are represented

as BeanDefinition objects, which contain (among other information) the following
metadata:

 A package-qualified class name: typically the actual implementation class of

the bean being defined.
 Bean behavioral configuration elements, which state how the bean should
behave in the container (scope, lifecycle callbacks, and so forth).

 References to other beans that are needed for the bean to do its work; these
references are also called collaborators or dependencies.

 Other configuration settings to set in the newly created object, for example,
the number of connections to use in a bean that manages a connection pool,
or the size limit of the pool.

This metadata translates to a set of properties that make up each bean definition.

Table 3.1. The bean definition

61
Property Explained in...

Section 3.3.2, “Instantiating beans”

Section 3.3.1, “Naming beans”

Section 3.5, “Bean scopes”

ments
Section 3.4.1, “Dependency injection”

Section 3.4.1, “Dependency injection”

e
Section 3.4.5, “Autowiring collaborators”
n mode
Section 3.4.4, “Lazy-initialized beans”
thod
Section 3.6.1.1, “Initialization callbacks”
od
Section 3.6.1.2, “Destruction callbacks”

In addition to bean definitions that contain information on how to create a specific

bean, the ApplicationContext implementations also permit the registration of
existing objects that are created outside the container, by users. This is done by
accessing the ApplicationContext's BeanFactory via the
method getBeanFactory() which returns the BeanFactory
implementation DefaultListableBeanFactory. DefaultListableBeanFactorysupports this
registration through the
methods registerSingleton(..) and registerBeanDefinition(..). However, typical
applications work solely with beans defined through metadata bean definitions.

3.3.1 Naming beans

Every bean has one or more identifiers. These identifiers must be unique within
the container that hosts the bean. A bean usually has only one identifier, but if it
requires more than one, the extra ones can be considered aliases.

In XML-based configuration metadata, you use the id and/or name attributes to

specify the bean identifier(s). The id attribute allows you to specify exactly one id,
and because it is a real XML element ID attribute, the XML parser can do some
extra validation when other elements reference the id. As such, it is the preferred
way to specify a bean identifier. However, the XML specification does limit the

62
characters that are legal in XML ids. This is usually not a constraint, but if you
need to use one of these special XML characters, or want to introduce other
aliases to the bean, you can also specify them in the name attribute, separated by a
comma (,), semicolon (;), or white space.

You are not required to supply a name or id for a bean. If no name or id is supplied
explicitly, the container generates a unique name for that bean. However, if you
want to refer to that bean by name, through the use of the ref element or Service
Location style lookup, you must provide a name. Motivations for not supplying a
name are related to using inner beans and autowiring collaborators.
Bean naming conventions

The convention is to use the standard Java convention for instance field names when naming beans. That
is, bean names start with a lowercase letter, and are camel-cased from then on. Examples of such names
would be (without quotes)'accountManager', 'accountService','userDao', 'loginController',
and so forth.

Naming beans consistently makes your configuration easier to read and understand, and if you are using
Spring AOP it helps a lot when applying advice to a set of beans related by name.

3.3.1.1 Aliasing a bean outside the bean definition

In a bean definition itself, you can supply more than one name for the bean, by
using a combination of up to one name specified by the id attribute, and any
number of other names in the name attribute. These names can be equivalent
aliases to the same bean, and are useful for some situations, such as allowing
each component in an application to refer to a common dependency by using a
bean name that is specific to that component itself.

Specifying all aliases where the bean is actually defined is not always adequate,
however. It is sometimes desirable to introduce an alias for a bean that is defined
elsewhere. This is commonly the case in large systems where configuration is split
amongst each subsystem, each subsystem having its own set of object definitions.
In XML-based configuration metadata, you can use the <alias/> element to
accomplish this.

<alias name="fromName" alias="toName"/>

In this case, a bean in the same container which is named fromName, may also after
the use of this alias definition, be referred to as toName.

63
For example, the configuration metadata for subsystem A may refer to a
DataSource via the name 'subsystemA-dataSource. The configuration metadata
for subsystem B may refer to a DataSource via the name 'subsystemB-
dataSource'. When composing the main application that uses both these
subsystems the main application refers to the DataSource via the name 'myApp-
dataSource'. To have all three names refer to the same object you add to the
MyApp configuration metadata the following aliases definitions:

<alias name="subsystemA-dataSource" alias="subsystemB-dataSource"/>

Now each component and the main application can refer to the dataSource
through a name that is unique and guaranteed not to clash with any other
definition (effectively creating a namespace), yet they refer to the same bean.

3.3.2 Instantiating beans

A bean definition essentially is a recipe for creating one or more objects. The
container looks at the recipe for a named bean when asked, and uses the
configuration metadata encapsulated by that bean definition to create (or acquire)
an actual object.

If you use XML-based configuration metadata, you specify the type (or class) of
object that is to be instantiated in the class attribute of the <bean/>element.
This class attribute, which internally is a Class property on
a BeanDefinition instance, is usually mandatory. (For exceptions,
seeSection 3.3.2.3, “Instantiation using an instance factory
method” and Section 3.7, “Bean definition inheritance”.) You use the Class property
in one of two ways:

 Typically, to specify the bean class to be constructed in the case where the
container itself directly creates the bean by calling its constructor reflectively,
somewhat equivalent to Java code using the new operator.

 To specify the actual class containing the static factory method that will be

invoked to create the object, in the less common case where the container
invokes a static, factory method on a class to create the bean. The object
type returned from the invocation of the static factory method may be the
same class or another class entirely.
Inner class names

64
If you want to configure a bean definition for a static nested class, you have to use the binaryname of the
inner class.

For example, if you have a class called Foo in thecom.example package, and this Foo class has
astatic inner class called Bar, the value of the'class' attribute on a bean definition would be...

com.example.Foo$Bar

Notice the use of the $ character in the name to separate the inner class name from the outer class name.

3.3.2.1 Instantiation with a constructor

When you create a bean by the constructor approach, all normal classes are
usable by and compatible with Spring. That is, the class being developed does not
need to implement any specific interfaces or to be coded in a specific fashion.
Simply specifying the bean class should suffice. However, depending on what type
of IoC you use for that specific bean, you may need a default (empty) constructor.

The Spring IoC container can manage virtually any class you want it to manage; it
is not limited to managing true JavaBeans. Most Spring users prefer actual
JavaBeans with only a default (no-argument) constructor and appropriate setters
and getters modeled after the properties in the container. You can also have more
exotic non-bean-style classes in your container. If, for example, you need to use a
legacy connection pool that absolutely does not adhere to the JavaBean
specification, Spring can manage it as well.

With XML-based configuration metadata you can specify your bean class as
follows:

<bean id="exampleBean" class="examples.ExampleBean"/>

<bean name="anotherExample" class="examples.ExampleBeanTwo"/>

For details about the mechanism for supplying arguments to the constructor (if
required) and setting object instance properties after the object is constructed,
see Injecting Dependencies.

3.3.2.2 Instantiation with a static factory method

When defining a bean that you create with a static factory method, you use
the class attribute to specify the class containing the static factory method and an
attribute named factory-method to specify the name of the factory method itself.
You should be able to call this method (with optional arguments as described later)

65
and return a live object, which subsequently is treated as if it had been created
through a constructor. One use for such a bean definition is to call static factories
in legacy code.

The following bean definition specifies that the bean will be created by calling a
factory-method. The definition does not specify the type (class) of the returned
object, only the class containing the factory method. In this example,
the createInstance() method must be a static method.

<bean id="clientService"
class="examples.ClientService"
factory-method="createInstance"/>
public class ClientService {
private static ClientService clientService = new ClientService();
private ClientService() {}

public static ClientService createInstance() {

return clientService;
}
}

For details about the mechanism for supplying (optional) arguments to the factory
method and setting object instance properties after the object is returned from the
factory, see Dependencies and configuration in detail.

3.3.2.3 Instantiation using an instance factory method

Similar to instantiation through a static factory method, instantiation with an

instance factory method invokes a non-static method of an existing bean from the
container to create a new bean. To use this mechanism, leave the class attribute
empty, and in the factory-bean attribute, specify the name of a bean in the current
(or parent/ancestor) container that contains the instance method that is to be
invoked to create the object. Set the name of the factory method itself with
the factory-method attribute.

<bean id="serviceLocator" class="examples.DefaultServiceLocator">

</bean>

<bean id="clientService"
factory-bean="serviceLocator"
factory-method="createClientServiceInstance"/>
public class DefaultServiceLocator {
private static ClientService clientService = new ClientServiceImpl();

66
private DefaultServiceLocator() {}

public ClientService createClientServiceInstance() {

return clientService;
}
}

One factory class can also hold more than one factory method as shown here:

<bean id="serviceLocator" class="examples.DefaultServiceLocator">

</bean>
<bean id="clientService"
factory-bean="serviceLocator"
factory-method="createClientServiceInstance"/>

<bean id="accountService"
factory-bean="serviceLocator"
factory-method="createAccountServiceInstance"/>
public class DefaultServiceLocator {
private static ClientService clientService = new ClientServiceImpl();
private static AccountService accountService = new AccountServiceImpl();

private DefaultServiceLocator() {}

public ClientService createClientServiceInstance() {

return clientService;
}

public AccountService createAccountServiceInstance() {

return accountService;
}
}

This approach shows that the factory bean itself can be managed and configured
through dependency injection (DI). See Dependencies and configuration in detail.

Note

In Spring documentation, factory bean refers to a bean that is configured in the Spring container

that will create objects through an instance or static factory method. By
contrast, FactoryBean (notice the capitalization) refers to a Spring-specificFactoryBean .

3.4 Dependencies

A typical enterprise application does not consist of a single object (or bean in the
Spring parlance). Even the simplest application has a few objects that work
together to present what the end-user sees as a coherent application. This next

67
section explains how you go from defining a number of bean definitions that stand
alone to a fully realized application where objects collaborate to achieve a goal.

3.4.1 Dependency injection

Dependency injection (DI) is a process whereby objects define their dependencies,

that is, the other objects they work with, only through constructor arguments,
arguments to a factory method, or properties that are set on the object instance
after it is constructed or returned from a factory method. The container
then injects those dependencies when it creates the bean. This process is
fundamentally the inverse, hence the name Inversion of Control (IoC), of the bean
itself controlling the instantiation or location of its dependencies on its own by
using direct construction of classes, or the Service Locator pattern.

Code is cleaner with the DI principle and decoupling is more effective when
objects are provided with their dependencies. The object does not look up its
dependencies, and does not know the location or class of the dependencies. As
such, your classes become easier to test, in particular when the dependencies are
on interfaces or abstract base classes, which allow for stub or mock
implementations to be used in unit tests.

DI exists in two major variants, Constructor-based dependency

injection and Setter-based dependency injection.

3.4.1.1 Constructor-based dependency injection

Constructor-based DI is accomplished by the container invoking a constructor with

a number of arguments, each representing a dependency. Calling a static factory
method with specific arguments to construct the bean is nearly equivalent, and this
discussion treats arguments to a constructor and to a static factory method
similarly. The following example shows a class that can only be dependency-
injected with constructor injection. Notice that there is nothing special about this
class, it is a POJO that has no dependencies on container specific interfaces, base
classes or annotations.

public class SimpleMovieLister {

// the SimpleMovieLister has a dependency on a MovieFinder

private MovieFinder movieFinder;

// a constructor so that the Spring container can 'inject' a MovieFinder

public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;

68
}

// business logic that actually 'uses' the injected MovieFinder is omitted...

}

Constructor argument resolution

Constructor argument resolution matching occurs using the argument's type. If no

potential ambiguity exists in the constructor arguments of a bean definition, then
the order in which the constructor arguments are defined in a bean definition is the
order in which those arguments are supplied to the appropriate constructor when
the bean is being instantiated. Consider the following class:

package x.y;

public class Foo {

public Foo(Bar bar, Baz baz) {

// ...
}
}

No potential ambiguity exists, assuming that Bar and Baz classes are not related by

inheritance. Thus the following configuration works fine, and you do not need to
specify the constructor argument indexes and/or types explicitly in
the <constructor-arg/> element.

<bean id="bar" class="x.y.Bar"/>

</beans>

When another bean is referenced, the type is known, and matching can occur (as
was the case with the preceding example). When a simple type is used, such
as <value>true<value>, Spring cannot determine the type of the value, and so
cannot match by type without help. Consider the following class:

package examples;

69
public class ExampleBean {

// No. of years to the calculate the Ultimate Answer

private int years;

// The Answer to Life, the Universe, and Everything

private String ultimateAnswer;

public ExampleBean(int years, String ultimateAnswer) {

this.years = years;
this.ultimateAnswer = ultimateAnswer;
}
}

Constructor argument type matching

In the preceding scenario, the container can use type matching with simple types if
you explicitly specify the type of the constructor argument using the type attribute.
For example:

<bean id="exampleBean" class="examples.ExampleBean">

<constructor-arg type="int" value="7500000"/>
<constructor-arg type="java.lang.String" value="42"/>
</bean>

Constructor argument index

Use the index attribute to specify explicitly the index of constructor arguments. For

example:

<bean id="exampleBean" class="examples.ExampleBean">

<constructor-arg index="0" value="7500000"/>
<constructor-arg index="1" value="42"/>
</bean>

In addition to resolving the ambiguity of multiple simple values, specifying an index

resolves ambiguity where a constructor has two arguments of the same type. Note
that the index is 0 based.
Constructor argument name

As of Spring 3.0 you can also use the constructor parameter name for value
disambiguation:

<bean id="exampleBean" class="examples.ExampleBean">

70
<constructor-arg name="years" value="7500000"/>
<constructor-arg name="ultimateanswer" value="42"/>
</bean>

Keep in mind that to make this work out of the box your code must be compiled
with the debug flag enabled so that Spring can look up the parameter name from
the constructor. If you can't compile your code with debug flag (or don't want to)
you can use @ConstructorProperties JDK annotation to explicitly name your
constructor arguments. The sample class would then have to look as follows:

package examples;

public class ExampleBean {

// Fields omitted

@ConstructorProperties({"years", "ultimateAnswer"})
public ExampleBean(int years, String ultimateAnswer) {
this.years = years;
this.ultimateAnswer = ultimateAnswer;
}
}

3.4.1.2 Setter-based dependency injection

Setter-based DI is accomplished by the container calling setter methods on your

beans after invoking a no-argument constructor or no-argumentstatic factory
method to instantiate your bean.

The following example shows a class that can only be dependency-injected using
pure setter injection. This class is conventional Java. It is a POJO that has no
dependencies on container specific interfaces, base classes or annotations.

public class SimpleMovieLister {

// the SimpleMovieLister has a dependency on the MovieFinder

private MovieFinder movieFinder;

// a setter method so that the Spring container can 'inject' a MovieFinder

public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}

// business logic that actually 'uses' the injected MovieFinder is omitted...

}

71
The ApplicationContext supports constructor- and setter-based DI for the beans it
manages. It also supports setter-based DI after some dependencies are already
injected through the constructor approach. You configure the dependencies in the
form of a BeanDefinition, which you use with PropertyEditor instances to convert
properties from one format to another. However, most Spring users do not work
with these classes directly (programmatically), but rather with an XML definition file
that is then converted internally into instances of these classes, and used to load
an entire Spring IoC container instance.
Constructor-based or setter-based DI?

Since you can mix both, Constructor- and Setter-based DI, it is a good rule of thumb to use constructor
arguments for mandatory dependencies and setters for optional dependencies. Note that the use of
a @Required annotation on a setter can be used to make setters required dependencies.

The Spring team generally advocates setter injection, because large numbers of constructor arguments
can get unwieldy, especially when properties are optional. Setter methods also make objects of that class
amenable to reconfiguration or re-injection later. Management through JMX MBeansis a compelling use
case.

Some purists favor constructor-based injection. Supplying all object dependencies means that the object is
always returned to client (calling) code in a totally initialized state. The disadvantage is that the object
becomes less amenable to reconfiguration and re-injection.

Use the DI that makes the most sense for a particular class. Sometimes, when dealing with third-party
classes to which you do not have the source, the choice is made for you. A legacy class may not expose
any setter methods, and so constructor injection is the only available DI.

3.4.1.3 Dependency resolution process

The container performs bean dependency resolution as follows:

1. The ApplicationContext is created and initialized with configuration metadata

that describes all the beans. Configuration metadata can be specified via
XML, Java code or annotations.
2. For each bean, its dependencies are expressed in the form of properties,
constructor arguments, or arguments to the static-factory method if you are
using that instead of a normal constructor. These dependencies are
provided to the bean, when the bean is actually created.

3. Each property or constructor argument is an actual definition of the value to

set, or a reference to another bean in the container.

4. Each property or constructor argument which is a value is converted from its

specified format to the actual type of that property or constructor argument.

72
By default Spring can convert a value supplied in string format to all built-in
types, such as int, long, String, boolean, etc.

The Spring container validates the configuration of each bean as the container is
created, including the validation of whether bean reference properties refer to valid
beans. However, the bean properties themselves are not set until the bean is
actually created. Beans that are singleton-scoped and set to be pre-instantiated
(the default) are created when the container is created. Scopes are defined
in Section 3.5, “Bean scopes” Otherwise, the bean is created only when it is
requested. Creation of a bean potentially causes a graph of beans to be created,
as the bean's dependencies and its dependencies' dependencies (and so on) are
created and assigned.
Circular dependencies

If you use predominantly constructor injection, it is possible to create an unresolvable circular dependency
scenario.

For example: Class A requires an instance of class B through constructor injection, and class B requires
an instance of class A through constructor injection. If you configure beans for classes A and B to be
injected into each other, the Spring IoC container detects this circular reference at runtime, and throws
a BeanCurrentlyInCreationException.

One possible solution is to edit the source code of some classes to be configured by setters rather than
constructors. Alternatively, avoid constructor injection and use setter injection only. In other words,
although it is not recommended, you can configure circular dependencies with setter injection.

Unlike the typical case (with no circular dependencies), a circular dependency between bean A and bean
B forces one of the beans to be injected into the other prior to being fully initialized itself (a classic
chicken/egg scenario).

You can generally trust Spring to do the right thing. It detects configuration
problems, such as references to non-existent beans and circular dependencies, at
container load-time. Spring sets properties and resolves dependencies as late as
possible, when the bean is actually created. This means that a Spring container
which has loaded correctly can later generate an exception when you request an
object if there is a problem creating that object or one of its dependencies. For
example, the bean throws an exception as a result of a missing or invalid property.
This potentially delayed visibility of some configuration issues is
why ApplicationContext implementations by default pre-instantiate singleton beans.
At the cost of some upfront time and memory to create these beans before they
are actually needed, you discover configuration issues when
the ApplicationContext is created, not later. You can still override this default
behavior so that singleton beans will lazy-initialize, rather than be pre-instantiated.

73
If no circular dependencies exist, when one or more collaborating beans are being
injected into a dependent bean, each collaborating bean is totally configured prior
to being injected into the dependent bean. This means that if bean A has a
dependency on bean B, the Spring IoC container completely configures bean B
prior to invoking the setter method on bean A. In other words, the bean is
instantiated (if not a pre-instantiated singleton), its dependencies are set, and the
relevant lifecycle methods (such as a configured init method or the IntializingBean
callback method) are invoked.

3.4.1.4 Examples of dependency injection

The following example uses XML-based configuration metadata for setter-based

DI. A small part of a Spring XML configuration file specifies some bean definitions:

<bean id="exampleBean" class="examples.ExampleBean">

<bean id="anotherExampleBean" class="examples.AnotherBean"/>

<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean {

private AnotherBean beanOne;

private YetAnotherBean beanTwo;
private int i;

public void setBeanOne(AnotherBean beanOne) {

this.beanOne = beanOne;
}

public void setBeanTwo(YetAnotherBean beanTwo) {

this.beanTwo = beanTwo;
}

public void setIntegerProperty(int i) {

this.i = i;
}
}

In the preceding example, setters are declared to match against the properties
specified in the XML file. The following example uses constructor-based DI:

74
<bean id="exampleBean" class="examples.ExampleBean">

<constructor-arg>
<ref bean="anotherExampleBean"/>
</constructor-arg>

<constructor-arg ref="yetAnotherBean"/>

<constructor-arg type="int" value="1"/>

</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>

<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean {

private AnotherBean beanOne;

private YetAnotherBean beanTwo;
private int i;

public ExampleBean(
AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
this.beanOne = anotherBean;
this.beanTwo = yetAnotherBean;
this.i = i;
}
}

The constructor arguments specified in the bean definition will be used as

arguments to the constructor of the ExampleBean.

Now consider a variant of this example, where instead of using a constructor,

Spring is told to call a static factory method to return an instance of the object:

<bean id="exampleBean" class="examples.ExampleBean"

factory-method="createInstance">
<constructor-arg ref="anotherExampleBean"/>
<constructor-arg ref="yetAnotherBean"/>
<constructor-arg value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>

<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean {

// a private constructor
private ExampleBean(...) {
...
}

// a static factory method; the arguments to this method can be

75
// considered the dependencies of the bean that is returned,
// regardless of how those arguments are actually used.
public static ExampleBean createInstance (
AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {

ExampleBean eb = new ExampleBean (...);

// some other operations...
return eb;
}
}

Arguments to the static factory method are supplied via <constructor-

arg/> elements, exactly the same as if a constructor had actually been used. The
type of the class being returned by the factory method does not have to be of the
same type as the class that contains the static factory method, although in this
example it is. An instance (non-static) factory method would be used in an
essentially identical fashion (aside from the use of the factory-bean attribute
instead of the class attribute), so details will not be discussed here.

3.4.2 Dependencies and configuration in detail

As mentioned in the previous section, you can define bean properties and
constructor arguments as references to other managed beans (collaborators), or
as values defined inline. Spring's XML-based configuration metadata supports
sub-element types within its <property/> and<constructor-arg/> elements for this
purpose.

3.4.2.1 Straight values (primitives, Strings, and so on)

The value attribute of the <property/> element specifies a property or constructor

argument as a human-readable string representation. As mentioned previously,
JavaBeans PropertyEditors are used to convert these string values from a String to
the actual type of the property or argument.

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-

method="close">

76
The following example uses the p-namespace for even more succinct XML
configuration.

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close"
p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://localhost:3306/mydb"
p:username="root"
p:password="masterkaoli"/>

</beans>

The preceding XML is more succinct; however, typos are discovered at runtime
rather than design time, unless you use an IDE such as IntelliJ IDEAor
the SpringSource Tool Suite (STS) that support automatic property completion
when you create bean definitions. Such IDE assistance is highly recommended.

You can also configure a java.util.Properties instance as:

<bean id="mappings"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="properties">
<value>
jdbc.driver.className=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb
</value>
</property>
</bean>

The Spring container converts the text inside the <value/> element into

a java.util.Properties instance by using the JavaBeans PropertyEditormechanism.
This is a nice shortcut, and is one of a few places where the Spring team do favor
the use of the nested <value/> element over thevalue attribute style.

The idref element

77
The idref element is simply an error-proof way to pass the id (string value - not a
reference) of another bean in the container to a <constructor-
arg/> or <property/> element.

<bean id="theTargetBean" class="..."/>

<bean id="theClientBean" class="...">

The above bean definition snippet is exactly equivalent (at runtime) to the following
snippet:

<bean id="theTargetBean" class="..." />

<bean id="client" class="...">

The first form is preferable to the second, because using the idref tag allows the
container to validate at deployment time that the referenced, named bean actually
exists. In the second variation, no validation is performed on the value that is
passed to the targetName property of the clientbean. Typos are only discovered
(with most likely fatal results) when the client bean is actually instantiated. If
the client bean is a prototype bean, this typo and the resulting exception may only
be discovered long after the container is deployed.

Additionally, if the referenced bean is in the same XML unit, and the bean name is
the bean id, you can use the local attribute, which allows the XML parser itself to
validate the bean id earlier, at XML document parse time.

A common place (at least in versions earlier than Spring 2.0) where the <idref/>
element brings value is in the configuration of AOP interceptors in
aProxyFactoryBean bean definition. Using <idref/> elements when you specify the
interceptor names prevents you from misspelling an interceptor id.

78
3.4.2.2 References to other beans (collaborators)

The ref element is the final element inside a <constructor-

arg/> or <property/> definition element. Here you set the value of the specified
property of a bean to be a reference to another bean (a collaborator) managed by
the container. The referenced bean is a dependency of the bean whose property
will be set, and it is initialized on demand as needed before the property is set. (If
the collaborator is a singleton bean, it may be initialized already by the container.)
All references are ultimately a reference to another object. Scoping and validation
depend on whether you specify the id/name of the other object through
the bean,local, or parent attributes.

Specifying the target bean through the bean attribute of the <ref/> tag is the most

general form, and allows creation of a reference to any bean in the same container
or parent container, regardless of whether it is in the same XML file. The value of
the bean attribute may be the same as the idattribute of the target bean, or as one
of the values in the name attribute of the target bean.

Specifying the target bean through the local attribute leverages the ability of the
XML parser to validate XML id references within the same file. The value of
the local attribute must be the same as the id attribute of the target bean. The
XML parser issues an error if no matching element is found in the same file. As
such, using the local variant is the best choice (in order to know about errors as
early as possible) if the target bean is in the same XML file.

Specifying the target bean through the parent attribute creates a reference to a

bean that is in a parent container of the current container. The value of
the parent attribute may be the same as either the id attribute of the target bean, or
one of the values in the name attribute of the target bean, and the target bean must
be in a parent container of the current one. You use this bean reference variant
mainly when you have a hierarchy of containers and you want to wrap an existing
bean in a parent container with a proxy that will have the same name as the parent
bean.

79

</bean>

<bean id="accountService" <-- bean name is the same as the parent bean -->
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target">
<ref parent="accountService"/> 
</property>

</bean>

3.4.2.3 Inner beans

A <bean/> element inside the <property/> or <constructor-arg/> elements defines a

so-called inner bean.

<bean id="outer" class="...">

<property name="target">
<bean class="com.example.Person"> 
<property name="name" value="Fiona Apple"/>
<property name="age" value="25"/>
</bean>
</property>
</bean>

An inner bean definition does not require a defined id or name; the container
ignores these values. It also ignores the scope flag. Inner beans
arealways anonymous and they are always scoped as prototypes. It is not possible
to inject inner beans into collaborating beans other than into the enclosing bean.

3.4.2.4 Collections

In the <list/>, <set/>, <map/>, and <props/> elements, you set the properties and

arguments of the Java Collection types List, Set, Map, andProperties, respectively.

<bean id="moreComplexObject" class="example.ComplexObject">

<property name="adminEmails">
<props>
<prop key="administrator">[email protected]</prop>
<prop key="support">[email protected]</prop>
<prop key="development">[email protected]</prop>
</props>
</property>

80

<property name="someList">
<list>
<value>a list element followed by a reference</value>
<ref bean="myDataSource" />
</list>
</property>

<property name="someMap">
<map>
<entry key="an entry" value="just some string"/>
<entry key ="a ref" value-ref="myDataSource"/>
</map>
</property>

<property name="someSet">
<set>
<value>just some string</value>
<ref bean="myDataSource" />
</set>
</property>
</bean>

The value of a map key or value, or a set value, can also again be any of the
following elements:

bean | ref | idref | list | set | map | props | value | null

Collection merging

As of Spring 2.0, the container supports the merging of collections. An application

developer can define a parent-style <list/>, <map/>, <set/> or<props/> element, and
have child-style <list/>, <map/>, <set/> or <props/> elements inherit and override
values from the parent collection. That is, the child collection's values are the result
of merging the elements of the parent and child collections, with the child's
collection elements overriding values specified in the parent collection.

This section on merging discusses the parent-child bean mechanism. Readers

unfamiliar with parent and child bean definitions may wish to read the relevant
section before continuing.

The following example demonstrates collection merging:

81
<props>
<prop key="administrator">[email protected]</prop>
<prop key="support">[email protected]</prop>
</props>
</property>
</bean>
<bean id="child" parent="parent">
<property name="adminEmails">

<props merge="true">
<prop key="sales">[email protected]</prop>
<prop key="support">[email protected]</prop>
</props>
</property>
</bean>
<beans>

Notice the use of the merge=true attribute on the <props/> element of

the adminEmails property of the child bean definition. When the child bean is
resolved and instantiated by the container, the resulting instance has
an adminEmails Properties collection that contains the result of the merging of the
child's adminEmails collection with the parent's adminEmails collection.

[email protected]
[email protected]
[email protected]

The child Properties collection's value set inherits all property elements from the
parent <props/>, and the child's value for the support value overrides the value in
the parent collection.

This merging behavior applies similarly to the <list/>, <map/>, and <set/> collection

types. In the specific case of the <list/> element, the semantics associated with
the List collection type, that is, the notion of an ordered collection of values, is
maintained; the parent's values precede all of the child list's values. In the case of
the Map, Set, and Properties collection types, no ordering exists. Hence no ordering
semantics are in effect for the collection types that underlie the associated Map, Set,
and Properties implementation types that the container uses internally.

Limitations of collection merging

You cannot merge different collection types (such as a Map and a List), and if you
do attempt to do so an appropriate Exception is thrown. Themerge attribute must be
specified on the lower, inherited, child definition; specifying the merge attribute on a

82
parent collection definition is redundant and will not result in the desired merging.
The merging feature is available only in Spring 2.0 and later.

Strongly-typed collection (Java 5+ only)

In Java 5 and later, you can use strongly typed collections (using generic types).
That is, it is possible to declare a Collection type such that it can only
contain String elements (for example). If you are using Spring to dependency-
inject a strongly-typed Collection into a bean, you can take advantage of Spring's
type-conversion support such that the elements of your strongly-
typed Collection instances are converted to the appropriate type prior to being
added to the Collection.

public class Foo {

private Map<String, Float> accounts;

public void setAccounts(Map<String, Float> accounts) {

this.accounts = accounts;
}
}
<beans>
<bean id="foo" class="x.y.Foo">
<property name="accounts">
<map>
<entry key="one" value="9.99"/>
<entry key="two" value="2.75"/>
<entry key="six" value="3.99"/>
</map>
</property>
</bean>
</beans>

When the accounts property of the foo bean is prepared for injection, the generics

information about the element type of the strongly-typedMap<String, Float> is
available by reflection. Thus Spring's type conversion infrastructure recognizes the
various value elements as being of typeFloat, and the string values 9.99, 2.75,
and 3.99 are converted into an actual Float type.

3.4.2.5 Null and empty string values

Spring treats empty arguments for properties and the like as empty Strings. The
following XML-based configuration metadata snippet sets the email property to the
empty String value ("")

83
<bean class="ExampleBean">
<property name="email" value=""/>
</bean>

The preceding example is equivalent to the following Java

code: exampleBean.setEmail(""). The <null/> element handles null values. For
example:

The above configuration is equivalent to the following Java

code: exampleBean.setEmail(null).

3.4.2.6 XML shortcut with the p-namespace

The p-namespace enables you to use the bean element's attributes, instead of

nested <property/> elements, to describe your property values and/or collaborating
beans.

Spring 2.0 and later supports extensible configuration formats with namespaces,

which are based on an XML Schema definition. The beansconfiguration format
discussed in this chapter is defined in an XML Schema document. However, the p-
namespace is not defined in an XSD file and exists only in the core of Spring.

The following example shows two XML snippets that resolve to the same result:
The first uses standard XML format and the second uses the p-namespace.

<bean name="classic" class="com.example.ExampleBean">

<bean name="p-namespace" class="com.example.ExampleBean"

p:email="[email protected]"/>
</beans>

84
The example shows an attribute in the p-namespace called email in the bean
definition. This tells Spring to include a property declaration. As previously
mentioned, the p-namespace does not have a schema definition, so you can set
the name of the attribute to the property name.

This next example includes two more bean definitions that both have a reference
to another bean:

<bean name="john-classic" class="com.example.Person">

<bean name="jane" class="com.example.Person">

As you can see, this example includes not only a property value using the p-
namespace, but also uses a special format to declare property references.
Whereas the first bean definition uses <property name="spouse" ref="jane"/> to
create a reference from bean john to bean jane, the second bean definition
uses p:spouse-ref="jane" as an attribute to do the exact same thing. In this
case spouse is the property name, whereas the -ref part indicates that this is not a straight
value but rather a reference to another bean.

Note

The p-namespace is not as flexible as the standard XML format. For example, the format for
declaring property references clashes with properties that end in Ref, whereas the standard XML
format does not. We recommend that you choose your approach carefully and communicate this
to your team members, to avoid producing XML documents that use all three approaches at the
same time.

85
3.4.2.7 Compound property names

You can use compound or nested property names when you set bean properties,
as long as all components of the path except the final property name are not null.
Consider the following bean definition.

<bean id="foo" class="foo.Bar">

The foo bean has a fred property, which has a bob property, which has

a sammy property, and that final sammy property is being set to the value 123. In order
for this to work, the fred property of foo, and the bob property of fred must not
be null after the bean is constructed, or aNullPointerException is thrown.

3.4.3 Using depends-on

If a bean is a dependency of another that usually means that one bean is set as a
property of another. Typically you accomplish this with the <ref/>element in XML-
based configuration metadata. However, sometimes dependencies between beans
are less direct; for example, a static initializer in a class needs to be triggered,
such as database driver registration. The depends-on attribute can explicitly force
one or more beans to be initialized before the bean using this element is initialized.
The following example uses the depends-on attribute to express a dependency on a
single bean:

<bean id="beanOne" class="ExampleBean" depends-on="manager"/>

<bean id="manager" class="ManagerBean" />

To express a dependency on multiple beans, supply a list of bean names as the

value of the depends-on attribute, with commas, whitespace and semicolons, used
as valid delimiters:

<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">

<bean id="manager" class="ManagerBean" />

Note

86
The depends-on attribute in the bean definition can specify both an initialization time
dependency and, in the case of singletonbeans only, a corresponding destroy time dependency.
Dependent beans that define a depends-on relationship with a given bean are destroyed first,
prior to the given bean itself being destroyed. Thus depends-on can also control shutdown order.

3.4.4 Lazy-initialized beans

By default, ApplicationContext implementations eagerly create and configure

all singleton beans as part of the initialization process. Generally, this pre-
instantiation is desirable, because errors in the configuration or surrounding
environment are discovered immediately, as opposed to hours or even days later.
When this behavior is not desirable, you can prevent pre-instantiation of a
singleton bean by marking the bean definition as lazy-initialized. A lazy-initialized
bean tells the IoC container to create a bean instance when it is first requested,
rather than at startup.

In XML, this behavior is controlled by the lazy-init attribute on

the <bean/> element; for example:

<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/>

<bean name="not.lazy" class="com.foo.AnotherBean"/>

When the preceding configuration is consumed by an ApplicationContext, the bean

named lazy is not eagerly pre-instantiated when theApplicationContext is starting
up, whereas the not.lazy bean is eagerly pre-instantiated.

However, when a lazy-initialized bean is a dependency of a singleton bean that

is not lazy-initialized, the ApplicationContext creates the lazy-initialized bean at
startup, because it must satisfy the singleton's dependencies. The lazy-initialized
bean is injected into a singleton bean elsewhere that is not lazy-initialized.

You can also control lazy-initialization at the container level by using the default-
lazy-init attribute on the <beans/> element; for example:

87
3.4.5 Autowiring collaborators

The Spring container can autowire relationships between collaborating beans. You

can allow Spring to resolve collaborators (other beans) automatically for your bean
by inspecting the contents of the ApplicationContext. Autowiring has the following
advantages:

 Autowiring can significantly reduce the need to specify properties or

constructor arguments. (Other mechanisms such as a bean
templatediscussed elsewhere in this chapter are also valuable in this
regard.)
 Autowiring can update a configuration as your objects evolve. For example,
if you need to add a dependency to a class, that dependency can be
satisfied automatically without you needing to modify the configuration. Thus
autowiring can be especially useful during development, without negating
the option of switching to explicit wiring when the code base becomes more
stable.

When using XML-based configuration metadata[2], you specify autowire mode for a
bean definition with the autowire attribute of the <bean/>element. The autowiring
functionality has five modes. You specify autowiring per bean and thus can choose
which ones to autowire.

Table 3.2. Autowiring modes

Explanation

fault) No autowiring. Bean references must be defined via a ref element. Changing the default setting is not recommended
er deployments, because specifying collaborators explicitly gives greater control and clarity. To some extent, it documents
cture of a system.

owiring by property name. Spring looks for a bean with the same name as the property that needs to be autowired. For example,
n definition is set to autowire by name, and it contains a master property (that is, it has a setMaster(..)method), Spring looks f
n definition named master, and uses it to set the property.

ws a property to be autowired if exactly one bean of the property type exists in the container. If more than one exists, a
eption is thrown, which indicates that you may not use byType autowiring for that bean. If there are no matching beans, not
pens; the property is not set.

logous to byType, but applies to constructor arguments. If there is not exactly one bean of the constructor argument type in
ainer, a fatal error is raised.

88
With byType or constructor autowiring mode, you can wire arrays and typed-
collections. In such cases all autowire candidates within the container that match
the expected type are provided to satisfy the dependency. You can autowire
strongly-typed Maps if the expected key type is String. An autowired Maps values
will consist of all bean instances that match the expected type, and the Maps keys
will contain the corresponding bean names.

You can combine autowire behavior with dependency checking, which is

performed after autowiring completes.

3.4.5.1 Limitations and disadvantages of autowiring

Autowiring works best when it is used consistently across a project. If autowiring is

not used in general, it might be confusing to developers to use it to wire only one
or two bean definitions.

Consider the limitations and disadvantages of autowiring:

 Explicit dependencies in property and constructor-arg settings always

override autowiring. You cannot autowire so-called simpleproperties such as
primitives, Strings, and Classes (and arrays of such simple properties). This
limitation is by-design.

 Autowiring is less exact than explicit wiring. Although, as noted in the above
table, Spring is careful to avoid guessing in case of ambiguity that might
have unexpected results, the relationships between your Spring-managed
objects are no longer documented explicitly.

 Wiring information may not be available to tools that may generate

documentation from a Spring container.

 Multiple bean definitions within the container may match the type specified
by the setter method or constructor argument to be autowired. For arrays,
collections, or Maps, this is not necessarily a problem. However for
dependencies that expect a single value, this ambiguity is not arbitrarily
resolved. If no unique bean definition is available, an exception is thrown.

In the latter scenario, you have several options:

 Abandon autowiring in favor of explicit wiring.

 Avoid autowiring for a bean definition by setting its autowire-
candidate attributes to false as described in the next section.

89
 Designate a single bean definition as the primary candidate by setting
the primary attribute of its <bean/> element to true.

 If you are using Java 5 or later, implement the more fine-grained control
available with annotation-based configuration, as described inSection 3.9,
“Annotation-based container configuration”.

3.4.5.2 Excluding a bean from autowiring

On a per-bean basis, you can exclude a bean from autowiring. In Spring's XML
format, set the autowire-candidate attribute of the <bean/> element to false; the
container makes that specific bean definition unavailable to the autowiring
infrastructure (including annotation style configurations such as @Autowired).

You can also limit autowire candidates based on pattern-matching against bean
names. The top-level <beans/> element accepts one or more patterns within
its default-autowire-candidates attribute. For example, to limit autowire candidate
status to any bean whose name ends withRepository, provide a value of
*Repository. To provide multiple patterns, define them in a comma-separated list.
An explicit value of true or falsefor a bean definitions autowire-candidate attribute
always takes precedence, and for such beans, the pattern matching rules do not
apply.

These techniques are useful for beans that you never want to be injected into
other beans by autowiring. It does not mean that an excluded bean cannot itself be
configured using autowiring. Rather, the bean itself is not a candidate for
autowiring other beans.

3.4.6 Method injection

In most application scenarios, most beans in the container are singletons. When a

singleton bean needs to collaborate with another singleton bean, or a non-
singleton bean needs to collaborate with another non-singleton bean, you typically
handle the dependency by defining one bean as a property of the other. A problem
arises when the bean lifecycles are different. Suppose singleton bean A needs to
use non-singleton (prototype) bean B, perhaps on each method invocation on A.
The container only creates the singleton bean A once, and thus only gets one
opportunity to set the properties. The container cannot provide bean A with a new
instance of bean B every time one is needed.

A solution is to forego some inversion of control. You can make bean A aware of

the container by implementing the ApplicationContextAwareinterface, and by making

90
a getBean("B") call to the container ask for (a typically new) bean B instance every
time bean A needs it. The following is an example of this approach:

// a class that uses a stateful Command-style class to perform some processing

package fiona.apple;

// Spring-API imports
import org.springframework.beans.BeansException;
import org.springframework.context.Applicationcontext;
import org.springframework.context.ApplicationContextAware;

public class CommandManager implements ApplicationContextAware {

private ApplicationContext applicationContext;

public Object process(Map commandState) {

// grab a new instance of the appropriate Command
Command command = createCommand();
// set the state on the (hopefully brand new) Command instance
command.setState(commandState);
return command.execute();
}

protected Command createCommand() {

// notice the Spring API dependency!
return this.applicationContext.getBean("command", Command.class);
}

public void setApplicationContext(ApplicationContext applicationContext)

throws
BeansException {
this.applicationContext = applicationContext;
}
}

The preceding is not desirable, because the business code is aware of and
coupled to the Spring Framework. Method Injection, a somewhat advanced feature
of the Spring IoC container, allows this use case to be handled in a clean fashion.
You can read more about the motivation for Method Injection in this blog entry.

3.4.6.1 Lookup method injection

Lookup method injection is the ability of the container to override methods

on container managed beans, to return the lookup result for another named bean in the
container. The lookup typically involves a prototype bean as in the scenario described in the preceding
section. The Spring Framework implements this method injection by using bytecode generation from
the CGLIB library to generate dynamically a subclass that overrides the method.

Note

91
For this dynamic subclassing to work, you must have the CGLIB jar(s) in your classpath. The
class that the Spring container will subclass cannot be final, and the method to be overridden
cannot be final either. Also, testing a class that has an abstractmethod requires you to subclass
the class yourself and to supply a stub implementation of the abstract method. Finally, objects
that have been the target of method injection cannot be serialized.

Looking at the CommandManager class in the previous code snippet, you see that the
Spring container will dynamically override the implementation of
the createCommand() method. Your CommandManager class will not have any Spring
dependencies, as can be seen in the reworked example:

package fiona.apple;

// no more Spring imports!

public abstract class CommandManager {

public Object process(Object commandState) {

// grab a new instance of the appropriate Command interface
Command command = createCommand();
// set the state on the (hopefully brand new) Command instance
command.setState(commandState);
return command.execute();
}

// okay... but where is the implementation of this method?

protected abstract Command createCommand();
}

In the client class containing the method to be injected (the CommandManager in this

case), the method to be injected requires a signature of the following form:

<public|protected> [abstract] <return-type> theMethodName(no-arguments);

If the method is abstract, the dynamically-generated subclass implements the

method. Otherwise, the dynamically-generated subclass overrides the concrete
method defined in the original class. For example:

92

<bean id="commandManager" class="fiona.apple.CommandManager">
<lookup-method name="createCommand" bean="command"/>
</bean>

The bean identified as commandManager calls its own

method createCommand() whenever it needs a new instance of
the command bean. You must be careful to deploy the command bean as a
prototype, if that is actually what is needed. If it is deployed as a singleton, the
same instance of thecommand bean is returned each time.

Tip

The interested reader may also find the ServiceLocatorFactoryBean (in

the org.springframework.beans.factory.configpackage) to be of use. The approach used in
ServiceLocatorFactoryBean is similar to that of another utility
class,ObjectFactoryCreatingFactoryBean, but it allows you to specify your own lookup
interface as opposed to a Spring-specific lookup interface. Consult the JavaDocs for these classes
as well as this blog entry for additional information ServiceLocatorFactoryBean.

3.4.6.2 Arbitrary method replacement

A less useful form of method injection than lookup method Injection is the ability to
replace arbitrary methods in a managed bean with another method
implementation. Users may safely skip the rest of this section until the functionality
is actually needed.

With XML-based configuration metadata, you can use the replaced-method element

to replace an existing method implementation with another, for a deployed bean.
Consider the following class, with a method computeValue, which we want to
override:

public class MyValueCalculator {

public String computeValue(String input) {

// some real code...
}

// some other methods...

93
A class implementing
the org.springframework.beans.factory.support.MethodReplacer interface provides the
new method definition.

/** meant to be used to override the existing computeValue(String)

implementation in MyValueCalculator
*/
public class ReplacementComputeValue implements MethodReplacer {

public Object reimplement(Object o, Method m, Object[] args) throws Throwable {

// get the input value, work with it, and return a computed result
String input = (String) args[0];
...
return ...;
}
}

The bean definition to deploy the original class and specify the method override
would look like this:

<bean id="myValueCalculator" class="x.y.z.MyValueCalculator">

<replaced-method name="computeValue" replacer="replacementComputeValue">
<arg-type>String</arg-type>
</replaced-method>
</bean>

<bean id="replacementComputeValue" class="a.b.c.ReplacementComputeValue"/>

You can use one or more contained <arg-type/> elements within the <replaced-

method/> element to indicate the method signature of the method being overridden.
The signature for the arguments is necessary only if the method is overloaded and
multiple variants exist within the class. For convenience, the type string for an
argument may be a substring of the fully qualified type name. For example, the
following all matchjava.lang.String:

java.lang.String
String
Str

Because the number of arguments is often enough to distinguish between each

possible choice, this shortcut can save a lot of typing, by allowing you to type only
the shortest string that will match an argument type.

94
3.5 Bean scopes

When you create a bean definition, you create a recipe for creating actual
instances of the class defined by that bean definition. The idea that a bean
definition is a recipe is important, because it means that, as with a class, you can
create many object instances from a single recipe.

You can control not only the various dependencies and configuration values that
are to be plugged into an object that is created from a particular bean definition,
but also the scope of the objects created from a particular bean definition. This
approach is powerful and flexible in that you canchoose the scope of the objects
you create through configuration instead of having to bake in the scope of an
object at the Java class level. Beans can be defined to be deployed in one of a
number of scopes: out of the box, the Spring Framework supports five scopes,
three of which are available only if you use a web-aware ApplicationContext.

The following scopes are supported out of the box. You can also create a custom
scope.

Table 3.3. Bean scopes

Description

fault) Scopes a single bean definition to a single object instance per Spring IoC container.

pes a single bean definition to any number of object instances.

pes a single bean definition to the lifecycle of a single HTTP request; that is, each HTTP request has its own instance of a b
ated off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

pes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aw
ingApplicationContext.

pes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. O
d in the context of a web-aware Spring ApplicationContext.

Thread-scoped beans

As of Spring 3.0, a thread scope is available, but is not registered by default. For more
information, see the documentation forSimpleThreadScope. For instructions on how to register
this or any other custom scope, see Section 3.5.5.2, “Using a custom scope”.

95
3.5.1 The singleton scope

Only one shared instance of a singleton bean is managed, and all requests for

beans with an id or ids matching that bean definition result in that one specific
bean instance being returned by the Spring container.

To put it another way, when you define a bean definition and it is scoped as a
singleton, the Spring IoC container creates exactly one instance of the object
defined by that bean definition. This single instance is stored in a cache of such
singleton beans, and all subsequent requests and references for that named bean
return the cached object.

Spring's concept of a singleton bean differs from the Singleton pattern as defined
in the Gang of Four (GoF) patterns book. The GoF Singleton hard-codes the
scope of an object such that one and only one instance of a particular class is
created per ClassLoader. The scope of the Spring singleton is best described
as per container and per bean. This means that if you define one bean for a
particular class in a single Spring container, then the Spring container creates
one and only one instance of the class defined by that bean definition. The
singleton scope is the default scope in Spring. To define a bean as a singleton in
XML, you would write, for example:

96
<bean id="accountService" class="com.foo.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the

default) -->
<bean id="accountService" class="com.foo.DefaultAccountService"
scope="singleton"/>

3.5.2 The prototype scope

The non-singleton, prototype scope of bean deployment results in the creation of a

new bean instance every time a request for that specific bean is made. That is, the
bean is injected into another bean or you request it through a getBean() method call
on the container. As a rule, use the prototype scope for all stateful beans and the
singleton scope for stateless beans.

The following diagram illustrates the Spring prototype scope. A data access object
(DAO) is not typically configured as a prototype, because a typical DAO does not
hold any conversational state; it was just easier for this author to reuse the core of
the singleton diagram.

The following example defines a bean as a prototype in XML:

97

<bean id="accountService" class="com.foo.DefaultAccountService"
scope="prototype"/>

In contrast to the other scopes, Spring does not manage the complete lifecycle of
a prototype bean: the container instantiates, configures, and otherwise assembles
a prototype object, and hands it to the client, with no further record of that
prototype instance. Thus, although initializationlifecycle callback methods are
called on all objects regardless of scope, in the case of prototypes,
configured destruction lifecycle callbacks are notcalled. The client code must clean
up prototype-scoped objects and release expensive resources that the prototype
bean(s) are holding. To get the Spring container to release resources held by
prototype-scoped beans, try using a custom bean post-processor, which holds a
reference to beans that need to be cleaned up.

In some respects, the Spring container's role in regard to a prototype-scoped bean

is a replacement for the Java new operator. All lifecycle management past that point
must be handled by the client. (For details on the lifecycle of a bean in the Spring
container, see Section 3.6.1, “Lifecycle callbacks”.)

3.5.3 Singleton beans with prototype-bean dependencies

When you use singleton-scoped beans with dependencies on prototype beans, be

aware that dependencies are resolved at instantiation time. Thus if you
dependency-inject a prototype-scoped bean into a singleton-scoped bean, a new
prototype bean is instantiated and then dependency-injected into the singleton
bean. The prototype instance is the sole instance that is ever supplied to the
singleton-scoped bean.

However, suppose you want the singleton-scoped bean to acquire a new instance
of the prototype-scoped bean repeatedly at runtime. You cannot dependency-
inject a prototype-scoped bean into your singleton bean, because that injection
occurs only once, when the Spring container is instantiating the singleton bean
and resolving and injecting its dependencies. If you need a new instance of a
prototype bean at runtime more than once, see Section 3.4.6, “Method injection”

3.5.4 Request, session, and global session scopes

The request, session, and global session scopes are only available if you use a

web-aware Spring ApplicationContext implementation (such
as XmlWebApplicationContext). If you use these scopes with regular Spring IoC

98
containers such as the ClassPathXmlApplicationContext, you get
an IllegalStateException complaining about an unknown bean scope.

3.5.4.1 Initial web configuration

To support the scoping of beans at the request, session, and global session levels

(web-scoped beans), some minor initial configuration is required before you define
your beans. (This initial setup is not required for the standard scopes, singleton
and prototype.)

How you accomplish this initial setup depends on your particular Servlet
environment..

If you access scoped beans within Spring Web MVC, in effect, within a request
that is processed by the Spring DispatcherServlet, orDispatcherPortlet, then no
special setup is necessary: DispatcherServlet and DispatcherPortlet already expose
all relevant state.

If you use a Servlet 2.4+ web container, with requests processed outside of
Spring's DispatcherServlet (for example, when using JSF or Struts), you need to
add the following javax.servlet.ServletRequestListener to the declarations in your
web applications web.xml file:

<web-app>
...
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
...
</web-app>

If you use an older web container (Servlet 2.3), use the

provided javax.servlet.Filter implementation. The following snippet of XML
configuration must be included in the web.xml file of your web application if you
want to access web-scoped beans in requests outside of Spring's
DispatcherServlet on a Servlet 2.3 container. (The filter mapping depends on the
surrounding web application configuration, so you must change it as appropriate.)

<web-app>
..
<filter>

99
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
...
</web-app>

DispatcherServlet, RequestContextListener and RequestContextFilter alldo exactly
the same thing, namely bind the HTTP request object to the Thread that is servicing
that request. This makes beans that are request- and session-scoped available
further down the call chain.

3.5.4.2 Request scope

Consider the following bean definition:

<bean id="loginAction" class="com.foo.LoginAction" scope="request"/>

The Spring container creates a new instance of the LoginAction bean by using

the loginAction bean definition for each and every HTTP request. That is,
the loginAction bean is scoped at the HTTP request level. You can change the
internal state of the instance that is created as much as you want, because other
instances created from the same loginAction bean definition will not see these
changes in state; they are particular to an individual request. When the request
completes processing, the bean that is scoped to the request is discarded.

3.5.4.3 Session scope

Consider the following bean definition:

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

The Spring container creates a new instance of the UserPreferences bean by using

the userPreferences bean definition for the lifetime of a single HTTP Session. In
other words, the userPreferences bean is effectively scoped at the
HTTP Session level. As with request-scoped beans, you can change the internal
state of the instance that is created as much as you want, knowing that other
HTTP Session instances that are also using instances created from the
same userPreferences bean definition do not see these changes in state, because

100
they are particular to an individual HTTP Session. When the HTTP Session is
eventually discarded, the bean that is scoped to that particular HTTP Session is
also discarded.

3.5.4.4 Global session scope

Consider the following bean definition:

<bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>

The global session scope is similar to the standard HTTP Session scope (described

above), and applies only in the context of portlet-based web applications. The
portlet specification defines the notion of a global Session that is shared among all
portlets that make up a single portlet web application. Beans defined at the global
session scope are scoped (or bound) to the lifetime of the global portlet Session.

If you write a standard Servlet-based web application and you define one or more
beans as having global session scope, the standard HTTPSession scope is used,
and no error is raised.

3.5.4.5 Scoped beans as dependencies

The Spring IoC container manages not only the instantiation of your objects (beans), but also the
wiring up of collaborators (or dependencies). If you want to inject (for example) an HTTP request
scoped bean into another bean, you must inject an AOP proxy in place of the scoped bean. That is, you
need to inject a proxy object that exposes the same public interface as the scoped object but that can
also retrieve the real, target object from the relevant scope (for example, an HTTP request) and
delegate method calls onto the real object.

Note

You do not need to use the <aop:scoped-proxy/> in conjunction with beans that are scoped
as singletons or prototypes. If you try to create a scoped proxy for a singleton bean,
the BeanCreationException is raised.

The configuration in the following example is only one line, but it is important to
understand the “why” as well as the “how” behind it.

<?xml version="1.0" encoding="UTF-8"?>

101
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<aop:scoped-proxy/>
</bean>

<bean id="userService" class="com.foo.SimpleUserService">

</bean>
</beans>

To create such a proxy, you insert a child <aop:scoped-proxy/> element into a

scoped bean definition. (If you choose class-based proxying, you also need the
CGLIB library in your classpath. See the section called “Choosing the type of proxy
to create” and Appendix C, XML Schema-based configuration.) Why do definitions
of beans scoped at the request, session, globalSession and custom-scope levels
require the <aop:scoped-proxy/> element ? Let's examine the following singleton
bean definition and contrast it with what you need to define for the aforementioned
scopes. (The following userPreferences bean definition as it stands is incomplete.)

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

<bean id="userManager" class="com.foo.UserManager">

In the preceding example, the singleton bean userManager is injected with a

reference to the HTTP Session-scoped bean userPreferences. The salient point here
is that the userManager bean is a singleton: it will be instantiated exactly once per
container, and its dependencies (in this case only one, the userPreferences bean)
are also injected only once. This means that the userManager bean will only operate
on the exact sameuserPreferences object, that is, the one that it was originally
injected with.

This is not the behavior you want when injecting a shorter-lived scoped bean into a
longer-lived scoped bean, for example injecting an HTTP Session-scoped
collaborating bean as a dependency into singleton bean. Rather, you need a

102
single userManager object, and for the lifetime of an HTTP Session, you need
a userPreferences object that is specific to said HTTP Session. Thus the container
creates an object that exposes the exact same public interface as
the UserPreferences class (ideally an object that is a UserPreferences instance) which
can fetch the realUserPreferences object from the scoping mechanism (HTTP
request, Session, etc.). The container injects this proxy object into
the userManagerbean, which is unaware that this UserPreferences reference is a
proxy. In this example, when a UserManager instance invokes a method on the
dependency-injected UserPreferences object, it actually is invoking a method on the
proxy. The proxy then fetches the real UserPreferences object from (in this case) the
HTTP Session, and delegates the method invocation onto the retrieved
real UserPreferences object.

Thus you need the following, correct and complete, configuration when
injecting request-, session-, and globalSession-scoped beans into collaborating
objects:

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">

<aop:scoped-proxy/>
</bean>

<bean id="userManager" class="com.foo.UserManager">

Choosing the type of proxy to create

By default, when the Spring container creates a proxy for a bean that is marked up
with the <aop:scoped-proxy/> element, a CGLIB-based class proxy is created. This
means that you need to have the CGLIB library in the classpath of your
application.

Note: CGLIB proxies only intercept public method calls! Do not call non-public
methods on such a proxy; they will not be delegated to the scoped target object.

Alternatively, you can configure the Spring container to create standard JDK
interface-based proxies for such scoped beans, by specifying falsefor the value of
the proxy-target-class attribute of the <aop:scoped-proxy/> element. Using JDK
interface-based proxies means that you do not need additional libraries in your
application classpath to effect such proxying. However, it also means that the
class of the scoped bean must implement at least one interface, and that
all collaborators into which the scoped bean is injected must reference the bean
through one of its interfaces.

103

<bean id="userPreferences" class="com.foo.DefaultUserPreferences" scope="session">
<aop:scoped-proxy proxy-target-class="false"/>
</bean>

<bean id="userManager" class="com.foo.UserManager">

For more detailed information about choosing class-based or interface-based

proxying, see Section 7.6, “Proxying mechanisms”.

3.5.5 Custom scopes

As of Spring 2.0, the bean scoping mechanism is extensible. You can define your
own scopes, or even redefine existing scopes, although the latter is considered
bad practice and you cannot override the built-in singleton and prototype scopes.

3.5.5.1 Creating a custom scope

To integrate your custom scope(s) into the Spring container, you need to
implement the org.springframework.beans.factory.config.Scopeinterface, which is
described in this section. For an idea of how to implement your own scopes, see
the Scope implementations that are supplied with the Spring Framework itself and
the Scope Javadoc, which explains the methods you need to implement in more
detail.

The Scope interface has four methods to get objects from the scope, remove them
from the scope, and allow them to be destroyed.

The following method returns the object from the underlying scope. The session
scope implementation, for example, returns the session-scoped bean (and if it
does not exist, the method returns a new instance of the bean, after having bound
it to the session for future reference).

Object get(String name, ObjectFactory objectFactory)

The following method removes the object from the underlying scope. The session
scope implementation for example, removes the session-scoped bean from the
underlying session. The object should be returned, but you can return null if the
object with the specified name is not found.

104
Object remove(String name)

The following method registers the callbacks the scope should execute when it is
destroyed or when the specified object in the scope is destroyed. Refer to the
Javadoc or a Spring scope implementation for more information on destruction
callbacks.

void registerDestructionCallback(String name, Runnable destructionCallback)

The following method obtains the conversation identifier for the underlying scope.
This identifier is different for each scope. For a session scoped implementation,
this identifier can be the session identifier.

String getConversationId()

3.5.5.2 Using a custom scope

After you write and test one or more custom Scope implementations, you need to
make the Spring container aware of your new scope(s). The following method is
the central method to register a new Scope with the Spring container:

void registerScope(String scopeName, Scope scope);

This method is declared on the ConfigurableBeanFactory interface, which is available

on most of the concrete ApplicationContextimplementations that ship with Spring
via the BeanFactory property.

The first argument to the registerScope(..) method is the unique name associated

with a scope; examples of such names in the Spring container itself
are singleton and prototype. The second argument to the registerScope(..) method
is an actual instance of the custom Scopeimplementation that you wish to register
and use.

Suppose that you write your custom Scope implementation, and then register it as below.

Note

The example below uses SimpleThreadScope which is included with Spring, but not registered
by default. The instructions would be the same for your own custom Scope implementations.

105
Scope threadScope = new SimpleThreadScope();
beanFactory.registerScope("thread", threadScope);

You then create bean definitions that adhere to the scoping rules of your
custom Scope:

<bean id="..." class="..." scope="thread">

With a custom Scope implementation, you are not limited to programmatic

registration of the scope. You can also do the Scope registration declaratively, using
the CustomScopeConfigurer class:

<?xml version="1.0" encoding="UTF-8"?>

<bean id="bar" class="x.y.Bar" scope="thread">

<bean id="foo" class="x.y.Foo">

</beans>

Note

When you place <aop:scoped-proxy/> in a FactoryBean implementation, it is the factory bean

itself that is scoped, not the object returned from getObject().

106
3.6 Customizing the nature of a bean
3.6.1 Lifecycle callbacks

To interact with the container's management of the bean lifecycle, you can
implement the Spring InitializingBean and DisposableBean interfaces. The container
calls afterPropertiesSet() for the former and destroy() for the latter to allow the
bean to perform certain actions upon initialization and destruction of your beans.
You can also achieve the same integration with the container without coupling your
classes to Spring interfaces through the use of init-method and destroy method
object definition metadata.

Internally, the Spring Framework uses BeanPostProcessor implementations to

process any callback interfaces it can find and call the appropriate methods. If you
need custom features or other lifecycle behavior Spring does not offer out-of-the-
box, you can implement a BeanPostProcessoryourself. For more information,
see Section 3.8, “Container extension points”.

In addition to the initialization and destruction callbacks, Spring-managed objects

may also implement the Lifecycle interface so that those objects can participate in
the startup and shutdown process as driven by the container's own lifecycle.

The lifecycle callback interfaces are described in this section.

3.6.1.1 Initialization callbacks

The org.springframework.beans.factory.InitializingBean interface allows a bean to

perform initialization work after all necessary properties on the bean have been set
by the container. The InitializingBean interface specifies a single method:

void afterPropertiesSet() throws Exception;

It is recommended that you do not use the InitializingBean interface because it

unnecessarily couples the code to Spring. Alternatively, specify a POJO
initialization method. In the case of XML-based configuration metadata, you use
the init-method attribute to specify the name of the method that has a void no-
argument signature. For example, the following definition:

<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>

public class ExampleBean {

107
public void init() {
// do some initialization work
}
}

...is exactly the same as...

<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>

public class AnotherExampleBean implements InitializingBean {

public void afterPropertiesSet() {

// do some initialization work
}
}

... but does not couple the code to Spring.

3.6.1.2 Destruction callbacks

Implementing the org.springframework.beans.factory.DisposableBean interface allows

a bean to get a callback when the container containing it is destroyed.
The DisposableBean interface specifies a single method:

void destroy() throws Exception;

It is recommended that you do not use the DisposableBean callback interface

because it unnecessarily couples the code to Spring. Alternatively, specify a
generic method that is supported by bean definitions. With XML-based
configuration metadata, you use the destroy-method attribute on the <bean/>. For
example, the following definition:

<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>

public class ExampleBean {

public void cleanup() {

// do some destruction work (like releasing pooled connections)
}
}

...is exactly the same as...

<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>

public class AnotherExampleBean implements DisposableBean {

108
public void destroy() {
// do some destruction work (like releasing pooled connections)
}
}

... but does not couple the code to Spring.

3.6.1.3 Default initialization and destroy methods

When you write initialization and destroy method callbacks that do not use the
Spring-specific InitializingBean and DisposableBean callback interfaces, you
typically write methods with names such as init(), initialize(), dispose(), and so
on. Ideally, the names of such lifecycle callback methods are standardized across
a project so that all developers use the same method names and ensure
consistency.

You can configure the Spring container to look for named initialization and destroy
callback method names on every bean. This means that you, as an application
developer, can write your application classes and use an initialization callback
called init(), without having to configure an init-method="init" attribute with each
bean definition. The Spring IoC container calls that method when the bean is
created (and in accordance with the standard lifecycle callback contract described
previously). This feature also enforces a consistent naming convention for
initialization and destroy method callbacks.

Suppose that your initialization callback methods are named init() and destroy

callback methods are named destroy(). Your class will resemble the class in the
following example.

public class DefaultBlogService implements BlogService {

private BlogDao blogDao;

public void setBlogDao(BlogDao blogDao) {

this.blogDao = blogDao;
}

// this is (unsurprisingly) the initialization callback method

public void init() {
if (this.blogDao == null) {
throw new IllegalStateException("The [blogDao] property must be set.");
}
}
}

109
<beans default-init-method="init">

<bean id="blogService" class="com.foo.DefaultBlogService">

</beans>

The presence of the default-init-method attribute on the top-level <beans/> element

attribute causes the Spring IoC container to recognize a method called init on
beans as the initialization method callback. When a bean is created and
assembled, if the bean class has such a method, it is invoked at the appropriate
time.

You configure destroy method callbacks similarly (in XML, that is) by using
the default-destroy-method attribute on the top-level <beans/> element.

Where existing bean classes already have callback methods that are named at
variance with the convention, you can override the default by specifying (in XML,
that is) the method name using the init-method and destroy-method attributes of the
<bean/> itself.

The Spring container guarantees that a configured initialization callback is called

immediately after a bean is supplied with all dependencies. Thus the initialization
callback is called on the raw bean reference, which means that AOP interceptors
and so forth are not yet applied to the bean. A target bean is fully
created first, then an AOP proxy (for example) with its interceptor chain is applied.
If the target bean and the proxy are defined separately, your code can even
interact with the raw target bean, bypassing the proxy. Hence, it would be
inconsistent to apply the interceptors to the init method, because doing so would
couple the lifecycle of the target bean with its proxy/interceptors and leave strange
semantics when your code interacts directly to the raw target bean.

3.6.1.4 Combining lifecycle mechanisms

As of Spring 2.5, you have three options for controlling bean lifecycle behavior:
the InitializingBean and DisposableBean callback interfaces;
custom init() and destroy() methods; and
the @PostConstruct and @PreDestroy annotations. You can combine these mechanisms
to control a given bean.

Note

110
If multiple lifecycle mechanisms are configured for a bean, and each mechanism is configured
with a different method name, then each configured method is executed in the order listed below.
However, if the same method name is configured - for example, init() for an initialization
method - for more than one of these lifecycle mechanisms, that method is executed once, as
explained in the preceding section.

Multiple lifecycle mechanisms configured for the same bean, with different
initialization methods, are called as follows:

 Methods annotated with @PostConstruct

 afterPropertiesSet() as defined by the InitializingBean callback interface

 A custom configured init() method

Destroy methods are called in the same order:

 Methods annotated with @PreDestroy

 destroy() as defined by the DisposableBean callback interface

 A custom configured destroy() method

3.6.1.5 Startup and shutdown callbacks

The Lifecycle interface defines the essential methods for any object that has its
own lifecycle requirements (e.g. starts and stops some background process):

public interface Lifecycle {

void start();

void stop();

boolean isRunning();

Any Spring-managed object may implement that interface. Then, when the
ApplicationContext itself starts and stops, it will cascade those calls to all Lifecycle
implementations defined within that context. It does this by delegating to
a LifecycleProcessor:

111
public interface LifecycleProcessor extends Lifecycle {

void onRefresh();

void onClose();

Notice that the LifecycleProcessor is itself an extension of the Lifecycle interface. It

also adds two other methods for reacting to the context being refreshed and
closed.

The order of startup and shutdown invocations can be important. If a "depends-on"

relationship exists between any two objects, the dependent side will start after its
dependency, and it will stop before its dependency. However, at times the direct
dependencies are unknown. You may only know that objects of a certain type
should start prior to objects of another type. In those cases,
the SmartLifecycle interface defines another option, namely the getPhase() method
as defined on its super-interface, Phased.

public interface Phased {

int getPhase();

public interface SmartLifecycle extends Lifecycle, Phased {

boolean isAutoStartup();

void stop(Runnable callback);

When starting, the objects with the lowest phase start first, and when stopping, the
reverse order is followed. Therefore, an object that implements SmartLifecycle and
whose getPhase() method returns Integer.MIN_VALUE would be among the first to
start and the last to stop. At the other end of the spectrum, a phase value
of Integer.MAX_VALUE would indicate that the object should be started last and
stopped first (likely because it depends on other processes to be running). When
considering the phase value, it's also important to know that the default phase for
any "normal" Lifecycleobject that does not implement SmartLifecycle would be 0.
Therefore, any negative phase value would indicate that an object should start

112
before those standard components (and stop after them), and vice versa for any
positive phase value.

As you can see the stop method defined by SmartLifecycle accepts a callback. Any
implementation must invoke that callback's run() method after that
implementation's shutdown process is complete. That enables asynchronous
shutdown where necessary since the default implementation of
the LifecycleProcessor interface, DefaultLifecycleProcessor, will wait up to its
timeout value for the group of objects within each phase to invoke that callback.
The default per-phase timeout is 30 seconds. You can override the default lifecycle
processor instance by defining a bean named "lifecycleProcessor" within the
context. If you only want to modify the timeout, then defining the following would
be sufficient:

As mentioned, the LifecycleProcessor interface defines callback methods for the

refreshing and closing of the context as well. The latter will simply drive the
shutdown process as if stop() had been called explicitly, but it will happen when
the context is closing. The 'refresh' callback on the other hand enables another
feature of SmartLifecycle beans. When the context is refreshed (after all objects
have been instantiated and initialized), that callback will be invoked, and at that
point the default lifecycle processor will check the boolean value returned by
each SmartLifecycle object'sisAutoStartup() method. If "true", then that object will
be started at that point rather than waiting for an explicit invocation of the context's
or its own start() method (unlike the context refresh, the context start does not
happen automatically for a standard context implementation). The "phase" value
as well as any "depends-on" relationships will determine the startup order in the
same way as described above.

3.6.1.6 Shutting down the Spring IoC container gracefully in non-web applications

Note

This section applies only to non-web applications. Spring's web-

based ApplicationContext implementations already have code in place to shut down the Spring
IoC container gracefully when the relevant web application is shut down.

113
If you are using Spring's IoC container in a non-web application environment; for
example, in a rich client desktop environment; you register a shutdown hook with
the JVM. Doing so ensures a graceful shutdown and calls the relevant destroy
methods on your singleton beans so that all resources are released. Of course,
you must still configure and implement these destroy callbacks correctly.

To register a shutdown hook, you call the registerShutdownHook() method that is

declared on the AbstractApplicationContext class:

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public final class Boot {

public static void main(final String[] args) throws Exception {

AbstractApplicationContext ctx
= new ClassPathXmlApplicationContext(new String []{"beans.xml"});

// add a shutdown hook for the above context...

ctx.registerShutdownHook();

// app runs here...

// main method exits, hook is called prior to the app shutting down...
}
}

3.6.2 ApplicationContextAware and BeanNameAware

When an ApplicationContext creates a class that implements

the org.springframework.context.ApplicationContextAware interface, the class is
provided with a reference to that ApplicationContext.

public interface ApplicationContextAware {

void setApplicationContext(ApplicationContext applicationContext) throws

BeansException;
}

Thus beans can manipulate programmatically the ApplicationContext that created

them, through the ApplicationContext interface, or by casting the reference to a
known subclass of this interface, such as ConfigurableApplicationContext, which
exposes additional functionality. One use would be the programmatic retrieval of
other beans. Sometimes this capability is useful; however, in general you should
avoid it, because it couples the code to Spring and does not follow the Inversion of
Control style, where collaborators are provided to beans as properties. Other

114
methods of the ApplicationContext provide access to file resources, publishing
application events, and accessing a MessageSource. These additional features
are described in Section 3.13, “Additional Capabilities of the ApplicationContext”

As of Spring 2.5, autowiring is another alternative to obtain reference to

the ApplicationContext. The "traditional" constructor and byTypeautowiring modes
(as described in Section 3.4.5, “Autowiring collaborators”) can provide a
dependency of type ApplicationContext for a constructor argument or setter method
parameter, respectively. For more flexibility, including the ability to autowire fields
and multiple parameter methods, use the new annotation-based autowiring
features. If you do, the ApplicationFactory is autowired into a field, constructor
argument, or method parameter that is expecting the BeanFactory type if the field,
constructor, or method in question carries the @Autowired annotation. For more
information, see Section 3.9.2, “@Autowired and @Inject”.

When an ApplicationContext creates a class that implements

the org.springframework.beans.factory.BeanNameAware interface, the class is provided
with a reference to the name defined in its associated object definition.

public interface BeanNameAware {

void setBeanName(string name) throws BeansException;

}

The callback is invoked after population of normal bean properties but before an
initialization callback such as InitializingBeansafterPropertiesSet or a custom init-
method.

3.6.3 Other Aware interfaces

Besides ApplicationContextAware and BeanNameAware discussed above, Spring offers

a range of Aware interfaces that allow beans to indicate to the container that they
require a certain infrastructure dependency. The most important Aware interfaces
are summarized below - as a general rule, the name is a good indication of the
dependency type:

Table 3.4. Aware interfaces

Name Injected Dependency Explained in...

ApplicationContextAware Declaring ApplicationContext Section 3.6.2,

“ApplicationContextAware

115
Name Injected Dependency Explained in...

and BeanNameAware”

Section 3.13, “Additional
ApplicationEventPublisherAwar Event publisher of the
e Capabilities of the
enclosing ApplicationContext
ApplicationContext”

BeanClassLoaderAware
Class loader used to load the bean Section 3.3.2, “Instantiating
classes. beans”

Section 3.6.2,
BeanFactoryAware Declaring BeanFactory “ApplicationContextAware
and BeanNameAware”

Section 3.6.2,
BeanNameAware Name of the declaring bean “ApplicationContextAware
and BeanNameAware”

Resource
adapter BootstrapContext the
BootstrapContextAware container runs in. Typically Chapter 23, JCA CCI
available only in JCA
aware ApplicationContexts

Section 7.8.4, “Load-time
Defined weaver for processing
LoadTimeWeaverAware weaving with AspectJ in the
class definition at load time
Spring Framework”

Configured strategy for resolving

Section 3.13, “Additional
messages (with support for
MessageSourceAware Capabilities of the
parametrization and
ApplicationContext”
internationalization)

Spring JMX notification

NotificationPublisherAware Section 22.7, “Notifications”
publisher

Current PortletConfig the
PortletConfigAware
container runs in. Valid only in a Chapter 18, Portlet MVC
web-aware Framework
Spring ApplicationContext

PortletContextAware Current PortletContext the Chapter 18, Portlet MVC

container runs in. Valid only in a Framework

116
Name Injected Dependency Explained in...

web-aware
Spring ApplicationContext

Configured loader for low-level

ResourceLoaderAware Chapter 4, Resources
access to resources

Current ServletConfig the
ServletConfigAware
container runs in. Valid only in a Chapter 15, Web MVC
web-aware framework
Spring ApplicationContext

Current ServletContext the
ServletContextAware
container runs in. Valid only in a Chapter 15, Web MVC
web-aware framework
Spring ApplicationContext

Note again that usage of these interfaces ties your code to the Spring API and
does not follow the Inversion of Control style. As such, they are recommended for
infrastructure beans that require programmatic access to the container.

3.7 Bean definition inheritance

A bean definition can contain a lot of configuration information, including

constructor arguments, property values, and container-specific information such as
initialization method, static factory method name, and so on. A child bean definition
inherits configuration data from a parent definition. The child definition can override
some values, or add others, as needed. Using parent and child bean definitions
can save a lot of typing. Effectively, this is a form of templating.

If you work with an ApplicationContext interface programmatically, child bean

definitions are represented by the ChildBeanDefinition class. Most users do not
work with them on this level, instead configuring bean definitions declaratively in
something like the ClassPathXmlApplicationContext. When you use XML-based
configuration metadata, you indicate a child bean definition by using
the parent attribute, specifying the parent bean as the value of this attribute.

<bean id="inheritedTestBean" abstract="true"

class="org.springframework.beans.TestBean">
<property name="name" value="parent"/>
<property name="age" value="1"/>

117
</bean>

<property name="name" value="override"/>

</bean>

A child bean definition uses the bean class from the parent definition if none is
specified, but can also override it. In the latter case, the child bean class must be
compatible with the parent, that is, it must accept the parent's property values.

A child bean definition inherits constructor argument values, property values, and
method overrides from the parent, with the option to add new values. Any
initialization method, destroy method, and/or static factory method settings that
you specify will override the corresponding parent settings.

The remaining settings are always taken from the child definition: depends

on, autowire mode, dependency check, singleton, scope, lazy init.

The preceding example explicitly marks the parent bean definition as abstract by
using the abstract attribute. If the parent definition does not specify a class,
explicitly marking the parent bean definition as abstract is required, as follows:

<bean id="inheritedTestBeanWithoutClass" abstract="true">

<bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean"

parent="inheritedTestBeanWithoutClass" init-method="initialize">
<property name="name" value="override"/>

</bean>

The parent bean cannot be instantiated on its own because it is incomplete, and it
is also explicitly marked as abstract. When a definition isabstract like this, it is
usable only as a pure template bean definition that serves as a parent definition for
child definitions. Trying to use such anabstract parent bean on its own, by referring
to it as a ref property of another bean or doing an explicit getBean() call with the
parent bean id, returns an error. Similarly, the container's
internal preInstantiateSingletons() method ignores bean definitions that are defined as abstract.

118
Note

ApplicationContext pre-instantiates all singletons by default. Therefore, it is important (at least

for singleton beans) that if you have a (parent) bean definition which you intend to use only as a
template, and this definition specifies a class, you must make sure to set the abstract attribute
to true, otherwise the application context will actually (attempt to) pre-instantiate
the abstractbean.

3.8 Container extension points

Typically, an application developer does not need to subclass

any ApplicationContext implementation classes. You can extend The Spring IoC
container infinitely by plugging in implementations of special integration interfaces.
The next few sections describe these integration interfaces.

3.8.1 Customizing beans using the BeanPostProcessor Interface

The BeanPostProcessor interface defines callback methods that you can implement

to provide your own (or override the container's default) instantiation logic,
dependency-resolution logic, and so forth. If you want to implement some custom
logic after the Spring container finishes instantiating, configuring, and otherwise
initializing a bean, you can plug in one or more BeanPostProcessor implementations.

You can configure multiple BeanPostProcessor interfaces. You can control the

order in which these BeanPostProcessor interfaces execute by setting
the order property. You can set this property only if
the BeanPostProcessor implements the Ordered interface; if you write your
ownBeanPostProcessor you should consider implementing the Ordered interface
too. For more details, consult the Javadoc for
the BeanPostProcessorand Ordered interfaces.

Note
BeanPostProcessors operate on bean (or object) instances; that is to say, the Spring IoC
container instantiates a bean instance and then BeanPostProcessor interfaces do their work.

BeanPostProcessor interfaces are scoped per-container. This is only relevant if you are using

container hierarchies. If you define a BeanPostProcessor in one container, it will only do its
work on the beans in that container. Beans that are defined in one container are not post-
processed by a BeanPostProcessor in another container, even if both containers are part of the
same hierarchy.

To change the actual bean definition (that is, the recipe that defines the bean), you instead need to
use aBeanFactoryPostProcessor, described below in Section 3.8.2, “Customizing

119
configuration metadata with BeanFactoryPostProcessor interface”.

The org.springframework.beans.factory.config.BeanPostProcessor interface consists
of exactly two callback methods. When such a class is registered as a post-
processor with the container, for each bean instance that is created by the
container, the post-processor gets a callback from the container
both before container initialization methods (such as afterPropertiesSet and any
declared init method) are called, and also afterwards. The post-processor can take
any action with the bean instance, including ignoring the callback completely. A
bean post-processor typically checks for callback interfaces, or may wrap a bean
with a proxy. Some Spring AOP infrastructure classes are implemented as bean
post-processors and they do this proxy-wrapping logic.

An ApplicationContext automatically detects any beans that are defined in the

configuration metadata it receives that implement
theBeanPostProcessor interface. The ApplicationContext registers these beans as post-
processors, to be then called appropriately by the container upon bean creation. You can then deploy
the post-processors as you would any bean.

BeanPostProcessors and AOP auto-proxying

Classes that implement the BeanPostProcessor interface are special, and so they are treated
differently by the container. AllBeanPostProcessors and their directly referenced beans are
instantiated on startup, as part of the special startup phase of theApplicationContext. Next, all
those BeanPostProcessors are registered in a sorted fashion - and applied to all further beans.
Because AOP auto-proxying is implemented as a BeanPostProcessor itself,
no BeanPostProcessors or directly referenced beans are eligible for auto-proxying, and thus do
not have aspects woven into them.

For any such bean, you should see an info log message: “Bean foo is not eligible for getting
processed by all BeanPostProcessor interfaces (for example: not eligible for auto-proxying)”.

The following examples show how to write, register, and use BeanPostProcessors in

the context of an ApplicationContext.

3.8.1.1 Example: Hello World, BeanPostProcessor-style

This first example illustrates basic usage. The example shows a

custom BeanPostProcessor implementation that invokes the toString() method of
each bean as it is created by the container and prints the resulting string to the
system console.

Find below the custom BeanPostProcessor implementation class definition:

120
package scripting;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InstantiationTracingBeanPostProcessor implements BeanPostProcessor {

// simply return the instantiated bean as-is

public Object postProcessBeforeInitialization(Object bean, String beanName)
throws
BeansException {
return bean; // we could potentially return any object reference here...
}

public Object postProcessAfterInitialization(Object bean, String beanName)

throws
BeansException {
System.out.println("Bean '" + beanName + "' created : " + bean.toString());
return bean;
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:lang="http://www.springframework.org/schema/lang"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/lang
http://www.springframework.org/schema/lang/spring-lang-3.0.xsd">

<lang:groovy id="messenger"
script-
source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
<lang:property name="message" value="Fiona Apple Is Just So Dreamy."/>
</lang:groovy>

<bean class="scripting.InstantiationTracingBeanPostProcessor"/>

</beans>

Notice how the InstantiationTracingBeanPostProcessor is simply defined. It does not

even have a name, and because it is a bean it can be dependency-injected just
like any other bean. (The preceding configuration also defines a bean that is
backed by a Groovy script. The Spring 2.0 dynamic language support is detailed in
the chapter entitled Chapter 26, Dynamic language support.)

The following small driver script executes the preceding code and configuration:

121
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scripting.Messenger;

public final class Boot {

public static void main(final String[] args) throws Exception {

ApplicationContext ctx = new
ClassPathXmlApplicationContext("scripting/beans.xml");
Messenger messenger = (Messenger) ctx.getBean("messenger");
System.out.println(messenger);
}
}

The output of the preceding execution resembles the following:

Bean 'messenger' created :

org.springframework.scripting.groovy.GroovyMessenger@272961
org.springframework.scripting.groovy.GroovyMessenger@272961

3.8.1.2 Example: The RequiredAnnotationBeanPostProcessor

Using callback interfaces or annotations in conjunction with a

custom BeanPostProcessor implementation is a common means of extending the
Spring IoC container. An example is Spring's RequiredAnnotationBeanPostProcessor --
a BeanPostProcessor implementation that ships with the Spring distribution which
ensures that JavaBean properties on beans that are marked with an (arbitrary)
annotation are actually (configured to be) dependency-injected with a value.

3.8.2 Customizing configuration metadata with BeanFactoryPostProcessor interface

The next extension point that we will look at is

the org.springframework.beans.factory.config.BeanFactoryPostProcessor. The
semantics of this interface are similar to the BeanPostProcessor, with one major
difference: BeanFactoryPostProcessors operate on the bean configuration metadata;
that is, the Spring IoC container allows BeanFactoryPostProcessors to read the
configuration metadata and potentially change it beforethe container instantiates
any beans other than BeanFactoryPostProcessors.

You can configure multiple BeanFactoryPostProcessors. You can control the order

in which these BeanFactoryPostProcessors execute by setting the order property.
However, you can only set this property if
the BeanFactoryPostProcessor implements the Ordered interface. If you write your
own BeanFactoryPostProcessor, you should consider implementing

122
the Ordered interface too; consult the Javadoc for
theBeanFactoryPostProcessor and Ordered interfaces for more details.

Note
If you want to change the actual bean instances (the objects that are created from the
configuration metadata), then you instead need to use a BeanPostProcessor (described above
in Section 3.8.1, “Customizing beans using the BeanPostProcessor Interface ” . While it is
technically possible to work with bean instances within a BeanFactoryPostProcessor (e.g.
usingBeanFactory.getBean()), doing so causes premature bean instantiation, violating the
usual containter lifecycle. This may cause negative side effects such as bypassing bean post
processing.

Also, BeanFactoryPostProcessors are scoped per-container. This is only relevant if you are

using container hierarchies. If you define a BeanFactoryPostProcessor in one container, it
will only do its stuff on the bean definitions in that container. Bean definitions in another
container will not be post-processed by BeanFactoryPostProcessors in another container, even
if both containers are part of the same hierarchy.

A bean factory post-processor is executed automatically when it is declared inside

of an ApplicationContext, in order to apply changes to the configuration metadata
that defines a container. Spring includes a number of pre-existing bean factory
post-processors, such
asPropertyOverrideConfigurer and PropertyPlaceholderConfigurer. A
custom BeanFactoryPostProcessor can also be used, for example, to register custom
property editors.

An ApplicationContext detects any beans that are deployed into it and that

implement the BeanFactoryPostProcessor interface. It automatically uses these beans as
bean factory post-processors, at the appropriate time. You can then deploy these post-processor beans
as you would any other bean.

Note

As with BeanPostProcessors, you typically do not want BeanFactoryPostProcessors marked

as lazy-initialized. If they are marked as such, the Spring container never instantiates them, and
thus they cannot apply their custom logic. If you use the default-lazy-init attribute on the
declaration of your <beans/> element, be sure to mark your
variousBeanFactoryPostProcessor bean definitions with lazy-init="false".

3.8.2.1 Example: the PropertyPlaceholderConfigurer

You use the PropertyPlaceholderConfigurer to externalize property values from a

bean definition into another separate file in the standard Java Properties format.
Doing so enables the person deploying an application to customize environment-

123
specific properties such as database URLs and passwords, without the complexity
or risk of modifying the main XML definition file or files for the container.

Consider the following XML-based configuration metadata fragment, where

a DataSource with placeholder values is defined. The example shows properties
configured from an external Properties file. At runtime,
a PropertyPlaceholderConfigurer is applied to the metadata that will replace some
properties of the DataSource. The values to replace are specified as 'placeholders'
of the form ${property-name} which follows the Ant / Log4J / JSP EL style.

<bean id="dataSource" destroy-method="close"

class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

The actual values come from another file in the standard Java Properties format:

jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:hsql://production:9002
jdbc.username=sa
jdbc.password=root

Therefore, the string ${jdbc.username} is replaced at runtime with the value 'sa'
and similarly for other placeholder values that match to keys in the property file.
The PropertyPlaceholderConfigurer checks for placeholders in most locations of a
bean definition and the placeholder prefix and suffix can be customized.

With the context namespace introduced in Spring 2.5, it is possible to configure

property placeholders with a dedicated configuration element. You can provide
multiple locations as a comma-separated list in the location attribute.

<context:property-placeholder location="classpath:com/foo/jdbc.properties"/>

The PropertyPlaceholderConfigurer does not look for properties only in

the Properties file you specify, but also checks against the Java Systemproperties

124
if it cannot find a property you are trying to use. You can customize this behavior
by setting the systemPropertiesMode property of the configurer. It has three values
that specify configurer behavior: always override, never override, and override only
if the property is not found in the properties file specified. Consult the Javadoc for
the PropertyPlaceholderConfigurer for more information.

Class name substitution

You can use the PropertyPlaceholderConfigurer to substitute class names, which is
sometimes useful when you have to pick a particular implementation class at runtime. For
example:

<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:com/foo/strategy.properties</value>
</property>
<property name="properties">
<value>custom.strategy.class=com.foo.DefaultStrategy</value>
</property>
</bean>

<bean id="serviceStrategy" class="${custom.strategy.class}"/>

If the class cannot be resolved at runtime to a valid class, resolution of the bean fails when it is
about to be created, which is during the preInstantiateSingletons() phase of
an ApplicationContext for a non-lazy-init bean.

3.8.2.2 Example: the PropertyOverrideConfigurer

The PropertyOverrideConfigurer, another bean factory post-processor, resembles

the PropertyPlaceholderConfigurer, but unlike the latter, the original definitions can
have default values or no values at all for bean properties. If an
overriding Properties file does not have an entry for a certain bean property, the
default context definition is used.

Note that the bean definition is not aware of being overridden, so it is not

immediately obvious from the XML definition file that the override configurer is
used. In case of multiple PropertyOverrideConfigurer instances that define different
values for the same bean property, the last one wins, due to the overriding
mechanism.

Properties file configuration lines take this format:

beanName.property=value

125
For example:

dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql:mydb

This example file is usable against a container definition that contains a bean
called dataSource, which has driver and url properties.

Compound property names are also supported, as long as every component of the
path except the final property being overridden is already non-null (presumably
initialized by the constructors). In this example...

foo.fred.bob.sammy=123

... the sammy property of the bob property of the fred property of the foo bean is

set to the scalar value 123.

Note

Specified override values are always literal values; they are not translated into bean references.
This convention also applies when the original value in the XML bean definition specifies a bean
reference.

With the context namespace introduced in Spring 2.5, it is possible to configure

property overriding with a dedicated configuration element:

<context:property-override location="classpath:override.properties"/>

3.8.3 Customizing instantiation logic with the FactoryBean Interface

You implement the org.springframework.beans.factory.FactoryBean interface for

objects that are themselves factories.

The FactoryBean interface is a point of pluggability into the Spring IoC container's

instantiation logic. If you have complex initialization code that is better expressed
in Java as opposed to a (potentially) verbose amount of XML, you can create your
own FactoryBean, write the complex initialization inside that class, and then plug
your custom FactoryBean into the container.

The FactoryBean interface provides three methods:

126
 Object getObject(): returns an instance of the object this factory creates. The
instance can possibly be shared, depending on whether this factory returns
singletons or prototypes.
 boolean isSingleton(): returns true if this FactoryBean returns
singletons, false otherwise.

 Class getObjectType():returns the object type returned by

the getObject() method or null if the type is not known in advance

The FactoryBean concept and interface is used in a number of places within the

Spring Framework; more than 50 implementations of theFactoryBean interface ship
with Spring itself.

When you need to ask a container for an actual FactoryBean instance itself, not the
bean it produces, you preface the bean id with the ampersand symbol & (without
quotes) when calling the getBean() method of the ApplicationContext. So for a
given FactoryBean with an id of myBean, invokinggetBean("myBean") on the container
returns the product of the FactoryBean, and invoking getBean("&myBean") returns
the FactoryBean instance itself.

3.9 Annotation-based container configuration

Are annotations better than XML for configuring Spring?

The introduction of annotation-based configurations raised the question of whether this approach is 'better'
than XML. The short answer is it depends. The long answer is that each approach has its pros and cons,
and usually it is up to the developer to decide which strategy suits her better. Due to the way they are
defined, annotations provide a lot of context in their declaration, leading to shorter and more concise
configuration. However, XML excels at wiring up components without touching their source code or
recompiling them. Some developers prefer having the wiring close to the source while others argue that
annotated classes are no longer POJOs and, furthermore, that the configuration becomes decentralized
and harder to control.

No matter the choice, Spring can accommodate both styles and even mix them together. It's worth
pointing out that through its JavaConfig option, Spring allows annotations to be used in a non-invasive
way, without touching the target components source code and that in terms of tooling, all configuration
styles are supported by the SpringSource Tool Suite.

An alternative to XML setups is provided by annotation-based configuration which

rely on the bytecode metadata for wiring up components instead of angle-bracket
declarations. Instead of using XML to describe a bean wiring, the developer moves
the configuration into the component class itself by using annotations on the
relevant class, method, or field declaration. As mentioned in Section 3.8.1.2,
“Example: The RequiredAnnotationBeanPostProcessor”, using
a BeanPostProcessor in conjunction with annotations is a common means of

127
extending the Spring IoC container. For example, Spring 2.0 introduced the
possibility of enforcing required properties with the@Required annotation. As of
Spring 2.5, it is now possible to follow that same general approach to drive
Spring's dependency injection. Essentially, the @Autowired annotation provides
the same capabilities as described in Section 3.4.5, “Autowiring collaborators”but
with more fine-grained control and wider applicability. Spring 2.5 also adds support
for JSR-250 annotations such as @Resource, @PostConstruct,
and @PreDestroy. Spring 3.0 adds support for JSR-330 (Dependency Injection for
Java) annotations contained in the javax.inject package such
as @Inject, @Qualifier, @Named, and @Provider if the JSR330 jar is present on
the classpath. Use of these annotations also requires that
certain BeanPostProcessors be registered within the Spring container.

Note
Annotation injection is performed before XML injection, thus the latter configuration will
override the former for properties wired through both approaches.

As always, you can register them as individual bean definitions, but they can also
be implicitly registered by including the following tag in an XML-based Spring
configuration (notice the inclusion of the context namespace):

<?xml version="1.0" encoding="UTF-8"?>

<context:annotation-config/>

</beans>

(The implicitly registered post-processors

include AutowiredAnnotationBeanPostProcessor, CommonAnnotationBeanPostPr
ocessor,PersistenceAnnotationBeanPostProcessor, as well as the
aforementioned RequiredAnnotationBeanPostProcessor.)

Note

<context:annotation-config/> only looks for annotations on beans in the same application

context in which it is defined. This means that, if you put <context:annotation-config/> in
a WebApplicationContext for a DispatcherServlet, it only checks for@Autowired beans in

128
your controllers, and not your services. See Section 15.2, “The DispatcherServlet” for more
information.

3.9.1 @Required

The @Required annotation applies to bean property setter methods, as in the

following example:

public class SimpleMovieLister {

private MovieFinder movieFinder;

@Required
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}

// ...
}

This annotation simply indicates that the affected bean property must be populated
at configuration time, through an explicit property value in a bean definition or
through autowiring. The container throws an exception if the affected bean
property has not been populated; this allows for eager and explicit failure,
avoiding NullPointerExceptions or the like later on. It is still recommended that you
put assertions into the bean class itself, for example, into an init method. Doing so
enforces those required references and values even when you use the class
outside of a container.

3.9.2 @Autowired and @Inject

As expected, you can apply the @Autowired annotation to "traditional" setter methods:

Note

JSR 330's @Inject annotation can be used in place of Spring's @Autowired in the examples
below. @Inject does not have a required property unlike Spring's @Autowired annotation which
has a required property to indicate if the value being injected is optional. This behavior is
enabled automatically if you have the JSR 330 JAR on the classpath.
public class SimpleMovieLister {

private MovieFinder movieFinder;

@Autowired

129
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}

// ...
}

You can also apply the annotation to methods with arbitrary names and/or multiple
arguments:

public class MovieRecommender {

private MovieCatalog movieCatalog;

private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public void prepare(MovieCatalog movieCatalog,
CustomerPreferenceDao customerPreferenceDao) {
this.movieCatalog = movieCatalog;
this.customerPreferenceDao = customerPreferenceDao;
}

// ...
}

You can apply @Autowired to constructors and fields:

public class MovieRecommender {

@Autowired
private MovieCatalog movieCatalog;

private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
this.customerPreferenceDao = customerPreferenceDao;
}

// ...
}

It is also possible to provide all beans of a particular type from

the ApplicationContext by adding the annotation to a field or method that expects
an array of that type:

130
public class MovieRecommender {

@Autowired
private MovieCatalog[] movieCatalogs;

// ...
}

The same applies for typed collections:

public class MovieRecommender {

private Set<MovieCatalog> movieCatalogs;

@Autowired
public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) {
this.movieCatalogs = movieCatalogs;
}

// ...
}

Even typed Maps can be autowired as long as the expected key type is String.
The Map values will contain all beans of the expected type, and the keys will
contain the corresponding bean names:

public class MovieRecommender {

private Map<String, MovieCatalog> movieCatalogs;

@Autowired
public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {
this.movieCatalogs = movieCatalogs;
}

// ...
}

By default, the autowiring fails whenever zero candidate beans are available; the

default behavior is to treat annotated methods, constructors, and fields as
indicating required dependencies. This behavior can be changed as demonstrated
below.

public class SimpleMovieLister {

private MovieFinder movieFinder;

131
@Autowired(required=false)
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}

// ...
}

Note
Only one annotated constructor per-class can be marked as required, but multiple non-required
constructors can be annotated. In that case, each is considered among the candidates and Spring
uses the greediest constructor whose dependencies can be satisfied, that is the constructor that has
the largest number of arguments.

@Autowired's required attribute is recommended over the @Required annotation.

The required attribute indicates that the property is not required for autowiring purposes, the
property is ignored if it cannot be autowired. @Required, on the other hand, is stronger in that it
enforces the property that was set by any means supported by the container. If no value is
injected, a corresponding exception is raised.

You can also use @Autowired for interfaces that are well-known resolvable

dependencies: BeanFactory, ApplicationContext, ResourceLoader,ApplicationEventPubli
sher, and MessageSource. These interfaces and their extended interfaces, such
as ConfigurableApplicationContext orResourcePatternResolver, are automatically
resolved, with no special setup necessary.

public class MovieRecommender {

@Autowired
private ApplicationContext context;

public MovieRecommender() {
}

// ...
}

3.9.3 Fine-tuning annotation-based autowiring with qualifiers

Because autowiring by type may lead to multiple candidates, it is often necessary

to have more control over the selection process. One way to accomplish this is
with Spring's @Qualifier annotation. You can associate qualifier values with specific arguments,
narrowing the set of type matches so that a specific bean is chosen for each argument. In the simplest
case, this can be a plain descriptive value:

Note

132
JSR 330's @Qualifier annotation can only be applied as a meta-annotation unlike Spring's
@Qualifier which takes a string property to discriminate among multiple injection candidates and
can be placed on annotations as well as types, fields, methods, constructors, and parameters.

public class MovieRecommender {

@Autowired
@Qualifier("main")
private MovieCatalog movieCatalog;

// ...
}

The @Qualifier annotation can also be specified on individual constructor

arguments or method parameters:

public class MovieRecommender {

private MovieCatalog movieCatalog;

private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public void prepare(@Qualifier("main") MovieCatalog movieCatalog,
CustomerPreferenceDao customerPreferenceDao) {
this.movieCatalog = movieCatalog;
this.customerPreferenceDao = customerPreferenceDao;
}

// ...
}

The corresponding bean definitions appear as follows. The bean with qualifier
value "main" is wired with the constructor argument that is qualified with the same
value.

<?xml version="1.0" encoding="UTF-8"?>

<context:annotation-config/>

133
<bean class="example.SimpleMovieCatalog">
<qualifier value="main"/>

</bean>

<bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

For a fallback match, the bean name is considered a default qualifier value. Thus
you can define the bean with an id "main" instead of the nested qualifier element,
leading to the same matching result. However, although you can use this
convention to refer to specific beans by name,@Autowired is fundamentally about
type-driven injection with optional semantic qualifiers. This means that qualifier
values, even with the bean name fallback, always have narrowing semantics within
the set of type matches; they do not semantically express a reference to a unique
bean id. Good qualifier values are "main" or "EMEA" or "persistent", expressing
characteristics of a specific component that are independent from the bean id,
which may be auto-generated in case of an anonymous bean definition like the
one in the preceding example.

Qualifiers also apply to typed collections, as discussed above, for example,

to Set<MovieCatalog>. In this case, all matching beans according to the declared
qualifiers are injected as a collection. This implies that qualifiers do not have to be
unique; they rather simply constitute filtering criteria. For example, you can define
multiple MovieCatalog beans with the same qualifier value "action"; all of which
would be injected into aSet<MovieCatalog> annotated with @Qualifier("action").

Tip
If you intend to express annotation-driven injection by name, do not primarily use @Autowired,
even if is technically capable of referring to a bean name through @Qualifier values. Instead, use
the JSR-250 @Resource annotation, which is semantically defined to identify a specific target
component by its unique name, with the declared type being irrelevant for the matching process.

As a specific consequence of this semantic difference, beans that are themselves defined as a
collection or map type cannot be injected through @Autowired, because type matching is not
properly applicable to them. Use @Resource for such beans, referring to the specific collection or
map bean by unique name.

134
@Autowired applies to fields, constructors, and multi-argument methods, allowing for narrowing
through qualifier annotations at the parameter level. By contrast, @Resource is supported only for
fields and bean property setter methods with a single argument. As a consequence, stick with
qualifiers if your injection target is a constructor or a multi-argument method.

You can create your own custom qualifier annotations. Simply define an
annotation and provide the @Qualifier annotation within your definition:

Note

You can use JSR 330's @Qualifier annotation in the manner described below in place of
Spring's @Qualifier annotation. This behavior is enabled automatically if you have the JSR 330
jar on the classpath.
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Genre {

String value();
}

Then you can provide the custom qualifier on autowired fields and parameters:

public class MovieRecommender {

@Autowired
@Genre("Action")
private MovieCatalog actionCatalog;

private MovieCatalog comedyCatalog;

@Autowired
public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog) {
this.comedyCatalog = comedyCatalog;
}

// ...
}

Next, provide the information for the candidate bean definitions. You can
add <qualifier/> tags as sub-elements of the <bean/> tag and then specify
the type and value to match your custom qualifier annotations. The type is matched
against the fully-qualified class name of the annotation. Or, as a convenience if no
risk of conflicting names exists, you can use the short class name. Both
approaches are demonstrated in the following example.

135
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:annotation-config/>

<bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

In Section 3.10, “Classpath scanning and managed components”, you will see an

annotation-based alternative to providing the qualifier metadata in XML.
Specifically, see Section 3.10.7, “Providing qualifier metadata with annotations”.

In some cases, it may be sufficient to use an annotation without a value. This may
be useful when the annotation serves a more generic purpose and can be applied
across several different types of dependencies. For example, you may provide
an offline catalog that would be searched when no Internet connection is available.
First define the simple annotation:

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Offline {

Then add the annotation to the field or property to be autowired:

public class MovieRecommender {

@Autowired
@Offline

136
private MovieCatalog offlineCatalog;

// ...
}

Now the bean definition only needs a qualifier type:

You can also define custom qualifier annotations that accept named attributes in
addition to or instead of the simple value attribute. If multiple attribute values are
then specified on a field or parameter to be autowired, a bean definition must
match all such attribute values to be considered an autowire candidate. As an
example, consider the following annotation definition:

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface MovieQualifier {

String genre();

Format format();
}

In this case Format is an enum:

public enum Format {

VHS, DVD, BLURAY

}

The fields to be autowired are annotated with the custom qualifier and include
values for both attributes: genre and format.

public class MovieRecommender {

@Autowired
@MovieQualifier(format=Format.VHS, genre="Action")
private MovieCatalog actionVhsCatalog;

137
@Autowired
@MovieQualifier(format=Format.VHS, genre="Comedy")
private MovieCatalog comedyVhsCatalog;

@Autowired
@MovieQualifier(format=Format.DVD, genre="Action")
private MovieCatalog actionDvdCatalog;

@Autowired
@MovieQualifier(format=Format.BLURAY, genre="Comedy")
private MovieCatalog comedyBluRayCatalog;

// ...
}

Finally, the bean definitions should contain matching qualifier values. This example
also demonstrates that bean meta attributes may be used instead of
the <qualifier/> sub-elements. If available, the <qualifier/> and its attributes take
precedence, but the autowiring mechanism falls back on the values provided
within the <meta/> tags if no such qualifier is present, as in the last two bean
definitions in the following example.

<?xml version="1.0" encoding="UTF-8"?>

<context:annotation-config/>

138
<meta key="genre" value="Action"/>

</bean>

</beans>

3.9.4 CustomAutowireConfigurer

The CustomAutowireConfigurer is a BeanFactoryPostProcessor that enables you to

<bean id="customAutowireConfigurer"

class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer">
<property name="customQualifierTypes">
<set>
<value>example.CustomQualifier</value>
</set>
</property>
</bean>

The particular implementation of AutowireCandidateResolver that is activated for the

application context depends on the Java version. In versions earlier than Java 5,
the qualifier annotations are not supported, and therefore autowire candidates are
solely determined by the autowire-candidate value of each bean definition as well
as by any default-autowire-candidates pattern(s) available on the <beans/> element.
In Java 5 or later, the presence of @Qualifier annotations and any custom
annotations registered with the CustomAutowireConfigurer will also play a role.

Regardless of the Java version, when multiple beans qualify as autowire

candidates, the determination of a "primary" candidate is the same: if exactly one
bean definition among the candidates has a primary attribute set to true, it will be
selected.

3.9.5 @Resource

Spring also supports injection using the JSR-250 @Resource annotation on fields or

bean property setter methods. This is a common pattern in Java EE 5 and 6, for

139
example in JSF 1.2 managed beans or JAX-WS 2.0 endpoints. Spring supports
this pattern for Spring-managed objects as well.

@Resource takesa name attribute, and by default Spring interprets that value as the
bean name to be injected. In other words, it follows by-namesemantics, as
demonstrated in this example:

public class SimpleMovieLister {

private MovieFinder movieFinder;

@Resource(name="myMovieFinder")
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}

If no name is specified explicitly, the default name is derived from the field name or
setter method. In case of a field, it takes the field name; in case of a setter method,
it takes the bean property name. So the following example is going to have the
bean with name "movieFinder" injected into its setter method:

public class SimpleMovieLister {

private MovieFinder movieFinder;

@Resource
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}

Note

The name provided with the annotation is resolved as a bean name by

the ApplicationContext of which theCommonAnnotationBeanPostProcessor is aware. The
names can be resolved through JNDI if you configure
Spring'sSimpleJndiBeanFactory explicitly. However, it is recommended that you rely on the
default behavior and simply use Spring's JNDI lookup capabilities to preserve the level of
indirection.

In the exclusive case of @Resource usage with no explicit name specified, and

similar to @Autowired, @Resource finds a primary type match instead of a specific
named bean and resolves well-known resolvable dependencies: the BeanFactory,
ApplicationContext, ResourceLoader, ApplicationEventPublisher,
and MessageSource interfaces.

140
Thus in the following example, the customerPreferenceDao field first looks for a bean
named customerPreferenceDao, then falls back to a primary type match for the
type CustomerPreferenceDao. The "context" field is injected based on the known
resolvable dependency typeApplicationContext.

public class MovieRecommender {

@Resource
private CustomerPreferenceDao customerPreferenceDao;

@Resource
private ApplicationContext context;

public MovieRecommender() {
}

// ...
}

3.9.6 @PostConstruct and @PreDestroy

The CommonAnnotationBeanPostProcessor not only recognizes the @Resource annotation

but also the JSR-250 lifecycle annotations. Introduced in Spring 2.5, the support
for these annotations offers yet another alternative to those described
in initialization callbacks and destruction callbacks. Provided that
the CommonAnnotationBeanPostProcessor is registered within the
Spring ApplicationContext, a method carrying one of these annotations is invoked
at the same point in the lifecycle as the corresponding Spring lifecycle interface
method or explicitly declared callback method. In the example below, the cache
will be pre-populated upon initialization and cleared upon destruction.

public class CachingMovieLister {

@PostConstruct
public void populateMovieCache() {
// populates the movie cache upon initialization...
}

@PreDestroy
public void clearMovieCache() {
// clears the movie cache upon destruction...
}
}

Note

For details about the effects of combining various lifecycle mechanisms, see Section 3.6.1.4,
“Combining lifecycle mechanisms”.

141
3.10 Classpath scanning and managed components

Most examples foo bar in this chapter use XML to specify the configuration
metadata that produces each BeanDefinition within the Spring container. The
previous section (Section 3.9, “Annotation-based container configuration”)
demonstrates how to provide a lot of the configuration metadata through source-
level annotations. Even in those examples, however, the "base" bean definitions
are explicitly defined in the XML file, while the annotations only drive the
dependency injection. This section describes an option for implicitly detecting
the candidate components by scanning the classpath. Candidate components are classes that
match against a filter criteria and have a corresponding bean definition registered with the container.
This removes the need to use XML to perform bean registration, instead you can use annotations (for
example @Component), AspectJ type expressions, or your own custom filter criteria to select which
classes will have bean definitions registered with the container.

Note

Starting with Spring 3.0, many features provided by the Spring JavaConfig project are part of the
core Spring Framework. This allows you to define beans using Java rather than using the
traditional XML files. Take a look at the @Configuration, @Bean,@Import,
and @DependsOn annotations for examples of how to use these new features.

3.10.1 @Component and further stereotype annotations

In Spring 2.0 and later, the @Repository annotation is a marker for any class that
fulfills the role or stereotype (also known as Data Access Object or DAO) of a
repository. Among the uses of this marker is the automatic translation of
exceptions as described in Section 13.2.2, “Exception translation”.

Spring 2.5 introduces further stereotype annotations: @Component, @Service,

and @Controller. @Component is a generic stereotype for any Spring-managed
component. @Repository, @Service, and @Controller are specializations
of @Component for more specific use cases, for example, in the persistence, service,
and presentation layers, respectively. Therefore, you can annotate your
component classes with @Component, but by annotating them
with @Repository, @Service, or @Controller instead, your classes are more properly
suited for processing by tools or associating with aspects. For example, these
stereotype annotations make ideal targets for pointcuts. It is also possible
that @Repository, @Service, and@Controller may carry additional semantics in future
releases of the Spring Framework. Thus, if you are choosing between
using @Component or@Service for your service layer, @Service is clearly the better
choice. Similarly, as stated above, @Repository is already supported as a marker for
automatic exception translation in your persistence layer.

142
3.10.2 Automatically detecting classes and registering bean definitions

Spring can automatically detect stereotyped classes and register

corresponding BeanDefinitions with the ApplicationContext. For example, the
following two classes are eligible for such autodetection:

@Service
public class SimpleMovieLister {

private MovieFinder movieFinder;

@Autowired
public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}
@Repository
public class JpaMovieFinder implements MovieFinder {
// implementation elided for clarity
}

To autodetect these classes and register the corresponding beans, you need to
include the following element in XML, where the base-package element is a
common parent package for the two classes. (Alternatively, you can specify a
comma-separated list that includes the parent package of each class.)

<?xml version="1.0" encoding="UTF-8"?>

<context:component-scan base-package="org.example"/>

</beans>

Note

The scanning of classpath packages requires the presence of corresponding directory entries in
the classpath. When you build JARs with Ant, make sure that you do not activate the files-only
switch of the JAR task.

Furthermore,
the AutowiredAnnotationBeanPostProcessor and CommonAnnotationBeanPostPr
ocessor are both included implicitly when you use the component-scan element.

143
That means that the two components are autodetected and wired together - all without
any bean configuration metadata provided in XML.

Note

You can disable the registration

of AutowiredAnnotationBeanPostProcessor and CommonAnnotationBeanPostProcessor by
including the annotation-config attribute with a value of false.

3.10.3 Using filters to customize scanning

By default, classes annotated with @Component, @Repository, @Service, @Controller, or

a custom annotation that itself is annotated with@Component are the only detected
candidate components. However, you can modify and extend this behavior simply
by applying custom filters. Add them as include-filter or exclude-filter sub-elements
of the component-scan element. Each filter element requires
the type and expressionattributes. The following table describes the filtering options.

Table 3.5. Filter Types

Example Expression Description

.example.SomeAnnotation An annotation to be present at the type level in target components.
.example.SomeClass A class (or interface) that the target components are assignable to (extend/implement).
.example..*Service+ An AspectJ type expression to be matched by the target components.
\.example\.Default.* A regex expression to be matched by the target components class names.
.example.MyTypeFilter A custom implementation of the org.springframework.core.type .TypeFilter interface.

The following example shows the XML configuration ignoring

all @Repository annotations and using "stub" repositories instead.

<beans>

<context:component-scan base-package="org.example">
<context:include-filter type="regex" expression=".*Stub.*Repository"/>
<context:exclude-filter type="annotation"

expression="org.springframework.stereotype.Repository"/>
</context:component-scan>

</beans>

Note

You can also disable the default filters by providing use-default-filters="false" as an attribute of

144
the <component-scan/> element. This will in effect disable automatic detection of classes
annotated with @Component, @Repository, @Service, or@Controller.

3.10.4 Defining bean metadata within components

Spring components can also contribute bean definition metadata to the container.
You do this with the same @Bean annotation used to define bean metadata
within @Configuration annotated classes. Here is a simple example:

@Component
public class FactoryMethodComponent {

@Bean @Qualifier("public")
public TestBean publicInstance() {
return new TestBean("publicInstance");
}

public void doWork() {

// Component method implementation omitted
}
}

This class is a Spring component that has application-specific code contained in

its doWork() method. However, it also contributes a bean definition that has a
factory method referring to the method publicInstance(). The @Bean annotation
identifies the factory method and other bean definition properties, such as a
qualifier value through the @Qualifier annotation. Other method level annotations
that can be specified are @Scope,@Lazy, and custom qualifier annotations. Autowired
fields and methods are supported as previously discussed, with additional support
for autowiring of @Bean methods:

@Component
public class FactoryMethodComponent {

private static int i;

@Bean @Qualifier("public")
public TestBean publicInstance() {
return new TestBean("publicInstance");
}

// use of a custom qualifier and autowiring of method parameters

@Bean @BeanAge(1)
protected TestBean protectedInstance(@Qualifier("public") TestBean spouse,

145
@Value("#{privateInstance.age}") String
country) {
TestBean tb = new TestBean("protectedInstance", 1);
tb.setSpouse(tb);
tb.setCountry(country);
return tb;
}

@Bean @Scope(BeanDefinition.SCOPE_SINGLETON)
private TestBean privateInstance() {
return new TestBean("privateInstance", i++);
}

@Bean @Scope(value = WebApplicationContext.SCOPE_SESSION,

proxyMode = ScopedProxyMode.TARGET_CLASS)
public TestBean requestScopedInstance() {
return new TestBean("requestScopedInstance", 3);
}
}

The example autowires the String method parameter country to the value of

the Age property on another bean named privateInstance. A Spring Expression
Language element defines the value of the property through the
notation #{ <expression> }. For @Value annotations, an expression resolver is
preconfigured to look for bean names when resolving expression text.

The @Bean methods in a Spring component are processed differently than their

counterparts inside a Spring @Configuration class. The difference is
that @Component classes are not enhanced with CGLIB to intercept the invocation of
methods and fields. CGLIB proxying is the means by which invoking methods or
fields within @Configuration classes @Bean methods create bean metadata
references to collaborating objects. Methods arenot invoked with normal Java
semantics. In contrast, calling a method or field within
a @Component classes @Bean method has standard Java semantics.

3.10.5 Naming autodetected components

When a component is autodetected as part of the scanning process, its bean

name is generated by the BeanNameGenerator strategy known to that scanner.
By default, any Spring stereotype annotation
(@Component, @Repository, @Service, and @Controller) that contains
a name value will thereby provide that name to the corresponding bean definition.

Note

JSR 330's @Named annotation can be used as a means to both detect components and to provide

146
them with a name. This behavior is enabled automatically if you have the JSR 330 JAR on the
classpath.

If such an annotation contains no name value or for any other detected component

(such as those discovered by custom filters), the default bean name generator
returns the uncapitalized non-qualified class name. For example, if the following
two components were detected, the names would be myMovieLister and
movieFinderImpl:

@Service("myMovieLister")
public class SimpleMovieLister {
// ...
}
@Repository
public class MovieFinderImpl implements MovieFinder {
// ...
}

Note

If you do not want to rely on the default bean-naming strategy, you can provide a custom bean-
naming strategy. First, implement the BeanNameGenerator interface, and be sure to include a
default no-arg constructor. Then, provide the fully-qualified class name when configuring the
scanner:
<beans>

<context:component-scan base-package="org.example"
name-generator="org.example.MyNameGenerator" />

</beans>

As a general rule, consider specifying the name with the annotation whenever
other components may be making explicit references to it. On the other hand, the
auto-generated names are adequate whenever the container is responsible for
wiring.

3.10.6 Providing a scope for autodetected components

As with Spring-managed components in general, the default and most common

scope for autodetected components is singleton. However, sometimes you need
other scopes, which Spring 2.5 provides with a new @Scope annotation. Simply
provide the name of the scope within the annotation:

147
@Scope("prototype")
@Repository
public class MovieFinderImpl implements MovieFinder {
// ...
}

Note

To provide a custom strategy for scope resolution rather than relying on the annotation-based
approach, implement theScopeMetadataResolver interface, and be sure to include a default no-
arg constructor. Then, provide the fully-qualified class name when configuring the scanner:
<beans>

<context:component-scan base-package="org.example"
scope-resolver="org.example.MyScopeResolver" />

</beans>

When using certain non-singleton scopes, it may be necessary to generate proxies

for the scoped objects. The reasoning is described inSection 3.5.4.5, “Scoped
beans as dependencies”. For this purpose, a scoped-proxy attribute is available on
the component-scan element. The three possible values are: no, interfaces, and
targetClass. For example, the following configuration will result in standard JDK
dynamic proxies:

<beans>

<context:component-scan base-package="org.example"
scoped-proxy="interfaces" />

</beans>

3.10.7 Providing qualifier metadata with annotations

The @Qualifier annotation is discussed in Section 3.9.3, “Fine-tuning annotation-

based autowiring with qualifiers”. The examples in that section demonstrate the
use of the @Qualifier annotation and custom qualifier annotations to provide fine-
grained control when you resolve autowire candidates. Because those examples
were based on XML bean definitions, the qualifier metadata was provided on the
candidate bean definitions using the qualifier or meta sub-elements of
the bean element in the XML. When relying upon classpath scanning for
autodetection of components, you provide the qualifier metadata with type-level
annotations on the candidate class. The following three examples demonstrate this
technique:

148
@Component
@Qualifier("Action")
public class ActionMovieCatalog implements MovieCatalog {
// ...
}
@Component
@Genre("Action")
public class ActionMovieCatalog implements MovieCatalog {
// ...
}
@Component
@Offline
public class CachingMovieCatalog implements MovieCatalog {
// ...
}

Note

As with most annotation-based alternatives, keep in mind that the annotation metadata is bound
to the class definition itself, while the use of XML allows for multiple beans of the same type to
provide variations in their qualifier metadata, because that metadata is provided per-instance
rather than per-class.

3.11 Java-based container configuration

3.11.1 Basic concepts: @Configuration and @Bean

The central artifact in Spring's new Java-configuration support is

the @Configuration-annotated class. These classes consist principally of @Bean-
annotated methods that define instantiation, configuration, and initialization logic
for objects to be managed by the Spring IoC container.

Annotating a class with the @Configuration indicates that the class can be used by

the Spring IoC container as a source of bean definitions. The simplest
possible @Configuration class would read as follows:

@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}

For those more familiar with Spring <beans/> XML, the AppConfig class above would

be equivalent to:

149
<beans>
<bean id="myService" class="com.acme.services.MyServiceImpl"/>
</beans>

As you can see, the @Bean annotation plays the same role as the <bean/> element.

The @Bean annotation will be discussed in depth in the sections below. First,
however, we'll cover the various ways of creating a spring container using Java-
based configuration.

3.11.2 Instantiating the Spring container using AnnotationConfigApplicationContext

The sections below document Spring's AnnotationConfigApplicationContext, new in

Spring 3.0. This versatile ApplicationContextimplementation is capable of accepting
not only @Configuration classes as input, but also plain @Component classes and
classes annotated with JSR-330 metadata.

When @Configuration classes are provided as input, the @Configuration class itself

is registered as a bean definition, and all declared @Beanmethods within the class
are also registered as bean definitions.

When @Component and JSR-330 classes are provided, they are registered as bean

definitions, and it is assumed that DI metadata such as @Autowired or @Inject are
used within those classes where necessary.

3.11.2.1 Simple construction

In much the same way that Spring XML files are used as input when instantiating
a ClassPathXmlApplicationContext, @Configuration classes may be used as input
when instantiating an AnnotationConfigApplicationContext. This allows for
completely XML-free usage of the Spring container:

public static void main(String[] args) {

ApplicationContext ctx = new
AnnotationConfigApplicationContext(AppConfig.class);
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}

As mentioned above, AnnotationConfigApplicationContext is not limited to working

only with @Configuration classes. Any @Component or JSR-330 annotated class may
be supplied as input to the constructor. For example:

150
public static void main(String[] args) {
ApplicationContext ctx = new
AnnotationConfigApplicationContext(MyServiceImpl.class, Dependency1.class,
Dependency2.class);
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}

The above assumes that MyServiceImpl, Dependency1 and Dependency2 use Spring

dependency injection annotations such as @Autowired.

3.11.2.2 Building the container programmatically using register(Class<?>...)

An AnnotationConfigApplicationContext may be instantiated using a no-arg

constructor and then configured using the register() method. This approach is
particularly useful when programmatically building
an AnnotationConfigApplicationContext.

public static void main(String[] args) {

AnnotationConfigApplicationContext ctx = new
AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}

3.11.2.3 Enabling component scanning with scan(String...)

Experienced Spring users will be familiar with the following commonly-used XML
declaration from Spring's context: namespace

In the example above, the com.acme package will be scanned, looking for

any @Component-annotated classes, and those classes will be registered as Spring
bean definitions within the container. AnnotationConfigApplicationContext exposes
the scan(String...) method to allow for the same component-scanning
functionality:

151
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new
AnnotationConfigApplicationContext();
ctx.scan("com.acme");
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
}

Note

Remember that @Configuration classes are meta-annotated with @Component, so they are

candidates for component-scanning! In the example above, assuming that AppConfig is declared
within the com.acme package (or any package underneath), it will be picked up during the call
to scan(), and upon refresh() all its @Bean methods will be processed and registered as bean
definitions within the container.

3.11.2.4 Support for web applications

with AnnotationConfigWebApplicationContext

A WebApplicationContext variant of AnnotationConfigApplicationContext is available

with AnnotationConfigWebApplicationContext. This implementation may be used
when configuring the Spring ContextLoaderListener servlet listener, Spring
MVC DispatcherServlet, etc. What follows is a web.xml snippet that configures a
typical Spring MVC web application. Note the use of the contextClass context-
param and init-param:

<web-app>

<context-param>
<param-name>contextClass</param-name>
<param-value>

org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</context-param>

<!-- Configuration locations must consist of one or more comma- or space-

delimited
fully-qualified @Configuration classes. Fully-qualified packages may also
be
specified for component-scanning -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.acme.AppConfig</param-value>
</context-param>

152

<listener>
<listener-
class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-
class>

<init-param>
<param-name>contextClass</param-name>
<param-value>

org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</init-param>

<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.acme.web.MvcConfig</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/main/*</url-pattern>
</servlet-mapping>
</web-app>

3.11.3 Composing Java-based configurations

3.11.3.1 Using the @Import annotation

Much as the <import/> element is used within Spring XML files to aid in

modularizing configurations, the @Import annotation allows for
loading@Bean definitions from another configuration class:

@Configuration
public class ConfigA {
public @Bean A a() { return new A(); }
}

153
@Configuration
@Import(ConfigA.class)
public class ConfigB {
public @Bean B b() { return new B(); }
}

Now, rather than needing to specify both ConfigA.class and ConfigB.class when

instantiating the context, only ConfigB needs to be supplied explicitly:

public static void main(String[] args) {

ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);

// now both beans A and B will be available...

A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}

This approach simplifies container instantiation, as only one class needs to be

dealt with, rather than requiring the developer to remember a potentially large
number of @Configuration classes during construction.

Injecting dependencies on imported @Bean definitions

The example above works, but is simplistic. In most practical scenarios, beans will
have dependencies on one another across configuration classes. When using
XML, this is not an issue, per se, because there is no compiler involved, and one
can simply declare ref="someBean" and trust that Spring will work it out during
container initialization. Of course, when using @Configuration classes, the Java
compiler places constraints on the configuration model, in that references to other
beans must be valid Java syntax.

Fortunately, solving this problem is simple. Remember that @Configuration classes

are ultimately just another bean in the container - this means that they can take
advantage of @Autowired injection metadata just like any other bean!

Let's consider a more real-world scenario with several @Configuration classes, each

depending on beans declared in the others:

@Configuration
public class ServiceConfig {
private @Autowired AccountRepository accountRepository;

public @Bean TransferService transferService() {

return new TransferServiceImpl(accountRepository);

154
}
}

@Configuration
public class RepositoryConfig {
private @Autowired DataSource dataSource;

public @Bean AccountRepository accountRepository() {

return new JdbcAccountRepository(dataSource);
}
}

@Configuration
@Import({ServiceConfig.class, RepositoryConfig.class})
public class SystemTestConfig {
public @Bean DataSource dataSource() { /* return new DataSource */ }
}

public static void main(String[] args) {

ApplicationContext ctx = new
AnnotationConfigApplicationContext(SystemTestConfig.class);
// everything wires up across configuration classes...
TransferService transferService = ctx.getBean(TransferService.class);
transferService.transfer(100.00, "A123", "C456");
}

Fully-qualifying imported beans for ease of navigation

In the scenario above, using @Autowired works well and provides the desired

modularity, but determining exactly where the autowired bean definitions are
declared is still somewhat ambiguous. For example, as a developer looking
at ServiceConfig, how do you know exactly where the@Autowired
AccountRepository bean is declared? It's not explicit in the code, and this may be
just fine. Remember that the SpringSource Tool Suite provides tooling that can
render graphs showing how everything is wired up - that may be all you need.
Also, your Java IDE can easily find all declarations and uses of
the AccountRepository type, and will quickly show you the location of @Bean methods
that return that type.

In cases where this ambiguity is not acceptable and you wish to have direct
navigation from within your IDE from one @Configuration class to another, consider
autowiring the configuration classes themselves:

@Configuration
public class ServiceConfig {
private @Autowired RepositoryConfig repositoryConfig;

public @Bean TransferService transferService() {

155
// navigate 'through' the config class to the @Bean method!
return new TransferServiceImpl(repositoryConfig.accountRepository());
}
}

In the situation above, it is completely explicit where AccountRepository is defined.

However, ServiceConfig is now tightly coupled toRepositoryConfig; that's the
tradeoff. This tight coupling can be somewhat mitigated by using interface-based
or abstract class-based@Configuration classes. Consider the following:

@Configuration
public class ServiceConfig {
private @Autowired RepositoryConfig repositoryConfig;

public @Bean TransferService transferService() {

return new TransferServiceImpl(repositoryConfig.accountRepository());
}
}

@Configuration
public interface RepositoryConfig {
@Bean AccountRepository accountRepository();
}

@Configuration
public class DefaultRepositoryConfig implements RepositoryConfig {
public @Bean AccountRepository accountRepository() {
return new JdbcAccountRepository(...);
}
}

@Configuration
@Import({ServiceConfig.class, DefaultRepositoryConfig.class}) // import the
concrete config!
public class SystemTestConfig {
public @Bean DataSource dataSource() { /* return DataSource */ }
}

public static void main(String[] args) {

ApplicationContext ctx = new
AnnotationConfigApplicationContext(SystemTestConfig.class);
TransferService transferService = ctx.getBean(TransferService.class);
transferService.transfer(100.00, "A123", "C456");
}

Now ServiceConfig is loosely coupled with respect to the

concrete DefaultRepositoryConfig, and built-in IDE tooling is still useful: it will be
easy for the developer to get a type hierarchy of RepositoryConfig implementations.
In this way, navigating @Configuration classes and their dependencies becomes no
different than the usual process of navigating interface-based code.

156
3.11.3.2 Combining Java and XML configuration

Spring's @Configuration class support does not aim to be a 100% complete

replacement for Spring XML. Some facilities such as Spring XML namespaces
remain an ideal way to configure the container. In cases where XML is convenient
or necessary, you have a choice: either instantiate the container in an "XML-
centric" way using, for example, ClassPathXmlApplicationContext, or in a "Java-
centric" fashion usingAnnotationConfigApplicationContext and
the @ImportResource annotation to import XML as needed.

XML-centric use of @Configuration classes

It may be preferable to bootstrap the Spring container from XML and

include @Configuration classes in an ad-hoc fashion. For example, in a large
existing codebase that uses Spring XML, it will be easier to
create @Configuration classes on an as-needed basis and include them from the
existing XML files. Below you'll find the options for using @Configuration classes in
this kind of "XML-centric" situation.
Declaring @Configuration classes as plain Spring <bean/> elements

Remember that @Configuration classes are ultimately just bean definitions in the

container. In this example, we create a @Configuration class named AppConfig and
include it within system-test-config.xml as a <bean/>definition.
Because <context:annotation-config/> is switched on, the container will recognize
the @Configuration annotation, and process the @Bean methods declared
in AppConfig properly.

@Configuration
public class AppConfig {
private @Autowired DataSource dataSource;

public @Bean AccountRepository accountRepository() {

return new JdbcAccountRepository(dataSource);
}

public @Bean TransferService transferService() {

return new TransferService(accountRepository());
}
}
system-test-config.xml
<beans>

<context:annotation-config/>
<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>

157
<bean class="com.acme.AppConfig"/>

<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
</beans>
jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=
public static void main(String[] args) {
ApplicationContext ctx = new
ClassPathXmlApplicationContext("classpath:/com/acme/system-test-config.xml");
TransferService transferService = ctx.getBean(TransferService.class);
// ...
}

Note

In system-test-config.xml above, the AppConfig<bean/> does not declare an id element.

While it would be acceptable to do so, it is unnecessary given that no other bean will ever refer to
it, and it is unlikely that it will be explicitly fetched from the container by name. Likewise with
the DataSource bean - it is only ever autowired by type, so an explicit bean id is not strictly
required.

Using <context:component-scan/> to pick up @Configuration classes

Because @Configuration is meta-annotated with @Component, @Configuration-

annotated classes are automatically candidates for component scanning. Using
the same scenario as above, we can redefine system-test-config.xml to take
advantage of component-scanning. Note that in this case, we don't need to
explicitly declare <context:annotation-config/>, because <context:component-
scan/> enables all the same functionality.

system-test-config.xml
<beans>

<context:component-scan base-package="com.acme"/>
<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>

@Configuration class-centric use of XML with @ImportResource

158
In applications where @Configuration classes are the primary mechanism for
configuring the container, it will still likely be necessary to use at least some XML.
In these scenarios, simply use @ImportResource and define only as much XML as is
needed. Doing so achieves a "Java-centric" approach to configuring the container
and keeps XML to a bare minimum.

@Configuration
@ImportResource("classpath:/com/acme/properties-config.xml")
public class AppConfig {
private @Value("${jdbc.url}") String url;
private @Value("${jdbc.username}") String username;
private @Value("${jdbc.password}") String password;

public @Bean DataSource dataSource() {

return new DriverManagerDataSource(url, username, password);
}
}
properties-config.xml
<beans>
<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>
</beans>
jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=
public static void main(String[] args) {
ApplicationContext ctx = new
AnnotationConfigApplicationContext(AppConfig.class);
TransferService transferService = ctx.getBean(TransferService.class);
// ...
}

3.11.4 Using the @Bean annotation

@Bean is a method-level annotation and a direct analog of the XML <bean/> element.

The annotation supports some of the attributes offered by<bean/>, such as: init-
method, destroy-method, autowiring and name.

You can use the @Bean annotation in a @Configuration-annotated or in a @Component-

annotated class.

3.11.4.1 Declaring a bean

To declare a bean, simply annotate a method with the @Bean annotation. You use

this method to register a bean definition within an ApplicationContext of the type
specified as the method's return value. By default, the bean name will be the same
as the method name. The following is a simple example of a @Bean method
declaration:

159
@Configuration
public class AppConfig {

@Bean
public TransferService transferService() {
return new TransferServiceImpl();
}

The preceding configuration is exactly equivalent to the following Spring XML:

Both declarations make a bean named transferService available in

the ApplicationContext, bound to an object instance of typeTransferServiceImpl:

transferService -> com.acme.TransferServiceImpl

3.11.4.2 Injecting dependencies

When @Beans have dependencies on one another, expressing that dependency is

as simple as having one bean method call another:

@Configuration
public class AppConfig {

@Bean
public Foo foo() {
return new Foo(bar());
}

@Bean
public Bar bar() {
return new Bar();
}

In the example above, the foo bean receives a reference to bar via constructor

injection.

160
3.11.4.3 Receiving lifecycle callbacks

Beans declared in a @Configuration-annotated class support the regular lifecycle

callbacks. Any classes defined with the @Bean annotation can use
the @PostConstruct and @PreDestroy annotations from JSR-250, see JSR-250
annotations for further details.

The regular Spring lifecycle callbacks are fully supported as well. If a bean

implements InitializingBean, DisposableBean, or Lifecycle, their respective methods
are called by the container.

The standard set of *Aware interfaces such

as BeanFactoryAware, BeanNameAware, MessageSourceAware, ApplicationContextAware, and
so on are also fully supported.

The @Bean annotation supports specifying arbitrary initialization and destruction

callback methods, much like Spring XML's init-method anddestroy-method attributes
on the bean element:

public class Foo {

public void init() {
// initialization logic
}
}

public class Bar {

public void cleanup() {
// destruction logic
}
}

@Configuration
public class AppConfig {
@Bean(initMethod = "init")
public Foo foo() {
return new Foo();
}
@Bean(destroyMethod = "cleanup")
public Bar bar() {
return new Bar();
}
}

Of course, in the case of Foo above, it would be equally as valid to call

the init() method directly during construction:

161
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
Foo foo = new Foo();
foo.init();
return foo;
}

// ...
}

Tip

When you work directly in Java, you can do anything you like with your objects and do not
always need to rely on the container lifecycle!

3.11.4.4 Specifying bean scope

Using the @Scope annotation

You can specify that your beans defined with the @Bean annotation should have a
specific scope. You can use any of the standard scopes specified in the Bean
Scopes section.

The default scope is singleton, but you can override this with the @Scope annotation:

@Configuration
public class MyConfiguration {
@Bean
@Scope("prototype")
public Encryptor encryptor() {
// ...
}
}

@Scope and scoped-proxy

Spring offers a convenient way of working with scoped dependencies

through scoped proxies. The easiest way to create such a proxy when using the
XML configuration is the <aop:scoped-proxy/> element. Configuring your beans in
Java with a @Scope annotation offers equivalent support with the proxyMode
attribute. The default is no proxy (ScopedProxyMode.NO), but you can
specify ScopedProxyMode.TARGET_CLASS orScopedProxyMode.INTERFACES.

If you port the scoped proxy example from the XML reference documentation (see
preceding link) to our @Bean using Java, it would look like the following:

162
// an HTTP Session-scoped bean exposed as a proxy
@Bean
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public UserPreferences userPreferences() {
return new UserPreferences();
}

@Bean
public Service userService() {
UserService service = new SimpleUserService();
// a reference to the proxied userPreferences bean
service.setUserPreferences(userPreferences());
return service;
}

Lookup method injection

As noted earlier, lookup method injection is an advanced feature that you should

use rarely. It is useful in cases where a singleton-scoped bean has a dependency
on a prototype-scoped bean. Using Java for this type of configuration provides a
natural means for implementing this pattern.

public abstract class CommandManager {

public Object process(Object commandState) {
// grab a new instance of the appropriate Command interface
Command command = createCommand();

// set the state on the (hopefully brand new) Command instance

command.setState(commandState);
return command.execute();
}

// okay... but where is the implementation of this method?

protected abstract Command createCommand();
}

Using Java-configuration support , you can create a subclass

of CommandManager where the abstract createCommand() method is overridden in such
a way that it looks up a new (prototype) command object:

@Bean
@Scope("prototype")
public AsyncCommand asyncCommand() {
AsyncCommand command = new AsyncCommand();
// inject dependencies here as required
return command;
}

163
@Bean
public CommandManager commandManager() {
// return new anonymous implementation of CommandManager with command()
overridden
// to return a new prototype Command object
return new CommandManager() {
protected Command createCommand() {
return asyncCommand();
}
}
}

3.11.4.5 Customizing bean naming

By default, configuration classes use a @Bean method's name as the name of the

resulting bean. This functionality can be overridden, however, with
the name attribute.

@Configuration
public class AppConfig {

@Bean(name = "myFoo")
public Foo foo() {
return new Foo();
}

3.11.4.6 Bean aliasing

As discussed in Section 3.3.1, “Naming beans”, it is sometimes desirable to give a

single bean multiple names, otherwise known as bean aliasing. The name attribute
of the @Bean annotation accepts a String array for this purpose.

@Configuration
public class AppConfig {

@Bean(name = { "dataSource", "subsystemA-dataSource", "subsystemB-dataSource" })

public DataSource dataSource() {
// instantiate, configure and return DataSource bean...
}

3.11.5 Further information about how Java-based configuration works internally

The following example shows a @Bean annotated method being called twice:

164
@Configuration
public class AppConfig {

@Bean
public ClientService clientService1() {
ClientServiceImpl clientService = new ClientServiceImpl();
clientService.setClientDao(clientDao());
return clientService;
}
@Bean
public ClientService clientService2() {
ClientServiceImpl clientService = new ClientServiceImpl();
clientService.setClientDao(clientDao());
return clientService;
}

@Bean
public ClientDao clientDao() {
return new ClientDaoImpl();
}
}

clientDao() has been called once in clientService1() and once in clientService2().

Since this method creates a new instance ofClientDaoImpl and returns it, you
would normally expect having 2 instances (one for each service). That definitely
would be problematic: in Spring, instantiated beans have a singleton scope by
default. This is where the magic comes in: All @Configuration classes are
subclassed at startup-time with CGLIB. In the subclass, the child method checks the container
first for any cached (scoped) beans before it calls the parent method and creates a new instance.

Note

The behavior could be different according to the scope of your bean. We are talking about
singletons here.
Note

Beware that, in order for JavaConfig to work, you must include the CGLIB jar in your list of
dependencies.
Note
There are a few restrictions due to the fact that CGLIB dynamically adds features at startup-time:

 Configuration classes should not be final

 They should have a constructor with no arguments

165
3.12 Registering a LoadTimeWeaver

The context namespace introduced in Spring 2.5 provides a load-time-

weaver element.

<beans>

<context:load-time-weaver/>

</beans>

Adding this element to an XML-based Spring configuration file activates a

Spring LoadTimeWeaver for the ApplicationContext. Any bean within
that ApplicationContext may implement LoadTimeWeaverAware, thereby receiving a
reference to the load-time weaver instance. This is particularly useful in
combination with Spring's JPA support where load-time weaving may be
necessary for JPA class transformation. Consult
theLocalContainerEntityManagerFactoryBean Javadoc for more detail. For more on
AspectJ load-time weaving, see Section 7.8.4, “Load-time weaving with AspectJ in
the Spring Framework”.

3.13 Additional Capabilities of the ApplicationContext

As was discussed in the chapter introduction,

the org.springframework.beans.factory package provides basic functionality for
managing and manipulating beans, including in a programmatic way.
The org.springframework.context package adds the ApplicationContext interface,
which extends the BeanFactory interface, in addition to extending other interfaces to
provide additional functionality in a more application framework-oriented style.
Many people use the ApplicationContext in a completely declarative fashion, not
even creating it programmatically, but instead relying on support classes such
as ContextLoader to automatically instantiate an ApplicationContext as part of the
normal startup process of a J2EE web application.

To enhance BeanFactory functionality in a more framework-oriented style the

context package also provides the following functionality:

 Access to messages in i18n-style, through the MessageSource interface.

 Access to resources, such as URLs and files, through
the ResourceLoader interface.

166
 Event publication to beans implementing the ApplicationListener interface,
through the use of the ApplicationEventPublisher interface.

 Loading of multiple (hierarchical) contexts, allowing each to be focused on

one particular layer, such as the web layer of an application, through
the HierarchicalBeanFactory interface.

3.13.1 Internationalization using MessageSource

The ApplicationContext interface extends an interface called MessageSource, and

therefore provides internationalization (i18n) functionality. Spring also provides the
interface HierarchicalMessageSource, which can resolve messages hierarchically.
Together these interfaces provide the foundation upon which Spring effects
message resolution. The methods defined on these interfaces include:

 String getMessage(String code, Object[] args, String default, Locale loc):

The basic method used to retrieve a message from theMessageSource. When
no message is found for the specified locale, the default message is used.
Any arguments passed in become replacement values, using
the MessageFormat functionality provided by the standard library.
 String getMessage(String code, Object[] args, Locale loc): Essentially the
same as the previous method, but with one difference: no default message
can be specified; if the message cannot be found, a NoSuchMessageException is
thrown.

 String getMessage(MessageSourceResolvable resolvable, Locale locale):

All
properties used in the preceding methods are also wrapped in a class
named MessageSourceResolvable, which you can use with this method.

When an ApplicationContext is loaded, it automatically searches for

a MessageSource bean defined in the context. The bean must have the
namemessageSource. If such a bean is found, all calls to the preceding methods are
delegated to the message source. If no message source is found,
theApplicationContext attempts to find a parent containing a bean with the same
name. If it does, it uses that bean as the MessageSource. If
theApplicationContext cannot find any source for messages, an
empty DelegatingMessageSource is instantiated in order to be able to accept calls to
the methods defined above.

Spring provides
two MessageSource implementations, ResourceBundleMessageSource and StaticMessageSo
urce. Both implementHierarchicalMessageSource in order to do nested messaging.

167
The StaticMessageSource is rarely used but provides programmatic ways to add
messages to the source. The ResourceBundleMessageSource is shown in the following
example:

<beans>
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>format</value>
<value>exceptions</value>
<value>windows</value>
</list>
</property>
</bean>
</beans>

In the example it is assumed you have three resource bundles defined in your
classpath called format, exceptions and windows. Any request to resolve a message
will be handled in the JDK standard way of resolving messages through
ResourceBundles. For the purposes of the example, assume the contents of two
of the above resource bundle files are...

# in format.properties
message=Alligators rock!
# in exceptions.properties
argument.required=The '{0}' argument is required.

A program to execute the MessageSource functionality is shown in the next example.

Remember that all ApplicationContext implementations are
also MessageSource implementations and so can be cast to
the MessageSource interface.

public static void main(String[] args) {

MessageSource resources = new ClassPathXmlApplicationContext("beans.xml");
String message = resources.getMessage("message", null, "Default", null);
System.out.println(message);
}

The resulting output from the above program will be...

Alligators rock!

168
So to summarize, the MessageSource is defined in a file called beans.xml, which exists
at the root of your classpath. The messageSource bean definition refers to a number
of resource bundles through its basenames property. The three files that are passed
in the list to the basenames property exist as files at the root of your classpath and
are called format.properties, exceptions.properties,
and windows.properties respectively.

The next example shows arguments passed to the message lookup; these
arguments will be converted into Strings and inserted into placeholders in the
lookup message.

<beans>

<bean id="example" class="com.foo.Example">
<property name="messages" ref="messageSource"/>
</bean>

</beans>
public class Example {

private MessageSource messages;

public void setMessages(MessageSource messages) {

this.messages = messages;
}

public void execute() {

String message = this.messages.getMessage("argument.required",
new Object [] {"userDao"}, "Required", null);
System.out.println(message);
}

The resulting output from the invocation of the execute() method will be...

The userDao argument is required.

With regard to internationalization (i18n), Spring's

various MessageResource implementations follow the same locale resolution and
fallback rules as the standard JDK ResourceBundle. In short, and continuing with the

169
example messageSource defined previously, if you want to resolve messages against
the British (en-GB) locale, you would create files
called format_en_GB.properties, exceptions_en_GB.properties,
andwindows_en_GB.properties respectively.

Typically, locale resolution is managed by the surrounding environment of the

application. In this example, the locale against which (British) messages will be
resolved is specified manually.

# in exceptions_en_GB.properties
argument.required=Ebagum lad, the '{0}' argument is required, I say, required.
public static void main(final String[] args) {
MessageSource resources = new ClassPathXmlApplicationContext("beans.xml");
String message = resources.getMessage("argument.required",
new Object [] {"userDao"}, "Required", Locale.UK);
System.out.println(message);
}

The resulting output from the running of the above program will be...

Ebagum lad, the 'userDao' argument is required, I say, required.

You can also use the MessageSourceAware interface to acquire a reference to

any MessageSource that has been defined. Any bean that is defined in
an ApplicationContext that implements the MessageSourceAware interface is
injected with the application context's MessageSource when the bean is created and
configured.

Note

As an alternative to ResourceBundleMessageSource, Spring provides

a ReloadableResourceBundleMessageSource class. This variant supports the same bundle file
format but is more flexible than the standard JDK
basedResourceBundleMessageSource implementation. In particular, it allows for reading files
from any Spring resource location (not just from the classpath) and supports hot reloading of
bundle property files (while efficiently caching them in between). Check out
the ReloadableResourceBundleMessageSource javadoc for details.

3.13.2 Standard and Custom Events

Event handling in the ApplicationContext is provided through

the ApplicationEvent class and ApplicationListener interface. If a bean that
implements the ApplicationListener interface is deployed into the context, every

170
time an ApplicationEvent gets published to theApplicationContext, that bean is
notified. Essentially, this is the standard Observer design pattern. Spring provides
the following standard events:

Table 3.6. Built-in Events

Explanation
Published when the ApplicationContext is initialized or refreshed, for example, using the refresh() method on
the ConfigurableApplicationContext interface. "Initialized" here means that all beans are loaded, post-processor
hedEvent
beans are detected and activated, singletons are pre-instantiated, and the ApplicationContextobject is ready for use
long as the context has not been closed, a refresh can be triggered multiple times, provided that the
chosen ApplicationContext actually supports such "hot" refreshes. For
example,XmlWebApplicationContext supports hot refreshes, but GenericApplicationContext does not.
Published when the ApplicationContext is started, using the start() method on
dEvent
theConfigurableApplicationContext interface. "Started" here means that all Lifecycle beans receive an explicit
start signal. Typically this signal is used to restart beans after an explicit stop, but it may also be used to start compon
that have not been configured for autostart , for example, components that have not already started on initialization.
Published when the ApplicationContext is stopped, using the stop() method on
dEvent theConfigurableApplicationContext interface. "Stopped" here means that all Lifecycle beans receive an explici
stop signal. A stopped context may be restarted through a start() call.
Published when the ApplicationContext is closed, using the close() method on
Event theConfigurableApplicationContext interface. "Closed" here means that all singleton beans are destroyed. A clos
context reaches its end of life; it cannot be refreshed or restarted.
dEvent
A web-specific event telling all beans that an HTTP request has been serviced. This event is published after the reque
complete. This event is only applicable to web applications using Spring's DispatcherServlet.

You can also create and publish your own custom events. This example
demonstrates a simple class that extends Spring's ApplicationEvent base class:

public class BlackListEvent extends ApplicationEvent {

private final String address;
private final String test;

public BlackListEvent(Object source, String address, String test) {

super(source);
this.address = address;
this.test = test;
}

// accessor and other methods...

}

To publish a custom ApplicationEvent, call the publishEvent() method on

an ApplicationEventPublisher. Typically this is done by creating a class that

171
implements ApplicationEventPublisherAware and registering it as a Spring bean. The
following example demonstrates such a class:

public class EmailService implements ApplicationEventPublisherAware {

private List<String> blackList;

private ApplicationEventPublisher publisher;

public void setBlackList(List<String> blackList) {

this.blackList = blackList;
}

public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {

this.publisher = publisher;
}

public void sendEmail(String address, String text) {

if (blackList.contains(address)) {
BlackListEvent event = new BlackListEvent(this, address, text);
publisher.publishEvent(event);
return;
}
// send email...
}
}

At configuration time, the Spring container will detect

that EmailService implements ApplicationEventPublisherAware and will automatically call
setApplicationEventPublisher(). In reality, the parameter passed in will be the
Spring container itself; you're simply interacting with the application context via
its ApplicationEventPublisher interface.

To receive the custom ApplicationEvent, create a class that

implements ApplicationListener and register it as a Spring bean. The following
example demonstrates such a class:

public class BlackListNotifier implements ApplicationListener<BlackListEvent> {

private String notificationAddress;

public void setNotificationAddress(String notificationAddress) {

this.notificationAddress = notificationAddress;
}

public void onApplicationEvent(BlackListEvent event) {

// notify appropriate parties via notificationAddress...
}
}

172
Notice that ApplicationListener is generically parameterized with the type of your
custom event, BlackListEvent. This means that theonApplicationEvent() method can
remain type-safe, avoiding any need for downcasting. You may register as many
event listeners as you wish, but note that by default event listeners receive events
synchronously. This means the publishEvent() method blocks until all listeners
have finished processing the event. One advantage of this synchronous and
single-threaded approach is that when a listener receives an event, it operates
inside the transaction context of the publisher if a transaction context is available.
If another strategy for event publication becomes necessary, refer to the JavaDoc
for Spring's ApplicationEventMulticaster interface.

The following example demonstrates the bean definitions used to register and
configure each of the classes above:

<bean id="emailService" class="example.EmailService">

<property name="blackList">
<list>
<value>[email protected]</value>
<value>[email protected]</value>
<value>[email protected]</value>
</list>
</property>
</bean>

<bean id="blackListNotifier" class="example.BlackListNotifier">

Putting it all together, when the sendEmail() method of the emailService bean is

called, if there are any emails that should be blacklisted, a custom event of
type BlackListEvent is published. The blackListNotifier bean is registered as
an ApplicationListener and thus receives theBlackListEvent, at which point it can notify
appropriate parties.

Note

Spring's eventing mechanism is designed for simple communication between Spring beans within
the same application context. However, for more sophisticated enterprise integration needs, the
separately-maintained Spring Integration project provides complete support for building
lightweight, pattern-oriented, event-driven architectures that build upon the well-known Spring
programming model.

173
3.13.3 Convenient access to low-level resources

For optimal usage and understanding of application contexts, users should

generally familiarize themselves with Spring's Resource abstraction, as described in
the chapter Chapter 4, Resources.

An application context is a ResourceLoader, which can be used to load Resources.

A Resource is essentially a more feature rich version of the JDK class java.net.URL,
in fact, the implementations of the Resource wrap an instance of java.net.URL where
appropriate. A Resource can obtain low-level resources from almost any location in
a transparent fashion, including from the classpath, a filesystem location,
anywhere describable with a standard URL, and some other variations. If the
resource location string is a simple path without any special prefixes, where those
resources come from is specific and appropriate to the actual application context
type.

You can configure a bean deployed into the application context to implement the
special callback interface, ResourceLoaderAware, to be automatically called back at
initialization time with the application context itself passed in as the ResourceLoader.
You can also expose properties of type Resource, to be used to access static
resources; they will be injected into it like any other properties. You can specify
those Resourceproperties as simple String paths, and rely on a special
JavaBean PropertyEditor that is automatically registered by the context, to convert
those text strings to actual Resource objects when the bean is deployed.

The location path or paths supplied to an ApplicationContext constructor are

actually resource strings, and in simple form are treated appropriately to the
specific context implementation. ClassPathXmlApplicationContext treats a simple
location path as a classpath location. You can also use location paths (resource
strings) with special prefixes to force loading of definitions from the classpath or a
URL, regardless of the actual context type.

3.13.4 Convenient ApplicationContext instantiation for web applications

You can create ApplicationContext instances declaratively by using, for example,

a ContextLoader. Of course you can also createApplicationContext instances
programmatically by using one of the ApplicationContext implementations.

The ContextLoader mechanism comes in two flavors: the ContextLoaderListener and

the ContextLoaderServlet. They have the same functionality but differ in that the
listener version is not reliable in Servlet 2.3 containers. In the Servlet 2.4
specification, Servlet context listeners must execute immediately after the Servlet

174
context for the web application is created and is available to service the first
request (and also when the Servlet context is about to be shut down). As such a
Servlet context listener is an ideal place to initialize the Spring ApplicationContext.
All things being equal, you should probably prefer ContextLoaderListener; for more
information on compatibility, have a look at the Javadoc for
theContextLoaderServlet.

You can register an ApplicationContext using the ContextLoaderListener as follows:

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-
class>
</listener>

<!-- or use the ContextLoaderServlet instead of the above listener

<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-
class>
<load-on-startup>1</load-on-startup>
</servlet>
-->

The listener inspects the contextConfigLocation parameter. If the parameter does

not exist, the listener uses /WEB-INF/applicationContext.xmlas a default. When the
parameter does exist, the listener separates the String by using predefined
delimiters (comma, semicolon and whitespace) and uses the values as locations
where application contexts will be searched. Ant-style path patterns are supported
as well. Examples are /WEB-INF/*Context.xml for all files with names ending with
"Context.xml", residing in the "WEB-INF" directory, and /WEB-INF/**/*Context.xml,
for all such files in any subdirectory of "WEB-INF".

You can use ContextLoaderServlet instead of ContextLoaderListener. The Servlet

uses the contextConfigLocation parameter just as the listener does.

3.13.5 Deploying a Spring ApplicationContext as a J2EE RAR file

In Spring 2.5 and later, it is possible to deploy a Spring ApplicationContext as a

RAR file, encapsulating the context and all of its required bean classes and library
JARs in a J2EE RAR deployment unit. This is the equivalent of bootstrapping a
standalone ApplicationContext, just hosted in J2EE environment, being able to

175
access the J2EE servers facilities. RAR deployment is a more natural alternative
to scenario of deploying a headless WAR file, in effect, a WAR file without any
HTTP entry points that is used only for bootstrapping a Spring ApplicationContext
in a J2EE environment.

RAR deployment is ideal for application contexts that do not need HTTP entry
points but rather consist only of message endpoints and scheduled jobs. Beans in
such a context can use application server resources such as the JTA transaction
manager and JNDI-bound JDBC DataSources and JMS ConnectionFactory
instances, and may also register with the platform's JMX server - all through
Spring's standard transaction management and JNDI and JMX support facilities.
Application components can also interact with the application server's JCA
WorkManager through Spring'sTaskExecutor abstraction.

Check out the JavaDoc of the SpringContextResourceAdapter class for the

configuration details involved in RAR deployment.

For a simple deployment of a Spring ApplicationContext as a J2EE RAR

file: package all application classes into a RAR file, which is a standard JAR file
with a different file extension. Add all required library JARs into the root of the RAR
archive. Add a "META-INF/ra.xml" deployment descriptor (as shown
in SpringContextResourceAdapters JavaDoc) and the corresponding Spring XML bean
definition file(s) (typically "META-INF/applicationContext.xml"), and drop the resulting RAR file
into your application server's deployment directory.

Note

Such RAR deployment units are usually self-contained; they do not expose components to the
outside world, not even to other modules of the same application. Interaction with a RAR-based
ApplicationContext usually occurs through JMS destinations that it shares with other modules. A
RAR-based ApplicationContext may also, for example, schedule some jobs, reacting to new files
in the file system (or the like). If it needs to allow synchronous access from the outside, it could
for example export RMI endpoints, which of course may be used by other application modules on
the same machine.

3.14 The BeanFactory

The BeanFactory provides the underlying basis for Spring's IoC functionality but it is

only used directly in integration with other third-party frameworks and is now
largely historical in nature for most users of Spring. The BeanFactory and related
interfaces, such as BeanFactoryAware,InitializingBean, DisposableBean, are still
present in Spring for the purposes of backward compatibility with the large number
of third-party frameworks that integrate with Spring. Often third-party components

176
that can not use more modern equivalents such as @PostConstruct or@PreDestroy in
order to remain compatible with JDK 1.4 or to avoid a dependency on JSR-250.

This section provides additional background into the differences between

the BeanFactory and ApplicationContext and how one might access the IoC
container directly through a classic singleton lookup.

3.14.1 BeanFactory or ApplicationContext?

Use an ApplicationContext unless you have a good reason for not doing so.

Because the ApplicationContext includes all functionality of the BeanFactory, it is

generally recommended over the BeanFactory, except for a few situations such as
in an Applet where memory consumption might be critical and a few extra kilobytes
might make a difference. However, for most typical enterprise applications and
systems, the ApplicationContext is what you will want to use. Spring 2.0 and later
makes heavy use of theBeanPostProcessor extension point (to effect proxying and so
on). If you use only a plain BeanFactory, a fair amount of support such as
transactions and AOP will not take effect, at least not without some extra steps on
your part. This situation could be confusing because nothing is actually wrong with
the configuration.

The following table lists features provided by

the BeanFactory and ApplicationContext interfaces and implementations.

Table 3.7. Feature Matrix

Feature BeanFactory ApplicationContext

Bean instantiation/wiring Yes Yes

Automatic BeanPostProcessor registration No Yes

Automatic BeanFactoryPostProcessor registration No Yes

Convenient MessageSource access (for i18n) No Yes

ApplicationEvent publication No Yes

To explicitly register a bean post-processor with a BeanFactory implementation, you

must write code like this:

177
ConfigurableBeanFactory factory = new XmlBeanFactory(...);

// now register any needed BeanPostProcessor instances

MyBeanPostProcessor postProcessor = new MyBeanPostProcessor();
factory.addBeanPostProcessor(postProcessor);

// now start using the factory

To explicitly register a BeanFactoryPostProcessor when using

a BeanFactory implementation, you must write code like this:

XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml"));

// bring in some property values from a Properties file

PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.setLocation(new FileSystemResource("jdbc.properties"));

// now actually do the replacement

cfg.postProcessBeanFactory(factory);

In both cases, the explicit registration step is inconvenient, which is one reason
why the various ApplicationContext implementations are preferred above
plain BeanFactory implementations in the vast majority of Spring-backed
applications, especially when
using BeanFactoryPostProcessorsand BeanPostProcessors. These mechanisms
implement important functionality such as property placeholder replacement and
AOP.

3.14.2 Glue code and the evil singleton

It is best to write most application code in a dependency-injection (DI) style, where

that code is served out of a Spring IoC container, has its own dependencies
supplied by the container when it is created, and is completely unaware of the
container. However, for the small glue layers of code that are sometimes needed
to tie other code together, you sometimes need a singleton (or quasi-singleton)
style access to a Spring IoC container. For example, third-party code may try to
construct new objects directly (Class.forName() style), without the ability to get
these objects out of a Spring IoC container. If the object constructed by the third-
party code is a small stub or proxy, which then uses a singleton style access to a
Spring IoC container to get a real object to delegate to, then inversion of control
has still been achieved for the majority of the code (the object coming out of the
container). Thus most code is still unaware of the container or how it is accessed,
and remains decoupled from other code, with all ensuing benefits. EJBs may also
use this stub/proxy approach to delegate to a plain Java implementation object,

178
retrieved from a Spring IoC container. While the Spring IoC container itself ideally
does not have to be a singleton, it may be unrealistic in terms of memory usage or
initialization times (when using beans in the Spring IoC container such as a
Hibernate SessionFactory) for each bean to use its own, non-singleton Spring IoC
container.

Looking up the application context in a service locator style is sometimes the only
option for accessing shared Spring-managed components, such as in an EJB 2.1
environment, or when you want to share a single ApplicationContext as a parent to
WebApplicationContexts across WAR files. In this case you should look into using
the utility class ContextSingletonBeanFactoryLocator locator that is described in
this SpringSource team blog entry.

[1]
See Background
[2]
See Section 3.4.1, “Dependency injection”

4. Resources

4.1 Introduction

Java's standard java.net.URL class and standard handlers for various URL prefixes

unfortunately are not quite adequate enough for all access to low-level resources.
For example, there is no standardized URL implementation that may be used to
access a resource that needs to be obtained from the classpath, or relative to
a ServletContext. While it is possible to register new handlers for
specialized URL prefixes (similar to existing handlers for prefixes such as http:), this
is generally quite complicated, and the URL interface still lacks some desirable
functionality, such as a method to check for the existence of the resource being
pointed to.

4.2 The Resource interface

Spring's Resource interface is meant to be a more capable interface for abstracting

access to low-level resources.

public interface Resource extends InputStreamSource {

boolean exists();

179
boolean isOpen();

URL getURL() throws IOException;

File getFile() throws IOException;

Resource createRelative(String relativePath) throws IOException;

String getFilename();

String getDescription();
}
public interface InputStreamSource {

InputStream getInputStream() throws IOException;

}

Some of the most important methods from the Resource interface are:

 getInputStream(): locates and opens the resource, returning

an InputStream for reading from the resource. It is expected that each
invocation returns a fresh InputStream. It is the responsibility of the caller to
close the stream.
 exists(): returns a boolean indicating whether this resource actually exists in
physical form.

 isOpen(): returns a boolean indicating whether this resource represents a

handle with an open stream. If true, the InputStream cannot be read multiple
times, and must be read once only and then closed to avoid resource leaks.
Will be false for all usual resource implementations, with the exception
of InputStreamResource.

 getDescription():
returns a description for this resource, to be used for error
output when working with the resource. This is often the fully qualified file
name or the actual URL of the resource.

Other methods allow you to obtain an actual URL or File object representing the

resource (if the underlying implementation is compatible, and supports that
functionality).

The Resource abstraction is used extensively in Spring itself, as an argument type

in many method signatures when a resource is needed. Other methods in some
Spring APIs (such as the constructors to
various ApplicationContext implementations), take a String which in unadorned or

180
simple form is used to create a Resource appropriate to that context
implementation, or via special prefixes on the String path, allow the caller to
specify that a specific Resource implementation must be created and used.

While the Resource interface is used a lot with Spring and by Spring, it's actually
very useful to use as a general utility class by itself in your own code, for access to
resources, even when your code doesn't know or care about any other parts of
Spring. While this couples your code to Spring, it really only couples it to this small
set of utility classes, which are serving as a more capable replacement for URL, and
can be considered equivalent to any other library you would use for this purpose.

It is important to note that the Resource abstraction does not replace functionality: it

wraps it where possible. For example, a UrlResource wraps a URL, and uses the
wrapped URL to do its work.

4.3 Built-in Resource implementations

There are a number of Resource implementations that come supplied straight out of

the box in Spring:

4.3.1 UrlResource

The UrlResource wraps a java.net.URL, and may be used to access any object that

is normally accessible via a URL, such as files, an HTTP target, an FTP target,
etc. All URLs have a standardized String representation, such that appropriate
standardized prefixes are used to indicate one URL type from another. This
includes file: for accessing filesystem paths, http: for accessing resources via the
HTTP protocol, ftp: for accessing resources via FTP, etc.

A UrlResource is created by Java code explicitly using the UrlResource constructor,

but will often be created implicitly when you call an API method which takes
a String argument which is meant to represent a path. For the latter case, a
JavaBeans PropertyEditor will ultimately decide which type of Resource to create. If
the path string contains a few well-known (to it, that is) prefixes such as classpath:,
it will create an appropriate specialized Resource for that prefix. However, if it
doesn't recognize the prefix, it will assume the this is just a standard URL string,
and will create aUrlResource.

181
4.3.2 ClassPathResource

This class represents a resource which should be obtained from the classpath.
This uses either the thread context class loader, a given class loader, or a given
class for loading resources.

This Resource implementation supports resolution as java.io.File if the class path

resource resides in the file system, but not for classpath resources which reside in
a jar and have not been expanded (by the servlet engine, or whatever the
environment is) to the filesystem. To address this the
various Resource implementations always support resolution as a java.net.URL.

A ClassPathResource is created by Java code explicitly using

the ClassPathResource constructor, but will often be created implicitly when you call
an API method which takes a String argument which is meant to represent a path.
For the latter case, a JavaBeans PropertyEditor will recognize the special
prefix classpath:on the string path, and create a ClassPathResource in that case.

4.3.3 FileSystemResource

This is a Resource implementation for java.io.File handles. It obviously supports

resolution as a File, and as a URL.

4.3.4 ServletContextResource

This is a Resource implementation for ServletContext resources, interpreting relative

paths within the relevant web application's root directory.

This always supports stream access and URL access, but only
allows java.io.File access when the web application archive is expanded and the
resource is physically on the filesystem. Whether or not it's expanded and on the
filesystem like this, or accessed directly from the JAR or somewhere else like a DB
(it's conceivable) is actually dependent on the Servlet container.

4.3.5 InputStreamResource

A Resource implementation for a given InputStream. This should only be used if no

specific Resource implementation is applicable. In particular,
prefer ByteArrayResource or any of the file-based Resource implementations where
possible.

182
In contrast to other Resource implementations, this is a descriptor for
an already opened resource - therefore returning true from isOpen(). Do not use it
if you need to keep the resource descriptor somewhere, or if you need to read a
stream multiple times.

4.3.6 ByteArrayResource

This is a Resource implementation for a given byte array. It creates

a ByteArrayInputStream for the given byte array.

It's useful for loading content from any given byte array, without having to resort to
a single-use InputStreamResource.

4.4 The ResourceLoader

The ResourceLoader interface is meant to be implemented by objects that can return

(i.e. load) Resource instances.

public interface ResourceLoader {

Resource getResource(String location);
}

All application contexts implement the ResourceLoader interface, and therefore all

application contexts may be used to obtain Resource instances.

When you call getResource() on a specific application context, and the location path
specified doesn't have a specific prefix, you will get back a Resource type that is
appropriate to that particular application context. For example, assume the
following snippet of code was executed against
aClassPathXmlApplicationContext instance:

Resource template = ctx.getResource("some/resource/path/myTemplate.txt");

What would be returned would be a ClassPathResource; if the same method was

executed against a FileSystemXmlApplicationContext instance, you'd get back
a FileSystemResource. For a WebApplicationContext, you'd get back
a ServletContextResource, and so on.

As such, you can load resources in a fashion appropriate to the particular

application context.

183
On the other hand, you may also force ClassPathResource to be used, regardless of
the application context type, by specifying the specialclasspath: prefix:

Resource template =
ctx.getResource("classpath:some/resource/path/myTemplate.txt");

Similarly, one can force a UrlResource to be used by specifying any of the

standard java.net.URL prefixes:

Resource template = ctx.getResource("file:/some/resource/path/myTemplate.txt");

Resource template =
ctx.getResource("http://myhost.com/resource/path/myTemplate.txt");

The following table summarizes the strategy for converting Strings to Resources:

Table 4.1. Resource strings

Prefix Example Explanation

classpath classpath:com/myapp/config.xml
Loaded from the classpath.
:

file: file:/data/config.xml Loaded as a URL, from the filesystem. [1]

http: http://myserver/logo.png Loaded as a URL.

(none) /data/config.xml Depends on the underlying ApplicationContext.

[1]
But see also Section 4.7.3, “FileSystemResource caveats”.

4.5 The ResourceLoaderAware interface

The ResourceLoaderAware interface is a special marker interface, identifying objects

that expect to be provided with a ResourceLoader reference.

public interface ResourceLoaderAware {

void setResourceLoader(ResourceLoader resourceLoader);

}

184
When a class implements ResourceLoaderAware and is deployed into an application
context (as a Spring-managed bean), it is recognized asResourceLoaderAware by the
application context. The application context will then invoke
the setResourceLoader(ResourceLoader), supplying itself as the argument (remember,
all application contexts in Spring implement the ResourceLoader interface).

Of course, since an ApplicationContext is a ResourceLoader, the bean could also

implement the ApplicationContextAware interface and use the supplied application
context directly to load resources, but in general, it's better to use the
specialized ResourceLoader interface if that's all that's needed. The code would just
be coupled to the resource loading interface, which can be considered a utility
interface, and not the whole SpringApplicationContext interface.

As of Spring 2.5, you can rely upon autowiring of the ResourceLoader as an

alternative to implementing the ResourceLoaderAware interface. The
"traditional" constructor and byType autowiring modes (as described
in Section 3.4.5, “Autowiring collaborators”) are now capable of providing a
dependency of type ResourceLoader for either a constructor argument or setter
method parameter respectively. For more flexibility (including the ability to autowire
fields and multiple parameter methods), consider using the new annotation-based
autowiring features. In that case, theResourceLoader will be autowired into a field,
constructor argument, or method parameter that is expecting
the ResourceLoader type as long as the field, constructor, or method in question
carries the @Autowired annotation. For more information, see Section 3.9.2,
“@Autowired and @Inject”.

4.6 Resources as dependencies

If the bean itself is going to determine and supply the resource path through some
sort of dynamic process, it probably makes sense for the bean to use
the ResourceLoader interface to load resources. Consider as an example the loading
of a template of some sort, where the specific resource that is needed depends on
the role of the user. If the resources are static, it makes sense to eliminate the use
of the ResourceLoader interface completely, and just have the bean expose
the Resource properties it needs, and expect that they will be injected into it.

What makes it trivial to then inject these properties, is that all application contexts
register and use a special JavaBeans PropertyEditor which can
convert String paths to Resource objects. So if myBean has a template property of
type Resource, it can be configured with a simple string for that resource, as follows:

185
<bean id="myBean" class="...">
<property name="template" value="some/resource/path/myTemplate.txt"/>
</bean>

Note that the resource path has no prefix, so because the application context itself
is going to be used as the ResourceLoader, the resource itself will be loaded via
a ClassPathResource, FileSystemResource, or ServletContextResource (as appropriate)
depending on the exact type of the context.

If there is a need to force a specific Resource type to be used, then a prefix may be

used. The following two examples show how to force a ClassPathResource and
a UrlResource (the latter being used to access a filesystem file).

<property name="template" value="classpath:some/resource/path/myTemplate.txt">

4.7 Application contexts and Resource paths

4.7.1 Constructing application contexts

An application context constructor (for a specific application context type) generally

takes a string or array of strings as the location path(s) of the resource(s) such as
XML files that make up the definition of the context.

When such a location path doesn't have a prefix, the specific Resource type built
from that path and used to load the bean definitions, depends on and is
appropriate to the specific application context. For example, if you create
a ClassPathXmlApplicationContext as follows:

ApplicationContext ctx = new

ClassPathXmlApplicationContext("conf/appContext.xml");

The bean definitions will be loaded from the classpath, as a ClassPathResource will

be used. But if you create aFileSystemXmlApplicationContext as follows:

ApplicationContext ctx =
new FileSystemXmlApplicationContext("conf/appContext.xml");

The bean definition will be loaded from a filesystem location, in this case relative to
the current working directory.

186
Note that the use of the special classpath prefix or a standard URL prefix on the
location path will override the default type of Resource created to load the definition.
So this FileSystemXmlApplicationContext...

ApplicationContext ctx =
new FileSystemXmlApplicationContext("classpath:conf/appContext.xml");

... will actually load its bean definitions from the classpath. However, it is still
a FileSystemXmlApplicationContext. If it is subsequently used as a ResourceLoader,
any unprefixed paths will still be treated as filesystem paths.

4.7.1.1 Constructing ClassPathXmlApplicationContext instances - shortcuts

The ClassPathXmlApplicationContext exposes a number of constructors to enable

convenient instantiation. The basic idea is that one supplies merely a string array
containing just the filenames of the XML files themselves (without the leading path
information), and one also supplies a Class; the ClassPathXmlApplicationContext will
derive the path information from the supplied class.

An example will hopefully make this clear. Consider a directory layout that looks
like this:

com/
foo/
services.xml
daos.xml
MessengerService.class

A ClassPathXmlApplicationContext instance composed of the beans defined in

the 'services.xml' and 'daos.xml' could be instantiated like so...

ApplicationContext ctx = new ClassPathXmlApplicationContext(

new String[] {"services.xml", "daos.xml"}, MessengerService.class);

Please do consult the Javadocs for the ClassPathXmlApplicationContext class for

details of the various constructors.

4.7.2 Wildcards in application context constructor resource paths

The resource paths in application context constructor values may be a simple path
(as shown above) which has a one-to-one mapping to a target Resource, or
alternately may contain the special "classpath*:" prefix and/or internal Ant-style

187
regular expressions (matched using Spring'sPathMatcher utility). Both of the latter
are effectively wildcards

One use for this mechanism is when doing component-style application assembly.
All components can 'publish' context definition fragments to a well-known location
path, and when the final application context is created using the same path
prefixed via classpath*:, all component fragments will be picked up automatically.

Note that this wildcarding is specific to use of resource paths in application context
constructors (or when using the PathMatcher utility class hierarchy directly), and is
resolved at construction time. It has nothing to do with the Resource type itself. It's
not possible to use the classpath*:prefix to construct an actual Resource, as a
resource points to just one resource at a time.

4.7.2.1 Ant-style Patterns

When the path location contains an Ant-style pattern, for example:

/WEB-INF/*-context.xml
com/mycompany/**/applicationContext.xml
file:C:/some/path/*-context.xml
classpath:com/mycompany/**/applicationContext.xml

... the resolver follows a more complex but defined procedure to try to resolve the
wildcard. It produces a Resource for the path up to the last non-wildcard segment
and obtains a URL from it. If this URL is not a "jar:" URL or container-specific
variant (e.g. "zip:" in WebLogic, "wsjar" in WebSphere, etc.), then a java.io.File is
obtained from it and used to resolve the wildcard by traversing the filesystem. In
the case of a jar URL, the resolver either gets a java.net.JarURLConnection from it or
manually parses the jar URL and then traverses the contents of the jar file to
resolve the wildcards.

Implications on portability

If the specified path is already a file URL (either explicitly, or implicitly because the
base ResourceLoader is a filesystem one, then wildcarding is guaranteed to work in
a completely portable fashion.

If the specified path is a classpath location, then the resolver must obtain the last
non-wildcard path segment URL via aClassloader.getResource() call. Since this is
just a node of the path (not the file at the end) it is actually undefined (in
the ClassLoader Javadocs) exactly what sort of a URL is returned in this case. In

188
practice, it is always a java.io.File representing the directory, where the classpath
resource resolves to a filesystem location, or a jar URL of some sort, where the
classpath resource resolves to a jar location. Still, there is a portability concern on
this operation.

If a jar URL is obtained for the last non-wildcard segment, the resolver must be
able to get a java.net.JarURLConnection from it, or manually parse the jar URL, to be
able to walk the contents of the jar, and resolve the wildcard. This will work in most
environments, but will fail in others, and it is strongly recommended that the
wildcard resolution of resources coming from jars be thoroughly tested in your
specific environment before you rely on it.

4.7.2.2 The classpath*: prefix

When constructing an XML-based application context, a location string may use

the special classpath*: prefix:

ApplicationContext ctx =
new ClassPathXmlApplicationContext("classpath*:conf/appContext.xml");

This special prefix specifies that all classpath resources that match the given name
must be obtained (internally, this essentially happens via
aClassLoader.getResources(...) call), and then merged to form the final application context
definition.

Classpath*: portability

The wildcard classpath relies on the getResources() method of the underlying classloader. As

most application servers nowadays supply their own classloader implementation, the behavior
might differ especially when dealing with jar files. A simple test to check if classpath* works is
to use the classloader to load a file from within a jar on the
classpath:getClass().getClassLoader().getResources("<someFileInsideTheJar>"). Try
this test with files that have the same name but are placed inside two different locations. In case
an inappropriate result is returned, check the application server documentation for settings that
might affect the classloader behavior.

The "classpath*:" prefix can also be combined with a PathMatcher pattern in the rest
of the location path, for example "classpath*:META-INF/*-beans.xml". In this case, the
resolution strategy is fairly simple: a ClassLoader.getResources() call is used on
the last non-wildcard path segment to get all the matching resources in the class
loader hierarchy, and then off each resource the same PathMatcher resoltion
strategy described above is used for the wildcard subpath.

189
4.7.2.3 Other notes relating to wildcards

Please note that "classpath*:" when combined with Ant-style patterns will only
work reliably with at least one root directory before the pattern starts, unless the
actual target files reside in the file system. This means that a pattern like
"classpath*:*.xml" will not retrieve files from the root of jar files but rather only from
the root of expanded directories. This originates from a limitation in the
JDK's ClassLoader.getResources() method which only returns file system locations
for a passed-in empty string (indicating potential roots to search).

Ant-style patterns with "classpath:" resources are not guaranteed to find matching
resources if the root package to search is available in multiple class path locations.
This is because a resource such as

com/mycompany/package1/service-context.xml

may be in only one location, but when a path such as

classpath:com/mycompany/**/service-context.xml

is used to try to resolve it, the resolver will work off the (first) URL returned
by getResource("com/mycompany");. If this base package node exists in multiple
classloader locations, the actual end resource may not be underneath. Therefore,
preferably, use "classpath*:" with the same Ant-style pattern in such a case, which
will search all class path locations that contain the root package.

4.7.3 FileSystemResource caveats

A FileSystemResource that is not attached to a FileSystemApplicationContext (that is,

a FileSystemApplicationContext is not the actualResourceLoader) will treat absolute
vs. relative paths as you would expect. Relative paths are relative to the current
working directory, while absolute paths are relative to the root of the filesystem.

For backwards compatibility (historical) reasons however, this changes when

the FileSystemApplicationContext is the ResourceLoader.
TheFileSystemApplicationContext simply forces all
attached FileSystemResource instances to treat all location paths as relative,
whether they start with a leading slash or not. In practice, this means the following
are equivalent:

190
ApplicationContext ctx =
new FileSystemXmlApplicationContext("conf/context.xml");
ApplicationContext ctx =
new FileSystemXmlApplicationContext("/conf/context.xml");

As are the following: (Even though it would make sense for them to be different, as
one case is relative and the other absolute.)

FileSystemXmlApplicationContext ctx = ...;

ctx.getResource("some/resource/path/myTemplate.txt");
FileSystemXmlApplicationContext ctx = ...;
ctx.getResource("/some/resource/path/myTemplate.txt");

In practice, if true absolute filesystem paths are needed, it is better to forgo the use
of absolute paths with FileSystemResource /FileSystemXmlApplicationContext, and just
force the use of a UrlResource, by using the file: URL prefix.

// actual context type doesn't matter, the Resource will always be UrlResource
ctx.getResource("file:/some/resource/path/myTemplate.txt");
// force this FileSystemXmlApplicationContext to load its definition via a
UrlResource
ApplicationContext ctx =
new FileSystemXmlApplicationContext("file:/conf/context.xml");

5. Validation, Data Binding, and Type Conversion

5.1 Introduction

There are pros and cons for considering validation as business logic, and Spring
offers a design for validation (and data binding) that does not exclude either one of
them. Specifically validation should not be tied to the web tier, should be easy to
localize and it should be possible to plug in any validator available. Considering
the above, Spring has come up with a Validator interface that is both basic ands
eminently usable in every layer of an application.

Data binding is useful for allowing user input to be dynamically bound to the
domain model of an application (or whatever objects you use to process user
input). Spring provides the so-called DataBinder to do exactly that.
The Validator and the DataBinder make up the validationpackage, which is
primarily used in but not limited to the MVC framework.

The BeanWrapper is a fundamental concept in the Spring Framework and is used in

a lot of places. However, you probably will not have the need to use

191
the BeanWrapper directly. Because this is reference documentation however, we felt
that some explanation might be in order. We will explain theBeanWrapper in this
chapter since, if you were going to use it at all, you would most likely do so when
trying to bind data to objects.

Spring's DataBinder and the lower-level BeanWrapper both use PropertyEditors to

parse and format property values. The PropertyEditor concept is part of the
JavaBeans specification, and is also explained in this chapter. Spring 3 introduces
a "core.convert" package that provides a general type conversion facility, as well
as a higher-level "format" package for formatting UI field values. These new
packages may be used as simpler alternatives to PropertyEditors, and will also be
discussed in this chapter.

5.2 Validation using Spring's Validator interface

Spring features a Validator interface that you can use to validate objects.

The Validator interface works using an Errors object so that while validating,
validators can report validation failures to the Errors object.

Let's consider a small data object:

public class Person {

private String name;

private int age;

// the usual getters and setters...

}

We're going to provide validation behavior for the Person class by implementing the

following two methods of theorg.springframework.validation.Validator interface:

 supports(Class) -Can this Validator validate instances of the supplied Class?

 validate(Object, org.springframework.validation.Errors) - validates the given
object and in case of validation errors, registers those with the
given Errors object

Implementing a Validator is fairly straightforward, especially when you know of

the ValidationUtils helper class that the Spring Framework also provides.

public class PersonValidator implements Validator {

/**

192
* This Validator validates just Person instances
*/
public boolean supports(Class clazz) {
return Person.class.equals(clazz);
}

public void validate(Object obj, Errors e) {

ValidationUtils.rejectIfEmpty(e, "name", "name.empty");
Person p = (Person) obj;
if (p.getAge() < 0) {
e.rejectValue("age", "negativevalue");
} else if (p.getAge() > 110) {
e.rejectValue("age", "too.darn.old");
}
}
}

As you can see, the static rejectIfEmpty(..) method on the ValidationUtils class

is used to reject the 'name' property if it is null or the empty string. Have a look at
the Javadoc for the ValidationUtils class to see what functionality it provides
besides the example shown previously.

While it is certainly possible to implement a single Validator class to validate each

of the nested objects in a rich object, it may be better to encapsulate the validation
logic for each nested class of object in its own Validator implementation. A simple
example of a 'rich' object would be aCustomer that is composed of
two String properties (a first and second name) and a
complex Address object. Address objects may be used independently
of Customer objects, and so a distinct AddressValidator has been implemented. If
you want your CustomerValidator to reuse the logic contained within
the AddressValidator class without resorting to copy-and-paste, you can
dependency-inject or instantiate anAddressValidator within your CustomerValidator,
and use it like so:

public class CustomerValidator implements Validator {

private final Validator addressValidator;

public CustomerValidator(Validator addressValidator) {

if (addressValidator == null) {
throw new IllegalArgumentException(
"The supplied [Validator] is required and must not be null.");
}
if (!addressValidator.supports(Address.class)) {
throw new IllegalArgumentException(
"The supplied [Validator] must support the validation of [Address]
instances.");

193
}
this.addressValidator = addressValidator;
}

/**
* This Validator validates Customer instances, and any subclasses of Customer
too
*/
public boolean supports(Class clazz) {
return Customer.class.isAssignableFrom(clazz);
}

public void validate(Object target, Errors errors) {

ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName",
"field.required");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "surname",
"field.required");
Customer customer = (Customer) target;
try {
errors.pushNestedPath("address");
ValidationUtils.invokeValidator(this.addressValidator,
customer.getAddress(), errors);
} finally {
errors.popNestedPath();
}
}
}

Validation errors are reported to the Errors object passed to the validator. In case

of Spring Web MVC you can use <spring:bind/> tag to inspect the error messages,
but of course you can also inspect the errors object yourself. More information
about the methods it offers can be found from the Javadoc.

5.3 Resolving codes to error messages

We've talked about databinding and validation. Outputting messages

corresponding to validation errors is the last thing we need to discuss. In the
example we've shown above, we rejected the name and the age field. If we're going
to output the error messages by using a MessageSource, we will do so using the error
code we've given when rejecting the field ('name' and 'age' in this case). When you
call (either directly, or indirectly, using for example
the ValidationUtils class) rejectValue or one of the other reject methods from
the Errors interface, the underlying implementation will not only register the code
you've passed in, but also a number of additional error codes. What error codes it
registers is determined by theMessageCodesResolver that is used. By default,
the DefaultMessageCodesResolver is used, which for example not only registers a
message with the code you gave, but also messages that include the field name
you passed to the reject method. So in case you reject a field

194
usingrejectValue("age", "too.darn.old"), apart from the too.darn.old code, Spring
will also register too.darn.old.age and too.darn.old.age.int(so the first will include
the field name and the second will include the type of the field); this is done as a
convenience to aid developers in targeting error messages and suchlike.

More information on the MessageCodesResolver and the default strategy can be found

online with the Javadocs
for MessageCodesResolver andDefaultMessageCodesResolver respectively.

5.4 Bean manipulation and the BeanWrapper

The org.springframework.beans package adheres to the JavaBeans standard

provided by Sun. A JavaBean is simply a class with a default no-argument
constructor, which follows a naming convention where (by way of an example) a
property named bingoMadness would have a setter method setBingoMadness(..) and
a getter method getBingoMadness(). For more information about JavaBeans and the
specification, please refer to Sun's website ( java.sun.com/products/javabeans).

One quite important class in the beans package is the BeanWrapper interface and its
corresponding implementation (BeanWrapperImpl). As quoted from the Javadoc,
the BeanWrapper offers functionality to set and get property values (individually or in
bulk), get property descriptors, and to query properties to determine if they are
readable or writable. Also, the BeanWrapper offers support for nested properties,
enabling the setting of properties on sub-properties to an unlimited depth. Then,
the BeanWrapper supports the ability to add standard
JavaBeansPropertyChangeListeners and VetoableChangeListeners, without the need
for supporting code in the target class. Last but not least, the BeanWrapper provides
support for the setting of indexed properties. The BeanWrapper usually isn't used by
application code directly, but by theDataBinder and the BeanFactory.

The way the BeanWrapper works is partly indicated by its name: it wraps a bean to

perform actions on that bean, like setting and retrieving properties.

5.4.1 Setting and getting basic and nested properties

Setting and getting properties is done using

the setPropertyValue(s) and getPropertyValue(s) methods that both come with a
couple of overloaded variants. They're all described in more detail in the Javadoc
Spring comes with. What's important to know is that there are a couple of
conventions for indicating properties of an object. A couple of examples:

Table 5.1. Examples of properties

195
on Explanation
Indicates the property name corresponding to the methods getName() or isName() and setName(..)
Indicates the nested property name of the property account corresponding e.g. to the
methodsgetAccount().setName() or getAccount().getName()
Indicates the third element of the indexed property account. Indexed properties can be of type array, list or
other naturally ordered collection
NYNAME] Indicates the value of the map entry indexed by the key COMPANYNAME of the Map property account

Below you'll find some examples of working with the BeanWrapper to get and set
properties.

(This next section is not vitally important to you if you're not planning to work with
the BeanWrapper directly. If you're just using the DataBinderand the BeanFactory and
their out-of-the-box implementation, you should skip ahead to the section
about PropertyEditors.)

Consider the following two classes:

public class Company {

private String name;
private Employee managingDirector;

public String getName() {

return this.name;
}
public void setName(String name) {
this.name = name;
}
public Employee getManagingDirector() {
return this.managingDirector;
}
public void setManagingDirector(Employee managingDirector) {
this.managingDirector = managingDirector;
}
}
public class Employee {
private String name;
private float salary;

public String getName() {

return this.name;
}
public void setName(String name) {
this.name = name;
}
public float getSalary() {
return salary;

196
}
public void setSalary(float salary) {
this.salary = salary;
}
}

The following code snippets show some examples of how to retrieve and
manipulate some of the properties of instantiated Companies andEmployees:

BeanWrapper company = BeanWrapperImpl(new Company());

// setting the company name..
company.setPropertyValue("name", "Some Company Inc.");
// ... can also be done like this:
PropertyValue value = new PropertyValue("name", "Some Company Inc.");
company.setPropertyValue(value);

// ok, let's create the director and tie it to the company:

BeanWrapper jim = BeanWrapperImpl(new Employee());
jim.setPropertyValue("name", "Jim Stravinsky");
company.setPropertyValue("managingDirector", jim.getWrappedInstance());

// retrieving the salary of the managingDirector through the company

Float salary = (Float) company.getPropertyValue("managingDirector.salary");

5.4.2 Built-in PropertyEditor implementations

Spring uses the concept of PropertyEditors to effect the conversion between

an Object and a String. If you think about it, it sometimes might be handy to be
able to represent properties in a different way than the object itself. For example,
a Date can be represented in a human readable way (as the String '2007-14-09'),
while we're still able to convert the human readable form back to the original date
(or even better: convert any date entered in a human readable form, back
to Date objects). This behavior can be achieved by registering custom editors, of
typejava.beans.PropertyEditor. Registering custom editors on a BeanWrapper or
alternately in a specific IoC container as mentioned in the previous chapter, gives
it the knowledge of how to convert properties to the desired type. Read more
about PropertyEditors in the Javadoc of thejava.beans package provided by Sun.

A couple of examples where property editing is used in Spring:

 setting properties on beans is done using PropertyEditors. When

mentioning java.lang.String as the value of a property of some bean you're
declaring in XML file, Spring will (if the setter of the corresponding property
has a Class-parameter) use the ClassEditor to try to resolve the parameter to
a Class object.

197
 parsing HTTP request parameters in Spring's MVC framework is done using
all kinds of PropertyEditors that you can manually bind in all subclasses of
the CommandController.

Spring has a number of built-in PropertyEditors to make life easy. Each of those is

listed below and they are all located in
theorg.springframework.beans.propertyeditors package. Most, but not all (as
indicated below), are registered by default by BeanWrapperImpl. Where the property
editor is configurable in some fashion, you can of course still register your own
variant to override the default one:

Table 5.2. Built-in PropertyEditors

s Explanation
ertyEditor
Editor for byte arrays. Strings will simply be converted to their corresponding byte representations. Registered by
default by BeanWrapperImpl.
Parses Strings representing classes to actual classes and the other way around. When a class is not found,
an IllegalArgumentException is thrown. Registered by default by BeanWrapperImpl.
Editor
Customizable property editor for Boolean properties. Registered by default by BeanWrapperImpl, but, can be
overridden by registering custom instance of it as custom editor.
ionEditor Property editor for Collections, converting any source Collection to a given target Collection type.

tor
Customizable property editor for java.util.Date, supporting a custom DateFormat. NOT registered by default. Must
user registered as needed with appropriate format.
ditor
Customizable property editor for any Number subclass like Integer, Long, Float, Double. Registered by default
by BeanWrapperImpl, but can be overridden by registering custom instance of it as a custom editor.
Capable of resolving Strings to java.io.File objects. Registered by default by BeanWrapperImpl.
One-way property editor, capable of taking a text string and producing (via an
itor
intermediate ResourceEditorand Resource) an InputStream, so InputStream properties may be directly set as
Strings. Note that the default usage will not close the InputStream for you! Registered by default
by BeanWrapperImpl.
Capable of resolving Strings to Locale objects and vice versa (the String format is [language]_[country]_[variant],
which is the same thing the toString() method of Locale provides). Registered by default by BeanWrapperImpl.
Capable of resolving Strings to JDK 1.5 Pattern objects and vice versa.
tor
Capable of converting Strings (formatted using the format as defined in the Javadoc for the java.lang.Properties cla
to Properties objects. Registered by default by BeanWrapperImpl.
Editor
Property editor that trims Strings. Optionally allows transforming an empty string into a null value. NOT registere
by default; must be user registered as needed.
Capable of resolving a String representation of a URL to an actual URL object. Registered by default
byBeanWrapperImpl.

198
Spring uses the java.beans.PropertyEditorManager to set the search path for
property editors that might be needed. The search path also
includes sun.bean.editors, which includes PropertyEditor implementations for types
such as Font, Color, and most of the primitive types. Note also that the standard
JavaBeans infrastructure will automatically discover PropertyEditor classes
(without you having to register them explicitly) if they are in the same package as
the class they handle, and have the same name as that class,
with 'Editor' appended; for example, one could have the following class and
package structure, which would be sufficient for the FooEditor class to be
recognized and used as the PropertyEditorfor Foo-typed properties.

com
chank
pop
Foo
FooEditor // the PropertyEditor for the Foo class

Note that you can also use the standard BeanInfo JavaBeans mechanism here as
well (described in not-amazing-detail here). Find below an example of using
the BeanInfo mechanism for explicitly registering one or
more PropertyEditor instances with the properties of an associated class.

com
chank
pop
Foo
FooBeanInfo // the BeanInfo for the Foo class

Here is the Java source code for the referenced FooBeanInfo class. This would
associate a CustomNumberEditor with the age property of the Fooclass.

public class FooBeanInfo extends SimpleBeanInfo {

public PropertyDescriptor[] getPropertyDescriptors() {

try {
final PropertyEditor numberPE = new CustomNumberEditor(Integer.class,
true);
PropertyDescriptor ageDescriptor = new PropertyDescriptor("age",
Foo.class) {
public PropertyEditor createPropertyEditor(Object bean) {
return numberPE;
};
};
return new PropertyDescriptor[] { ageDescriptor };
}

199
catch (IntrospectionException ex) {
throw new Error(ex.toString());
}
}
}

5.4.2.1 Registering additional custom PropertyEditors

When setting bean properties as a string value, a Spring IoC container ultimately
uses standard JavaBeans PropertyEditors to convert these Strings to the complex
type of the property. Spring pre-registers a number of custom PropertyEditors (for
example, to convert a classname expressed as a string into a real Class object).
Additionally, Java's standard JavaBeans PropertyEditor lookup mechanism allows
aPropertyEditor for a class simply to be named appropriately and placed in the
same package as the class it provides support for, to be found automatically.

If there is a need to register other custom PropertyEditors, there are several

mechanisms available. The most manual approach, which is not normally
convenient or recommended, is to simply use the registerCustomEditor() method of
the ConfigurableBeanFactory interface, assuming you have a BeanFactory reference.
Another, slightly more convenient, mechanism is to use a special bean factory
post-processor calledCustomEditorConfigurer. Although bean factory post-
processors can be used with BeanFactory implementations,
the CustomEditorConfigurerhas a nested property setup, so it is strongly
recommended that it is used with the ApplicationContext, where it may be deployed
in similar fashion to any other bean, and automatically detected and applied.

Note that all bean factories and application contexts automatically use a number of
built-in property editors, through their use of something called aBeanWrapper to
handle property conversions. The standard property editors that
the BeanWrapper registers are listed in the previous section.
Additionally, ApplicationContexts also override or add an additional number of
editors to handle resource lookups in a manner appropriate to the specific
application context type.

Standard JavaBeans PropertyEditor instances are used to convert property values

expressed as strings to the actual complex type of the
property. CustomEditorConfigurer, a bean factory post-processor, may be used to
conveniently add support for additional PropertyEditorinstances to
an ApplicationContext.

200
Consider a user class ExoticType, and another class DependsOnExoticType which
needs ExoticType set as a property:

package example;

public class ExoticType {

private String name;

public ExoticType(String name) {

this.name = name;
}
}

public class DependsOnExoticType {

private ExoticType type;

public void setType(ExoticType type) {

this.type = type;
}
}

When things are properly set up, we want to be able to assign the type property as
a string, which a PropertyEditor will behind the scenes convert into an
actual ExoticType instance:

<bean id="sample" class="example.DependsOnExoticType">

The PropertyEditor implementation could look similar to this:

// converts string representation to ExoticType object

package example;

public class ExoticTypeEditor extends PropertyEditorSupport {

public void setAsText(String text) {

setValue(new ExoticType(text.toUpperCase()));
}
}

Finally, we use CustomEditorConfigurer to register the new PropertyEditor with

the ApplicationContext, which will then be able to use it as needed:

201
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="example.ExoticType" value="example.ExoticTypeEditor"/>
</map>
</property>
</bean>

Using PropertyEditorRegistrars

Another mechanism for registering property editors with the Spring container is to
create and use a PropertyEditorRegistrar. This interface is particularly useful when
you need to use the same set of property editors in several different situations:
write a corresponding registrar and reuse that in each
case. PropertyEditorRegistrars work in conjunction with an interface
called PropertyEditorRegistry, an interface that is implemented by the
Spring BeanWrapper (and DataBinder). PropertyEditorRegistrars are particularly
convenient when used in conjunction with
the CustomEditorConfigurer (introduced here), which exposes a property
called setPropertyEditorRegistrars(..): PropertyEditorRegistrarsadded to
a CustomEditorConfigurer in this fashion can easily be shared with DataBinder and
Spring MVC Controllers. Furthermore, it avoids the need for synchronization on
custom editors: a PropertyEditorRegistrar is expected to create
fresh PropertyEditor instances for each bean creation attempt.

Using a PropertyEditorRegistrar is perhaps best illustrated with an example. First

off, you need to create your own PropertyEditorRegistrarimplementation:

package com.foo.editors.spring;

public final class CustomPropertyEditorRegistrar implements

PropertyEditorRegistrar {

public void registerCustomEditors(PropertyEditorRegistry registry) {

// it is expected that new PropertyEditor instances are created

registry.registerCustomEditor(ExoticType.class, new ExoticTypeEditor());

// you could register as many custom property editors as are required

here...
}
}

Next we configure a CustomEditorConfigurer and inject an instance of

our CustomPropertyEditorRegistrar into it:

Finally, and in a bit of a departure from the focus of this chapter, for those of you
using Spring's MVC web framework, usingPropertyEditorRegistrars in conjunction
with data-binding Controllers (such as SimpleFormController) can be very
convenient. Find below an example of using a PropertyEditorRegistrar in the
implementation of an initBinder(..) method:

public final class RegisterUserController extends SimpleFormController {

private final PropertyEditorRegistrar customPropertyEditorRegistrar;

public RegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar)

{
this.customPropertyEditorRegistrar = propertyEditorRegistrar;
}

protected void initBinder(HttpServletRequest request, ServletRequestDataBinder

binder)
throws Exception {
this.customPropertyEditorRegistrar.registerCustomEditors(binder);
}

// other methods to do with registering a User

}

This style of PropertyEditor registration can lead to concise code (the

implementation of initBinder(..) is just one line long!), and allows
common PropertyEditor registration code to be encapsulated in a class and then
shared amongst as many Controllers as needed.

203
5.5 Spring 3 Type Conversion

Spring 3 introduces a core.convert package that provides a general type

conversion system. The system defines an SPI to implement type conversion
logic, as well as an API to execute type conversions at runtime. Within a Spring
container, this system can be used as an alternative to PropertyEditors to convert
externalized bean property value strings to required property types. The public API
may also be used anywhere in your application where type conversion is needed.

5.5.1 Converter SPI

The SPI to implement type conversion logic is simple and strongly typed:

package org.springframework.core.convert.converter;

public interface Converter<S, T> {

T convert(S source);

To create your own Converter, simply implement the interface above.

Parameterize S as the type you are converting from, and T as the type you are
converting to. For each call to convert(S), the source argument is guaranteed to be
NOT null. Your Converter may throw any Exception if conversion fails. An
IllegalArgumentException should be thrown to report an invalid source value. Take
care to ensure your Converter implementation is thread-safe.

Several converter implementations are provided in

the core.convert.support package as a convenience. These include converters
from Strings to Numbers and other common types. Consider StringToInteger as an
example Converter implementation:

package org.springframework.core.convert.support;

final class StringToInteger implements Converter<String, Integer> {

public Integer convert(String source) {

return Integer.valueOf(source);
}

204
5.5.2 ConverterFactory

When you need to centralize the conversion logic for an entire class hierarchy, for
example, when converting from String to java.lang.Enum objects,
implement ConverterFactory:

package org.springframework.core.convert.converter;

public interface ConverterFactory<S, R> {

<T extends R> Converter<S, T> getConverter(Class<T> targetType);

Parameterize S to be the type you are converting from and R to be the base type
defining the range of classes you can convert to. Then implement
getConverter(Class<T>), where T is a subclass of R.

Consider the StringToEnum ConverterFactory as an example:

package org.springframework.core.convert.support;

final class StringToEnumConverterFactory implements ConverterFactory<String, Enum>

{

public <T extends Enum> Converter<String, T> getConverter(Class<T> targetType)

{
return new StringToEnumConverter(targetType);
}

private final class StringToEnumConverter<T extends Enum> implements

Converter<String, T> {

private Class<T> enumType;

public StringToEnumConverter(Class<T> enumType) {

this.enumType = enumType;
}

public T convert(String source) {

return (T) Enum.valueOf(this.enumType, source.trim());
}
}
}

205
5.5.3 GenericConverter

When you require a sophisticated Converter implementation, consider the

GenericConverter interface. With a more flexible but less strongly typed signature,
a GenericConverter supports converting between multiple source and target types.
In addition, a GenericConverter makes available source and target field context
you can use when implementing your conversion logic. Such context allows a type
conversion to be driven by a field annotation, or generic information declared on a
field signature.

package org.springframework.core.convert.converter;

public interface GenericConverter {

public Set<ConvertiblePair> getConvertibleTypes();

Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor

targetType);

To implement a GenericConverter, have getConvertibleTypes() return the

supported source->target type pairs. Then implement convert(Object,
TypeDescriptor, TypeDescriptor) to implement your conversion logic. The source
TypeDescriptor provides access to the source field holding the value being
converted. The target TypeDescriptor provides access to the target field where the
converted value will be set.

A good example of a GenericConverter is a converter that converts between a Java Array and a
Collection. Such an ArrayToCollectionConverter introspects the field that declares the target
Collection type to resolve the Collection's element type. This allows each element in the source array
to be converted to the Collection element type before the Collection is set on the target field.

Note

Because GenericConverter is a more complex SPI interface, only use it when you need it. Favor
Converter or ConverterFactory for basic type conversion needs.

5.5.3.1 ConditionalGenericConverter

Sometimes you only want a Converter to execute if a specific condition holds true.
For example, you might only want to execute a Converter if a specific annotation is
present on the target field. Or you might only want to execute a Converter if a
specific method, such as static valueOf method, is defined on the target class.

206
ConditionalGenericConverter is an subinterface of GenericConverter that allows
you to define such custom matching criteria:

public interface ConditionalGenericConverter extends GenericConverter {

boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);

A good example of a ConditionalGenericConverter is an EntityConverter that

converts between an persistent entity identifier and an entity reference. Such a
EntityConverter might only match if the target entity type declares a static finder
method e.g. findAccount(Long). You would perform such a finder method check in
the implementation of matches(TypeDescriptor, TypeDescriptor).

5.5.4 ConversionService API

The ConversionService defines a unified API for executing type conversion logic at
runtime. Converters are often executed behind this facade interface:

package org.springframework.core.convert;

public interface ConversionService {

boolean canConvert(Class<?> sourceType, Class<?> targetType);

<T> T convert(Object source, Class<T> targetType);

boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);

Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor

targetType);

Most ConversionService implementations also implement ConverterRegistry,

which provides an SPI for registering converters. Internally, a ConversionService
implementation delegates to its registered converters to carry out type conversion
logic.

A robust ConversionService implementation is provided in

the core.convert.support package. GenericConversionService is the general-purpose
implementation suitable for use in most
environments. ConversionServiceFactory provides a convenient factory for creating
common ConversionService configurations.

207
5.5.5 Configuring a ConversionService

A ConversionService is a stateless object designed to be instantiated at application startup, then shared

between multiple threads. In a Spring application, you typically configure a ConversionService
instance per Spring container (or ApplicationContext). That ConversionService will be picked up by
Spring and then used whenever a type conversion needs to be performed by the framework. You may
also inject this ConversionService into any of your beans and invoke it directly.

Note

If no ConversionService is registered with Spring, the original PropertyEditor-based system is

used.

To register a default ConversionService with Spring, add the following bean

definition with id conversionService:

A default ConversionService can convert between strings, numbers, enums,

collections, maps, and other common types. To suppliment or override the default
converters with your own custom converter(s), set the converters property.
Property values may implement either of the Converter, ConverterFactory, or
GenericConverter interfaces.

It is also common to use a ConversionService within a Spring MVC application.

See Section 5.6.4, “Configuring Formatting in Spring MVC” for details on use
with <mvc:annotation-driven/>.

In certain situations you may wish to apply formatting during conversion.

See Section 5.6.3, “FormatterRegistry SPI” for details on
usingFormattingConversionServiceFactoryBean.

208
5.5.6 Using a ConversionService programatically

To work with a ConversionService instance programatically, simply inject a

reference to it like you would for any other bean:

@Service
public class MyService {

@Autowired
public MyService(ConversionService conversionService) {
this.conversionService = conversionService;
}

public void doIt() {

this.conversionService.convert(...)
}
}

5.6 Spring 3 Field Formatting

As discussed in the previous section, core.convert is a general-purpose type

conversion system. It provides a unified ConversionService API as well as a
strongly-typed Converter SPI for implementing conversion logic from one type to
another. A Spring Container uses this system to bind bean property values. In
addition, both the Spring Expression Language (SpEL) and DataBinder use this
system to bind field values. For example, when SpEL needs to coerce a Short to
a Long to complete an expression.setValue(Object bean, Object value) attempt, the
core.convert system performs the coercion.

Now consider the type conversion requirements of a typical client environment

such as a web or desktop application. In such environments, you typically
convert from String to support the client postback process, as well as back to
String to support the view rendering process. In addition, you often need to localize
String values. The more general core.convert Converter SPI does not address
such formatting requirements directly. To directly address them, Spring 3
introduces a convenient Formatter SPI that provides a simple and robust
alternative to PropertyEditors for client environments.

In general, use the Converter SPI when you need to implement general-purpose
type conversion logic; for example, for converting between a java.util.Date and and
java.lang.Long. Use the Formatter SPI when you're working in a client
environment, such as a web application, and need to parse and print localized field
values. The ConversionService provides a unified type conversion API for both
SPIs.

209
5.6.1 Formatter SPI

The Formatter SPI to implement field formatting logic is simple and strongly typed:

package org.springframework.format;

public interface Formatter<T> extends Printer<T>, Parser<T> {

}

Where Formatter extends from the Printer and Parser building-block interfaces:

public interface Printer<T> {

String print(T fieldValue, Locale locale);
}
import java.text.ParseException;

public interface Parser<T> {

T parse(String clientValue, Locale locale) throws ParseException;
}

To create your own Formatter, simply implement the Formatter interface above.
Parameterize T to be the type of object you wish to format, for
example, java.util.Date. Implement the print() operation to print an instance of T
for display in the client locale. Implement the parse()operation to parse an instance
of T from the formatted representation returned from the client locale. Your
Formatter should throw a ParseException or IllegalArgumentException if a parse
attempt fails. Take care to ensure your Formatter implementation is thread-safe.

Several Formatter implementations are provided in format subpackages as a

convenience. The number package provides a NumberFormatter,
CurrencyFormatter, and PercentFormatter to format java.lang.Number objects
using a java.text.NumberFormat. The datetime package provides a DateFormatter
to format java.util.Date objects with a java.text.DateFormat.
The datetime.joda package provides comprehensive datetime formatting support
based on the Joda Time library.

Consider DateFormatter as an example Formatter implementation:

package org.springframework.format.datetime;

public final class DateFormatter implements Formatter<Date> {

private String pattern;

210
public DateFormatter(String pattern) {
this.pattern = pattern;
}

public String print(Date date, Locale locale) {

if (date == null) {
return "";
}
return getDateFormat(locale).format(date);
}

public Date parse(String formatted, Locale locale) throws ParseException {

if (formatted.length() == 0) {
return null;
}
return getDateFormat(locale).parse(formatted);
}

protected DateFormat getDateFormat(Locale locale) {

DateFormat dateFormat = new SimpleDateFormat(this.pattern, locale);
dateFormat.setLenient(false);
return dateFormat;
}

The Spring team welcomes community-driven Formatter contributions;

see http://jira.springframework.org to contribute.

5.6.2 Annotation-driven Formatting

As you will see, field formatting can be configured by field type or annotation. To
bind an Annotation to a formatter, implement AnnotationFormatterFactory:

package org.springframework.format;

public interface AnnotationFormatterFactory<A extends Annotation> {

Set<Class<?>> getFieldTypes();

Printer<?> getPrinter(A annotation, Class<?> fieldType);

Parser<?> getParser(A annotation, Class<?> fieldType);

Parameterize A to be the field annotationType you wish to associate formatting

logic with, for exampleorg.springframework.format.annotation.DateTimeFormat.
Have getFieldTypes() return the types of fields the annotation may be used on.

211
HavegetPrinter() return a Printer to print the value of an annotated field.
Have getParser() return a Parser to parse a clientValue for an annotated field.

The example AnnotationFormatterFactory implementation below binds the

@NumberFormat Annotation to a formatter. This annotation allows either a
number style or pattern to be specified:

public final class NumberFormatAnnotationFormatterFactory

implements AnnotationFormatterFactory<NumberFormat> {

public Set<Class<?>> getFieldTypes() {

return new HashSet<Class<?>>(asList(new Class<?>[] {
Short.class, Integer.class, Long.class, Float.class,
Double.class, BigDecimal.class, BigInteger.class }));
}

public Printer<Number> getPrinter(NumberFormat annotation, Class<?> fieldType)

{
return configureFormatterFrom(annotation, fieldType);
}

public Parser<Number> getParser(NumberFormat annotation, Class<?> fieldType) {

return configureFormatterFrom(annotation, fieldType);
}

private Formatter<Number> configureFormatterFrom(NumberFormat annotation,

Class<?> fieldType) {
if (!annotation.pattern().isEmpty()) {
return new NumberFormatter(annotation.pattern());
} else {
Style style = annotation.style();
if (style == Style.PERCENT) {
return new PercentFormatter();
} else if (style == Style.CURRENCY) {
return new CurrencyFormatter();
} else {
return new NumberFormatter();
}
}
}
}

To trigger formatting, simply annotate fields with @NumberFormat:

public class MyModel {

@NumberFormat(style=Style.CURRENCY)
private BigDecimal decimal;

212
5.6.2.1 Format Annotation API

A portable format annotation API exists in

the org.springframework.format.annotation package. Use @NumberFormat to
format java.lang.Number fields. Use @DateTimeFormat to format java.util.Date,
java.util.Calendar, java.util.Long, or Joda Time fields.

The example below uses @DateTimeFormat to format a java.util.Date as a ISO

Date (yyyy-MM-dd):

public class MyModel {

@DateTimeFormat(iso=ISO.DATE)
private Date date;

5.6.3 FormatterRegistry SPI

At runtime, Formatters are registered in a FormatterRegistry. The

FormatterRegistry SPI allows you to configure Formatting rules centrally, instead
of duplicating such configuration across your Controllers. For example, you might
want to enforce that all Date fields are formatted a certain way, or fields with a
specific annotation are formatted in a certain way. With a shared
FormatterRegistry, you define these rules once and they are applied whenever
formatting is needed.

Review the FormatterRegistry SPI below:

package org.springframework.format;

public interface FormatterRegistry {

void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?

> parser);

void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter);

void addFormatterForAnnotation(AnnotationFormatterFactory<?, ?> factory);

As shown above, Formatters can be registered by fieldType or

annotation. FormattingConversionService is the implementation
ofFormatterRegistry suitable for most environments. This implementation may be

213
configured programatically, or declaratively as a Spring bean
using FormattingConversionServiceFactoryBean. Because this implemementation also
implements ConversionService, it can be directly configured for use with Spring's
DataBinder and the Spring Expression Language (SpEL).

5.6.4 Configuring Formatting in Spring MVC

In a Spring MVC application, you may configure a custom ConversionService

instance explicity as an attribute of the annotation-driven element of the MVC
namespace. This ConversionService will then be used anytime a type conversion
is required during Controller model binding. If not configured explicitly, Spring MVC
will automatically register default formatters and converters for common types
such as numbers and dates.

To rely on default formatting rules, no custom configuration is required in your

Spring MVC config XML:

<?xml version="1.0" encoding="UTF-8"?>

<mvc:annotation-driven/>

</beans>

With this one-line of configuation, default formatters for Numbers and Date types
will be installed, including support for the @NumberFormat and
@DateTimeFormat annotations. Full support for the Joda Time formatting library is
also installed if Joda Time is present on the classpath.

To inject a ConversionService instance with custom formatters and converters

registered, set the conversion-service attribute:

<?xml version="1.0" encoding="UTF-8"?>

214
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<mvc:annotation-driven conversion-service="conversionService"/>

<bean id="conversionService"

class="org.springframework.format.support.FormattingConversionServiceFactoryBean"/
>

</beans>

A custom ConversionService instance is often constructed by a FactoryBean that

internally registers custom Formatters and Converters programatically before the
ConversionService is returned. See FormattingConversionServiceFactoryBean for
an example.

5.7 Spring 3 Validation

Spring 3 introduces several enhancements to its validation support. First, the JSR-
303 Bean Validation API is now fully supported. Second, when used
programatically, Spring's DataBinder can now validate objects as well as bind to
them. Third, Spring MVC now has support for declaratively validating @Controller
inputs.

5.7.1 Overview of the JSR-303 Bean Validation API

JSR-303 standardizes validation constraint declaration and metadata for the Java
platform. Using this API, you annotate domain model properties with declarative
validation constraints and the runtime enforces them. There are a number of built-
in constraints you can take advantage of. You may also define your own custom
constraints.

To illustrate, consider a simple PersonForm model with two properties:

public class PersonForm {

private String name;
private int age;
}

JSR-303 allows you to define declarative validation constraints against such

properties:

215
public class PersonForm {

@NotNull
@Size(max=64)
private String name;

@Min(0)
private int age;

When an instance of this class is validated by a JSR-303 Validator, these

constraints will be enforced.

For general information on JSR-303, see the Bean Validation Specification. For

information on the specific capabilities of the default reference implementation, see
the Hibernate Validator documentation. To learn how to setup a JSR-303
implementation as a Spring bean, keep reading.

5.7.2 Configuring a Bean Validation Implementation

Spring provides full support for the JSR-303 Bean Validation API. This includes
convenient support for bootstrapping a JSR-303 implementation as a Spring bean.
This allows for a javax.validation.ValidatorFactory or javax.validation.Validator to
be injected wherever validation is needed in your application.

Use the LocalValidatorFactoryBean to configure a default JSR-303 Validator as a

Spring bean:

<bean id="validator"

class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/>

The basic configuration above will trigger JSR-303 to initialize using its default
bootstrap mechanism. A JSR-303 provider, such as Hibernate Validator, is
expected to be present in the classpath and will be detected automatically.

5.7.2.1 Injecting a Validator

LocalValidatorFactoryBean implements
both javax.validation.ValidatorFactory and javax.validation.Validator, as well as
Spring'sorg.springframework.validation.Validator. You may inject a reference to
either of these interfaces into beans that need to invoke validation logic.

216
Inject a reference to javax.validation.Validator if you prefer to work with the JSR-
303 API directly:

import javax.validation.Validator;

@Service
public class MyService {

@Autowired
private Validator validator;

Inject a reference to org.springframework.validation.Validator if your bean requires

the Spring Validation API:

import org.springframework.validation.Validator;

@Service
public class MyService {

@Autowired
private Validator validator;

5.7.2.2 Configuring Custom Constraints

Each JSR-303 validation constraint consists of two parts. First, a @Constraint

annotation that declares the constraint and its configurable properties. Second, an
implementation of the javax.validation.ConstraintValidator interface that
implements the constraint's behavior. To associate a declaration with an
implementation, each @Constraint annotation references a corresponding
ValidationConstraint implementation class. At runtime,
a ConstraintValidatorFactory instantiates the referenced implementation when the
constraint annotation is encountered in your domain model.

By default, the LocalValidatorFactoryBean configures
a SpringConstraintValidatorFactory that uses Spring to create ConstraintValidator
instances. This allows your custom ConstraintValidators to benefit from
dependency injection like any other Spring bean.

Shown below is an example of a custom @Constraint declaration, followed by an

associated ConstraintValidator implementation that uses Spring for dependency
injection:

217
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy=MyConstraintValidator.class)
public @interface MyConstraint {
}
import javax.validation.ConstraintValidator;

public class MyConstraintValidator implements ConstraintValidator {

@Autowired;
private Foo aDependency;

...
}

As you can see, a ConstraintValidator implementation may have its dependencies

@Autowired like any other Spring bean.

5.7.2.3 Additional Configuration Options

The default LocalValidatorFactoryBean configuration should prove sufficient for most

cases. There are a number of other configuration options for various JSR-303
constructs, from message interpolation to traversal resolution. See the JavaDocs
of LocalValidatorFactoryBean for more information on these options.

5.7.3 Configuring a DataBinder

Since Spring 3, a DataBinder instance can be configured with a Validator. Once

configured, the Validator may be invoked by callingbinder.validate(). Any
validation Errors are automatically added to the binder's BindingResult.

When working with the DataBinder programatically, this can be used to invoke
validation logic after binding to a target object:

Foo target = new Foo();

DataBinder binder = new DataBinder(target);
binder.setValidator(new FooValidator());

// bind to the target object

binder.bind(propertyValues);

// validate the target object

binder.validate();

// get BindingResult that includes any validation errors

BindingResult results = binder.getBindingResult();

218
5.7.4 Spring MVC 3 Validation

Beginning with Spring 3, Spring MVC has the ability to automatically validate
@Controller inputs. In previous versions it was up to the developer to manually
invoke validation logic.

5.7.4.1 Triggering @Controller Input Validation

To trigger validation of a @Controller input, simply annotate the input argument as

@Valid:

@Controller
public class MyController {

@RequestMapping("/foo", method=RequestMethod.POST)
public void processFoo(@Valid Foo foo) { /* ... */ }

Spring MVC will validate a @Valid object after binding so-long as an appropriate Validator has been
configured.

Note

The @Valid annotation is part of the standard JSR-303 Bean Validation API, and is not a Spring-
specific construct.

5.7.4.2 Configuring a Validator for use by Spring MVC

The Validator instance invoked when a @Valid method argument is encountered

may be configured in two ways. First, you may call binder.setValidator(Validator)
within a @Controller's @InitBinder callback. This allows you to configure a
Validator instance per @Controller class:

@Controller
public class MyController {

@InitBinder
protected void initBinder(WebDataBinder binder) {
binder.setValidator(new FooValidator());
}

@RequestMapping("/foo", method=RequestMethod.POST)
public void processFoo(@Valid Foo foo) { ... }

219
Second, you may call setValidator(Validator) on the global WebBindingInitializer.
This allows you to configure a Validator instance across all @Controllers. This can
be achieved easily by using the Spring MVC namespace:

<?xml version="1.0" encoding="UTF-8"?>

<mvc:annotation-driven validator="globalValidator"/>

</beans>

5.7.4.3 Configuring a JSR-303 Validator for use by Spring MVC

With JSR-303, a single javax.validation.Validator instance typically

validates all model objects that declare validation constraints. To configure a JSR-
303-backed Validator with Spring MVC, simply add a JSR-303 Provider, such as
Hibernate Validator, to your classpath. Spring MVC will detect it and automatically
enable JSR-303 support across all Controllers.

The Spring MVC configuration required to enable JSR-303 support is shown

below:

<?xml version="1.0" encoding="UTF-8"?>

<!-- JSR-303 support will be detected on classpath and enabled automatically

-->
<mvc:annotation-driven/>

</beans>

With this minimal configuration, anytime a @Valid @Controller input is

encountered, it will be validated by the JSR-303 provider. JSR-303, in turn, will

220
enforce any constraints declared against the input. Any ConstraintViolations will
automatically be exposed as errors in the BindingResult renderable by standard
Spring MVC form tags.

6. Spring Expression Language (SpEL)

6.1 Introduction

The Spring Expression Language (SpEL for short) is a powerful expression

language that supports querying and manipulating an object graph at runtime. The
language syntax is similar to Unified EL but offers additional features, most notably
method invocation and basic string templating functionality.

While there are several other Java expression languages available, OGNL, MVEL,
and JBoss EL, to name a few, the Spring Expression Language was created to
provide the Spring community with a single well supported expression language
that can be used across all the products in the Spring portfolio. Its language
features are driven by the requirements of the projects in the Spring portfolio,
including tooling requirements for code completion support within the eclipse
based SpringSource Tool Suite. That said, SpEL is based on a technology
agnostic API allowing other expression language implementations to be integrated
should the need arise.

While SpEL serves as the foundation for expression evaluation within the Spring
portfolio, it is not directly tied to Spring and can be used independently. In order to
be self contained, many of the examples in this chapter use SpEL as if it were an
independent expression language. This requires creating a few bootstrapping
infrastructure classes such as the parser. Most Spring users will not need to deal
with this infrastructure and will instead only author expression strings for
evaluation. An example of this typical use is the integration of SpEL into creating
XML or annotated based bean definitions as shown in the section Expression
support for defining bean definitions.

This chapter covers the features of the expression language, its API, and its
language syntax. In several places an Inventor and Inventor's Society class are
used as the target objects for expression evaluation. These class declarations and
the data used to populate them are listed at the end of the chapter.

6.2 Feature Overview

The expression language supports the following functionality

221
 Literal expressions
 Boolean and relational operators

 Regular expressions

 Class expressions

 Accessing properties, arrays, lists, maps

 Method invocation

 Relational operators

 Assignment

 Calling constructors

 Bean references

 Array construction

 Inline lists

 Ternary operator

 Variables

 User defined functions

 Collection projection

 Collection selection

 Templated expressions

6.3 Expression Evaluation using Spring's Expression Interface

This section introduces the simple use of SpEL interfaces and its expression
language. The complete language reference can be found in the section Language
Reference.

The following code introduces the SpEL API to evaluate the literal string
expression 'Hello World'.

222
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'");
String message = (String) exp.getValue();

The value of the message variable is simply 'Hello World'.

The SpEL classes and interfaces you are most likely to use are located in the
packages org.springframework.expression and its sub packages andspel.support.

The interface ExpressionParser is responsible for parsing an expression string. In

this example the expression string is a string literal denoted by the surrounding
single quotes. The interface Expression is responsible for evaluating the previously
defined expression string. There are two exceptions that can be
thrown, ParseException and EvaluationException when calling
'parser.parseExpression' and 'exp.getValue' respectively.

SpEL supports a wide range of features, such as calling methods, accessing

properties, and calling constructors.

As an example of method invocation, we call the 'concat' method on the string

literal.

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("'Hello World'.concat('!')");
String message = (String) exp.getValue();

The value of message is now 'Hello World!'.

As an example of calling a JavaBean property, the String property 'Bytes' can be

called as shown below.

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes()'
Expression exp = parser.parseExpression("'Hello World'.bytes");

byte[] bytes = (byte[]) exp.getValue();

SpEL also supports nested properties using standard 'dot' notation, i.e.
prop1.prop2.prop3 and the setting of property values

Public fields may also be accessed.

223
ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes().length'
Expression exp = parser.parseExpression("'Hello World'.bytes.length");

int length = (Integer) exp.getValue();

The String's constructor can be called instead of using a string literal.

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("new String('hello
world').toUpperCase()");
String message = exp.getValue(String.class);

Note the use of the generic method public <T> T getValue(Class<T>

desiredResultType). Using this method removes the need to cast the value of the
expression to the desired result type. An EvaluationException will be thrown if the
value cannot be cast to the type T or converted using the registered type converter.

The more common usage of SpEL is to provide an expression string that is

evaluated against a specific object instance (called the root object). There are two
options here and which to choose depends on whether the object against which
the expression is being evaluated will be changing with each call to evaluate the
expression. In the following example we retrieve the name property from an instance
of the Inventor class.

// Create and set a calendar

GregorianCalendar c = new GregorianCalendar();
c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.

Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name");
EvaluationContext context = new StandardEvaluationContext(tesla);

String name = (String) exp.getValue(context);

In the last line, the value of the string variable 'name' will be set to "Nikola Tesla".
The class StandardEvaluationContext is where you can specify which object the
"name" property will be evaluated against. This is the mechanism to use if the root
object is unlikely to change, it can simply be set once in the evaluation context. If
the root object is likely to change repeatedly, it can be supplied on each call
to getValue, as this next example shows:

224
/ Create and set a calendar
GregorianCalendar c = new GregorianCalendar();
c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.

Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name");

String name = (String) exp.getValue(tesla);

In this case the inventor tesla has been supplied directly to getValue and the

expression evaluation infrastructure creates and manages a default evaluation
context internally - it did not require one to be supplied.

The StandardEvaluationContext is relatively expensive to construct and during

repeated usage it builds up cached state that enables subsequent expression
evaluations to be performed more quickly. For this reason it is better to cache and
reuse them where possible, rather than construct a new one for each expression
evaluation.

In some cases it can be desirable to use a configured evaluation context and yet
still supply a different root object on each call to getValue.getValue allows both to be
specified on the same call. In these situations the root object passed on the call is considered to
override any (which maybe null) specified on the evaluation context.

Note

In standalone usage of SpEL there is a need to create the parser, parse expressions and perhaps
provide evaluation contexts and a root context object. However, more common usage is to
provide only the SpEL expression string as part of a configuration file, for example for Spring
bean or Spring Web Flow definitions. In this case, the parser, evaluation context, root object and
any predefined variables are all set up implicitly, requiring the user to specify nothing other than
the expressions.

As a final introductory example, the use of a boolean operator is shown using the
Inventor object in the previous example.

Expression exp = parser.parseExpression("name == 'Nikola Tesla'");

boolean result = exp.getValue(context, Boolean.class); // evaluates to true

225
6.3.1 The EvaluationContext interface

The interface EvaluationContext is used when evaluating an expression to resolve

properties, methods, fields, and to help perform type conversion. The out-of-the-
box implementation, StandardEvaluationContext, uses reflection to manipulate the
object, caching java.lang.reflect'sMethod, Field, and Constructor instances for
increased performance.

The StandardEvaluationContext is where you may specify the root object to evaluate

against via the method setRootObject() or passing the root object into the
constructor. You can also specify variables and functions that will be used in the
expression using the methods setVariable() andregisterFunction(). The use of
variables and functions are described in the language reference
sections Variables and Functions. TheStandardEvaluationContext is also where you
can register custom ConstructorResolvers, MethodResolvers, and PropertyAccessors to
extend how SpEL evaluates expressions. Please refer to the JavaDoc of these
classes for more details.

6.3.1.1 Type Conversion

By default SpEL uses the conversion service available in Spring core

(org.springframework.core.convert.ConversionService). This conversion service
comes with many converters built in for common conversions but is also fully
extensible so custom conversions between types can be added. Additionally it has
the key capability that it is generics aware. This means that when working with
generic types in expressions, SpEL will attempt conversions to maintain type
correctness for any objects it encounters.

What does this mean in practice? Suppose assignment, using setValue(), is being

used to set a List property. The type of the property is actually List<Boolean>. SpEL
will recognize that the elements of the list need to be converted to Boolean before
being placed in it. A simple example:

class Simple {
public List<Boolean> booleanList = new ArrayList<Boolean>();
}

Simple simple = new Simple();

simple.booleanList.add(true);

StandardEvaluationContext simpleContext = new StandardEvaluationContext(simple);

// false is passed in here as a string. SpEL and the conversion service will

226
// correctly recognize that it needs to be a Boolean and convert it
parser.parseExpression("booleanList[0]").setValue(simpleContext, "false");

// b will be false
Boolean b = simple.booleanList.get(0);

6.4 Expression support for defining bean definitions

SpEL expressions can be used with XML or annotation based configuration

metadata for defining BeanDefinitions. In both cases the syntax to define the
expression is of the form #{ <expression string> }.

6.4.1 XML based configuration

A property or constructor-arg value can be set using expressions as shown below

<bean id="numberGuess" class="org.spring.samples.NumberGuess">

</bean>

The variable 'systemProperties' is predefined, so you can use it in your

expressions as shown below. Note that you do not have to prefix the predefined
variable with the '#' symbol in this context.

<bean id="taxCalculator" class="org.spring.samples.TaxCalculator">

</bean>

You can also refer to other bean properties by name, for example.

<bean id="numberGuess" class="org.spring.samples.NumberGuess">

</bean>

<bean id="shapeGuess" class="org.spring.samples.ShapeGuess">

227
<property name="initialShapeSeed" value="#{ numberGuess.randomNumber }"/>

</bean>

6.4.2 Annotation-based configuration

The @Value annotation can be placed on fields, methods and method/constructor

parameters to specify a default value.

Here is an example to set the default value of a field variable.

public static class FieldValueTestBean

@Value("#{ systemProperties['user.region'] }")

private String defaultLocale;

public void setDefaultLocale(String defaultLocale)

{
this.defaultLocale = defaultLocale;
}

public String getDefaultLocale()

{
return this.defaultLocale;
}

The equivalent but on a property setter method is shown below.

public static class PropertyValueTestBean

private String defaultLocale;

@Value("#{ systemProperties['user.region'] }")

public void setDefaultLocale(String defaultLocale)
{
this.defaultLocale = defaultLocale;
}

public String getDefaultLocale()

{
return this.defaultLocale;
}

228
Autowired methods and constructors can also use the @Value annotation.

public class SimpleMovieLister {

private MovieFinder movieFinder;

private String defaultLocale;

@Autowired
public void configure(MovieFinder movieFinder,
@Value("#{ systemProperties['user.region'] }"} String
defaultLocale) {
this.movieFinder = movieFinder;
this.defaultLocale = defaultLocale;
}

// ...
}
public class MovieRecommender {

private String defaultLocale;

private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public MovieRecommender(CustomerPreferenceDao customerPreferenceDao,
@Value("#{systemProperties['user.country']}"} String
defaultLocale) {
this.customerPreferenceDao = customerPreferenceDao;
this.defaultLocale = defaultLocale;
}

// ...
}

6.5 Language Reference
6.5.1 Literal expressions

The types of literal expressions supported are strings, dates, numeric values (int,
real, and hex), boolean and null. Strings are delimited by single quotes. To put a
single quote itself in a string use two single quote characters. The following listing
shows simple usage of literals. Typically they would not be used in isolation like
this, but as part of a more complex expression, for example using a literal on one
side of a logical comparison operator.

ExpressionParser parser = new SpelExpressionParser();

// evals to "Hello World"

String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();

229
double avogadrosNumber = (Double)
parser.parseExpression("6.0221415E+23").getValue();

// evals to 2147483647
int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();

boolean trueValue = (Boolean) parser.parseExpression("true").getValue();

Object nullValue = parser.parseExpression("null").getValue();

Numbers support the use of the negative sign, exponential notation, and decimal
points. By default real numbers are parsed using Double.parseDouble().

6.5.2 Properties, Arrays, Lists, Maps, Indexers

Navigating with property references is easy, just use a period to indicate a nested
property value. The instances of Inventor class, pupin and tesla, were populated
with data listed in the section Classes used in the examples. To navigate "down"
and get Tesla's year of birth and Pupin's city of birth the following expressions are
used.

// evals to 1856
int year = (Integer) parser.parseExpression("Birthdate.Year +
1900").getValue(context);

String city = (String)

parser.parseExpression("placeOfBirth.City").getValue(context);

Case insensitivity is allowed for the first letter of property names. The contents of
arrays and lists are obtained using square bracket notation.

ExpressionParser parser = new SpelExpressionParser();

// Inventions Array
StandardEvaluationContext teslaContext = new StandardEvaluationContext(tesla);

// evaluates to "Induction motor"

String invention = parser.parseExpression("inventions[3]").getValue(teslaContext,
String.class);

// Members List
StandardEvaluationContext societyContext = new StandardEvaluationContext(ieee);

// evaluates to "Nikola Tesla"

230
String name = parser.parseExpression("Members[0].Name").getValue(societyContext,
String.class);

// List and Array navigation

// evaluates to "Wireless communication"
String invention =
parser.parseExpression("Members[0].Inventions[6]").getValue(societyContext,

String.class);

The contents of maps are obtained by specifying the literal key value within the
brackets. In this case, because keys for the Officers map are strings, we can
specify string literals.

// Officer's Dictionary

Inventor pupin =
parser.parseExpression("Officers['president']").getValue(societyContext,

Inventor.class);

// evaluates to "Idvor"
String city =

parser.parseExpression("Officers['president'].PlaceOfBirth.City").getValue(society
Context,

String.class);

// setting values
parser.parseExpression("Officers['advisors']
[0].PlaceOfBirth.Country").setValue(societyContext,

"Croatia");

6.5.3 Inline lists

Lists can be expressed directly in an expression using {} notation.

// evaluates to a Java list containing the four numbers

List numbers = (List) parser.parseExpression("{1,2,3,4}").getValue(context);

List listOfLists = (List) parser.parseExpression("{{'a','b'},

{'x','y'}}").getValue(context);

231
{} by itself means an empty list. For performance reasons, if the list is itself entirely
composed of fixed literals then a constant list is created to represent the
expression, rather than building a new list on each evaluation.

6.5.4 Array construction

Arrays can be built using the familiar Java syntax, optionally supplying an initializer
to have the array populated at construction time.

int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);

// Array with initializer

int[] numbers2 = (int[]) parser.parseExpression("new int[]
{1,2,3}").getValue(context);

// Multi dimensional array

int[][] numbers3 = (int[][]) parser.parseExpression("new int[4]
[5]").getValue(context);

It is not currently allowed to supply an initializer when constructing a multi-

dimensional array.

6.5.5 Methods

Methods are invoked using typical Java programming syntax. You may also invoke
methods on literals. Varargs are also supported.

// string literal, evaluates to "bc"

String c = parser.parseExpression("'abc'.substring(2, 3)").getValue(String.class);

// evaluates to true
boolean isMember = parser.parseExpression("isMember('Mihajlo
Pupin')").getValue(societyContext,

Boolean.class);

6.5.6 Operators

6.5.6.1 Relational operators

The relational operators; equal, not equal, less than, less than or equal, greater
than, and greater than or equal are supported using standard operator notation.

// evaluates to true
boolean trueValue = parser.parseExpression("2 == 2").getValue(Boolean.class);

232
// evaluates to false
boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class);

// evaluates to true
boolean trueValue = parser.parseExpression("'black' <
'block'").getValue(Boolean.class);

In addition to standard relational operators SpEL supports the 'instanceof' and

regular expression based 'matches' operator.

// evaluates to false
boolean falseValue = parser.parseExpression("'xyz' instanceof
T(int)").getValue(Boolean.class);

// evaluates to true
boolean trueValue =
parser.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?
$'").getValue(Boolean.class);

//evaluates to false
boolean falseValue =
parser.parseExpression("'5.0067' matches '^-?\\d+(\\.\\d{2})?
$'").getValue(Boolean.class);

Each symbolic operator can also be specified as a purely alphabetic equivalent.

This avoids problems where the symbols used have special meaning for the
document type in which the expression is embedded (eg. an XML document). The
textual equivalents are shown here: lt ('<'), gt ('>'), le ('<='), ge ('>='), eq ('=='), ne ('!
='), div ('/'), mod ('%'), not ('!'). These are case insensitive.

6.5.6.2 Logical operators

The logical operators that are supported are and, or, and not. Their use is
demonstrated below.

// -- AND --

// evaluates to false
boolean falseValue = parser.parseExpression("true and
false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') and isMember('Mihajlo Pupin')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext,
Boolean.class);

233
// -- OR --

// evaluates to true
boolean trueValue = parser.parseExpression("true or
false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') or isMember('Albert Einstien')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext,
Boolean.class);

// -- NOT --

// evaluates to false
boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

// -- AND and NOT --

String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
boolean falseValue = parser.parseExpression(expression).getValue(societyContext,
Boolean.class);

6.5.6.3 Mathematical operators

The addition operator can be used on numbers, strings and dates. Subtraction can
be used on numbers and dates. Multiplication and division can be used only on
numbers. Other mathematical operators supported are modulus (%) and
exponential power (^). Standard operator precedence is enforced. These operators
are demonstrated below.

// Addition
int two = parser.parseExpression("1 + 1").getValue(Integer.class); // 2

String testString =
parser.parseExpression("'test' + ' ' + 'string'").getValue(String.class); //
'test string'

// Subtraction
int four = parser.parseExpression("1 - -3").getValue(Integer.class); // 4

double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class); //

-9000

// Multiplication
int six = parser.parseExpression("-2 * -3").getValue(Integer.class); // 6

double twentyFour = parser.parseExpression("2.0 * 3e0 *

4").getValue(Double.class); // 24.0

// Division

234
int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class); // -2

double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class); //

1.0

// Modulus
int three = parser.parseExpression("7 % 4").getValue(Integer.class); // 3

int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class); // 1

// Operator precedence
int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class); //
-21

6.5.7 Assignment

Setting of a property is done by using the assignment operator. This would

typically be done within a call to setValue but can also be done inside a call
to getValue.

Inventor inventor = new Inventor();

StandardEvaluationContext inventorContext = new
StandardEvaluationContext(inventor);

parser.parseExpression("Name").setValue(inventorContext, "Alexander Seovic2");

// alternatively

String aleks = parser.parseExpression("Name = 'Alexandar

Seovic'").getValue(inventorContext,

String.class);

6.5.8 Types

The special 'T' operator can be used to specify an instance of java.lang.Class (the
'type'). Static methods are invoked using this operator as well.
The StandardEvaluationContext uses a TypeLocator to find types and
the StandardTypeLocator (which can be replaced) is built with an understanding of
the java.lang package. This means T() references to types within java.lang do not
need to be fully qualified, but all other type references must be.

Class dateClass =
parser.parseExpression("T(java.util.Date)").getValue(Class.class);

Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

235
boolean trueValue =
parser.parseExpression("T(java.math.RoundingMode).CEILING <
T(java.math.RoundingMode).FLOOR")
.getValue(Boolean.class);

6.5.9 Constructors

Constructors can be invoked using the new operator. The fully qualified class
name should be used for all but the primitive type and String (where int, float, etc,
can be used).

Inventor einstein =
p.parseExpression("new org.spring.samples.spel.inventor.Inventor('Albert
Einstein',
'German')")

.getValue(Inventor.class);

//create new inventor instance within add method of List

p.parseExpression("Members.add(new
org.spring.samples.spel.inventor.Inventor('Albert Einstein',
'German'))")

.getValue(societyContext);

6.5.10 Variables

Variables can be referenced in the expression using the syntax #variableName.

Variables are set using the method setVariable on the StandardEvaluationContext.

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");

StandardEvaluationContext context = new StandardEvaluationContext(tesla);
context.setVariable("newName", "Mike Tesla");

parser.parseExpression("Name = #newName").getValue(context);

System.out.println(tesla.getName()) // "Mike Tesla"

6.5.10.1 The #this and #root variables

The variable #this is always defined and refers to the current evaluation object
(against which unqualified references are resolved). The variable #root is always
defined and refers to the root context object. Although #this may vary as
components of an expression are evaluated, #root always refers to the root.

236
// create an array of integers
List<Integer> primes = new ArrayList<Integer>();
primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

// create parser and set variable 'primes' as the array of integers

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("primes",primes);

// all prime numbers > 10 from the list (using selection ?{...})
// evaluates to [11, 13, 17]
List<Integer> primesGreaterThanTen =
(List<Integer>) parser.parseExpression("#primes.?
[#this>10]").getValue(context);

6.5.11 Functions

You can extend SpEL by registering user defined functions that can be called
within the expression string. The function is registered with
theStandardEvaluationContext using the method.

public void registerFunction(String name, Method m)

A reference to a Java Method provides the implementation of the function. For

example, a utility method to reverse a string is shown below.

public abstract class StringUtils {

public static String reverseString(String input) {

StringBuilder backwards = new StringBuilder();
for (int i = 0; i < input.length(); i++)
backwards.append(input.charAt(input.length() - 1 - i));
}
return backwards.toString();
}
}

This method is then registered with the evaluation context and can be used within
an expression string.

ExpressionParser parser = new SpelExpressionParser();

StandardEvaluationContext context = new StandardEvaluationContext();

context.registerFunction("reverseString",
StringUtils.class.getDeclaredMethod("reverseString",

237
new Class[]
{ String.class }));

String helloWorldReversed =
parser.parseExpression("#reverseString('hello')").getValue(context,
String.class);

6.5.12 Bean references

If the evaluation context has been configured with a bean resolver it is possible to
lookup beans from an expression using the (@) symbol.

ExpressionParser parser = new SpelExpressionParser();

StandardEvaluationContext context = new StandardEvaluationContext();
context.setBeanResolver(new MyBeanResolver());

// This will end up calling resolve(context,"foo") on MyBeanResolver during

evaluation
Object bean = parser.parseExpression("@foo").getValue(context);

6.5.13 Ternary Operator (If-Then-Else)

You can use the ternary operator for performing if-then-else conditional logic inside
the expression. A minimal example is:

String falseString =
parser.parseExpression("false ? 'trueExp' :
'falseExp'").getValue(String.class);

In this case, the boolean false results in returning the string value 'falseExp'. A
more realistic example is shown below.

parser.parseExpression("Name").setValue(societyContext, "IEEE");
societyContext.setVariable("queryName", "Nikola Tesla");

expression = "isMember(#queryName)? #queryName + ' is a member of the ' " +

"+ Name + ' Society' : #queryName + ' is not a member of the ' + Name
+ ' Society'";

String queryResultString =
parser.parseExpression(expression).getValue(societyContext,
String.class);
// queryResultString = "Nikola Tesla is a member of the IEEE Society"

Also see the next section on the Elvis operator for an even shorter syntax for the
ternary operator.

238
6.5.14 The Elvis Operator

The Elvis operator is a shortening of the ternary operator syntax and is used in
the Groovy language. With the ternary operator syntax you usually have to repeat
a variable twice, for example:

String name = "Elvis Presley";

String displayName = name != null ? name : "Unknown";

Instead you can use the Elvis operator, named for the resemblance to Elvis' hair
style.

ExpressionParser parser = new SpelExpressionParser();

String name = parser.parseExpression("null?:'Unknown'").getValue(String.class);

System.out.println(name); // 'Unknown'

Here is a more complex example.

ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");

StandardEvaluationContext context = new StandardEvaluationContext(tesla);

String name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context,

String.class);

System.out.println(name); // Mike Tesla

tesla.setName(null);

name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context,

String.class);

System.out.println(name); // Elvis Presley

6.5.15 Safe Navigation operator

The Safe Navigation operator is used to avoid a NullPointerException and comes

from the Groovy language. Typically when you have a reference to an object you
might need to verify that it is not null before accessing methods or properties of the
object. To avoid this, the safe navigation operator will simply return null instead of
throwing an exception.

239
ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");

tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan"));

StandardEvaluationContext context = new StandardEvaluationContext(tesla);

String city = parser.parseExpression("PlaceOfBirth?.City").getValue(context,

String.class);
System.out.println(city); // Smiljan

tesla.setPlaceOfBirth(null);

city = parser.parseExpression("PlaceOfBirth?.City").getValue(context,
String.class);

System.out.println(city); // null - does not throw NullPointerException!!!

6.5.16 Collection Selection

Selection is a powerful expression language feature that allows you to transform

some source collection into another by selecting from its entries.

Selection uses the syntax ?[selectionExpression]. This will filter the collection and
return a new collection containing a subset of the original elements. For example,
selection would allow us to easily get a list of Serbian inventors:

List<Inventor> list = (List<Inventor>)

parser.parseExpression("Members.?[Nationality ==
'Serbian']").getValue(societyContext);

Selection is possible upon both lists and maps. In the former case the selection
criteria is evaluated against each individual list element whilst against a map the
selection criteria is evaluated against each map entry (objects of the Java
type Map.Entry). Map entries have their key and value accessible as properties for
use in the selection.

This expression will return a new map consisting of those elements of the original
map where the entry value is less than 27.

Map newMap = parser.parseExpression("map.?[value<27]").getValue();

In addition to returning all the selected elements, it is possible to retrieve just the
first or the last value. To obtain the first entry matching the selection the syntax
is ^[...] whilst to obtain the last matching selection the syntax is $[...].

240
6.5.17 Collection Projection

Projection allows a collection to drive the evaluation of a sub-expression and the

result is a new collection. The syntax for projection is ![projectionExpression]. Most
easily understood by example, suppose we have a list of inventors but want the list
of cities where they were born. Effectively we want to evaluate 'placeOfBirth.city'
for every entry in the inventor list. Using projection:

// returns [ 'Smiljan', 'Idvor' ]

List placesOfBirth = (List)parser.parseExpression("Members.![placeOfBirth.city]");

A map can also be used to drive projection and in this case the projection
expression is evaluated against each entry in the map (represented as a
Java Map.Entry). The result of a projection across a map is a list consisting of the
evaluation of the projection expression against each map entry.

6.5.18 Expression templating

Expression templates allow a mixing of literal text with one or more evaluation
blocks. Each evaluation block is delimited with prefix and suffix characters that you
can define, a common choice is to use #{ } as the delimiters. For example,

String randomPhrase =
parser.parseExpression("random number is #{T(java.lang.Math).random()}",
new TemplateParserContext()).getValue(String.class);

// evaluates to "random number is 0.7038186818312008"

The string is evaluated by concatenating the literal text 'random number is ' with
the result of evaluating the expression inside the #{ } delimiter, in this case the
result of calling that random() method. The second argument to the
method parseExpression() is of the type ParserContext. TheParserContext interface is
used to influence how the expression is parsed in order to support the expression
templating functionality. The definition of TemplateParserContext is shown below.

public class TemplateParserContext implements ParserContext {

public String getExpressionPrefix() {

return "#{";
}

public String getExpressionSuffix() {

return "}";

241
}

public boolean isTemplate() {

return true;
}
}

6.6 Classes used in the examples

Inventor.java

package org.spring.samples.spel.inventor;

import java.util.Date;
import java.util.GregorianCalendar;

public class Inventor {

private String name;

private String nationality;
private String[] inventions;
private Date birthdate;
private PlaceOfBirth placeOfBirth;

public Inventor(String name, String nationality)

{
GregorianCalendar c= new GregorianCalendar();
this.name = name;
this.nationality = nationality;
this.birthdate = c.getTime();
}
public Inventor(String name, Date birthdate, String nationality) {
this.name = name;
this.nationality = nationality;
this.birthdate = birthdate;
}

public Inventor() {
}

public String getName() {

return name;
}
public void setName(String name) {
this.name = name;
}
public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality;

242
}
public Date getBirthdate() {
return birthdate;
}
public void setBirthdate(Date birthdate) {
this.birthdate = birthdate;
}
public PlaceOfBirth getPlaceOfBirth() {
return placeOfBirth;
}
public void setPlaceOfBirth(PlaceOfBirth placeOfBirth) {
this.placeOfBirth = placeOfBirth;
}
public void setInventions(String[] inventions) {
this.inventions = inventions;
}
public String[] getInventions() {
return inventions;
}
}

PlaceOfBirth.java

package org.spring.samples.spel.inventor;

public class PlaceOfBirth {

private String city;

private String country;

public PlaceOfBirth(String city) {

this.city=city;
}
public PlaceOfBirth(String city, String country)
{
this(city);
this.country = country;
}

public String getCity() {

return city;
}
public void setCity(String s) {
this.city = s;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}

243
}

Society.java

package org.spring.samples.spel.inventor;

import java.util.*;

public class Society {

private String name;

public static String Advisors = "advisors";

public static String President = "president";

private List<Inventor> members = new ArrayList<Inventor>();

private Map officers = new HashMap();

public List getMembers() {

return members;
}

public Map getOfficers() {

return officers;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public boolean isMember(String name)

{
boolean found = false;
for (Inventor inventor : members) {
if (inventor.getName().equals(name))
{
found = true;
break;
}
}
return found;
}

244
7. Aspect Oriented Programming with Spring

7.1 Introduction

Aspect-Oriented Programming (AOP) complements Object-Oriented Programming

(OOP) by providing another way of thinking about program structure. The key unit
of modularity in OOP is the class, whereas in AOP the unit of modularity is
the aspect. Aspects enable the modularization of concerns such as transaction
management that cut across multiple types and objects. (Such concerns are often
termed crosscutting concerns in AOP literature.)

One of the key components of Spring is the AOP framework. While the Spring IoC
container does not depend on AOP, meaning you do not need to use AOP if you
don't want to, AOP complements Spring IoC to provide a very capable middleware
solution.
Spring 2.0 AOP

Spring 2.0 introduces a simpler and more powerful way of writing custom aspects using either a schema-
based approach or the @AspectJ annotation style. Both of these styles offer fully typed advice and use of
the AspectJ pointcut language, while still using Spring AOP for weaving.

The Spring 2.0 schema- and @AspectJ-based AOP support is discussed in this chapter. Spring 2.0 AOP
remains fully backwards compatible with Spring 1.2 AOP, and the lower-level AOP support offered by the
Spring 1.2 APIs is discussed in the following chapter.

AOP is used in the Spring Framework to...

 ... provide declarative enterprise services, especially as a replacement for

EJB declarative services. The most important such service is declarative
transaction management.
 ... allow users to implement custom aspects, complementing their use of
OOP with AOP.

If you are interested only in generic declarative services or other pre-packaged

declarative middleware services such as pooling, you do not need to work directly
with Spring AOP, and can skip most of this chapter.

7.1.1 AOP concepts

Let us begin by defining some central AOP concepts and terminology. These
terms are not Spring-specific... unfortunately, AOP terminology is not particularly

245
intuitive; however, it would be even more confusing if Spring used its own
terminology.

 Aspect: a modularization of a concern that cuts across multiple classes.

Transaction management is a good example of a crosscutting concern in
enterprise Java applications. In Spring AOP, aspects are implemented using
regular classes (the schema-based approach) or regular classes annotated
with the @Aspect annotation (the @AspectJ style).
 Join point: a point during the execution of a program, such as the execution
of a method or the handling of an exception. In Spring AOP, a join
point always represents a method execution.

 Advice: action taken by an aspect at a particular join point. Different types of

advice include "around," "before" and "after" advice. (Advice types are
discussed below.) Many AOP frameworks, including Spring, model an
advice as an interceptor, maintaining a chain of interceptorsaround the join
point.

 Pointcut: a predicate that matches join points. Advice is associated with a

pointcut expression and runs at any join point matched by the pointcut (for
example, the execution of a method with a certain name). The concept of
join points as matched by pointcut expressions is central to AOP, and Spring
uses the AspectJ pointcut expression language by default.

 Introduction: declaring additional methods or fields on behalf of a type.

Spring AOP allows you to introduce new interfaces (and a corresponding
implementation) to any advised object. For example, you could use an
introduction to make a bean implement an IsModifiedinterface, to simplify
caching. (An introduction is known as an inter-type declaration in the
AspectJ community.)

 Target object: object being advised by one or more aspects. Also referred to
as the advised object. Since Spring AOP is implemented using runtime
proxies, this object will always be a proxied object.

 AOP proxy: an object created by the AOP framework in order to implement

the aspect contracts (advise method executions and so on). In the Spring
Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy.

 Weaving: linking aspects with other application types or objects to create an

advised object. This can be done at compile time (using the AspectJ

246
compiler, for example), load time, or at runtime. Spring AOP, like other pure
Java AOP frameworks, performs weaving at runtime.

Types of advice:

 Before advice: Advice that executes before a join point, but which does not
have the ability to prevent execution flow proceeding to the join point (unless
it throws an exception).
 After returning advice: Advice to be executed after a join point completes
normally: for example, if a method returns without throwing an exception.

 After throwing advice: Advice to be executed if a method exits by throwing

an exception.

 After (finally) advice: Advice to be executed regardless of the means by

which a join point exits (normal or exceptional return).

 Around advice: Advice that surrounds a join point such as a method

invocation. This is the most powerful kind of advice. Around advice can
perform custom behavior before and after the method invocation. It is also
responsible for choosing whether to proceed to the join point or to shortcut
the advised method execution by returning its own return value or throwing
an exception.

Around advice is the most general kind of advice. Since Spring AOP, like AspectJ,
provides a full range of advice types, we recommend that you use the least
powerful advice type that can implement the required behavior. For example, if you
need only to update a cache with the return value of a method, you are better off
implementing an after returning advice than an around advice, although an around
advice can accomplish the same thing. Using the most specific advice type
provides a simpler programming model with less potential for errors. For example,
you do not need to invoke the proceed() method on the JoinPoint used for around
advice, and hence cannot fail to invoke it.

In Spring 2.0, all advice parameters are statically typed, so that you work with
advice parameters of the appropriate type (the type of the return value from a
method execution for example) rather than Object arrays.

The concept of join points, matched by pointcuts, is the key to AOP which
distinguishes it from older technologies offering only interception. Pointcuts enable
advice to be targeted independently of the Object-Oriented hierarchy. For
example, an around advice providing declarative transaction management can be

247
applied to a set of methods spanning multiple objects (such as all business
operations in the service layer).

7.1.2 Spring AOP capabilities and goals

Spring AOP is implemented in pure Java. There is no need for a special

compilation process. Spring AOP does not need to control the class loader
hierarchy, and is thus suitable for use in a Servlet container or application server.

Spring AOP currently supports only method execution join points (advising the
execution of methods on Spring beans). Field interception is not implemented,
although support for field interception could be added without breaking the core
Spring AOP APIs. If you need to advise field access and update join points,
consider a language such as AspectJ.

Spring AOP's approach to AOP differs from that of most other AOP frameworks.
The aim is not to provide the most complete AOP implementation (although Spring
AOP is quite capable); it is rather to provide a close integration between AOP
implementation and Spring IoC to help solve common problems in enterprise
applications.

Thus, for example, the Spring Framework's AOP functionality is normally used in
conjunction with the Spring IoC container. Aspects are configured using normal
bean definition syntax (although this allows powerful "autoproxying" capabilities):
this is a crucial difference from other AOP implementations. There are some things
you cannot do easily or efficiently with Spring AOP, such as advise very fine-
grained objects (such as domain objects typically): AspectJ is the best choice in
such cases. However, our experience is that Spring AOP provides an excellent
solution to most problems in enterprise Java applications that are amenable to
AOP.

Spring AOP will never strive to compete with AspectJ to provide a comprehensive
AOP solution. We believe that both proxy-based frameworks like Spring AOP and
full-blown frameworks such as AspectJ are valuable, and that they are
complementary, rather than in competition. Spring 2.0 seamlessly integrates
Spring AOP and IoC with AspectJ, to enable all uses of AOP to be catered for
within a consistent Spring-based application architecture. This integration does not
affect the Spring AOP API or the AOP Alliance API: Spring AOP remains
backward-compatible. See the following chapter for a discussion of the Spring AOP APIs.

Note
One of the central tenets of the Spring Framework is that of non-invasiveness; this is the idea that

248
you should not be forced to introduce framework-specific classes and interfaces into your
business/domain model. However, in some places the Spring Framework does give you the
option to introduce Spring Framework-specific dependencies into your codebase: the rationale in
giving you such options is because in certain scenarios it might be just plain easier to read or
code some specific piece of functionality in such a way. The Spring Framework (almost) always
offers you the choice though: you have the freedom to make an informed decision as to which
option best suits your particular use case or scenario.

One such choice that is relevant to this chapter is that of which AOP framework (and which AOP
style) to choose. You have the choice of AspectJ and/or Spring AOP, and you also have the
choice of either the @AspectJ annotation-style approach or the Spring XML configuration-style
approach. The fact that this chapter chooses to introduce the @AspectJ-style approach first
should not be taken as an indication that the Spring team favors the @AspectJ annotation-style
approach over the Spring XML configuration-style.

See Section 7.4, “Choosing which AOP declaration style to use” for a more complete discussion
of the whys and wherefores of each style.

7.1.3 AOP Proxies

Spring AOP defaults to using standard J2SE dynamic proxies for AOP proxies.

This enables any interface (or set of interfaces) to be proxied.

Spring AOP can also use CGLIB proxies. This is necessary to proxy classes,
rather than interfaces. CGLIB is used by default if a business object does not
implement an interface. As it is good practice to program to interfaces rather than
classes, business classes normally will implement one or more business
interfaces. It is possible to force the use of CGLIB, in those (hopefully rare) cases
where you need to advise a method that is not declared on an interface, or where
you need to pass a proxied object to a method as a concrete type.

It is important to grasp the fact that Spring AOP is proxy-based. See Section 7.6.1,

“Understanding AOP proxies” for a thorough examination of exactly what this
implementation detail actually means.

7.2 @AspectJ support

@AspectJ refers to a style of declaring aspects as regular Java classes annotated

with Java 5 annotations. The @AspectJ style was introduced by the AspectJ
project as part of the AspectJ 5 release. Spring 2.0 interprets the same
annotations as AspectJ 5, using a library supplied by AspectJ for pointcut parsing
and matching. The AOP runtime is still pure Spring AOP though, and there is no
dependency on the AspectJ compiler or weaver.

249
Using the AspectJ compiler and weaver enables use of the full AspectJ language,
and is discussed in Section 7.8, “Using AspectJ with Spring applications”.

7.2.1 Enabling @AspectJ Support

To use @AspectJ aspects in a Spring configuration you need to enable Spring

support for configuring Spring AOP based on @AspectJ aspects,
and autoproxying beans based on whether or not they are advised by those
aspects. By autoproxying we mean that if Spring determines that a bean is advised
by one or more aspects, it will automatically generate a proxy for that bean to
intercept method invocations and ensure that advice is executed as needed.

The @AspectJ support is enabled by including the following element inside your
spring configuration:

<aop:aspectj-autoproxy/>

This assumes that you are using schema support as described

in Appendix C, XML Schema-based configuration. See Section C.2.7, “The aop
schema” for how to import the tags in the aop namespace.

If you are using the DTD, it is still possible to enable @AspectJ support by adding
the following definition to your application context:

You will also need two AspectJ libraries on the classpath of your
application: aspectjweaver.jar and aspectjrt.jar. These libraries are available in
the 'lib' directory of an AspectJ installation (version 1.5.1 or later required), or in
the 'lib/aspectj' directory of the Spring-with-dependencies distribution.

7.2.2 Declaring an aspect

With the @AspectJ support enabled, any bean defined in your application context
with a class that is an @AspectJ aspect (has the @Aspectannotation) will be
automatically detected by Spring and used to configure Spring AOP. The following
example shows the minimal definition required for a not-very-useful aspect:

250
A regular bean definition in the application context, pointing to a bean class that
has the @Aspect annotation:

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">

</bean>

And the NotVeryUsefulAspect class definition, annotated

with org.aspectj.lang.annotation.Aspect annotation;

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class NotVeryUsefulAspect {

Aspects (classes annotated with @Aspect) may have methods and fields just like any other
class. They may also contain pointcut, advice, and introduction (inter-type) declarations.

Autodetecting aspects through component scanning

You may register aspect classes as regular beans in your Spring XML configuration, or
autodetect them throuch classpath scanning - just like any other Spring-managed bean. However,
note that the @Aspect annotation is not sufficient for autodetection in the classpath: For that
purpose, you need to add a separate @Component annotation (or alternatively a custom
stereotype annotation that qualifies, as per the rules of Spring's component scanner).
Advising aspects with other aspects?

In Spring AOP, it is not possible to have aspects themselves be the target of advice from other
aspects. The @Aspectannotation on a class marks it as an aspect, and hence excludes it from
auto-proxying.

7.2.3 Declaring a pointcut

Recall that pointcuts determine join points of interest, and thus enable us to control
when advice executes. Spring AOP only supports method execution join points for
Spring beans, so you can think of a pointcut as matching the execution of methods
on Spring beans. A pointcut declaration has two parts: a signature comprising a
name and any parameters, and a pointcut expression that
determines exactly which method executions we are interested in. In the
@AspectJ annotation-style of AOP, a pointcut signature is provided by a regular
method definition, and the pointcut expression is indicated using

251
the @Pointcut annotation (the method serving as the pointcut signature must have
a void return type).

An example will help make this distinction between a pointcut signature and a
pointcut expression clear. The following example defines a pointcut
named 'anyOldTransfer' that will match the execution of any method
named 'transfer':

@Pointcut("execution(* transfer(..))")// the pointcut expression

private void anyOldTransfer() {}// the pointcut signature

The pointcut expression that forms the value of the @Pointcut annotation is a

regular AspectJ 5 pointcut expression. For a full discussion of AspectJ's pointcut
language, see the AspectJ Programming Guide (and for Java 5 based extensions,
the AspectJ 5 Developers Notebook) or one of the books on AspectJ such as
“Eclipse AspectJ” by Colyer et. al. or “AspectJ in Action” by Ramnivas Laddad.

7.2.3.1 Supported Pointcut Designators

Spring AOP supports the following AspectJ pointcut designators (PCD) for use in
pointcut expressions:
Other pointcut types

The full AspectJ pointcut language supports additional pointcut designators that are not supported in
Spring. These are: call, get, set, preinitialization, staticinitialization,
initialization, handler, adviceexecution, withincode, cflow, cflowbelow, if, @this,
and @withincode. Use of these pointcut designators in pointcut expressions interpreted by Spring AOP
will result in anIllegalArgumentException being thrown.

The set of pointcut designators supported by Spring AOP may be extended in future releases to support
more of the AspectJ pointcut designators.

 execution - for matching method execution join points, this is the primary
pointcut designator you will use when working with Spring AOP
 within - limits matching to join points within certain types (simply the
execution of a method declared within a matching type when using Spring
AOP)

 this - limits matching to join points (the execution of methods when using
Spring AOP) where the bean reference (Spring AOP proxy) is an instance of
the given type

252
 target - limits matching to join points (the execution of methods when using
Spring AOP) where the target object (application object being proxied) is an
instance of the given type

 args - limits matching to join points (the execution of methods when using
Spring AOP) where the arguments are instances of the given types

 @target -limits matching to join points (the execution of methods when using

Spring AOP) where the class of the executing object has an annotation of
the given type

 @args -limits matching to join points (the execution of methods when using

Spring AOP) where the runtime type of the actual arguments passed have
annotations of the given type(s)

 @within -limits matching to join points within types that have the given
annotation (the execution of methods declared in types with the given
annotation when using Spring AOP)

 @annotation - limits matching to join points where the subject of the join
point (method being executed in Spring AOP) has the given annotation

Because Spring AOP limits matching to only method execution join points, the
discussion of the pointcut designators above gives a narrower definition than you
will find in the AspectJ programming guide. In addition, AspectJ itself has type-
based semantics and at an execution join point both 'this' and 'target' refer to the
same object - the object executing the method. Spring AOP is a proxy-based
system and differentiates between the proxy object itself (bound to 'this') and the
target object behind the proxy (bound to 'target').

Note
Due to the proxy-based nature of Spring's AOP framework, protected methods are by
definition not intercepted, neither for JDK proxies (where this isn't applicable) nor for CGLIB
proxies (where this is technically possible but not recommendable for AOP purposes). As a
consequence, any given pointcut will be matched against public methods only!

If your interception needs include protected/private methods or even constructors, consider the
use of Spring-driven native AspectJ weaving instead of Spring's proxy-based AOP framework.
This constitutes a different mode of AOP usage with different characteristics, so be sure to make
yourself familiar with weaving first before making a decision.

Spring AOP also supports an additional PCD named 'bean'. This PCD allows you to
limit the matching of join points to a particular named Spring bean, or to a set of

253
named Spring beans (when using wildcards). The 'bean' PCD has the following
form:

bean(idOrNameOfBean)

The 'idOrNameOfBean' token can be the name of any Spring bean: limited
wildcard support using the '*' character is provided, so if you establish some
naming conventions for your Spring beans you can quite easily write a 'bean' PCD
expression to pick them out. As is the case with other pointcut designators, the
'bean' PCD can be &&'ed, ||'ed, and ! (negated) too.

Note
Please note that the 'bean' PCD is only supported in Spring AOP - and not in native AspectJ
weaving. It is a Spring-specific extension to the standard PCDs that AspectJ defines.

The 'bean' PCD operates at the instance level (building on the Spring bean name concept) rather
than at the type level only (which is what weaving-based AOP is limited to). Instance-based
pointcut designators are a special capability of Spring's proxy-based AOP framework and its
close integration with the Spring bean factory, where it is natural and straightforward to identify
specific beans by name.

7.2.3.2 Combining pointcut expressions

Pointcut expressions can be combined using '&&', '||' and '!'. It is also possible to
refer to pointcut expressions by name. The following example shows three pointcut
expressions: anyPublicOperation (which matches if a method execution join point
represents the execution of any public method); inTrading (which matches if a
method execution is in the trading module), and tradingOperation (which matches if
a method execution represents any public method in the trading module).

@Pointcut("execution(public * *(..))")
private void anyPublicOperation() {}

@Pointcut("within(com.xyz.someapp.trading..*)")
private void inTrading() {}

@Pointcut("anyPublicOperation() && inTrading()")

private void tradingOperation() {}

It is a best practice to build more complex pointcut expressions out of smaller

named components as shown above. When referring to pointcuts by name, normal
Java visibility rules apply (you can see private pointcuts in the same type,

254
protected pointcuts in the hierarchy, public pointcuts anywhere and so on).
Visibility does not affect pointcut matching.

7.2.3.3 Sharing common pointcut definitions

When working with enterprise applications, you often want to refer to modules of
the application and particular sets of operations from within several aspects. We
recommend defining a "SystemArchitecture" aspect that captures common
pointcut expressions for this purpose. A typical such aspect would look as follows:

package com.xyz.someapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SystemArchitecture {

/**
* A join point is in the web layer if the method is defined
* in a type in the com.xyz.someapp.web package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.web..*)")
public void inWebLayer() {}

/**
* A join point is in the service layer if the method is defined
* in a type in the com.xyz.someapp.service package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.service..*)")
public void inServiceLayer() {}

/**
* A join point is in the data access layer if the method is defined
* in a type in the com.xyz.someapp.dao package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.dao..*)")
public void inDataAccessLayer() {}

/**
* A business service is the execution of any method defined on a service
* interface. This definition assumes that interfaces are placed in the
* "service" package, and that implementation types are in sub-packages.
*
* If you group service interfaces by functional area (for example,
* in packages com.xyz.someapp.abc.service and com.xyz.def.service) then
* the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"
* could be used instead.
*

255
* Alternatively, you can write the expression using the 'bean'
* PCD, like so "bean(*Service)". (This assumes that you have
* named your Spring service beans in a consistent fashion.)
*/
@Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
public void businessService() {}

/**
* A data access operation is the execution of any method defined on a
* dao interface. This definition assumes that interfaces are placed in the
* "dao" package, and that implementation types are in sub-packages.
*/
@Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
public void dataAccessOperation() {}

The pointcuts defined in such an aspect can be referred to anywhere that you
need a pointcut expression. For example, to make the service layer transactional,
you could write:

<aop:config>
<aop:advisor
pointcut="com.xyz.someapp.SystemArchitecture.businessService()"
advice-ref="tx-advice"/>
</aop:config>

<tx:advice id="tx-advice">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

The <aop:config> and <aop:advisor> elements are discussed in Section 7.3,

“Schema-based AOP support”. The transaction elements are discussed
in Chapter 10, Transaction Management.

7.2.3.4 Examples

Spring AOP users are likely to use the execution pointcut designator the most
often. The format of an execution expression is:

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-

pattern(param-pattern)
throws-pattern?)

256
All parts except the returning type pattern (ret-type-pattern in the snippet above),
name pattern, and parameters pattern are optional. The returning type pattern
determines what the return type of the method must be in order for a join point to
be matched. Most frequently you will use * as the returning type pattern, which
matches any return type. A fully-qualified type name