Java 注解（Annotation）概念及实战

摘要：

　　java注解：java 提供了一种源程序中的 元素 关联任何信息和任何元数据的途径和方法。

　　学习注解的目的：

• 能够读懂别人写的代码，特别是框架相关的代码
• 让编程更加简洁，代码更加清晰
• 让别人高看一眼，特别是会使用自定义注解

目录：

1. java中的常见注解

2. 注解分类

3. 自定义注解

4. 注解应用实践

1. java中的常见注解

1） JDK 自带的注解
　　@Override @Deprecated @SuppressWarnings
2） 常见的第三方注解
　　Spring @Autowired @Service @Repository
　　MyBatis @InsertProvider @UpdateProvider @Options

2. 注解分类

1） 按照运行机制分：源码注解、编译时注解（如jDK 自带的三个注解）、运行时注解（如@Autowired）
2） 按照来源来分：JDK的注解、第三方的注解、用户自定义的注解

3. 自定义注解

1） 自定义注解的语法要求

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

/*元注解*/

/*注解作用域的列表
CONSTRUCTOR     构造方法声明
FIELD           字段声明
LOCAL_VARIABLE  局部变量声明
METHOD          方法声明
PACKAGE         包声明
PARAMETER       参数声明
TYPE　　　　　　　类，接口*/
@Target({ ElementType.METHOD, ElementType.TYPE })

/*
 * 注解的生命周期 
 * SOURCE 自在源码中显示，编译时会丢弃 
 * CLASS 编译时会记录到class中，运行时忽略
 * RUNTIME运行时存在，可以通过反射读取
 */
@Retention(RetentionPolicy.RUNTIME)

/* 标识性元注解，允许子类继承父类的注解，只在类上有效，接口和方法无效 */
@Inherited

/* 标识性元注解，生成 javadoc 时会包含注解 */
@Documented

/* 使用 @interface 关键字定义注解 */
public @interface Description {

    /**
     * 成员类型是受限的，合法的类型包括原始类型及String,Class,Annotation,Enumeration
     * 如果注解只有一个成员，则成员名必须为 value(),在使用时可以忽略成员名和赋值号 
     * 注解类可以没有成员，没有成员的注解类成为标识注解
     */

     String deco(); //成员以无参无类型方式声明
      
     String author();
     
     int age() default 18; //可以用default为成员制定一个默认的值 
}

2） 元注解（注解的注解）

　　@Target

　　@Retention

　　@Inherited

　　@Documented

　　元注解，相当于是注解的注解，用来对注解的作用域、作用时期等进行解释声明（具体内容看上面的代码）。

3） 自定义注解的使用

　　@<注解名>(<成员名1>=<成员值1>,<成员名2>=<注解值2>,...)
例：
　　@Description(desc="I am eyeColor", author="Mooc Boy", age=18)
　　public String eyeColor() {
　　　return "red";
　　}

特殊情况：

　　标识注解：
　　@<注解名>
　　只有一个成员的注解：
　　@<注解名>(<成员值>)

4） 解析注解

　　通过反射获取类、函数或成员上的运行时注解信息，从而实现动态控制程序运行的逻辑。

　　在本例中，定义一个接口 Person，一个实现类 Child，一个自定义的解析类 Description 以及一个解析注解的测试类ParseAnn，通过此例可以看到解析注解的作用。

Person.java

public interface Person {
    public String name();
    
    public int age();
    
    @Deprecated  //表明该方法已经过时，可以使用，但不推荐使用
    public void sing();
}

Child.java

@Description("I am class annotation")
public class Child implements Person {

    @Override
    @Description("I am method annotation")
    public String name() {
        return null;
    }

    @Override
    public int age() {
        return 0;
    }

    @Override
    public void sing() {
        
    }
}

Description.java

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

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented

/* 使用 @interface 关键字定义注解 */
public @interface Description {
    String value();
}

