Java 反射机制与动态代理

1.什么是反射机制？

      Java反射机制是在运行状态中，对任意一个类（class文件）都能知道这个类的属性和方法、对于任意一个对象都能调用它的属性和方法，这种动态获取的信息以及调用对象的方法的功能称为Java语言的反射机制。

        简而言之，动态获取类中的信息，就是Java反射机制。可以理解为对类的解剖，知识获得它的字节码（Class对象）。

2. 获取Class类实例化对象的方式

（1）Class.forName("全类名")

• 将字节码文件加载进内存，返回Class对象。
• 多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
• 推荐使用这种方式。

（2）类名.class

• 通过类名的属性class获取。
• 多用于参数的传递。

（3）对象.getClass()

• getClass()方法在Object类中定义着。
• 多用于对象的获取字节码文件的方式。

package com.zzu.reflect;

public class Test {

	public static void main(String[] args) throws Exception {
		//1.Class.forName("全类名")
		Class class1 = Class.forName("com.zzu.reflect.Student");
		System.out.println(class1);
		//2.类名.class
		Class class2 = Student.class;
		System.out.println(class2);
		//3.对象.getClass() ，需要先创建对象
		Class class3 = new Student().getClass();
		System.out.println(class3);

		System.out.println(class1==class2);
		System.out.println(class1==class3);
	}
}
/**  输出
    class com.zzu.reflect
    class com.zzu.reflect
    class com.zzu.reflect
    true
    true
*/

结论：同一份字节码文件（.class文件）在一次程序运行过程中，只会被加载一次，不论通过哪种方式获取的Class对象都是同一个。

3. 什么是动态代理？

        动态代理底层利用了反射机制。

        首先，动态代理是代理模式的一种实现方式，代理模式除了动态代理还有静态代理，只不过静态代理能够在编译时期确定类的执行对象，而动态代理只有在运行时才能够确定执行对象是谁。代理可以看作是对最终调用目标的一个封装，我们能够通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合。

        动态代理的实现有很多，但是 JDK 动态代理是很重要的一种，下面我们就 JDK 动态代理来深入理解一波。

4. JDK 动态代理

        首先我们先来看一下动态代理的执行过程，

         在 JDK 动态代理中，实现了 InvocationHandler 接口的类可以看作是代理类(因为类也是一种对象，所以我们上面为了描述关系，把代理类形容成了代理对象)。JDK 动态代理就是围绕实现了 InvocationHandler 接口的代理类进行的，比如下面就是一个 InvocationHandler 的实现类，同时它也是一个代理类，

public class UserHandler implements InvocationHandler {
 
    private UserDao userDao;
 
    public UserHandler(UserDao userDao){
        this.userDao = userDao;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        saveUserStart();
        Object obj = method.invoke(userDao, args);
        saveUserDone();
        return obj;
    }
 
    public void saveUserStart(){
        System.out.println("---- 开始插入 ----");
    }
 
    public void saveUserDone(){
        System.out.println("---- 插入完成 ----");
    }
}

    代理类一个最最最重要的方法就是 invoke 方法，它有三个参数，

              Object proxy：动态代理对象，关于这个方法我们后面会说。

              Method method：表示最终要执行的方法，method.invoke 用于执行被代理的方法，也就是真正的目标方法 。

              Object[ ] args：这个参数就是向目标方法传递的参数。

 

     我们构造好了代理类 UserHandler，现在就要使用它来实现我们对目标对象的调用，那么如何操作呢？请看下面代码，

        如果要用 JDK 动态代理的话，就需要知道目标对象的类加载器、目标对象的接口，当然还要知道目标对象是谁。构造完成后，我们就可以调用 Proxy.newProxyInstance方法，然后把类加载器、目标对象的接口、目标对象绑定上去就完事儿了。

public static void dynamicProxy(){
 
  UserDao userDao = new UserDaoImpl();
  InvocationHandler handler = new UserHandler(userDao);
 
  ClassLoader loader = userDao.getClass().getClassLoader();
  Class[] interfaces = userDao.getClass().getInterfaces();
 
  UserDao proxy = (UserDao)Proxy.newProxyInstance(loader, interfaces, handler);
  proxy.saveUser();
}

---

这里需要注意一下 Proxy 类，它就是动态代理实现所用到的代理类。Proxy 位于java.lang.reflect 包下，这同时也旁敲侧击的表明动态代理的本质就是反射。