一、代理模式基本概念
定义
1、模式说明
代理模式结构
proxy代理对象:（1）实现与具体的目标对象一样的接口，这样就可以使用代理来代替具体的目标对象（2）保存一个指向具体目标对象的引用，可以在需要的时候调用具体的目标对象，可以控制对具体目标对象的访问，并可能负责创建和删除它
Subject目标接口：定义代理和具体目标对象的接口，这样就可以在任何使用具体目标对象的地方使用代理对象
RealSubject具体的目标对象：真正实现目标接口要求的功能。
2、代理运行过程
3、代理功能
- 代理模式是通过创建一个代理对象，用这个代理对象去代表真实的对象，客户端得到这个代理对象过后，对客户端没有什么影响，就跟得到了真实对象一样来使用。
- 当客户端操作这个代理对象的时候，实际上功能最终还是会由真实的对象来完成，只不过是通过代理操作的，也就是客户端操作代理，代理操作真正的对象。
代理其实就是中转的意思，用代理对象去完成真实对象的动作。但是因为是中转，可以利用代理完成很多对客户端透明的东西，比如权限验证等。因此代理的作用可以归纳为：把一些共有的逻辑抽象到代理类中，由代理来完成，可以大大简化代码的。
4、代理分类
- 静态代理：（虚代理、保护代理、远程代理和智能指引等等）
- 动态代理：jdk动态代理、cglib动态代理
二、静态代理示例
1、创建需要代理的接口对象及其实现类
public interface Target {
String execute();
}
public class TargetImpl implements Target {
public String execute() {
System.err.println("TargetImpl execute！");
return "targetImpl";
}
}
2、创建代理对象
public class StaticProxy implements Target {
/**
* 需要被代理的目标接口
*/
private Target target;
public StaticProxy(Target target) {
this.target = target;
}
public String execute() {
//代理类进行代理方法操作（相当于中转，但是同时可以添加很多的东西，比如日志、权限等等）
System.err.println("perProcess");
String result = this.target.execute();
System.out.println("postProcess");
return result;
}
}
3、测试
public class StaticProxyTest {
public static void main(String[] args) {
Target target=new TargetImpl();
StaticProxy proxy=new StaticProxy(target);
//代理类进行代理处理
String execute = proxy.execute();
System.err.println(execute);
}
}
结果：
postProcess
perProcess
TargetImpl execute！
targetImpl
三、动态代理
静态代理具有一个明显的缺点就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活。而动态代理如其名，能动态的适应变化，应用更加广泛。
1、jdk动态代理
- Java对代理模式提供了内建的支持，在java.lang.reflect包下面，提供了一个Proxy的类和一个InvocationHandler的接口。
- Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。
- 使用jdk动态代理的步骤：
（1）通过实现InvocationHandler接口来自定义自己的InvocationHandler;
（2）通过Proxy.getProxyClass获得动态代理类
（3）通过代理对象调用目标方法
public class JdkProxyInvocation implements InvocationHandler {
private Object target;
public JdkProxyInvocation(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("========before==========");
Object result = method.invoke(target,args);
System.out.println("========after===========");
return result;
}
}
public class JdkProxy<T> {
/**
* 要被代理的对象
*/
private Class<T> target;
/**
* 具体处理逻辑的invoke
*/
private InvocationHandler invocationHandler;
public JdkProxy(Class<T> target, InvocationHandler invocationHandler) {
this.target = target;
this.invocationHandler = invocationHandler;
}
public T getProxyObject() {
return (T) Proxy.newProxyInstance(target.getClassLoader(),
target.getInterfaces() , invocationHandler);
}
}
public class JdkProxyTest {
public static void main(String[] args) {
Target target = new TargetImpl();
JdkProxyInvocation jdkProxyInvocation = new JdkProxyInvocation(target);
//获取代理对象
Target proxy = (Target) new JdkProxy(target.getClass(), jdkProxyInvocation)
.getProxyObject();
proxy.execute();
}
}
如果想深入可以看这篇分析源码的博客：深度剖析 JDK 动态代理机制
2、cglib代理
CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。
public class CglibProxy implements MethodInterceptor {
//单例模式
private static CglibProxy instance = new CglibProxy();
public static CglibProxy getInstance(){
return instance;
}
/**
* 创建代理对象
* @param cls 要代理的类
* @param <T>
* @return
*/
public <T> T getProxy(Class<T> cls){
return (T) Enhancer.create(cls, this);
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println(">>>>MethodInterceptor start...");
Object result = methodProxy.invokeSuper(obj,args);
System.out.println(">>>>MethodInterceptor ending...");
return result;
}
}
public class CglibTarget {
public String execute() {
String message = "-----------test------------";
System.out.println(message);
return message;
}
}
public class CglibTest {
public static void main(String[] args) {
CglibTarget proxy = CglibProxy.getInstance().getProxy(CglibTarget.class);
proxy.execute();
}
}
