java annotation 转载

wukunlsy

浏览: 124069 次
性别:
来自: 大连

最近访客更多访客>>

罗伯特X

Alpha0323

Ranber

a40255478

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

JAVE SE

Java Office Bean Spring 虚拟机

Annotation是继承自java.lang.annotation.Annotation的类,用于向程序分析工具或虚拟机提供package class field methed 等方面的信息,它和其他类没什么区别,除了使用方式.
Annotation的一般形式是 :

Java代码

public @interface MyAnnotation {
String value() default "hahaha";
}

public @interface MyAnnotation {
    String value() default "hahaha";
}

我认为和它等价的java类为:

Java代码

public class MyAnnotation extends java.lang.annotation.Annotation{
private String value = "hahaha";
public void setValue(String value){
this.value = value;
}
public String getValue(){
return value;
}
}

public class MyAnnotation extends java.lang.annotation.Annotation{
     private String value = "hahaha";
     public void setValue(String value){
          this.value = value;
     }
     public String getValue(){
          return value;
      }
}

Annotation的使用方法和Bean的比较:

Java代码

@MyAnnotation(value="hello") //对应Bean的set方法
Method method = AnnotationTest.class.getMethod("doSomthing", null); //取得被注释的方法,AnnotationTest.class为该方法所在的类
MyRetention mr = method.getAnnotation(MyRetention.class); //取得注释对象
String value = mr.value(); //取得value的值,对应Bean的get方法.

@MyAnnotation(value="hello")     //对应Bean的set方法

Method method = AnnotationTest.class.getMethod("doSomthing", null);   //取得被注释的方法,AnnotationTest.class为该方法所在的类
MyRetention mr = method.getAnnotation(MyRetention.class); //取得注释对象
String value = mr.value();    //取得value的值,对应Bean的get方法.

@interface实际上是继承了java.lang.annotation.Annotation,所以定义annotation时不能继承其他annotation或interface.
java.lang.annotation.Retention告诉编译器如何对待 Annotation,使用Retention时,需要提供java.lang.annotation.RetentionPolicy的枚举值.

Java代码

public enum RetentionPolicy {
SOURCE, // 编译器处理完Annotation后不存储在class中
CLASS, // 编译器把Annotation存储在class中，这是默认值
RUNTIME // 编译器把Annotation存储在class中，可以由虚拟机读取,反射需要
}

public enum RetentionPolicy {
    SOURCE, // 编译器处理完Annotation后不存储在class中
    CLASS, // 编译器把Annotation存储在class中，这是默认值
    RUNTIME // 编译器把Annotation存储在class中，可以由虚拟机读取,反射需要
}

.
java.lang.annotation.Target告诉编译器Annotation使用在哪些地方,使用需要指定java.lang.annotation.ElementType的枚举值.

Java代码

public enum ElementType {
TYPE, // 指定适用点为 class, interface, enum
FIELD, // 指定适用点为 field
METHOD, // 指定适用点为 method
PARAMETER, // 指定适用点为 method 的 parameter
CONSTRUCTOR, // 指定适用点为 constructor
LOCAL_VARIABLE, // 指定使用点为局部变量
ANNOTATION_TYPE, //指定适用点为 annotation 类型
PACKAGE // 指定适用点为 package
}

public enum ElementType {
    TYPE, // 指定适用点为 class, interface, enum
    FIELD, // 指定适用点为 field
    METHOD, // 指定适用点为 method
    PARAMETER, // 指定适用点为 method 的 parameter
    CONSTRUCTOR, // 指定适用点为 constructor
    LOCAL_VARIABLE, // 指定使用点为 局部变量
    ANNOTATION_TYPE, //指定适用点为 annotation 类型
    PACKAGE // 指定适用点为 package
}

java.lang.annotation.Documented用于指定该Annotation是否可以写入javadoc中.
java.lang.annotation.Inherited用于指定该Annotation用于父类时是否能够被子类继承.
如

