15、注解和反射

1. 注解

1.1 什么是注解

注解的作用

• 作为特定标记，用于告诉编译器一些信息
• 编译时动态处理，如动态生成代码
• 运行时动态处理，作为额外信息的载体，如获取注解信息

注解的格式

• @注解名
• @注解名(参数列表)

使用场景

可以附加在 package, class, method, field 等上面，相当于给他们添加了额外的辅助信息，开发者可以通过反射机制实现对元数据的访问

1.2 内置注解

• @Override

  定义在 java.lang.Override 中，此注释只适用于修辞方法；

  表示一个方法声明打算重写超类中的另一个方法声明

• @Deprecated

  定义在 java.lang.Deprecated 中，此注释可以用于修辞方法、属性、类；

  表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择

• @SuppressWarnings

  定义在 java.lang.SuppressWarnings 中，用来抑制编译时的警告信息；

  与前两个注释有所不同，开发者需要添加一个参数才能正确使用，这些参数都是已经定义好了的，开发者选择性的使用即可

  • @SuppressWarnings("all")

  • @SuppressWarnings("unchecked")

  • @SuppressWarnings(value={"unchecked","deprecation"})

  • …

1.3 元注解

元注解的作用就是负责注解其他注解，Java 定义了 4 个标准的 meta-annotation 类型，它们被用来提供对其他 annotation 类型作说明：

• @Target - 描述注解的使用范围
• @Retention - 表示需要在什么级别保存该注解信息，用于描述注解的生命周期 (SOURCE < CLASS < RUNTIME)
• @Documented - 说明该注解将被包含在 javadoc 中
• @Inherited - 说明子类可以继承父类中的该注解

1.4 自定义注解

使用 @interface 自定义注解时，自动继承 java.lang.annotation.Annotation 接口

@interface 用来声明一个注解，格式：

public @interface 注解名 {
    # 注解参数格式：参数类型 参数名()
    String value();
}

• 其中的 ”每一个方法“ 实际上是声明了一个配置参数

  • ”方法“ 的名称就是参数的名称
  • 如果只有一个参数成员 , 一般参数名为 value

• 注解元素必须要有值

  定义注解元素时，可以通过 default 来声明参数的默认值，经常使用空字符串、0作为默认值

代码示例：

public class Demo {
    @MyAnnotation(name="felix")
    public void func() {}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String name();
    int age() default 0;
}

2. 反射

反射是 Java 被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象包含了完整的类的结构信息，开发者可以通过此对象看到类的结构，这一过程形象的称之为：反射。

反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理
• …

反射机制优缺点

• 优点：可以实现动态创建对象和编译，体现出很大的灵活性 !

• 缺点：对性能有影响

  使用反射基本上是一种解释操作，开发者可以告诉 JVM 希望它做什么并且它能够满足开发者的需求，这类操作总是慢于直接执行相同的操作。

反射相关的主要 API

• java.lang.Class - 代表一个类
• java.lang.reflect.Method - 代表类的方法
• java.lang.reflect.Field - 代表类的成员变量
• java.lang.reflect.Constructor - 代表类的构造器
• …

2.1 Class 类

在 Object 类中定义了以下的方法，此方法将被所有子类继承：

public final native Class<?> getClass();

此方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

对象 ”照镜子“ 后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。

对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。

一个 Class 对象包含了特定某个结构 (class / interface / enum / annotation / primitive type / void / []) 的有关信息

• Class 本身也是一个类
• Class 对象只能由系统建立对象
• 一个加载的类在 JVM 中只会有一个 Class 实例
• 一个 Class 对象对应的是一个加载到 JVM 中的一个 .class 文件
• 每个类的实例都会记得自己是由哪个 Class 实例所生成
• 通过 Class 可以完整地得到一个类中的所有被加载的结构
• Class 类是 reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class 对象

Class 类的常用方法

方法名	功能说明
public static Class<?> forName(String className)	返回指定类名 className 的 Class 对象
public T newInstance()	调用缺省构造函数，返回 Class 对象的一个实例
public String getName()	返回此 Class 对象所表示的实体的名称
public native Class<? super T> getSuperclass();	返回当前 Class 对象的父类的 Class 对象
public Class<?>[] getInterfaces()	获取当前 Class 对象的接口
public ClassLoader getClassLoader()	返回该类的类加载器
public Constructor<?>[] getConstructors()	返回一个包含某些 Constructor 对象的数组
public Method getMethod(String name, Class<?>... parameterTypes)	返回一个 Method 对象
public Field[] getDeclaredFields()	返回 Field 对象的一个数组

