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.

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.

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.

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, 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. The
BeanFactory 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 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 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 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).

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 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, 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.

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.

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.

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/download/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 deployed
in Maven Central.

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.

Bundle Symbolic Name, derived from the main package
root, e.g. org.springframework.beans. If the jar had to be
patched to ensure OSGi compliance then com.springsource is
appended, e.g. com.springsource.org.apache.log4j

Naming Convention: Version

Varies. Many new artifacts use m.m.m or m.m.m.X (with
m=digit, X=text). Older ones use m.m. Some neither. Ordering
is defined but not often relied on, so not strictly
reliable.

OSGi version number m.m.m.X, e.g. 3.0.0.RC3. The text
qualifier imposes alphabetic ordering on versions with the
same numeric values.

Publishing

Usually automatic via rsync or source control updates.
Project authors can upload individual jars to JIRA.

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.

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:

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 snapshots), you need to specify the repository location in
your Maven configuration. For full releases:

If you are managing your dependencies by hand, the URL in the
repository declaration above is not browsable, but there is a user
interface at http://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.

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:

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 you'll find an Ivy snippet ready for you to
include in your dependencies section. For example (in
ivy.xml):

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
Log objects 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.

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 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.

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.

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

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.

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 libraries not four (jcl-over-slf4j and
logback). If you do that you might also need to exclude the
slf4j-api dependency from other external dependencies (not Spring),
because you only want one version of that API on the classpath.

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:

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

2. New Features and Enhancements in Spring Framework 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 Framework 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.

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 Framework
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 Framework 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
Framework 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
Framework 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.

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.

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 Framework 3.0. We will cover these
features in more detail later in this section.

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

Defining bean metadata within components

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.

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.

2.5.9 Support for embedded databases

3. New Features and Enhancements in Spring Framework 3.1

This is a list of new features for Spring Framework 3.1. A number of features
do not have dedicated reference documentation but do have complete Javadoc. In such
cases, fully-qualified class names are given. See also Appendix C, Migrating to Spring Framework 3.1

3.5 Code equivalents for Spring's XML namespaces

Code-based equivalents to popular Spring XML namespace elements
<context:component-scan/>, <tx:annotation-driven/>
and <mvc:annotation-driven> have been developed, most in the
form of @Enable annotations. These are
designed for use in conjunction with Spring's
@Configuration classes, which were
introduced in Spring Framework 3.0.

See org.springframework.context.annotation.Configuration
Javadoc

See org.springframework.context.annotation.ComponentScan
Javadoc

See
org.springframework.transaction.annotation.EnableTransactionManagement
Javadoc

See
org.springframework.cache.annotation.EnableCaching Javadoc

See org.springframework.web.servlet.config.annotation.EnableWebMvc
Javadoc

See org.springframework.scheduling.annotation.EnableScheduling
Javadoc

See org.springframework.scheduling.annotation.EnableAsync
Javadoc

See
org.springframework.context.annotation.EnableAspectJAutoProxy
Javadoc

See
org.springframework.context.annotation.EnableLoadTimeWeaving
Javadoc

See
org.springframework.beans.factory.aspectj.EnableSpringConfigured
Javadoc

3.6 Support for Hibernate 4.x

See Javadoc for classes within the new
org.springframework.orm.hibernate4 package

The @ContextConfiguration
annotation now supports supplying
@Configuration classes for configuring
the Spring TestContext. In addition, a new
@ActiveProfiles annotation has been
introduced to support declarative configuration of active bean
definition profiles in ApplicationContext
integration tests.

3.8 c: namespace for more concise constructor injection

3.9 Support for injection against non-standard JavaBeans
setters

Prior to Spring Framework 3.1, in order to inject against a property
method it had to conform strictly to JavaBeans property signature rules,
namely that any 'setter' method must be void-returning. It is now possible
in Spring XML to specify setter methods that return any object type. This
is useful when considering designing APIs for method-chaining, where
setter methods return a reference to 'this'.

3.10 Support for Servlet 3 code-based configuration of Servlet
Container

The new WebApplicationInitializer
builds atop Servlet 3.0's
ServletContainerInitializer support to
provide a programmatic alternative to the traditional web.xml.

3.11 Support for Servlet 3 MultipartResolver

See
org.springframework.web.multipart.support.StandardServletMultipartResolver
Javadoc

3.12 JPA EntityManagerFactory bootstrapping without
persistence.xml

In standard JPA, persistence units get defined through
META-INF/persistence.xml files in specific jar files
which will in turn get searched for @Entity classes.
In many cases, persistence.xml does not contain more than a unit name
and relies on defaults and/or external setup for all other concerns
(such as the DataSource to use, etc). For that reason, Spring Framework
3.1 provides an alternative:
LocalContainerEntityManagerFactoryBean accepts a
'packagesToScan' property, specifying base packages to scan for
@Entity classes. This is analogous to
AnnotationSessionFactoryBean's property of the
same name for native Hibernate setup, and also to Spring's
component-scan feature for regular Spring beans. Effectively, this
allows for XML-free JPA setup at the mere expense of specifying a base
package for entity scanning: a particularly fine match for Spring
applications which rely on component scanning for Spring beans as well,
possibly even bootstrapped using a code-based Servlet 3.0
initializer.

3.13 New HandlerMethod-based Support Classes For Annotated Controller
Processing

Spring Framework 3.1 introduces a new set of support classes for
processing requests with annotated controllers:

RequestMappingHandlerMapping

RequestMappingHandlerAdapter

ExceptionHandlerExceptionResolver

These classes are a replacement for the existing:

DefaultAnnotationHandlerMapping

AnnotationMethodHandlerAdapter

AnnotationMethodHandlerExceptionResolver

The new classes were developed in response to many requests to
make annotation controller support classes more customizable and open
for extension. Whereas previously you could configure a custom annotated
controller method argument resolver, with the new support classes you
can customize the processing for any supported method argument or return
value type.

See
org.springframework.web.method.support.HandlerMethodArgumentResolver
Javadoc

See
org.springframework.web.method.support.HandlerMethodReturnValueHandler
Javadoc

A second notable difference is the introduction of a
HandlerMethod abstraction to represent an
@RequestMapping method. This abstraction is used
throughout by the new support classes as the handler
instance. For example a HandlerInterceptor can
cast the handler from Object
to HandlerMethod and get access to the target
controller method, its annotations, etc.

The new classes are enabled by default by the MVC namespace and by
Java-based configuration via @EnableWebMvc. The
existing classes will continue to be available but use of the new
classes is recommended going forward.

3.15 Flash Attributes and
RedirectAttributes

Flash attributes can now be stored in a
FlashMap and saved in the HTTP session to survive
a redirect. For an overview of the general support for flash attributes
in Spring MVC see Section 17.6, “Using flash attributes”.

In annotated controllers, an
@RequestMapping method can add flash
attributes by declaring a method argument of type
RedirectAttributes. This method argument
can now also be used to get precise control over the attributes used in
a redirect scenario. See the section called “Specifying redirect and flash attributes”
for more details.

3.16 URI Template Variable Enhancements

URI template variables from the current request are used in more
places:

URI template variables are used in addition to request
parameters when binding a request to
@ModelAttribute method
arguments.

@PathVariable method argument values are merged into the
model before rendering, except in views that generate content in
an automated fashion such as JSON serialization or XML
marshalling.

A redirect string can contain placeholders for URI variables
(e.g. "redirect:/blog/{year}/{month}"). When
expanding the placeholders, URI template variables from the
current request are automatically considered.

An @ModelAttribute method
argument can be instantiated from a URI template variable provided
there is a registered Converter or PropertyEditor to convert from
a String to the target object type.

3.17 @Valid On
@RequestBody Controller Method Arguments

