代理模式详解-优快云博客

一、中介隔离作用

代理模式，第一次接触它，是在学习.Net的时候看的一本书，叫做《大话设计模式》，至今已快三年了。相信看过这本书的同学们，都记得书中的代理模式，就是为他人做嫁衣裳的故事。好，我们回归代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用，其特征是代理类与委托类有同样的接口，。代理模式是常用的java设计模式。

表现形式如下：

以上一张图就是当初对代理模式的认识。

二、开闭原则，增加功能，

现在有了进一步的认识。代理类不仅仅是一个隔离客户端和委托类的中介。我们还可以借助代理来在增加一些功能，而不需要修改原有代码，严重的复合开闭原则哦。

代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

就是这样，真正的业务功能还是有委托类来实现，但是在实现业务类之前的一些公共服务。例如在项目开发中我们没有加入缓冲，日志这些功能，后期想加入，我们就可以使用代理来实现，而没有必要打开已经封装好的委托类。

三、代理的分类

    根据以上对代理的理解，对于代理的具体实现，我们有不同的方式，如果按照代理的创建时期，代理类可以分为两种。：静态代理、动态代理。
    静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
    动态代理：在程序运行时，运用反射机制动态创建而程。

1、静态代理

那我们先来看一下静态代理。只需要三步即可实现。首先，我们需要定义业务接口，业务接口实现类，然后定义代理类，且实现业务接口；最后写一个Client来调用。

第一：需要定义业务接口，业务接口实现类

 /**
* 定义一个业务接口
* @author Cassie
*/
public interface Account {
// 查询
public void queryAccount ();
// 修改
public void updateAccount ();
}
<pre name="code" class="java"> /**
* 接口实现类(包含业务逻辑)
* 即：委托类
* @author Cassie
*/
public class AccountImpl implements Account{
@Override
public void queryAccount() {
System.out.println("查询方法...");
}
@Override
public void updateAccount() {
System.out.println("修改方法...");
}
}

第二：定义代理类，实现业务接口

/**
* 代理类（增强AccountImpl的功能）
* @author Cassie
*/
public class AccountProxy implements Account{
private AccountImpl accountImpl;
/**
* 重写默认构造函数
* @param accountImpl :真正要执行业务的对象
*/
public AccountProxy(AccountImpl accountImpl) {
this.accountImpl =accountImpl;
}
@Override
public void queryAccount() {
System.out.println("业务处理之前...");
// 调用委托类的方法，这是具体的业务方法
account>Impl.queryCount();
System.out.println("业务处理之后...");
}
@Override
public void updateAccount() {
System.out.println("业务处理之前...");
// 调用委托类的方法;
accountImpl.updateAccount();
System.out.println("业务处理之后...");
}
}

第三：写客户端，我这里写的测试类。

/**
* 测试Account类
* @author Cassie
*/
public class TestAccount {
public static void main(String[] args) {
AccountImpl accountImpl = new AccountImpl();
//在这里传入要调用的业务对象
AccountProxy accountProxy = new AccountProxy(accountImpl);
//开始调用业务对象的方法，这两个方法都被增强了。
accountProxy.updateAcc>ount();
accountProxy.queryAccount();
}
}

看到的执行效果：

<span style="font-family:KaiTi_GB2312;font-size:18px;">业务处理之前...</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;">修改方法...</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;">业务处理之后...</span>

业务处理之前...
查询方法...

<span style="font-family:KaiTi_GB2312;font-size:18px;">业务处理之后...</span>

好了，至此我们的静态代理实现了，但是问题也跟着来了，观察代码可以发现每一个代理类只能为一个接口服务，一个AccountProxy 类实现了一个Account接口，那么我要是有多个接口，是不是要写多个Proxy类与之对应。这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那就引入了我们的动态代理了。

让我们就接着上篇博客的静态代理来开始今天的动态代理。

一、动态代理

静态代理需要在运行之前就写好代理类，这样就造成了代码的大量重复，所以我们通过动态代理在运行时期动态生成业务类的代理类，那么动态代理类是如何实现的呢？

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。原来是利用反射的机制来实现的，今天我们不讨论反射，我们看JDK的动态代理的实现。

      JDK动态代理中包含一个类和一个接口： InvocationHandler接口，和我们定义的一个实现类“Proxy“，这是一个万能的代理类，我们就是通过这个代理类来动态代理的。
      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指定的类，是最常使用的是一种加载器。

