1.基础

1、反射的基础及定义：

Java反射机制是在运行状态中，对于任意一个类，应用都能够知道这个类中的场景所有属性和方法；对于任意一个对象，都能够调用它的反射任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。

2、基础及Java 反射机制的应用功能

• 在运行时判断任意一个对象所属的类。
• 在运行时构造任意一个类的场景对象。
• 在运行时判断任意一个类所具有的反射成员变量和方法。
• 在运行时调用任意一个对象的基础及方法。
• 生成动态代理。应用

3Java 反射机制的场景应用场景

• 逆向代码 ，例如反编译
• 与注解相结合的反射框架，例如 Retrofit
• 单纯的基础及反射机制应用框架，例如 EventBus
• 动态生成类框架 例如Gson

4、应用获取Class对象的三种方式

//第一种方式 通过Class类的静态方法——forName()来实现class1 = Class.forName("com.tsp.reflection.Person");//第二种方式 通过类的class属性class1 = Person.class;//第三种方式 通过对象getClass方法Person person = new Person();Classclass1 = person.getClass();

5、通过反射生成并操作对象

1.生成类的实例对象

1.使用 Class对象的newInstance()方法来创建该Class对象对应类的实例。这种方式要求该Class对象的对应类有默认构造器，而执行newInstance()方法时实际上是利用默认构造器来创建该类的实例。

2.先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。通过这种方式可以选择使用指定的构造器来创建实例。

//第一种方式 Class对象调用 newInstance()方法生成Object obj = class1.newInstance();//第二种方式 对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成Constructorconstructor = class1.getDeclaredConstructor(String.class);//获取指定声明构造函数obj = constructor.newInstance("hello");

2. 获取class对象的属性、方法、构造函数等

// 1. 获取class对象的成员变量Field[] allFields = class1.getDeclaredFields();//获取class对象的所有属性Field[] publicFields = class1.getFields();//获取class对象的public属性Field ageField = class1.getDeclaredField("age");//获取class指定属性Field desField = class1.getField("des");//获取class指定的public属性///2. 获取class对象的方法Method[] methods = class1.getDeclaredMethods();//获取class对象的所有声明方法Method[] allMethods = class1.getMethods();//获取class对象的所有public方法 包括父类的方法Method method = class1.getMethod("info", String.class);//返回次Class对象对应类的、带指定形参列表的public方法Method declaredMethod = class1.getDeclaredMethod("info", String.class);//返回次Class对象对应类的、带指定形参列表的方法// 3.获取class对象的构造函数Constructor[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数Constructor[] publicConstructors = class1.getConstructors();//获取class对象public构造函数Constructorconstructor = class1.getDeclaredConstructor(String.class);//获取指定声明构造函数Constructor publicConstructor = class1.getConstructor(String.class);//获取指定声明的public构造函数//4.其他方法Annotation[] annotations = (Annotation[]) class1.getAnnotations();//获取class对象的所有注解Annotation annotation = (Annotation) class1.getAnnotation(Deprecated.class);//获取class对象指定注解Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 TypeType[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的type集合

3.通过反射调用对象的方法

通过Class对象的getMethods()方法或者getMethod()方法获得指定方法，返回Method数组或对象。

调用Method对象中的Object invoke(Object obj, Object... args)方法。第一个参数对应调用该方法的实例对象，第二个参数对应该方法的参数。

// 生成新的对象：用newInstance()方法 Object obj = class1.newInstance(); //首先需要获得与该方法对应的Method对象Method method = class1.getDeclaredMethod("setAge", int.class);//调用指定的函数并传递参数method.invoke(obj, 28);

当通过Method的invoke()方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限。如果程序确实需要调用某个对象的private方法，则可以先调用Method对象的如下方法。setAccessible(boolean flag)：将Method对象的acessible设置为true来获取访问权限。

4.访问成员变量值

通过Class对象的getFields()方法或者getField()方法获得指定方法，返回Field数组或对象。