An @RequestBody method argument can be
annotated with @Valid to invoke automatic
validation similar to the support for
@ModelAttribute method arguments. A resulting
MethodArgumentNotValidException is handled in the
DefaultHandlerExceptionResolver and results in a
400 response code.

3.19 UriComponentsBuilder and UriComponents

A new UriComponents class has been added,
which is an immutable container of URI components providing
access to all contained URI components.
A new UriComponentsBuilder class is also
provided to help create UriComponents instances.
Together the two classes give fine-grained control over all
aspects of preparing a URI including construction, expansion
from URI template variables, and encoding.

In most cases the new classes can be used as a more flexible
alternative to the existing UriTemplate
especially since UriTemplate relies on those
same classes internally.

4.1 Support for Servlet 3 based asynchronous request processing

java.util.concurrent.Callable to
complete processing in a separate thread managed by a task executor
within Spring MVC.

org.springframework.web.context.request.async.DeferredResult
to complete processing at a later time from a thread not known to
Spring MVC — for example, in response to some external event (JMS,
AMQP, etc.)

org.springframework.web.context.request.async.AsyncTask
to wrap a Callable and customize the
timeout value or the task executor to use.

4.2 Spring MVC Test framework

First-class support for testing Spring MVC applications with a
fluent API and without a Servlet container. Server-side tests involve use
of the DispatcherServlet while client-side REST
tests rely on the RestTemplate. See Section 11.3.6, “Spring MVC Test Framework”.

4.3 Content negotiation improvements

A ContentNegotiationStrategy is now
available for resolving the requested media types from an incoming
request. The available implementations are based on the file extension,
query parameter, the 'Accept' header, or a fixed content type.
Equivalent options were previously available only in the
ContentNegotiatingViewResolver but are now available throughout.

4.4 @ControllerAdvice annotation

Classes annotated with
@ControllerAdvice can contain
@ExceptionHandler,
@InitBinder, and
@ModelAttribute methods and those will
apply to @RequestMapping methods across
controller hierarchies as opposed to the controller hierarchy within which
they are declared. @ControllerAdvice is a
component annotation allowing implementation classes to be auto-detected
through classpath scanning.

An abstract base class implementation of the
WebApplicationInitializer interface is
provided to simplify code-based registration of a DispatcherServlet and
filters mapped to it. The new class is named
AbstractDispatcherServletInitializer and its
sub-class
AbstractAnnotationConfigDispatcherServletInitializer
can be used with Java-based Spring configuration. For more details see
Section 17.14, “Code-based Servlet container initialization”.

4.7 ResponseEntityExceptionHandler class

A convenient base class with an
@ExceptionHandler method that handles
standard Spring MVC exceptions and returns a
ResponseEntity that allowing customizing and
writing the response with HTTP message converters. This serves as an
alternative to the DefaultHandlerExceptionResolver,
which does the same but returns a ModelAndView
instead.

4.8 Support for generic types in the
RestTemplate and in
@RequestBody arguments

The RestTemplate can now read an HTTP
response to a generic type (e.g. List<Account>). There
are three new exchange() methods that accept
ParameterizedTypeReference, a new class that
enables capturing and passing generic type info.

In support of this feature, the
HttpMessageConverter is extended by
GenericHttpMessageConverter adding a method
for reading content given a specified parameterized type. The new
interface is implemented by the
MappingJacksonHttpMessageConverter and also by a
new Jaxb2CollectionHttpMessageConverter that can
read read a generic Collection where the
generic type is a JAXB type annotated with
@XmlRootElement or
@XmlType.

4.9 Jackson JSON 2 and related improvements

The Jackson JSON 2 library is now supported. Due to packaging
changes in the Jackson library, there are separate classes in Spring MVC
as well. Those are
MappingJackson2HttpMessageConverter and
MappingJackson2JsonView. Other related
configuration improvements include support for pretty printing as well as
a JacksonObjectMapperFactoryBean for convenient
customization of an ObjectMapper in XML
configuration.

4.10 Tiles 3

Tiles 3 is now supported in addition to Tiles 2.x. Configuring
it should be very similar to the Tiles 2 configuration, i.e. the
combination of TilesConfigurer,
TilesViewResolver and TilesView
except using the tiles3 instead of the tiles2
package.

Also note that besides the version number change, the tiles
dependencies have also changed. You will need to have a subset or all of
tiles-request-api, tiles-api,
tiles-core, tiles-servlet,
tiles-jsp, tiles-el.

4.11 @RequestBody improvements

An @RequestBody or an
@RequestPart argument can now be followed
by an Errors argument making it possible to
handle validation errors (as a result of an
@Valid annotation) locally within the
@RequestMapping method.
@RequestBody now also supports a required
flag.

4.12 HTTP PATCH method

The HTTP request method PATCH may now be used in
@RequestMapping methods as well as in the
RestTemplate in conjunction with Apache
HttpComponents HttpClient version 4.2 or later. The JDK
HttpURLConnection does not support the
PATCH method.

4.13 Excluded patterns in mapped interceptors

Mapped interceptors now support URL patterns to be excluded. The MVC
namespace and the MVC JavaConfig both expose these options.

4.14 Using meta-annotations for injection points and for bean definition methods

As of 3.2, Spring allows for @Autowired and
@Value to be used as meta-annotations,
e.g. to build custom injection annotations in combination with specific qualifiers.
Analogously, you may build custom @Bean definition
annotations for @Configuration classes,
e.g. in combination with specific qualifiers, @Lazy, @Primary, etc.

4.15 Initial support for JCache 0.5

Spring provides a CacheManager adapter for JCache, building against the JCache 0.5
preview release. Full JCache support is coming next year, along with Java EE 7 final.

4.16 Support for @DateTimeFormat without
Joda Time

The @DateTimeFormat annotation can
now be used without needing a dependency on the Joda Time library. If Joda
Time is not present the JDK SimpleDateFormat will
be used to parse and print date patterns. When Joda Time is present it
will continue to be used in preference to
SimpleDateFormat.

4.17 Global date & time formatting

4.18 New Testing Features

In addition to the aforementioned inclusion of the Spring MVC Test Framework in
the spring-test module, the Spring
TestContext Framework has been revised with support for
integration testing web applications as well as configuring application
contexts with context initializers. For further details, consult the
following.

4.19 Concurrency refinements across the framework

Spring Framework 3.2 includes fine-tuning of concurrent data structures
in many parts of the framework, minimizing locks and generally improving the
arrangements for highly concurrent creation of scoped/prototype beans.

4.20 New Gradle-based build and move to GitHub

Building and contributing to the framework has never been simpler with
our move to a Gradle-based build system and source control at GitHub.
See the
building from source section of the README and the
contributor guidelines for complete details.

4.21 Refined Java SE 7 / OpenJDK 7 support

Last but not least, Spring Framework 3.2 comes with refined Java 7 support
within the framework as well as through upgraded third-party dependencies:
specifically, CGLIB 3.0, ASM 4.0 (both of which come as inlined dependencies with
Spring now) and AspectJ 1.7 support (next to the existing AspectJ 1.6 support).

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 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.

5. The IoC container

5.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. The BeanFactory 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.

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 5.15, “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.

5.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 providing 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 5.14.4, “Convenient ApplicationContext
instantiation for web applications”).
If you are using the SpringSource Tool Suite Eclipse-powered development environment
or Spring Roo this
boilerplate configuration can be easily created with few mouse clicks or
keystrokes.

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

The Spring IoC container

5.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
totally decoupled from the format in which this
configuration metadata is actually written.

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

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:

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.

5.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.

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

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

In the preceding example, the service layer consists of the class
PetStoreServiceImpl, and two data access objects
of the type SqlMapAccountDao and 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.

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 Resource locations, 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:

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.

5.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(String name, Class<T> requiredType) you can
retrieve instances of your beans.

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

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.

