java 注解 详解

博客参考
http://www.open-open.com/lib/view/open1423558996951.html
以及慕课网

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。

Annotation(注解)是JDK1.5及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解、单值注解、完整注解三类。它们都不会直接影响到程序的语义，只是作为注解（标识）存在，我们可以通过反射机制编程实现对这些元数据（用来描述数据的数据）的访问。另外，你可以在编译时选择代码里的注解是否只存在于源代码级，或者它也能在class文件、或者运行时中出现（SOURCE/CLASS/RUNTIME）。

在定义Annotation时，也可以使用JDK提供的元注解来修饰Annotation定义。JDK提供了如下4个元注解（注解的注解，不是上述的”元数据Annotation“）：

@Retention

@Target

@Documented

@Inherited

@Retention用于指定Annotation可以保留多长时间。

@Retention包含一个名为“value”的成员变量，该value成员变量是RetentionPolicy枚举类型。使用@Retention时，必须为其value指定值。value成员变量的值只能是如下3个：

RetentionPolicy.SOURCE：Annotation只保留在源代码中，编译器编译时，直接丢弃这种Annotation。

RetentionPolicy.CLASS：编译器把Annotation记录在class文件中。当运行Java程序时，JVM中不再保留该Annotation。

RetentionPolicy.RUNTIME：编译器把Annotation记录在class文件中。当运行Java程序时，JVM会保留该Annotation，程序可以通过反射获取该Annotation的信息。

如果Annotation里有一个名为“value“的成员变量，使用该Annotation时，可以直接使用XXX(val)形式为value成员变量赋值，无须使用name=val形式。

@Target指定Annotation用于修饰哪些程序元素。@Target也包含一个名为”value“的成员变量，该value成员变量类型为ElementType[ ]，ElementType为枚举类型，值有如下几个：

ElementType.TYPE：能修饰类、接口或枚举类型

ElementType.FIELD：能修饰成员变量

ElementType.METHOD：能修饰方法

ElementType.PARAMETER：能修饰参数

ElementType.CONSTRUCTOR：能修饰构造器

ElementType.LOCAL_VARIABLE：能修饰局部变量

ElementType.ANNOTATION_TYPE：能修饰注解

ElementType.PACKAGE：能修饰包

@Documented

如果定义注解A时，使用了@Documented修饰定义，则在用javadoc命令生成API文档后，所有使用注解A修饰的程序元素，将会包含注解A的说明。

@Inherited指定Annotation具有继承性。

基本Annotation

JDK默认提供了如下几个基本Annotation：

@Override 

限定重写父类方法。对于子类中被@Override 修饰的方法，如果存在对应的被重写的父类方法，则正确；如果不存在，则报错。@Override 只能作用于方法，不能作用于其他程序元素。

@Deprecated

用于表示某个程序元素（类、方法等）已过时。如果使用被@Deprecated修饰的类或方法等，编译器会发出警告。

@SuppressWarning

抑制编译器警告。指示被@SuppressWarning修饰的程序元素（以及该程序元素中的所有子元素，例如类以及该类中的方法.....）取消显示指定的编译器警告。例如，常见的@SuppressWarning（value="unchecked"）

@SafeVarargs

@SafeVarargs是JDK 7 专门为抑制“堆污染”警告提供的。

提取Annotation信息（反射）

当开发者使用了Annotation修饰了类、方法、Field等成员之后，这些Annotation不会自己生效，必须由开发者提供相应的代码来提取并处理Annotation信息。这些处理提取和处理Annotation的代码统称为APT（Annotation Processing Tool）。

JDK主要提供了两个类，来完成Annotation的提取：

java.lang.annotation.Annotation接口：这个接口是所有Annotation类型的父接口（后面会分析Annotation的本质，Annotation本质是接口，而java.lang.annotation.Annotation接口是这些接口的父接口）。

java.lang.reflect.AnnotatedElement接口：该接口代表程序中可以被注解的程序元素。

实例：

数据库注解实现实例

定义列注解

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

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String value();
}

定义表明注解

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

bean类

@Table("department")
public class Department {
@Column("id")
private int id;
@Column("name")
private String name;
@Column("leader")
private String deader;
@Column("num")
private int num;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDeader() {
return deader;
}
public void setDeader(String deader) {
this.deader = deader;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}

@Table("user")
public class User {
@Column("id")
private int id;
@Column("user_name")
private String userName;
@Column("nick_name")
private String nickName;
@Column("age")
private int age;
@Column("city")
private String city;
@Column("email")
private String email;

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}

}

注解解析

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
User f1 = new User();
f1.setId(10);

User f2 = new User();
f2.setUserName("luck");

User f3 = new User();
f3.setEmail("xxx,zzzzz,vvvv");

query(f1);
query(f2);
query(f3);

Department d = new Department();
d.setId(222);
query(d);
}

private static void query(Object f)
{
StringBuilder sb = new StringBuilder();

//获取class
Class c = f.getClass();
//获取table名字
boolean exists = c.isAnnotationPresent(Table.class);
if(!exists)
{
return;
}

Table t = (Table) c.getAnnotation(Table.class);
String tableName = t.value();
sb.append("select * from ").append(tableName).append(" where 1=1");

//遍历所有的字段
Field[] fArray = c.getDeclaredFields();

for(Field field : fArray)
{
//处理每个字段对应的sql
//拿到字段名
boolean fExists = field.isAnnotationPresent(Column.class);
if(!fExists)
{
continue;
}
Column column = field.getAnnotation(Column.class);
String columnName = column.value();

//拿到字段的值
String fieldName = field.getName();
String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
Object fieldValue = "";
try {
Method getMethod = c.getMethod(getMethodName);
fieldValue = getMethod.invoke(f);

} catch (Exception e) {
e.printStackTrace();
}

//拼sql
if(fieldValue == null ||
(fieldValue instanceof Integer && (Integer)fieldValue == 0))
{
continue;
}
sb.append(" and ").append(columnName);
if(fieldValue instanceof String)
{
if(((String) fieldValue).contains(","))
{
String[] values = ((String) fieldValue).split(",");
sb.append(" in(");
for(String v : values)
{
sb.append("'").append(v).append("',");
}
sb.deleteCharAt(sb.length()-1);
sb.append(")");
}
else
{
sb.append("='").append(fieldValue).append("'");
}
}else if(fieldValue instanceof Integer)
{
sb.append("=").append(fieldValue);
}
}

System.out.println(sb);
}

}