深入理解动态代理（一）（网上总结的要点）

来源：互联网发布：yy淘宝刷钻平台网址编辑：程序博客网时间：2024/04/30 09:19

1.代理模式的概念
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理：在程序运行时，运用反射机制动态创建而成。

代理模式是非常常用的一种设计模式，在我们的应用中经常被使用。一般场景是，我们有一个现成的类，它的功能比较的完善了，但是还是存在某些欠缺，这个时候我们需要去扩展一些新的功能，但又不想去重造轮子，这个时候可以使用代理类来替代原来的目标类，通过组合的模式，增加一种为目标类增加一些额外的功能。

代理模式的类结构图一般如下：

图1：代理模式类结构图

图2：代理模式序列图

2.动态代理相关的接口

JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

3.JDK动态代理实例剖析：

假设有这样一个接口 Speak:

[java] view plaincopy

package proxy;
public interface Speak {
public void sayHello();
}

实现类 PeopleSpeak.

[java] view plaincopy

package proxy;
public class PersonSpeak implements Speak {
public void sayHello() {
System.out.println("hello");
}
}

当我们去调用 PersonSpeak 的 sayHello 的时候，很显然是输出 hello 。现在我们需要通过动态代理在运行时动态的生成Speak 的代理类，并在调用 sayHello 方法的前后做一些输出。完成类似 aop 的功能。

根据以上的思路，我们需要有一个 PersonSpeak 的代理类，它持了 PersonSpeak 的对象，这样就能很方便的完成这个任务。如果用静态代理实现显然是很简单，那么用动态代理如何实现呢？

这个时候我们可以使用 java 反射里的 Proxy 类。此类是 JDK 动态代理的核心类。 Proxy 类拥有一个在运行期动态创建类的功能。动态的去创建一个 Speak 的子类，同时该子类持有 PersonSpeak 类的一个实例，该子类的功能就是实现上述第一部分代理类的功能。

关于 java 反射的 Method 、 Field 、 Class 、 Construtor 等这里不做介绍，重点介绍 Proxy和 InvocationHandler 类。

Proxy和InvocationHandler 类简介

Proxy 类提供了非常重要的方法，该方法能够动态的生成几个接口的实现类。具体的实现过程由 ProxyGenerator 类来实现，这是比较低层的一个类，这里不做过多描述。同时该动态类需要持有一个实现了 InvocationHandler 接口的子类对象。 InvocationHandler 接口的子类对象是我们目标类的又一层代理。对于接口里面的每个方法实现，都是通过调用InvocationHandler 接口的子类对象的反射调用。也就是说动态代理类实际上是 InvocationHandler 子类对象的一个代理。那么 InvocationHandler 子类对象有时我们目标类的代理。通过这样层层代理我们就能实现上述的功能了。这句话可能不是很好理解，但是确实就是这么实现的，也许通过下面的图就能更好的理解：

图3：JDK动态代理调用过程

可以从上图看出来， JDK 动态反射并不是那么简单的一层代理，而是通过层层代理，最终通过 Method 的反射来调用目标对象的方法，而 aop 的实现可以放在 InvocationHandler 的是实现类里。

那么根据上述关于动态代理的简介，要实现 PersonSpeak 的 aop ，需要做两件事情

1. 实现一个持有 Speak 对象的 InvocationHandler 子类，改子类通过 Mechod 反射调用 PersonSpeak 的方法，并在调用方法前后实现 aop 功能。

2. 实现一个能动态创建 Speak 子类的代理类工厂，改工厂能动态的创建 Speak 子类。

具体实现如下：

1. SpeakInvocationHandler ( 实现 InvocationHandler 接口 )

可以看出该类的 invoke 方法实现 aop 的关键，所有方法都是通过 invoke 来调用， invoke 内部通过反射来调用目标对象 target ，同时在调用前后实现了 aop 。

[java] view plaincopy

package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class SpeakInvocationHandler implements InvocationHandler {
public Object target;
SpeakInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName() + " invoked!");
Object result = method.invoke(target, args);
System.out.println(method.getName() + " return!");
return result;
}
}

2. ProxyFactory

[java] view plaincopy

package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class ProxyFactory {
Class cls;
InvocationHandler h;
public ProxyFactory(String className, InvocationHandler h) {
try {
cls = Class.forName(className);
this.h = h;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public Object createProxyObject() {
return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h);
}
}

ProxyFactory 主要是通过反射的 Proxy 类动态的去创建接口的子类，同时该子类是 InvocationHandler 的一个代理，所有的方法实现，都是通过 InvocationHandler 代理来调用。

最后来看下 Main 函数：

[java] view plaincopy

package proxy;
import java.lang.reflect.InvocationHandler;
public class ProxyTest {
public static void main(String args[]) {
Speak s = new PersonSpeak();
InvocationHandler h = new SpeakInvocationHandler(s);
ProxyFactory proxyFactory = new ProxyFactory(PersonSpeak.class.getName(), h);
Speak speakProxy = (Speak) proxyFactory.createProxyObject();
speakProxy.sayHello();
}
}

得到的输出结果如下：

sayHello invoked!

hello

sayHello return!

从输出结果可以看出红色的输出部分正是我们通过动态代理来实现的。通过如上的过程完成了正果动态代理的过程。

除了实现 AOP ，动态代理还可以用于实现远程服务代理。比如说 Hessian 就是通过动态创建远程服务代理类来调用远程服务，从而使应用对远程服务透明化。 Hessian 调用过程如下：

图4：Hessian远程服务调用过程

（补充：CBlib动态代理的实现）

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
示例
1、BookFacadeCglib.java

Java代码  
package net.battier.dao;  
  
public interface BookFacade {  
    public void addBook();  
}  

2、BookCadeImpl1.java

Java代码  
package net.battier.dao.impl;  
  
/** 
 * 这个是没有实现接口的实现类 
 *  
 * @author student 
 *  
 */  
public class BookFacadeImpl1 {  
    public void addBook() {  
        System.out.println("增加图书的普通方法...");  
    }  
}  

3、BookFacadeProxy.java

Java代码  
package net.battier.proxy;  
  
import java.lang.reflect.Method;  
  
import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  
  
/** 
 * 使用cglib动态代理 
 *  
 * @author student 
 *  
 */  
public class BookFacadeCglib implements MethodInterceptor {  
    private Object target;  
  
    /** 
     * 创建代理对象 
     *  
     * @param target 
     * @return 
     */  
    public Object getInstance(Object target) {  
        this.target = target;  
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(this.target.getClass());  
        // 回调方法  
        enhancer.setCallback(this);  
        // 创建代理对象  
        return enhancer.create();  
    }  
  
    @Override  
    // 回调方法  
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy proxy) throws Throwable {  
        System.out.println("事物开始");  
        proxy.invokeSuper(obj, args);  
        System.out.println("事物结束");  
        return null;  
  
  
    }  
  
}  

4、TestCglib.java

Java代码  
package net.battier.test;  
  
import net.battier.dao.impl.BookFacadeImpl1;  
import net.battier.proxy.BookFacadeCglib;  
  
public class TestCglib {  
      
    public static void main(String[] args) {  
        BookFacadeCglib cglib=new BookFacadeCglib();  
        BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
        bookCglib.addBook();  
    }  
}  