5.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.

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.
DefaultListableBeanFactory supports this
registration through the methods
registerSingleton(..) and
registerBeanDefinition(..). However, typical
applications work solely with beans defined through metadata bean
definitions.

5.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. Conventionally these names are
alphanumeric ('myBean', 'fooService', etc), but may special characters
as well. If you 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. As a historical note, in versions prior to Spring 3.1, the
id attribute was typed as an
xsd:ID, which constrained possible characters. As of
3.1, it is now xsd:string. Note that bean id
uniqueness is still enforced by the container, though no longer by XML
parsers.

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 Locator 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.

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.

<aliasname="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.

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:

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.

5.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.

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

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

For example, if you have a class called Foo
in the com.example package, and this
Foo class has a static 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.

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:

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.

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) 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.

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.

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.

<!-- the factory bean, which contains a method called createInstance() --><beanid="serviceLocator"class="examples.DefaultServiceLocator"><!-- inject any dependencies required by this locator bean --></bean><!-- the bean to be created via the factory bean --><beanid="clientService"factory-bean="serviceLocator"factory-method="createClientServiceInstance"/>

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-specific FactoryBean.

5.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 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.

5.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.

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.

publicclass SimpleMovieLister {
// the SimpleMovieLister has a dependency on a MovieFinderprivate MovieFinder movieFinder;
// a constructor so that the Spring container can 'inject' a MovieFinderpublic SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// 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:

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.

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:

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:

Setter-based dependency injection

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.

publicclass SimpleMovieLister {
// the SimpleMovieLister has a dependency on the MovieFinderprivate MovieFinder movieFinder;
// a setter method so that the Spring container can 'inject' a MovieFinderpublicvoid setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// business logic that actually 'uses' the injected MovieFinder is omitted...
}

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 MBeans is 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.

Dependency resolution process

The container performs bean dependency resolution as follows:

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.

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.

Each property or constructor argument is an actual definition of
the value to set, or a reference to another bean in the
container.

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. 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 5.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.

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 InitializingBean
callback method) are invoked.

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:

publicclass ExampleBean {
// a private constructorprivate ExampleBean(...) {
...
}
// a static factory method; the arguments to this method can be
// considered the dependencies of the bean that is returned,
// regardless of how those arguments are actually used.publicstatic 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.

5.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.

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.

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

The Spring container converts the text inside the
<value/> element into a
java.util.Properties instance by using the
JavaBeans PropertyEditor mechanism. 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 the value attribute style.

The idref element

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.

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
client bean. 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.

<propertyname="targetName"><!-- a bean with id 'theTargetBean' must exist; otherwise an exception will be thrown --><idreflocal="theTargetBean"/></property>

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 a
ProxyFactoryBean bean definition. Using
<idref/> elements when you specify the interceptor names
prevents you from misspelling an interceptor id.

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 id attribute of the target bean, or as
one of the values in the name attribute of the target
bean.

<refbean="someBean"/>

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.

<reflocal="someBean"/>

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.

<!-- in the parent context --><beanid="accountService"class="com.foo.SimpleAccountService"><!-- insert dependencies as required as here --></bean>

<!-- in the child (descendant) context --><beanid="accountService"<-- bean name is the same as the parent bean -->
class="org.springframework.aop.framework.ProxyFactoryBean">
<propertyname="target"><refparent="accountService"/><!-- notice how we refer to the parent bean --></property><!-- insert other configuration and dependencies as required here --></bean>

Inner beans

<beanid="outer"class="..."><!-- instead of using a reference to a target bean, simply define the target bean inline --><propertyname="target"><beanclass="com.example.Person"><!-- this is the inner bean --><propertyname="name"value="Fiona Apple"/><propertyname="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 are
always anonymous and they are
always created with the outer bean. It is
not possible to inject inner beans into
collaborating beans other than into the enclosing bean.

Collections

In the <list/>,
<set/>, <map/>, and
<props/> elements, you set the properties and
arguments of the Java Collection types
List, Set,
Map, and
Properties, respectively.

<beanid="moreComplexObject"class="example.ComplexObject"><!-- results in a setAdminEmails(java.util.Properties) call --><propertyname="adminEmails"><props><propkey="administrator">[email protected]</prop><propkey="support">[email protected]</prop><propkey="development">[email protected]</prop></props></property><!-- results in a setSomeList(java.util.List) call --><propertyname="someList"><list><value>a list element followed by a reference</value><refbean="myDataSource" /></list></property><!-- results in a setSomeMap(java.util.Map) call --><propertyname="someMap"><map><entrykey="an entry"value="just some string"/><entrykey ="a ref"value-ref="myDataSource"/></map></property><!-- results in a setSomeSet(java.util.Set) call --><propertyname="someSet"><set><value>just some string</value><refbean="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.

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
adminEmailsProperties
collection that contains the result of the merging of the child's
adminEmails collection with the parent's
adminEmails collection.

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. The
merge attribute must be specified on the lower,
inherited, child definition; specifying the merge
attribute on a 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.

When the accounts property of the
foo bean is prepared for injection, the generics
information about the element type of the strongly-typed
Map<String, Float> is available by
reflection. Thus Spring's type conversion infrastructure recognizes
the various value elements as being of type
Float, and the string values 9.99,
2.75, and 3.99 are converted into an
actual Float type.

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 ("")

<beanclass="ExampleBean"><propertyname="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).

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 beans configuration 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.

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:

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.

The c: namespace uses the same conventions as the p: one (trailing -ref for bean references)
for setting the constructor arguments by their names. And just as well, it needs to be declared even though it is not defined in an XSD schema
(but it exists inside the Spring core).

For the rare cases where the constructor argument names are not available (usually if the bytecode was compiled without debugging information), one can
use fallback to the argument indexes:

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 a
NullPointerException is thrown.

5.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:

The depends-on attribute in the bean definition
can specify both an initialization time dependency and, in the case of
singleton beans
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.

5.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:

When the preceding configuration is consumed by an
ApplicationContext, the bean named
lazy is not eagerly pre-instantiated when the
ApplicationContext 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:

<beansdefault-lazy-init="true"><!-- no beans will be pre-instantiated... --></beans>

5.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 template
discussed 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 5.2. Autowiring modes

Mode

Explanation

no

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

byName

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

byType

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

constructor

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

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.

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
simple properties 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.

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

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 with
Repository, provide a value of *Repository. To
provide multiple patterns, define them in a comma-separated list. An
explicit value of true or false
for 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.

5.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.

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.

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

For this dynamic subclassing to work, 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 abstract method 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. As of Spring
3.2 it is no longer necessary to add CGLIB to your classpath, because
CGLIB classes are repackaged under org.springframework and distributed
within the spring-core JAR. This is done both for convenience as well
as to avoid potential conflicts with other projects that use differing
versions of CGLIB.

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! publicabstractclass 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?protectedabstract 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:

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:

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 the command bean is returned each
time.

Tip

The interested reader may also find the
ServiceLocatorFactoryBean (in the
org.springframework.beans.factory.config package)
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.

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:

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 match
java.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.

5.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 can choose 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.

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

5.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:

<beanid="accountService"class="com.foo.DefaultAccountService"/><!-- the following is equivalent, though redundant (singleton scope is the default) --><beanid="accountService"class="com.foo.DefaultAccountService"scope="singleton"/>

5.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.

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
initialization lifecycle callback methods are called
on all objects regardless of scope, in the case of prototypes, configured
destruction lifecycle callbacks are
not called. 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 5.6.1, “Lifecycle callbacks”.)

5.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 5.4.6, “Method injection”

5.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 containers such as the
ClassPathXmlApplicationContext, you get an
IllegalStateException complaining about an unknown
bean scope.

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, or
DispatcherPortlet, 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:

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.)

DispatcherServlet,
RequestContextListener and
RequestContextFilter all do 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.

Request scope

Consider the following bean definition:

<beanid="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.

Session scope

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 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.

