Java注解与反射

注解

什么是注解

注解是JDK1.5引入的，不是程序本身，可以对程序做出解释。可以被其他程序读取（如：编译器）

• Annotation的格式：以 "@注释名"在代码中存在，还可以添加一些参数值。例如：@SuppressWarning(value="unchecked")

• Annotation在哪里使用：可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息；可以通过反射机制实现对这些元数据的访问

内置注解

• @Override：重写的注解（代表注解的方法是重写父类的方***进行一些检查）

• @Deprecated：废弃的注解，不推荐程序员使用，但是可以使用，或存在更好的方式。调用方法时，方法上会有一个横划线。

• @SuppressWarnings(" ")：***警告

元注解

• 元注解的作用是负责注解其他注解

  • @Target：用于描述注解的使用范围

  • @Retention：表示注解在什么级别还有效，用于描述注解的生命周期（SOURCE < CLASS < RUNTIME）

  • @Document：表示是否将注解生成在javadoc中

  • @Inherited：表示子类可以继承父类中的注解

自定义注解

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

  • 格式：public @Interface 注解名(){ 定义内容 }

  • 注解的参数：参数类型 + 参数名() default 默认值;

/**
 * @author lixing
 * @date 2022-03-31 13:53
 * @description 自定义注解
 */
public class Test02 {
    @MyAnnotation(age=18)
    public void test(){}

    @MyAnnotation2(value = "123")
    public void test2(){}
}

@Target({ElementType.TYPE, ElementType.METHOD}) // 表示此注解可作用在类和方法上
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    String name() default "";
    int age();
    int id() default -1;
    String[] schools() default {"清华大学", "北京大学"};
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String value();
}

反射

java反射机制概述

• 静态语言、动态语言

  • 静态语言：运行时结构不可变，如 java，c++，c

  • 动态语言：运行时可以改变其结构的语言，如 c#，javascript，php，python等

  • java不是动态语言，但是可以称为 ”准动态语言“ 。java具有一定的动态性，可以通过反射机制获取类似动态语言的特性，让编程更加灵活

• 反射（Reflection）机制允许程序在执行期间借助 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

  Class c = Class.forName("java.lag.String");
  

• 类加载完之后，就会在内存中产生一个Class类型的对象（一个类只有唯一一个Class对象），这个对象就包含了完整的类的结构信息，可以通过这个对象看到类的结构。所以形象称之为 ”反射“

  • 正常方式：引入需要的”包类“名称 ——> 通过new实例化 ——> 获取实例化对象

  • 反射方式：实例化对象 ——> getClass()方法 ——> 得到完整的”包类“名称

• 反射机制的功能

  • 在运行时判断任何一个对象所属的类

  • 在运行时构造任何一个类的对象

  • 在运行时判断任何一个类的所有成员变量和方法

  • 在运行时获取泛型信息

  • 在运行时调用任何一个对象的成员变量和方法

  • 在运行时处理注解

  • 生成动态代理

反射的优缺点

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

• 缺点：对性能有影响，使用反射基本上是一种解释操作，这类操作总是慢于直接执行相同的操作。存在安全性问题。

反射相关的API

• java.lang.Class：代表一个类

• java.lang.reflect.Method：代表类的方法

• java.lang.reflect.Field：代表类的成员变量

• java.lang.reflect.Constructor：代表类的构造器

理解Class类并获取Class对象

创建Class类对象的三种方式

• 对象.getClass()

• 类.class

• Class.forName("类的全路径")

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);

        // 方式一：通过对象获取
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        // 方式二：forName获取
        Class c2 = Class.forName("AnnotationAndReflect.Student");
        System.out.println(c2.hashCode());

        // 方式三：通过类名.class
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
    }
}

class Person{
    public 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 = "学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

类的加载与ClassLoader

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

  • 类的加载（Load）——> 类的链接（Link） ——> 类的初始化（Initialize）

  • 类的加载：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成

  • 类的链接：将类的二进制数据合并到JRE中

  • 类的初始化：JVM负责对类进行初始化

• 详细理解类加载过程

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

  • 链接：将java类的二进制代码合并到JVM的运行时状态中的过程

    • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题

    • 准备：正式为static修饰的类变量分配内存，并设置类变量默认值的阶段。这些内存都将在方法区中进行分配

    • 解析：将JVM常量池中的符号引用（常量名）替换为直接引用（地址）的过程

  • 初始化：

    • 执行类构造器() 方法的过程。

    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化

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

• 什么时候会发生类的初始化

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

    • 当虚拟机启动时，先初始化main方法所在的类

    • new一个类的对象

    • 调用类的静态成员和静态方法（final常量除外）

    • 使用java.lang.reflect包的方法对类进行反射调用

    • 当初始化一个类时，如果其父类没有被初始化，则会先初始化它的父类

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

    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化

    • 通过数组定义类引用，不会触发此类的初始化

    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

• 类加载器的作用：把类加载到内存中

  • 启动类加载器（Bootstrap Classloader）

  • 扩展类加载器（Extension Classloader）

  • 应用程序类加载器（System Classloader）

  • 自定义类加载器

public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2

        // 获取系统类加载器的父类加载器 ——> 扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@1540e19d

        // 获取扩展类加载器的父类加载器 ——> 启动类加载器 (c++写的，获取不到，会返回null)
        ClassLoader parent2 = parent.getParent();
        System.out.println(parent2); // null

