# 注解编程

## 注解

注解是JDK 1.5之后引入的一个语言特性，一般用于对类，方法，属性的修饰。主要的目的在于简化java中的配置，用注解代替配置。 下面是几个Java底层内置的几个注解

* @Override: 只适用于方法，表示重写父类中的方法
* @Deprecated: 表示某各类或方法已过时
* @SuppressWarnings: 抑制编译器的警告

## 元注解

所谓元注解就是用于修饰注解的注解 **@Target**：指定注解使用的位置，@Target 中有一个 ElementType 数组，因此被 @Target 注解修饰的注解可以在多个位置上使用。下面是 ElementType 枚举中的一些属性（只列举一些常用的属性）

* TYPE：能在类、接口（包含注解类型）和枚举类型上使用
* FIELD：只能在属性上使用
* METHOD：只能在方法上使用

**@Retention**：用于表示该注解可以保留的作用域，@Retention 注解包含一个 RetentionPolicy 属性，通过这个属性来设置注解的保留域。RetentionPolicy 是一个枚举，其中有 3 个属性，如下

* SOURCE：只在源代码中显示，在编译成 .class 文件的时候会被丢弃
* CLASS：编译器会把注解记录在 .class 文件中，当程序运行时，虚拟机不会保留该注解
* RUNTIME：当程序运行时，也会被保留，因此可以通过反射技术获取该类型注解中的一些信息

**@Documented**：被该注解修饰的类可以使用 javadoc 工具生成文档，这里就不演示了

**@Inherited**：如果子类继承了被 Inherited 修饰的注解，则子类也自动拥有父类中的注解

### 举个栗子

```java
package java.lang;

import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;

/**
 * A program element annotated &#64;Deprecated is one that programmers
 * are discouraged from using, typically because it is dangerous,
 * or because a better alternative exists.  Compilers warn when a
 * deprecated program element is used or overridden in non-deprecated code.
 *
 * @author  Neal Gafter
 * @since 1.5
 * @jls 9.6.3.6 @Deprecated
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
```

上面是Deprecated注解的实现，几个元注解的实际含义如下：

* 表示可以被生成文档
* 在程序运行时也会被保留
* 可以使用在构造器，属性，方法，类或接口，包上等

## 注解编程

注解编程其实就是使用注解的特性进行编程的一个技巧，主要包含两个核心点：注解的定义，反射判断 注解的定义就是定义自己需要使用的注解 反射判断表示在适当的实际反射获取注解的值进行相应逻辑的处理

### 举个栗子

写一个通过注解自动生成SQL查询语句的例子

```java
[src/anotations/Table.java]

package anotaions;

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)
public @interface Table {
    String value();
}
```

```java
[src/anotations/Column.java]

package anotaions;

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();
}
```

```java
[src/Student.java]

import anotaions.Column;
import anotaions.Table;

@Table("student")
public class Student {
    @Column("id")
    private int id;
    @Column("user_name")
    private String username;
    @Column("age")
    private int age;
    @Column("city")
    private String city;
    @Column("phone")
    private String phone;

    public int getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    public String getPhone() {
        return phone;
    }

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

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}
```

```java
[src/DBDriver.java]

import anotaions.Column;
import anotaions.Table;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class DBDriver {
    public static String query(Student student) throws Exception {
        StringBuilder sb = new StringBuilder();
        Class<?> clazz = student.getClass();
        boolean tableAnnoExits = clazz.isAnnotationPresent(Table.class);
        // 判断 class 对象上是否有 @Table 注解
        if (!tableAnnoExits) {
            return null;
        }
        // 获取 @Table 注解中的表名，拼接 SQl
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.value();
        sb.append("SELECT * FROM " + tableName + " WHERE 1 = 1");

        // 获取 class 对象中的所有字段并遍历
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            boolean fieldAnnoExits = field.isAnnotationPresent(Column.class);
            // 判断字段上是否含有 @Column 注解
            if (!fieldAnnoExits) {
                continue;
            }
            // 获取注解中的字段名
            Column column = field.getAnnotation(Column.class);
            String columnName = column.value();
            // 通过 get() 方法获取传入的字段值
            String fieldName = field.getName();
            String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
                    + fieldName.substring(1);
            Method method = clazz.getMethod(getMethodName);
            Object fieldValue = method.invoke(student);

            if (fieldValue == null
                    || (fieldValue instanceof Integer && (Integer)fieldValue == 0)) {
                continue;
            }
            // 接着拼接 SQL 语句
            sb.append(" AND ").append(columnName).append(" = ");
            if (fieldValue instanceof String) {
                sb.append("'").append(fieldValue).append("'");
            } else if (fieldValue instanceof Integer) {
                sb.append(fieldValue);
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        Student student1 = new Student();
        student1.setUsername("张三");
        student1.setAge(18);
        student1.setCity("hangzhou");
        String s1 = query(student1);
        System.out.println(s1);

        Student student2 = new Student();
        student2.setUsername("李四");
        student2.setPhone("12345678977");
        String s2 = query(student2);
        System.out.println(s2);
    }
}
```

### 结果

![结果](https://1819138102-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MM7mD6Z7_ShtqqizKx0%2Fsync%2F6dcc0851dbbb3421d737ce48533e80f30a7fea3a.png?generation=1605391584262687\&alt=media)
