Spring Annotations Cheat Sheet
来源:互联网 发布:java获取数据库表字段 编辑:程序博客网 时间:2024/06/10 01:40
Spring Annotations
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.
CORE SPRING ANNOTATIONS
Context Configuration Annotations
These annotations are used by Spring to guide creation and injection of beans.
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="treasureMap" 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 name) { this.name = name; }@Autowiredpublic void setTreasureMap(TreasureMap treasureMap) {this.treasureMap = treasureMap;}}
...and if you were to configure annotation configuration in Spring using the <context:annotation-configuration> 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:
@Autowiredpublic void directionsToTreasure(TreasureMaptreasureMap) {this.treasureMap = treasureMap;}
And even on member variables:
@Autowiredprivate TreasureMap treasureMap;
To resolve any autowiring ambiguity, use the @Qualifier attribute with @Autowired.
@Autowired@Qualifier("mapToTortuga")private TreasureMap treasureMap;
Ensuring That Required Properties are Set
To ensure that a property is injected with a value, use the @Required annotation:
@Requiredpublic void setTreasureMap(TreasureMap treasureMap) {this.treasureMap = treasureMap;}
In this case, the "treasureMap" property must be injected or else Spring will throw a BeanInitializationException and context creation will fail.
Stereotyping Annotations
These annotations are used to stereotype classes with regard to the application tier that they belong to. Classes that are annotated with one of these annotations will automatically be registered in the Spring application context if <context:component-scan> is in the Spring XML configuration.
In addition, if a PersistenceExceptionTranslationPostProcessor is configured in Spring, any bean annotated with @Repository will have SQLExceptions thrown from its methods translated into one of Spring's unchecked DataAccessExceptions.
Automatically Configuring Beans
In the previous section, you saw how to automatically wire a bean's properties using the @Autowired annotation. But it is possible to take autowiring to a new level by automatically registering beans in Spring. To get started with automatic registration of beans, first annotate the bean with one of the stereotype annotations, such as @Component:
@Componentpublic class Pirate {private String name;private TreasureMap treasureMap;public Pirate(String name) { this.name = name; }@Autowiredpublic void setTreasureMap(TreasureMap treasureMap) {this.treasureMap = treasureMap;}}
Then add <context:component-scan> to your Spring XML configuration:
<context:component-scanbase-package="com.habuma.pirates" />
The base-package annotation tells Spring to scan com.habuma. pirates and all of its subpackages for beans to automatically register.
You can specify a name for the bean by passing it as the value of @Component.
@Component("jackSparrow")public class Pirate { ... }
Specifying Scope For Auto-Configured Beans
By default, all beans in Spring, including auto-configured beans, are scoped as singleton. But you can specify the scope using the @Scope annotation. For example:
@Component@Scope("prototype")public class Pirate { ... }
This specifies that the pirate bean be scoped as a prototype bean.
Creating Custom Stereotypes
Autoregistering beans is a great way to cut back on the amount of XML required to configure Spring. But it may bother you that your autoregistered classes are annotated with Spring-specific annotations. If you're looking for a more non-intrusive way to autoregister beans, you have two options:
- Create your own custom stereotype annotation. Doing so is as simple as creating a custom annotation that is itself annotated with @Component:
@Componentpublic @interface MyComponent {String value() default "";}
- Or add a filter to <context:component-scan> to scan for annotations that it normally would not:
<context:component-scanbase-package="com.habuma.pirates"><context:include-filter type="annotation"expression="com.habuma.MyComponent" /><context:exclude-filter type="annotation"expression="org.springframework.stereotype.Component" /></context:component-scan>
In this case, the @MyComponent custom annotation has been added to the list of annotations that are scanned for, but @Component has been excluded (that is, @Componentannotated classes will no longer be autoregistered).
Regardless of which option you choose, you should be able to autoregister beans by annotating their classes with the custom annotation:
@MyComponentpublic class Pirate {...}
Spring MVC Annotations
These annotations were introduced in Spring 2.5 to make it easier to create Spring MVC applications with minimal XML configuration and without extending one of the many implementations of the Controller interface.
Setting up Spring for Annotated Controllers
Before we can use annotations on Spring MVC controllers, we'll need to add a few lines of XML to tell Spring that our controllers will be annotation-driven. First, so that we won't have to register each of our controllers individually as <bean>s, we'll need a <context:component-scan>:
<context:component-scanbase-package="com.habuma.pirates.mvc"/>
In addition to autoregistering @Component-annotated beans, <context:component-scan> also autoregisters beans that are annotated with @Controller. We'll see a few examples of @Controller-annotated classes in a moment.
But first, we'll also need to tell Spring to honor the other Spring MVC annotations. For that we'll need <context:annotation-config> : <context:annotation-config/>
Use a conventions-based view resolver.
If you use a conventions-based view resolver, such as Spring's UrlBasedViewResolver or InternalResourceViewResolver, along with <context:component-scan> and <context:annotation-config>, you can grow your application indefinitely without ever touching the Spring XML again.
Creating a Simple MVC Controller
The following HomePage class is annotated to function as a Spring MVC controller:
@Controller@RequestMapping("/home.htm")public class HomePage {@RequestMapping(method = RequestMethod.GET)public String showHomePage(Map model) {List<Pirate> pirates = pirateService.getPirateList();model.add("pirateList", pirates);return "home";}@AutowiredPirateService pirateService;}
There are several important things to point out here. First, the HomePage class is annotated with @Controller so that it will be autoregistered as a bean by <context:component-scan>. It is also annotated with @RequestMapping, indicating that this controller will respond to requests for "/home.htm".
Within the class, the showHomePage() method is also annotated with @RequestMapping. In this case, @RequestMapping indicates that HTTP GET requests to "/home.htm" will be handled by the showHomePage() method.
Creating a Form-Handling Controller
In a pre-2.5 Spring MVC application, form-processing controllers would typically extend SimpleFormController (or some similar base class). But with Spring 2.5, a form-processing controller just has a method that is annotated to handle the HTTP POST request:
@Controller@RequestMapping("/addPirate.htm")public class AddPirateFormController {@RequestMapping(method = RequestMethod.GET)public String setupForm(ModelMap model) {return "addPirate";}@ModelAttribute("pirate")public Pirate setupPirate() {Pirate pirate = new Pirate();return pirate;}@RequestMapping(method = RequestMethod.POST)protected String addPirate(@ModelAttribute("pirate")Pirate pirate) {pirateService.addPirate(pirate);return "pirateAdded";}@AutowiredPirateService pirateService;}
Here the @RequestMapping annotation is applied to two different methods. The setupForm() method is annotated to handle HTTP GET requests while the addPirate() method will handle HTTP POST requests. Meanwhile, the @ModelAttribute is also pulling double duty by populating the model with a new instance of Pirate before the form is displayed and then pulling the Pirate from the model so that it can be given to addPirate() for processing.
Transaction Annotations
The @Transactional annotation is used along with the <tx:annotation-driven> element to declare transactional boundaries and rules as class and method metadata in Java.
Annotating Transactional Boundaries
To use Spring's support for annotation-declared transactions, you'll first need to add a small amount of XML to the Spring configuration:
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/springbeans-2.5.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd"><tx:annotation-driven />...</beans>
The <tx:annotation-driven> element tells Spring to keep an eye out for beans that are annotated with @Transactional. In addition, you'll also need a platform transaction manager bean declared in the Spring context. For example, if your application uses Hibernate, you'll want to include the HibernateTransactionManager:
<bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean>
With the basic plumbing in place, you're ready to start annotating the transactional boundaries:
@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)public class TreasureRepositoryImpl implementsTreasureRepository {...@Transactional(propagation=Propagation.REQUIRED,readOnly=false)public void storeTreasure(Treasure treasure) {...}...}
At the class level, @Transactional is declaring that all methods should support transactions and be read-only. But, at the method-level, @Transactional declares that the storeTreasure() method requires a transaction and is not read-only. Note that for transactions to be applied to @Transactionalannotated classes, those classes must be wired as beans in Spring.
JMX Annotations
These annotations, used with the <context:mbean-export> element, declare bean methods and properties as MBean operations and attributes.
Exposing a Spring Bean as a MBean
To get started with Spring-annotated MBeans, you'll need to include <context:mbean-export> in the Spring XML configuration:
<context:mbean-export/>
Then, you can annotate any of your Spring-managed beans to be exported as MBeans:
@ManagedResource(objectName="pirates:name=PirateService")public interface PirateService {@ManagedOperation(description="Get the pirate list")public List<Pirate> getPirateList();}
Here, the PirateService has been annotated to be exported as a MBean and its getPirateList() method is a managed operation.
ASPECT ANNOTATIONS
For defining aspects, Spring leverages the set of annotations provided by AspectJ.
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/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/aophttp://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:
@Aspectpublic class ChantySinger {@Pointcut("execution(* Pirate.plunder(..))")public void plunderPC() {}@Before("plunderPC()")public void singYoHo() {...}@AfterReturning("plunderPC()")public 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 athttp://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 and return void.
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.
Wiring Bean Properties with @Resource
Using @Resource, you can wire a bean property by name:
public class Pirate {@Resourceprivate 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 {...@PostConstructpublic void wakeUp() {System.out.println("Yo ho!");}@PreDestroypublic 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.
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.
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" })public class PirateTest {...}
With test configured to load a Spring application context, you now may request that Spring autowire properties of the test class with beans from the Spring context:
@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations = { "pirates.xml" })public class PirateTest {@Autowiredprivate Pirate pirate;@Autowiredprivate TreasureMap treasureMap;@Testpublic void annotatedPropertyShouldBeAutowired() {assertNotNull(pirate.getTreasureMap());assertEquals(treasureMap, pirate.getTreasureMap());}}
In this case, the pirate and treasureMap properties will be wired with the beans whose ID are "pirate" and "treasureMap", respectively.
Accessing the Spring Context in a Test
If you need the Spring application context itself in a test, you can autowire it into the test the same as if it were a bean in the context:
@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations = { "pirates.xml" })public class PirateTest {@Autowiredprivate Pirate pirate;@Autowiredprivate ApplicationContext applicationContext;@Testpublic void annotatedPropertyShouldBeAutowired() {assertNotNull(pirate.getTreasureMap());assertEquals(applicationContext.getBean("treasureMap"), pirate.getTreasureMap());}}
- Spring Annotations Cheat Sheet
- Cheat Sheet
- Cheat Sheet
- 关于“cheat sheet”
- regular expressions cheat sheet
- Vim Cheat Sheet
- vi vim cheat sheet
- Rails Migration Cheat Sheet
- Watir Cheat Sheet
- WinDbg / SOS Cheat Sheet
- PHP Cheat Sheet
- SQL Injection Cheat Sheet
- sql injection cheat sheet
- Input Validation Cheat Sheet
- Git Cheat Sheet
- DBA cheat sheet
- Mdadm Cheat Sheet
- Cheat Sheet of Nmap
- 17-5 数组的排序
- 详解Spring IOC 与 DI 核心原理
- 排序之直接选择排序
- 判断两个有序数组中是否有相同的数字(第十七周上机任务)
- Android平台实现位图(Bitmap)的序列化和反序列化
- Spring Annotations Cheat Sheet
- Commands out of sync; you can't run this command now错误
- mysql存储过程执行动态sql
- 完成一程序演示字符数组、C风格字符串、std::string和MFC中的Cstring类型之间的相互转换
- 电驴提示“该内容尚未提供权利证明,无法提供下载”之解决办法详解
- DIY爱好者自制ARM笔记本 只为将项目彻底开源化
- 前端工程师必须掌握的知识点
- Android 面试题(有详细答案)
- Hibernamte一对一经典剖析