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