获取 Class 类的实例

• 若已知具体的类，通过类的 class 属性获取，该方法最为安全可靠，程序性能最高
• 已知某个类的实例，调用该实例的 getClass() 方法获取 Class 对象
• 已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName() 获取，可能抛出 ClassNotFoundException 异常
• 内置基本数据类型可以直接用 类名.TYPE
• 可以利用 ClassLoader

代码示例：

package pers.afelixliu.study.reflection;

public class Demo {

    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Student();

        System.out.println(p1.name);

        // 1、通过对象的 class 属性获得 Class 类
        Class<?> c1 = Student.class;
        System.out.println(c1.hashCode());

        // 2、通过实例的 getClass() 方法获得 Class 类
        Class<?> c2 = p1.getClass();
        System.out.println(c2.hashCode());

        // 3、通过 Class 类的静态方法 forName() 获得 Class 类
        Class<?> c3 = Class.forName("pers.afelixliu.study.reflection.Student");
        System.out.println(c3.hashCode());

        // 4、内置基本数据类型可通过实例的 TYPE 属性获得 Class 对象
        Class<?> c4 = Integer.TYPE;
        System.out.println(c4.hashCode());

        // 获得当前 Class 对象的父类的 Class 对象
        Class<?> c5 = c1.getSuperclass();
        System.out.println(c5);
        System.out.println(c5.hashCode());

    }

}

class Person {

    String name;

    public Person() {}

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

}

class Student extends Person {

    public Student() {
        this.name = "Student";
    }

}

class Teacher extends Person {

    public Teacher() {
        this.name = "Teacher";
    }

}

哪些类型可以有 Class 对象：

• class - 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类。
• interface - 接口
• [] - 数组
• enum - 枚举
• annotation - 注解
• primitive type - 基本数据类型
• void

2.2 类加载内存分析

类的加载过程

1. 加载（Load）

   将 class 文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后生成一个对应的 java.lang.Class 对象

2. 链接（Link）：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程

   • 验证：确保加载的类信息符合 JVM 规范，没有安全方面的问题
   • 准备：正式为类变量（static）分配内存并设置变量默认初始值的阶段，这些内存都将在方法区中进行分配
   • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

3. 初始化（Initialize）

   • 执行类构造器 <clinit>() 方法的过程：类构造器 <clinit>() 方法是由编译器自动收集所有类变量的赋值动作和静态代码块中的语句合并产生的

     类构造器是构造类信息，不是构造该类对象的构造器

   • 当初始化一个类时，如果发现其父类还没初始化，则先初始化其父类

   • 虚拟机会保证一个类的 <clinit>() 方法在多线程环境中被正确加锁和同步

何时会发生类的初始化？

• 会发生类初始化的情况：（类的主动引用）

  • 当虚拟机启动，首先初始化 main 方法所在的类
  • new 一个类的对象
  • 调用类的静态成员（除了 final 常量）和静态方法
  • 使用 java.lang.reflect 包的方法对类进行反射调用
  • 初始化一个类，如果其父类没有被初始化，则优先初始化其父类

• 不会发生类初始化：（类的被动引用）

  • 当访问哪一个静态域时，只有真正声明这个域的类才会被初始化
  • 通过数组定义类引用时，不会触发此类的初始化
  • 引用常量不会触发初始化（常量在链接阶段就存入调用类的常量池中了）

类加载器的作用：

将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口。

类缓存：

标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到加载器中将维持加载（缓存）一段时间，不过 JVM 垃圾回收机制可以回收这些 Class 对象

类加载器的种类：

• 引导类加载器：jre/lib/rt.jar 包，负责Java平台核心库，由 C++ 编写，JVM 自带的加载器，用来装在核心类库，无法直接获取
• 扩展类加载器：将 jre/lib/ext 目录下的 jar 包或 -D java.ext.dirs 指定目录下的 jar 包装入工作库
• 系统类加载器：将 java -classpath 或 -D java.class.path 所指定目录下的类与 jar 包装入工作库，是最常用的加载器

代码示例：

package pers.afelixliu.study.reflection;

public class Demo {

    public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        // 获取系统类加载器的父类加载器，即扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);

        // 获取扩展类加载器的父类加载器，即引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);

        // 获取当前类的类加载器
        ClassLoader currentClassLoader = Class.forName("pers.afelixliu.study.reflection.Demo").getClassLoader();
        System.out.println(currentClassLoader);

