1. 定义
代理模式：给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问。
代理对象会表现出和目标对象一样的行为，同时对目标对象进行增强，完成了一些无法完成的业务。
现实的例子：
-
律师。没有完善的法律知识，依然可以进行维权。
-
代购。无需护照，无需出国，通过朋友直接买到国外的商品。
代理模式-效果图
2. 设计
代理模式两大角色：
- 目标对象。
- 代理对象。
类图如下：
代理模式-类图
根据业务模型，代理可以进行分类。
根据我的理解，从对目标对象侵入程度的影响，可以分成两大类：
- 强权代理。会干涉目标对象的执行。比如权限控制。
- 佛系代理。不影响目标对象的执行。比如日志记录，方法耗时统计。
代理模式的实现，有个关键的地方就是 代理与目标需要有一致的行为。
Java 有这几种方式：
- 静态代理。设计接口，代理与目标实现接口。
- JDL 动态代理。在内存中使用反射工具创建代理对象。也需要接口
- CGLIB 动态代理。使用 ASM 工具直接进行字节码修改，创建代理对象。不需要接口。但属于继承关系，所以无法代理 final 修饰的目标类。
2.1. 静态代理
目标对象创建接口：
public interface ISubject {
void request();
}
实现类：
public class RealSubject implements ISubject {
public void request() {
System.out.println("Hello world!");
}
}
代理对象也实现该接口，并且持有目标对象的引用：
public class Proxy implements ISubject {
public ISubject target;
public Proxy(ISubject target) {
this.target = target;
}
public void request() {
System.out.println("begin");
target.request();
System.out.println("end");
}
public static ISubject wrap(ISubject target) {
return new Proxy(target);
}
}
使用者面向接口编程：
public class TestStaticProxy {
public static void main(String[] args) {
ISubject subject = new RealSubject();
System.out.println("代理前：");
subject.request();
System.out.println("代理后：");
subject = Proxy.wrap(subject);
subject.request();
}
}
确实实现了代理。
静态代理实现简单，但有以下弊端：
- 必须实现同一个接口。
- 目标类型多样，代理类数量会膨胀。
2.2. JDK 动态代理
无需静态创建代理类，解决了静态代理类膨胀的问题。
使用 JDK reflect 包的工具，核心类有：
- Proxy
- InvocationHandler
两种的关系为：把目标类的接口传递给 Proxy 生成代理对象，在调用接口的方法时，会触发 InvocationHandler 回调，在回调中实现代理业务。
还是上面的例子，这里代理对象实现 InvocationHandler：
public class JDKProxy implements InvocationHandler {
public Object target;
public JDKProxy(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("begin");
Object result = method.invoke(target, args);
System.out.println("end");
return result;
}
@SuppressWarnings("unchecked")
public static <T> T wrap(Object target) {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new JDKProxy(target));
}
}
使用：
public class TestJDKProxy {
public static void main(String[] args) {
ISubject subject = new RealSubject();
System.out.println("代理前：");
subject.request();
System.out.println("代理后：");
subject = JDKProxy.wrap(subject);
subject.request();
}
}
因为动态去创建代理对象，所以 SimpleProxy 可以应用到任务实现接口的目标类型中，而不仅仅是 ISubject。
JDK 动态代理虽强大，但也存在几个问题：
- 反射消耗性能。
- 目标类必须实现接口。
假如我们的目标类就没有实现接口，该怎么做？
2.3. Cglib 动态代理
静态代理和 JDK 动态代理都需要实现接口，但 Cglib 不需要。
Cglib 的底层使用了 ASM 修改字节码，动态创建代理类并加载。
虽然没有实现同一套接口，但与目标类属于继承关系，所以 final 类型的类是无法代理的。
核心类：
- Enhance，生产代理对象。
- MethodInterceptor，方法拦截器，执行到对应方法会触发拦截器。
使用方式和 JDK 动态代理类似：
public class CglibProxy implements MethodInterceptor {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("begin");
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("end");
return result;
}
@SuppressWarnings("unchecked")
public static <T> T wrap(Class<T> targetCls) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetCls);
enhancer.setCallback(new CglibProxy());
return (T) enhancer.create();
}
}
及时目标对象没有实现接口，也可以进行代理。
3. 应用
在实际开发中，代理模式有着很广的应用，也是很多框架的基础。
具体的应用有：
-
远程访问：客户端要调用远程对象时可以使用，比如 RPC 调用。
-
权限控制：方法执行权限的控制。
-
数据校验：输入参数的校验。
-
缓存设计：调用频繁或耗性能的操作加入缓存。
-
统计设计：对一些关键方法进行埋点，加入统计信息。
-
日志设计：对方法调用加入一些日志记录。
-
实现 AOP 编程。
3.1. Spring：AopProxy
AOP 编程，在我理解就是把通用的规则、规律或者公共行为统一在统一的地方搞定，然后通知到各个要处理的分类对象中（对象没有继承关系）。这样就可以实现非侵入式代码，而且便于维护和修改规则代码。
Spring AOP 编程中，来指定切入点（point cut），获取连接点（join point），编写通知（advice），内聚到一个切面类（Apect）中并使用 @Aspect 注解。
框架会去识别到这个切面类。
然后 Bean 的创建后，内部会使用 AopProxy，结合我们定义好的规则，创建代理对象，找到每个代理对象的连接点，织入增强代码。
AopProxy 的定义如下：
public interface AopProxy {
/**
* Create a new proxy object.
* <p>Uses the AopProxy's default class loader (if necessary for proxy creation):
* usually, the thread context class loader.
* @return the new proxy object (never {@code null})
* @see Thread#getContextClassLoader()
*/
Object getProxy();
/**
* Create a new proxy object.
* <p>Uses the given class loader (if necessary for proxy creation).
* {@code null} will simply be passed down and thus lead to the low-level
* proxy facility's default, which is usually different from the default chosen
* by the AopProxy implementation's {@link #getProxy()} method.
* @param classLoader the class loader to create the proxy with
* (or {@code null} for the low-level proxy facility's default)
* @return the new proxy object (never {@code null})
*/
Object getProxy(ClassLoader classLoader);
}
AopProxy 的具体实现有：
- JdkDynamicAopProxy，使用 JDK 动态代理。
- CglibAopProxy，使用 Cglib 动态代理。
4. 特点
4.1. 优势
- 解耦：降低系统耦合。
- 易修改：代理类独立变化，不影响目标类。
- 非侵入式 代码。
4.2. 缺点
- 性能损耗：增加了代理的业务逻辑，目标对象方法处理变慢。
- 增加复杂度：有些代理实现复杂。
4.3. 注意事项
- 代理类的设计要注意性能问题。
网友评论