二、使用JDK的动态代理

还是使用上篇博客的代码，我们也是简单的说三步来实现：业务接口，业务实现类的创建；代理类的创建，业务的调用。

我们看代码实现：

 /**
* 定义一个业务接口
* @author Cassie
*/
public interface Account {
// 查询
public void queryAccount ();
// 修改
public void updateAccount ();
}
/**
* 接口实现类(包含业务逻辑)
* 即：委托类
* @author Cassie
*/
public class AccountImpl implements Account{
@Override
public void queryAccount() {
System.out.println("查询方法...");
}
@Override
public void updateAccount() {
System.out.println("修改方法...");
}
}

关键的动态代理是如下几行代码：该处的代理类Proxy 不去实现具体的某个业务接口，而是实现了JDK提供的InvocationHander类。在Proxy中我们不需要知道具体的业务类，即委托类，在运行之前，讲委托类和代理类进行解耦，在运行期才发生的联系，是通过这句话实现的：private object target。然后在调用的时候通过getInstance 在确定谁是委托对象。

/**
* JDK动态代理代理类
*
* @author Cassie
*
*/
public class Proxy implements InvocationHandler {
private Object target;
/**
* 绑定委托对象并返回一个代理类
* @param target
* @return
*/
public Object GetInstance(Object target) {
this.target = target;
//取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
/**
* 调用方法
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result=null;
System.out.println("before");
//执行方法
result=method.invoke(target, args);
System.out.println("after");
return result;
}
}

再看我们的客户端调用：这时候才传入真正的委托类。

public class TestProxy {
public static void main(String[] args) {
Proxy proxy = new Proxy();
// 在这里进行真正的对象传入
Account account= (Account )proxy.getInstance(new AccountImpl());
proxy.queryAccount();
}
}

以上过程就是JDK动态代理的实现，我们发现JDK动态代理帮我们讲代理类和委托类的绑定关系延迟了，什么时候用，什么时候调，这样我们的业务类不仅得到了增强，还简化了代码。

当然，JDK的动态代理也有缺陷，不知道你发现了没有，这里的每个委托类都必须是要有接口的，也就是说JDK的动态代理依靠接口实现，要是我一个没有接口的类想被代理怎么办？

如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。请看下篇博客。

接着上篇博客的代理模式，我们继续，上篇博客介绍了JDK的动态代理，但是JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，这样就存在一定的局限性。对于这种情况，我们采用CGLIB来实现。

一、CGLIB动态代理

cglib是针对类来实现代理的，其实现原理：CGLIB的底层采用ASM字节码生成框架，使用字节码技术生成代理，比使用反射生成代理的效果要高，是对指定的目标类生成一个子类，并覆盖其中方法实现增强。但是也有一点点不足，因为采用的是继承，所以不能对final修饰的类进行代理。

还是使用以前的代码，依然还是简单的三步来实现。第一：建立一个普普通通的业务类；第二：写CGLIB代理类；第三：写测试代码或者客户端调用。这里的不同是第一步中，我们不需要在建接口了，只是一个普普通通的java类。

看代码：

 /**
* 业务类(包含业务逻辑)
* 即：委托类
* @author Cassie
*/
public class Account{
@Override
public void queryAccount() {
System.out.println("查询方法...");
}
@Override
public void updateAccount() {
System.out.println("修改方法...");
}
}

然后，我们来写CGLIB代理类：

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 Cassie
* 实现MethodInterceptor 接口
*/
public class CglibProxy 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("before");
Object result = proxy.invokeSuper(obj, args);
System.out.println("after");
return result
}
}

最后写测试类调用

public class TestCglib {
public static void main(String[] args) {
//实例化代理
CglibProxy cglib=new CglibProxy();
//通过代理拿到对象
Account account = (Account)cglib.getInstance(new Account());
account.query();
}
}

通过以上代码，我们发现proxy.invokeSuper（obj,arg)是执行的关键。

使用CGLIB,需要实现 CGLib 给我们提供的 MethodInterceptor 实现类，并填充 intercept() 方法。方法中最后一个 MethodProxy 类型的参数 proxy，值得注意！CGLib 给我们提供的是方法级别的代理，也可以理解为对方法的拦截。我们直接调用 proxy 的 invokeSuper() 方法，将被代理的对象 obj 以及方法参数 args 传入其中即可。

至此，CGLIB代理也实现了。