Global session scope

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 HTTP Session scope is used, and
no error is raised.

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.

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"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"><!-- an HTTP Session-scoped bean exposed as a proxy --><beanid="userPreferences"class="com.foo.UserPreferences"scope="session"><!-- instructs the container to proxy the surrounding bean --><aop:scoped-proxy/></bean><!-- a singleton-scoped bean injected with a proxy to the above bean --><beanid="userService"class="com.foo.SimpleUserService"><!-- a reference to the proxied userPreferences bean --><propertyname="userPreferences"ref="userPreferences"/></bean></beans>

To create such a proxy, you insert a child
<aop:scoped-proxy/> element into a scoped bean
definition. See the section called “Choosing the type of proxy to create” and Appendix E, 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.)

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 same userPreferences 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 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 aUserPreferences
instance) which can fetch the real
UserPreferences object from the scoping mechanism
(HTTP request, Session, etc.). The
container injects this proxy object into the
userManager bean, 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:

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.

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 false for 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.

5.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.

Creating a custom scope

To integrate your custom scope(s) into the Spring container, you
need to implement the
org.springframework.beans.factory.config.Scope
interface, 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.

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.

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()

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
ApplicationContext implementations 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 Scope implementation 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.

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().

5.6 Customizing the nature of a bean

5.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.

Tip

The JSR-250 @PostConstruct and
@PreDestroy annotations are generally
considered best practice for receiving lifecycle callbacks in a modern
Spring application. Using these annotations means that your beans are not
coupled to Spring specific interfaces. For details see
Section 5.9.6, “@PostConstruct and
@PreDestroy”.

If you don't want to use the JSR-250 annotations but you are still
looking to remove coupling consider 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
BeanPostProcessor yourself. For more
information, see Section 5.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.

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, use the
@PostConstruct annotation or 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:

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, use the
@PreDestroy annotation or 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:

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.

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.

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

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):

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:

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.

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" Lifecycle
object that does not implement
SmartLifecycle would be 0. Therefore, any
negative phase value would indicate that an object should start 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's
isAutoStartup() 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.

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.

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:

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 methods of the ApplicationContext provide access to
file resources, publishing application events, and accessing a
MessageSource. These additional features are described in Section 5.14, “Additional Capabilities of the
ApplicationContext”

As of Spring 2.5, autowiring is another alternative to obtain
reference to the ApplicationContext. The
"traditional" constructor and byType
autowiring modes (as described in Section 5.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
ApplicationContext is autowired into a
field, constructor argument, or method parameter that is expecting the
ApplicationContext type if the field,
constructor, or method in question carries the
@Autowired annotation. For more
information, see Section 5.9.2, “@Autowired”.

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.

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

5.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:

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.

5.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.

<beanid="inheritedTestBean"abstract="true"class="org.springframework.beans.TestBean"><propertyname="name"value="parent"/><propertyname="age"value="1"/></bean><beanid="inheritsWithDifferentClass"class="org.springframework.beans.DerivedTestBean"parent="inheritedTestBean" init-method="initialize">
<propertyname="name"value="override"/><!-- the age property value of 1 will be inherited from parent --></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.

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:

<beanid="inheritedTestBeanWithoutClass"abstract="true"><propertyname="name"value="parent"/><propertyname="age"value="1"/></bean><beanid="inheritsWithClass"class="org.springframework.beans.DerivedTestBean"parent="inheritedTestBeanWithoutClass"init-method="initialize"><propertyname="name"value="override"/><!-- age will inherit the value of 1 from the parent bean definition--></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 is
abstract 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 an abstract 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.

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 abstract
bean.

5.8 Container Extension Points

Typically, an application developer does not need to subclass
ApplicationContext implementation classes.
Instead, the Spring IoC container can be extended by plugging in
implementations of special integration interfaces. The next few sections
describe these integration interfaces.

5.8.1 Customizing beans using a
BeanPostProcessor

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 initializing a bean, you can plug in one or
more BeanPostProcessor
implementations.

You can configure multiple BeanPostProcessor
instances, and you can control the order in which these
BeanPostProcessors execute by setting the
order property. You can set this property only if the
BeanPostProcessor implements the
Ordered interface; if you write your own
BeanPostProcessor you should consider
implementing the Ordered interface too. For
further details, consult the Javadoc for the
BeanPostProcessor and
Ordered interfaces. See also the note below on
programmatic registration of BeanPostProcessors

Note

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

BeanPostProcessors 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 post-process the beans in that
container. In other words, beans that are defined in one container are not
post-processed by a BeanPostProcessor defined in another
container, even if both containers are part of the same hierarchy.

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 InitializingBean's afterPropertiesSet()
and any declared init method) are called as well as after
any bean initialization callbacks. 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 in order
to provide proxy-wrapping logic.

An ApplicationContextautomatically detects any beans that are defined in
the configuration metadata which implement the
BeanPostProcessor interface. The
ApplicationContext registers these beans as
post-processors so that they can be called later upon bean creation.
Bean post-processors can be deployed in the container just like any other
beans.

Programmatically registering BeanPostProcessors

While the recommended approach for BeanPostProcessor
registration is through ApplicationContext
auto-detection (as described above), it is also
possible to register them programmatically
against a ConfigurableBeanFactory using the
addBeanPostProcessor method. This can be useful
when needing to evaluate conditional logic before registration, or even
for copying bean post processors across contexts in a hierarchy. Note
however that BeanPostProcessors added
programmatically do not respect the Ordered
interface. Here it is the order of
registration that dictates the order of execution. Note also
that BeanPostProcessors registered
programmatically are always processed before those registered through
auto-detection, regardless of any explicit ordering.

BeanPostProcessors and AOP
auto-proxying

Classes that implement the
BeanPostProcessor interface are
special and are treated differently by the
container. All BeanPostProcessorsand beans that they reference directly are
instantiated on startup, as part of the special startup phase of the
ApplicationContext. Next, all
BeanPostProcessors are registered in a
sorted fashion and applied to all further beans in the container.
Because AOP auto-proxying is implemented as a
BeanPostProcessor itself, neither
BeanPostProcessors nor the beans they reference
directly are eligible for auto-proxying, and thus do not have aspects woven
into them.

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

Note that if you have beans wired into your BeanPostProcessor
using autowiring or @Resource (which may fall back to autowiring),
Spring might access unexpected beans when searching for type-matching dependency candidates,
and therefore make them ineligible for auto-proxying or other kinds of bean post-processing.
For example, if you have a dependency annotated with @Resource
where the field/setter name does not directly correspond to the declared name of a bean and
no name attribute is used, then Spring will access other beans for matching them by type.

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

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.

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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.xsd
http://www.springframework.org/schema/lang
http://www.springframework.org/schema/lang/spring-lang.xsd"><lang:groovyid="messenger"script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy"><lang:propertyname="message"value="Fiona Apple Is Just So Dreamy."/></lang:groovy><!--
when the above bean (messenger) is instantiated, this custom
BeanPostProcessor implementation will output the fact to the system console
--><beanclass="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 28, Dynamic language support.)

The following simple Java application executes the preceding code and
configuration:

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.

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 those of 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
before the container instantiates any beans other
than BeanFactoryPostProcessors.

You can configure multiple
BeanFactoryPostProcessors, and 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 the Ordered interface
too. Consult the Javadoc for the
BeanFactoryPostProcessor and
Ordered interfaces for more details.

Note

If you want to change the actual bean instances
(i.e., the objects that are created from the configuration metadata), then you
instead need to use a BeanPostProcessor
(described above in Section 5.8.1, “Customizing beans using a
BeanPostProcessor”). While
it is technically possible to work with bean instances within a
BeanFactoryPostProcessor (e.g., using
BeanFactory.getBean()), doing so causes
premature bean instantiation, violating the standard container 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 be applied to the bean
definitions in that container. Bean definitions in one 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 an ApplicationContext,
in order to apply changes to the configuration metadata that define the
container. Spring includes a number of predefined bean factory
post-processors, such as PropertyOverrideConfigurer
and PropertyPlaceholderConfigurer. A custom
BeanFactoryPostProcessor can also be used,
for example, to register custom property editors.

