秋招冲刺系列（1）：Java注解与反射详解-每日运维

当前，2024届秋招正在如火如荼地进行中。在复习的过程中，逐渐地发现了一些以前掌握得不牢固的地方，于是通过写博客的方式加以巩固。在这个系列中，不会重复一些比较基础的内容，而是重点巩固中等偏难或面试中的热点问题。本篇的主题是Java注解与反射，它们的重要性不言而喻，在Mybatis、Spring/Spring Boot等框架中应用广泛。因此，理解Java的注解与反射机制，也有助于理解常用框架的工作机理。

注解

Java注解（Annotation）是JDK 1.5后引入的一种给代码添加信息的一种形式化方法，常用的注解一共有7个，包含3个内置注解和4个元注解，分别位于java.lang和java.lang.annotation中。

内置注解

常用内置注解一共有三个，它们分别是：

@Override: 重写注解，一般用在子类继承父类后重写某个方法时，或是实现某个接口定义的方法时。如果父类或者接口中没有该方法，则会报错。
@Deprecated: 废弃注解，用于指示不再鼓励使用的元素（一般情况下，继续使用也不会有太大问题，但是不推荐），该元素可能会在以后的版本中不兼容或删除，通常是被更好的方法所取代。
@SuppressWarnings: 抑制警告注解，用于忽略编译器的警告。特别地，该注解必须传递参数value的值，该参数是一个String类型的数组，指示了要在注释元素中由编译器抑制的警告集。

示例	含义
@SuppressWarnings("all")	忽略所有警告信息。
@SuppressWarnings("unchecked")	忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。
@SuppressWarnings("serial")	忽略序列化警告，当实现了序列化接口的类上缺少serialVersionUID属性的定义时，会出现黄色警告。
@SuppressWarnings("deprecation")	当使用@Deprecated注释的方法，忽略警告信息。
@SuppressWarnings("unchecked", "deprecation")	同时忽略unchecked和deprecation的警告信息。

@SuppressWarnings(value={"unchecked", "deprecation"})等同于@SuppressWarnings("unchecked", "deprecation")

如下代码，@Override标识了重写Object类的toString()方法，@Deprecated标识了test()已被弃用，因此在调用test()方法时会有警告（具体在IDE中表现为对应方法名颜色加深，且在调用时会有一根横线），而@SuppressWarnings("all")则指示忽略所有的警告。

public class Test01 {
    @Override
    public String toString() {
        return super.toString();
    }

    @SuppressWarnings("all")
    @Deprecated
    public static void test() {
        System.out.println("Deprecated");
    }

    public static void main(String[] args) {
        test();
    }
}

元注解

所谓元注解就是标注其他注解的注解，常用元注解一共有四个：

@Documented：标记这些注解是否包含在JavaDoc中。
@Inherited：表示自动继承注释类型，子类可以继承父类中的该注解。
@Retention：指示要在什么级别保存该注释信息，用于描述注解的生命周期。
- RetentionPolicy.SOURCE: 注释只保存在源文件中，当Java文件被编译成class文件的时候，注释就被遗弃。
- RetentionPolicy.CLASS：注释被保留到class文件中，当JVM加载class文件时被遗弃，这是默认的生命周期。
- RetentionPolicy.RUNTIME：当JVM加载class文件开始运行时，仍然存在。
@Target：用于指示注释的使用范围。其参数value是一个ElementType数组，具体取值如下：

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

自定义注解

可以使用@interface来自定义注解，注解的参数定义与方法类似：

方法的名称就是参数的名称
返回值类型就是参数的类型（只能是基本类型、Class、String、enum）
可以通过default来声明参数的默认值，如果没有默认值则必须给参数传递一个值
如果只有一个参数成员，则一般参数名为value，这样在传参时就不要指定参数名了
注解的元素必须要有值，常用空字符串、0作为默认值