Java代码

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented //这个Annotation可以被写入javadoc
@Inherited //这个Annotation 可以被继承
@Target({ElementType.CONSTRUCTOR,ElementType.METHOD}) //表示这个Annotation只能用于注释构造子和方法
@Retention(RetentionPolicy.CLASS) //表示这个Annotation存入class但vm不读取
public @interface MyAnnotation {
String value() default "hahaha";
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented  //这个Annotation可以被写入javadoc
@Inherited       //这个Annotation 可以被继承
@Target({ElementType.CONSTRUCTOR,ElementType.METHOD}) //表示这个Annotation只能用于注释 构造子和方法
@Retention(RetentionPolicy.CLASS) //表示这个Annotation存入class但vm不读取
public @interface MyAnnotation {
	String value() default "hahaha";
}

java.lang.reflect.AnnotatedElement接口提供了四个方法来访问Annotation

Java代码

public Annotation getAnnotation(Class annotationType);
public Annotation[] getAnnotations();
public Annotation[] getDeclaredAnnotations();
public boolean isAnnotationPresent(Class annotationType);

public Annotation getAnnotation(Class annotationType);
public Annotation[] getAnnotations();
public Annotation[] getDeclaredAnnotations();
public boolean isAnnotationPresent(Class annotationType);

Class、Constructor、Field、Method、Package等都实现了该接口,可以通过这些方法访问Annotation信息,前提是要访问的Annotation指定Retention为RUNTIME.

    Java内置的annotation有Override Deprecated SuppressWarnings.
    Override只用于方法,它指明注释的方法重写父类的方法,如果不是,则编译器报错.
    Deprecated指明该方法不建议使用
    SuppressWarnings告诉编译器:我知道我的代码没问题,你不用吓我了,我不怕的^_^
    这些都是Mark Annotation,名称本身就包含了要提供的信息,不需要额外提供.

========

Annotation在java的世界正铺天盖地展开,有空写这一篇简单的annotations的文章,算是关于Annotation入门的文章吧,希望能各位们能抛砖,共同学习......
   不讲废话了,实践才是硬道理.

   第一部分:了解一下java1.5起默认的三个annotation类型:
   一个是@Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。
   一个是@Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上.
   一个是@SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭.
   如果不清楚上面三个类型的具体用法，各位可以baidu或google一下的,很简单的。

   第二部分:讲一下annotation的概念先，再来讲一下怎样设计自己的annotation.
   首先在jdk自带的java.lang.annotation包里,打开如下几个源文件:

   1、源文件Target.java

Java代码

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}

   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.ANNOTATION_TYPE)
   public @interface Target {
      ElementType[] value();
   }

   其中的@interface是一个关键字，在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字(会不会觉得sun有点吝啬,偏偏搞得与interface这么像).

   2、源文件Retention.java

Java代码

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
RetentionPolicy value();
}

   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.ANNOTATION_TYPE)
   public @interface Retention {
      RetentionPolicy value();
   }

   看到这里，大家可能都模糊了,都不知道在说什么，别急，往下看一下.
   在上面的文件都用到了RetentionPolicy，ElementType这两个字段,你可能就会猜到这是两个java文件.的确，这两个文件的源代码如下：

   3、源文件RetentionPolicy.java

Java代码

public enum RetentionPolicy {
SOURCE,
CLASS,
RUNTIME
}

    public enum RetentionPolicy {
     SOURCE,
     CLASS,
     RUNTIME
    }

   这是一个enum类型,共有三个值，分别是SOURCE,CLASS 和 RUNTIME.
   SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译之后，Annotation的数据就会消失,并不会保留在编译好的.class文件里面。
   ClASS的意思是这个Annotation类型的信息保留在程序源码里,同时也会保留在编译好的.class文件里面,在执行的时候，并不会把这一些信息加载到虚拟机(JVM)中去.注意一下，当你没有设定一个Annotation类型的Retention值时，系统默认值是CLASS.
   第三个,是RUNTIME,表示在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的．
　举一个例子，如@Override里面的Retention设为SOURCE,编译成功了就不要这一些检查的信息;相反,@Deprecated里面的Retention设为RUNTIME,表示除了在编译时会警告我们使用了哪个被Deprecated的方法,在执行的时候也可以查出该方法是否被Deprecated.

   4、源文件ElementType.java

Java代码

