java自定义注解（由潜到深）带完整的示例代码

一、定义自定义注解

Java 中的自定义注解是一种元数据，可以为程序中的类、方法、字段等元素添加额外的信息。自定义注解可以用于标记和约束程序中的元素，增强程序的可读性和可维护性。在 Java 中，自定义注解使用 @interface 关键字来定义，注解中可以包含成员变量和方法等元素。下面是一个简单的示例：

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

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

在上面的示例中，我们定义了一个注解 MyAnnotation，使用了 @Retention 注解来指定该注解应该在运行时保留。注解中只包含了一个成员变量 value，该成员变量的类型为字符串，表示注解的值。当使用该注解时，可以通过 value 属性来指定注解的值，例如：

@MyAnnotation(value = "Hello World")
public class MyClass {
    // ...
}

在上面的示例中，我们在类声明上使用了 @MyAnnotation 注解，并指定了注解的值为 Hello World。使用自定义注解的时候，需要注意注解的作用范围，可以使用 @Target 注解来指定注解可以应用于哪些元素上。同时，还需要使用 @Retention 注解来指定注解的保留策略，即该注解应该在编译后的字节码中保留到什么程度。

二、简单的使用自定义注解

在上面介绍了如何定义一个自定义注解，下面将介绍如何通过反射来使用自定义的注解，代码如下：

//定义一个自定义的注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface MyAnnotation {
    String name() default "jack";

    int value() default 12;

    String[] hobby() default {"吃","喝","玩"};

}

在上面的示例中，我们定义了一个注解 MyAnnotation，使用了 @Retention 注解来指定该注解应该在运行时保留，使用了 @Target 注解来指定该注解应该应用于方法上。注解中包含了四个成员变量，分别表示名称、年龄、爱好和婚姻状况。注解中还包含了一个方法 String toString()，用于返回注解的字符串表示。

public class Main {
    @MyAnnotation(name = "tom")
    public void myMethod() {
        
    }
    public static void main(String[] args) {
        Main main = new Main();
        try {
            MyAnnotation annotation = main.getClass().getMethod("myMethod").getAnnotation(MyAnnotation.class);
            if (annotation != null) {
                System.out.println("name = " + annotation.name());
                System.out.println("hobby  = " + annotation.hobby());
                System.out.println("value = " + annotation.value());
            }
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }
}

在 Main 类中，我们在方法 myMethod() 上使用了 @MyAnnotation 注解，并指定了注解的各个成员变量的值。在 main() 方法中，我们使用反射机制来获取 myMethod() 方法上的 @MyAnnotation 注解，并输出注解的各个成员变量的值。运行该程序，输出如下：

name = tom
hobby  = [Ljava.lang.String;@60e53b93
value = 12

三、使用自定注解实现链接数据库保存数据

下面难度升级，这里将使用一个自定义的注解，通过反射实现连接数据库并保存数据。

1.定义注解注解

首先，定义一个注解@Table，用于标识实体类对应的数据库表名：

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

然后，定义一个注解@Column，用于标识实体类中的属性对应的数据库列名：

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

2. 定义实体类

定义一个实体类User，使用@Table注解标识该类对应的数据库表名：

@Table(name = "user")
public class User {
    // 使用@Column注解标识属性对应的数据库列名
    @Column(name = "id")
    private Long id;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private Integer age;

    // 省略getter和setter方法
}

3. 通过反射使用注解

定义ORM框架类，实现对实体类的持久化操作

public class ORMFramework {
    // 保存实体类到数据库
    public static void save(Object obj) throws Exception {
        // 获取实体类的Class对象
        Class<?> clazz = obj.getClass();
        // 获取实体类上的@Table注解
        Table table = clazz.getAnnotation(Table.class);
        if (table == null) {
            throw new RuntimeException("No @Table annotation found on class " + clazz.getName());
        }
        // 获取实体类对应的数据库表名
        String tableName = table.name();
        // 构造SQL语句
        StringBuilder sb = new StringBuilder("insert into ").append(tableName).append("(");
        // 获取实体类的所有属性
        Field[] fields = clazz.getDeclaredFields();
        // 用于存储属性值的列表
        List<Object> values = new ArrayList<>();
        // 遍历属性，获取属性上的@Column注解和属性值
        for (Field field : fields) {
            Column column = field.getAnnotation(Column.class);
            if (column != null) {
                // 获取属性对应的数据库列名
                String columnName = column.name();
                sb.append(columnName).append(",");
                // 设置属性可访问，获取属性值
                field.setAccessible(true);
                Object value = field.get(obj);
                values.add(value);
            }
        }
        // 删除最后一个逗号，并添加values子句
        sb.deleteCharAt(sb.length() - 1).append(") values (");
        // 添加占位符
        for (int i = 0; i < values.size(); i++) {
            sb.append("?").append(",");
        }
        // 删除最后一个逗号，并添加右括号
        sb.deleteCharAt(sb.length() - 1).append(")");
        // 获取数据库连接
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = getConnection();
            // 创建PreparedStatement对象，并设置参数
            ps = conn.prepareStatement(sb.toString());
            for (int i = 0; i < values.size(); i++) {
                ps.setObject(i + 1, values.get(i));
            }
            // 执行SQL语句
            ps.executeUpdate();
        } finally {
            // 关闭数据库连接
            close(conn, ps, null);
        }
    }

    // 获取数据库连接
    private static Connection getConnection() throws Exception {
        // 省略获取数据库连接的代码，完整代码见附件
    }

    // 关闭数据库连接
    private static void close(Connection conn, Statement stmt, ResultSet rs) throws Exception {
        // 省略关闭数据库连接的代码，完整代码见附件
    }
}

4.测试

// 编写测试代码，演示ORM框架的使用
public class TestORM {
    public static void main(String[] args) throws Exception {
        // 创建一个User对象，并设置属性值
        User user = new User();
        user.setName("Tom");
        user.setAge(20);
        // 调用ORMFramework.save()方法，将User对象保存到数据库中
        ORMFramework.save(user);
    }
}

5. 实例测试截图

通过newInstance创建一个实例，然后将它的id赋值为122，name赋值为"Vesper"，age赋值为22，然后调用封装在ORMFramework类的静态方法save保存数据到数据库。