反射机制

一：什么是反射？

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

二： Class 对象：类的信息，什么是 RTTI？

• RTTI 即 Runtime Type Information，顾名思义，也就是在运行时，识别对象和类的信息。
• RTTI 有两种，一种是“传统的” RTTI，它假定我们在编译时就已经知道了所有的类型；另一种是“反射”机制，它允许我们在运行时发现和使用类的信息。

理解1：

Class 对象包含了与类有关的信息，事实上 Java 中是用 Class 对象来创建这个类中的所有的对象的。每当编译完成，就会生成一个 Class 对象，被保存在 .class 文件中（每个类都会产生一个对应的Class对象）。JVM 使用 ClassLoader 来加载对象，所有的类都是在对其第一次使用（静态成员被引用，静态常量除外）或者用 new 关键字创建对象后，动态加载到 JVM 中的。所谓的动态加载也就是在被使用到时才去加载。

理解2：

理解RTTI在Java中的工作原理，首先需要知道类型信息在运行时是如何表示的，这是由Class对象来完成的，它包含了与类有关的信息。Class对象就是用来创建所有“常规”对象的，Java使用Class对象来执行RTTI，即使你正在执行的是类似类型转换这样的操作。每个类都会产生一个对应的Class对象，也就是保存在.class文件。所有类都是在对其第一次使用时，动态加载到JVM的，当程序创建一个对类的静态成员的引用时，就会加载这个类。Class对象仅在需要的时候才会加载，static初始化是在类加载时进行的。

理解3：

类加载器首先会检查这个类的Class对象是否已被加载过，如果尚未加载，默认的类加载器就会根据类名查找对应的.class文件。想在运行时使用类型信息，必须获取对象(比如类Base对象)的Class对象的引用，使用功能Class.forName(“Base”)可以实现该目的，或者使用base.class。注意，有一点很有趣，使用功能”.class”来创建Class对象的引用时，不会自动初始化该Class对象，使用forName()会自动初始化该Class对象。

三：使用反射的前提

