全面剖析java中的注解（Annotation）

更新時(shí)間：2019年04月02日 15:21:10 作者：HDWK

一個(gè)詞就可以描述注解，那就是元數(shù)據(jù)，即一種描述數(shù)據(jù)的數(shù)據(jù)。所以，可以說注解就是源代碼的元數(shù)據(jù)。文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

1.什么是注解

用一個(gè)詞就可以描述注解，那就是元數(shù)據(jù)，即一種描述數(shù)據(jù)的數(shù)據(jù)。所以，可以說注解就是源代碼的元數(shù)據(jù)。比如，下面這段代碼：

@Override
public String toString() {
 return "This is String Representation of current object.";
}

上面的代碼中，我重寫了toString()方法并使用了@Override注解。但是，即使我不使用@Override注解標(biāo)記代碼，程序也能夠正常執(zhí)行。那么，該注解表示什么？這么寫有什么好處嗎？事實(shí)上，@Override告訴編譯器這個(gè)方法是一個(gè)重寫方法(描述方法的元數(shù)據(jù))，如果父類中不存在該方法，編譯器便會(huì)報(bào)錯(cuò)，提示該方法沒有重寫父類中的方法。如果我不小心拼寫錯(cuò)誤，例如將toString()寫成了toStrring(){double r}，而且我也沒有使用@Override注解，那程序依然能編譯運(yùn)行。但運(yùn)行結(jié)果會(huì)和我期望的大不相同?，F(xiàn)在我們了解了什么是注解，并且使用注解有助于閱讀程序。

Annotation是一種應(yīng)用于類、方法、參數(shù)、變量、構(gòu)造器及包聲明中的特殊修飾符。它是一種由JSR-175標(biāo)準(zhǔn)選擇用來描述元數(shù)據(jù)的一種工具。

2.為什么要使用注解

使用Annotation之前(甚至在使用之后)，XML被廣泛的應(yīng)用于描述元數(shù)據(jù)。不知何時(shí)開始一些應(yīng)用開發(fā)人員和架構(gòu)師發(fā)現(xiàn)XML的維護(hù)越來越糟糕了。他們希望使用一些和代碼緊耦合的東西，而不是像XML那樣和代碼是松耦合的(在某些情況下甚至是完全分離的)代碼描述。

假如你想為應(yīng)用設(shè)置很多的常量或參數(shù)，這種情況下，XML是一個(gè)很好的選擇，因?yàn)樗粫?huì)同特定的代碼相連。如果你想把某個(gè)方法聲明為服務(wù)，那么使用Annotation會(huì)更好一些，因?yàn)檫@種情況下需要注解和方法緊密耦合起來，開發(fā)人員也必須認(rèn)識(shí)到這點(diǎn)。

另一個(gè)很重要的因素是Annotation定義了一種標(biāo)準(zhǔn)的描述元數(shù)據(jù)的方式。在這之前，開發(fā)人員通常使用他們自己的方式定義元數(shù)據(jù)。例如，使用標(biāo)記interfaces，注釋，transient關(guān)鍵字等等。每個(gè)程序員按照自己的方式定義元數(shù)據(jù)，而不像Annotation這種標(biāo)準(zhǔn)的方式。

3.基本語(yǔ)法

編寫Annotation非常簡(jiǎn)單，可以將Annotation的定義同接口的定義進(jìn)行比較。我們來看兩個(gè)例子：一個(gè)是標(biāo)準(zhǔn)的注解@Override，另一個(gè)是用戶自定義注解@Todo。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

對(duì)于@Override注釋你可能有些疑問，它什么都沒做，那它是如何檢查在父類中有一個(gè)同名的函數(shù)呢。當(dāng)然，不要驚訝，我是逗你玩的。@Override注解的定義不僅僅只有這么一點(diǎn)代碼。這部分內(nèi)容很重要，我不得不再次重復(fù)：Annotations僅僅是元數(shù)據(jù)，和業(yè)務(wù)邏輯無關(guān)。理解起來有點(diǎn)困難，但就是這樣。如果Annotations不包含業(yè)務(wù)邏輯，那么必須有人來實(shí)現(xiàn)這些邏輯。元數(shù)據(jù)的用戶來做這個(gè)事情。Annotations僅僅提供它定義的屬性(類/方法/包/域)的信息。Annotations的用戶(同樣是一些代碼)來讀取這些信息并實(shí)現(xiàn)必要的邏輯。

