探索代理设计模式第八篇：深入解析代理模式奥秘？

本文共计1871个文字，预计阅读时间需要8分钟。

一、定义 + 代理模式：代理模式为目标对象提供一种代理，以控制对这个对象的访问。在某些情况下，直接访问目标对象可能不合适或不安全，代理对象可以在客户端和目标对象之间起到中介的作用。

在以下情况下，使用代理模式可能更为合适：- 对象不适合直接访问或直接访问存在风险（如权限限制的类）。- 需要控制对目标对象的访问，例如实现权限验证、日志记录等。- 需要在不修改目标对象代码的情况下扩展其功能。

代理对象可以在客户端端点提供以下功能：在客户端端点提供对目标对象的间接访问，以确保访问的安全性、灵活性和扩展性。

一、定义

代理模式：为目标对象提供一种代理以控制对目标对象的访问。在某些情况下，一个对象不适合或者不能直接引用目标对象（比如包访问权限的类），而代理对象可以在客户端和目标对象之间起到中介的作用。

代理类就像秘书一样,为老板代理一些琐碎的事情，管事的还是老板。

为目标对象创建一个代理，以控制对它的直接访问。

二、分类

静态代理，JDK动态代理，Cglib动态代理。

三、静态代理

优点：静态代理本质上就是创建一个类的包装类，所以不用修改被代理的对象。

缺点：如果被代理的对象加了一个方法，那么代理类也要同步加一个方法。

下面是一个简单的例子

//被代理的对象或者说是委托对象，实现了接口
public class Subject implements Operation{
@Override
public void function() {
System.out.println("主体操作");
}
}
//代理的对象，与委托对象实现了相同的接口
class Proxy implements Operation{
//持有委托对象的引用
private Subject subject;
//使用构造函数接收
public Proxy(Subject subject) {
this.subject = subject;
}

@Override
public void function() {
System.out.println("增强操作，如 日志，安全，事务，缓存");
subject.function();
System.out.println("后置处理，如记录操作时间");
}
}

四、JDK动态代理

优点：JDK动态代理把代理方法的处理都集中到了InvocationHandler这个类的实现中，所以方便统一增加类似于切面的功能，比如记录时间，增加日志、缓存等。

缺点：JDK动态代理只能代理接口的实现

根据我们在Java代码中的“指示”，动态的生成了相关类

下面是一个简单的例子

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler{
//被代理的对象的引用，或者说是委托对象，也可以称它为真实对象
private Object target;

public DynamicProxy(Object target) {
this.target = target;
}

public Object getInstance(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置增强
System.out.println("增强操作，如 日志，安全，事务，缓存");
//调用被代理对象的业务方法
Object result = method.invoke(target,args);
System.out.println("后置增强，用于记录数据,或者记录时间，将数据存到全局map中等");
return result;
}

public static void main(String[] args) {
//业务实现类实现了Operatino接口
Operation subject = new Subject();
//创建动态代理对象
DynamicProxy proxy = new DynamicProxy(subject);
//创建代理实例对象
Operation proxyInstance = (Operation)proxy.getInstance();
//调用代理对象的方法，包裹了真实对象的方法
proxyInstance.function();
}
}

五、Cglib动态代理

如果目标没有实现接口，那么可以用cglib动态代理。cglib是针对类来实现代理的，它生成目标类的一个子类作为代理类。

Cglib动态代理的缺点就是不能对final修饰的类进行代理，final修饰的类不能生成子类。

下面是一个简单的例子

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
//被代理的对象，或者是说是真实对象，委托对象
private Object target;
public CglibProxy(Object target) {
this.target = target;
}

public Object getInstance() {
//创建代理对象的工厂
Enhancer enhancer = new Enhancer();
//设置代理对象的父类是当前的真实对象
enhancer.setSuperclass(this.target.getClass());
// 回调方法，当调用代理对象的时候，让真实对象去操作
enhancer.setCallback(this);
// 创建代理对象，并返回
return enhancer.create();
}

@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
//前置增强
System.out.println("增强操作，如 日志，安全，事务，缓存");
Object result = method.invoke(target,args);
System.out.println("后置增强");
return result;
}

public static void main(String[] args) {
Temp temp = new Temp();
CglibProxy proxy = new CglibProxy(temp);
Temp tempInstance = (Temp)proxy.getInstance();
tempInstance.login();
/**
* 运行结果：
* 增强操作，如 日志，安全，事务，缓存
* 临时登录
* 后置增强，用于记录数据,或者记录时间，将数据存到全局map中等
*/
}
}

六、增强工具类例子

在类中添加抽象方法，让子类去继承它，实现其它增强的方法。这有点像拦截器的感觉了。重写invoke方法，父类的用super.invoke()方法回调。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public abstract class DynamicProxy implements InvocationHandler{
//被代理的对象的引用，或者说是委托对象，也很称它为真实对象
private Object target;

public DynamicProxy(Object target) {
this.target = target;
}

//前处理
public abstract Object prehandle();
//后处理
public abstract Object posthandle();

public Object getInstance(){
/**
* 参数1：类加载器
* 参数2：被代理对象所实现的接口，我们动态生成的代理类也将实现这些接口
* 参数3：使用哪个调用处理器的invoke方法，当前就使用这个类的实例对象的invoke方法
*
*/
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}

/**
*
* @param proxy 生成的代理对象的引用
* @param method 代理对象调用的方法
* @param args 参数数组
* @return 调用此方法的结果
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
prehandle();
//调用被代理对象的业务方法
Object result = method.invoke(target, args);
posthandle();
return result;
}
}

深度好文：

谈谈JAVA的代理模式认识 一——为什么使用代理模式

java的动态代理机制详解

代理模式（Proxy Pattern），静态代理 VS 动态代理

分割线--------------------------------------------------------------------------------------------

下一篇：代理设计模式9--使用AOP风格的代理模式

刻意练习

（1）一句话描述代理设计模式

（2）静态代理模式的优点与缺点

（3）JDK动态代理的缺点

（4）JDK动态代理的优点

（5）一般代理Controller，为什么用Cglib代理，而不用Jdk动态代理

（6） Cglib动态代理的一个比较常见的缺陷