Field提供了两组方法来读取或设置成员变量的值：getXXX(Object obj):获取obj对象的该成员变量的值。此处的XXX对应8种基本类型。
如果该成员变量的类型是引用类型，则取消get后面的XXX。setXXX(Object obj,XXX val)：将obj对象的该成员变量设置成val值。

//生成新的对象：用newInstance()方法 Object obj = class1.newInstance();//获取age成员变量Field field = class1.getField("age");//将obj对象的age的值设置为10field.setInt(obj, 10);//获取obj对象的age的值field.getInt(obj);

2.通过反射来获取泛型信息

通过指定类对应的 Class 对象，可以获得该类里包含的所有 Field，不管该 Field 是使用 private 修饰，还是使用 public 修饰。获得了 Field 对象后，就可以很容易地获得该 Field 的数据类型，即使用如下代码即可获得指定 Field 的类型。

// 获取 Field 对象 f 的类型Classa = f.getType();

但这种方式只对普通类型的 Field 有效。如果该 Field 的类型是有泛型限制的类型，如 Map类型，则不能准确地得到该 Field 的泛型参数。

为了获得指定 Field 的泛型类型，应先使用如下方法来获取指定 Field 的类型。

// 获得 Field 实例的泛型类型Type type = f.getGenericType();//然后将 Type 对象强制类型转换为 ParameterizedType 对象，ParameterizedType 代表被参数化的类型，也就是增加了泛型限制的类型。ParameterizedType 类提供了如下两个方法。getRawType()：返回没有泛型信息的原始类型。getActualTypeArguments()：返回泛型参数的类型。

//下面是一个获取泛型类型的完整程序。public class GenericTest{     private Mapscore;    public static void main(String[] args)        throws Exception    {         Classclazz = GenericTest.class;        Field f = clazz.getDeclaredField("score");        // 直接使用getType()取出Field类型只对普通类型的Field有效        Classa = f.getType();        // 下面将看到仅输出java.util.Map        System.out.println("score的类型是:" + a);        // 获得Field实例f的泛型类型        Type gType = f.getGenericType();        // 如果gType类型是ParameterizedType对象        if(gType instanceof ParameterizedType)        {             // 强制类型转换            ParameterizedType pType = (ParameterizedType)gType;            // 获取原始类型            Type rType = pType.getRawType();            System.out.println("原始类型是：" + rType);            // 取得泛型类型的泛型参数            Type[] tArgs = pType.getActualTypeArguments();            System.out.println("泛型类型是:");            for (int i = 0; i < tArgs.length; i++)             {                 System.out.println("第" + i + "个泛型类型是：" + tArgs[i]);            }        }        else        {             System.out.println("获取泛型类型出错！");        }    }}输出结果：score 的类型是: interface java.util.Map原始类型是: interface java.util.Map泛型类型是:第 0 个泛型类型是: class java.lang.String第 1 个泛型类型是：class java.lang.Integer

从上面的运行结果可以看出，直接使用 Field的 getType()方法只能获取普通类型的 Field的数据类型：对于增加了泛型参数的类型的Field，应该使用 getGenericType()方法来取得其类型。

Type也是java.lang.reflect包下的一个接口，该接口代表所有类型的公共高级接口，Class 是 Type 接口的实现类。Type 包括原始类型、参数化类型、数组类型、类型变量和基本类型等。

3.Java的反射与动态代理

动态代理介绍

动态代理是指在运行时动态生成代理类。即，代理类的字节码将在运行时生成并载入当前代理的 ClassLoader。与静态处理类相比，动态类有诸多好处。

• 不需要为(RealSubject )写一个形式上完全一样的封装类，假如主题接口（Subject）中的方法很多，为每一个接口写一个代理方法也很麻烦。如果接口有变动，则目标对象和代理类都要修改，不利于系统维护；
• 使用一些动态代理的生成方法甚至可以在运行时制定代理类的执行逻辑，从而大大提升系统的灵活性。

动态代理涉及的主要类

主要涉及两个类，这两个类都是java.lang.reflect包下的类，内部主要通过反射来实现的。

java.lang.reflect.Proxy:这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类。
Proxy提供了用户创建动态代理类和代理对象的静态方法，它是所有动态代理类的父类。

