小白都能学会的 Java 注解与反射机制

关注

发布于: 2021 年 04 月 07 日

前言

Java 注解和反射是很基础的 Java 知识了，为何还要讲它呢？因为我在面试应聘者的过程中，发现不少面试者很少使用过注解和反射，甚至有人只能说出@Override这一个注解。我建议大家还是尽量能在开发中使用注解和反射，有时候使用它们能让你事半功倍，简化代码提高编码的效率。很多优秀的框架都基本使用了注解和反射，在 Spring AOP 中，就把注解和反射用得淋漓尽致。

什么是注解

Java 注解（Annotation）亦叫 Java 标注，是 JDK5.0 开始引入的一种注释机制。注解可以用在类、接口，方法、变量、参数以及包等之上。注解可以设置存在于不同的生命周期中，例如 SOURCE（源码中），CLASS（Class 文件中，默认是此保留级别），RUNTIME（运行期中）。

注解以@注解名的形式存在于代码中，Java 中内置了一些注解，例如@Override，当然我们也可以自定义注解。注解也可以有参数，例如 @MyAnnotation(value = "陈皮")。

@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}

复制代码

那注解有什么作用呢？其一是作为一种辅助信息，可以对程序做出一些解释，例如 @Override 注解作用于方法上，表示此方法是重写了父类的方法。其二，注解可以被其他程序读取，例如编译器，例如编译器会对被 @Override 注解的方法检测判断方法名和参数等是否与父类相同，否则会编译报错；而且在运行期可以通过反射机制访问某些注解信息。

内置注解

Java 中有 10 个内置注解，其中 6 个注解是作用在代码上的，4 个注解是负责注解其他注解的(即元注解)，元注解提供对其他注解的类型说明。

自定义注解

使用 @interface 关键字自定义注解，其实底层就是定义了一个接口，而且自动继承java.lang.annotation.Annotation接口。

我们自定义一个注解如下：

@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface MyAnnotation {    String value();}

复制代码

我们使用命令 javap 反编译我们定义的 MyAnnotation 注解的 class 文件，结果显示如下。虽然注解隐式继承了 Annotation 接口，但是 Java 不允许我们显示通过 extends 关键字继承 Annotation 接口甚至其他接口，否则编译报错。

D:\>javap MyAnnotation.classCompiled from "MyAnnotation.java"public interface com.nobody.MyAnnotation extends java.lang.annotation.Annotation {  public abstract java.lang.String value();}

复制代码

注解的定义内容如下：

格式为 public @interface 注解名 {定义内容}
内部的每一个方法实际是声明了一个参数，方法的名称就是参数的名称。
返回值类型就是参数的类型，而且返回值类型只能是基本类型（int，float，long，short，boolean，byte，double，char），Class，String，enum，Annotation 以及上述类型的数组形式。
如果定义了参数，可通过 default 关键字声明参数的默认值，若不指定默认值，使用时就一定要显示赋值，而且不允许使用 null 值，一般会使用空字符串或者 0。
如果只有一个参数，一般参数名为 value，因为使用注解时，赋值可以不显示写出参数名，直接写参数值。

import java.lang.annotation.*;
/** * @Description 自定义注解 * @Author Mr.nobody * @Date 2021/3/30 * @Version 1.0 */@Target(ElementType.METHOD) // 此注解只能用在方法上。@Retention(RetentionPolicy.RUNTIME) // 此注解保存在运行时期，可以通过反射访问。@Inherited // 说明子类可以继承此类的此注解。@Documented // 此注解包含在用户文档中。public @interface CustomAnnotation {    String value(); // 使用时需要显示赋值    int id() default 0; // 有默认值，使用时可以不赋值}

复制代码

/** * @Description 测试注解 * @Author Mr.nobody * @Date 2021/3/30 * @Version 1.0 */public class TestAnnotation {
    // @CustomAnnotation(value = "test") 只能注解在方法上，这里会报错    private String str = "Hello World!";
    @CustomAnnotation(value = "test")    public static void main(String[] args) {        System.out.println(str);    }}

复制代码

Java8 注解

在这里讲解下 Java8 之后的几个注解和新特性，其中一个注解是 @FunctionalInterface，它作用在接口上，标识是一个函数式接口，即只有有一个抽象方法，但是可以有默认方法。

@FunctionalInterfacepublic interface Callback<P,R> {
    public R call(P param);}

复制代码

还有一个注解是 @Repeatable，它允许在同一个位置使用多个相同的注解，而在 Java8 之前是不允许的。

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Repeatable(OperTypes.class)public @interface OperType {    String[] value();}

复制代码

// 可以理解@OperTypes注解作为接收同一个类型上重复@OperType注解的容器@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface OperTypes {    OperType[] value();}

复制代码

@OperType("add")@OperType("update")public class MyClass {    }

复制代码

注意，对于重复注解，不能再通过 clz.getAnnotation(Class<A> annotationClass)方法来获取重复注解，Java8 之后，提供了新的方法来获取重复注解，即 clz.getAnnotationsByType(Class<A> annotationClass)方法。

package com.nobody;
import java.lang.annotation.Annotation;
/** * @Description * @Author Mr.nobody * @Date 2021/3/31 * @Version 1.0 */@OperType("add")@OperType("update")public class MyClass {
    public static void main(String[] args) {        Class<MyClass> clz = MyClass.class;        Annotation[] annotations = clz.getAnnotations();        for (Annotation annotation : annotations) {            System.out.println(annotation.toString());        }
        OperType operType = clz.getAnnotation(OperType.class);        System.out.println(operType);
        OperType[] operTypes = clz.getAnnotationsByType(OperType.class);        for (OperType type : operTypes) {            System.out.println(type.toString());        }    }
}
// 输出结果为@com.nobody.OperTypes(value=[@com.nobody.OperType(value=[add]), @com.nobody.OperType(value=[update])])null@com.nobody.OperType(value=[add])@com.nobody.OperType(value=[update])

复制代码

在 Java8 中，ElementType 枚举新增了两个枚举成员，分别为 TYPE_PARAMETER 和 TYPE_USE，TYPE_PARAMETER 标识注解可以作用于类型参数，TYPE_USE 标识注解可以作用于标注任意类型(除了 Class)。

Java 反射机制

我们先了解下什么是静态语言和动态语言。动态语言是指在运行时可以改变其自身结构的语言。例如新的函数，对象，甚至代码可以被引进，已有的函数可以被删除或者结构上的一些变化。简单说即是在运行时代码可以根据某些条件改变自身结构。动态语言主要有 C#，Object-C，JavaScript，PHP，Python 等。静态语言是指运行时结构不可改变的语言，例如 Java，C，C++等。

Java 不是动态语言，但是它可以称为准动态语言，因为 Java 可以利用反射机制获得类似动态语言的特性，Java 的动态性让它在编程时更加灵活。

反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性以及方法等。类在被加载完之后，会在堆内存的方法区中生成一个 Class 类型的对象，一个类只有一个 Class 对象，这个对象包含了类的结构信息。我们可以通过这个对象看到类的结构。

比如我们可以通过Class clz = Class.forName("java.lang.String");获得 String 类的 Class 对象。我们知道每个类都隐式继承 Object 类，Object 类有个getClass()方法也能获取 Class 对象。

Java 反射机制提供的功能

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

Java 反射机制的优缺点

优点：实现动态创建对象和编译，有更加的灵活性。
缺点：对性能有影响。使用反射其实是一种解释操作，即告诉 JVM 我们想要做什么，然后它满足我们的要求，所以总是慢于直接执行相同的操作。

Java 反射相关的主要 API

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

我们知道在运行时通过反射可以准确获取到注解信息，其实以上类（Class，Method，Field，Constructor 等）都直接或间接实现了 AnnotatedElement 接口，并实现了它定义的方法，AnnotatedElement 接口的作用主要用于表示正在 JVM 中运行的程序中已使用注解的元素，通过该接口提供的方法可以获取到注解信息。

java.lang.Class 类

在 Java 反射中，最重要的是 Class 这个类了。Class 本身也是一个类。当程序想要使用某个类时，如果此类还未被加载到内存中，首先会将类的 class 文件字节码加载到内存中，并将这些静态数据转换为方法区的运行时数据结构，然后生成一个 Class 类型的对象（Class 对象只能由系统创建），一个类只有一个 Class 对象，这个对象包含了类的结构信息。我们可以通过这个对象看到类的结构。每个类的实例都会记得自己是由哪个 Class 实例所生成的。

通过 Class 对象可以知道某个类的属性，方法，构造器，注解，以及实现了哪些接口等信息。注意，只有 class，interface，enum，annotation，primitive type，void，[] 等才有 Class 对象。

package com.nobody;
import java.lang.annotation.ElementType;import java.util.Map;
public class TestClass {
    public static void main(String[] args) {
        // 类        Class<MyClass> myClassClass = MyClass.class;        // 接口        Class<Map> mapClass = Map.class;        // 枚举        Class<ElementType> elementTypeClass = ElementType.class;        // 注解        Class<Override> overrideClass = Override.class;        // 原生类型        Class<Integer> integerClass = Integer.class;        // 空类型        Class<Void> voidClass = void.class;        // 一维数组        Class<String[]> aClass = String[].class;        // 二维数组        Class<String[][]> aClass1 = String[][].class;        // Class类也有Class对象        Class<Class> classClass = Class.class;
        System.out.println(myClassClass);        System.out.println(mapClass);        System.out.println(elementTypeClass);        System.out.println(overrideClass);        System.out.println(integerClass);        System.out.println(voidClass);        System.out.println(aClass);        System.out.println(aClass1);        System.out.println(classClass);    }}
// 输出结果class com.nobody.MyClassinterface java.util.Mapclass java.lang.annotation.ElementTypeinterface java.lang.Overrideclass java.lang.Integervoidclass [Ljava.lang.String;class [[Ljava.lang.String;class java.lang.Class

复制代码

获取 Class 对象的方法

如果知道具体的类，可通过类的 class 属性获取，这种方法最安全可靠并且性能最高。Class clz = User.class;
通过类的实例的 getClass()方法获取。Class clz = user.getClass();
如果知道一个类的全限定类名，并且在类路径下，可通过 Class.forName()方法获取，但是可能会抛出 ClassNotFoundException。Class clz = Class.forName("com.nobody.User");
内置的基本数据类型可以直接通过类名.Type 获取。Class<Integer> clz = Integer.TYPE;
通过类加载器 ClassLoader 获取

Class 类的常用方法

public static Class<?> forName(String className)：创建一个指定全限定类名的 Class 对象
public T newInstance()：调用 Class 对象所代表的类的无参构造方法，创建一个实例
public String getName()：返回 Class 对象所代表的类的全限定名称。
public String getSimpleName()：返回 Class 对象所代表的类的简单名称。
public native Class<? super T> getSuperclass()：返回 Class 对象所代表的类的父类的 Class 对象，这是一个本地方法
public Class<?>[] getInterfaces()：返回 Class 对象的接口
public Field[] getFields()：返回 Class 对象所代表的实体的 public 属性 Field 对象数组
public Field[] getDeclaredFields()：返回 Class 对象所代表的实体的所有属性 Field 对象数组
public Field getDeclaredField(String name)：获取指定属性名的 Field 对象
public Method[] getDeclaredMethods()：返回 Class 对象所代表的实体的所有 Method 对象数组
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回指定名称和参数类型的 Method 对象
myClassClass.getDeclaredConstructors();：返回所有 Constructor 对象的数组
public ClassLoader getClassLoader()：返回当前类的类加载器

在反射中经常会使用到 Method 的 invoke 方法，即public Object invoke(Object obj, Object... args)，我们简单说明下：

第一个 Object 对应原方法的返回值，若原方法没有返回值，则返回 null。
第二个 Object 对象对应调用方法的实例，若原方法为静态方法，则参数 obj 可为 null。
第二个 Object 对应若原方法形参列表，若参数为空，则参数 args 为 null。
若原方法声明为 private 修饰，则调用 invoke 方法前，需要显示调用方法对象的 method.setAccessible(true)方法，才可访问 private 方法。

反射操作泛型

泛型是 JDK 1.5 的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候再指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

在 Java 中，采用泛型擦除的机制来引入泛型，泛型能编译器使用 javac 时确保数据的安全性和免去强制类型转换问题，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。并且一旦编译完成，所有和泛型有关的类型会被全部擦除。

Java 新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType等几种类型，能让我们通过反射操作这些类型。

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

package com.nobody;
import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.Map;
public class TestReflectGenerics {
    public Map<String, Person> test(Map<String, Integer> map, Person person) {        return null;    }
    public static void main(String[] args) throws NoSuchMethodException {        // 获取test方法对象        Method test = TestReflectGenerics.class.getDeclaredMethod("test", Map.class, Person.class);        // 获取方法test的参数类型        Type[] genericParameterTypes = test.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);                }            }        }
        // 获取方法test的返回值类型        Type genericReturnType = test.getGenericReturnType();        System.out.println("返回值类型：" + genericReturnType);        // 如果参数类型等于参数化类型        if (genericReturnType instanceof ParameterizedType) {            // 获得真实参数类型            Type[] actualTypeArguments =                    ((ParameterizedType) genericReturnType).getActualTypeArguments();            for (Type actualTypeArgument : actualTypeArguments) {                System.out.println("    " + actualTypeArgument);            }        }
    }}
class Person {}
// 输出结果方法参数类型：java.util.Map<java.lang.String, java.lang.Integer>    class java.lang.String    class java.lang.Integer方法参数类型：class com.nobody.Person返回值类型：java.util.Map<java.lang.String, com.nobody.Person>    class java.lang.String    class com.nobody.Person

复制代码

反射操作注解

在 Java 运行时，通过反射获取代码中的注解是比较常用的手段了，获取到了注解之后，就能知道注解的所有信息了，然后根据信息进行相应的操作。下面通过一个例子，获取类和属性的注解，解析映射为数据库中的表信息。

package com.nobody;
import java.lang.annotation.*;
public class AnalysisAnnotation {
    public static void main(String[] args) throws Exception {        Class<?> aClass = Class.forName("com.nobody.Book");        // 获取类的指定注解，并且获取注解的值        Table annotation = aClass.getAnnotation(Table.class);        String value = annotation.value();        System.out.println("Book类映射的数据库表名：" + value);
        java.lang.reflect.Field bookName = aClass.getDeclaredField("bookName");        TableField annotation1 = bookName.getAnnotation(TableField.class);        System.out.println("bookName属性映射的数据库字段属性 - 列名：" + annotation1.colName() + ",类型："                + annotation1.type() + ",长度：" + annotation1.length());        java.lang.reflect.Field price = aClass.getDeclaredField("price");        TableField annotation2 = price.getAnnotation(TableField.class);        System.out.println("price属性映射的数据库字段属性 - 列名：" + annotation2.colName() + ",类型："                + annotation2.type() + ",长度：" + annotation2.length());    }}
// 作用于类的注解，用于解析表数据@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@interface Table {    // 表名    String value();}
// 作用于字段，用于解析表列@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@interface TableField {    // 列名    String colName();
    // 列类型    String type();
    // 长度    int length();}
@Table("t_book")class Book {    @TableField(colName = "name", type = "varchar", length = 15)    String bookName;    @TableField(colName = "price", type = "int", length = 10)    int price;}
// 输出结果Book类映射的数据库表名：t_bookbookName属性映射的数据库字段属性 - 列名：name,类型：varchar,长度：15price属性映射的数据库字段属性 - 列名：price,类型：int,长度：10

复制代码

性能分析

前面我们说过，反射对性能有一定影响。因为反射是一种解释操作，它总是慢于直接执行相同的操作。而且 Method，Field，Constructor 都有 setAccessible()方法，它的作用是开启或禁用访问安全检查。如果我们程序代码中用到了反射，而且此代码被频繁调用，为了提高反射效率，则最好禁用访问安全检查，即设置为 true。

package com.nobody;
import java.lang.reflect.Method;
public class TestReflectSpeed {
    // 10亿次    private static int times = 1000000000;
    public static void main(String[] args) throws Exception {        test01();        test02();        test03();    }
    public static void test01() {        Teacher t = new Teacher();        long start = System.currentTimeMillis();        for (int i = 0; i < times; i++) {            t.getName();        }        long end = System.currentTimeMillis();        System.out.println("普通方式执行10亿次消耗：" + (end - start) + "ms");    }
    public static void test02() throws Exception {        Teacher teacher = new Teacher();        Class<?> aClass = Class.forName("com.nobody.Teacher");        Method getName = aClass.getDeclaredMethod("getName");        long start = System.currentTimeMillis();        for (int i = 0; i < times; i++) {            getName.invoke(teacher);        }        long end = System.currentTimeMillis();        System.out.println("反射方式执行10亿次消耗：" + (end - start) + "ms");    }
    public static void test03() throws Exception {        Teacher teacher = new Teacher();        Class<?> aClass = Class.forName("com.nobody.Teacher");        Method getName = aClass.getDeclaredMethod("getName");        getName.setAccessible(true);        long start = System.currentTimeMillis();        for (int i = 0; i < times; i++) {            getName.invoke(teacher);        }        long end = System.currentTimeMillis();        System.out.println("关闭安全检查反射方式执行10亿次消耗：" + (end - start) + "ms");    }
}

class Teacher {
    private String name;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }}
//输出结果普通方式执行10亿次消耗：13ms反射方式执行10亿次消耗：20141ms关闭安全检查反射方式执行10亿次消耗：8233ms

复制代码

通过实验可知，反射比直接执行相同的方法慢了很多，特别是当反射的操作被频繁调用时效果更明显，当然通过关闭安全检查可以提高一些速度。所以，放射也不应该泛滥成灾的，而是适度使用才能发挥最大作用。

发布于: 2021 年 04 月 07 日阅读数: 24

原文链接:【http://xie.infoq.cn/article/e1b312647dfb2ffda58049b32】。未经作者许可，禁止转载。

陈皮的JavaLib

关注

CSDN博客专家，微信搜一搜 - 陈皮的JavaLib 2020.02.22 加入

CSDN博客专家，专注各项技术领域的Java开发工程师，微信搜一搜【陈皮的JavaLib】，关注后学习更多技术文章和一线大厂面试资料和技术电子书籍。

发布

暂无评论

创作场景

小白都能学会的 Java 注解与反射机制

前言

什么是注解

内置注解

自定义注解

Java8 注解

Java 反射机制

java.lang.Class 类

反射操作泛型

反射操作注解

性能分析

陈皮的JavaLib

评论