當(dāng)我們使用Java的標(biāo)注Annotations(例如@Override)時(shí)，JVM就是一個(gè)用戶，它在字節(jié)碼層面工作。到這里，應(yīng)用開發(fā)人員還不能控制也不能使用自定義的注解。因此，我們講解一下如何編寫自定義的Annotations。

我們來逐個(gè)講述編寫自定義Annotations的要點(diǎn)。上面的例子中，你看到一些注解應(yīng)用在注解上。

3.1 四種基本元注解

J2SE5.0版本在 java.lang.annotation提供了四種元注解，專門注解其他的注解：
@Documented –注解是否將包含在JavaDoc中
@Retention –什么時(shí)候使用該注解
@Target? –注解用于什么地方
@Inherited – 是否允許子類繼承該注解

@Documented–一個(gè)簡(jiǎn)單的Annotations標(biāo)記注解，表示是否將注解信息添加在java文檔中。

@Retention– 定義該注解的生命周期。
RetentionPolicy.SOURCE – 在編譯階段丟棄。這些注解在編譯結(jié)束之后就不再有任何意義，所以它們不會(huì)寫入字節(jié)碼。@Override, @SuppressWarnings都屬于這類注解。
RetentionPolicy.CLASS – 在類加載的時(shí)候丟棄。在字節(jié)碼文件的處理中有用。注解默認(rèn)使用這種方式。
RetentionPolicy.RUNTIME– 始終不會(huì)丟棄，運(yùn)行期也保留該注解，因此可以使用反射機(jī)制讀取該注解的信息。我們自定義的注解通常使用這種方式。

@Target – 表示該注解用于什么地方。如果不明確指出，該注解可以放在任何地方。以下是一些可用的參數(shù)。需要說明的是：屬性的注解是兼容的，如果你想給7個(gè)屬性都添加注解，僅僅排除一個(gè)屬性，那么你需要在定義target包含所有的屬性。
ElementType.TYPE:用于描述類、接口或enum聲明
ElementType.FIELD:用于描述實(shí)例變量
ElementType.METHOD
ElementType.PARAMETER
ElementType.CONSTRUCTOR
ElementType.LOCAL_VARIABLE
ElementType.ANNOTATION_TYPE 另一個(gè)注釋
ElementType.PACKAGE 用于記錄java文件的package信息

@Inherited – 定義該注釋和子類的關(guān)系

那么，注解的內(nèi)部到底是如何定義的呢？Annotations只支持基本類型、String及枚舉類型。注釋中所有的屬性被定義成方法，并允許提供默認(rèn)值。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Todo {
 public enum Priority {LOW, MEDIUM, HIGH}
 public enum Status {STARTED, NOT_STARTED}
 String author() default "Yash";
 Priority priority() default Priority.LOW;
 Status status() default Status.NOT_STARTED;
}

下面的例子演示了如何使用上面的注解。

@Todo(priority = Todo.Priority.MEDIUM, author = "Yashwant", status = Todo.Status.STARTED)
public void incompleteMethod1() {
//Some business logic is written
//But it's not complete yet
}

如果注解中只有一個(gè)屬性，可以直接命名為“value”，使用時(shí)無需再標(biāo)明屬性名。

@interface Author{
String value();
}
@Author("Yashwant")
public void someMethod() {
}

3.2 重復(fù)注解

在Java8以前，同一個(gè)程序元素前只能使用一個(gè)相同類型的Annotation;如果需要在同一個(gè)元素前使用多個(gè)類型相同的Annotation,則必須使用Annotation“容器”。
下面先介紹這種“容器”,
首先定義個(gè)MyTag注解：

