Java 注解与反射

注解 Annotation

作用

• 对程序作出解释（类似于注释）
• 可以被其他程序读取（如：编译器等）

使用方式

• 注解以 “@注释名” 形式存在，如 “@Override”，有些可以添加一些参数值，如 “@SuppressWarnings(value=”unchecked”)”
• 附加在package，class，method，field等上方，等于给他们添加额外辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

内置注解

• @Override: 此注释只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明
• @SuppressWarnings: 用于抑制编译时的警告信息(Warning)，需要添加参数才能使用，如：(“all”),(“unchecked”),(value={“unchecked”,”deprecation”})等等

元注解

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

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

自定义注解

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

• @interface用来声明一个注释，格式：@interface 注解名 { 定义内容 }
• 其中的每一个方法实际上是声明了一个配置参数
• 方法的名称就是参数的名称
• 返回值类型就是参数的类型，返回值只能是基本类型(Class, String, enum)
• 可以通过default来声明参数的默认值
• 如果只有一个参数成员，一般参数名为value
• 注解必须要有值，我们定义注解元素时，经常使用空字符串或者0来作为默认值(default)

public class Test01 {
    // 注解可以显示赋值，没有先后顺序之分，如果没有默认值，就必须给注解赋值
    @MyAnnotation01(id = 1, age = 18, name = "Benboby")
    public void test01() {}
    
    // 当注解只有一个参数时，默认定义为 value() , 则可以省略 "value = "
    @MyAnnotation02("Benboby") 
    public void test02() {}
}

@Target({ElementType.TYPE, ElementType.METHOD}) // 作用域可以在类上或者方法上
@Retention(RetentionPolicy.RUNTIME) // 在运行时有效
@interface MyAnnotation01 {
    // 注解的参数：参数类型 + 参数名() (+ 默认值);
    String name() default "";
    int age();
    int id();
    
    String[] schools() default {"本科","带专"};
}

@Target({ElementType.TYPE, ElementType.METHOD}) // 作用域可以在类上或者方法上
@Retention(RetentionPolicy.RUNTIME) // 在运行时有效
@interface MyAnnotation02 {
    String value();
}

反射（Java Reflection）

动态 VS 静态语言

动态语言：运行时代码可以根据某些条件改变自身结构。如：C#, JavaScript, PHP, Python等。

function f() {
    // var 是万能类型
    var x = "var a=1; var b=2; alert(a+b)"; // 可以认为目前是字符串类型
    eval(x) // 执行 x ，x 变为 a+b 的值
}

静态语言：运行时结构不可改变的语言就是静态语言。如：Java, C, C++。

• Java不是动态语言，但Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性，使得Java在编程的时候变得更灵活。

简介

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

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

正常方式： 引入需要的“包类”名称 -> 通过new实例化 -> 取得实例化对象
反射方式： 实例化对象 -> getClass()方法 -> 得到完整的“包类”名称

优点：可以实现创建对象和编译，体现出很大的灵活性
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过反射获取对象类的Class对象
        Class c1 = Class.forName("pers.Shuke.reflection.User");
        System.out.println(c1); // 输出：class pers.Shuke.reflection.User
    }
}

class User {...}

Class类

在Object类中定义了以下的方法，此方法将所有子类继承：public final Class getClass()

以上方法的返回值类型是一个Class类，此类是Java反射的源头，即：可以通过对象反射求出类名称。

获取Class类型的几种方式

public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        // 方式1：通过对象获得
        Class c1 = person.getClass();

        // 方式2：forname获得
        Class c2 = Class.forName("pers.Shuke.reflection.Student");

        // 方式3：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3);
        // c1 = c2 = c3 = "class pers.Shuke.reflection.Student"

        // 方式4：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;   // c4 = int

        // 方式5：
        Class c5 = c1.getSuperclass();  // c5 = "class pers.Shuke.reflection.Person"
        System.out.println(c5);
    }
}

class Person {...}

class Student extends Person {...}

class Teacher extends Person {...}

所有类型的Class对象

public class Test04 {
    public static void main(String[] args) {
        Class c1 = Object.class; // 类 c1 = "class java.lang.Object"
        Class c2 = Comparable.class; // 接口 c2 = "interface java.lang.Comparable"
        Class c3 = String[].class; // 一维数组 c3 = "class [Ljava.lang.String;"
        Class c4 = int[][].class; // 二维数组 c4 = "class [[I"
        Class c5 = Override.class; // 注解 c5 = "interface java.lang.Override"
        Class c6 = ElementType.class; // 枚举 c6 = "class java.lang.annotation.ElementType"
        Class c7 = Integer.class; // 基本数据类型 c7 = "class java.lang.Integer"
        Class c8 = void.class; // void c8 = "void"
        Class c9 = Class.class; // Class c9 = "class java.lang.Class"

        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        // c10 = c11
        // 只有元素类型与维度一样，就是同一个Class
    }
}

Java内存分析

简介

堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（包含具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区：可以被所有的线程共享，包含所有的class和static变量

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过以下三个步骤来对该类进行初始化。

1. 类的加载(Load)：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
2. 类的连接(Link)：将类的二进制数据合并到JRE中。
3. 类的初始化(Initialize)：JVM负责对类进行初始化。

类的初始化

1. 类的主动引用（一定会发生类的初始化）

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

1. 类的被动引用

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

// 测试类什么时候会被初始化
public class Test08 {

    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        // 主动调用
        //Son son = new Son();
        /* main类被加载
           父类被加载
           子类被加载
         */

        // 通过反射
        //Class.forName("pers.Shuke.Initialization.Son");
        /*  main类被加载
            父类被加载
            子类被加载
         */

        // 引用父类常量
        //System.out.println(Son.b);
        /*  main类被加载
            父类被加载
            2
         */

        // 引用自身常量
        //System.out.println(Son.m);
        /*  main类被加载
            父类被加载
            子类被加载
            100
         */

        // 定义数组
        //Son[] array = new Son[5];
        /*
            main类被加载
         */

        // 引用final常量
        //System.out.println(Son.f);
        /*  main类被加载
            10
         */
    }
}

class Father {
    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {
    static{
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int f = 10;
}

类加载器的作用

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

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

源程序(.java文件) -> Java编译器 -> 字节码(.class文件) -> 类装载器 -> 字节码校验器 -> 解释器 -> 操作系统平台

public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader); // 输出：jdk.internal.loader.ClassLoaders$AppClassLoader@3d4eac69

        // 获取系统类父类的加载器 -> 拓展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent); // 输出：jdk.internal.loader.ClassLoaders$PlatformClassLoader@77459877

        // 获取拓展类加载器的父类加载器 -> 引导类加载器/根加载器（C/C++）
        ClassLoader root = parent.getParent();
        System.out.println(root); // 输出：null （无法直接获取）

        // 测试当前类是哪个加载器加载的
        ClassLoader classLoader1 = Class.forName("pers.Shuke.Initialization.Test09").getClassLoader();
        System.out.println(classLoader1); // 输出：jdk.internal.loader.ClassLoaders$AppClassLoader@3d4eac69

        // 测试jdk内置的类是哪个加载器加载的
        ClassLoader classLoader2 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader2); // 输出：null

        // 如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

获取类的运行时结构

通过反射获取类运行时的完整结构：

• 实现的全部接口（Interface）
• 所继承的父类（Superclass）
• 全部的构造器（Constructor）
• 全部的方法（Method）
• 全部的Field
• 注解
• …

PS：public/private/protected区别（默认为friendly）

作用域	当前类	同一public	子孙类	其他package
public	1	1	1	1
protected	1	1	1	0
friendly	1	1	0	0
private	1	0	0	0

public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("pers.Shuke.reflection.User");
        System.out.println(c1.getName()); // 输出：pers.Shuke.reflection.User
        System.out.println(c1.getSimpleName()); // 输出：User

        User user = new User();
        c1 = user.getClass();
        System.out.println(c1.getName()); // 输出：pers.Shuke.reflection.User
        System.out.println(c1.getSimpleName()); // 输出：User

        Field[] fields = c1.getFields(); // 输出：null  解释：只能找到public属性
        fields = c1.getDeclaredFields();
        /*  private java.lang.String pers.Shuke.reflection.User.name
            private int pers.Shuke.reflection.User.age
            private int pers.Shuke.reflection.User.id
            解释：可以找到全部属性
         */
        for(Field field : fields) {
            System.out.println(field);
        }

        // 获得指定属性的值
        //Field name = c1.getField("name"); // 报错：只能获取public对象
        Field name = c1.getDeclaredField("name"); // 输出：private java.lang.String pers.Shuke.reflection.User.name
        System.out.println(name);

        // 获取类的方法
        Method[] methods = c1.getMethods(); // 获取本类和父类所有public方法
        methods = c1.getDeclaredMethods(); // 获取本类所有方法
        for(Method method : methods) {
            System.out.println(method);
        }

        // 获取类的指定方法(需要传参)
        Method getname = c1.getMethod("getName", null);
        Method setname = c1.getMethod("setName", String.class);
        System.out.println(getname); // 输出：public java.lang.String pers.Shuke.reflection.User.getName()
        System.out.println(setname); // 输出：public void pers.Shuke.reflection.User.setName(java.lang.String)

        // 获得指定的构造器
        Constructor[] constructors = c1.getConstructors(); // 获取public构造器
        constructors = c1.getDeclaredConstructors(); // 获取指定构造器

        // 获得指定构造器
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(constructor); // 输出：public pers.Shuke.reflection.User(java.lang.String,int,int)
    }
}

动态创建对象执行方法

创建类的对象：
有无参构造器：调用Class对象的newInstance()方法

• 类必须有一个无参数构造器
• 类的构造器的访问权限要足够

没有无参构造器：