An ApplicationContext automatically
detects any beans that are deployed into it that implement the
BeanFactoryPostProcessor interface. It
uses these beans as bean factory post-processors, at the
appropriate time. You can deploy these post-processor beans as you
would any other bean.

Note

As with BeanPostProcessors, you typically
do not want to configure BeanFactoryPostProcessors
for lazy initialization. If no other bean references a
Bean(Factory)PostProcessor,
that post-processor will not get instantiated at all. Thus, marking it for
lazy initialization will be ignored, and the
Bean(Factory)PostProcessor will be
instantiated eagerly even if you set the default-lazy-init
attribute to true on the declaration of your
<beans /> element.

Example: the
PropertyPlaceholderConfigurer

You use the
PropertyPlaceholderConfigurer to
externalize property values from a bean definition in a separate
file using the standard Java Properties format.
Doing so enables the person deploying an application to customize
environment-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.

Therefore, the string ${jdbc.username} is replaced
at runtime with the value 'sa', and the same applies for other placeholder
values that match keys in the properties file. The
PropertyPlaceholderConfigurer checks for
placeholders in most properties and attributes of a bean definition.
Furthermore, 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. One or more locations can be provided as a
comma-separated list in the location
attribute.

The PropertyPlaceholderConfigurer not only
looks for properties in the Properties file
you specify. By default it also checks against the Java
System properties if it cannot find a property
in the specified properties files. You can customize this behavior by setting the
systemPropertiesMode property of the configurer with
one of the following three supported integer values:

never (0): Never check system properties

fallback (1): Check system properties if not resolvable in the specified properties files. This is the default.

override (2): Check system properties first, before trying the specified properties files. This allows system properties to override any other property source.

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:

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.

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 being 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.

This example file can be used with 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-overridelocation="classpath:override.properties"/>

5.8.3 Customizing instantiation logic with a
FactoryBean

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:

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.

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 the FactoryBean
interface ship with Spring itself.

When you need to ask a container for an actual
FactoryBean instance itself instead of the bean
it produces, preface the bean's id with the ampersand symbol
(&) when calling the
getBean() method of the
ApplicationContext. So for a given
FactoryBean with an id of
myBean, invoking getBean("myBean")
on the container returns the product of the
FactoryBean; whereas, invoking
getBean("&myBean") returns the
FactoryBean instance
itself.

5.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 the section called “Example: The
RequiredAnnotationBeanPostProcessor”, using a
BeanPostProcessor in conjunction with
annotations is a common means of extending the Spring IoC container. For
example, Spring 2.0 introduced the possibility of enforcing required
properties with the @Required annotation. Spring 2.5 made it 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 5.4.5, “Autowiring collaborators” but with more fine-grained control and
wider applicability. Spring 2.5 also added support for JSR-250 annotations
such as @PostConstruct, and
@PreDestroy. Spring 3.0 added support for
JSR-330 (Dependency Injection for Java) annotations contained in the
javax.inject package such as @Inject and
@Named. Details about those annotations can be found in the relevant section.

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):

<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 your controllers, and
not your services. See Section 17.2, “The DispatcherServlet” for more
information.

5.9.1 @Required

The @Required annotation applies to
bean property setter methods, as in the following example:

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.

5.9.2 @Autowired

As expected, you can apply the
@Autowired annotation to "traditional"
setter methods:

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.

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,
Environment,
ResourceLoader,
ApplicationEventPublisher, and
MessageSource. These interfaces and their
extended interfaces, such as
ConfigurableApplicationContext or
ResourcePatternResolver, are automatically
resolved, with no special setup necessary.

@Autowired,
@Inject,
@Resource, and
@Value annotations are handled by a
Spring BeanPostProcessor implementations
which in turn means that you cannot
apply these annotations within your own
BeanPostProcessor or
BeanFactoryPostProcessor types (if any). These
types must be 'wired up' explicitly via XML or using a Spring
@Bean method.

5.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:

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 a
Set<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.

@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:

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.

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:

<beanclass="example.SimpleMovieCatalog"><qualifier type="Offline"/><!-- inject any dependencies required by this bean --></bean>

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:

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"?><beansxmlns="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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"><context:annotation-config/><beanclass="example.SimpleMovieCatalog"><qualifiertype="MovieQualifier"><attributekey="format"value="VHS"/><attributekey="genre"value="Action"/></qualifier><!-- inject any dependencies required by this bean --></bean><beanclass="example.SimpleMovieCatalog"><qualifiertype="MovieQualifier"><attributekey="format"value="VHS"/><attributekey="genre"value="Comedy"/></qualifier><!-- inject any dependencies required by this bean --></bean><beanclass="example.SimpleMovieCatalog"><metakey="format"value="DVD"/><metakey="genre"value="Action"/><!-- inject any dependencies required by this bean --></bean><beanclass="example.SimpleMovieCatalog"><metakey="format"value="BLURAY"/><metakey="genre"value="Comedy"/><!-- inject any dependencies required by this bean --></bean></beans>

5.9.4 CustomAutowireConfigurer

The CustomAutowireConfigurer is a
BeanFactoryPostProcessor that enables you
to register your own custom qualifier annotation types even if they are
not annotated with Spring's @Qualifier
annotation.

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.

5.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
example in JSF 1.2 managed beans or JAX-WS 2.0 endpoints. Spring supports
this pattern for Spring-managed objects as well.

@Resource takes a name attribute, and
by default Spring interprets that value as the bean name to be injected.
In other words, it follows by-name semantics, as
demonstrated in this example:

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:

The name provided with the annotation is resolved as a bean name by
the ApplicationContext of which the
CommonAnnotationBeanPostProcessor is aware. The
names can be resolved through JNDI if you configure Spring's SimpleJndiBeanFactory 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.

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 type
ApplicationContext.

5.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.

5.10 Classpath scanning and managed components

Most examples in this chapter use XML to specify the configuration
metadata that produces each BeanDefinition
within the Spring container. The previous section
(Section 5.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.

5.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 15.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.

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.)

The use of <context:component-scan> implicitly
enables the functionality of <context:annotation-config>.
There is usually no need to include the <context:annotation-config>
element when using <context:component-scan>.

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
CommonAnnotationBeanPostProcessor are both
included implicitly when you use the component-scan element. 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.

5.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
expression attributes. The following table describes
the filtering options.

Table 5.5. Filter Types

Filter Type

Example Expression

Description

annotation

org.example.SomeAnnotation

An annotation to be present at the type level in target
components.

assignable

org.example.SomeClass

A class (or interface) that the target components are
assignable to (extend/implement).

aspectj

org.example..*Service+

An AspectJ type expression to be matched by the target
components.

regex

org\.example\.Default.*

A regex expression to be matched by the target components
class names.

custom

org.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.

You can also disable the default filters by providing
use-default-filters="false" as an attribute of the
<component-scan/> element. This will in effect disable automatic
detection of classes annotated with
@Component,
@Repository,
@Service, or
@Controller.

5.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:

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:

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 are
not invoked with normal Java semantics. In contrast,
calling a method or field within a @Component classes
@Bean method has standard Java
semantics.

5.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.

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:

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:

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.

5.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:

To provide a custom strategy for scope resolution rather than
relying on the annotation-based approach, implement the ScopeMetadataResolver interface,
and be sure to include a default no-arg constructor. Then, provide the
fully-qualified class name when configuring the scanner:

When using certain non-singleton scopes, it may be necessary to
generate proxies for the scoped objects. The reasoning is described in
the section called “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:

5.10.7 Providing qualifier metadata with annotations