如下代码，定义了两个注解，在使用MyAnnotation1时由于age没有默认值且参数名不是value，所以必须显式地传参赋值。而对于MyAnnotation2，参数value同样没有默认值，但是只需要传参即可，不必显式地给它赋值。

package annotation;

import java.lang.annotation.*;

public class Test02 {

    @MyAnnotation1(age = 18)
    public static void test1(){
        System.out.println("test1");
    }

    @MyAnnotation2("张三")
    public static void test2(){
        System.out.println("test2");
    }

    public static void main(String[] args) {
        test1();
        test2();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@interface MyAnnotation1{
    String name() default "";
    int age();
    int id() default -1; // 默认值为-1，代表不存在
    String[] schools() default {"清华大学", "北京大学"};
}

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

反射

众所周知，Java是一门静态语言，但是，反射（Reflection）机制的存在可以使Java变成“准动态语言”。通过反射机制，可以使Java获得类似动态语言的特性，可以实现动态创建对象和编译，从而使编程更加灵活。但是，反射机制也会产生一些安全性问题，并一定程度降低性能。因为，反射基本上是一种解释操作，通过它我们可以告诉JVM，我们希望做什么然后JVM要满足我们的要求。这类操作总是慢于直接执行相同的操作。

动态语言：一类可以在运行时改变其结构的语言，例如：新的函数、对象甚至代码可以被引进，已有的函数可以被删除，或是其他结构上的变化。通俗点说就是代码可以在运行时根据某些条件改变自身结构。静态语言的代表有C#、JavaScript、Python等。
静态语言：与动态语言相反，运行时结构不可变的语言就是静态语言，例如Java、C、C++。

反射概述

反射的定义

反射机制允许程序在运行时通过Reflection API获取任何类的内部信息，并且能直接操作任意对象的内部属性及方法。在加载完类之后，堆内存的方法区就产生了一个Class类型的对象（一个类只有Class对象，如下代码所示），这个对象包含了完整的类的结构信息。通过Class对象，可以看到类的结构，得到完整的类的名称，这就是所谓的反射。

package annotation;

public class Test03 {

    public static void main(String[]args) throws ClassNotFoundException {
        // 通过反射获取class对象
        Class c1 = Class.forName("annotation.User");
        Class c2 = Class.forName("annotation.User");
        System.out.println(c1 == c2); // 输出true
    }

}

class User {...}

反射的作用：

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

反射的主要API:

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

Class类

Class类是一个特殊类，它用于表示JVM运行时类（runtime class）或接口的信息。Class类提供很多方法用于获取类的各种信息，比如属性、方法、构造器等等。Class类默认的父类也是Object，可以通过Object的getClass()方法获得。

Class类的特性

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

Class类的常用方法

获取Class对象的方式

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

代码示例如下：

package annotation;

public class Test04 {

    public static void main(String[] args) throws ClassNotFoundException {

        // 方式一：通过类的class属性获取
        Class c1 = Student.class;
        System.out.println(c1);

        // 方式二：通过类的实例的getClass()方法获取
        Student stu = new Student();
        Class c3 = Class.forName("annotation.Student");
        System.out.println(c3 == c2);

        // 方式四：基本内置类型的包装类都有一个TYPE属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        // 方式五：通过子类的Class对象调用getSuperclass()方法获取
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
    }

}

什么时候发生类的初始化？

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final变量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当调用一个类，如果其父类没有被初始化，则先会初始化其父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。例如，通过子类调用父类的静态变量，子类不会被初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就被存入调用类的常量池中了）

package annotation;

public class Test06 {
    static {
        System.out.println("main类被初始化");
    }

    public static void main(String[] args) throws ClassNotFoundException {

        // new一个类的对象
        Son son = new Son();

        // 反射调用
        Class.forName("annotation.Son");

        // 调用类的静态成员（除了final变量）和静态方法
        System.out.println(Father.b);

        // 当调用一个类，如果其父类没有被初始化，则先会初始化其父类
        System.out.println(Son.m);

        // 通过子类调用父类的静态变量，子类不会被初始化
        System.out.println(Son.b);

        // 引用常量不会触发此类的初始化
        System.out.println(Son.M);

        // 通过数组定义类引用，不会触发此类的初始化
        Son[] arr = new Son[5];
    }
}

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 M = 1;
}

类加载内存分析

类加载器

类加载器的作用：将class字节码文件内容加载到内存中，并将静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

秋招冲刺系列（1）：Java注解与反射详解-1

在JVM规范中，把类加载器分了两种：

⼀种是BootStrapClassLoader，这是由C和C++实现的，负责加载jre/lib下的jar包中的类，⽐如
rt.jar中的String类
⼀种是继承了ClassLoader抽象类的类加载器，是由Java语⾔实现的，⽐如：
- ExtClassLoader，⽤Java实现的，加载⽬录为jre/lib/ext⽬录下的类
- AppClassLoader，也叫系统类加载器，⽤Java实现的，加载⽬录为classpath所指定的⽬录
- 以及其他⾃定义的，⽐如Tomcat中的WebAppClassLoader

package annotation;

public class Test07 {