public enum ElementType {
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,
LOCAL_VARIABLE, ANNOTATION_TYPE,PACKAGE
}

   public enum ElementType {
    TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,
    LOCAL_VARIABLE, ANNOTATION_TYPE,PACKAGE
   }

   ＠Target里面的ElementType是用来指定Annotation类型可以用在哪一些元素上的.说明一下：TYPE(类型), FIELD(属性), METHOD(方法), PARAMETER(参数), CONSTRUCTOR(构造函数),LOCAL_VARIABLE(局部变量), ANNOTATION_TYPE,PACKAGE(包),其中的TYPE(类型)是指可以用在Class,Interface,Enum和Annotation类型上.
   另外,从1的源代码可以看出,@Target自己也用了自己来声明自己,只能用在ANNOTATION_TYPE之上.
   如果一个Annotation类型没有指明@Target使用在哪些元素上,那么它可以使用在任何元素之上,这里的元素指的是上面的八种类型.
   举几个正确的例子:
   @Target(ElementType.METHOD)
   @Target(value=ElementType.METHOD)
   @Target(ElementType.METHOD,ElementType.CONSTRUCTOR)
   具体参考一下javadoc文档

   上面一下1和2的源文件，它们都使用了@Documented,@Documented的目的就是让这一个Annotation类型的信息能够显示在javaAPI说明文档上;没有添加的话，使用javadoc生成API文档的时候就会找不到这一个类型生成的信息.
   另外一点，如果需要把Annotation的数据继承给子类，那么就会用到@Inherited这一个Annotation类型.

   第三部分:下面讲的设计一个最简单的Annotation例子,这一例子共用四个文件;
   1、Description.java

Java代码

package lighter.iteye.com;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Description {
String value();
}

   package lighter.iteye.com;

   import java.lang.annotation.Documented;
   import java.lang.annotation.ElementType;
   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   import java.lang.annotation.Target;

   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   public @interface Description {
       String value();
   }

   说明:所有的Annotation会自动继承java.lang.annotation这一个接口,所以不能再去继承别的类或是接口.
   最重要的一点,Annotation类型里面的参数该怎么设定:
   第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型.
   第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String.
   第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:上面的例子就只有一个参数成员.

   2、Name.java

Java代码

package lighter.iteye.com;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//注意这里的@Target与@Description里的不同,参数成员也不同
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Name {
String originate();
String community();
}

   package lighter.iteye.com;

   import java.lang.annotation.Documented;
   import java.lang.annotation.ElementType;
   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   import java.lang.annotation.Target;

    //注意这里的@Target与@Description里的不同,参数成员也不同
   @Target(ElementType.METHOD)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   public @interface Name {
       String originate();
       String community();
   }

3、JavaEyer.java

Java代码

package lighter.iteye.com;
@Description("javaeye,做最棒的软件开发交流社区")
public class JavaEyer {
@Name(originate="创始人:robbin",community="javaEye")
public String getName()
{
return null;
}
@Name(originate="创始人:江南白衣",community="springside")
public String getName2()
{
return "借用两位的id一用,写这一个例子,请见谅!";
}
}

package lighter.iteye.com;

@Description("javaeye,做最棒的软件开发交流社区")
public class JavaEyer {
	@Name(originate="创始人:robbin",community="javaEye")
	public String getName()
	{
		return null;
	}
	
	@Name(originate="创始人:江南白衣",community="springside")
	public String getName2()
	{
		return "借用两位的id一用,写这一个例子,请见谅!";
	}
}

4、最后，写一个可以运行提取JavaEyer信息的类TestAnnotation

Java代码

package lighter.iteye.com;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
public class TestAnnotation {
/**
* author lighter
* 说明:具体关天Annotation的API的用法请参见javaDoc文档
*/
public static void main(String[] args) throws Exception {
String CLASS_NAME = "lighter.iteye.com.JavaEyer";
Class test = Class.forName(CLASS_NAME);
Method[] method = test.getMethods();
boolean flag = test.isAnnotationPresent(Description.class);
if(flag)
{
Description des = (Description)test.getAnnotation(Description.class);
System.out.println("描述:"+des.value());
System.out.println("-----------------");
}
//把JavaEyer这一类有利用到@Name的全部方法保存到Set中去
Set<Method> set = new HashSet<Method>();
for(int i=0;i<method.length;i++)
{
boolean otherFlag = method[i].isAnnotationPresent(Name.class);
if(otherFlag) set.add(method[i]);
}
for(Method m: set)
{
Name name = m.getAnnotation(Name.class);
System.out.println(name.originate());
System.out.println("创建的社区:"+name.community());
}
}
}

 package lighter.iteye.com;

  import java.lang.reflect.Method;
  import java.util.HashSet;
  import java.util.Set;

  public class TestAnnotation {
	/**
	 * author lighter
	 * 说明:具体关天Annotation的API的用法请参见javaDoc文档
	 */
       public static void main(String[] args) throws Exception {
       String  CLASS_NAME = "lighter.iteye.com.JavaEyer";
       Class  test = Class.forName(CLASS_NAME);
       Method[] method = test.getMethods();
       boolean flag = test.isAnnotationPresent(Description.class);
        if(flag)
        {
        	Description des = (Description)test.getAnnotation(Description.class);
        	System.out.println("描述:"+des.value());
        	System.out.println("-----------------");
        }
        
        //把JavaEyer这一类有利用到@Name的全部方法保存到Set中去
        Set<Method> set = new HashSet<Method>();
        for(int i=0;i<method.length;i++)
        {
        	boolean otherFlag = method[i].isAnnotationPresent(Name.class);
        	if(otherFlag) set.add(method[i]);
        }
        for(Method m: set)
        {
        	Name name = m.getAnnotation(Name.class);
        	System.out.println(name.originate());
        	System.out.println("创建的社区:"+name.community());
        }
     }
}

    5、运行结果：
     描述:javaeye,做最棒的软件开发交流社区
     -----------------
    创始人:robbin
    创建的社区:javaEye
    创始人:江南白衣
     创建的社区:springside

