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

本文链接：https://blog.youkuaiyun.com/ldaolong/article/details/84655170

一、核心思想

为一个对象提供一个代理对象，并由代理对象控制对象的引用。

代理与适配器、装饰器的区别：

1)、适配器是将类A转换成另一个类B

2)、装饰器是为了一个类A增加一个新功能，从而变成类B.

3)、代理模式是为一个类A转换操作类B.

关系图：

代码：

 
    [java]  
    view plain 
    copy 
   
public interface Sourceable {  
    public void method();  
}  

 
    [java]  
    view plain 
    copy 
   
public class Source implements Sourceable {  
  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  

 
    [java]  
    view plain 
    copy 
   
public class Proxy implements Sourceable {  
  
    private Source source;  
    public Proxy(){  
        super();  
        this.source = new Source();  
    }  
    @Override  
    public void method() {  
        before();  
        source.method();  
        atfer();  
    }  
    private void atfer() {  
        System.out.println("after proxy!");  
    }  
    private void before() {  
        System.out.println("before proxy!");  
    }  
}  

测试类：

 
    [java]  
    view plain 
    copy 
   
public class ProxyTest {  
  
    public static void main(String[] args) {  
        Sourceable source = new Proxy();  
        source.method();  
    }  
  
}  

二、代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

三、动态代理

核心思想：接口和实现类之间可以不直接发生联系，而可以在运行期实现动态关联。

Java动态代理主要涉及到两个类：

InvocationHandler：该接口中仅定义了一个Object : invoke(Object proxy, Method method, Object[] args);参数proxy指代理类，method表示被代理的方法，args为method中的参数数组，返回值Object为代理实例的方法调用返回的值。这个抽象方法在代理类中动态实现。

Proxy：所有动态代理类的父类，提供用于创建动态代理类和实例的静态方法。

所谓动态代理类是在运行时生成的class，在生成它时，你必须提供一组interface给它，则动态代理类就宣称它实现了这些interface。当然，动态代理类就充当一个代理，你不要企图它会帮你干实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

Code:

/**
* 抽象角色：声明真实对象和代理对象的共同接口
* @author WalkingDog
*
*/
public interface Subject {
public void doSomething();

}

* 真实对象：定义目标操作
* @author WalkingDog
*
*/
public class RealSubject implements Subject {
@Override
public void doSomething() {
System.out.println("RealSubject.doSomething");
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Before Invoke ! method : " + method);
//我们可以再代理方法调用前后添加功能
Object result = method.invoke(object, args);
System.out.println("object : " + object + "\tresult : " + result + "\targs : " + args);
System.out.println("After Invoke !");
return result;
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
* 客户端
* @author WalkingDog
*
*/
public class Client {
public static void main(String[] args) throws Exception {
//创建目标对象，也就是被代理对象
RealSubject realSubject = new RealSubject();
//将目标对象交给代理
InvocationHandler handler = new DynamicProxy(realSubject);
// Class<?> proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()
// , new Class[]{Subject.class});
// Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})
// .newInstance(new Object[]{handler});
//返回代理对象，相当于上面两句
Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(),
handler);
//叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会
//用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，
//method为doSomething()，参数为方法要传入的参数，这里没有
subject.doSomething();
}
}

四、CGlib

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

demo:

public class CglibProxy implements MethodInterceptor{
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
  //设置需要创建子类的类
  enhancer.setSuperclass(clazz);
  enhancer.setCallback(this);
  //通过字节码技术动态创建子类实例
  return enhancer.create();
}
//实现MethodInterceptor接口方法
public Object intercept(Object obj, Method method, Object[] args,
   MethodProxy proxy) throws Throwable {
  System.out.println("前置代理");
  //通过代理类调用父类中的方法
  Object result = proxy.invokeSuper(obj, args);
  System.out.println("后置代理");
  return result;
}
}

具体实现类：

public class DoCGLib {
public static void main(String[] args) {
  CglibProxy proxy = new CglibProxy();
  //通过生成子类的方式创建代理类
  SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);
  proxyImp.say();
}
}

CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。