    public static void main(String[] args) throws ClassNotFoundException {

        // 获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader); // AppClassLoader

        // 获取系统类加载器的父类-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent); // ExtClassLoader

        // 获取扩展类加载器的父类-->启动类加载器(由c/c++编写，获取不到)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1); // null

        // 测试当前类是哪个类加载器加载的
        ClassLoader classLoader = Class.forName("annotation.Test07").getClassLoader();
        System.out.println(classLoader); // AppClassLoader

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

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

获取类的运行时数据结构

通过反射获取运行时类的完整数据结构：Field、Method、Constructor、Annotation、Interface、Superclass等。

getXXX()：获得本类及其父类全部public修饰的XXX。
getDeclaredXXX()：获得本类的所有XXX，不论是否为public修饰。

package annotation;

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

public class Test08 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class aClass = Class.forName("java.lang.String");

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

        System.out.println("________分割线_______");
        // 获取类的属性
        Field[] fields = aClass.getFields(); // 只能找到public属性
        for (Field field : fields) {
            System.out.println(field);
        }

        fields = aClass.getDeclaredFields(); // 找到全部属性
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("________分割线_______");
        // 获得指定的属性
        System.out.println(aClass.getDeclaredField("hash"));

        // 获取类的方法
        Method[] methods = aClass.getMethods(); // 获得本类及其父类全部public方法
        for (Method method : methods) {
            System.out.println("Methods:" + method);
        }

        methods = aClass.getDeclaredMethods(); // 获得本类的所有方法
        for (Method method : methods) {
            System.out.println("DeclaredMethods:" + method);
        }

        // 获取指定的方法
        Method equals = aClass.getMethod("equals", Object.class);
        System.out.println(equals);
        Method length = aClass.getMethod("length", null);
        System.out.println(length);

        // 获得指定的构造器
        Constructor[] constructors = aClass.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        constructors = aClass.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        // 获得指定的构造器
        Constructor constructor = aClass.getConstructor(byte[].class);
        System.out.println(constructor);
    }
}

动态创建对象执行方法

动态创建对象：

创建对象需要调用Class对象的newInstance()方法，它本质上是调用了类的无参构造器。
如果需要使用有参构造器，则需要通过Class对象的getDeclaredConstructor()方法获取类中指定形参类型的构造器，然后通过构造器去调用newInstance()方法并传递所需的各个参数。

调用指定的方法：

通过Class对象的getMethod()方法获取一个Method对象，并设置此方法操作时所需的参数类型。

然后通过Method对象去调用invoke()方法，并向方法中传递要设置的obj对象及参数信息。

操作指定的属性

通过Class对象的getField()方法获取一个Field对象，并设置此方法操作时所需的参数类型。
通过Field对象的set()方法操作属性，并向方法中传递要操作的obj对象及参数信息。

代码示例：

package annotation;

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

// 通过反射动态创建对象
public class Test09 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

