Spring Annotations - DZone - Refcardz
1 of 8
https://dzone.com/refcardz/spring-annotations
Refcard #026
Become a Spring Guru
Written
by
Craig Walls
Principal Consultant,
Improving Enterprises
Guides you through all annotations supported in Spring 2.5,
covering Core Spring Annotations, Spring MVC Annotations,
and more.
SECTION 1
Spring Annotations
From its beginning, Spring's most common means of configuration has been XML-based. But as
developers grow weary of navigating through a seemingly endless maze of angle-brackets, some have
started looking for other ways to wire the beans in their Spring-enabled applications. Spring has
responded with several annotation-driven configuration options. In this reference card, you'll find a
guide to all of the annotations supported in Spring 2.5.
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
2 of 8
https://dzone.com/refcardz/spring-annotations
SECTION 2
Core Spring Annotations
Context Configuration Annotations
These annotations are used by Spring to guide creation and injection of beans.
ANNOTATION
USE
DESCRIPTION
@Autowired
Constructor, Field,
Method
Declares a constructor, field, setter method, or configuration method
to be autowired by type. Items annotated with @Autowired do not
have to be public.
@Configurable
Type
Used with <context:springconfigured> to declare types whose
properties should be injected, even if they are not instantiated by
Spring. Typically used to inject the properties of domain objects.
@Order
Type, Method,
Field
Defines ordering, as an alternative to implementing the org.
springframework.core.Ordered interface.
@Qualifier
Field, Parameter,
Type, Annotation
Type
Guides autowiring to be performed by means other than by type.
@Required
Method (setters)
Specifies that a particular property must be injected or else the
configuration will fail.
@Scope
Type
Specifies the scope of a bean, either singleton, prototype, request,
session, or some custom scope.
Autowiring Bean Properties
A typical Spring bean might have its properties wired something like this:
<bean id="pirate" class="Pirate"> <constructor-arg value="Long John Silver" /> <property name="tre
asureMap" ref="treasureMap" /> </bean>
But it's also possible to have Spring automatically inject a bean's properties from other beans in the
context. For example, if the Pirate class were annotated with @Autowired like this...
public class Pirate { private String name; private TreasureMap treasureMap; public Pirate(String n
ame) { this.name = name; } @Autowired public void setTreasureMap(TreasureMap treasureMap) { this.t
reasureMap = treasureMap; } }
...and if you were to configure annotation configuration in Spring using the <context:annotationconfiguration> element like this...
<beans ... > <bean id="pirate" class="Pirate"> <constructor-arg value="Long John Silver" /> </bean
> <bean id="treasureMap" class="TreasureMap" /> <context:annotation-config /> </beans>
...then the "treasureMap" property will be automatically injected with a reference to a bean whose type
is assignable to TreasureMap (in this case, the bean whose ID is "treasureMap").
Autowiring Without Setter Methods
@Autowired can be used on any method (not just setter methods). The wiring can be done through
any method, as illustrated here:
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
3 of 8
https://dzone.com/refcardz/spring-annotations
SECTION 3
Aspect Annotations
For defining aspects, Spring leverages the set of annotations provided by AspectJ.
ANNOTATION
USE
DESCRIPTION
@Aspect
Type
Declares a class to be an aspect.
@After
Method
Declares a method to be called after a pointcut completes.
@AfterReturning
Method
Declares a method to be called after a pointcut returns successfully.
@AfterThrowing
Method
Declares a method to be called after a pointcut throws an exception.
@Around
Method
Declares a method that will wrap the pointcut.
@Before
Method
Declares a method to be called before proceeding to the pointcut.
@DeclareParents
Static
Field
Declares that matching types should be given new parents,that is, it introduces
new functionality into matching types.
@Pointcut
Method
Declares an empty method as a pointcut placeholder method.
What's important to note, however, is that while you can use AspectJ annotations to define Spring
aspects, those aspects will be defined in the context of Spring AOP and will not be handled by the
AspectJ runtime. This is significant because Spring AOP is limited to proxying method invocations and
does not provide for the more exotic pointcuts (constructor interception, field interception, etc.)
offered by AspectJ.
Annotating Aspects
To use AspectJ annotations to create Spring aspects, you'll first need to provide a bit of Spring XML
plumbing:
<beans xmlns="http://www.springframework.org/schema/ beans" xmlns:xsi="http://www.w3.org/2001/XMLS
chema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://w
ww.springframework.org/ schema/beans http://www.springframework.org/schema/beans/ spring-beans-2.5
.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/springaop
- 2.5.xsd"> ... <aop:aspectj-autoproxy/> ... </beans>
The <aop:aspectj-autoproxy> element tells Spring to watch for beans annotated with AspectJ
annotations and, if it finds any, to use them to create aspects. Then you can annotate bean classes to
be aspects:
@Aspect public class ChantySinger { @Pointcut("execution(* Pirate.plunder(..))") public void plund
erPC() {} @Before("plunderPC()") public void singYoHo() { ... } @AfterReturning("plunderPC()") pub
lic void singAPiratesLifeForMe() { ... } }
This simple annotation-based aspect has a pointcut that is triggered by the execution of a plunder()
method on the Pirate class. Before the Pirate.plunder() method is executed, the singYoHo() method is
called. Then, after the Pirate.plunder() method returns successfully, the singAPiratesLifeForMe()
method is invoked. (For more advanced examples of AspectJ annotations, see the AspectJ
documentation at http://www.eclipse.org/aspectj/docs.php.)
Note the rather odd looking plunderPC() method. It is annotated with @Pointcut to indicate that this
method is a pointcut placeholder. The key thing here is that the most interesting stuff happens in the
annotation itself and not in the method. In fact, pointcut placeholder methods must be empty methods
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
4 of 8
https://dzone.com/refcardz/spring-annotations
SECTION 4
JSR-250 Annotations
In addition to Spring's own set of annotations, Spring also supports a few of the annotations defined
by JSR-250, which is the basis for the annotations used in EJB 3.
ANNOTATION
USE
DESCRIPTION
@PostConstruct
Method
Indicates a method to be invoked after a bean has been created and
dependency injection is complete. Used to perform any initialization work
necessary.
@PreDestroy
Method
Indicates a method to be invoked just before a bean is removed from the
Spring context. Used to perform any cleanup work necessary.
@Resource
Method,
Field
Indicates that a method or field should be injected with a named resource (by
default, another bean).
Wiring Bean Properties with @Resource
Using @Resource, you can wire a bean property by name:
public class Pirate { @Resource private TreasureMap treasureMap; }
In this case, Spring will attempt to wire the "treasureMap" property with a reference to a bean whose
ID is "treasureMap". If you'd rather explicitly choose another bean to wire into the property, specify it
to the name attribute:
public class Pirate { @Resource(name="mapToSkullIsland") private TreasureMap treasureMap; }
Initialization and Destruction Methods
Using JSR-250's @PostConstruct and @PreDestroy methods, you can declare methods that hook into
a bean's lifecycle. For example, consider the following methods added to the Pirate class:
public class Pirate { ... @PostConstruct public void wakeUp() { System.out.println("Yo ho!"); } @P
reDestroy public void goAway() { System.out.println("Yar!"); } }
As annotated, the wakeUp() method will be invoked just after Spring instantiates the bean and
goAway() will be invoked just before the bean is removed from the Spring container.
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
5 of 8
https://dzone.com/refcardz/spring-annotations
SECTION 5
Testing Annotations
These annotations are useful for creating unit tests in the JUnit 4 style that depend on Spring beans
and/or require a transactional context.
ANNOTATION
USE
DESCRIPTION
@AfterTransaction
Method
Used to identify a method to be invoked after a transaction
has completed.
@BeforeTransaction
Method
Used to identify a method to be invoked before a transaction
starts.
@ContextConfiguration
Type
Configures a Spring application context for a test.
@DirtiesContext
Method
Indicates that a method dirties the Spring container and thus
it must be rebuilt after the test completes.
@ExpectedException
Method
Indicates that the test method is expected to throw a specific
exception. The test will fail if the exception is not thrown.
@IfProfileValue
Type,
Method
Indicates that the test class or method is enabled for a
specific profile configuration.
@NotTransactional
Method
Indicates that a test method must not execute in a
transactional context.
@ProfileValueSourceConfiguration
Type
Identifies an implementation of a profile value source. The
absence of this annotation will cause profile values to be
loaded from system properties.
@Repeat
Method
Indicates that the test method must be repeated a specific
number of times.
@Rollback
Method
Specifies whether or not the transaction for the annotated
method should be rolled back or not.
@TestExecutionListeners
Type
Identifies zero or more test execution listeners for a test class.
@Timed
Method
Specifies a time limit for the test method. If the test does not
complete before the time has expired, the test will fail.
Type
Configures test classes for transactions, specifying the
transaction manager and/or the default rollback rule for all
test methods in a test class.
@TransactionConfiguration
Writing a Spring-Aware Test
The key to writing a Spring-aware test is to annotate the test class with @RunWith, specifying
SpringJUnit4ClassRunner as the class runner behind the test:
@RunWith(SpringJUnit4ClassRunner.class) public class PirateTest { ... }
In this case, the Spring test runner will try to load a Spring application context from a file named
PirateTest-context.xml. If you'd rather specify one or more XML files to load the application context
from, you can do that with @ContextConfiguration:
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "pirates.xml" }) publi
c class PirateTest { ... }
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
6 of 8
https://dzone.com/refcardz/spring-annotations
Publications
Building
Maintainable and
Scalable Software
Learn design patterns
quickly with Jason
McDonald's outstanding
tutorial on the original 23
Gang of Four design
patterns, including class
diagrams, explanations,
usage info, and real world
examples.
Jason
McDonald
Featured
A Power-User's
Guide to Java
Gives you an overview of
key aspects of the Java
language and references
on the core library,
commonly used tools, and
new Java 8 features.
Cay
Horstmann
Latest
Popular
Unlocking
Unobtrusive
JavaScript
The De Facto
Standard For
Version Control
Introduces Ajax, a group
interrelated techniques
used in client-side web
development for creating
asynchronous web
applications.
This updated Refcard
explains why so many
developers are migrating
to this exciting platform.
Learn about creating a
new Git repository,
cloning existing projects,
the remote workflow, and
more to pave the way for
limitless content version
control.
Dave
Crane
123.9k
100.9k
332.9k
207.6k
201.3k
559.8k
Matthew
McCullough
112.1k
259.0k
First Steps in CSS
Dependency
Injection in a
Nutshell
Catalogs the XML
elements available as of
Spring 2.5 and highlights
those most commonly
used: a handy resource
for Spring context
configuration.
Craig
Walls
102.4k
257.8k
Covers Core principles of
CSS that will expand and
strengthen your
professional ability to
work with CSS. Part one
of three.
Molly
Holzschlag
89.33k
194.0k
REST Practices
The Representational
State Transfer (REST)
architectural style is a
worldview that elevates
information into a
first-class element of
architectures. REST
allows us to achieve the
architectural properties of
performance, scalability,
generality, simplicity,
modifiability, and
extensibility. This newly
updated Refcard explains
main HTTP verbs,
describes response
codes, and lists libraries
and frameworks. It also
gives additional resources
to further explore each
The Core jQuery
Reference
Introduces jQuery
Selectors, which allow
you to select and
manipulate HTML
elements as a group or as
a single element in
jQuery.
Bear
Bibeault
92.55k
351.5k
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
7 of 8
https://dzone.com/refcardz/spring-annotations
topic.
Brian
Sletten
96.63k
The Most Popular
Agile Methodology
Provides a concise
overview of roles,
meetings, rules, and
artifacts within a Scrum
organization. Updated for
2016.
Michael
James
Understanding the
Core Concurrency
Concepts
Helps Java developers
working with multithreaded programs
understand the core
concurrency concepts and
how to apply them.
Alex
Miller
86.13k
89.00k
229.7k
184.4k
145.1k
Understanding
Selectors
Covers Core principles of
CSS that will expand and
strengthen your
professional ability to
work with CSS. Part two
of three.
Test and Debug
Code With Javas
Leading IDE
Eclipse IDE is a crossplatform, multi-purpose,
open-source Integrated
Development
Environment. It is widely
used to develop projects
in Java, JavaScript, PHP,
C++, Scala, and many
others. This newly
updated Refcard breaks
down installing, setting
up, and getting started
with Eclipse. It also
covers productivity tips,
creating new projects and
files, accessing Source
Control Managers, and
debugging configurations.
Molly
Holzschlag
72.87k
139.3k
Mickael
Istria
77.28k
201.1k
ABOUT US
ADVERTISE
Stay Updated
About DZone
Send feedback
Careers
Media Kit
[email protected]
+1 (919) 443-1644
Get the latest tech articles and resources,
straight to your inbox.
CONTRIBUTE ON
DZONE
MVB Program
Zone Leader Program
Become a Contributor
CONTACT US
150 Preston Executive Drive
Cary, NC 27513
[email protected]
+1 (919) 678-0300
SEE AN EXAMPLE
Enter Email
Let's be friends:
12/23/2016 11:51 PM
Spring Annotations - DZone - Refcardz
8 of 8
https://dzone.com/refcardz/spring-annotations
LEGAL
Terms of Service
Privacy Policy
DZone.com is powered by
12/23/2016 11:51 PM