        // 获取 JDK 内置类的类加载器
        ClassLoader builtClassLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(builtClassLoader);
        
        // 获取引导类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
    
}

双亲委派机制

1. 什么是双亲委派机制？

   • 当类加载器接收到类加载的请求时，首先检查该类是否已经被当前类加载器加载；
   • 若该类未被加载过，当前类加载器会将加载请求委托给父类加载器去完成；
   • 若当前类加载器的父类加载器为null，会委托启动类加载器完成加载；
   • 若父类加载器无法完成类的加载，当前类加载器才会去尝试加载该类。

2. 为什么会有这种机制？

   • 通过双亲委派机制，可以避免类的重复加载，当父加载器已经加载过某一个类时，子加载器就不会再重新加载这个类。

     2. 通过双亲委派机制，可以保证安全性。因为 BootstrapClassLoader 在加载的时候，只会加载 JAVA_HOME 中的 jar 包里面的类，如 java.lang.String，那么这个类是不会被随意替换的。

参考资料：【Java】深入了解双亲委派机制（常说的类加载机制）-CSDN博客

通过反射可以获取运行时类的完整结构，如Field、Method、Constructor、Superclass、Interface、Annotation…

2.3 如何使用 Class 对象

• 创建类的对象：调用 Class 对象的 newInstance() 方法

  • 类必须有一个无参数的构造器

    难道没有无参的构造器就不能创建对象了吗？

    只要在操作的时候明确地调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

    步骤如下：

    • 通过 Class 类的 getDeclaredConstructor(Class<?>... parameterTypes) 获取得本类的指定形参类型的构造器；
    • 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数；
    • 通过 Constructor 实例化对象。

  • 类的构造器的访问权限需要足够

调用指定的方法：通过反射，调用类中的方法，通过 Method 类完成。

• 通过 Class 类的 getMethod(String name, Class<?>... parameterTypes) 方法取得一个 Method 对象，并设置此方法操作时所需要的参数类型；
• 使用 Object invoke(Object obj, Object... args) 进行调用，并向方法中传递要设置的 obj 对象的参数信息。

Object invoke(Object obj, Object... args) 方法：

• Object 对应原方法的返回值，若原方法无返回值，此时返回 null；
• 若原方法为静态方法，此时形参 Object obj 可为 null；
• 若原方法形参列表为空，则 Object... args 为 null；
• 若原方法声明为 private，则需要在调用此 invoke() 方法前，显式调用方法对象的 setAccessible(true) 方法，即可访问 private 的方法

setAccessible(boolean flag) 方法

• Method 和 Field、Constructor 对象都有 setAccessible() 方法；

• setAccessible() 作用是启动和禁用访问安全检查的开关；

  • 参数值为 true 时指示反射的对象在使用时应该取消 Java 语言访问检查，能够提高反射效率
  • 参数值为 false 则指示反射的对象应该实施 Java 语言访问检查

• setAccessible() 使得原本无法访问的私有成员也可以访问

代码示例：

package pers.afelixliu.study.reflection;

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

class User {

    private String name;
    private int age;
    private int id;

    public User() {
    }

    public User(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }

}


public class Demo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        // 获得 Class 对象
        Class<?> c1 = Class.forName("pers.afelixliu.study.reflection.User");

        // 通过 Class 对象创建类的对象（本质是调用类的无参构造器）
        Object o = (User)c1.newInstance();
        System.out.println(o);

        // 通过反射获得类的有参构造器，调用有参构造器创建类的对象
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        constructor.setAccessible(true);
        Object felix = constructor.newInstance("Felix", 02, 18);
        System.out.println(felix);

        // 通过反射调用普通方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.setAccessible(true);
        setName.invoke(o, "User: o");
        System.out.println(o);

        // 通过反射操作类属性
        Field age = c1.getDeclaredField("age");
        age.setAccessible(true);
        age.set(o, 18);
        System.out.println(o);
    }

}

2.4 反射操作泛型

Java 泛型

所谓泛型就是在类定义时不明确类型，在使用时明确类型。

格式：“<>”，使用钻石操作符，<类>

1. Java 中泛型标记符：

   • E - Element（在集合中使用，因为集合中存放的是元素）

   • T - Type（Java 类）

   • K - Key（键）

   • V - Value（值）

   • N - Number（数值类型）

   • ? - 表示不确定的 Java 类型

