代理模式(Proxy)

一、核心思想

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

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

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

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

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

关系图：

代码：

[java] view plaincopy

1. public interface Sourceable {  
2.     public void method();  
3. }  

[java] view plaincopy

1. public class Source implements Sourceable {  
2.   
3.     @Override  
4.     public void method() {  
5.         System.out.println("the original method!");  
6.     }  
7. }  

[java] view plaincopy

1. public class Proxy implements Sourceable {  
2.   
3.     private Source source;  
4.     public Proxy(){  
5.         super();  
6.         this.source = new Source();  
7.     }  
8.     @Override  
9.     public void method() {  
10.         before();  
11.         source.method();  
12.         atfer();  
13.     }  
14.     private void atfer() {  
15.         System.out.println("after proxy!");  
16.     }  
17.     private void before() {  
18.         System.out.println("before proxy!");  
19.     }  
20. }  

测试类：

[java] view plaincopy

1. public class ProxyTest {  
2.   
3.     public static void main(String[] args) {  
4.         Sourceable source = new Proxy();  
5.         source.method();  
6.     }  
7.   
8. }  

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

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

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方法，无法进行代理。