The @Qualifier annotation is discussed
in Section 5.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:

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.

5.11 Using JSR 330 Standard Annotations

Starting with Spring 3.0, Spring offers support for JSR-330 standard annotations (Dependency Injection).
Those annotations are scanned in the same way as the Spring annotations. You just need to have the relevant jars in your classpath.

As with @Autowired, it is possible to use @Inject
at the class-level, field-level, method-level and constructor-argument level.
If you would like to use a qualified name for the dependency that should be injected,
you should use the @Named annotation as follows:

When using @Named, it is possible to use
component-scanning in the exact same way as when using Spring annotations:

<beans><context:component-scanbase-package="org.example"/></beans>

5.11.3 Limitations of the standard approach

When working with standard annotations, it is important to know that
some significant features are not available as shown in the table below:

Table 5.6. Spring annotations vs. standard annotations

Spring

javax.inject.*

javax.inject restrictions / comments

@Autowired

@Inject

@Inject has no 'required' attribute

@Component

@Named



@Scope("singleton")

@Singleton

The JSR-330 default scope is like Spring's prototype.
However, in order to keep it consistent with Spring's general defaults,
a JSR-330 bean declared in the Spring container is a
singleton by default. In order to use a
scope other than singleton, you should use Spring's
@Scope annotation.

javax.inject also provides a
@Scope annotation.
Nevertheless, this one is only intended to be used for creating your own annotations.

@Qualifier

@Named



@Value



no equivalent

@Required



no equivalent

@Lazy



no equivalent

5.12 Java-based container configuration

5.12.1 Basic concepts: @Bean and @Configuration

Full @Configuration vs 'lite' @Beans mode?

When @Bean methods are declared within
classes that are not annotated with
@Configuration they are referred to as being
processed in a 'lite' mode. For example, bean methods declared in a
@Component or even in a plain old
class will be considered 'lite'.

Unlike full @Configuration, lite
@Bean methods cannot easily declare inter-bean
dependencies. Usually one @Bean method should not
invoke another @Bean method when operating in
'lite' mode.

Only using @Bean methods within
@Configuration classes is a recommended approach
of ensuring that 'full' mode is always used. This will prevent the same
@Bean method from accidentally being invoked
multiple times and helps to reduce subtle bugs that can be hard to track down
when operating in 'lite' mode.

The central artifacts in Spring's new Java-configuration support are
@Configuration-annotated classes and
@Bean-annotated methods.

The @Bean annotation is used to indicate that a
method instantiates, configures and initializes a new object to be managed by
the Spring IoC container. For those familiar with Spring's
<beans/> XML configuration the @Bean
annotation plays the same role as the <bean/>
element. You can use @Bean annotated methods with
any Spring @Component, however, they are most
often used with @Configuration beans.

Annotating a class with @Configuration
indicates that its primary purpose is as a source of bean definitions. Furthermore,
@Configuration classes allow inter-bean
dependencies to be defined by simply calling other @Bean
methods in the same class. The simplest possible
@Configuration class would read as follows:

The sections below document Spring's
AnnotationConfigApplicationContext, new in Spring 3.0.
This versatile ApplicationContext implementation 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 @Bean methods 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.

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:

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:

The above assumes that MyServiceImpl,
Dependency1 and Dependency2 use
Spring dependency injection annotations such as
@Autowired.

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.

Enabling component scanning with
scan(String...)

Experienced Spring users will be familiar with the following
commonly-used XML declaration from Spring's context:
namespace