这一篇文章写了两个小时有多啦，也算是一篇关于设计自定的Annotation的入门篇啦；另外，特在处声明，如果转载请注明出处：http://lighter.iteye.com。
参考资料:
1、http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
2、http://caterpillar.onlyfun.net/Gossip/
3、http://calvin.iteye.com/blog/33210

======================================

非常不错啊，照着做了一遍就成功了，非常易懂，但是有个疑问，如何控制一个annotation里的某些属性可以填可以不填？
难道都是必填？
[/quote]

不是必填的,我举一个例子,可以更清楚一些,在把上面的Name.java改为

java 代码

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Name {
String originate();
String community();
public enum CommunityNumber(LITTLE,ORDINARY,WELL)
CommunityNumber number() default CommunityNumber.WELL;
}

这里的default是这一个关键字,指定默认值.(在上面文章上没有说明,谢谢Norther的提醒)
所以你可以在JavaEyer类上的方法指定用
@Name(originate="创始人:robbin",community="javaEye")或
@Name(originate="创始人:robbin",community="javaEye",number=Name.CommunityNumber.WELL)均可
这里的number的属性就不是必填的
另外,在enum CommunityNumber中,不一定非得要enum类型,用其他的合法类型也可,这里只是举一个例子而已

========================

============================

基于Spring的注释的配置

<?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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-
2.5.xsd">

使用 @Autowired 注释

Spring 2.5 引入了 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。来看一下使用 @Autowired 进行成员变量自动注入的代码：

清单 6. 使用 @Autowired 注释的 Boss.java

package com.baobaotao;
import org.springframework.beans.factory.annotation.Autowired;

public class Boss {

@Autowired
private Car car;

@Autowired
private Office office;

…
}

Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析，所以要让 @Autowired 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。

清单 7. 让 @Autowired 注释工作起来

<?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-2.5.xsd">

<bean class="org.springframework.beans.factory.annotation.
        AutowiredAnnotationBeanPostProcessor"/>

<bean id="boss" class="com.baobaotao.Boss"/>

    <bean id="office" class="com.baobaotao.Office">
        <property name="officeNo" value="001"/>
    </bean>
    <bean id="car" class="com.baobaotao.Car" scope="singleton">
        <property name="brand" value=" 红旗 CA72"/>
        <property name="price" value="2000"/>
    </bean>
</beans>

这样，当 Spring 容器启动时，AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean，当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配（默认按类型匹配）的 Bean，并注入到对应的地方中去。

按照上面的配置，Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用 @Autowired 后，您大可将它们的 setter 方法（setCar() 和 setOffice()）从 Boss 中删除。

当然，您也可以通过 @Autowired 对方法或构造函数进行标注，来看下面的代码：

清单 8. 将 @Autowired 注释标注在 Setter 方法上

package com.baobaotao;

public class Boss {
private Car car;
private Office office;

     @Autowired
    public void setCar(Car car) {
        this.car = car;
    }

    @Autowired
    public void setOffice(Office office) {
        this.office = office;
    }
    …
}

这时，@Autowired 将查找被标注的方法的入参类型的 Bean，并调用方法自动注入这些 Bean。而下面的使用方法则对构造函数进行标注：

清单 9. 将 @Autowired 注释标注在构造函数上

package com.baobaotao;

public class Boss {
    private Car car;
    private Office office;

    @Autowired
    public Boss(Car car ,Office office){
        this.car = car;
        this.office = office ;
    }

    …
}

由于 Boss() 构造函数有两个入参，分别是 car 和 office，@Autowired 将分别寻找和它们类型匹配的 Bean，将它们作为 Boss(Car car ,Office office) 的入参来创建 Boss Bean。