要先获取到该类的字节码文件对象（.class），通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息(方法，属性，类名，父类名，实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

获取字节码文件对象（获取class对象的方式）的三种方式：

• 根据类名：类名.class
• 根据对象：对象.getClass()
• 根据全限定类名：Class.forName(全限定类名)

代码示例如下，三个对象一致，1个类在 JVM 中只会有一个 Class 对象实例

public static void main(String[] args) throws ClassNotFoundException {
        //对象.getClass()
        Customer customer=new Customer();
        Class clzz=customer.getClass();
        System.out.println("clzz = " + clzz);
        //类名.class
        Class clzz2=Customer.class;
        System.out.println("clzz2 = " + clzz2);
        //Class.forName(全限定类名)
        Class clzz3=Class.forName("com.java.reflect.Customer");
        System.out.println("clzz3 = " + clzz3);
        //jvm中只有一个对象实例
        System.out.println(clzz==clzz2);
    }

 四：Java中主要由以下的类来实现Java反射机制（这些类都位于java.lang.reflect包中），

• Class类：Class类是Reflection API中的核心类。 
• Field类：代表类的成员变量（成员变量也称为类的属性）。
• Method类：代表类的方法。
• Constructor类：代表类的构造方法。
• Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

五：Class类的主要方法如下，

• getName()：获得类的完整名字。 getFields()：获得类的public类型的属性。
• getDeclaredFields()：获得类的所有属性。
• getMethods()：获得类的public类型的方法。
• getDeclaredMethods()：获得类的所有方法。
• getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型。
• getConstrutors()：获得类的public类型的构造方法。
• getConstrutor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。
• newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

六：举例，

6-1：通过有参构造，创建对象，总结如下，源码参考：利用有参构造创建类对象

• 不用反射：创建对象，需要手动new对象不能动态创建，new的时候根据new的类名寻找字节码文件，加载进入内存，创建Class对象，并接着创建对应的 Teacher 对象
• 通过反射：只需要一个名字，就可以创建对象。寻找该名称的类文件，加载进内存，并创建Class对象，调用有参构造方法初始化变量，通过Class对象的newInstance()创建类对象。

public static void main(String[] args) throws Exception {
        //不用反射: 创建对象，需要手动new对象不能动态创建
        //new的时候根据new的类名寻找字节码文件，加载进入内存，创建Class对象，并接着创建对应的 Teacher 对象
        Object obj1= new Teacher("张三", 22);
        System.out.println("不用反射： " + obj1);
        System.out.println("*********************************************************************");
        //Class.forName(全限定类名)
        //通过反射:只需要一个名字，就可以创建对象。寻找该名称的类文件，加载进内存，并创建Class对象
        Class clzz3 = Class.forName("com.java.reflect.Teacher");
        //调用有参构造方法初始化变量
        Constructor constructor = clzz3.getConstructor(String.class, int.class);
        通过Class对象的newInstance()创建类对象。
        Object obj2 = constructor.newInstance("张三", 22);
        System.out.println("通过反射： " + obj2);
    }

6-2：带参数的方法，源码参考：带参数的方法反射调用

public static void main(String[] args) throws Exception {
        //获取字节码文件
        Class classs = Class.forName("com.java.reflect.Student");
        //获取其实例对象
        Student stu = (Student) classs.newInstance();
        //获取带参数的方法，为方法名
        Method methodSet = classs.getDeclaredMethod("setName", String.class);
        Method methodGet = classs.getDeclaredMethod("getName");
        //设置可见性
        methodSet.setAccessible(true);
        //调用方法
        methodSet.invoke(stu, "李四");
        System.out.println(methodGet.invoke(stu));
    }

七：动态代理

理解1：

代理：就是将实际对象的方法调用分离开来，从而允许我们对一些操作进行修改，或者添加额外的操作。而动态代理比代理的思想更进一步，它允许我们动态地创建代理并动态地处理对所代理方法的调用。

使用动态代理其实很简单，首先要定义一个自己的 InvocationHandler，然后再通过 Proxy.newProxyInstance 创建一个代理对象。

理解2：

代理模式是为了提供额外或不同的操作，而插入的用来替代”实际”对象的对象，这些操作涉及到与”实际”对象的通信，因此代理通常充当中间人角色。Java的动态代理比代理的思想更前进了一步，它可以动态地创建并代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的策略。

通过调用Proxy静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器，一个你希望该代理实现的接口列表(不是类或抽象类)，以及InvocationHandler的一个实现类。动态代理可以将所有调用重定向到调用处理器，因此通常会调用处理器的构造器传递一个”实际”对象的引用，从而将调用处理器在执行中介任务时，将请求转发。

动态代理的概述及实现：

1、动态代理概述
动态代理：利用Java的反射技术(Java Reflection)，在运行时创建一个实现某些给定接口的新类（也称“动态代理类”）及其实例（对象）；
代理的是接口(Interfaces)，不是类(Class)，更不是抽象类。
2、动态代理的实现
分三步，但是注意JDK提供的代理只能针对接口做代理，也就是下面的第二步返回的必须要是一个接口。
2.1 new出代理对象，通过实现InvacationHandler接口，然后new出代理对象来。
2.2 通过Proxy类中的静态方法newProxyInstance，来将代理对象假装成那个被代理的对象，也就是如果叫人帮我们代买火车票一样，那个代理就假装成我们自己本人。
2.3 执行方法，代理成功

代码参考：

接口，

public interface IDo {
    void doSomething();

    void somethingElse(String arg);
}

 实现类，

public class IDoImpl implements IDo {
    public void doSomething() {
        System.out.println("doSomething.");
    }

    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}

 构建一个handler类来实现InvocationHandler接口，

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxyed;

    public DynamicProxyHandler(Object proxyed) {
        this.proxyed = proxyed;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        System.out.println("代理工作了.");
        return method.invoke(proxyed, args);
    }

    public static void main(String[] args) {
        IDoImpl real = new IDoImpl();
        IDo proxy = (IDo) Proxy.newProxyInstance(
                IDo.class.getClassLoader(), new Class[]{IDo.class},
                new DynamicProxyHandler(real));
        proxy.doSomething();
        proxy.somethingElse("赵柳");
    }
}

注意newProxyInstance的三个参数，第一个，类加载器，第二个被代理对象的接口，第三个代理对象。

使用动态代理的优势：

• 更强的灵活性。我们不用在设计实现的时候就指定某一个代理类来代理某一个被代理对象，而是可以把这种指定延迟到程序运行时由 JVM 来实现
• 动态代理更为统一与简洁。

动态代理的应用：

Spring的AOP，加事务，加权限，加日志。

 

八：反射总结

反射是无孔不入的，无论是私有方法还是私有内部类的方法，哪怕是匿名类的方法，也无法逃脱反射的调用。对于私有域来说也一样，只有 final 域，才不会被修改。反射可以说是给我们的程序留了一道后门，但是总的来说，从反射给我们带来的优劣对比上看，利大于弊。

 

参考：

Java高级篇（四）——反射

Java反射详解

深入理解Java反射

java反射机制详解

浅谈 RTTI

JAVA动态代理