3.2.10.RELEASE
Copyright © 2004-2013
Table of Contents
@RequestMapping
RedirectAttributes
@Valid
On
@RequestBody
Controller Method Arguments@RequestPart
Annotation On
Controller Method ArgumentsUriComponentsBuilder
and UriComponents
@ControllerAdvice
annotationResponseEntityExceptionHandler
classRestTemplate
and in
@RequestBody
arguments@RequestBody
improvements@DateTimeFormat
without
Joda Time@Component
and further stereotype
annotationsLoadTimeWeaver
ApplicationContext
Validator
interfaceBeanWrapper
Advice
types<tx:advice/>
settings@Transactional
@Transactional
with
AspectJSessionFactory
setup in a Spring
containerDispatcherServlet
@Controller
@RequestMapping
@RequestMapping
handler
methods@RequestParam
@ResponseBody
annotationHttpEntity<?>
@ModelAttribute
on a
method@ModelAttribute
on a
method argument@SessionAttributes
to store model
attributes in the HTTP session between requests"application/x-www-form-urlencoded"
dataWebDataBinder
initializationURI
sDispatcherPortlet
ViewRendererServlet
@Controller
@RequestMapping
@RequestParam
@ModelAttribute
@SessionAttributes
WebDataBinder
initializationAdvice
typescheckbox
tagcheckboxes
tagerrors
tagform
taghidden
taginput
taglabel
tagoption
tagoptions
tagpassword
tagradiobutton
tagradiobuttons
tagselect
tagtextarea
tagThe 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/.
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.
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.
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.
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.
The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and Transaction modules.
The JDBC module provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes.
The ORM module provides integration layers for popular object-relational mapping APIs, including JPA, JDO, Hibernate, and iBatis. Using the ORM package you can use all of these O/R-mapping frameworks in combination with all of the other features Spring offers, such as the simple declarative transaction management feature mentioned previously.
The OXM module provides an abstraction layer that supports Object/XML mapping implementations for JAXB, Castor, XMLBeans, JiBX and XStream.
The Java Messaging Service (JMS) module contains features for producing and consuming messages.
The Transaction module supports programmatic and declarative transaction management for classes that implement special interfaces and for all your POJOs (plain old Java objects).
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.
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.
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.
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.
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.
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.
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.
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.
Table 1.1. Comparison of Maven Central and SpringSource EBR Repositories
Feature | Maven Central | EBR |
---|---|---|
OSGi Compatible | Not explicit | Yes |
Number of Artifacts | Tens of thousands; all kinds | Hundreds; those that Spring integrates with |
Consistent Naming Conventions | No | Yes |
Naming Convention: GroupId | Varies. Newer artifacts often use domain name, e.g. org.slf4j. Older ones often just use the artifact name, e.g. log4j. | Domain name of origin or main package root, e.g. org.springframework |
Naming Convention: ArtifactId | Varies. Generally the project or module name, using a hyphen "-" separator, e.g. spring-core, logj4. | 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. | Manual (JIRA processed by SpringSource) |
Quality Assurance | By policy. Accuracy is responsibility of authors. | Extensive for OSGi manifest, Maven POM and Ivy metadata. QA performed by Spring team. |
Hosting | Contegix. Funded by Sonatype with several mirrors. | S3 funded by SpringSource. |
Search Utilities | Various | http://www.springsource.com/repository |
Integration with SpringSource Tools | Integration through STS with Maven dependency management | Extensive integration through STS with Maven, Roo, CloudFoundry |
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.
If you are using Maven for dependency management you don't even need to supply the logging dependency explicitly. For example, to create an application context and use dependency injection to configure an application, your Maven dependencies will look like this:
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.0.0.RELEASE</version> <scope>runtime</scope> </dependency> </dependencies>
That's it. Note the scope can be declared as runtime if you don't need to compile against Spring APIs, which is typically the case for basic dependency injection use cases.
We used the Maven Central naming conventions in the example above, so that works with Maven Central or the SpringSource S3 Maven repository. To use the S3 Maven repository (e.g. for milestones or developer snapshots), you need to specify the repository location in your Maven configuration. For full releases:
<repositories> <repository> <id>com.springsource.repository.maven.release</id> <url>http://repo.springsource.org/release/</url> <snapshots><enabled>false</enabled></snapshots> </repository> </repositories>
For milestones:
<repositories> <repository> <id>com.springsource.repository.maven.milestone</id> <url>http://repo.springsource.org/milestone/</url> <snapshots><enabled>false</enabled></snapshots> </repository> </repositories>
And for snapshots:
<repositories> <repository> <id>com.springsource.repository.maven.snapshot</id> <url>http://repo.springsource.org/snapshot/</url> <snapshots><enabled>true</enabled></snapshots> </repository> </repositories>
To use the SpringSource EBR you would need to use a different naming convention for the dependencies. The names are usually easy to guess, e.g. in this case it is:
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>org.springframework.context</artifactId> <version>3.0.0.RELEASE</version> <scope>runtime</scope> </dependency> </dependencies>
You also need to declare the location of the repository explicitly (only the URL is important):
<repositories> <repository> <id>com.springsource.repository.bundles.release</id> <url>http://repository.springsource.com/maven/bundles/release/</url> </repository> </repositories>
If you are managing your dependencies by hand, the URL in the repository declaration above is not 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.
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
:
<resolvers> <url name="com.springsource.repository.bundles.release"> <ivy pattern="http://repository.springsource.com/ivy/bundles/release/ [organisation]/[module]/[revision]/[artifact]-[revision].[ext]" /> <artifact pattern="http://repository.springsource.com/ivy/bundles/release/ [organisation]/[module]/[revision]/[artifact]-[revision].[ext]" /> </url> <url name="com.springsource.repository.bundles.external"> <ivy pattern="http://repository.springsource.com/ivy/bundles/external/ [organisation]/[module]/[revision]/[artifact]-[revision].[ext]" /> <artifact pattern="http://repository.springsource.com/ivy/bundles/external/ [organisation]/[module]/[revision]/[artifact]-[revision].[ext]" /> </url> </resolvers>
The XML above is not valid because the lines are too long - if you copy-paste then remove the extra line endings in the middle of the url patterns.
Once Ivy is configured to look in the EBR adding a dependency is
easy. Simply pull up the details page for the bundle in question in
the repository browser and you'll find an Ivy snippet ready for you to
include in your dependencies section. For example (in
ivy.xml
):
<dependency org="org.springframework" name="org.springframework.core" rev="3.0.0.RELEASE" conf="compile->runtime"/>
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.
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.
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.0.0.RELEASE</version> <scope>runtime</scope> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> </dependencies>
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.
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
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.0.0.RELEASE</version> <scope>runtime</scope> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>jcl-over-slf4j</artifactId> <version>1.5.8</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.5.8</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.5.8</version> <scope>runtime</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.14</version> <scope>runtime</scope> </dependency> </dependencies>
That might seem like a lot of dependencies just to get some
logging. Well it is, but it is optional, and it
should behave better than the vanilla commons-logging
with
respect to classloader issues, notably if you are in a strict container
like an OSGi platform. Allegedly there is also a performance benefit
because the bindings are at compile-time not runtime.
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.
Many people use Log4j as a logging framework for configuration and management purposes. It's efficient and well-established, and in fact it's what we use at runtime when we build and test Spring. Spring also provides some utilities for configuring and initializing Log4j, so it has an optional compile-time dependency on Log4j in some modules.
To make Log4j work with the default JCL dependency
(commons-logging
) all you need to do is put Log4j on the
classpath, and provide it with a configuration file
(log4j.properties
or log4j.xml
in the root
of the classpath). So for Maven users this is your dependency
declaration:
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.0.0.RELEASE</version> <scope>runtime</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.14</version> <scope>runtime</scope> </dependency> </dependencies>
And here's a sample log4j.properties for logging to the console:
log4j.rootCategory=INFO, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n log4j.category.org.springframework.beans.factory=DEBUG
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.
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.
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).
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.
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:
|
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
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
This is a list of new features for Spring Framework 3.0. We will cover these features in more detail later in this section.
Spring Expression Language
IoC enhancements/Java based bean metadata
General-purpose type conversion system and field formatting system
Object to XML mapping functionality (OXM) moved from Spring Web Services project
Comprehensive REST support
@MVC additions
Declarative model validation
Early support for Java EE 6
Embedded database support
BeanFactory interface returns typed bean instances as far as possible:
T getBean(Class<T> requiredType)
T getBean(String name, Class<T> requiredType)
Map<String, T> getBeansOfType(Class<T> type)
Spring's TaskExecutor interface now extends
java.util.concurrent.Executor
:
extended AsyncTaskExecutor supports standard Callables with Futures
New Java 5 based converter API and SPI:
stateless ConversionService and Converters
superseding standard JDK PropertyEditors
Typed ApplicationListener<E>
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
<bean class="mycompany.RewardsTestDatabase"> <property name="databaseName" value="#{systemProperties.databaseName}"/> <property name="keyGenerator" value="#{strategyBean.databaseKeyGenerator}"/> </bean>
This functionality is also available if you prefer to configure your components using annotations:
@Repository public class RewardsTestDatabase { @Value("#{systemProperties.databaseName}") public void setDatabaseName(String dbName) { … } @Value("#{strategyBean.databaseKeyGenerator}") public void setKeyGenerator(KeyGenerator kg) { … } }
Some core features from the JavaConfig project have been added to the Spring Framework now. This means that the following annotations are now directly supported:
@Configuration
@Bean
@DependsOn
@Primary
@Lazy
@Import
@ImportResource
@Value
Here is an example of a Java class providing basic configuration using the new JavaConfig features:
package org.example.config; @Configuration public class AppConfig { private @Value("#{jdbcProperties.url}") String jdbcUrl; private @Value("#{jdbcProperties.username}") String username; private @Value("#{jdbcProperties.password}") String password; @Bean public FooService fooService() { return new FooServiceImpl(fooRepository()); } @Bean public FooRepository fooRepository() { return new HibernateFooRepository(sessionFactory()); } @Bean public SessionFactory sessionFactory() { // wire up a session factory AnnotationSessionFactoryBean asFactoryBean = new AnnotationSessionFactoryBean(); asFactoryBean.setDataSource(dataSource()); // additional config return asFactoryBean.getObject(); } @Bean public DataSource dataSource() { return new DriverManagerDataSource(jdbcUrl, username, password); } }
To get this to work you need to add the following component scanning entry in your minimal application context XML file.
<context:component-scan base-package="org.example.config"/> <util:properties id="jdbcProperties" location="classpath:org/example/config/jdbc.properties"/>
Or you can bootstrap a @Configuration
class directly using
AnnotationConfigApplicationContext
:
public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); FooService fooService = ctx.getBean(FooService.class); fooService.doStuff(); }
See Section 5.12.2, “Instantiating the Spring container using
AnnotationConfigApplicationContext
” for full information on
AnnotationConfigApplicationContext
.
@Bean
annotated methods are also supported
inside Spring components. They contribute a factory bean definition to
the container. See Defining bean metadata within
components for more information
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.
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.
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.
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
HttpConverter
s to facilitate the
conversion between objects and their representation in HTTP requests
and responses.
The MarshallingHttpMessageConverter
uses
the Object to XML mapping functionality mentioned
earlier.
Refer to the sections on MVC and the RestTemplate for more information.
A mvc
namespace has been introduced that greatly simplifies Spring MVC configuration.
Additional annotations such as
@CookieValue
and
@RequestHeaders
have been added. See Mapping cookie values with the
@CookieValue annotation and Mapping request header attributes with
the @RequestHeader annotation for more information.
Several validation enhancements, including JSR 303 support that uses Hibernate Validator as the default provider.
We provide support for asynchronous method invocations through the use of the new @Async annotation (or EJB 3.1's @Asynchronous annotation).
JSR 303, JSF 2.0, JPA 2.0, etc
Convenient support for embedded Java database engines, including HSQL, H2, and Derby, is now provided.
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
Cache Abstraction (SpringSource team blog)
XML profiles (SpringSource Team Blog)
Introducing @Profile (SpringSource Team Blog)
See org.springframework.context.annotation.Configuration Javadoc
See org.springframework.context.annotation.Profile Javadoc
Environment Abstraction (SpringSource Team Blog)
See org.springframework.core.env.Environment Javadoc
Unified Property Management (SpringSource Team Blog)
See org.springframework.core.env.Environment Javadoc
See org.springframework.core.env.PropertySource Javadoc
See org.springframework.context.annotation.PropertySource Javadoc
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
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.
Spring 3.1 M2: Testing with @Configuration Classes and Profiles (SpringSource Team Blog)
See the section called “Context configuration with annotated classes”
and
org.springframework.test.context.ContextConfiguration
Javadoc
See
org.springframework.test.context.ActiveProfiles
Javadoc
See
org.springframework.test.context.SmartContextLoader
Javadoc
See
org.springframework.test.context.support.DelegatingSmartContextLoader
Javadoc
See
org.springframework.test.context.support.AnnotationConfigContextLoader
Javadoc
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'.
The new WebApplicationInitializer
builds atop Servlet 3.0's
ServletContainerInitializer
support to
provide a programmatic alternative to the traditional web.xml.
See org.springframework.web.WebApplicationInitializer Javadoc
Diff from Spring's
Greenhouse reference application demonstrating migration
from web.xml to
WebApplicationInitializer
See org.springframework.web.multipart.support.StandardServletMultipartResolver Javadoc
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.
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.
See the section called “New Support Classes for @RequestMapping
methods in Spring MVC 3.1” for additional
details and a list of features not available with the new support classes.
Improved support for specifying media types consumed by a method
through the 'Content-Type'
header as well as for
producible types specified through the 'Accept'
header. See the section called “Consumable Media Types” and the section called “Producible Media Types”
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.
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.
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.
This new annotation provides access to the content of a "multipart/form-data" request part. See Section 17.10.5, “Handling a file upload request from programmatic clients” and Section 17.10, “Spring's multipart (file upload) support”.
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.
A ServletUriComponentsBuilder
sub-class
provides static factory methods to copy information from
a Servlet request. See Section 17.7, “Building URI
s”.
This section covers what's new in Spring Framework 3.2. See also Appendix D, Migrating to Spring Framework 3.2
The Spring MVC programming model now provides explicit Servlet 3
async support. @RequestMapping
methods can
return one of:
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.
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”.
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.
ContentNegotiationManager
is the central
class to use when configuring content negotiation options.
For more details see Section 17.15.4, “Configuring Content Negotiation”.
The introduction of ContentNegotiationManger
also enables selective suffix pattern matching for incoming requests.
For more details, see the Javadoc of
RequestMappingHandlerMapping.setUseRegisteredSuffixPatternMatch.
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.
A new @MatrixVariable
annotation adds
support for extracting matrix variables from the request URI. For more
details see the section called “Matrix Variables”.
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”.
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.
See the revised Section 17.11, “Handling exceptions” including information on customizing the default Servlet container error page.
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
.
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.
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
.
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.
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.
Mapped interceptors now support URL patterns to be excluded. The MVC namespace and the MVC JavaConfig both expose these options.
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.
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.
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
.
It is now possible to define global formats that will be used when parsing and printing date and time types. See Section 7.7, “Configuring a global date & time format” for details.
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.
Configuring and loading a WebApplicationContext in integration tests
Configuring context hierarchies in integration tests
Testing request and session scoped beans
Improvements to Servlet API mocks
Configuring test application contexts with ApplicationContextInitializers
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.
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.
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).
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.
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.
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.
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:
Annotation-based configuration: Spring 2.5 introduced support for annotation-based configuration metadata.
Java-based configuration:
Starting with Spring 3.0, many features provided by the Spring JavaConfig
project became part of the core Spring Framework. Thus you
can define beans external to your application classes by using Java
rather than XML files. To use these new features, see the
@Configuration
, @Bean,
@Import
and
@DependsOn
annotations.
Spring configuration consists of at least one and typically more
than one bean definition that the container must manage. XML-based
configuration metadata shows these beans configured as
<bean/>
elements inside a top-level
<beans/>
element.
These bean definitions correspond to the actual objects that make up
your application. Typically you define service layer objects, data
access objects (DAOs), presentation objects such as Struts
Action
instances, infrastructure objects
such as Hibernate SessionFactories
, JMS
Queues
, and so forth. Typically one does
not configure fine-grained domain objects in the container, because it
is usually the responsibility of DAOs and business logic to create and
load domain objects. However, you can use Spring's integration with
AspectJ to configure objects that have been created outside the control
of an IoC container. See Using
AspectJ to dependency-inject domain objects with Spring.
The following example shows the basic structure of XML-based configuration metadata:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="..." class="..."> <!-- collaborators and configuration for this bean go here --> </bean> <bean id="..." class="..."> <!-- collaborators and configuration for this bean go here --> </bean> <!-- more bean definitions go here --> </beans>
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.
Instantiating a Spring IoC container is straightforward. The
location path or paths supplied to an
ApplicationContext
constructor are
actually resource strings that allow the container to load configuration
metadata from a variety of external resources such as the local file
system, from the Java CLASSPATH
, and so on.
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});
Note | |
---|---|
After you learn about Spring's IoC container, you may want to know
more about Spring's |
The following example shows the service layer objects
(services.xml)
configuration file:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- services --> <bean id="petStore" class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl"> <property name="accountDao" ref="accountDao"/> <property name="itemDao" ref="itemDao"/> <!-- additional collaborators and configuration for this bean go here --> </bean> <!-- more bean definitions for services go here --> </beans>
The following example shows the data access objects
daos.xml
file:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="accountDao" class="org.springframework.samples.jpetstore.dao.ibatis.SqlMapAccountDao"> <!-- additional collaborators and configuration for this bean go here --> </bean> <bean id="itemDao" class="org.springframework.samples.jpetstore.dao.ibatis.SqlMapItemDao"> <!-- additional collaborators and configuration for this bean go here --> </bean> <!-- more bean definitions for data access objects go here --> </beans>
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.
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:
<beans> <import resource="services.xml"/> <import resource="resources/messageSource.xml"/> <import resource="/resources/themeSource.xml"/> <bean id="bean1" class="..."/> <bean id="bean2" class="..."/> </beans>
In the preceding example, external bean definitions are loaded
from three files, services.xml
,
messageSource.xml
, and
themeSource.xml
. All location paths are relative to
the definition file doing the importing, so
services.xml
must be in the same directory or
classpath location as the file doing the importing, while
messageSource.xml
and
themeSource.xml
must be in a
resources
location below the location of the
importing file. As you can see, a leading slash is ignored, but given
that these paths are relative, it is better form not to use the slash
at all. The contents of the files being imported, including the top
level <beans/>
element, must be valid XML
bean definitions according to the Spring Schema or DTD.
Note | |
---|---|
It is possible, but not recommended, to reference files in parent directories using a relative "../" path. Doing so creates a dependency on a file that is outside the current application. In particular, this reference is not recommended for "classpath:" URLs (for example, "classpath:../services.xml"), where the runtime resolution process chooses the "nearest" classpath root and then looks into its parent directory. Classpath configuration changes may lead to the choice of a different, incorrect directory. You can always use fully qualified resource locations instead of relative paths: for example, "file:C:/config/services.xml" or "classpath:/config/services.xml". However, be aware that you are coupling your application's configuration to specific absolute locations. It is generally preferable to keep an indirection for such absolute locations, for example, through "${...}" placeholders that are resolved against JVM system properties at runtime. |
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:
// create and configure beans ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"}); // retrieve configured instance PetStoreServiceImpl service = context.getBean("petStore", PetStoreServiceImpl.class); // use configured instance List userList = service.getUsernameList();
You use getBean()
to retrieve instances of
your beans. The ApplicationContext
interface has a few other methods for retrieving beans, but ideally your
application code should never use them. Indeed, your application code
should have no calls to the getBean()
method at
all, and thus no dependency on Spring APIs at all. For example, Spring's
integration with web frameworks provides for dependency injection for
various web framework classes such as controllers and JSF-managed
beans.
A Spring IoC container manages one or more beans.
These beans are created with the configuration metadata that you supply to
the container, for example, in the form of XML
<bean/>
definitions.
Within the container itself, these bean definitions are represented as
BeanDefinition
objects, which contain
(among other information) the following metadata:
A package-qualified class name: typically the actual implementation class of the bean being defined.
Bean behavioral configuration elements, which state how the bean should behave in the container (scope, lifecycle callbacks, and so forth).
References to other beans that are needed for the bean to do its work; these references are also called collaborators or dependencies.
Other configuration settings to set in the newly created object, for example, the number of connections to use in a bean that manages a connection pool, or the size limit of the pool.
This metadata translates to a set of properties that make up each bean definition.
Table 5.1. The bean definition
Property | Explained in... |
---|---|
class | |
name | |
scope | |
constructor arguments | |
properties | |
autowiring mode | |
lazy-initialization mode | |
initialization method | |
destruction method |
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.
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.
In a bean definition itself, you can supply more than one name for
the bean, by using a combination of up to one name specified by the
id
attribute, and any number of other names in the
name
attribute. These names can be equivalent
aliases to the same bean, and are useful for some situations, such as
allowing each component in an application to refer to a common
dependency by using a bean name that is specific to that component
itself.
Specifying all aliases where the bean is actually defined is not
always adequate, however. It is sometimes desirable to introduce an
alias for a bean that is defined elsewhere. This is commonly the case
in large systems where configuration is split amongst each subsystem,
each subsystem having its own set of object definitions. In XML-based
configuration metadata, you can use the
<alias/>
element to accomplish this.
<alias name="fromName" alias="toName"/>
In this case, a bean in the same container which is named
fromName
, may also after the use of this alias
definition, be referred to as toName
.
For example, the configuration metadata for subsystem A may refer to a DataSource via the name 'subsystemA-dataSource. The configuration metadata for subsystem B may refer to a DataSource via the name 'subsystemB-dataSource'. When composing the main application that uses both these subsystems the main application refers to the DataSource via the name 'myApp-dataSource'. To have all three names refer to the same object you add to the MyApp configuration metadata the following aliases definitions:
<alias name="subsystemA-dataSource" alias="subsystemB-dataSource"/> <alias name="subsystemA-dataSource" alias="myApp-dataSource" />
Now each component and the main application can refer to the dataSource through a name that is unique and guaranteed not to clash with any other definition (effectively creating a namespace), yet they refer to the same bean.
A bean definition essentially is a recipe for creating one or more objects. The container looks at the recipe for a named bean when asked, and uses the configuration metadata encapsulated by that bean definition to create (or acquire) an actual object.
If you use XML-based configuration metadata, you specify the type
(or class) of object that is to be instantiated in the
class
attribute of the
<bean/>
element. This class
attribute, which internally is a Class
property
on a BeanDefinition
instance, is usually
mandatory. (For exceptions, see the section called “Instantiation using an instance factory method” and Section 5.7, “Bean definition inheritance”.) You use the
Class
property in one of two ways:
Typically, to specify the bean class to be constructed in the
case where the container itself directly creates the bean by calling
its constructor reflectively, somewhat equivalent to Java code using
the new
operator.
To specify the actual class containing the
static
factory method that will be invoked to
create the object, in the less common case where the container
invokes a static
, factory
method on a class to create the bean. The object type returned from
the invocation of the static
factory method may
be the same class or another class entirely.
When you create a bean by the constructor approach, all normal classes are usable by and compatible with Spring. That is, the class being developed does not need to implement any specific interfaces or to be coded in a specific fashion. Simply specifying the bean class should suffice. However, depending on what type of IoC you use for that specific bean, you may need a default (empty) constructor.
The Spring IoC container can manage virtually any class you want it to manage; it is not limited to managing true JavaBeans. Most Spring users prefer actual JavaBeans with only a default (no-argument) constructor and appropriate setters and getters modeled after the properties in the container. You can also have more exotic non-bean-style classes in your container. If, for example, you need to use a legacy connection pool that absolutely does not adhere to the JavaBean specification, Spring can manage it as well.
With XML-based configuration metadata you can specify your bean class as follows:
<bean id="exampleBean" class="examples.ExampleBean"/> <bean name="anotherExample" class="examples.ExampleBeanTwo"/>
For details about the mechanism for supplying arguments to the constructor (if required) and setting object instance properties after the object is constructed, see Injecting Dependencies.
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.
<bean id="clientService" class="examples.ClientService" factory-method="createInstance"/>
public class ClientService { private static ClientService clientService = new ClientService(); private ClientService() {} public static ClientService createInstance() { return clientService; } }
For details about the mechanism for supplying (optional) arguments to the factory method and setting object instance properties after the object is returned from the factory, see Dependencies and configuration in detail.
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() --> <bean id="serviceLocator" class="examples.DefaultServiceLocator"> <!-- inject any dependencies required by this locator bean --> </bean> <!-- the bean to be created via the factory bean --> <bean id="clientService" factory-bean="serviceLocator" factory-method="createClientServiceInstance"/>
public class DefaultServiceLocator { private static ClientService clientService = new ClientServiceImpl(); private DefaultServiceLocator() {} public ClientService createClientServiceInstance() { return clientService; } }
One factory class can also hold more than one factory method as shown here:
<bean id="serviceLocator" class="examples.DefaultServiceLocator"> <!-- inject any dependencies required by this locator bean --> </bean> <bean id="clientService" factory-bean="serviceLocator" factory-method="createClientServiceInstance"/> <bean id="accountService" factory-bean="serviceLocator" factory-method="createAccountServiceInstance"/>
public class DefaultServiceLocator { private static ClientService clientService = new ClientServiceImpl(); private static AccountService accountService = new AccountServiceImpl(); private DefaultServiceLocator() {} public ClientService createClientServiceInstance() { return clientService; } public AccountService createAccountServiceInstance() { return accountService; } }
This approach shows that the factory bean itself can be managed and configured through dependency injection (DI). See Dependencies and configuration in detail.
Note | |
---|---|
In Spring documentation, factory bean
refers to a bean that is configured in the Spring container that
will create objects through an instance or static
factory method. By contrast,
|
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.
Dependency injection (DI) is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control (IoC), of the bean itself controlling the instantiation or location of its dependencies on its own by using direct construction of classes, or the Service Locator pattern.
Code is cleaner with the DI principle and decoupling is more effective when objects are provided with their dependencies. The object does not look up its dependencies, and does not know the location or class of the dependencies. As such, your classes become easier to test, in particular when the dependencies are on interfaces or abstract base classes, which allow for stub or mock implementations to be used in unit tests.
DI exists in two major variants, Constructor-based dependency injection and Setter-based dependency injection.
Constructor-based DI is accomplished by the
container invoking a constructor with a number of arguments, each
representing a dependency. Calling a static
factory
method with specific arguments to construct the bean is nearly
equivalent, and this discussion treats arguments to a constructor and to
a static
factory method similarly. The following
example shows a class that can only be dependency-injected with
constructor injection. Notice that there is nothing
special about this class, it is a POJO that has no
dependencies on container specific interfaces, base classes or
annotations.
public class SimpleMovieLister { // the SimpleMovieLister has a dependency on a MovieFinder private MovieFinder movieFinder; // a constructor so that the Spring container can 'inject' a MovieFinder public SimpleMovieLister(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // business logic that actually 'uses' the injected MovieFinder is omitted... }
Constructor argument resolution matching occurs using the argument's type. If no potential ambiguity exists in the constructor arguments of a bean definition, then the order in which the constructor arguments are defined in a bean definition is the order in which those arguments are supplied to the appropriate constructor when the bean is being instantiated. Consider the following class:
package x.y; public class Foo { public Foo(Bar bar, Baz baz) { // ... } }
No potential ambiguity exists, assuming that
Bar
and Baz
classes are
not related by inheritance. Thus the following configuration works
fine, and you do not need to specify the constructor argument indexes
and/or types explicitly in the
<constructor-arg/>
element.
<beans> <bean id="foo" class="x.y.Foo"> <constructor-arg ref="bar"/> <constructor-arg ref="baz"/> </bean> <bean id="bar" class="x.y.Bar"/> <bean id="baz" class="x.y.Baz"/> </beans>
When another bean is referenced, the type is known, and matching
can occur (as was the case with the preceding example). When a simple
type is used, such as
<value>true<value>
, Spring cannot
determine the type of the value, and so cannot match by type without
help. Consider the following class:
package examples; public class ExampleBean { // No. of years to the calculate the Ultimate Answer private int years; // The Answer to Life, the Universe, and Everything private String ultimateAnswer; public ExampleBean(int years, String ultimateAnswer) { this.years = years; this.ultimateAnswer = ultimateAnswer; } }
In the preceding scenario, the container
can use type matching with simple types if you
explicitly specify the type of the constructor argument using the
type
attribute. For example:
<bean id="exampleBean" class="examples.ExampleBean"> <constructor-arg type="int" value="7500000"/> <constructor-arg type="java.lang.String" value="42"/> </bean>
Use the index
attribute to specify explicitly
the index of constructor arguments. For example:
<bean id="exampleBean" class="examples.ExampleBean"> <constructor-arg index="0" value="7500000"/> <constructor-arg index="1" value="42"/> </bean>
In addition to resolving the ambiguity of multiple simple values, specifying an index resolves ambiguity where a constructor has two arguments of the same type. Note that the index is 0 based.
As of Spring 3.0 you can also use the constructor parameter name for value disambiguation:
<bean id="exampleBean" class="examples.ExampleBean"> <constructor-arg name="years" value="7500000"/> <constructor-arg name="ultimateanswer" value="42"/> </bean>
Keep in mind that to make this work out of the box your code
must be compiled with the debug flag enabled so that Spring can
look up the parameter name from the constructor. If you can't compile
your code with debug flag (or don't want to) you can use
@ConstructorProperties
JDK annotation to explicitly name your constructor arguments. The
sample class would then have to look as follows:
package examples; public class ExampleBean { // Fields omitted @ConstructorProperties({"years", "ultimateAnswer"}) public ExampleBean(int years, String ultimateAnswer) { this.years = years; this.ultimateAnswer = ultimateAnswer; } }
Setter-based DI is accomplished by the
container calling setter methods on your beans after invoking a
no-argument constructor or no-argument static
factory
method to instantiate your bean.
The following example shows a class that can only be dependency-injected using pure setter injection. This class is conventional Java. It is a POJO that has no dependencies on container specific interfaces, base classes or annotations.
public class SimpleMovieLister { // the SimpleMovieLister has a dependency on the MovieFinder private MovieFinder movieFinder; // a setter method so that the Spring container can 'inject' a MovieFinder public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // business logic that actually 'uses' the injected MovieFinder is omitted... }
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.
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.
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.
The following example uses XML-based configuration metadata for setter-based DI. A small part of a Spring XML configuration file specifies some bean definitions:
<bean id="exampleBean" class="examples.ExampleBean"> <!-- setter injection using the nested <ref/> element --> <property name="beanOne"><ref bean="anotherExampleBean"/></property> <!-- setter injection using the neater 'ref' attribute --> <property name="beanTwo" ref="yetAnotherBean"/> <property name="integerProperty" value="1"/> </bean> <bean id="anotherExampleBean" class="examples.AnotherBean"/> <bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean { private AnotherBean beanOne; private YetAnotherBean beanTwo; private int i; public void setBeanOne(AnotherBean beanOne) { this.beanOne = beanOne; } public void setBeanTwo(YetAnotherBean beanTwo) { this.beanTwo = beanTwo; } public void setIntegerProperty(int i) { this.i = i; } }
In the preceding example, setters are declared to match against the properties specified in the XML file. The following example uses constructor-based DI:
<bean id="exampleBean" class="examples.ExampleBean"> <!-- constructor injection using the nested <ref/> element --> <constructor-arg> <ref bean="anotherExampleBean"/> </constructor-arg> <!-- constructor injection using the neater 'ref' attribute --> <constructor-arg ref="yetAnotherBean"/> <constructor-arg type="int" value="1"/> </bean> <bean id="anotherExampleBean" class="examples.AnotherBean"/> <bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean { private AnotherBean beanOne; private YetAnotherBean beanTwo; private int i; public ExampleBean( AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) { this.beanOne = anotherBean; this.beanTwo = yetAnotherBean; this.i = i; } }
The constructor arguments specified in the bean definition will be
used as arguments to the constructor of the
ExampleBean
.
Now consider a variant of this example, where instead of using a
constructor, Spring is told to call a static
factory
method to return an instance of the object:
<bean id="exampleBean" class="examples.ExampleBean" factory-method="createInstance"> <constructor-arg ref="anotherExampleBean"/> <constructor-arg ref="yetAnotherBean"/> <constructor-arg value="1"/> </bean> <bean id="anotherExampleBean" class="examples.AnotherBean"/> <bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
public class ExampleBean { // a private constructor private ExampleBean(...) { ... } // a static factory method; the arguments to this method can be // considered the dependencies of the bean that is returned, // regardless of how those arguments are actually used. public static ExampleBean createInstance ( AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) { ExampleBean eb = new ExampleBean (...); // some other operations... return eb; } }
Arguments to the static
factory method are
supplied via <constructor-arg/>
elements,
exactly the same as if a constructor had actually been used. The type of
the class being returned by the factory method does not have to be of
the same type as the class that contains the static
factory method, although in this example it is. An instance (non-static)
factory method would be used in an essentially identical fashion (aside
from the use of the factory-bean
attribute instead of
the class
attribute), so details will not be
discussed here.
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.
The value
attribute of the
<property/>
element specifies a property or
constructor argument as a human-readable string representation. As mentioned previously,
JavaBeans PropertyEditors
are used to convert these
string values from a String
to the actual type of
the property or argument.
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <!-- results in a setDriverClassName(String) call --> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mydb"/> <property name="username" value="root"/> <property name="password" value="masterkaoli"/> </bean>
The following example uses the p-namespace for even more succinct XML configuration.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" p:driverClassName="com.mysql.jdbc.Driver" p:url="jdbc:mysql://localhost:3306/mydb" p:username="root" p:password="masterkaoli"/> </beans>
The preceding XML is more succinct; however, typos are discovered at runtime rather than design time, unless you use an IDE such as IntelliJ IDEA or the SpringSource Tool Suite (STS) that support automatic property completion when you create bean definitions. Such IDE assistance is highly recommended.
You can also configure a java.util.Properties
instance as:
<bean id="mappings" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <!-- typed as a java.util.Properties --> <property name="properties"> <value> jdbc.driver.className=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mydb </value> </property> </bean>
The Spring container converts the text inside the
<value/>
element into a
java.util.Properties
instance by using the
JavaBeans 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 is simply an error-proof way
to pass the id (string value - not a reference)
of another bean in the container to a
<constructor-arg/>
or
<property/>
element.
<bean id="theTargetBean" class="..."/> <bean id="theClientBean" class="..."> <property name="targetName"> <idref bean="theTargetBean" /> </property> </bean>
The above bean definition snippet is exactly equivalent (at runtime) to the following snippet:
<bean id="theTargetBean" class="..." /> <bean id="client" class="..."> <property name="targetName" value="theTargetBean" /> </bean>
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.
<property name="targetName"> <!-- a bean with id 'theTargetBean' must exist; otherwise an exception will be thrown --> <idref local="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.
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.
<ref bean="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.
<ref local="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 --> <bean id="accountService" class="com.foo.SimpleAccountService"> <!-- insert dependencies as required as here --> </bean>
<!-- in the child (descendant) context --> <bean id="accountService" <-- bean name is the same as the parent bean --> class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target"> <ref parent="accountService"/> <!-- notice how we refer to the parent bean --> </property> <!-- insert other configuration and dependencies as required here --> </bean>
A <bean/>
element inside the
<property/>
or
<constructor-arg/>
elements defines a so-called
inner bean.
<bean id="outer" class="..."> <!-- instead of using a reference to a target bean, simply define the target bean inline --> <property name="target"> <bean class="com.example.Person"> <!-- this is the inner bean --> <property name="name" value="Fiona Apple"/> <property name="age" value="25"/> </bean> </property> </bean>
An inner bean definition does not require a defined id or name; the
container ignores these values. It also ignores the
scope
flag. Inner beans 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.
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.
<bean id="moreComplexObject" class="example.ComplexObject"> <!-- results in a setAdminEmails(java.util.Properties) call --> <property name="adminEmails"> <props> <prop key="administrator">administrator@example.org</prop> <prop key="support">support@example.org</prop> <prop key="development">development@example.org</prop> </props> </property> <!-- results in a setSomeList(java.util.List) call --> <property name="someList"> <list> <value>a list element followed by a reference</value> <ref bean="myDataSource" /> </list> </property> <!-- results in a setSomeMap(java.util.Map) call --> <property name="someMap"> <map> <entry key="an entry" value="just some string"/> <entry key ="a ref" value-ref="myDataSource"/> </map> </property> <!-- results in a setSomeSet(java.util.Set) call --> <property name="someSet"> <set> <value>just some string</value> <ref bean="myDataSource" /> </set> </property> </bean>
The value of a map key or value, or a set value, can also again be any of the following elements:
bean | ref | idref | list | set | map | props | value | null
As of Spring 2.0, the container supports the
merging of collections. An application developer
can define a parent-style <list/>
,
<map/>
, <set/>
or
<props/>
element, and have child-style
<list/>
, <map/>
,
<set/>
or <props/>
elements inherit and override values from the parent collection. That
is, the child collection's values are the result of merging the
elements of the parent and child collections, with the child's
collection elements overriding values specified in the parent
collection.
This section on merging discusses the parent-child bean mechanism. Readers unfamiliar with parent and child bean definitions may wish to read the relevant section before continuing.
The following example demonstrates collection merging:
<beans> <bean id="parent" abstract="true" class="example.ComplexObject"> <property name="adminEmails"> <props> <prop key="administrator">administrator@example.com</prop> <prop key="support">support@example.com</prop> </props> </property> </bean> <bean id="child" parent="parent"> <property name="adminEmails"> <!-- the merge is specified on the *child* collection definition --> <props merge="true"> <prop key="sales">sales@example.com</prop> <prop key="support">support@example.co.uk</prop> </props> </property> </bean> <beans>
Notice the use of the merge=true
attribute on
the <props/>
element of the
adminEmails
property of the
child
bean definition. When the
child
bean is resolved and instantiated by the
container, the resulting instance has an
adminEmails
Properties
collection that contains the result of the merging of the child's
adminEmails
collection with the parent's
adminEmails
collection.
administrator=administrator@example.com sales=sales@example.com support=support@example.co.uk
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.
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.
In Java 5 and later, you can use strongly typed collections (using
generic types). That is, it is possible to declare a
Collection
type such that it can only
contain String
elements (for example). If you
are using Spring to dependency-inject a strongly-typed
Collection
into a bean, you can take
advantage of Spring's type-conversion support such that the elements
of your strongly-typed Collection
instances are converted to the appropriate type prior to being added
to the Collection
.
public class Foo { private Map<String, Float> accounts; public void setAccounts(Map<String, Float> accounts) { this.accounts = accounts; } }
<beans> <bean id="foo" class="x.y.Foo"> <property name="accounts"> <map> <entry key="one" value="9.99"/> <entry key="two" value="2.75"/> <entry key="six" value="3.99"/> </map> </property> </bean> </beans>
When the accounts
property of the
foo
bean is prepared for injection, the generics
information about the element type of the strongly-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.
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 ("")
<bean class="ExampleBean"> <property name="email" value=""/> </bean>
The preceding example is equivalent to the following Java code:
exampleBean.setEmail("")
. The
<null/>
element handles null
values. For example:
<bean class="ExampleBean"> <property name="email"><null/></property> </bean>
The above configuration is equivalent to the following Java code:
exampleBean.setEmail(null)
.
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.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean name="classic" class="com.example.ExampleBean"> <property name="email" value="foo@bar.com"/> </bean> <bean name="p-namespace" class="com.example.ExampleBean" p:email="foo@bar.com"/> </beans>
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:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean name="john-classic" class="com.example.Person"> <property name="name" value="John Doe"/> <property name="spouse" ref="jane"/> </bean> <bean name="john-modern" class="com.example.Person" p:name="John Doe" p:spouse-ref="jane"/> <bean name="jane" class="com.example.Person"> <property name="name" value="Jane Doe"/> </bean> </beans>
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 |
Similar to the the section called “XML shortcut with the p-namespace”, the c-namespace, newly introduced in Spring 3.1,
allows usage of inlined attributes for configuring the constructor arguments rather then nested constructor-arg
elements.
Let's review the examples from the section called “Constructor-based dependency injection” with the c
namespace:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="bar" class="x.y.Bar"/> <bean id="baz" class="x.y.Baz"/> <-- 'traditional' declaration --> <bean id="foo" class="x.y.Foo"> <constructor-arg ref="bar"/> <constructor-arg ref="baz"/> <constructor-arg value="foo@bar.com"/> </bean> <-- 'c-namespace' declaration --> <bean id="foo" class="x.y.Foo" c:bar-ref="bar" c:baz-ref="baz" c:email="foo@bar.com"> </beans>
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:
<-- 'c-namespace' index declaration --> <bean id="foo" class="x.y.Foo" c:_0-ref="bar" c:_1-ref="baz">
Note | |
---|---|
Due to the XML grammar, the index notation requires the presence of the leading _ as XML attribute names cannot start with a number (even though some IDE allow it). |
In practice, the constructor resolution mechanism is quite efficient in matching arguments so unless one really needs to, we recommend using the name notation through-out your configuration.
You can use compound or nested property names when you set bean
properties, as long as all components of the path except the final
property name are not null
. Consider the following
bean definition.
<bean id="foo" class="foo.Bar"> <property name="fred.bob.sammy" value="123" /> </bean>
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.
If a bean is a dependency of another that usually means that one bean
is set as a property of another. Typically you accomplish this with the
<ref/>
element in XML-based configuration metadata. However, sometimes
dependencies between beans are less direct; for example, a static
initializer in a class needs to be triggered, such as database driver
registration. The depends-on
attribute can explicitly
force one or more beans to be initialized before the bean using this
element is initialized. The following example uses the
depends-on
attribute to express a dependency on a
single bean:
<bean id="beanOne" class="ExampleBean" depends-on="manager"/> <bean id="manager" class="ManagerBean" />
To express a dependency on multiple beans, supply a list of bean names
as the value of the depends-on
attribute, with commas,
whitespace and semicolons, used as valid delimiters:
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao"> <property name="manager" ref="manager" /> </bean> <bean id="manager" class="ManagerBean" /> <bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />
Note | |
---|---|
The |
By default, ApplicationContext
implementations eagerly create and configure all singleton beans as part of
the initialization process. Generally, this pre-instantiation is
desirable, because errors in the configuration or surrounding environment
are discovered immediately, as opposed to hours or even days later. When
this behavior is not desirable, you can prevent
pre-instantiation of a singleton bean by marking the bean definition as
lazy-initialized. A lazy-initialized bean tells the IoC container to
create a bean instance when it is first requested, rather than at
startup.
In XML, this behavior is controlled by the
lazy-init
attribute on the
<bean/>
element; for example:
<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/> <bean name="not.lazy" class="com.foo.AnotherBean"/>
When the preceding configuration is consumed by an
ApplicationContext
, the bean named
lazy
is not eagerly pre-instantiated when 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:
<beans default-lazy-init="true"> <!-- no beans will be pre-instantiated... --> </beans>
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 |
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 |
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.
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
.
If you are using Java 5 or later, implement the more fine-grained control available with annotation-based configuration, as described in Section 5.9, “Annotation-based container configuration”.
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.
In most application scenarios, most beans in the container are singletons. When a singleton bean needs to collaborate with another singleton bean, or a non-singleton bean needs to collaborate with another non-singleton bean, you typically handle the dependency by defining one bean as a property of the other. A problem arises when the bean lifecycles are different. Suppose singleton bean A needs to use non-singleton (prototype) bean B, perhaps on each method invocation on A. The container only creates the singleton bean A once, and thus only gets one opportunity to set the properties. The container cannot provide bean A with a new instance of bean B every time one is needed.
A solution is to forego some inversion of control. You can make bean A aware of the container by
implementing the ApplicationContextAware
interface, and by making a
getBean("B") call to the container ask for (a typically new) bean B
instance every time bean A needs it. The following is an example of this
approach:
// a class that uses a stateful Command-style class to perform some processing package fiona.apple; // Spring-API imports import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; public class CommandManager implements ApplicationContextAware { private ApplicationContext applicationContext; public Object process(Map commandState) { // grab a new instance of the appropriate Command Command command = createCommand(); // set the state on the (hopefully brand new) Command instance command.setState(commandState); return command.execute(); } protected Command createCommand() { // notice the Spring API dependency! return this.applicationContext.getBean("command", Command.class); } public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } }
The preceding is not desirable, because the business code is aware of and coupled to the Spring Framework. Method Injection, a somewhat advanced feature of the Spring IoC container, allows this use case to be handled in a clean fashion.
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 |
Looking at the CommandManager
class in the
previous code snippet, you see that the Spring container will
dynamically override the implementation of the
createCommand()
method. Your
CommandManager
class will not have any Spring
dependencies, as can be seen in the reworked example:
package fiona.apple; // no more Spring imports! public abstract class CommandManager { public Object process(Object commandState) { // grab a new instance of the appropriate Command interface Command command = createCommand(); // set the state on the (hopefully brand new) Command instance command.setState(commandState); return command.execute(); } // okay... but where is the implementation of this method? protected abstract Command createCommand(); }
In the client class containing the method to be injected (the
CommandManager
in this case), the method to be
injected requires a signature of the following form:
<public|protected> [abstract] <return-type> theMethodName(no-arguments);
If the method is abstract
, the
dynamically-generated subclass implements the method. Otherwise, the
dynamically-generated subclass overrides the concrete method defined in
the original class. For example:
<!-- a stateful bean deployed as a prototype (non-singleton) --> <bean id="command" class="fiona.apple.AsyncCommand" scope="prototype"> <!-- inject dependencies here as required --> </bean> <!-- commandProcessor uses statefulCommandHelper --> <bean id="commandManager" class="fiona.apple.CommandManager"> <lookup-method name="createCommand" bean="command"/> </bean>
The bean identified as commandManager calls its
own method createCommand()
whenever it needs a
new instance of the command bean. You must be
careful to deploy the command
bean as a prototype, if
that is actually what is needed. If it is deployed as a singleton, the same
instance of the command
bean is returned each
time.
Tip | |
---|---|
The interested reader may also find the
|
A less useful form of method injection than lookup method Injection is the ability to replace arbitrary methods in a managed bean with another method implementation. Users may safely skip the rest of this section until the functionality is actually needed.
With XML-based configuration metadata, you can use the
replaced-method
element to replace an existing method
implementation with another, for a deployed bean. Consider the following
class, with a method computeValue, which we want to override:
public class MyValueCalculator { public String computeValue(String input) { // some real code... } // some other methods... }
A class implementing the
org.springframework.beans.factory.support.MethodReplacer
interface provides the new method definition.
/** meant to be used to override the existing computeValue(String) implementation in MyValueCalculator */ public class ReplacementComputeValue implements MethodReplacer { public Object reimplement(Object o, Method m, Object[] args) throws Throwable { // get the input value, work with it, and return a computed result String input = (String) args[0]; ... return ...; } }
The bean definition to deploy the original class and specify the method override would look like this:
<bean id="myValueCalculator" class="x.y.z.MyValueCalculator"> <!-- arbitrary method replacement --> <replaced-method name="computeValue" replacer="replacementComputeValue"> <arg-type>String</arg-type> </replaced-method> </bean> <bean id="replacementComputeValue" class="a.b.c.ReplacementComputeValue"/>
You can use one or more contained
<arg-type/>
elements within the
<replaced-method/>
element to indicate the
method signature of the method being overridden. The signature for the
arguments is necessary only if the method is overloaded and multiple
variants exist within the class. For convenience, the type string for an
argument may be a substring of the fully qualified type name. For
example, the following all 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.
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.
Table 5.3. Bean scopes
Scope | Description |
---|---|
(Default) Scopes a single bean definition to a single object instance per Spring IoC container. | |
Scopes a single bean definition to any number of object instances. | |
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
| |
Scopes a single bean definition to the lifecycle of an
HTTP | |
Scopes a single bean definition to the lifecycle of a
global HTTP |
Thread-scoped beans | |
---|---|
As of Spring 3.0, a thread scope is available, but is not registered by default. For more information, see the documentation for SimpleThreadScope. For instructions on how to register this or any other custom scope, see the section called “Using a custom 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:
<bean id="accountService" class="com.foo.DefaultAccountService"/> <!-- the following is equivalent, though redundant (singleton scope is the default) --> <bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>
The non-singleton, prototype scope of bean deployment results in the
creation of a new bean instance every time a request
for that specific bean is made. That is, the bean is injected into another
bean or you request it through a getBean()
method call
on the container. As a rule, use the prototype scope for all stateful
beans and the singleton scope for stateless beans.
The following diagram illustrates the Spring prototype scope. A data access object (DAO) is not typically configured as a prototype, because a typical DAO does not hold any conversational state; it was just easier for this author to reuse the core of the singleton diagram.
The following example defines a bean as a prototype in XML:
<!-- using spring-beans-2.0.dtd --> <bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>
In contrast to the other scopes, Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, and otherwise assembles a prototype object, and hands it to the client, with no further record of that prototype instance. Thus, although 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”.)
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”
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.
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:
<web-app> ... <listener> <listener-class> org.springframework.web.context.request.RequestContextListener </listener-class> </listener> ... </web-app>
If you use an older web container (Servlet 2.3), use the provided
javax.servlet.Filter
implementation. The
following snippet of XML configuration must be included in the
web.xml
file of your web application if you want to
access web-scoped beans in requests outside of Spring's
DispatcherServlet on a Servlet 2.3 container. (The filter mapping
depends on the surrounding web application configuration, so you must
change it as appropriate.)
<web-app> .. <filter> <filter-name>requestContextFilter</filter-name> <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class> </filter> <filter-mapping> <filter-name>requestContextFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ... </web-app>
DispatcherServlet
,
RequestContextListener
and
RequestContextFilter
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.
Consider the following bean definition:
<bean id="loginAction" class="com.foo.LoginAction" scope="request"/>
The Spring container creates a new instance of the
LoginAction
bean by using the
loginAction
bean definition for each and every HTTP
request. That is, the loginAction
bean is scoped at
the HTTP request level. You can change the internal state of the
instance that is created as much as you want, because other instances
created from the same loginAction
bean definition
will not see these changes in state; they are particular to an
individual request. When the request completes processing, the bean that
is scoped to the request is discarded.
Consider the following bean definition:
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
The Spring container creates a new instance of the
UserPreferences
bean by using the
userPreferences
bean definition for the lifetime of a
single HTTP Session
. In other words, the
userPreferences
bean is effectively scoped at the
HTTP Session
level. As with
request-scoped
beans, you can change the internal
state of the instance that is created as much as you want, knowing that
other HTTP Session
instances that are
also using instances created from the same
userPreferences
bean definition do not see these
changes in state, because 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.
Consider the following bean definition:
<bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>
The global session
scope is similar to the
standard HTTP Session
scope (described above), and
applies only in the context of portlet-based web applications. The
portlet specification defines the notion of a global
Session
that is shared among all portlets
that make up a single portlet web application. Beans defined at the
global session
scope are scoped (or bound) to the
lifetime of the global portlet
Session
.
If you write a standard Servlet-based web application and you define
one or more beans as having global session
scope, the
standard HTTP Session
scope is used, and
no error is raised.
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
|
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"?> <beans xmlns="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 --> <bean id="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 --> <bean id="userService" class="com.foo.SimpleUserService"> <!-- a reference to the proxied userPreferences bean --> <property name="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.)
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/> <bean id="userManager" class="com.foo.UserManager"> <property name="userPreferences" ref="userPreferences"/> </bean>
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 a UserPreferences
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:
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">
<aop:scoped-proxy/>
</bean>
<bean id="userManager" class="com.foo.UserManager">
<property name="userPreferences" ref="userPreferences"/>
</bean>
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.
<!-- DefaultUserPreferences implements the UserPreferences interface -->
<bean id="userPreferences" class="com.foo.DefaultUserPreferences" scope="session">
<aop:scoped-proxy proxy-target-class="false"
/>
</bean>
<bean id="userManager" class="com.foo.UserManager">
<property name="userPreferences" ref="userPreferences"/>
</bean>
For more detailed information about choosing class-based or interface-based proxying, see Section 9.6, “Proxying mechanisms”.
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.
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.
void registerDestructionCallback(String name, Runnable destructionCallback)
The following method obtains the conversation identifier for the underlying scope. This identifier is different for each scope. For a session scoped implementation, this identifier can be the session identifier.
String getConversationId()
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 |
Scope threadScope = new SimpleThreadScope(); beanFactory.registerScope("thread", threadScope);
You then create bean definitions that adhere to the scoping rules of
your custom Scope
:
<bean id="..." class="..." scope="thread">
With a custom Scope
implementation,
you are not limited to programmatic registration of the scope. You can
also do the Scope
registration
declaratively, using the CustomScopeConfigurer
class:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="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"> <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer"> <property name="scopes"> <map> <entry key="thread"> <bean class="org.springframework.context.support.SimpleThreadScope"/> </entry> </map> </property> </bean> <bean id="bar" class="x.y.Bar" scope="thread"> <property name="name" value="Rick"/> <aop:scoped-proxy/> </bean> <bean id="foo" class="x.y.Foo"> <property name="bar" ref="bar"/> </bean> </beans>
Note | |
---|---|
When you place <aop:scoped-proxy/> in a
|
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 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.
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:
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>
public class ExampleBean { public void init() { // do some initialization work } }
...is exactly the same as...
<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>
public class AnotherExampleBean implements InitializingBean { public void afterPropertiesSet() { // do some initialization work } }
... but does not couple the code to Spring.
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:
<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>
public class ExampleBean { public void cleanup() { // do some destruction work (like releasing pooled connections) } }
...is exactly the same as...
<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>
public class AnotherExampleBean implements DisposableBean { public void destroy() { // do some destruction work (like releasing pooled connections) } }
... but does not couple the code to Spring.
When you write initialization and destroy method callbacks that do
not use the Spring-specific
InitializingBean
and
DisposableBean
callback interfaces, you
typically write methods with names such as init()
,
initialize()
, dispose()
, and so
on. Ideally, the names of such lifecycle callback methods are
standardized across a project so that all developers use the same method
names and ensure consistency.
You can configure the Spring container to look
for named initialization and destroy callback method names on
every bean. This means that you, as an application
developer, can write your application classes and use an initialization
callback called init()
, without having to configure
an init-method="init"
attribute with each bean
definition. The Spring IoC container calls that method when the bean is
created (and in accordance with the standard lifecycle callback contract
described previously). This feature also enforces a consistent naming
convention for initialization and destroy method callbacks.
Suppose that your initialization callback methods are named
init()
and destroy callback methods are named
destroy()
. Your class will resemble the class in the
following example.
public class DefaultBlogService implements BlogService { private BlogDao blogDao; public void setBlogDao(BlogDao blogDao) { this.blogDao = blogDao; } // this is (unsurprisingly) the initialization callback method public void init() { if (this.blogDao == null) { throw new IllegalStateException("The [blogDao] property must be set."); } } }
<beans default-init-method="init"> <bean id="blogService" class="com.foo.DefaultBlogService"> <property name="blogDao" ref="blogDao" /> </bean> </beans>
The presence of the default-init-method
attribute
on the top-level <beans/>
element attribute
causes the Spring IoC container to recognize a method called
init
on beans as the initialization method callback.
When a bean is created and assembled, if the bean class has such a
method, it is invoked at the appropriate time.
You configure destroy method callbacks similarly (in XML, that is)
by using the default-destroy-method
attribute on the
top-level <beans/>
element.
Where existing bean classes already have callback methods that are
named at variance with the convention, you can override the default by
specifying (in XML, that is) the method name using the
init-method
and destroy-method
attributes of the <bean/> itself.
The Spring container guarantees that a configured initialization callback is called immediately after a bean is supplied with all dependencies. Thus the initialization callback is called on the raw bean reference, which means that AOP interceptors and so forth are not yet applied to the bean. A target bean is fully created first, then an AOP proxy (for example) with its interceptor chain is applied. If the target bean and the proxy are defined separately, your code can even interact with the raw target bean, bypassing the proxy. Hence, it would be inconsistent to apply the interceptors to the init method, because doing so would couple the lifecycle of the target bean with its proxy/interceptors and leave strange semantics when your code interacts directly to the raw target bean.
As of Spring 2.5, you have three options for controlling bean
lifecycle behavior: the InitializingBean
and DisposableBean
callback
interfaces; custom init()
and
destroy()
methods; and the @PostConstruct
and
@PreDestroy
annotations. You can
combine these mechanisms to control a given bean.
Note | |
---|---|
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,
|
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
The Lifecycle
interface defines the
essential methods for any object that has its own lifecycle requirements
(e.g. starts and stops some background process):
public interface Lifecycle { void start(); void stop(); boolean isRunning(); }
Any Spring-managed object may implement that interface. Then, when
the ApplicationContext itself starts and stops, it will cascade those
calls to all Lifecycle implementations defined within that context. It
does this by delegating to a
LifecycleProcessor
:
public interface LifecycleProcessor extends Lifecycle { void onRefresh(); void onClose(); }
Notice that the LifecycleProcessor
is
itself an extension of the Lifecycle
interface. It also adds two other methods for reacting to the context
being refreshed and closed.
The order of startup and shutdown invocations can be important. If a
"depends-on" relationship exists between any two objects, the dependent
side will start after its dependency, and it will
stop before its dependency. However, at times the
direct dependencies are unknown. You may only know that objects of a
certain type should start prior to objects of another type. In those
cases, the SmartLifecycle
interface
defines another option, namely the getPhase()
method as defined on its super-interface,
Phased
.
public interface Phased { int getPhase(); } public interface SmartLifecycle extends Lifecycle, Phased { boolean isAutoStartup(); void stop(Runnable callback); }
When starting, the objects with the lowest phase start first, and
when stopping, the reverse order is followed. Therefore, an object that
implements SmartLifecycle
and whose
getPhase() method returns Integer.MIN_VALUE
would be
among the first to start and the last to stop. At the other end of the
spectrum, a phase value of Integer.MAX_VALUE
would
indicate that the object should be started last and stopped first
(likely because it depends on other processes to be running). When
considering the phase value, it's also important to know that the
default phase for any "normal" 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:
<bean id="lifecycleProcessor" class="org.springframework.context.support.DefaultLifecycleProcessor"> <!-- timeout value in milliseconds --> <property name="timeoutPerShutdownPhase" value="10000"/> </bean>
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.
Note | |
---|---|
This section applies only to non-web applications. Spring's
web-based |
If you are using Spring's IoC container in a non-web application environment; for example, in a rich client desktop environment; you register a shutdown hook with the JVM. Doing so ensures a graceful shutdown and calls the relevant destroy methods on your singleton beans so that all resources are released. Of course, you must still configure and implement these destroy callbacks correctly.
To register a shutdown hook, you call the
registerShutdownHook()
method that is declared
on the AbstractApplicationContext
class:
import org.springframework.context.support.AbstractApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public final class Boot { public static void main(final String[] args) throws Exception { AbstractApplicationContext ctx = new ClassPathXmlApplicationContext(new String []{"beans.xml"}); // add a shutdown hook for the above context... ctx.registerShutdownHook(); // app runs here... // main method exits, hook is called prior to the app shutting down... } }
When an ApplicationContext
creates a
class that implements the
org.springframework.context.ApplicationContextAware
interface, the class is provided with a reference to that
ApplicationContext
.
public interface ApplicationContextAware { void setApplicationContext(ApplicationContext applicationContext) throws BeansException; }
Thus beans can manipulate programmatically the
ApplicationContext
that created them,
through the ApplicationContext
interface,
or by casting the reference to a known subclass of this interface, such as
ConfigurableApplicationContext
, which exposes
additional functionality. One use would be the programmatic retrieval of
other beans. Sometimes this capability is useful; however, in general you
should avoid it, because it couples the code to Spring and does not follow
the Inversion of Control style, where collaborators are provided to beans
as properties. Other 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.
public interface BeanNameAware { void setBeanName(string name) throws BeansException; }
The callback is invoked after population of normal bean properties but
before an initialization callback such as
InitializingBean
s
afterPropertiesSet or a custom init-method.
Besides ApplicationContextAware
and
BeanNameAware
discussed above, Spring
offers a range of
Aware
interfaces that
allow beans to indicate to the container that they require a certain
infrastructure dependency. The most important
Aware
interfaces are summarized below - as
a general rule, the name is a good indication of the dependency
type:
Table 5.4. Aware
interfaces
Name | Injected Dependency | Explained in... |
---|---|---|
| Declaring
| |
| Event publisher of the enclosing
| Section 5.14, “Additional Capabilities of the
|
| Class loader used to load the bean classes. | |
| Declaring
| |
| Name of the declaring bean | |
| Resource adapter
| |
| Defined weaver for processing class definition at load time | Section 9.8.4, “Load-time weaving with AspectJ in the Spring Framework” |
| Configured strategy for resolving messages (with support for parametrization and internationalization) | Section 5.14, “Additional Capabilities of the
|
| Spring JMX notification publisher | |
| Current | |
| Current | |
| Configured loader for low-level access to resources | |
| Current | |
| Current |
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.
A bean definition can contain a lot of configuration information, including constructor arguments, property values, and container-specific information such as initialization method, static factory method name, and so on. A child bean definition inherits configuration data from a parent definition. The child definition can override some values, or add others, as needed. Using parent and child bean definitions can save a lot of typing. Effectively, this is a form of templating.
If you work with an ApplicationContext
interface programmatically, child bean definitions are represented by the
ChildBeanDefinition
class. Most users do not work
with them on this level, instead configuring bean definitions
declaratively in something like the
ClassPathXmlApplicationContext
. When you use
XML-based configuration metadata, you indicate a child bean definition by
using the parent
attribute, specifying the parent bean
as the value of this attribute.
<bean id="inheritedTestBean" abstract="true" class="org.springframework.beans.TestBean"> <property name="name" value="parent"/> <property name="age" value="1"/> </bean> <bean id="inheritsWithDifferentClass" class="org.springframework.beans.DerivedTestBean" parent="inheritedTestBean" init-method="initialize"> <property name="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.
A child bean definition inherits constructor argument values, property
values, and method overrides from the parent, with the option to add new
values. Any initialization method, destroy method, and/or
static
factory method settings that you specify will
override the corresponding parent settings.
The remaining settings are always taken from the child definition: depends on, autowire mode, dependency check, singleton, scope, lazy init.
The preceding example explicitly marks the parent bean definition as
abstract by using the abstract
attribute. If the parent
definition does not specify a class, explicitly marking the parent bean
definition as abstract
is required, as follows:
<bean id="inheritedTestBeanWithoutClass" abstract="true"> <property name="name" value="parent"/> <property name="age" value="1"/> </bean> <bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean" parent="inheritedTestBeanWithoutClass" init-method="initialize"> <property name="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 | |
---|---|
|
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.
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
BeanPostProcessor
s 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 | |
---|---|
To change the actual bean definition (i.e., the
blueprint that defines the bean), you instead need to use a
|
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 ApplicationContext
automatically 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 |
BeanPostProcessors and AOP
auto-proxying | |
---|---|
Classes that implement the
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 |
The following examples show how to write, register, and use
BeanPostProcessors
in an
ApplicationContext
.
This first example illustrates basic usage. The example shows a
custom BeanPostProcessor
implementation
that invokes the toString()
method of each bean
as it is created by the container and prints the resulting string to the
system console.
Find below the custom
BeanPostProcessor
implementation class
definition:
package scripting; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.BeansException; public class InstantiationTracingBeanPostProcessor implements BeanPostProcessor { // simply return the instantiated bean as-is public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; // we could potentially return any object reference here... } public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("Bean '" + beanName + "' created : " + bean.toString()); return bean; } }
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:lang="http://www.springframework.org/schema/lang" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"> <lang:groovy id="messenger" script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy"> <lang:property name="message" value="Fiona Apple Is Just So Dreamy."/> </lang:groovy> <!-- when the above bean (messenger) is instantiated, this custom BeanPostProcessor implementation will output the fact to the system console --> <bean class="scripting.InstantiationTracingBeanPostProcessor"/> </beans>
Notice how the
InstantiationTracingBeanPostProcessor
is simply
defined. It does not even have a name, and because it is a bean it can
be dependency-injected just like any other bean. (The preceding
configuration also defines a bean that is backed by a Groovy script. The
Spring 2.0 dynamic language support is detailed in the chapter entitled
Chapter 28, Dynamic language support.)
The following simple Java application executes the preceding code and configuration:
import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.scripting.Messenger; public final class Boot { public static void main(final String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("scripting/beans.xml"); Messenger messenger = (Messenger) ctx.getBean("messenger"); System.out.println(messenger); } }
The output of the preceding application resembles the following:
Bean 'messenger' created : org.springframework.scripting.groovy.GroovyMessenger@272961 org.springframework.scripting.groovy.GroovyMessenger@272961
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: BeanFactoryPostProcessor
s 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 Also, |
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 |
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.
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations" value="classpath:com/foo/jdbc.properties"/> </bean> <bean id="dataSource" destroy-method="close" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean>
The actual values come from another file in the standard Java
Properties
format:
jdbc.driverClassName=org.hsqldb.jdbcDriver jdbc.url=jdbc:hsqldb:hsql://production:9002 jdbc.username=sa jdbc.password=root
Therefore, the string ${jdbc.username}
is replaced
at runtime with the value 'sa', and 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.
<context:property-placeholder location="classpath:com/foo/jdbc.properties"/>
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
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <value>classpath:com/foo/strategy.properties</value> </property> <property name="properties"> <value>custom.strategy.class=com.foo.DefaultStrategy</value> </property> </bean> <bean id="serviceStrategy" class="${custom.strategy.class}"/> If the class cannot be resolved at runtime to a valid class,
resolution of the bean fails when it is about to be created, which is
during the |
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.
Properties file configuration lines take this format:
beanName.property=value
For example:
dataSource.driverClassName=com.mysql.jdbc.Driver dataSource.url=jdbc:mysql:mydb
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-override location="classpath:override.properties"/>
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.
boolean isSingleton()
: returns
true
if this
FactoryBean
returns singletons,
false
otherwise.
Class getObjectType()
: returns the object
type returned by the getObject()
method or
null
if the type is not known in advance.
The FactoryBean
concept and interface
is used in a number of places within the Spring Framework; more than 50
implementations of 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.
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):
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
(The implicitly registered post-processors include AutowiredAnnotationBeanPostProcessor
, CommonAnnotationBeanPostProcessor
, PersistenceAnnotationBeanPostProcessor
, as
well as the aforementioned RequiredAnnotationBeanPostProcessor
.)
Note | |
---|---|
|
The @Required
annotation applies to
bean property setter methods, as in the following example:
public class SimpleMovieLister { private MovieFinder movieFinder; @Required public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
This annotation simply indicates that the affected bean property must
be populated at configuration time, through an explicit property value in
a bean definition or through autowiring. The container throws an exception
if the affected bean property has not been populated; this allows for
eager and explicit failure, avoiding
NullPointerException
s 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.
As expected, you can apply the
@Autowired
annotation to "traditional"
setter methods:
public class SimpleMovieLister { private MovieFinder movieFinder; @Autowired public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
Note | |
---|---|
JSR 330's @Inject annotation can be used in place of Spring's
|
You can also apply the annotation to methods with arbitrary names and/or multiple arguments:
public class MovieRecommender { private MovieCatalog movieCatalog; private CustomerPreferenceDao customerPreferenceDao; @Autowired public void prepare(MovieCatalog movieCatalog, CustomerPreferenceDao customerPreferenceDao) { this.movieCatalog = movieCatalog; this.customerPreferenceDao = customerPreferenceDao; } // ... }
You can apply @Autowired
to
constructors and fields:
public class MovieRecommender { @Autowired private MovieCatalog movieCatalog; private CustomerPreferenceDao customerPreferenceDao; @Autowired public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) { this.customerPreferenceDao = customerPreferenceDao; } // ... }
It is also possible to provide all beans of a
particular type from the ApplicationContext
by adding the annotation to a field or method that expects an array of
that type:
public class MovieRecommender { @Autowired private MovieCatalog[] movieCatalogs; // ... }
The same applies for typed collections:
public class MovieRecommender { private Set<MovieCatalog> movieCatalogs; @Autowired public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) { this.movieCatalogs = movieCatalogs; } // ... }
Even typed Maps can be autowired as long as the expected key type is
String
. The Map values will contain all beans of
the expected type, and the keys will contain the corresponding bean
names:
public class MovieRecommender { private Map<String, MovieCatalog> movieCatalogs; @Autowired public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) { this.movieCatalogs = movieCatalogs; } // ... }
By default, the autowiring fails whenever zero candidate beans are available; the default behavior is to treat annotated methods, constructors, and fields as indicating required dependencies. This behavior can be changed as demonstrated below.
public class SimpleMovieLister { private MovieFinder movieFinder; @Autowired(required=false) public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
Note | |
---|---|
Only one annotated constructor per-class can be marked as required, but multiple non-required constructors can be annotated. In that case, each is considered among the candidates and Spring uses the greediest constructor whose dependencies can be satisfied, that is the constructor that has the largest number of arguments.
|
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.
public class MovieRecommender { @Autowired private ApplicationContext context; public MovieRecommender() { } // ... }
Note | |
---|---|
|
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:
public class MovieRecommender { @Autowired @Qualifier("main") private MovieCatalog movieCatalog; // ... }
The @Qualifier
annotation can also be
specified on individual constructor arguments or method parameters:
public class MovieRecommender { private MovieCatalog movieCatalog; private CustomerPreferenceDao customerPreferenceDao; @Autowired public void prepare(@Qualifier("main") MovieCatalog movieCatalog, CustomerPreferenceDao customerPreferenceDao) { this.movieCatalog = movieCatalog; this.customerPreferenceDao = customerPreferenceDao; } // ... }
The corresponding bean definitions appear as follows. The bean with qualifier value "main" is wired with the constructor argument that is qualified with the same value.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <bean class="example.SimpleMovieCatalog"> <qualifier value="main"/> <!-- inject any dependencies required by this bean --> </bean> <bean class="example.SimpleMovieCatalog"> <qualifier value="action"/> <!-- inject any dependencies required by this bean --> </bean> <bean id="movieRecommender" class="example.MovieRecommender"/> </beans>
For a fallback match, the bean name is considered a default qualifier
value. Thus you can define the bean with an id "main" instead of the
nested qualifier element, leading to the same matching result. However,
although you can use this convention to refer to specific beans by name,
@Autowired
is fundamentally about
type-driven injection with optional semantic qualifiers. This means that
qualifier values, even with the bean name fallback, always have narrowing
semantics within the set of type matches; they do not semantically express
a reference to a unique bean id. Good qualifier values are "main" or
"EMEA" or "persistent", expressing characteristics of a specific component
that are independent from the bean id, which may be auto-generated in case
of an anonymous bean definition like the one in the preceding
example.
Qualifiers also apply to typed collections, as discussed above, for
example, to Set<MovieCatalog>
. In this case, all
matching beans according to the declared qualifiers are injected as a
collection. This implies that qualifiers do not have to be unique; they
rather simply constitute filtering criteria. For example, you can define
multiple MovieCatalog
beans with the same qualifier
value "action"; all of which would be injected into a
Set<MovieCatalog>
annotated with
@Qualifier("action")
.
Tip | |
---|---|
If you intend to express annotation-driven injection by name, do not
primarily use As a specific consequence of this semantic difference, beans that
are themselves defined as a collection or map type cannot be injected
through
|
You can create your own custom qualifier annotations. Simply define an
annotation and provide the @Qualifier
annotation within your definition:
@Target({ElementType.FIELD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Qualifier public @interface Genre { String value(); }
Then you can provide the custom qualifier on autowired fields and parameters:
public class MovieRecommender { @Autowired @Genre("Action") private MovieCatalog actionCatalog; private MovieCatalog comedyCatalog; @Autowired public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog) { this.comedyCatalog = comedyCatalog; } // ... }
Next, provide the information for the candidate bean definitions. You
can add <qualifier/>
tags as sub-elements of the
<bean/>
tag and then specify the
type
and value
to match your custom
qualifier annotations. The type is matched against the fully-qualified
class name of the annotation. Or, as a convenience if no risk of
conflicting names exists, you can use the short class name. Both
approaches are demonstrated in the following example.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <bean class="example.SimpleMovieCatalog"> <qualifier type="Genre" value="Action"/> <!-- inject any dependencies required by this bean --> </bean> <bean class="example.SimpleMovieCatalog"> <qualifier type="example.Genre" value="Comedy"/> <!-- inject any dependencies required by this bean --> </bean> <bean id="movieRecommender" class="example.MovieRecommender"/> </beans>
In Section 5.10, “Classpath scanning and managed components”, you will see an annotation-based alternative to providing the qualifier metadata in XML. Specifically, see Section 5.10.7, “Providing qualifier metadata with annotations”.
In some cases, it may be sufficient to use an annotation without a value. This may be useful when the annotation serves a more generic purpose and can be applied across several different types of dependencies. For example, you may provide an offline catalog that would be searched when no Internet connection is available. First define the simple annotation:
@Target({ElementType.FIELD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Qualifier public @interface Offline { }
Then add the annotation to the field or property to be autowired:
public class MovieRecommender { @Autowired @Offline private MovieCatalog offlineCatalog; // ... }
Now the bean definition only needs a qualifier
type
:
<bean class="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:
@Target({ElementType.FIELD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Qualifier public @interface MovieQualifier { String genre(); Format format(); }
In this case Format
is an enum:
public enum Format {
VHS, DVD, BLURAY
}
The fields to be autowired are annotated with the custom qualifier and
include values for both attributes: genre
and
format
.
public class MovieRecommender { @Autowired @MovieQualifier(format=Format.VHS, genre="Action") private MovieCatalog actionVhsCatalog; @Autowired @MovieQualifier(format=Format.VHS, genre="Comedy") private MovieCatalog comedyVhsCatalog; @Autowired @MovieQualifier(format=Format.DVD, genre="Action") private MovieCatalog actionDvdCatalog; @Autowired @MovieQualifier(format=Format.BLURAY, genre="Comedy") private MovieCatalog comedyBluRayCatalog; // ... }
Finally, the bean definitions should contain matching qualifier
values. This example also demonstrates that bean meta
attributes may be used instead of the
<qualifier/>
sub-elements. If available, the
<qualifier/>
and its attributes take precedence,
but the autowiring mechanism falls back on the values provided within the
<meta/>
tags if no such qualifier is present, as
in the last two bean definitions in the following example.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <bean class="example.SimpleMovieCatalog"> <qualifier type="MovieQualifier"> <attribute key="format" value="VHS"/> <attribute key="genre" value="Action"/> </qualifier> <!-- inject any dependencies required by this bean --> </bean> <bean class="example.SimpleMovieCatalog"> <qualifier type="MovieQualifier"> <attribute key="format" value="VHS"/> <attribute key="genre" value="Comedy"/> </qualifier> <!-- inject any dependencies required by this bean --> </bean> <bean class="example.SimpleMovieCatalog"> <meta key="format" value="DVD"/> <meta key="genre" value="Action"/> <!-- inject any dependencies required by this bean --> </bean> <bean class="example.SimpleMovieCatalog"> <meta key="format" value="BLURAY"/> <meta key="genre" value="Comedy"/> <!-- inject any dependencies required by this bean --> </bean> </beans>
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.
<bean id="customAutowireConfigurer" class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer"> <property name="customQualifierTypes"> <set> <value>example.CustomQualifier</value> </set> </property> </bean>
The particular implementation of
AutowireCandidateResolver
that is activated
for the application context depends on the Java version. In versions
earlier than Java 5, the qualifier annotations are not supported, and
therefore autowire candidates are solely determined by the
autowire-candidate
value of each bean definition as
well as by any default-autowire-candidates
pattern(s)
available on the <beans/>
element. In Java 5 or
later, the presence of @Qualifier
annotations and any custom annotations registered with the
CustomAutowireConfigurer
will also play a
role.
Regardless of the Java version, when multiple beans qualify as
autowire candidates, the determination of a "primary" candidate is the
same: if exactly one bean definition among the candidates has a
primary
attribute set to true
, it
will be selected.
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:
public class SimpleMovieLister { private MovieFinder movieFinder; @Resource(name="myMovieFinder") public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } }
If no name is specified explicitly, the default name is derived from the field name or setter method. In case of a field, it takes the field name; in case of a setter method, it takes the bean property name. So the following example is going to have the bean with name "movieFinder" injected into its setter method:
public class SimpleMovieLister { private MovieFinder movieFinder; @Resource public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } }
Note | |
---|---|
The name provided with the annotation is resolved as a bean name by
the |
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
.
public class MovieRecommender { @Resource private CustomerPreferenceDao customerPreferenceDao; @Resource private ApplicationContext context; public MovieRecommender() { } // ... }
The CommonAnnotationBeanPostProcessor
not only
recognizes the @Resource
annotation but
also the JSR-250 lifecycle annotations. Introduced in
Spring 2.5, the support for these annotations offers yet another
alternative to those described in initialization
callbacks and destruction
callbacks. Provided that the
CommonAnnotationBeanPostProcessor
is registered
within the Spring ApplicationContext
, a
method carrying one of these annotations is invoked at the same point in
the lifecycle as the corresponding Spring lifecycle interface method or
explicitly declared callback method. In the example below, the cache will
be pre-populated upon initialization and cleared upon destruction.
public class CachingMovieLister { @PostConstruct public void populateMovieCache() { // populates the movie cache upon initialization... } @PreDestroy public void clearMovieCache() { // clears the movie cache upon destruction... } }
Note | |
---|---|
For details about the effects of combining various lifecycle mechanisms, see the section called “Combining lifecycle mechanisms”. |
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 |
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.
Spring can automatically detect stereotyped classes and register
corresponding BeanDefinition
s with the
ApplicationContext
. For example, the
following two classes are eligible for such autodetection:
@Service public class SimpleMovieLister { private MovieFinder movieFinder; @Autowired public SimpleMovieLister(MovieFinder movieFinder) { this.movieFinder = movieFinder; } }
@Repository public class JpaMovieFinder implements MovieFinder { // implementation elided for clarity }
To autodetect these classes and register the corresponding beans, you need to include the following element in XML, where the base-package element is a common parent package for the two classes. (Alternatively, you can specify a comma-separated list that includes the parent package of each class.)
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="org.example"/> </beans>
Tip | |
---|---|
The use of |
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
|
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.
<beans> <context:component-scan base-package="org.example"> <context:include-filter type="regex" expression=".*Stub.*Repository"/> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/> </context:component-scan> </beans>
Note | |
---|---|
You can also disable the default filters by providing
use-default-filters="false" as an attribute of the
<component-scan/> element. This will in effect disable automatic
detection of classes annotated with
|
Spring components can also contribute bean definition metadata to the
container. You do this with the same @Bean
annotation
used to define bean metadata within @Configuration
annotated classes. Here is a simple example:
@Component public class FactoryMethodComponent { @Bean @Qualifier("public") public TestBean publicInstance() { return new TestBean("publicInstance"); } public void doWork() { // Component method implementation omitted } }
This class is a Spring component that has application-specific code
contained in its doWork()
method. However, it
also contributes a bean definition that has a factory method referring to
the method publicInstance()
. The
@Bean
annotation identifies the factory method and
other bean definition properties, such as a qualifier value through the
@Qualifier
annotation. Other method level
annotations that can be specified are @Scope
,
@Lazy
, and custom qualifier annotations. Autowired
fields and methods are supported as previously discussed, with additional
support for autowiring of @Bean
methods:
@Component public class FactoryMethodComponent { private static int i; @Bean @Qualifier("public") public TestBean publicInstance() { return new TestBean("publicInstance"); } // use of a custom qualifier and autowiring of method parameters @Bean protected TestBean protectedInstance(@Qualifier("public") TestBean spouse, @Value("#{privateInstance.age}") String country) { TestBean tb = new TestBean("protectedInstance", 1); tb.setSpouse(tb); tb.setCountry(country); return tb; } @Bean @Scope(BeanDefinition.SCOPE_SINGLETON) private TestBean privateInstance() { return new TestBean("privateInstance", i++); } @Bean @Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS) public TestBean requestScopedInstance() { return new TestBean("requestScopedInstance", 3); } }
The example autowires the String
method
parameter country
to the value of the
Age
property on another bean named
privateInstance
. A Spring Expression Language element
defines the value of the property through the notation #{
<expression> }
. For @Value
annotations,
an expression resolver is preconfigured to look for bean names when
resolving expression text.
The @Bean
methods in a Spring component are
processed differently than their counterparts inside a Spring
@Configuration
class. The difference is that
@Component
classes are not enhanced with CGLIB to
intercept the invocation of methods and fields. CGLIB proxying is the
means by which invoking methods or fields within
@Configuration
classes @Bean
methods
create bean metadata references to collaborating objects. Methods are
not invoked with normal Java semantics. In contrast,
calling a method or field within a @Component
classes
@Bean
method has standard Java
semantics.
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:
@Service("myMovieLister") public class SimpleMovieLister { // ... }
@Repository public class MovieFinderImpl implements MovieFinder { // ... }
Note | |
---|---|
If you do not want to rely on the default bean-naming strategy, you
can provide a custom bean-naming strategy. First, implement the |
<beans> <context:component-scan base-package="org.example" name-generator="org.example.MyNameGenerator" /> </beans>
As a general rule, consider specifying the name with the annotation whenever other components may be making explicit references to it. On the other hand, the auto-generated names are adequate whenever the container is responsible for wiring.
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:
@Scope("prototype") @Repository public class MovieFinderImpl implements MovieFinder { // ... }
Note | |
---|---|
To provide a custom strategy for scope resolution rather than
relying on the annotation-based approach, implement the |
<beans> <context:component-scan base-package="org.example" scope-resolver="org.example.MyScopeResolver" /> </beans>
When using certain non-singleton scopes, it may be necessary to generate proxies for the scoped objects. The reasoning is described 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:
<beans> <context:component-scan base-package="org.example" scoped-proxy="interfaces" /> </beans>
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:
@Component @Qualifier("Action") public class ActionMovieCatalog implements MovieCatalog { // ... }
@Component @Genre("Action") public class ActionMovieCatalog implements MovieCatalog { // ... }
@Component @Offline public class CachingMovieCatalog implements MovieCatalog { // ... }
Note | |
---|---|
As with most annotation-based alternatives, keep in mind that the annotation metadata is bound to the class definition itself, while the use of XML allows for multiple beans of the same type to provide variations in their qualifier metadata, because that metadata is provided per-instance rather than per-class. |
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.
Note | |
---|---|
If you are using Maven, the <dependency> <groupId>javax.inject</groupId> <artifactId>javax.inject</artifactId> <version>1</version> </dependency> |
Instead of @Autowired
,
@javax.inject.Inject
may be used as follows:
import javax.inject.Inject; public class SimpleMovieLister { private MovieFinder movieFinder; @Inject public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
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:
import javax.inject.Inject; import javax.inject.Named; public class SimpleMovieLister { private MovieFinder movieFinder; @Inject public void setMovieFinder(@Named("main") MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
Instead of @Component
, @javax.inject.Named
may be used as follows:
import javax.inject.Inject; import javax.inject.Named; @Named("movieListener") public class SimpleMovieLister { private MovieFinder movieFinder; @Inject public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
It is very common to use @Component
without
specifying a name for the component. @Named
can be used in a similar fashion:
import javax.inject.Inject; import javax.inject.Named; @Named public class SimpleMovieLister { private MovieFinder movieFinder; @Inject public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } // ... }
When using @Named
, it is possible to use
component-scanning in the exact same way as when using Spring annotations:
<beans> <context:component-scan base-package="org.example"/> </beans>
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
|
@Qualifier | @Named | |
@Value | | no equivalent |
@Required | | no equivalent |
@Lazy | | no equivalent |
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:
@Configuration public class AppConfig { @Bean public MyService myService() { return new MyServiceImpl(); } }
The AppConfig
class above would be equivalent to the
following Spring <beans/>
XML:
<beans> <bean id="myService" class="com.acme.services.MyServiceImpl"/> </beans>
The @Bean
and @Configuration
annotations will be discussed in depth in the sections below. First, however, we'll
cover the various ways of creating a spring container using Java-based
configuration.
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.
In much the same way that Spring XML files are used as input when
instantiating a ClassPathXmlApplicationContext
,
@Configuration
classes may be used as input when
instantiating an AnnotationConfigApplicationContext
.
This allows for completely XML-free usage of the Spring container:
public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); MyService myService = ctx.getBean(MyService.class); myService.doStuff(); }
As mentioned above,
AnnotationConfigApplicationContext
is not limited to
working only with @Configuration
classes. Any
@Component
or JSR-330 annotated class may be supplied
as input to the constructor. For example:
public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(MyServiceImpl.class, Dependency1.class, Dependency2.class); MyService myService = ctx.getBean(MyService.class); myService.doStuff(); }
The above assumes that MyServiceImpl
,
Dependency1
and Dependency2
use
Spring dependency injection annotations such as
@Autowired
.
An AnnotationConfigApplicationContext
may be
instantiated using a no-arg constructor and then configured using the
register()
method. This approach is particularly
useful when programmatically building an
AnnotationConfigApplicationContext
.
public static void main(String[] args) { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.register(AppConfig.class, OtherConfig.class); ctx.register(AdditionalConfig.class); ctx.refresh(); MyService myService = ctx.getBean(MyService.class); myService.doStuff(); }
Experienced Spring users will be familiar with the following
commonly-used XML declaration from Spring's context:
namespace
<beans> <context:component-scan base-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:
public static void main(String[] args) { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); ctx.scan("com.acme"); ctx.refresh(); MyService myService = ctx.getBean(MyService.class); }
Note | |
---|---|
Remember that |
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>
@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.
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:
@Configuration public class AppConfig { @Bean public TransferService transferService() { return new TransferServiceImpl(); } }
The preceding configuration is exactly equivalent to the following Spring XML:
<beans> <bean id="transferService" class="com.acme.TransferServiceImpl"/> </beans>
Both declarations make a bean named transferService
available in the ApplicationContext
, bound to an object
instance of type TransferServiceImpl
:
transferService -> com.acme.TransferServiceImpl
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.
The standard set of *Aware
interfaces such as
BeanFactoryAware
,
BeanNameAware
,
MessageSourceAware
, ApplicationContextAware
, and
so on are also fully supported.
The @Bean
annotation supports
specifying arbitrary initialization and destruction callback methods,
much like Spring XML's init-method
and
destroy-method
attributes on the bean
element:
public class Foo { public void init() { // initialization logic } } public class Bar { public void cleanup() { // destruction logic } } @Configuration public class AppConfig { @Bean(initMethod = "init") public Foo foo() { return new Foo(); } @Bean(destroyMethod = "cleanup") public Bar bar() { return new Bar(); } }
Of course, in the case of Foo
above, it would be
equally as valid to call the init()
method directly during
construction:
@Configuration public class AppConfig { @Bean public Foo foo() { Foo foo = new Foo(); foo.init(); return foo; } // ... }
Tip | |
---|---|
When you work directly in Java, you can do anything you like with your objects and do not always need to rely on the container lifecycle! |
You can specify that your beans defined with the
@Bean
annotation should have a specific
scope. You can use any of the standard scopes specified in the Bean Scopes section.
The default scope is singleton
, but you can
override this with the @Scope
annotation:
@Configuration public class MyConfiguration { @Bean @Scope("prototype") public Encryptor encryptor() { // ... } }
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:
// an HTTP Session-scoped bean exposed as a proxy @Bean @Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS) public UserPreferences userPreferences() { return new UserPreferences(); } @Bean public Service userService() { UserService service = new SimpleUserService(); // a reference to the proxied userPreferences bean service.setUserPreferences(userPreferences()); return service; }
By default, configuration classes use a
@Bean
method's name as the name of the
resulting bean. This functionality can be overridden, however, with the
name
attribute.
@Configuration public class AppConfig { @Bean(name = "myFoo") public Foo foo() { return new Foo(); } }
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.
@Configuration public class AppConfig { @Bean(name = { "dataSource", "subsystemA-dataSource", "subsystemB-dataSource" }) public DataSource dataSource() { // instantiate, configure and return DataSource bean... } }
@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.
When @Bean
s have dependencies on one
another, expressing that dependency is as simple as having one bean
method call another:
@Configuration public class AppConfig { @Bean public Foo foo() { return new Foo(bar()); } @Bean public Bar bar() { return new Bar(); } }
In the example above, the foo
bean receives a reference
to bar
via constructor injection.
Note | |
---|---|
This method of declaring inter-bean dependencies only works when
the |
As noted earlier, lookup method injection is an advanced feature that you should use rarely. It is useful in cases where a singleton-scoped bean has a dependency on a prototype-scoped bean. Using Java for this type of configuration provides a natural means for implementing this pattern.
public abstract class CommandManager { public Object process(Object commandState) { // grab a new instance of the appropriate Command interface Command command = createCommand(); // set the state on the (hopefully brand new) Command instance command.setState(commandState); return command.execute(); } // okay... but where is the implementation of this method? protected abstract Command createCommand(); }
Using Java-configuration support , you can create a subclass of
CommandManager
where the abstract
createCommand()
method is overridden in such a way that
it looks up a new (prototype) command object:
@Bean @Scope("prototype") public AsyncCommand asyncCommand() { AsyncCommand command = new AsyncCommand(); // inject dependencies here as required return command; } @Bean public CommandManager commandManager() { // return new anonymous implementation of CommandManager with command() overridden // to return a new prototype Command object return new CommandManager() { protected Command createCommand() { return asyncCommand(); } } }
The following example shows a @Bean
annotated
method being called twice:
@Configuration public class AppConfig { @Bean public ClientService clientService1() { ClientServiceImpl clientService = new ClientServiceImpl(); clientService.setClientDao(clientDao()); return clientService; } @Bean public ClientService clientService2() { ClientServiceImpl clientService = new ClientServiceImpl(); clientService.setClientDao(clientDao()); return clientService; } @Bean public ClientDao clientDao() { return new ClientDaoImpl(); } }
clientDao()
has been called once in
clientService1()
and once in
clientService2()
. Since this method creates a new
instance 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:
|
Much as the <import/>
element is used
within Spring XML files to aid in modularizing configurations, the
@Import
annotation allows for loading
@Bean
definitions from another configuration
class:
@Configuration public class ConfigA { public @Bean A a() { return new A(); } } @Configuration @Import(ConfigA.class) public class ConfigB { public @Bean B b() { return new B(); } }
Now, rather than needing to specify both
ConfigA.class
and ConfigB.class
when instantiating the context, only ConfigB
needs to
be supplied
explicitly:
public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class); // now both beans A and B will be available... A a = ctx.getBean(A.class); B b = ctx.getBean(B.class); }
This approach simplifies container instantiation, as only one class
needs to be dealt with, rather than requiring the developer to remember
a potentially large number of @Configuration
classes
during construction.
The example above works, but is simplistic. In most practical
scenarios, beans will have dependencies on one another across
configuration classes. When using XML, this is not an issue, per se,
because there is no compiler involved, and one can simply declare
ref="someBean"
and trust that Spring will work it
out during container initialization. Of course, when using
@Configuration
classes, the Java compiler places
constraints on the configuration model, in that references to other
beans must be valid Java syntax.
Fortunately, solving this problem is simple. Remember that
@Configuration
classes are ultimately just another
bean in the container - this means that they can take advantage of
@Autowired
injection metadata just like any other
bean!
Let's consider a more real-world scenario with several
@Configuration
classes, each depending on beans
declared in the
others:
@Configuration public class ServiceConfig { private @Autowired AccountRepository accountRepository; public @Bean TransferService transferService() { return new TransferServiceImpl(accountRepository); } } @Configuration public class RepositoryConfig { private @Autowired DataSource dataSource; public @Bean AccountRepository accountRepository() { return new JdbcAccountRepository(dataSource); } } @Configuration @Import({ServiceConfig.class, RepositoryConfig.class}) public class SystemTestConfig { public @Bean DataSource dataSource() { /* return new DataSource */ } } public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class); // everything wires up across configuration classes... TransferService transferService = ctx.getBean(TransferService.class); transferService.transfer(100.00, "A123", "C456"); }
In the scenario above, using @Autowired
works
well and provides the desired modularity, but determining exactly
where the autowired bean definitions are declared is still somewhat
ambiguous. For example, as a developer looking at
ServiceConfig
, how do you know exactly where the
@Autowired AccountRepository
bean is declared?
It's not explicit in the code, and this may be just fine. Remember
that the SpringSource Tool Suite provides tooling that can render
graphs showing how everything is wired up - that may be all you
need. Also, your Java IDE can easily find all declarations and uses
of the AccountRepository
type, and will quickly
show you the location of @Bean
methods that
return that type.
In cases where this ambiguity is not acceptable and you wish to
have direct navigation from within your IDE from one
@Configuration
class to another, consider
autowiring the configuration classes themselves:
@Configuration public class ServiceConfig { private @Autowired RepositoryConfig repositoryConfig; public @Bean TransferService transferService() { // navigate 'through' the config class to the @Bean method! return new TransferServiceImpl(repositoryConfig.accountRepository()); } }
In the situation above, it is completely explicit where
AccountRepository
is defined. However,
ServiceConfig
is now tightly coupled 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:
@Configuration public class ServiceConfig { private @Autowired RepositoryConfig repositoryConfig; public @Bean TransferService transferService() { return new TransferServiceImpl(repositoryConfig.accountRepository()); } } @Configuration public interface RepositoryConfig { @Bean AccountRepository accountRepository(); } @Configuration public class DefaultRepositoryConfig implements RepositoryConfig { public @Bean AccountRepository accountRepository() { return new JdbcAccountRepository(...); } } @Configuration @Import({ServiceConfig.class, DefaultRepositoryConfig.class}) // import the concrete config! public class SystemTestConfig { public @Bean DataSource dataSource() { /* return DataSource */ } } public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemTestConfig.class); TransferService transferService = ctx.getBean(TransferService.class); transferService.transfer(100.00, "A123", "C456"); }
Now ServiceConfig
is loosely coupled with respect
to the concrete DefaultRepositoryConfig
, and
built-in IDE tooling is still useful: it will be easy for the
developer to get a type hierarchy of
RepositoryConfig
implementations. In this way,
navigating @Configuration
classes and their
dependencies becomes no different than the usual process of
navigating interface-based code.
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.
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.
Remember that @Configuration
classes are
ultimately just bean definitions in the container. In this example,
we create a @Configuration
class named
AppConfig
and include it within
system-test-config.xml
as a
<bean/>
definition. Because
<context:annotation-config/>
is switched
on, the container will recognize the
@Configuration
annotation, and process the
@Bean
methods declared in
AppConfig
properly.
@Configuration public class AppConfig { private @Autowired DataSource dataSource; public @Bean AccountRepository accountRepository() { return new JdbcAccountRepository(dataSource); } public @Bean TransferService transferService() { return new TransferService(accountRepository()); } }
system-test-config.xml <beans> <!-- enable processing of annotations such as @Autowired and @Configuration --> <context:annotation-config/> <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/> <bean class="com.acme.AppConfig"/> <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> </beans>
jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=
public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:/com/acme/system-test-config.xml"); TransferService transferService = ctx.getBean(TransferService.class); // ... }
Note | |
---|---|
In |
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-scan base-package="com.acme"/> <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/> <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> </beans>
In applications where @Configuration
classes
are the primary mechanism for configuring the container, it will still
likely be necessary to use at least some XML. In these scenarios,
simply use @ImportResource
and define only as much
XML as is needed. Doing so achieves a "Java-centric" approach to
configuring the container and keeps XML to a bare minimum.
@Configuration @ImportResource("classpath:/com/acme/properties-config.xml") public class AppConfig { private @Value("${jdbc.url}") String url; private @Value("${jdbc.username}") String username; private @Value("${jdbc.password}") String password; public @Bean DataSource dataSource() { return new DriverManagerDataSource(url, username, password); } }
properties-config.xml <beans> <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/> </beans>
jdbc.properties
jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
jdbc.username=sa
jdbc.password=
public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); TransferService transferService = ctx.getBean(TransferService.class); // ... }
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 @EnableLoadTimeWeaving public class 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”.
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.
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:
<beans> <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basenames"> <list> <value>format</value> <value>exceptions</value> <value>windows</value> </list> </property> </bean> </beans>
In the example it is assumed you have three resource bundles defined
in your classpath called format
,
exceptions
and windows
. Any request
to resolve a message will be handled in the JDK standard way of resolving
messages through ResourceBundles. For the purposes of the example, assume
the contents of two of the above resource bundle files are...
# in format.properties
message=Alligators rock!
# in exceptions.properties argument.required=The '{0}' argument is required.
A program to execute the MessageSource
functionality is shown in the next example. Remember that all
ApplicationContext
implementations are also
MessageSource
implementations and so can be cast to
the MessageSource
interface.
public static void main(String[] args) { MessageSource resources = new ClassPathXmlApplicationContext("beans.xml"); String message = resources.getMessage("message", null, "Default", null); System.out.println(message); }
The resulting output from the above program will be...
Alligators rock!
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 --> <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basename" value="exceptions"/> </bean> <!-- lets inject the above MessageSource into this POJO --> <bean id="example" class="com.foo.Example"> <property name="messages" ref="messageSource"/> </bean> </beans>
public class Example { private MessageSource messages; public void setMessages(MessageSource messages) { this.messages = messages; } public void execute() { String message = this.messages.getMessage("argument.required", new Object [] {"userDao"}, "Required", null); System.out.println(message); } }
The resulting output from the invocation of the
execute()
method will be...
The userDao argument is required.
With regard to internationalization (i18n), Spring's various
MessageResource
implementations follow the same
locale resolution and fallback rules as the standard JDK
ResourceBundle
. In short, and continuing with the
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.
public static void main(final String[] args) { MessageSource resources = new ClassPathXmlApplicationContext("beans.xml"); String message = resources.getMessage("argument.required", new Object [] {"userDao"}, "Required", Locale.UK); System.out.println(message); }
The resulting output from the running of the above program will be...
Ebagum lad, the 'userDao' argument is required, I say, required.
You can also use the MessageSourceAware
interface to acquire a reference to any
MessageSource
that has been defined. Any bean that
is defined in an ApplicationContext
that implements
the MessageSourceAware
interface is injected with
the application context's MessageSource
when the
bean is created and configured.
Note | |
---|---|
As an alternative to
|
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:
public class BlackListEvent extends ApplicationEvent { private final String address; private final String test; public BlackListEvent(Object source, String address, String test) { super(source); this.address = address; this.test = test; } // accessor and other methods... }
To publish a custom ApplicationEvent
, call the
publishEvent()
method on an
ApplicationEventPublisher
. Typically this
is done by creating a class that implements
ApplicationEventPublisherAware
and
registering it as a Spring bean. The following example demonstrates such a
class:
public class EmailService implements ApplicationEventPublisherAware { private List<String> blackList; private ApplicationEventPublisher publisher; public void setBlackList(List<String> blackList) { this.blackList = blackList; } public void setApplicationEventPublisher(ApplicationEventPublisher publisher) { this.publisher = publisher; } public void sendEmail(String address, String text) { if (blackList.contains(address)) { BlackListEvent event = new BlackListEvent(this, address, text); publisher.publishEvent(event); return; } // send email... } }
At configuration time, the Spring container will detect that
EmailService
implements
ApplicationEventPublisherAware
and will
automatically call
setApplicationEventPublisher()
. In reality, the
parameter passed in will be the Spring container itself; you're simply
interacting with the application context via its
ApplicationEventPublisher
interface.
To receive the custom ApplicationEvent
, create
a class that implements ApplicationListener
and register it as a Spring bean. The following example demonstrates such
a class:
public class BlackListNotifier implements ApplicationListener<BlackListEvent> { private String notificationAddress; public void setNotificationAddress(String notificationAddress) { this.notificationAddress = notificationAddress; } public void onApplicationEvent(BlackListEvent event) { // notify appropriate parties via notificationAddress... } }
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:
<bean id="emailService" class="example.EmailService"> <property name="blackList"> <list> <value>known.spammer@example.org</value> <value>known.hacker@example.org</value> <value>john.doe@example.org</value> </list> </property> </bean> <bean id="blackListNotifier" class="example.BlackListNotifier"> <property name="notificationAddress" value="blacklist@example.org"/> </bean>
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. |
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
Resource
s. 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.
The ContextLoader
mechanism comes in two
flavors: the ContextLoaderListener
and the
ContextLoaderServlet
. They have the same
functionality but differ in that the listener version is not reliable in
Servlet 2.3 containers. In the Servlet 2.4 specification, Servlet context
listeners must execute immediately after the Servlet context for the web
application is created and is available to service the first request (and
also when the Servlet context is about to be shut down). As such a Servlet
context listener is an ideal place to initialize the Spring
ApplicationContext
. All things being equal,
you should probably prefer ContextLoaderListener
;
for more information on compatibility, have a look at the Javadoc for the
ContextLoaderServlet
.
You can register an ApplicationContext
using the ContextLoaderListener
as follows:
<context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- or use the ContextLoaderServlet instead of the above listener <servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> -->
The listener inspects the contextConfigLocation
parameter. If the parameter does not exist, the listener uses
/WEB-INF/applicationContext.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".
You can use ContextLoaderServlet
instead of
ContextLoaderListener
. The Servlet uses the
contextConfigLocation
parameter just as the listener
does.
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.
Check out the JavaDoc of the SpringContextResourceAdapter class for the configuration details involved in RAR deployment.
For a simple deployment of a Spring ApplicationContext as a
J2EE RAR file: package all application classes into a RAR file,
which is a standard JAR file with a different file extension. Add all
required library JARs into the root of the RAR archive. Add a
"META-INF/ra.xml" deployment descriptor (as shown in
SpringContextResourceAdapter
s 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. |
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.
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
| No | Yes |
Automatic
| No | Yes |
Convenient
| No | Yes |
| No | Yes |
To explicitly register a bean post-processor with a
BeanFactory
implementation, you must
write code like this:
ConfigurableBeanFactory factory = new XmlBeanFactory(...); // now register any needed BeanPostProcessor instances MyBeanPostProcessor postProcessor = new MyBeanPostProcessor(); factory.addBeanPostProcessor(postProcessor); // now start using the factory
To explicitly register a
BeanFactoryPostProcessor
when using a
BeanFactory
implementation, you must
write code like this:
XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml")); // bring in some property values from a Properties file PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer(); cfg.setLocation(new FileSystemResource("jdbc.properties")); // now actually do the replacement cfg.postProcessBeanFactory(factory);
In both cases, the explicit registration step is inconvenient, which
is one reason why the various
ApplicationContext
implementations are
preferred above plain BeanFactory
implementations in the vast majority of Spring-backed applications,
especially when using BeanFactoryPostProcessors
and
BeanPostProcessors
. These mechanisms implement
important functionality such as property placeholder replacement and
AOP.
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.
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.
Spring's Resource
interface is meant
to be a more capable interface for abstracting access to low-level
resources.
public interface Resource extends InputStreamSource { boolean exists(); boolean isOpen(); URL getURL() throws IOException; File getFile() throws IOException; Resource createRelative(String relativePath) throws IOException; String getFilename(); String getDescription(); }
public interface InputStreamSource { InputStream getInputStream() throws IOException; }
Some of the most important methods from the
Resource
interface are:
getInputStream()
: locates and opens the
resource, returning an InputStream
for reading
from the resource. It is expected that each invocation returns a
fresh InputStream
. It is the responsibility of
the caller to close the stream.
exists()
: returns a
boolean
indicating whether this resource actually
exists in physical form.
isOpen()
: returns a
boolean
indicating whether this resource represents
a handle with an open stream. If true
, the
InputStream
cannot be read multiple times, and
must be read once only and then closed to avoid resource leaks. Will
be false
for all usual resource implementations,
with the exception of
InputStreamResource
.
getDescription()
: returns a description
for this resource, to be used for error output when working with the
resource. This is often the fully qualified file name or the actual
URL of the resource.
Other methods allow you to obtain an actual
URL
or File
object
representing the resource (if the underlying implementation is compatible,
and supports that functionality).
The Resource
abstraction is used
extensively in Spring itself, as an argument type in many method
signatures when a resource is needed. Other methods in some Spring APIs
(such as the constructors to various
ApplicationContext
implementations), take a
String
which in unadorned or 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.
There are a number of Resource
implementations that come supplied straight out of the box in
Spring:
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
.
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.
This is a Resource
implementation
for java.io.File
handles. It obviously supports
resolution as a File
, and as a
URL
.
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.
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.
The ResourceLoader
interface is meant
to be implemented by objects that can return (i.e. load)
Resource
instances.
public interface ResourceLoader { Resource getResource(String location); }
All application contexts implement the
ResourceLoader
interface, and therefore all
application contexts may be used to obtain
Resource
instances.
When you call getResource()
on a specific
application context, and the location path specified doesn't have a
specific prefix, you will get back a
Resource
type that is appropriate to that
particular application context. For example, assume the following snippet
of code was executed against a
ClassPathXmlApplicationContext
instance:
Resource template = ctx.getResource("some/resource/path/myTemplate.txt");
What would be returned would be a
ClassPathResource
; if the same method was executed
against a FileSystemXmlApplicationContext
instance,
you'd get back a FileSystemResource
. For a
WebApplicationContext
, you'd get back a
ServletContextResource
, and so on.
As such, you can load resources in a fashion appropriate to the particular application context.
On the other hand, you may also force
ClassPathResource
to be used, regardless of the
application context type, by specifying the special
classpath:
prefix:
Resource template = ctx.getResource("classpath:some/resource/path/myTemplate.txt");
Similarly, one can force a UrlResource
to be
used by specifying any of the standard java.net.URL
prefixes:
Resource template = ctx.getResource("file:/some/resource/path/myTemplate.txt");
Resource template = ctx.getResource("http://myhost.com/resource/path/myTemplate.txt");
The following table summarizes the strategy for converting
String
s to
Resource
s:
Table 6.1. Resource strings
Prefix | Example | Explanation |
---|---|---|
classpath: | | Loaded from the classpath. |
file: | | Loaded as a |
http: | | Loaded as a
|
(none) | | Depends on the underlying
|
[1] But see also
Section 6.7.3, “ |
The ResourceLoaderAware
interface is
a special marker interface, identifying objects that expect to be provided
with a ResourceLoader
reference.
public interface ResourceLoaderAware { void setResourceLoader(ResourceLoader resourceLoader); }
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
”.
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:
<bean id="myBean" class="..."> <property name="template" value="some/resource/path/myTemplate.txt"/> </bean>
Note that the resource path has no prefix, so because the
application context itself is going to be used as the
ResourceLoader
, the resource itself will be
loaded via a ClassPathResource
,
FileSystemResource
, or
ServletContextResource
(as appropriate)
depending on the exact type of the context.
If there is a need to force a specific
Resource
type to be used, then a prefix may
be used. The following two examples show how to force a
ClassPathResource
and a
UrlResource
(the latter being used to access a
filesystem file).
<property name="template" value="classpath:some/resource/path/myTemplate.txt">
<property name="template" value="file:/some/resource/path/myTemplate.txt"/>
An application context constructor (for a specific application context type) generally takes a string or array of strings as the location path(s) of the resource(s) such as XML files that make up the definition of the context.
When such a location path doesn't have a prefix, the specific
Resource
type built from that path and
used to load the bean definitions, depends on and is appropriate to the
specific application context. For example, if you create a
ClassPathXmlApplicationContext
as follows:
ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/appContext.xml");
The bean definitions will be loaded from the classpath, as a
ClassPathResource
will be
used. But if you create a
FileSystemXmlApplicationContext
as
follows:
ApplicationContext ctx = new FileSystemXmlApplicationContext("conf/appContext.xml");
The bean definition will be loaded from a filesystem location, in this case relative to the current working directory.
Note that the use of the special classpath prefix or a standard
URL prefix on the location path will override the default type of
Resource
created to load the definition.
So this FileSystemXmlApplicationContext
...
ApplicationContext ctx = new FileSystemXmlApplicationContext("classpath:conf/appContext.xml");
... will actually load its bean definitions from the classpath.
However, it is still a FileSystemXmlApplicationContext
. If it is
subsequently used as a ResourceLoader
,
any unprefixed paths will still be treated as filesystem paths.
The ClassPathXmlApplicationContext
exposes a number of constructors to enable convenient instantiation.
The basic idea is that one supplies merely a string array containing
just the filenames of the XML files themselves (without the leading
path information), and one also supplies a
Class
; the
ClassPathXmlApplicationContext
will derive the
path information from the supplied class.
An example will hopefully make this clear. Consider a directory layout that looks like this:
com/ foo/ services.xml daos.xml MessengerService.class
A ClassPathXmlApplicationContext
instance
composed of the beans defined in the 'services.xml'
and 'daos.xml'
could be instantiated like
so...
ApplicationContext ctx = new ClassPathXmlApplicationContext( new String[] {"services.xml", "daos.xml"}, MessengerService.class);
Please do consult the Javadocs for the
ClassPathXmlApplicationContext
class for
details of the various constructors.
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.
When the path location contains an Ant-style pattern, for example:
/WEB-INF/*-context.xml com/mycompany/**/applicationContext.xml file:C:/some/path/*-context.xml classpath:com/mycompany/**/applicationContext.xml
... the resolver follows a more complex but defined procedure to
try to resolve the wildcard. It produces a Resource for the path up to
the last non-wildcard segment and obtains a URL from it. If this URL
is not a "jar:" URL or container-specific variant (e.g.
"zip:
" in WebLogic, "wsjar
" in
WebSphere, etc.), then a java.io.File
is
obtained from it and used to resolve the wildcard by traversing the
filesystem. In the case of a jar URL, the resolver either gets a
java.net.JarURLConnection
from it or manually
parses the jar URL and then traverses the contents of the jar file
to resolve the wildcards.
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.
When constructing an XML-based application context, a location
string may use the special classpath*:
prefix:
ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:conf/appContext.xml");
This special prefix specifies that all classpath resources that
match the given name must be obtained (internally, this essentially
happens via a ClassLoader.getResources(...)
call), and then merged to form the final application context
definition.
Classpath*: portability | |
---|---|
The wildcard classpath relies on the |
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.
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.
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:
ApplicationContext ctx = new FileSystemXmlApplicationContext("conf/context.xml");
ApplicationContext ctx = new FileSystemXmlApplicationContext("/conf/context.xml");
As are the following: (Even though it would make sense for them to be different, as one case is relative and the other absolute.)
FileSystemXmlApplicationContext ctx = ...;
ctx.getResource("some/resource/path/myTemplate.txt");
FileSystemXmlApplicationContext ctx = ...;
ctx.getResource("/some/resource/path/myTemplate.txt");
In practice, if true absolute filesystem paths are needed, it is
better to forgo the use of absolute paths with
FileSystemResource
/
FileSystemXmlApplicationContext
, and just force
the use of a UrlResource
, by using the
file:
URL prefix.
// actual context type doesn't matter, the Resource will always be UrlResource ctx.getResource("file:/some/resource/path/myTemplate.txt");
// force this FileSystemXmlApplicationContext to load its definition via a UrlResource ApplicationContext ctx = new FileSystemXmlApplicationContext("file:/conf/context.xml");
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.
Spring features a Validator
interface
that you can use to validate objects. The
Validator
interface works using an
Errors
object so that while validating,
validators can report validation failures to the
Errors
object.
Let's consider a small data object:
public class Person { private String name; private int age; // the usual getters and setters... }
We're going to provide validation behavior for the
Person
class by implementing the following two
methods of the
org.springframework.validation.Validator
interface:
supports(Class)
- Can this
Validator
validate instances of the
supplied Class
?
validate(Object,
org.springframework.validation.Errors)
- validates the
given object and in case of validation errors, registers those with
the given Errors
object
Implementing a Validator
is fairly
straightforward, especially when you know of the
ValidationUtils
helper class that the Spring
Framework also provides.
public class PersonValidator implements Validator { /** * This Validator validates *just* Person instances */ public boolean supports(Class clazz) { return Person.class.equals(clazz); } public void validate(Object obj, Errors e) { ValidationUtils.rejectIfEmpty(e, "name", "name.empty"); Person p = (Person) obj; if (p.getAge() < 0) { e.rejectValue("age", "negativevalue"); } else if (p.getAge() > 110) { e.rejectValue("age", "too.darn.old"); } } }
As you can see, the static
rejectIfEmpty(..)
method on the
ValidationUtils
class is used to reject the
'name'
property if it is null
or the
empty string. Have a look at the Javadoc for the
ValidationUtils
class to see what functionality it
provides besides the example shown previously.
While it is certainly possible to implement a single
Validator
class to validate each of the
nested objects in a rich object, it may be better to encapsulate the
validation logic for each nested class of object in its own
Validator
implementation. A simple example
of a 'rich' object would be 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:
public class CustomerValidator implements Validator { private final Validator addressValidator; public CustomerValidator(Validator addressValidator) { if (addressValidator == null) { throw new IllegalArgumentException( "The supplied [Validator] is required and must not be null."); } if (!addressValidator.supports(Address.class)) { throw new IllegalArgumentException( "The supplied [Validator] must support the validation of [Address] instances."); } this.addressValidator = addressValidator; } /** * This Validator validates Customer instances, and any subclasses of Customer too */ public boolean supports(Class clazz) { return Customer.class.isAssignableFrom(clazz); } public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "field.required"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "surname", "field.required"); Customer customer = (Customer) target; try { errors.pushNestedPath("address"); ValidationUtils.invokeValidator(this.addressValidator, customer.getAddress(), errors); } finally { errors.popNestedPath(); } } }
Validation errors are reported to the
Errors
object passed to the validator. In
case of Spring Web MVC you can use <spring:bind/>
tag to inspect the error messages, but of course you can also inspect the
errors object yourself. More information about the methods it offers can
be found from the Javadoc.
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.
More information on the
MessageCodesResolver
and the default
strategy can be found online with the Javadocs for MessageCodesResolver and DefaultMessageCodesResolver respectively.
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.
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
.)
Consider the following two classes:
public class Company { private String name; private Employee managingDirector; public String getName() { return this.name; } public void setName(String name) { this.name = name; } public Employee getManagingDirector() { return this.managingDirector; } public void setManagingDirector(Employee managingDirector) { this.managingDirector = managingDirector; } }
public class Employee { private String name; private float salary; public String getName() { return this.name; } public void setName(String name) { this.name = name; } public float getSalary() { return salary; } public void setSalary(float salary) { this.salary = salary; } }
The following code snippets show some examples of how to retrieve
and manipulate some of the properties of instantiated
Companies
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");
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 . |
PatternEditor | Capable of resolving Strings to JDK 1.5
Pattern objects and vice versa. |
PropertiesEditor | 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.
public class FooBeanInfo extends SimpleBeanInfo { public PropertyDescriptor[] getPropertyDescriptors() { try { final PropertyEditor numberPE = new CustomNumberEditor(Integer.class, true); PropertyDescriptor ageDescriptor = new PropertyDescriptor("age", Foo.class) { public PropertyEditor createPropertyEditor(Object bean) { return numberPE; }; }; return new PropertyDescriptor[] { ageDescriptor }; } catch (IntrospectionException ex) { throw new Error(ex.toString()); } } }
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:
package example; public class ExoticType { private String name; public ExoticType(String name) { this.name = name; } } public class DependsOnExoticType { private ExoticType type; public void setType(ExoticType type) { this.type = type; } }
When things are properly set up, we want to be able to assign the
type property as a string, which a
PropertyEditor
will behind the scenes
convert into an actual ExoticType
instance:
<bean id="sample" class="example.DependsOnExoticType"> <property name="type" value="aNameForExoticType"/> </bean>
The PropertyEditor
implementation
could look similar to this:
// converts string representation to ExoticType object package example; public class ExoticTypeEditor extends PropertyEditorSupport { public void setAsText(String text) { setValue(new ExoticType(text.toUpperCase())); } }
Finally, we use CustomEditorConfigurer
to
register the new PropertyEditor
with
the ApplicationContext
, which will then
be able to use it as needed:
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer"> <property name="customEditors"> <map> <entry key="example.ExoticType" value="example.ExoticTypeEditor"/> </map> </property> </bean>
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; public final class CustomPropertyEditorRegistrar implements PropertyEditorRegistrar { public void registerCustomEditors(PropertyEditorRegistry registry) { // it is expected that new PropertyEditor instances are created registry.registerCustomEditor(ExoticType.class, new ExoticTypeEditor()); // you could register as many custom property editors as are required here... } }
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:
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer"> <property name="propertyEditorRegistrars"> <list> <ref bean="customPropertyEditorRegistrar"/> </list> </property> </bean> <bean id="customPropertyEditorRegistrar" class="com.foo.editors.spring.CustomPropertyEditorRegistrar"/>
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:
public final class RegisterUserController extends SimpleFormController { private final PropertyEditorRegistrar customPropertyEditorRegistrar; public RegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar) { this.customPropertyEditorRegistrar = propertyEditorRegistrar; } protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception { this.customPropertyEditorRegistrar.registerCustomEditors(binder); } // other methods to do with registering a User }
This style of PropertyEditor
registration can lead to concise code (the implementation of
initBinder(..)
is just one line long!), and
allows common PropertyEditor
registration code to be encapsulated in a class and then shared
amongst as many Controllers
as
needed.
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.
The SPI to implement type conversion logic is simple and strongly typed:
package org.springframework.core.convert.converter; public interface Converter<S, T> { T convert(S source); }
To create your own Converter, simply implement the interface above. Parameterize S as the type you are converting from, and T as the type you are converting to. For each call to convert(S), the source argument is guaranteed to be NOT null. Your Converter may throw any Exception if conversion fails. An IllegalArgumentException should be thrown to report an invalid source value. Take care to ensure your Converter implementation is thread-safe.
Several converter implementations are provided in the
core.convert.support
package as a convenience.
These include converters from Strings to Numbers and other common types.
Consider StringToInteger
as an example Converter
implementation:
package org.springframework.core.convert.support; final class StringToInteger implements Converter<String, Integer> { public Integer convert(String source) { return Integer.valueOf(source); } }
When you need to centralize the conversion logic for an entire
class hierarchy, for example, when converting from String to
java.lang.Enum objects, implement
ConverterFactory
:
package org.springframework.core.convert.converter; public interface ConverterFactory<S, R> { <T extends R> Converter<S, T> getConverter(Class<T> targetType); }
Parameterize S to be the type you are converting from and R to be the base type defining the range of classes you can convert to. Then implement getConverter(Class<T>), where T is a subclass of R.
Consider the StringToEnum
ConverterFactory
as an example:
package org.springframework.core.convert.support; final class StringToEnumConverterFactory implements ConverterFactory<String, Enum> { public <T extends Enum> Converter<String, T> getConverter(Class<T> targetType) { return new StringToEnumConverter(targetType); } private final class StringToEnumConverter<T extends Enum> implements Converter<String, T> { private Class<T> enumType; public StringToEnumConverter(Class<T> enumType) { this.enumType = enumType; } public T convert(String source) { return (T) Enum.valueOf(this.enumType, source.trim()); } } }
When you require a sophisticated Converter implementation, consider the GenericConverter interface. With a more flexible but less strongly typed signature, a GenericConverter supports converting between multiple source and target types. In addition, a GenericConverter makes available source and target field context you can use when implementing your conversion logic. Such context allows a type conversion to be driven by a field annotation, or generic information declared on a field signature.
package org.springframework.core.convert.converter; public interface GenericConverter { public Set<ConvertiblePair> getConvertibleTypes(); Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType); }
To implement a GenericConverter, have getConvertibleTypes() return the supported source->target type pairs. Then implement convert(Object, TypeDescriptor, TypeDescriptor) to implement your conversion logic. The source TypeDescriptor provides access to the source field holding the value being converted. The target TypeDescriptor provides access to the target field where the converted value will be set.
A good example of a GenericConverter is a converter that converts between a Java Array and a Collection. Such an ArrayToCollectionConverter introspects the field that declares the target Collection type to resolve the Collection's element type. This allows each element in the source array to be converted to the Collection element type before the Collection is set on the target field.
Note | |
---|---|
Because GenericConverter is a more complex SPI interface, only use it when you need it. Favor Converter or ConverterFactory for basic type conversion needs. |
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:
public interface ConditionalGenericConverter extends GenericConverter { boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType); }
A good example of a ConditionalGenericConverter is an EntityConverter that converts between an persistent entity identifier and an entity reference. Such a EntityConverter might only match if the target entity type declares a static finder method e.g. findAccount(Long). You would perform such a finder method check in the implementation of matches(TypeDescriptor, TypeDescriptor).
The ConversionService defines a unified API for executing type conversion logic at runtime. Converters are often executed behind this facade interface:
package org.springframework.core.convert; public interface ConversionService { boolean canConvert(Class<?> sourceType, Class<?> targetType); <T> T convert(Object source, Class<T> targetType); boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType); Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType); }
Most ConversionService implementations also implement
ConverterRegistry
, which provides an SPI for
registering converters. Internally, a ConversionService implementation
delegates to its registered converters to carry out type conversion
logic.
A robust ConversionService implementation is provided in the
core.convert.support
package.
GenericConversionService
is the general-purpose
implementation suitable for use in most environments.
ConversionServiceFactory
provides a convenient
factory for creating common ConversionService configurations.
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
:
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"/>
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.
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"> <property name="converters"> <list> <bean class="example.MyCustomConverter"/> </list> </property> </bean>
It is also common to use a ConversionService within a Spring MVC
application. See Section 7.6.5, “Configuring Formatting in Spring MVC”
for details on use with
<mvc:annotation-driven/>
.
In certain situations you may wish to apply formatting during
conversion. See Section 7.6.3, “FormatterRegistry SPI” for
details on using
FormattingConversionServiceFactoryBean
.
To work with a ConversionService instance programmatically, simply inject a reference to it like you would for any other bean:
@Service public class MyService { @Autowired public MyService(ConversionService conversionService) { this.conversionService = conversionService; } public void doIt() { this.conversionService.convert(...) } }
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.
The Formatter SPI to implement field formatting logic is simple and strongly typed:
package org.springframework.format; public interface Formatter<T> extends Printer<T>, Parser<T> { }
Where Formatter extends from the Printer and Parser building-block interfaces:
public interface Printer<T> { String print(T fieldValue, Locale locale); }
import java.text.ParseException; public interface Parser<T> { T parse(String clientValue, Locale locale) throws ParseException; }
To create your own Formatter, simply implement the Formatter
interface above. Parameterize T to be the type of object you wish to
format, for example, java.util.Date
. Implement
the print()
operation to print an instance of T
for display in the client locale. Implement the
parse()
operation to parse an instance of T from
the formatted representation returned from the client locale. Your
Formatter should throw a ParseException or IllegalArgumentException if a
parse attempt fails. Take care to ensure your Formatter implementation
is thread-safe.
Several Formatter implementations are provided in
format
subpackages as a convenience. The
number
package provides a NumberFormatter,
CurrencyFormatter, and PercentFormatter to format java.lang.Number
objects using a java.text.NumberFormat. The
datetime
package provides a DateFormatter to format
java.util.Date objects with a java.text.DateFormat. The
datetime.joda
package provides comprehensive
datetime formatting support based on the Joda Time library.
Consider DateFormatter
as an example
Formatter
implementation:
package org.springframework.format.datetime; public final class DateFormatter implements Formatter<Date> { private String pattern; public DateFormatter(String pattern) { this.pattern = pattern; } public String print(Date date, Locale locale) { if (date == null) { return ""; } return getDateFormat(locale).format(date); } public Date parse(String formatted, Locale locale) throws ParseException { if (formatted.length() == 0) { return null; } return getDateFormat(locale).parse(formatted); } protected DateFormat getDateFormat(Locale locale) { DateFormat dateFormat = new SimpleDateFormat(this.pattern, locale); dateFormat.setLenient(false); return dateFormat; } }
The Spring team welcomes community-driven Formatter contributions; see http://jira.springframework.org to contribute.
As you will see, field formatting can be configured by field type or annotation. To bind an Annotation to a formatter, implement AnnotationFormatterFactory:
package org.springframework.format; public interface AnnotationFormatterFactory<A extends Annotation> { Set<Class<?>> getFieldTypes(); Printer<?> getPrinter(A annotation, Class<?> fieldType); Parser<?> getParser(A annotation, Class<?> fieldType); }
Parameterize A to be the field annotationType you wish to associate
formatting logic with, for 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:
public final class NumberFormatAnnotationFormatterFactory implements AnnotationFormatterFactory<NumberFormat> { public Set<Class<?>> getFieldTypes() { return new HashSet<Class<?>>(asList(new Class<?>[] { Short.class, Integer.class, Long.class, Float.class, Double.class, BigDecimal.class, BigInteger.class })); } public Printer<Number> getPrinter(NumberFormat annotation, Class<?> fieldType) { return configureFormatterFrom(annotation, fieldType); } public Parser<Number> getParser(NumberFormat annotation, Class<?> fieldType) { return configureFormatterFrom(annotation, fieldType); } private Formatter<Number> configureFormatterFrom(NumberFormat annotation, Class<?> fieldType) { if (!annotation.pattern().isEmpty()) { return new NumberFormatter(annotation.pattern()); } else { Style style = annotation.style(); if (style == Style.PERCENT) { return new PercentFormatter(); } else if (style == Style.CURRENCY) { return new CurrencyFormatter(); } else { return new NumberFormatter(); } } } }
To trigger formatting, simply annotate fields with @NumberFormat:
public class MyModel { @NumberFormat(style=Style.CURRENCY) private BigDecimal decimal; }
A portable format annotation API exists in the
org.springframework.format.annotation
package.
Use @NumberFormat to format java.lang.Number fields. Use
@DateTimeFormat to format java.util.Date, java.util.Calendar,
java.util.Long, or Joda Time fields.
The example below uses @DateTimeFormat to format a java.util.Date as a ISO Date (yyyy-MM-dd):
public class MyModel { @DateTimeFormat(iso=ISO.DATE) private Date date; }
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).
Review the FormatterRegistry SPI below:
package org.springframework.format; public interface FormatterRegistry extends ConverterRegistry { void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser); void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter); void addFormatterForFieldType(Formatter<?> formatter); void addFormatterForAnnotation(AnnotationFormatterFactory<?, ?> factory); }
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.
The FormatterRegistrar is an SPI for registering formatters and converters through the FormatterRegistry:
package org.springframework.format; public interface FormatterRegistrar { void registerFormatters(FormatterRegistry registry); }
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.
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.
To rely on default formatting rules, no custom configuration is required in your Spring MVC config XML:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <mvc:annotation-driven/> </beans>
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:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <mvc:annotation-driven conversion-service="conversionService"/> <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"> <property name="converters"> <set> <bean class="org.example.MyConverter"/> </set> </property> <property name="formatters"> <set> <bean class="org.example.MyFormatter"/> <bean class="org.example.MyAnnotationFormatterFactory"/> </set> </property> <property name="formatterRegistrars"> <set> <bean class="org.example.MyFormatterRegistrar"/> </set> </property> </bean> </beans>
Note | |
---|---|
See Section 7.6.4, “FormatterRegistrar SPI” and
the |
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:
@Configuration public class AppConfig { @Bean public FormattingConversionService conversionService() { // Use the DefaultFormattingConversionService but do not register defaults DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService(false); // Ensure @NumberFormat is still supported conversionService.addFormatterForFieldAnnotation(new NumberFormatAnnotationFormatterFactory()); // Register date conversion with a specific global format DateFormatterRegistrar registrar = new DateFormatterRegistrar(); registrar.setFormatter(new DateFormatter("yyyyMMdd")); registrar.registerFormatters(conversionService); return conversionService; } }
If you prefer XML based configuration you can use a
FormattingConversionServiceFactoryBean
. Here is the same
example, this time using Joda Time:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd> <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"> <property name="registerDefaultFormatters" value="false" /> <property name="formatters"> <set> <bean class="org.springframework.format.number.NumberFormatAnnotationFormatterFactory" /> </set> </property> <property name="formatterRegistrars"> <set> <bean class="org.springframework.format.datetime.joda.JodaTimeFormatterRegistrar"> <property name="dateFormatter"> <bean class="org.springframework.format.datetime.joda.DateTimeFormatterFactoryBean"> <property name="pattern" value="yyyyMMdd"/> </bean> </property> </bean> </set> </property> </bean> </beans>
Note | |
---|---|
Joda Time provides separate distinct types to represent
|
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.
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.
JSR-303 standardizes validation constraint declaration and metadata for the Java platform. Using this API, you annotate domain model properties with declarative validation constraints and the runtime enforces them. There are a number of built-in constraints you can take advantage of. You may also define your own custom constraints.
To illustrate, consider a simple PersonForm model with two properties:
public class PersonForm { private String name; private int age; }
JSR-303 allows you to define declarative validation constraints against such properties:
public class PersonForm { @NotNull @Size(max=64) private String name; @Min(0) private int age; }
When an instance of this class is validated by a JSR-303 Validator, these constraints will be enforced.
For general information on JSR-303, see the Bean Validation Specification. For information on the specific capabilities of the default reference implementation, see the Hibernate Validator documentation. To learn how to setup a JSR-303 implementation as a Spring bean, keep reading.
Spring provides full support for the JSR-303 Bean Validation API.
This includes convenient support for bootstrapping a JSR-303
implementation as a Spring bean. This allows for a
javax.validation.ValidatorFactory
or
javax.validation.Validator
to be injected wherever
validation is needed in your application.
Use the LocalValidatorFactoryBean
to
configure a default JSR-303 Validator as a Spring bean:
<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/>
The basic configuration above will trigger JSR-303 to initialize using its default bootstrap mechanism. A JSR-303 provider, such as Hibernate Validator, is expected to be present in the classpath and will be detected automatically.
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:
import javax.validation.Validator; @Service public class MyService { @Autowired private Validator validator;
Inject a reference to
org.springframework.validation.Validator
if your bean
requires the Spring Validation API:
import org.springframework.validation.Validator; @Service public class MyService { @Autowired private Validator validator; }
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:
@Target({ElementType.METHOD, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @Constraint(validatedBy=MyConstraintValidator.class) public @interface MyConstraint { }
import javax.validation.ConstraintValidator; public class MyConstraintValidator implements ConstraintValidator { @Autowired; private Foo aDependency; ... }
As you can see, a ConstraintValidator implementation may have its dependencies @Autowired like any other Spring bean.
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.
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:
Foo target = new Foo(); DataBinder binder = new DataBinder(target); binder.setValidator(new FooValidator()); // bind to the target object binder.bind(propertyValues); // validate the target object binder.validate(); // get BindingResult that includes any validation errors BindingResult results = binder.getBindingResult();
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”.
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.
To trigger validation of a @Controller input, simply annotate the input argument as @Valid:
@Controller public class MyController { @RequestMapping("/foo", method=RequestMethod.POST) public void processFoo(@Valid Foo foo) { /* ... */ }
Spring MVC will validate a @Valid object after binding so-long as an appropriate Validator has been configured.
Note | |
---|---|
The @Valid annotation is part of the standard JSR-303 Bean Validation API, and is not a Spring-specific construct. |
The Validator instance invoked when a @Valid method argument is encountered may be configured in two ways. First, you may call binder.setValidator(Validator) within a @Controller's @InitBinder callback. This allows you to configure a Validator instance per @Controller class:
@Controller public class MyController { @InitBinder protected void initBinder(WebDataBinder binder) { binder.setValidator(new FooValidator()); } @RequestMapping("/foo", method=RequestMethod.POST) public void processFoo(@Valid Foo foo) { ... } }
Second, you may call setValidator(Validator) on the global WebBindingInitializer. This allows you to configure a Validator instance across all @Controllers. This can be achieved easily by using the Spring MVC namespace:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <mvc:annotation-driven validator="globalValidator"/> </beans>
To combine a global and a local validator, configure the global validator as shown above and then add a local validator:
@Controller public class MyController { @InitBinder protected void initBinder(WebDataBinder binder) { binder.addValidators(new FooValidator()); } }
With JSR-303, a single javax.validation.Validator
instance typically validates all model objects
that declare validation constraints. To configure a JSR-303-backed
Validator with Spring MVC, simply add a JSR-303 Provider, such as
Hibernate Validator, to your classpath. Spring MVC will detect it and
automatically enable JSR-303 support across all Controllers.
The Spring MVC configuration required to enable JSR-303 support is shown below:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- JSR-303 support will be detected on classpath and enabled automatically --> <mvc:annotation-driven/> </beans>
With this minimal configuration, anytime a @Valid @Controller input is encountered, it will be validated by the JSR-303 provider. JSR-303, in turn, will 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.
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.
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
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'.
ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression("'Hello World'"); String message = (String) exp.getValue();
The value of the message variable is simply 'Hello World'.
The SpEL classes and interfaces you are most likely to use are located in the packages org.springframework.expression and its sub packages 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.
ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression("'Hello World'.concat('!')"); String message = (String) exp.getValue();
The value of message is now 'Hello World!'.
As an example of calling a JavaBean property, the String property 'Bytes' can be called as shown below.
ExpressionParser parser = new SpelExpressionParser(); // invokes 'getBytes()' Expression exp = parser.parseExpression("'Hello World'.bytes"); byte[] bytes = (byte[]) exp.getValue();
SpEL also supports nested properties using standard 'dot' notation, i.e. prop1.prop2.prop3 and the setting of property values
Public fields may also be accessed.
ExpressionParser parser = new SpelExpressionParser(); // invokes 'getBytes().length' Expression exp = parser.parseExpression("'Hello World'.bytes.length"); int length = (Integer) exp.getValue();
The String's constructor can be called instead of using a string literal.
ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression("new String('hello world').toUpperCase()"); String message = exp.getValue(String.class);
Note the use of the generic method public <T> T
getValue(Class<T> desiredResultType)
. Using this method
removes the need to cast the value of the expression to the desired result
type. An EvaluationException
will be thrown if the
value cannot be cast to the type T
or converted using
the registered type converter.
The more common usage of SpEL is to provide an expression string that
is evaluated against a specific object instance (called the root object).
There are two options here and which to choose depends on whether the object
against which the expression is being evaluated will be changing with each
call to evaluate the expression. In the following example
we retrieve the name
property from an instance of the
Inventor class.
// Create and set a calendar GregorianCalendar c = new GregorianCalendar(); c.set(1856, 7, 9); // The constructor arguments are name, birthday, and nationality. Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian"); ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression("name"); EvaluationContext context = new StandardEvaluationContext(tesla); String name = (String) exp.getValue(context);
In the last
line, the value of the string variable 'name' will be set to "Nikola
Tesla". The class StandardEvaluationContext is where you can specify which
object the "name" property will be evaluated against. This is the mechanism
to use if the root object is unlikely to change, it can simply be set once
in the evaluation context. If the root object is likely to change
repeatedly, it can be supplied on each call to getValue
,
as this next example shows:
/ Create and set a calendar GregorianCalendar c = new GregorianCalendar(); c.set(1856, 7, 9); // The constructor arguments are name, birthday, and nationality. Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian"); ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression("name"); String name = (String) exp.getValue(tesla);
In this case the inventor tesla
has been
supplied directly to getValue
and the expression
evaluation infrastructure creates and manages a default evaluation context
internally - it did not require one to be supplied.
The StandardEvaluationContext is relatively expensive to construct and during repeated usage it builds up cached state that enables subsequent expression evaluations to be performed more quickly. For this reason it is better to cache and reuse them where possible, rather than construct a new one for each expression evaluation.
In some cases it can be desirable to use a configured evaluation context and
yet still supply a different root object on each call to getValue
.
getValue
allows both to be specified on the same call.
In these situations the root object passed on the call is considered to override
any (which maybe null) specified on the evaluation context.
Note | |
---|---|
In standalone usage of SpEL there is a need to create the parser, parse expressions and perhaps provide evaluation contexts and a root context object. However, more common usage is to provide only the SpEL expression string as part of a configuration file, for example for Spring bean or Spring Web Flow definitions. In this case, the parser, evaluation context, root object and any predefined variables are all set up implicitly, requiring the user to specify nothing other than the expressions. |
As a final introductory example, the use of a boolean operator is shown using the Inventor object in the previous example.
Expression exp = parser.parseExpression("name == 'Nikola Tesla'"); boolean result = exp.getValue(context, Boolean.class); // evaluates to true
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 ConstructorResolver
s,
MethodResolver
s, and
PropertyAccessor
s to extend how SpEL evaluates
expressions. Please refer to the JavaDoc of these classes for more
details.
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);
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> }
.
A property or constructor-arg value can be set using expressions as shown below
<bean id="numberGuess" class="org.spring.samples.NumberGuess"> <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/> <!-- other properties --> </bean>
The variable 'systemProperties' is predefined, so you can use it in your expressions as shown below. Note that you do not have to prefix the predefined variable with the '#' symbol in this context.
<bean id="taxCalculator" class="org.spring.samples.TaxCalculator"> <property name="defaultLocale" value="#{ systemProperties['user.region'] }"/> <!-- other properties --> </bean>
You can also refer to other bean properties by name, for example.
<bean id="numberGuess" class="org.spring.samples.NumberGuess"> <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/> <!-- other properties --> </bean> <bean id="shapeGuess" class="org.spring.samples.ShapeGuess"> <property name="initialShapeSeed" value="#{ numberGuess.randomNumber }"/> <!-- other properties --> </bean>
The @Value
annotation can be placed on fields,
methods and method/constructor parameters to specify a default
value.
Here is an example to set the default value of a field variable.
public static class FieldValueTestBean @Value("#{ systemProperties['user.region'] }") private String defaultLocale; public void setDefaultLocale(String defaultLocale) { this.defaultLocale = defaultLocale; } public String getDefaultLocale() { return this.defaultLocale; } }
The equivalent but on a property setter method is shown below.
public static class PropertyValueTestBean private String defaultLocale; @Value("#{ systemProperties['user.region'] }") public void setDefaultLocale(String defaultLocale) { this.defaultLocale = defaultLocale; } public String getDefaultLocale() { return this.defaultLocale; } }
Autowired methods and constructors can also use the
@Value
annotation.
public class SimpleMovieLister { private MovieFinder movieFinder; private String defaultLocale; @Autowired public void configure(MovieFinder movieFinder, @Value("#{ systemProperties['user.region'] }") String defaultLocale) { this.movieFinder = movieFinder; this.defaultLocale = defaultLocale; } // ... }
public class MovieRecommender { private String defaultLocale; private CustomerPreferenceDao customerPreferenceDao; @Autowired public MovieRecommender(CustomerPreferenceDao customerPreferenceDao, @Value("#{systemProperties['user.country']}") String defaultLocale) { this.customerPreferenceDao = customerPreferenceDao; this.defaultLocale = defaultLocale; } // ... }
The types of literal expressions supported are strings, dates, numeric values (int, real, and hex), boolean and null. Strings are delimited by single quotes. To put a single quote itself in a string use two single quote characters. The following listing shows simple usage of literals. Typically they would not be used in isolation like this, but as part of a more complex expression, for example using a literal on one side of a logical comparison operator.
ExpressionParser parser = new SpelExpressionParser(); // evals to "Hello World" String helloWorld = (String) parser.parseExpression("'Hello World'").getValue(); double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue(); // evals to 2147483647 int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue(); boolean trueValue = (Boolean) parser.parseExpression("true").getValue(); Object nullValue = parser.parseExpression("null").getValue();
Numbers support the use of the negative sign, exponential notation, and decimal points. By default real numbers are parsed using Double.parseDouble().
Navigating with property references is easy, just use a period to indicate a nested property value. The instances of Inventor class, pupin and tesla, were populated with data listed in the section Classes used in the examples. To navigate "down" and get Tesla's year of birth and Pupin's city of birth the following expressions are used.
// evals to 1856 int year = (Integer) parser.parseExpression("Birthdate.Year + 1900").getValue(context); String city = (String) parser.parseExpression("placeOfBirth.City").getValue(context);
Case insensitivity is allowed for the first letter of property names. The contents of arrays and lists are obtained using square bracket notation.
ExpressionParser parser = new SpelExpressionParser(); // Inventions Array StandardEvaluationContext teslaContext = new StandardEvaluationContext(tesla); // evaluates to "Induction motor" String invention = parser.parseExpression("inventions[3]").getValue(teslaContext, String.class); // Members List StandardEvaluationContext societyContext = new StandardEvaluationContext(ieee); // evaluates to "Nikola Tesla" String name = parser.parseExpression("Members[0].Name").getValue(societyContext, String.class); // List and Array navigation // evaluates to "Wireless communication" String invention = parser.parseExpression("Members[0].Inventions[6]").getValue(societyContext, String.class);
The contents of maps are obtained by specifying the literal key value within the brackets. In this case, because keys for the Officers map are strings, we can specify string literals.
// Officer's Dictionary Inventor pupin = parser.parseExpression("Officers['president']").getValue(societyContext, Inventor.class); // evaluates to "Idvor" String city = parser.parseExpression("Officers['president'].PlaceOfBirth.City").getValue(societyContext, String.class); // setting values parser.parseExpression("Officers['advisors'][0].PlaceOfBirth.Country").setValue(societyContext, "Croatia");
Lists can be expressed directly in an expression using {} notation.
// evaluates to a Java list containing the four numbers List numbers = (List) parser.parseExpression("{1,2,3,4}").getValue(context); List listOfLists = (List) parser.parseExpression("{{'a','b'},{'x','y'}}").getValue(context);
{} 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.
Arrays can be built using the familiar Java syntax, optionally supplying an initializer to have the array populated at construction time.
int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context); // Array with initializer int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context); // Multi dimensional array int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);
It is not currently allowed to supply an initializer when constructing a multi-dimensional array.
Methods are invoked using typical Java programming syntax. You may also invoke methods on literals. Varargs are also supported.
// string literal, evaluates to "bc" String c = parser.parseExpression("'abc'.substring(2, 3)").getValue(String.class); // evaluates to true boolean isMember = parser.parseExpression("isMember('Mihajlo Pupin')").getValue(societyContext, Boolean.class);
The relational operators; equal, not equal, less than, less than or equal, greater than, and greater than or equal are supported using standard operator notation.
// evaluates to true boolean trueValue = parser.parseExpression("2 == 2").getValue(Boolean.class); // evaluates to false boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class); // evaluates to true boolean trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);
In addition to standard relational operators SpEL supports the 'instanceof' and regular expression based 'matches' operator.
// evaluates to false boolean falseValue = parser.parseExpression("'xyz' instanceof T(int)").getValue(Boolean.class); // evaluates to true boolean trueValue = parser.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class); //evaluates to false boolean falseValue = parser.parseExpression("'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
Each symbolic operator can also be specified as a purely alphabetic equivalent. This avoids problems where the symbols used have special meaning for the document type in which the expression is embedded (eg. an XML document). The textual equivalents are shown here: lt ('<'), gt ('>'), le ('<='), ge ('>='), eq ('=='), ne ('!='), div ('/'), mod ('%'), not ('!'). These are case insensitive.
The logical operators that are supported are and, or, and not. Their use is demonstrated below.
// -- AND -- // evaluates to false boolean falseValue = parser.parseExpression("true and false").getValue(Boolean.class); // evaluates to true String expression = "isMember('Nikola Tesla') and isMember('Mihajlo Pupin')"; boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class); // -- OR -- // evaluates to true boolean trueValue = parser.parseExpression("true or false").getValue(Boolean.class); // evaluates to true String expression = "isMember('Nikola Tesla') or isMember('Albert Einstein')"; boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class); // -- NOT -- // evaluates to false boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class); // -- AND and NOT -- String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')"; boolean falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);
The addition operator can be used on numbers, strings and dates. Subtraction can be used on numbers and dates. Multiplication and division can be used only on numbers. Other mathematical operators supported are modulus (%) and exponential power (^). Standard operator precedence is enforced. These operators are demonstrated below.
// Addition int two = parser.parseExpression("1 + 1").getValue(Integer.class); // 2 String testString = parser.parseExpression("'test' + ' ' + 'string'").getValue(String.class); // 'test string' // Subtraction int four = parser.parseExpression("1 - -3").getValue(Integer.class); // 4 double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class); // -9000 // Multiplication int six = parser.parseExpression("-2 * -3").getValue(Integer.class); // 6 double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class); // 24.0 // Division int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class); // -2 double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class); // 1.0 // Modulus int three = parser.parseExpression("7 % 4").getValue(Integer.class); // 3 int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class); // 1 // Operator precedence int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class); // -21
Setting of a property is done by using the assignment operator.
This would typically be done within a call to
setValue
but can also be done inside a call to
getValue
.
Inventor inventor = new Inventor(); StandardEvaluationContext inventorContext = new StandardEvaluationContext(inventor); parser.parseExpression("Name").setValue(inventorContext, "Alexander Seovic2"); // alternatively String aleks = parser.parseExpression("Name = 'Alexandar Seovic'").getValue(inventorContext, String.class);
The special 'T' operator can be used to specify an instance of
java.lang.Class (the 'type'). Static methods are invoked using this
operator as well. The StandardEvaluationContext
uses a TypeLocator
to find types and the
StandardTypeLocator
(which can be replaced) is
built with an understanding of the java.lang package. This means T()
references to types within java.lang do not need to be fully qualified,
but all other type references must be.
Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class); Class stringClass = parser.parseExpression("T(String)").getValue(Class.class); boolean trueValue = parser.parseExpression("T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR") .getValue(Boolean.class);
Constructors can be invoked using the new operator. The fully qualified class name should be used for all but the primitive type and String (where int, float, etc, can be used).
Inventor einstein = p.parseExpression("new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')") .getValue(Inventor.class); //create new inventor instance within add method of List p.parseExpression("Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))") .getValue(societyContext);
Variables can be referenced in the expression using the syntax #variableName. Variables are set using the method setVariable on the StandardEvaluationContext.
Inventor tesla = new Inventor("Nikola Tesla", "Serbian"); StandardEvaluationContext context = new StandardEvaluationContext(tesla); context.setVariable("newName", "Mike Tesla"); parser.parseExpression("Name = #newName").getValue(context); System.out.println(tesla.getName()) // "Mike Tesla"
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.
// create an array of integers List<Integer> primes = new ArrayList<Integer>(); primes.addAll(Arrays.asList(2,3,5,7,11,13,17)); // create parser and set variable 'primes' as the array of integers ExpressionParser parser = new SpelExpressionParser(); StandardEvaluationContext context = new StandardEvaluationContext(); context.setVariable("primes",primes); // all prime numbers > 10 from the list (using selection ?{...}) // evaluates to [11, 13, 17] List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression("#primes.?[#this>10]").getValue(context);
You can extend SpEL by registering user defined functions that can
be called within the expression string. The function is registered with
the StandardEvaluationContext
using the
method.
public void registerFunction(String name, Method m)
A reference to a Java Method provides the implementation of the function. For example, a utility method to reverse a string is shown below.
public abstract class StringUtils { public static String reverseString(String input) { StringBuilder backwards = new StringBuilder(); for (int i = 0; i < input.length(); i++) backwards.append(input.charAt(input.length() - 1 - i)); } return backwards.toString(); } }
This method is then registered with the evaluation context and can be used within an expression string.
ExpressionParser parser = new SpelExpressionParser(); StandardEvaluationContext context = new StandardEvaluationContext(); context.registerFunction("reverseString", StringUtils.class.getDeclaredMethod("reverseString", new Class[] { String.class })); String helloWorldReversed = parser.parseExpression("#reverseString('hello')").getValue(context, String.class);
If the evaluation context has been configured with a bean resolver it is possible to lookup beans from an expression using the (@) symbol.
ExpressionParser parser = new SpelExpressionParser(); StandardEvaluationContext context = new StandardEvaluationContext(); context.setBeanResolver(new MyBeanResolver()); // This will end up calling resolve(context,"foo") on MyBeanResolver during evaluation Object bean = parser.parseExpression("@foo").getValue(context);
You can use the ternary operator for performing if-then-else conditional logic inside the expression. A minimal example is:
String falseString = parser.parseExpression("false ? 'trueExp' : 'falseExp'").getValue(String.class);
In this case, the boolean false results in returning the string value 'falseExp'. A more realistic example is shown below.
parser.parseExpression("Name").setValue(societyContext, "IEEE"); societyContext.setVariable("queryName", "Nikola Tesla"); expression = "isMember(#queryName)? #queryName + ' is a member of the ' " + "+ Name + ' Society' : #queryName + ' is not a member of the ' + Name + ' Society'"; String queryResultString = parser.parseExpression(expression).getValue(societyContext, String.class); // queryResultString = "Nikola Tesla is a member of the IEEE Society"
Also see the next section on the Elvis operator for an even shorter syntax for the ternary operator.
The Elvis operator is a shortening of the ternary operator syntax and is used in the Groovy language. With the ternary operator syntax you usually have to repeat a variable twice, for example:
String name = "Elvis Presley"; String displayName = name != null ? name : "Unknown";
Instead you can use the Elvis operator, named for the resemblance to Elvis' hair style.
ExpressionParser parser = new SpelExpressionParser(); String name = parser.parseExpression("null?:'Unknown'").getValue(String.class); System.out.println(name); // 'Unknown'
Here is a more complex example.
ExpressionParser parser = new SpelExpressionParser(); Inventor tesla = new Inventor("Nikola Tesla", "Serbian"); StandardEvaluationContext context = new StandardEvaluationContext(tesla); String name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, String.class); System.out.println(name); // Nikola Tesla tesla.setName(null); name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, String.class); System.out.println(name); // Elvis Presley
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.
ExpressionParser parser = new SpelExpressionParser(); Inventor tesla = new Inventor("Nikola Tesla", "Serbian"); tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan")); StandardEvaluationContext context = new StandardEvaluationContext(tesla); String city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, String.class); System.out.println(city); // Smiljan tesla.setPlaceOfBirth(null); city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, String.class); System.out.println(city); // null - does not throw NullPointerException!!!
Note | |
---|---|
The Elvis operator can be used to apply default values in
expressions, e.g. in an @Value("#{systemProperties['pop3.port'] ?: 25}") This will inject a system property |
Selection is a powerful expression language feature that allows you to transform some source collection into another by selecting from its entries.
Selection uses the syntax
?[selectionExpression]
. This will filter the
collection and return a new collection containing a subset of the
original elements. For example, selection would allow us to easily get a
list of Serbian inventors:
List<Inventor> list = (List<Inventor>)
parser.parseExpression("Members.?[Nationality == 'Serbian']").getValue(societyContext);
Selection is possible upon both lists and maps. In the former case
the selection criteria is evaluated against each individual list element
whilst against a map the selection criteria is evaluated against each
map entry (objects of the Java type Map.Entry
). Map
entries have their key and value accessible as properties for use in the
selection.
This expression will return a new map consisting of those elements of the original map where the entry value is less than 27.
Map newMap = parser.parseExpression("map.?[value<27]").getValue();
In addition to returning all the selected elements, it is possible
to retrieve just the first or the last value. To obtain the first entry
matching the selection the syntax is ^[...]
whilst to
obtain the last matching selection the syntax is
$[...]
.
Projection allows a collection to drive the evaluation of a
sub-expression and the result is a new collection. The syntax for
projection is ![projectionExpression]
. Most easily
understood by example, suppose we have a list of inventors but want the
list of cities where they were born. Effectively we want to evaluate
'placeOfBirth.city' for every entry in the inventor list. Using
projection:
// returns [ 'Smiljan', 'Idvor' ] List placesOfBirth = (List)parser.parseExpression("Members.![placeOfBirth.city]");
A map can also be used to drive projection and in this case the
projection expression is evaluated against each entry in the map
(represented as a Java Map.Entry
). The result of a
projection across a map is a list consisting of the evaluation of the
projection expression against each map entry.
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.
public class TemplateParserContext implements ParserContext { public String getExpressionPrefix() { return "#{"; } public String getExpressionSuffix() { return "}"; } public boolean isTemplate() { return true; } }
Inventor.java
package org.spring.samples.spel.inventor; import java.util.Date; import java.util.GregorianCalendar; public class Inventor { private String name; private String nationality; private String[] inventions; private Date birthdate; private PlaceOfBirth placeOfBirth; public Inventor(String name, String nationality) { GregorianCalendar c= new GregorianCalendar(); this.name = name; this.nationality = nationality; this.birthdate = c.getTime(); } public Inventor(String name, Date birthdate, String nationality) { this.name = name; this.nationality = nationality; this.birthdate = birthdate; } public Inventor() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getNationality() { return nationality; } public void setNationality(String nationality) { this.nationality = nationality; } public Date getBirthdate() { return birthdate; } public void setBirthdate(Date birthdate) { this.birthdate = birthdate; } public PlaceOfBirth getPlaceOfBirth() { return placeOfBirth; } public void setPlaceOfBirth(PlaceOfBirth placeOfBirth) { this.placeOfBirth = placeOfBirth; } public void setInventions(String[] inventions) { this.inventions = inventions; } public String[] getInventions() { return inventions; } }
PlaceOfBirth.java
package org.spring.samples.spel.inventor; public class PlaceOfBirth { private String city; private String country; public PlaceOfBirth(String city) { this.city=city; } public PlaceOfBirth(String city, String country) { this(city); this.country = country; } public String getCity() { return city; } public void setCity(String s) { this.city = s; } public String getCountry() { return country; } public void setCountry(String country) { this.country = country; } }
Society.java
package org.spring.samples.spel.inventor; import java.util.*; public class Society { private String name; public static String Advisors = "advisors"; public static String President = "president"; private List<Inventor> members = new ArrayList<Inventor>(); private Map officers = new HashMap(); public List getMembers() { return members; } public Map getOfficers() { return officers; } public String getName() { return name; } public void setName(String name) { this.name = name; } public boolean isMember(String name) { boolean found = false; for (Inventor inventor : members) { if (inventor.getName().equals(name)) { found = true; break; } } return found; } }
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.
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.
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).