当候选 Bean 数目不为 1 时的应对方法

在默认情况下使用 @Autowired 注释进行自动注入时，Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时，Spring 容器将抛出 BeanCreationException 异常，并指出必须至少拥有一个匹配的 Bean。我们可以来做一个实验：

清单 10. 候选 Bean 数目为 0 时

<?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-2.5.xsd ">

    <bean class="org.springframework.beans.factory.annotation.
        AutowiredAnnotationBeanPostProcessor"/>

由于 office Bean 被注释掉了，所以 Spring 容器中将没有类型为 Office 的 Bean 了，而 Boss 的 office 属性标注了 @Autowired，当启动 Spring 容器时，异常就产生了。

当不能确定 Spring 容器中一定拥有某个类的 Bean 时，可以在需要自动注入该类 Bean 的地方可以使用 @Autowired(required = false)，这等于告诉 Spring：在找不到匹配 Bean 时也不报错。来看一下具体的例子：

清单 11. 使用 @Autowired(required = false)

package com.baobaotao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;

public class Boss {

private Car car;
private Office office;

    @Autowired
    public void setCar(Car car) {
        this.car = car;
    }
    @Autowired(required = false)
    public void setOffice(Office office) {
        this.office = office;
    }
    …
}

当然，一般情况下，使用 @Autowired 的地方都是需要注入 Bean 的，使用了自动注入而又允许不注入的情况一般仅会在开发期或测试期碰到（如为了快速启动 Spring 容器，仅引入一些模块的 Spring 配置文件），所以 @Autowired(required = false) 会很少用到。

和找不到一个类型匹配 Bean 相反的一个错误是：如果 Spring 容器中拥有多个候选 Bean，Spring 容器在启动时也会抛出 BeanCreationException 异常。来看下面的例子：

清单 12. 在 beans.xml 中配置两个 Office 类型的 Bean

…
<bean id="office" class="com.baobaotao.Office">
    <property name="officeNo" value="001"/>
</bean>
<bean id="office2" class="com.baobaotao.Office">
    <property name="officeNo" value="001"/>
</bean>
…

我们在 Spring 容器中配置了两个类型为 Office 类型的 Bean，当对 Boss 的 office 成员变量进行自动注入时，Spring 容器将无法确定到底要用哪一个 Bean，因此异常发生了。

Spring 允许我们通过 @Qualifier 注释指定注入 Bean 的名称，这样歧义就消除了，可以通过下面的方法解决异常：

清单 13. 使用 @Qualifier 注释指定注入 Bean 的名称

@Autowired
public void setOffice(@Qualifier("office")Office office) {
this.office = office;
}

@Qualifier("office") 中的 office 是 Bean 的名称，所以 @Autowired 和 @Qualifier 结合使用时，自动注入的策略就从 byType 转变成 byName 了。@Autowired 可以对成员变量、方法以及构造函数进行注释，而 @Qualifier 的标注对象是成员变量、方法入参、构造函数入参。正是由于注释对象的不同，所以 Spring 不将 @Autowired 和 @Qualifier 统一成一个注释类。下面是对成员变量和构造函数入参进行注释的代码：

对成员变量进行注释：

清单 14. 对成员变量使用 @Qualifier 注释

public class Boss {
    @Autowired
    private Car car;

    @Autowired
    @Qualifier("office")
    private Office office;
    …
}

对构造函数入参进行注释：

清单 15. 对构造函数变量使用 @Qualifier 注释

public class Boss {
    private Car car;
    private Office office;

    @Autowired
    public Boss(Car car , @Qualifier("office")Office office){
        this.car = car;
        this.office = office ;
}
}

@Qualifier 只能和 @Autowired 结合使用，是对 @Autowired 有益的补充。一般来讲，@Qualifier 对方法签名中入参进行注释会降低代码的可读性，而对成员变量注释则相对好一些。

使用 JSR-250 的注释

Spring 不但支持自己定义的 @Autowired 的注释，还支持几个由 JSR-250 规范定义的注释，它们分别是 @Resource、@PostConstruct 以及 @PreDestroy。

@Resource

@Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，面 @Resource 默认按 byName 自动注入罢了。@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。

Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中，因此在使用之前必须将其加入到项目的类库中。来看一个使用 @Resource 的例子：

清单 16. 使用 @Resource 注释的 Boss.java

package com.baobaotao;

import javax.annotation.Resource;