//指定注解保留到運(yùn)行時(shí)
@Retention(RetentionPolicy.RUNTIME)
//指定注解可以修飾類、接口、枚舉
@Target(ElementType.TYPE)
@interface MyTag
{
 String name() default "測(cè)試";
 int age() default 20;
}

然后再定義MyTag注解的容器注解：

//指定注解保留到運(yùn)行時(shí)
@Retention(RetentionPolicy.RUNTIME)
//指定注解可以修飾類、接口、枚舉
@Target(ElementType.TYPE)
@interface MyTags
{
 MyTag[] value();
}

然后就可以按照如下的方式來使用注解了

@MyTags({
 @MyTag(name="測(cè)試1",age=21),
 @MyTag(name="測(cè)試2",age=22)
})
public class Test {
 public static void main(String[] args)
 {
 //通過反射解析注解
 Class testClass= Test.class;
 //獲得MyTags注解
 MyTags myTagsAnnotation= (MyTags) testClass.getAnnotation(MyTags.class);
 //獲得添加到里面的MyTag注解
 MyTag[] myTags=myTagsAnnotation.value();
 for(MyTag myTag : myTags)
 {
 System.out.println(String.format("name:%1$s,age:%2$d",myTag.name(),myTag.age()));
 }
 }
}

打?。?br /> name:測(cè)試1,age:21
name:測(cè)試2,age:22

java8為上面這種繁瑣的語(yǔ)法提供了糖語(yǔ)法，在java8中新增加了@Repeatable元注解，只需要在MyTag注解上添加上元注解@Repeatable(MyTags.class)。
觀察可以發(fā)現(xiàn)，@Repeatable依然需要依賴容器注解，所以依然可以按照如下的方式來使用：

@MyTags({
 @MyTag(name="測(cè)試1",age=21),
 @MyTag(name="測(cè)試2",age=22)
})

又因?yàn)镸yTag是重復(fù)注解，所以還可以像如下這樣使用：

@MyTag(name="測(cè)試1",age=21)
@MyTag(name="測(cè)試2",age=22)

這里需要注意，重復(fù)注解只是一種簡(jiǎn)便寫法，多個(gè)重復(fù)注解其實(shí)會(huì)被作為“容器”注解的value成員變量的數(shù)組元素。例如上面重復(fù)的MyTag注解會(huì)被作為@MyTags注解的value成員變量的數(shù)組元素處理。

4.使用注解

現(xiàn)在我們已經(jīng)知道了可以通過使用@Retention注解來指定注解的生存周期，注解的生存周期有三種，分別為：RetentionPolicy.SOURCE,RetentionPolicy.CLASS,RetentionPolicy.RUNTIME,這三個(gè)值分別表示注解的生存周期為源代碼，字節(jié)碼，運(yùn)行時(shí)中。

接下來介紹注解在不同階段中的處理：

4.1 運(yùn)行時(shí)處理的注解

其實(shí)在上面的案例中，已經(jīng)展示了如何使用反射獲取注解的數(shù)據(jù)。如果要在程序運(yùn)行時(shí)處理注解，那么必須將注解的聲明周期聲明為： @Retention(RetentionPolicy.RUNTIME) 。
由于注解本身是不包含任何業(yè)務(wù)邏輯的，在運(yùn)行時(shí)中，我們就可以通過反射來實(shí)現(xiàn)具體的邏輯，
先定義一個(gè)Debug注解：

//指定注解保留到運(yùn)行時(shí)
@Retention(RetentionPolicy.RUNTIME)
//指定該注解只能用于方法
@Target(ElementType.METHOD)
@interface Debug
{
 boolean value() default false;
}

接下來將該注解和具體的業(yè)務(wù)邏輯關(guān)聯(lián)起來：