<beans><context:component-scanbase-package="com.acme"/></beans>

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:

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.

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><!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext
instead of the default XmlWebApplicationContext --><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><!-- Bootstrap the root application context as usual using ContextLoaderListener --><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!-- Declare a Spring MVC DispatcherServlet as usual --><servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext
instead of the default XmlWebApplicationContext --><init-param><param-name>contextClass</param-name><param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value></init-param><!-- Again, config locations must consist of one or more comma- or space-delimited
and fully-qualified @Configuration classes --><init-param><param-name>contextConfigLocation</param-name><param-value>com.acme.web.MvcConfig</param-value></init-param></servlet><!-- map all requests for /app/* to the dispatcher servlet --><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>/app/*</url-pattern></servlet-mapping></web-app>

5.12.3 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.

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:

Both declarations make a bean named transferService
available in the ApplicationContext, bound to an object
instance of type TransferServiceImpl:

transferService -> com.acme.TransferServiceImpl

Receiving lifecycle callbacks

Any classes defined with the
@Bean annotation support
the regular lifecycle callbacks and 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.

@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 or
ScopedProxyMode.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:

Bean aliasing

As discussed in Section 5.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.

5.12.4 Using the @Configuration annotation

@Configuration is a class-level annotation
indicating that an object is a source of bean definitions.
@Configuration classes declare beans via
public @Bean annotated methods. Calls to
@Bean methods on
@Configuration classes can also be used to
define inter-bean dependencies. See Section 5.12.1, “Basic concepts: @Bean and @Configuration” for
a general introduction.

Injecting inter-bean dependencies

When @Beans have dependencies on one
another, expressing that dependency is as simple as having one bean
method call another:

In the example above, the foo bean receives a reference
to bar via constructor injection.

Note

This method of declaring inter-bean dependencies only works when
the @Bean method is declared within a
@Configuration class. You cannot declare
inter-bean dependencies using plain @Component
classes.

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.

publicabstractclass 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?protectedabstract 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:

clientDao() has been called once in
clientService1() and once in
clientService2(). Since this method creates a new
instance of ClientDaoImpl 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 that as of Spring
3.2, it is no longer necessary to add CGLIB to your classpath because
CGLIB classes have been repackaged under org.springframework and included
directly within the spring-core JAR.

Note

The behavior could be different according to the scope of your
bean. We are talking about singletons here.

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

5.12.5 Composing Java-based configurations

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:

Now, rather than needing to specify both
ConfigA.class and ConfigB.class
when instantiating the context, only ConfigB needs to
be supplied
explicitly:

publicstaticvoid 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:

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:

In the situation above, it is completely explicit where
AccountRepository is defined. However,
ServiceConfig is now tightly coupled to
RepositoryConfig; that's the tradeoff. This tight
coupling can be somewhat mitigated by using interface-based or
abstract class-based @Configuration classes.
Consider the following:

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.

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 using
AnnotationConfigApplicationContext 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.

system-test-config.xml<beans><!-- enable processing of annotations such as @Autowired and @Configuration --><context:annotation-config/><context:property-placeholderlocation="classpath:/com/acme/jdbc.properties"/><beanclass="com.acme.AppConfig"/><beanclass="org.springframework.jdbc.datasource.DriverManagerDataSource"><propertyname="url"value="${jdbc.url}"/><propertyname="username"value="${jdbc.username}"/><propertyname="password"value="${jdbc.password}"/></bean></beans>

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><!-- picks up and registers AppConfig as a bean definition --><context:component-scanbase-package="com.acme"/><context:property-placeholderlocation="classpath:/com/acme/jdbc.properties"/><beanclass="org.springframework.jdbc.datasource.DriverManagerDataSource"><propertyname="url"value="${jdbc.url}"/><propertyname="username"value="${jdbc.username}"/><propertyname="password"value="${jdbc.password}"/></bean></beans>

@Configuration class-centric use of XML with
@ImportResource

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.

5.13 Registering a LoadTimeWeaver

The LoadTimeWeaver is used by Spring to dynamically
transform classes as they are loaded into the Java virtual machine (JVM).

To enable load-time weaving add the @EnableLoadTimeWeaving
to one of your @Configuration classes:

@Configuration@EnableLoadTimeWeavingpublicclass AppConfig {
}

Alternatively for XML configuration use the context:load-time-weaver element:

<beans><context:load-time-weaver/></beans>

Once configured 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
the LocalContainerEntityManagerFactoryBean Javadoc
for more detail. For more on AspectJ load-time weaving, see Section 9.8.4, “Load-time weaving with AspectJ in the Spring Framework”.

5.14 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.

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.

5.14.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 the MessageSource. 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 name messageSource. If such a
bean is found, all calls to the preceding methods are delegated to the
message source. If no message source is found, the
ApplicationContext attempts to find a
parent containing a bean with the same name. If it does, it uses that bean
as the MessageSource. If the
ApplicationContext 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
StaticMessageSource. Both implement
HierarchicalMessageSource in order to do
nested messaging. The StaticMessageSource is rarely
used but provides programmatic ways to add messages to the source. The
ResourceBundleMessageSource is shown in the
following example:

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...

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.

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><!-- this MessageSource is being used in a web application --><beanid="messageSource"class="org.springframework.context.support.ResourceBundleMessageSource"><propertyname="basename"value="exceptions"/></bean><!-- lets inject the above MessageSource into this POJO --><beanid="example"class="com.foo.Example"><propertyname="messages"ref="messageSource"/></bean></beans>

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
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, and
windows_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.

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 based
ResourceBundleMessageSource
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.

5.14.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 time an
ApplicationEvent gets published to the
ApplicationContext, that bean is notified.
Essentially, this is the standard Observer design
pattern. Spring provides the following standard events:

Table 5.7. Built-in Events

Event

Explanation

ContextRefreshedEvent

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 beans are detected and activated, singletons are
pre-instantiated, and the
ApplicationContext object is ready
for use. As 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.

ContextStartedEvent

Published when the
ApplicationContext is started,
using the start() method on the
ConfigurableApplicationContext
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 components that
have not been configured for autostart , for example, components
that have not already started on initialization.

ContextStoppedEvent

Published when the
ApplicationContext is stopped,
using the stop() method on the
ConfigurableApplicationContext
interface. "Stopped" here means that all
Lifecycle beans receive an explicit
stop signal. A stopped context may be restarted through a
start() call.

ContextClosedEvent

Published when the
ApplicationContext is closed, using
the close() method on the
ConfigurableApplicationContext
interface. "Closed" here means that all singleton beans are
destroyed. A closed context reaches its end of life; it cannot be
refreshed or restarted.

RequestHandledEvent

A web-specific event telling all beans that an HTTP request
has been serviced. This event is published
after the request is 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:

To publish a custom ApplicationEvent, call the
publishEvent() method on an
ApplicationEventPublisher. Typically this
is done by creating a class that implements
ApplicationEventPublisherAware and
registering it as a Spring bean. The following example demonstrates such a
class:

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:

Notice that ApplicationListener is
generically parameterized with the type of your custom event,
BlackListEvent. This means that the
onApplicationEvent() 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 shows the bean definitions used to
register and configure each of the classes above:

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 the
BlackListEvent, 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.

5.14.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 6, 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
Resource properties 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.

You can create ApplicationContext
instances declaratively by using, for example, a
ContextLoader. Of course you can also create
ApplicationContext instances
programmatically by using one of the
ApplicationContext implementations.

You can register an ApplicationContext
using the ContextLoaderListener as follows:

The listener inspects the contextConfigLocation
parameter. If the parameter does not exist, the listener uses
/WEB-INF/applicationContext.xml as 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".

5.14.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 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's
TaskExecutor abstraction.

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.

5.15 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 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.

5.15.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 the BeanPostProcessor 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 5.8. 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:

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 BeanFactoryPostProcessors and
BeanPostProcessors. These mechanisms implement
important functionality such as property placeholder replacement and
AOP.

5.15.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, 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.

6. Resources

6.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.

6.2 The Resource interface

Spring's Resource interface is meant
to be a more capable interface for abstracting access to low-level
resources.

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.

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 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.

6.3 Built-in Resource implementations

There are a number of Resource
implementations that come supplied straight out of the box in
Spring:

6.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 a UrlResource.

6.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.

6.3.3 FileSystemResource

This is a Resource implementation
for java.io.File handles. It obviously supports
resolution as a File, and as a
URL.

6.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.

6.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.

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.

6.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.

6.4 The ResourceLoader

The ResourceLoader interface is meant
to be implemented by objects that can return (i.e. load)
Resource instances.

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 a
ClassPathXmlApplicationContext instance:

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.

On the other hand, you may also force
ClassPathResource to be used, regardless of the
application context type, by specifying the special
classpath: prefix:

When a class implements
ResourceLoaderAware and is deployed into an
application context (as a Spring-managed bean), it is recognized as
ResourceLoaderAware 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
Spring ApplicationContext 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 5.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, the
ResourceLoader 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 5.9.2, “@Autowired”.

6.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:

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).

6.7 Application contexts and Resource paths

6.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:

The bean definition will be loaded from a filesystem location, in
this case relative to the current working directory.

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...

... 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.

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...

Please do consult the Javadocs for the
ClassPathXmlApplicationContext class for
details of the various constructors.

6.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 regular expressions (matched using
Spring's PathMatcher 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.

... 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 a
Classloader.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 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.

The classpath*: prefix

When constructing an XML-based application context, a location
string may use the special classpath*:
prefix:

This special prefix specifies that all classpath resources that
match the given name must be obtained (internally, this essentially
happens via a ClassLoader.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 resolution
strategy described above is used for the wildcard subpath.

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.

6.7.3 FileSystemResource caveats

A FileSystemResource that is not attached
to a FileSystemApplicationContext (that is, a
FileSystemApplicationContext is not the actual
ResourceLoader) 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. The
FileSystemApplicationContext 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:

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.

7. Validation, Data Binding, and Type Conversion

7.1 Introduction

An application can choose to enable JSR-303 Bean Validation once globally,
as described in Section 7.8, “Spring 3 Validation”, and use it
exclusively for all validation needs.

An application can also register
additional Spring Validator instances
per DataBinder instance, as described in
Section 7.8.3, “Configuring a DataBinder”. This may be useful for
plugging in validation logic without the use of annotations.

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
validation package, 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 the
BeanWrapper directly. Because this is
reference documentation however, we felt that some explanation might be in
order. We will explain the BeanWrapper 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.

7.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.

As you can see, the staticrejectIfEmpty(..) 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 a
Customer 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 an
AddressValidator within your
CustomerValidator, and use it like so:

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.

7.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 the MessageCodesResolver 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 using rejectValue("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.

7.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 JavaBeans PropertyChangeListeners
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 the
DataBinder 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.

7.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 7.1. Examples of properties

Expression

Explanation

name

Indicates the property name
corresponding to the methods getName()
or isName() and
setName(..)

account.name

Indicates the nested property name of
the property account corresponding e.g. to
the methods getAccount().setName() or
getAccount().getName()

account[2]

Indicates the third element of the
indexed property account. Indexed properties
can be of type array, list
or other naturally ordered
collection

account[COMPANYNAME]

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 DataBinder and the
BeanFactory and their out-of-the-box
implementation, you should skip ahead to the section about
PropertyEditors.)

The following code snippets show some examples of how to retrieve
and manipulate some of the properties of instantiated
Companies and Employees:

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");

7.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 type
java.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 the
java.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.

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 the
org.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 7.2. Built-in PropertyEditors

Class

Explanation

ByteArrayPropertyEditor

Editor for byte arrays. Strings will simply be converted to
their corresponding byte representations. Registered by default
by BeanWrapperImpl.

ClassEditor

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.

CustomBooleanEditor

Customizable property editor for
Boolean properties. Registered by default
by BeanWrapperImpl, but, can be
overridden by registering custom instance of it as custom
editor.

CustomCollectionEditor

Property editor for Collections, converting any source
Collection to a given target
Collection type.

CustomDateEditor

Customizable property editor for java.util.Date, supporting
a custom DateFormat. NOT registered by default. Must be user
registered as needed with appropriate format.

CustomNumberEditor

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.

FileEditor

Capable of resolving Strings to
java.io.File objects. Registered by
default by BeanWrapperImpl.

InputStreamEditor

One-way property editor, capable of taking a text string
and producing (via an intermediate
ResourceEditor and
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.

LocaleEditor

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 converting Strings (formatted using the format
as defined in the Javadoc for the java.lang.Properties class) to
Properties objects. Registered by default
by BeanWrapperImpl.

StringTrimmerEditor

Property editor that trims Strings. Optionally allows
transforming an empty string into a null
value. NOT registered by default; must be user registered as
needed.

URLEditor

Capable of resolving a String representation of a URL to an
actual URL object. Registered by default
by BeanWrapperImpl.

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
PropertyEditor for
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 Foo class.

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 a PropertyEditor 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 called
CustomEditorConfigurer. Although bean factory
post-processors can be used with
BeanFactory implementations, the
CustomEditorConfigurer has 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 a BeanWrapper
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
PropertyEditor instances to an
ApplicationContext.

Consider a user class ExoticType, and
another class DependsOnExoticType which needs
ExoticType set as a property:

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(..):
PropertyEditorRegistrars added 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
PropertyEditorRegistrar
implementation:

package com.foo.editors.spring;
publicfinalclass CustomPropertyEditorRegistrar implements PropertyEditorRegistrar {
publicvoid 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...
}
}

See also the
org.springframework.beans.support.ResourceEditorRegistrar
for an example
PropertyEditorRegistrar
implementation. Notice how in its implementation of the
registerCustomEditors(..) method it creates
new instances of each property editor.

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, using
PropertyEditorRegistrars 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:

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.

7.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.

7.5.1 Converter SPI

The SPI to implement type conversion logic is simple and strongly
typed:

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:

7.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.

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.

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.
ConditionalGenericConverter is an subinterface of GenericConverter
that allows you to define such custom matching criteria:

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).

7.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:

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.

7.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 supplement 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.

7.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.

7.6.1 Formatter SPI

The Formatter SPI to implement field formatting logic is simple and
strongly typed:

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.

Parameterize A to be the field annotationType you wish to associate
formatting logic with, for example
org.springframework.format.annotation.DateTimeFormat. Have
getFieldTypes() return the types of fields the
annotation may be used on. Have getPrinter()
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:

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):

7.6.3 FormatterRegistry SPI

The FormatterRegistry is an SPI for registering formatters and
converters. FormattingConversionService is
an implementation of FormatterRegistry suitable for most environments.
This implementation may be configured programmatically or declaratively
as a Spring bean using
FormattingConversionServiceFactoryBean.
Because this implementation also implements
ConversionService, it can be directly
configured for use with Spring's DataBinder and the Spring Expression
Language (SpEL).

As shown above, Formatters can be registered by fieldType or
annotation.

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.

7.6.4 FormatterRegistrar SPI

The FormatterRegistrar is an SPI for registering formatters and
converters through the FormatterRegistry:

A FormatterRegistrar is useful when registering multiple related
converters and formatters for a given formatting category, such as Date
formatting. It can also be useful where declarative registration is
insufficient. For example when a formatter needs to be indexed under a
specific field type different from its own <T> or when registering
a Printer/Parser pair. The next section provides more information on
converter and formatter registration.

7.6.5 Configuring Formatting in Spring MVC

In a Spring MVC application, you may configure a custom
ConversionService instance explicitly 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.

With this one-line of configuration, 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 and then
specify custom converters, formatters, or FormatterRegistrars as properties
of the FormattingConversionServiceFactoryBean:

7.7 Configuring a global date & time format

By default, date and time fields that are not annotated with
@DateTimeFormat are converted from strings
using the the DateFormat.SHORT style. If you prefer,
you can change this by defining your own global format.

You will need to ensure that Spring does not register default
formatters, and instead you should register all formatters manually. Use the
org.springframework.format.datetime.joda.JodaTimeFormatterRegistrar
or org.springframework.format.datetime.DateFormatterRegistrar
class depending on whether you use the Joda Time library.

For example, the following Java configuration will register a global
'yyyyMMdd' format. This example does not depend on the
Joda Time library:

Joda Time provides separate distinct types to represent
date, time and
date-time values. The dateFormatter,
timeFormatter and dateTimeFormatter
properties of the JodaTimeFormatterRegistrar should
be used to configure the different formats for each type. The
DateTimeFormatterFactoryBean provides a
convenient way to create formatters.

If you are using Spring MVC remember to explicitly configure the
conversion service that is used. For Java based
@Configuration this means extending the
WebMvcConfigurationSupport class and overriding
the mvcConversionService() method. For XML you should
use the 'conversion-service' attribute of the
mvc:annotation-driven element. See
Section 7.6.5, “Configuring Formatting in Spring MVC” for details.

7.8 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 programmatically, Spring's DataBinder can now validate objects as
well as bind to them. Third, Spring MVC now has support for declaratively
validating @Controller inputs.

7.8.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:

publicclass PersonForm {
private String name;
privateint age;
}

JSR-303 allows you to define declarative validation constraints
against such properties:

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.

7.8.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:

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.

Injecting a Validator

LocalValidatorFactoryBean implements both
javax.validation.ValidatorFactory and
javax.validation.Validator, as well as Spring's
org.springframework.validation.Validator. You may inject
a reference to either of these interfaces into beans that need to
invoke validation logic.

Inject a reference to javax.validation.Validator if
you prefer to work with the JSR-303 API directly:

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:

As you can see, a ConstraintValidator implementation may have its
dependencies @Autowired like any other Spring bean.

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.

7.8.3 Configuring a DataBinder

Since Spring 3, a DataBinder instance can be configured with a
Validator. Once configured, the Validator may be invoked by calling
binder.validate(). Any validation Errors are automatically
added to the binder's BindingResult.

When working with the DataBinder programmatically, this can be used
to invoke validation logic after binding to a target object:

A DataBinder can also be configured with multiple
Validator instances
via dataBinder.addValidators
and dataBinder.replaceValidators.
This is useful when combining globally configured JSR-303 Bean Validation
with a Spring Validator configured
locally on a DataBinder instance.
See the section called “Configuring a Validator for use by Spring MVC”.

7.8.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.

Triggering @Controller Input Validation

To trigger validation of a @Controller input, simply annotate the
input argument as @Valid:

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.

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:

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:

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:

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 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.

8. Spring Expression Language (SpEL)

8.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.

8.2 Feature Overview

The expression language supports the following functionality

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

8.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'.

The SpEL classes and interfaces you are most likely to use are
located in the packages org.springframework.expression
and its sub packages and spel.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.

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.

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:

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.

8.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's Method,
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() and
registerFunction(). The use of variables and
functions are described in the language reference sections Variables and Functions. The
StandardEvaluationContext 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.

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// 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);

8.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> }.

8.4.1 XML based configuration

A property or constructor-arg value can be set using expressions
as shown below

8.5 Language Reference

8.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.

Numbers support the use of the negative sign, exponential
notation, and decimal points. By default real numbers are parsed using
Double.parseDouble().

8.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.

{} 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.

8.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.

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.

Logical operators

The logical operators that are supported are and, or, and not.
Their use is demonstrated below.

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.

8.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.

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.

8.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.

The Elvis operator can be used to apply default values in
expressions, e.g. in an @Value expression:

@Value("#{systemProperties['pop3.port'] ?: 25}")

This will inject a system property pop3.port if it
is defined or 25 if not.

8.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:

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
$[...].

8.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:

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.

8.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. The
ParserContext 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.

9. Aspect Oriented Programming with Spring

9.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.

9.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 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
interceptors around 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 IsModified
interface, 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 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 applied to a set of methods
spanning multiple objects (such as all business operations in the
service layer).

9.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 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.