java.lang.reflect.InvocationHandler:这里称他为"调用处理器"，它是一个接口。当调用动态代理类中的方法时，将会直接转接到执行自定义的InvocationHandler中的invoke()方法。即我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口，通过重写invoke()方法来执行具体内容。

Proxy提供了如下两个方法来创建动态代理类和动态代理实例。

static ClassgetProxyClass(ClassLoader loader, Class... interfaces)返回代理类的java.lang.Class对象。
第一个参数是类加载器对象（即哪个类加载器来加载这个代理类到 JVM 的方法区）
第二个参数是接口（表明你这个代理类需要实现哪些接口）
第三个参数是调用处理器类实例（指定代理类中具体要干什么）
该代理类将实现interfaces所指定的所有接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)返回代理类实例。参数与上述方法一致。

对应上述两种方法创建动态代理对象的方式：

//创建一个InvocationHandler对象InvocationHandler handler = new MyInvocationHandler(.args..); //使用Proxy生成一个动态代理类Class proxyClass = Proxy.getProxyClass(RealSubject.class.getClassLoader(),RealSubject.class.getInterfaces(), handler);//获取proxyClass类中一个带InvocationHandler参数的构造器Constructor constructor = proxyClass.getConstructor(InvocationHandler.class);//调用constructor的newInstance方法来创建动态实例RealSubject real = (RealSubject)constructor.newInstance(handler);//创建一个InvocationHandler对象InvocationHandler handler = new MyInvocationHandler(.args..);//使用Proxy直接生成一个动态代理对象RealSubject real =Proxy.newProxyInstance(RealSubject.class.getClassLoader(),RealSubject.class.getInterfaces(), handler);//newProxyInstance这个方法实际上做了两件事：第一，创建了一个新的类【代理类】，//这个类实现了Class[] interfaces中的所有接口，并通过你指定的ClassLoader//将生成的类的字节码加载到JVM中，创建Class对象；第二，//以你传入的InvocationHandler作为参数创建一个代理类的实例并返回。

Proxy 类还有一些静态方法，比如：

InvocationHandler getInvocationHandler(Object proxy):获得代理对象对应的调用处理器对象。Class getProxyClass(ClassLoader loader, Class[] interfaces):根据类加载器和实现的接口获得代理类。

InvocationHandler 接口中有方法：

invoke(Object proxy, Method method, Object[] args)
这个函数是在代理对象调用任何一个方法时都会调用的，方法不同会导致第二个参数method不同，第一个参数是代理对象（表示哪个代理对象调用了method方法），第二个参数是 Method 对象（表示哪个方法被调用了），第三个参数是指定调用方法的参数。

3、动态代理模式的简单实现

public class DynamicProxyDemo {     public static void main(String[] args) {         //1.创建目标对象        RealSubject realSubject = new RealSubject();            //2.创建调用处理器对象        ProxyHandler handler = new ProxyHandler(realSubject);           //3.动态生成代理对象        Subject proxySubject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),RealSubject.class.getInterfaces(), handler);           //4.通过代理对象调用方法           proxySubject.request();        }}/** * 主题接口 */interface Subject{     void request();}/** * 目标对象类 */class RealSubject implements Subject{     public void request(){         System.out.println("====RealSubject Request====");    }}/** * 代理类的调用处理器 */class ProxyHandler implements InvocationHandler{     private Subject subject;    public ProxyHandler(Subject subject){         this.subject = subject;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args)            throws Throwable {         //定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作        System.out.println("====before====");       //调用RealSubject中的方法        Object result = method.invoke(subject, args);        System.out.println("====after====");        return result;    }}

可以看到，我们通过newProxyInstance就产生了一个Subject 的实例，即代理类的实例，然后就可以通过Subject .request()，就会调用InvocationHandler中的invoke()方法，传入方法Method对象，以及调用方法的参数，通过Method.invoke调用RealSubject中的方法的request()方法。同时可以在InvocationHandler中的invoke()方法加入其他执行逻辑。