ParseAnn.java

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class ParseAnn {

    public static void main(String[] args) {
        // 1.使用类加载器加载类
        try {
            Class c = Class.forName("com.ann.test.Child");
            // 2.找到类上面的注解
            boolean isExist = c.isAnnotationPresent(Description.class);
            if (isExist) {
                // 3.拿到注解实例
                Description d = (Description) c.getAnnotation(Description.class);
                System.out.println(d.value());
            }

            // 4.找到方法上的注解
            Method[] ms = c.getMethods();
            for (Method m : ms) {
                boolean isMExist = m.isAnnotationPresent(Description.class);
                if (isMExist) {
                    Description d = (Description) m.getAnnotation(Description.class);
                    System.out.println(d.value());
                }
            }

            // 另外一种解析方法
            for (Method m : ms) {
                Annotation[] as = m.getAnnotations();
                for (Annotation a : as) {
                    if (a instanceof Description) {
                        Description d = (Description) a;
                        System.out.println(d.value());
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

I am class annotation
I am method annotation
I am method annotation

4. 注解应用实践

需求：
　　1.有一个用户表，字段包括用户ID，用户名，昵称，年龄，性别，所在城市，邮箱，手机号。
　　2.方便的对每个字段或字段的组合条件进行检索，并打印出SQL。
　　3.使用方式要足够简单，见代码示例。

　　首先考虑代码如何与数据库进行一个映射，比如程序如何知道数据库的表名、字段名，这就可以用到注解，利用注解解析实现。

      每一个字段都有一个 get 方法，通过反射调用 get 方法来取得字段的值 getMethod.invoke()。

　　对于注解，特别是运行时注解，相当于在类、方法、字段等内容上套上一层“外衣”，可以根据“外衣”分类，找到相关内容，从而进行操作。
　　

　　java类：Filter.java 定义了字段内容，Test.java 测试类。

　　解析类：Table.java 表解析，Column.java 字段解析。

Table.java

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

Column.java

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

Filter.java

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }
    /*自动生成的get set 方法*/
}

Test.java

public class Test {

    public static void main(String[] args) {
        Filter f1 = new Filter();
        f1.setId(10);// 表示查询ID为10的用户

        Filter f2 = new Filter();
        f2.setUserName("lucy");// 查询用户名为lucy的用户
        f2.setAge(18);

        Filter f3 = new Filter();
        f3.setEmail("liu@sina.com,zh@163.com,123@qq.com");// 查询邮箱为其中任意一个的用户

        String sql1 = query(f1);
        String sql2 = query(f2);
        String sql3 = query(f3);

        System.out.println(sql1);
        System.out.println(sql2);
        System.out.println(sql3);
    }

    private static String query(Filter f) {
        StringBuilder sb = new StringBuilder();
        // 1.获取到class
        Class c = f.getClass();
        // 2.获取到Table的名字
        boolean exists = c.isAnnotationPresent(Table.class);
        if (!exists) {
            return null;
        }
        Table t = (Table) c.getAnnotation(Table.class);
        String tableName = t.value();
        sb.append("select * from ").append(tableName).append(" where 1=1");
        // 3.遍历所有的字段
        Field[] fArray = c.getDeclaredFields();
        for (Field field : fArray) {
            // 4.处理每个字段对应的sql
            // 4.1 拿到字段名
            boolean fExists = field.isAnnotationPresent(Column.class);
            if (!fExists) {
                continue; // 如果不是数据库的字段，不做处理
            }
            Column column = field.getAnnotation(Column.class);
            String columnName = column.value();
            // 4.2 拿到字段值
            String fieldName = field.getName();
            String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); // 利用字段名获取方法名
            Object fieldValue = null;
            try {
                Method getMethod = c.getMethod(getMethodName); // 利用方法名得到方法
                fieldValue = getMethod.invoke(f); // 反射调用方法
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 4.3 拼装sql
            if(fieldValue == null || (fieldValue instanceof Integer && (Integer)fieldValue == 0)) {
                continue;
            }
            sb.append(" and ").append(fieldName);
            if(fieldValue instanceof String) {
                if(((String) fieldValue).contains(",")) {
                    String[] values = ((String) fieldValue).split(",");
                    sb.append(" in (");
                    for (String string : values) {
                        sb.append("'").append(string).append("'").append(",");
                    }
                    sb.deleteCharAt(sb.length()-1);
                    sb.append(")");
                } else {
                    sb.append("=").append("'").append(fieldValue).append("'");
                }
            } else if(fieldValue instanceof Integer) {
                sb.append("=").append(fieldValue);
            }
        }
        return sb.toString();
    }
}

输出结果：

select * from user where 1=1 and id=10
select * from user where 1=1 and userName='lucy' and age=18
select * from user where 1=1 and email in ('liu@sina.com','zh@163.com','123@qq.com')

Eclipse快捷键：

shift + alt + s 调出有用命令，比如生成set get 方法。
ctrl + d 删除整行
ctrl + alt + down 复制整行