1. 通过Class类的getDeclaredConstructor()取得本类的指定形参类型的构造器
2. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的哥哥参数
3. 通过Constructor

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

1. 通过Class类的getMethod()方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2. 之后使用Object invoke()进行调用，并向方法中传递需要设置的obj对象的参数信息。

setAccessible：

• Method，Field和Constructor对象都有setAccessible()方法
• 作用为启动和禁用访问安全检查的开关
• 参数值为true则指示反射的对象在使用时应该取消Java语言访问检测，这样可以提高反射的效率，使得原本无法访问的私有成员也可以访问

public class Test11 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 获取class对象
        Class c1 = Class.forName("pers.Shuke.reflection.User");

        // 构造一个对象
        User user = (User)c1.newInstance(); // 本质上调用类的无参构造器
        System.out.println(user); // pers.Shuke.reflection.User@5b2133b1

        // 通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User)constructor.newInstance("舒克", 1, 10);
        System.out.println(user2); // pers.Shuke.reflection.User@72ea2f77

        // 通过反射调用普通方法
        User user3 = (User)c1.newInstance();
        // 通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);

        // invoke : 激活的意思
        // {对象，方法的值}
        setName.invoke(user3, "舒克");
        System.out.println(user3.getName()); // 舒克

        // 通过反射操作属性
        User user4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");

        name.setAccessible(false); // 关闭权限检测，否则无法直接修改private变量
        name.set(user4, "舒克2");
        System.out.println(user4.getName());
    }
}

性能对比分析

// 分析性能问题
public class Test12 {
    // 普通方式调用
    public static void Test12_1() {
        User user = new User();

        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();

        System.out.println("普通方法执行10亿次：" + (endTime - startTime) + "ms");
    }

    // 反射方式调用
    public static void Test12_2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("反射调用不关检测执行10亿次：" + (endTime - startTime) + "ms");
    }

    // 反射反射调用（关闭检测）
    public static void Test12_3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < 1000000000; i++) {
            getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("反射调用不关检测执行10亿次：" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Test12_1(); // 6ms
        Test12_2(); // 2686ms
        Test12_3(); // 1065ms
    }
}

根据结果可知：普通调用效率 >> 关闭检测反射调用效率 > 不关闭检测反射调用效率

获取泛型信息

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

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

• ParameterizedType: 表示一种参数化类型，比如Collection
• GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型
• TypeVariable: 是各种类型变量的公共父接口
• WildcardType: 代表一种通配符类型表达式

// 通过反射获取泛型
public class Test13 {
    public static void Test13_1(Map<String, User> map, List<User> list) {
        System.out.println("test13_1");
    }

    public Map<String, User> Test13_2() {
        System.out.println("test13_2");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        // 获取方法
        Method method = Test13.class.getMethod("Test13_1", Map.class, List.class);

        // 获取泛型参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for(Type genericParameterType : genericParameterTypes) {
            System.out.println("#" + genericParameterType);
            /*  #java.util.Map<java.lang.String, pers.Shuke.reflection.User>
                ------------
                #java.util.List<pers.Shuke.reflection.User>
             */
            // 是否属于参数化类型
            if(genericParameterType instanceof ParameterizedType) {
                // 强制转化，获得真实的参数类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for(Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                    /*  class java.lang.String
                        class pers.Shuke.reflection.User
                        ------------
                        class pers.Shuke.reflection.User
                     */
                }
            }
        }

        method = Test13.class.getMethod("Test13_2", null);
        // 获取返回值类型
        Type genericParameterType = method.getGenericReturnType();

        // 是否为泛型
        if(genericParameterType instanceof ParameterizedType) {
            // 强制转化为具体泛型
            Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
            for(Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
                /*  class java.lang.String
                    class pers.Shuke.reflection.User
                 */
            }
        }
    }
}

获取注解信息

// 反射操作注解
public class Test14 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("pers.Shuke.reflection.People");

        // 通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for(Annotation annotation : annotations) {
            System.out.println(annotation); // @pers.Shuke.reflection.TableShuke("db_people")
        }

        // 获得注解的value的值
        TableShuke tableShuke = (TableShuke)c1.getAnnotation(TableShuke.class);
        String value = tableShuke.value();
        System.out.println(value); // db_people

        // 获得类的指定注解
        Field field = c1.getDeclaredField("name"); // 获得name属性的注解
        FieldShuke annotation = field.getAnnotation(FieldShuke.class);
        System.out.println(annotation.columnName() + " " + annotation.type() + " " + annotation.length()); // db_name varchar 8
    }
}

@TableShuke("db_people")
class People {
    @FieldShuke(columnName = "db_name", type = "varchar", length = 8)
    private String name;
    @FieldShuke(columnName = "db_age", type = "int", length = 4)
    private int age;
    @FieldShuke(columnName = "db_id", type = "int", length = 12)
    private int id;

    public People() {}

    public People(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;
    }
}

// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableShuke {
    String value();
}

// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldShuke {
    String columnName();
    String type();
    int length();
}