public class DebugTest {
 public static void main(String[] args) {
 Class debugTestClass = DebugTest.class;
 //獲得所有的方法
 Method[] methods = debugTestClass.getMethods();
 for (Method method : methods) {
 method.setAccessible(true);//禁用安全機(jī)制
 if (method.isAnnotationPresent(Debug.class)) {//檢查是否使用了Debug注解
 Debug debug = method.getAnnotation(Debug.class);//獲得注解實(shí)例
 String name = method.getName();//獲得方法名稱
 if (debug.value()) {
  System.out.println("method:" + name + " should debug");
 } else {
  System.out.println("method:" + name + " should't debug");
 }
 }
 }
 }
 @Debug(false)
 public void testMethod1() {
 }
 @Debug(true)
 public void testMethod2() {
 }
 @Debug(true)
 public void testMethod3() {
 }
 @Debug(false)
 public void testMethod4() {
 }
 @Debug(true)
 public void testMethod5() {
 }
}

4.2 編譯時(shí)處理的注解

若是編譯時(shí)需要處理的注解，那么可以把注解的聲明周期聲明為： @Retention(RetentionPolicy.SOURCE) 。

在這里需要先介紹一下APT，API(Annotation Processing Tool)是一種注解處理工具，他對(duì)源代碼進(jìn)行檢測(cè)，并找出源代碼所包含的Annotation信息，然后針對(duì)Annotation信息進(jìn)行額外的處理。使用APT工具處理Annotation時(shí)可以根據(jù)源文件中的Annotation生成額外的源文件和其他的文件(文件的具體內(nèi)容由Annotation處理器的編寫者決定)，APT還會(huì)將編譯生成的源代碼文件和原來的源文件一起生成Class文件。

使用APT的主要目的是為了簡(jiǎn)化開發(fā)者的工作量，因?yàn)锳PT可以在編譯程序源代碼的同時(shí)生成一些附屬文件（比如源文件、類文件、程序發(fā)布描述文件等），這些附屬文件的內(nèi)容也都與源代碼相關(guān)。換句話說，使用APT可以代替?zhèn)鹘y(tǒng)的對(duì)代碼信息和附屬文件的維護(hù)工具。

Java提供的javac.exe工具有一個(gè)-processor選項(xiàng)，該選項(xiàng)可指定一個(gè)Annotation處理器，如果在編譯java源文件時(shí)指定了該Annotation處理器，那么這個(gè)Annotation處理器將會(huì)在編譯時(shí)提取并處理Java源文件中的Annotaion.
每一個(gè)Annoataion處理器都需要實(shí)現(xiàn)javax.annotataion.processor包下的Processor接口，不過實(shí)現(xiàn)該接口必須實(shí)現(xiàn)該接口下的所有的方法，因此通常會(huì)采用繼承AbstractProcessor的方式來實(shí)現(xiàn)Annotation的處理器。一個(gè)Annotation處理器可以處理一個(gè)或多個(gè)Annotaion注解。

在Hibernate中，如果使用非注解的方式，那么每寫一個(gè)Java Bean類文件，還必須額外地維護(hù)一個(gè)Hibernate映射文件(名為*.hbm.xml的文件)，下面將使用APT來簡(jiǎn)化這步操作。

為了示范使用APT根據(jù)源文件中的注解來生成額外的文件，下面定義3種注解。
標(biāo)識(shí)持久化類的@Persistent 注解：

//指定該注解可以修飾類，接口，枚舉
@Target(ElementType.TYPE)
//指定該注解保留到編譯時(shí)
@Retention(RetentionPolicy.SOURCE)
//指定該注解可以被顯示在文檔中(通過javadoc生成文檔，便可以在被該注解修飾的元素上看到該注解信息)
@Documented
public @interface Persistent {
 String table();
}

標(biāo)識(shí)屬性的@Id 注解：

//指定該注解只能修飾字段
@Target(ElementType.FIELD)
//指定該注解保留到編譯時(shí)
@Retention(RetentionPolicy.SOURCE)
//指定該注解可以被顯示在文檔中(通過javadoc生成文檔，便可以在被該注解修飾的元素上看到該注解信息)
@Documented
public @interface Id {
 String column();
 String type();
 String generator();
}

標(biāo)識(shí)屬性的@Property 注解