public class Boss {
    // 自动注入类型为 Car 的 Bean
    @Resource
    private Car car;

    // 自动注入 bean 名称为 office 的 Bean
    @Resource(name = "office")
    private Office office;
}

一般情况下，我们无需使用类似于 @Resource(type=Car.class) 的注释方式，因为 Bean 的类型信息可以通过 Java 反射从代码中获取。

要让 JSR-250 的注释生效，除了在 Bean 类中标注这些注释外，还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor：

CommonAnnotationBeanPostProcessor 实现了 BeanPostProcessor 接口，它负责扫描使用了 JSR-250 注释的 Bean，并对它们进行相应的操作。

@PostConstruct 和 @PreDestroy

Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法，也可以通过 <bean> 元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法。关于 Spring 的生命周期，笔者在《精通 Spring 2.x—企业应用开发精解》第 3 章进行了详细的描述，有兴趣的读者可以查阅。

JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类，分别是 @PostConstruct 和 @PreDestroy，这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。

清单 17. 使用 @PostConstruct 和 @PreDestroy 注释的 Boss.java

package com.baobaotao;

import javax.annotation.Resource;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Boss {
@Resource
private Car car;

@Resource(name = "office")
private Office office;

    @PostConstruct
    public void postConstruct1(){
        System.out.println("postConstruct1");
    }

    @PreDestroy
    public void preDestroy1(){
        System.out.println("preDestroy1");
    }
    …
}

您只需要在方法前标注 @PostConstruct 或 @PreDestroy，这些方法就会在 Bean 初始化后或销毁之前被 Spring 容器执行了。

我们知道，不管是通过实现 InitializingBean/DisposableBean 接口，还是通过 <bean> 元素的 init-method/destroy-method 属性进行配置，都只能为 Bean 指定一个初始化 / 销毁的方法。但是使用 @PostConstruct 和 @PreDestroy 注释却可以指定多个初始化 / 销毁方法，那些被标注 @PostConstruct 或 @PreDestroy 注释的方法都会在初始化 / 销毁时被执行。

通过以下的测试代码，您将可以看到 Bean 的初始化 / 销毁方法是如何被执行的：

清单 18. 测试类代码

package com.baobaotao;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnoIoCTest {

    public static void main(String[] args) {
        String[] locations = {"beans.xml"};
        ClassPathXmlApplicationContext ctx =
            new ClassPathXmlApplicationContext(locations);
        Boss boss = (Boss) ctx.getBean("boss");
        System.out.println(boss);
        ctx.destroy();// 关闭 Spring 容器，以触发 Bean 销毁方法的执行
    }
}

这时，您将看到标注了 @PostConstruct 的 postConstruct1() 方法将在 Spring 容器启动时，创建 Boss Bean 的时候被触发执行，而标注了 @PreDestroy 注释的 preDestroy1() 方法将在 Spring 容器关闭前销毁 Boss Bean 的时候被触发执行。

使用 <context:annotation-config/> 简化配置

Spring 2.1 添加了一个新的 context 的 Schema 命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。

而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是 <context:annotation-config/>。请看下面的配置：

清单 19. 调整 beans.xml 配置文件

<?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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:annotation-config/>

<context:annotationconfig/> 将隐式地向 Spring 容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 以及 equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。

在配置文件中使用 context 命名空间之前，必须在 <beans> 元素中声明 context 命名空间。

使用 @Component

虽然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说，在 XML 配置文件中定义 Bean，通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？答案是肯定的，我们通过 Spring 2.5 提供的 @Component 注释就可以达到这个目标了。

下面，我们完全使用注释定义 Bean 并完成 Bean 之间装配：

清单 20. 使用 @Component 注释的 Car.java

package com.baobaotao;

import org.springframework.stereotype.Component;

@Component
public class Car {
…
}

仅需要在类定义处，使用 @Component 注释就可以将一个类定义了 Spring 容器中的 Bean。下面的代码将 Office 定义为一个 Bean：

清单 21. 使用 @Component 注释的 Office.java

package com.baobaotao;

import org.springframework.stereotype.Component;

@Component
public class Office {
private String officeNo = "001";
…
}

这样，我们就可以在 Boss 类中通过 @Autowired 注入前面定义的 Car 和 Office Bean 了。

清单 22. 使用 @Component 注释的 Boss.java

package com.baobaotao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Compone

分享到：

可重复使用文件保存 | MyEclipse中使用Hibernate时出现log4j:WA ...

2010-09-28 21:42
浏览 1878
评论(0)
分类:企业架构
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论