        // 通过newInstance()创建对象，本质上是调用了无参构造器
        Class aClass = Class.forName("annotation.User");
        User user1 = (User) aClass.newInstance();
        System.out.println(user1);

        // 通过构造器创建对象
        Constructor constructor = aClass.getDeclaredConstructor(String.class, int.class);
        User user2 = (User) constructor.newInstance("张三", 18);
        System.out.println(user2);

        // 通过反射调用普通方法
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        setName.invoke(user1, "李四");
        System.out.println(user1.getName());

        // 通过反射操作属性
        Field age = aClass.getDeclaredField("age");
        age.setAccessible(true); // 私有属性不能直接操作，需要设置为可见
        age.set(user1, 20);
        System.out.println(user1.getAge());
    }
}

性能对比分析

当Method、Field或Constructor对象被private修饰的时候，则无法被外界所访问。通过调用对象的setAccessible()方法可将其设置为可访问。本质上，setAccessible()是启用和禁用访问安全检查的开关。参数值为 true 指示反射的对象在使用时应该取消 Java 语言访问检查，值为 false 则指示反射的对象应该实施 Java 语言访问检查。由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的。

通过下面这段代码可以来测试不同方式执行指定方法的性能。根据测试结果，不难发现，通过反射的方式去调用类的方法确实比正常方式性能更低，且关闭安全检查确实能提升反射速度。

package annotation;

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

public class Test10 {

    // 普通方式调用
    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");
    }

    // 反射方式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class、 aClass = Class.forName("annotation.Good");

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

        // 获取指定注解的value值
        TableAnnotation annotation = aClass.getAnnotation(TableAnnotation.class);
        System.out.println(annotation.value());

        // 获取类中指定成员的注解
        Field name = aClass.getDeclaredField("id");
        FieldAnnotation annotation1 = name.getAnnotation(FieldAnnotation.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }

}

@TableAnnotation("db_good")
class Good {
    @FieldAnnotation(columnName = "db_name", type = "varchar", length = 10)
    private String name;
    @FieldAnnotation(columnName = "db_price", type = "float", length = 8)
    private float price;
    @FieldAnnotation(columnName = "db_id", type = "int", length = 6)
    private int id;

    public String getName() {
        return name;
    }

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

    public float getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getId() {
        return id;
    }

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

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
    String columnName();
    String type();
    int length();
}

Reference

注解和反射01：什么是注解_哔哩哔哩_bilibili

秋招冲刺系列（1）：Java注解与反射详解

内置注解

元注解

自定义注解

反射概述

反射的定义

反射的作用：

反射的主要API:

Class类

Class类的特性

Class类的常用方法

获取Class对象的方式

什么时候发生类的初始化？

类加载内存分析

类加载器

获取类的运行时数据结构

动态创建对象执行方法

相关文章

发布评论取消回复

法医

百度搜索：蓝易云 – JDK1.8在LINUX下安装教程

万字长文 | MatrixOne 的 MySQL 协议实现

一个简单小工具obtool，助你成为Oceanbase高级专家

秋招冲刺系列（1）：Java注解与反射详解

内置注解

元注解

自定义注解

反射概述

反射的定义

反射的作用：

反射的主要API:

Class类

Class类的特性

Class类的常用方法

获取Class对象的方式

什么时候发生类的初始化？

类加载内存分析

类加载器

获取类的运行时数据结构

动态创建对象执行方法

相关文章

发布评论 取消回复

法医

百度搜索：蓝易云 – JDK1.8在LINUX下安装教程

万字长文 | MatrixOne 的 MySQL 协议实现

一个简单小工具obtool，助你成为Oceanbase高级专家

发布评论取消回复