2. 泛型的限制和规则：

   • 泛型的类型参数只能是引用类型，不能使用值类型；

   • 泛型的类型参数可以有多个；

   • 泛型类不是真正存在的类，不能使用 instanceof 运算符；

   • 泛型类的类型参数不能用在静态申明；

   • 如果定义了泛型，不指定具体类型，泛型默认指定为 Object 类型；

   • 泛型使用 ? 作为类型通配符，表示未知类型，可以匹配任何类型（因为是未知，所以无法添加元素）；

   • 类型通配符上限：<? extends T>，? 代表是 T 类型本身或者是 T 的子类型（常用于泛型方法，避免类型转换）；

   • 类型通配符下限。<? super T>，? 代表T类型本身或者是T的父类型；

   • 除了通配符可以实现限制，类、接口和方法中定义的泛型参数也能限制上限和下限。

参考资料：泛型与反射，看这篇就够了_泛型反射-CSDN博客

---

Java 采用泛型擦除的机制来引入泛型，Java 中的泛型仅仅是给编译器 javac 使用的，确保数据的安全性和免去强制类型转换问题。但是一旦编译完成，所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型以迎合实际开发的需要，Java 新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型但是又和原始类型齐名的类型：

• ParameterizedType - 表示一种参数化类型，比如 Collection<String>
• GenericArrayType - 表示一种元素类型是参数化类型或者类型变量的数组类型（generic 表示 “泛型”）
• TypeVariable - 是各种类型变量的公共父接口
• WildcardType - 代表一种通配符类型表达式，比如 ?、? extends Number、? super Integer、…（ wildcard 表示 ”通配符“）

代码示例：

package pers.afelixliu.study.reflection;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

public class Demo {

    public static void func01(Map<String, User> map, List<User> list) {
        System.out.println("func01");
    }

    public static Map<String, User> func02() {
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method m1 = Demo.class.getDeclaredMethod("func01", Map.class, List.class);
        for (Type genericParameterType : m1.getGenericParameterTypes()) {
            System.out.println("#" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                for (Type actualTypeArgument : ((ParameterizedType) genericParameterType).getActualTypeArguments()) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        System.out.println("------------------------------------------------------------------------");
        Method m2 = Demo06.class.getDeclaredMethod("func02", null);
        Type genericReturnType = m2.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            for (Type actualTypeArgument : ((ParameterizedType) genericReturnType).getActualTypeArguments()) {
                System.out.println(actualTypeArgument);
            }
        }
    }

}

2.5 反射操作注解

代码示例：

package pers.afelixliu.study.reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Demo {

    public static void main(String[] args) throws NoSuchFieldException {
        Class<Kids> kidsClass = Kids.class;

        // 通过反射获取注解
        Annotation[] annotations = kidsClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        // 获得注解的值
        TableNameAnnotation tableNameAnnotation = kidsClass.getAnnotation(TableNameAnnotation.class);
        System.out.println(tableNameAnnotation.value());

        // 获得指定注解和值
        Field name = kidsClass.getDeclaredField("name");
        TableFieldAnnotation nameAnnotation = name.getAnnotation(TableFieldAnnotation.class);
        System.out.println(nameAnnotation.columnName());
        System.out.println(nameAnnotation.columnType());
        System.out.println(nameAnnotation.length());
        System.out.println("--------------------------");
        Field age = kidsClass.getDeclaredField("age");
        TableFieldAnnotation ageAnnotation = age.getAnnotation(TableFieldAnnotation.class);
        System.out.println(ageAnnotation.columnName()); 
        System.out.println(ageAnnotation.columnType());
        System.out.println(ageAnnotation.length());
    }

}

@TableNameAnnotation("db_kids")
class Kids {

    @TableFieldAnnotation(columnName = "kids_name", columnType = "varchar", length = 10)
    private String name;
    @TableFieldAnnotation(columnName = "kids_age", columnType = "int", length = 3)
    private int age;
    @TableFieldAnnotation(columnName = "kids_school", columnType = "varchar", length = 20)
    private String school;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Kids{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school='" + school + '\'' +
                '}';
    }

    public Kids() {}

    public Kids(String name, int age, String school){
        this.name = name;
        this.age = age;
        this.school = school;
    }

}

/**
 * 数据库表名注解
 * @author AFelixLiu
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableNameAnnotation {
    String value();
}

/**
 * 数据库字段注解
 * @author AFelixLiu
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableFieldAnnotation {
    String columnName();
    String columnType();
    int length();
}