//指定該注解只能修飾字段
@Target(ElementType.FIELD)
//指定該注解保留到編譯時(shí)
@Retention(RetentionPolicy.SOURCE)
//指定該注解可以被顯示在文檔中(通過javadoc生成文檔，便可以在被該注解修飾的元素上看到該注解信息)
@Documented
public @interface Property {
 String column();
 String type();
}

在有了三個(gè)Annotation后，我們定義一個(gè)簡(jiǎn)單的Java Bean類Person.java.

@Persistent(table="personInfo")
public class Person {
 @Id(column="person_id",type="integer",generator="identity")
 private int id;
 @Property(column="person_name",type="string")
 private String name;
 @Property(column="person_age",type="integer")
 private int age;
 
 public Person(){}
 
 public Person(int id,String name,int age)
 {
 this.id=id;
 this.name=name;
 this.age=age;
 }
 //所有屬性的setter和getter.....
}

接下來寫一個(gè)API工具，該API工具是根據(jù)java類中的注解來生成一個(gè)Hibernate 映射文件。

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.Name;
import javax.lang.model.element.TypeElement;

//指定該注解支持java平臺(tái)的最新版本為6.0
@SupportedSourceVersion(SourceVersion.RELEASE_6)
//指定可以處理Persistent,id,Property注解
@SupportedAnnotationTypes({"Persistent","Id","Property"})
public class HibernateAnnotationProcessor extends AbstractProcessor{
 @Override
 public boolean process(Set<? extends TypeElement> annotations,
 RoundEnvironment roundEnv) {
 //定義文件輸出流,用于生成額外的文件
 PrintStream ps=null;
 try{
 for(Element t:roundEnv.getElementsAnnotatedWith(Persistent.class)){
 //獲取正在處理的類名稱
 Name className=t.getSimpleName();
 //獲得類定義前的@Persistent Annotation
 Persistent per= t.getAnnotation(Persistent.class);
 //創(chuàng)建文件輸出流
 ps=new PrintStream(new FileOutputStream(new File(className+".hbm.xml")));
 //執(zhí)行輸出
 ps.println("<?xml version=\"1.0\"?>");
 ps.println("<!DOCTYPE hibernate-mapping PUBLIC \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\"");
 ps.println("\"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">");
 ps.println("<hibernate-mapping>");
 ps.println("<class name=\""+className+"\" table=\""+per.table()+"\" >");
 for(Element f:t.getEnclosedElements())
 {
  //只處理成員變量上的Annotation
  if(f.getKind()==ElementKind.FIELD)
  {
  //獲取成員變量定義前的@Id Annotation
  Id id=f.getAnnotation(Id.class);
  //但@id注解存在時(shí)，輸出<id ../>元素
  if(id!=null)
  {
  ps.println("<id name=\""+f.getSimpleName()+"\" "+
   "column=\""+id.column()+"\" "+
   "type=\""+id.type()+"\">");
  ps.println("<generator class=\""+id.generator()+"\" />");
  ps.println("</id>");
  continue;
  }
  //獲取成員變量前的@Property Annotation
  Property p=f.getAnnotation(Property.class);
  if(p!=null)
  {
  ps.println("<property name=\""+f.getSimpleName()+"\" "+
   "column=\""+p.column()+"\" "+
   "type=\""+p.type()+"\" />");
  continue;
  }
  }
 }
 ps.println("</class>");
 ps.println("</hibernate-mapping>");
 }
 }catch(Exception e)
 {
 e.printStackTrace();
 }finally{
 if(ps!=null)
 ps.close();
 }
 return true;
 }
}

在編譯完HibernateAnnotationProcessor.java后執(zhí)行如下的命令：

javac -processor HibernateAnnotationProcessor Person.java

就可以看到在該路徑下多了一個(gè)Person.cfg.xml文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="Person" table="personInfo" >
<id name="id" column="person_id" type="integer">
<generator class="identity" />
</id>
<property name="name" column="person_name" type="string" />
<property name="age" column="person_age" type="integer" />
</class>
</hibernate-mapping>

您可能感興趣的文章: