反射-注解

注解

什么是注解？

类似一个标签，给字段、方法、类、做一个标记

注解不仅仅是通过反射一种方式来使用，也可以使用APT在编译期处理

为什么要用注解？

• 使用它们修饰我们的代码， 可以让我们提高程序的开发效率。
• 以及对代码施以规范，让代码更加有可读性

元注解

定义注解的存活时间，注解运用的地方等

@Target

说明了Annotation所修饰的对象范围

• TYPE:用于描述类、接口(包括注解类型) 或enum声明
• METHOD:用于描述方法
• CONSTRUCTOR:用于描述构造器
• PACKAGE:用于描述包
• PARAMETER:用于描述参数

@Retetion

定义了该Annotation被保留的时间长短

• SOURCE:在源文件中有效（即源文件保留）
  源码注解(RetentionPolicy.SOURCE)的生命周期只存在Java源文件这一阶段，是3种生命周期中最短的注解。当在Java源程序上加了一个注解，这个Java源程序要由javac去编译，javac把java源文件编译成.class文件，在编译成class时会把Java源程序上的源码注解给去掉。
  需要注意的是，在编译器处理期间源码注解还存在，即注解处理器Processor 也能处理源码注解，编译器处理完之后就没有该注解信息了

• CLASS:在class文件中有效（即class保留）

• RUNTIME:在运行时有效（即运行时保留）

@Documented

Documented是一个标记注解，没有成员

@Inherited

类继承关系中，子类会继承父类使用的注解中被@Inherited修饰的注解

接口继承关系中，子接口不会继承父接口中的任何注解，不管父接口中使用的注解有没有被@Inherited修饰

自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Test {
 public String name() default "name";
}

注解的使用解析

• 首先通过反射获取类信息，然后依次获取类、方法上面的注解内容。
• 至于属性上面的注解，可以使用Class.getDeclaredFields()获取所有的属性，然后进行遍历获取

//这里介绍下注解内容的获取，首先在使用注解到需要的类上
@Description(desc = "student",author = "imtianx",age = 20)
public class Student implements Person {
    public String name;
    @Description(desc = "run-M",author = "imtianx-M",age = 21)
    public void run() {
    }
    @Override
    public void sign() {
    }
    }
    
    //测试获取注解内容
    public class TestDemo01 {
    public static void main(String[] args) {
        try {
            //1.反射获取类信息
            Class c = Class.forName("Student");
            //2.获取类上面的注解
            boolean hasCAnno = c.isAnnotationPresent(Description.class);
            if (hasCAnno) {
                Description d = (Description) c.getAnnotation(Description.class);
                System.out.println(d.desc());
                System.out.println(d.author());
                System.out.println(d.age());
            }
            //3.获取方法上的注解
            Method[] methods = c.getMethods();
            for (Method method : methods) {
                boolean isMAnno = method.isAnnotationPresent(Description.class);
                if (isMAnno) {
                    Description md = method.getAnnotation(Description.class);
                    System.out.println(md.desc());
                    System.out.println(md.author());
                    System.out.println(md.age());
                }
            }
            //另一种获取注解的方式，以获取类上面的注解为例
            for (Method method : methods) {
                Annotation[] as = method.getDeclaredAnnotations();
                for (Annotation a : as) {
                    if (a instanceof Description) {
                        Description d = (Description) a;
                        System.out.println(d.desc());
                        System.out.println(d.author());
                        System.out.println(d.age());
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    }

APT

是一个注解处理工具 Annotation Processing Tool 作用：利用apt，我们可以找到源代中的注解，并根据注解做相应的处理

abstractProcessor

用来生成类文件的核心类，它是一个抽象类，一般使用的时候我们只要覆写它的方法中的4个就可以了

反射

什么是反射？

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象
https://blog.csdn.net/sinat_38259539/article/details/71799078

class对象

（1）类名.class：JVM将使用类装载器，将类装入内存(前提是:类还没有装入内存)，不做类的初始化工作，返回Class的对象。

（2）Class.forName(“类名字符串”)：装入类，并做类的静态初始化，返回Class的对象。

（3）实例对象.getClass()：对类进行静态初始化、非静态初始化；返回引用运行时真正所指的对象(子对象的引用会赋给父对象的引用变量中)所属的类的Class的对象。

在程序运行时，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性。这种动态的获取信息以及动态调用对象的方法的功能称为 java 的反射机制。

通过反射获取父类的私有属性

    @Test
    public void myTest() {
        CustomerApiInfoReqDtoNew t = new CustomerApiInfoReqDtoNew();//改成你要操作的子类
        Class className = t.getClass();
        Map<String, Object> param = new HashMap<>();
        try{
            for (; className != Object.class; className = className.getSuperclass()) {//获取本身和父级对象
                Field[] fields = className.getDeclaredFields();//获取所有私有字段
                for (Field field : fields) {
                    field.setAccessible(true);
                    param.put(field.getName(), field.get(t) == null ? "" : field.get(t));
                }
            }
            System.out.print(JsonUtil.toJson(param));//打印子类和父类所有字段，注意：JsonUtil改成你自己的json解析工具
        }catch (Exception e){
            e.printStackTrace();
        }
    }

JVM 是如何实现反射的？

反射呢是 Java 语言中一个相当重要的特性，它允许正在运行的 Java 程序观测，甚至是修改程序的动态行为。表现为两点，一是对于任意一个类，都能知道这个类的所有属性和方法，二是对于任意一个对象，都能调用它的任意属性和方法。

反射的使用还是比较简单的，涉及的 API 分为三类，Class、Member（Filed、Method、Constructor）、Array and Enumerated。我当时是直接扒 Oracle 官方文档看的，讲的很详细。

我对反射的好奇是来源于，经常会听说反射影响性能，那么性能开销在哪以及如何优化？

在此之前，我先讲讲 JVM 是如何实现反射的。

我们可以直接 new Exception 来查看方法调用的栈轨迹，在调用 Method.invoke() 时，是去调用 DelegatingMethodAccessorImpl 的 invoke，它的实际调用的是 NativeMethodAccessorImpl 的 invoke 方法。前者称为委派实现，后者称为本地实现。既然委派实现的具体实现是一个本地实现，那么为啥还需要委派实现这个中间层呢？其实，Java 反射调用机制还设立了另一种动态生成字节码的实现，成为动态实现，直接使用 invoke 指令来调用目标方法。之所以采用委派实现，是在本地实现和动态实现直接做切换。依据注释信息，动态实现比本地实现相比，其运行效率要快上 20 倍。这是因为动态实现无需经过 Java 到 C++ 再到 Java 的切换，但由于生产字节码比较耗时，仅调用一次的话，反而是本地实现要快上三四倍。考虑到很多反射调用仅会执行一次，JVM 设置了阈值 15，在 15 之下使用本地实现，高于 15 时便开始动态生成字节码采用动态实现。这也被称为 Inflation 机制。

在反手说一下反射的性能开销在哪呢？平时我们会调用 Class.forName、Class.getMethod、以及 Method.invoke 这三个操作。其中，Class.forName 会调用本地方法，Class.getMethod 则会遍历该类的公有方法，如果没有匹配到，它还将遍历父类的公有方法，可想而知，这两个操作都非常耗时。下面就是 Method.invoke 调用本身的开销了，首先是 invoke 方法的参数是一个可变长参数，也就是构建一个 Object 数组存参数，这也同时带来了基本数据类型的装箱操作，在 invoke 内部会进行运行时权限检查，这也是一个损耗点。普通方法调用可能有一系列优化手段，比如方法内联、逃逸分析，而这又是反射调用所不能做的，性能差距再一次被放大。

优化反射调用，可以尽量避免反射调用虚方法、关闭运行时权限检查、可能需要增大基本数据类型对应的包装类缓存、如果调用次数可知可以关闭 Inflation 机制，以及增加内联缓存记录的类型数目。