        // 测试当前类是哪个类加载器加载的  --> 应用程序类加载器
        ClassLoader classLoader = Class.forName("AnnotationAndReflect.ClassLoaderDemo").getClassLoader();
        System.out.println(classLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2

        // 测试JDK内置类是谁加载的 --> 启动类加载器
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1); // null
    }

获取运行时类的完整结构

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

• Field、Method、Constructor、Superclass、Interface、Annotation

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        // Class c = Class.forName("AnnotationAndReflect.User");

        User user = new User();
        Class c1 = user.getClass();

        // 获取类的名字
        System.out.println(c1.getName()); // 获得包名+类名
        System.out.println(c1.getSimpleName()); // 获取类名

        // 获取类的属性
        Field[] fields = c1.getDeclaredFields();
        for(Field field: fields){
            System.out.println(field);
        }

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

        // 获取指定的方法  需要指定参数，因为方***有重载
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(setName);

        System.out.println("=====================");
        // 获取类的构造器
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        // 获取指定的构造器
        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        System.out.println(constructor);
    }

动态创建对象执行方法

有了Class对象，能够做什么？ —— 动态创建类的实例对象

• 第一种方式：可以创建类的对象。调用Class对象的newInstance()方法

  • 要求类必须有一个无参构造器

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

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

• 第二种方式：可以在操作的时候明确调用的构造器，并将参数传递进去，再实例化。操作步骤如下：

  • 通过Class类的 getDeclaredConstructors(Class ... parameterTypes) 取得本类的指定形参类型的构造器

  • 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数

  • 通过Constructor实例化对象

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException,                        NoSuchMethodException, InvocationTargetException {
        // 获取Class对象
        Class c = Class.forName("AnnotationAndReflect.User");
        // 构造一个对象
//        User user = (User) c.newInstance(); // 本质上是调用了类的无参构造器。如果类没有无参构造器，就会报错
//        System.out.println(user);

        // 通过构造器创建对象
//        Constructor constructor = c.getDeclaredConstructor(String.class, int.class, int.class);
//        User user2 = (User) constructor.newInstance("小明", 1, 3);
//        System.out.println(user2);

        // 通过反射调用普通方法
        User user3 = (User) c.newInstance();
        Method setName = c.getDeclaredMethod("setName", String.class); // 通过反射获取指定方法
        setName.invoke(user3, "小猪"); // 通过invoke()调用方法  invoke：激活的意思
        System.out.println(user3);

        // 通过反射操作属性
        User user4 =  (User) c.newInstance();
        Field name = c.getDeclaredField("name");
        name.setAccessible(true); // 关闭程序的安全检测，使私有的属性可以被操作
        name.set(user4, "张三");
        System.out.println(user4);
    }

Method、Field、Constructor对象都有 setAccessible() 方法。默认值为false，即开启程序安全检测。设置成true，可以实现通过反射操作类的私有属性、私有方法、和私有构造器。

性能分析 —— 不同调用方法的方式

/**
 * @author lixing
 * @date 2022-04-01 15:23
 * @description 性能分析：普通方法调用 优于 反射方式调用（关闭安全检测） 优于 反射方式调用（不关闭安全检测）
 */
public class Test05 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//        test01();
//        test02();
        test03();
    }

    // 普通方法调用
    public static void test01(){
        User user = new User();
        long start = System.currentTimeMillis();
        for(int i=0; i<1000000000; i++){
            user.getName();
        }
        long end = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次："+(end-start)+"ms"); // 4ms
    }

    // 反射方式调用
    public static void test02() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c = Class.forName("AnnotationAndReflect.User");
        User user = (User) c.newInstance();
        Method getName = c.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        long start = System.currentTimeMillis();
        for(int i=0; i<1000000000; i++){
            getName.invoke(user, null);
        }
        long end = System.currentTimeMillis();
        System.out.println("关闭检测执行10亿次："+(end-start)+"ms"); // 1353ms
    }

    // 反射方式调用 （不关闭检测）
    public static void test03() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c = Class.forName("AnnotationAndReflect.User");
        User user = (User) c.newInstance();
        Method getName = c.getDeclaredMethod("getName", null);
        long start = System.currentTimeMillis();
        for(int i=0; i<1000000000; i++){
            getName.invoke(user, null);
        }
        long end = System.currentTimeMillis();
        System.out.println("关闭检测执行10亿次："+(end-start)+"ms"); // 2510ms
    }

}

反射操作泛型

public class Test06 {

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

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

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test06.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes(); // 获取泛型的参数信息
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);
            if(genericParameterType instanceof ParameterizedType){ // 获取参数化类型里的类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
    }

}

反射操作注解

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        // 通过反射获取类的Class对象
        Class c = Class.forName("AnnotationAndReflect.Student2");
        // 通过反射获取注解
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        // 获取指定注解的value值
        TableKuang tableKuang = (TableKuang) c.getAnnotation(TableKuang.class);
        String value = tableKuang.value();
        System.out.println(value);

        // 获取类指定的注解
        Field field = c.getDeclaredField("name"); // 先通过反射获取属性
        FieldKuang fieldKuang = field.getAnnotation(FieldKuang.class); // 通过属性获取注解（属性上的注解）
        System.out.println(fieldKuang.columnName());
        System.out.println(fieldKuang.type());
        System.out.println(fieldKuang.length());
    }
}

@TableKuang("db_student")
class Student2{
    @FieldKuang(columnName = "db_id", type = "int", length = 10)
    private int id;
    @FieldKuang(columnName = "db_age", type = "int", length = 10)
    private int age;
    @FieldKuang(columnName = "db_name", type = "varchar", length = 3)
    private String name;

    public Student2(){}

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

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

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