GOF23-代理模式_代理模式 gof

一、初识代理模式

代理模式：控制目标对象的访问。可以详细的控制方法的前置，后置等附加功能。由代理对象引用或者调用目标类。客户端不直接与目标类联系。

举个例子：在Spring aop中事物管理就是一个典型的代理例子，当把单个数据源事物交给spring管理时，我们对数据库的增删改操作时不会写数据库事物的开启、提交和回滚。当我们获取一个Service时是获取的一个代理对象，使用方法时，会做一个前置通知开启事物，接着执行我们的业务代码，最后提交或者回滚。 

画一个示意图

在这每一个带事物的service都有一个对应的代理类，在执行我们所写的业务代码之前和之后都会对事物进行处理。 而这个事物处理对所有数据库操作都生效。在这个例子中，service是目标类，Controller是客户端，中间包裹目标类的为代理类。

二、代理模式实现

代理模式分为静态代理，动态代理。然而动态代理又有多种实现方式。

1、静态代理模式

静态代理，动态代理差别在于代理类是否是自动生成。 顾名思义静态代理模式就是代理类为程序猿手码代码。

1）、UML类图

实现步骤：

①动态代理对象实现目标对象的接口

②代理对象持有目标对象的引用

2）代码实现

目标类

package proxy.staticproxy;
 
/**
 * 目标接口
 */
public interface ITestService {
    void execute();
}

静态代理类

package proxy.staticproxy;
 
public class TestServiceProxy implements ITestService {
    private ITestService testService;
 
    public TestServiceProxy(ITestService testService) {
        this.testService = testService;
    }
 
    public void execute() {
        System.out.println("真实方法执行前"+this.toString());
        this.testService.execute();
        System.out.println("真实方法执行后"+this.toString());
    }
}

代码测试就不放了，很简单。理解静态代理就行

2、动态代理模式

动态代理模式，要求在程序运行时自动生成代理类，提高程序的灵活性。动态代理的实现方式有JDK动态代理，cglib动态代理，javassist动态代理，asm（不在本文）。

其实动态代理实现的代理模式和静态代理实现的代理模式本质上是没啥区别的，只是动态代理模式，代理类是靠java代码操作字节码动态在内存中生成。而生成的代码中主要使用反射实现功能。

1）JDK动态代理

JDK动态代理：此动态代理是基于接口，代理类实现目标类的接口，所以目标类必须有接口，才可以使用此代理方式。实现JDK动态代理需要一个统一处理器，而这个处理器需要实现一个接口InvocationHandler，并实现invoke方法。

①目标类不变

②处理器类

package proxy.dynamic.jdk;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class TestServiceHandler implements InvocationHandler {
    private ITestService testService;
 
    public TestServiceHandler(ITestService testService) {
        this.testService = testService;
    }
 
    public ITestService getProxy(ITestService testService){
        this.testService =testService;
        ITestService proxy = (ITestService) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), 
                new Class[]{ITestService.class}, this);
        return  proxy;
    }
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("真实方法执行之前"+this.toString());
        method.invoke(testService,args);
        System.out.println("真实方法执行之后"+this.toString());
        return null;
    }
}

③测试

package proxy.dynamic.jdk;
 
import java.lang.reflect.Proxy;
 
public class Client {
    public static void main(String[] args) {
        ITestService testService = new TestService();
        TestServiceHandler handler = new TestServiceHandler(testService);
        handler.getProxy(testService).execute();
    }
 
 
}

此代理模式，只对接口中存在的方法代理，对非接口中方法是调用不了的。

2）cglib动态代理

cglib动态代理：此代理方式不需要有接口的存在，此代理方式是通过集成目标对象，成为其子类的方式实现。所以如果目标类为final类那就会失败。实现cglib动态代理需要方法拦截器并且实现MethodInterceptor接口

①目标类不变

②方法拦截器类

package proxy.dynamic.cglib;
 
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 TestServiceInterceptor implements MethodInterceptor {
    public static int sum = 0;
    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TestService.class);
        enhancer.setCallback(this);
        return enhancer.create();
    }
 
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        ++sum;
        System.out.println("真实方法执行之前"+this.toString()+"----"+sum);
        methodProxy.invokeSuper(o,args);
        System.out.println("真实方法执行之后"+this.toString()+"----"+sum);
        return null;
    }
}

③测试代码

package proxy.dynamic.cglib;
 
public class Client {
    public static void main(String[] args) {
        TestServiceInterceptor interceptor = new TestServiceInterceptor();
        ITestService proxy = (ITestService) interceptor.getProxy();
        proxy.execute("yanghs");
        proxy.toString();
    }
}

cglib实现动态代理方式会把所有public对象代理。

3）javassist动态代理

javassist动态代理：此方式是通过很强大，也不需要目标类需要接口。 宁外还可以直接手工添加需要的代买在动态代理类中。实现此方式需要方法处理器类并且实现MethodInterceptor接口。

①目标类不变

②方法处理器类

package proxy.dynamic.javassist;
 
import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyFactory;
import javassist.util.proxy.ProxyObject;
 
import java.lang.reflect.Method;
 
public class TestServiceMethodHander implements MethodHandler {
 
    private Object object;
    public Object getProxy(Object object) throws IllegalAccessException, InstantiationException {
        this.object = object;
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setInterfaces(new Class[]{ITestService.class});
        Class<?> clazz = proxyFactory.createClass();
        ITestService proxy = (ITestService) clazz.newInstance();
        ((ProxyObject)proxy).setHandler(this);
        return proxy;
    }
 
 
    public Object invoke(Object o, Method method, Method method1, Object[] args) throws Throwable {
        System.out.println("真实方法执行之前"+this.toString());
        method.invoke(object,args);
        System.out.println("真实方法执行之后"+this.toString());
        return null;
    }
}

③测试代码

package proxy.dynamic.javassist;
 
public class Client {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        ITestService testService = new TestService();
        TestServiceMethodHander methodHander = new TestServiceMethodHander();
        ITestService proxy = (ITestService) methodHander.getProxy(testService);
        proxy.execute();
    }
}

三、性能测试

1）测试代理对象生成

package proxy;
 
import proxy.dynamic.cglib.TestServiceInterceptor;
import proxy.dynamic.javassist.TestServiceMethodHander;
import proxy.dynamic.jdk.ITestService;
import proxy.dynamic.jdk.TestService;
import proxy.dynamic.jdk.TestServiceHandler;
 
public class PerformanceTest {
    static final int MAX_CYC = 1000;
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        ITestService testService = new TestService();
        Long start = System.currentTimeMillis();
        TestServiceHandler jdkhandler = new TestServiceHandler(testService);
        for(int i=0;i<MAX_CYC;i++){
            ITestService proxy = jdkhandler.getProxy();
        }
        Long end = System.currentTimeMillis();
        System.out.println("jdk动态代理创建"+MAX_CYC+"个代理对象用时"+(end-start));
 
 
        start = System.currentTimeMillis();
        TestServiceInterceptor cglibInterceptor = new TestServiceInterceptor();
        for(int i=0;i<MAX_CYC;i++){
            Object proxy = cglibInterceptor.getProxy();
        }
        end = System.currentTimeMillis();
        System.out.println("cglib动态代理创建"+MAX_CYC+"个代理对象用时"+(end-start));
 
 
        TestServiceMethodHander javassistHander = new TestServiceMethodHander();
        proxy.dynamic.javassist.ITestService javassistService = new proxy.dynamic.javassist.TestService();
        start = System.currentTimeMillis();
        for(int i=0;i<MAX_CYC;i++){
            Object proxy = javassistHander.getProxy(javassistService);
        }
        end = System.currentTimeMillis();
 
        System.out.println("javassist动态代理创建"+MAX_CYC+"个代理对象用时"+(end-start));
 
 
    }
}

结果

可见jdk代理方式对代理对象生成性能最高，所用时间最少。

2）代理对象方法调用

package proxy;
 
import proxy.dynamic.cglib.TestServiceInterceptor;
import proxy.dynamic.javassist.TestServiceMethodHander;
import proxy.dynamic.jdk.ITestService;
import proxy.dynamic.jdk.TestService;
import proxy.dynamic.jdk.TestServiceHandler;
 
public class PerformanceTest {
    static final int MAX_CYC = Integer.MAX_VALUE;
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        ITestService testService = new TestService();
        TestServiceHandler jdkhandler = new TestServiceHandler(testService);
        ITestService jdkhandlerProxy = jdkhandler.getProxy();
        Long start = System.currentTimeMillis();
        for(int i=0;i<MAX_CYC;i++){
            jdkhandlerProxy.execute();
        }
        Long end = System.currentTimeMillis();
        System.out.println("jdk动态代理对象调用"+MAX_CYC+"次方法用时用时"+(end-start));
 
 
        TestServiceInterceptor cglibInterceptor = new TestServiceInterceptor();
        proxy.dynamic.cglib.ITestService cglibInterceptorProxy = (proxy.dynamic.cglib.ITestService) cglibInterceptor.getProxy();
        start = System.currentTimeMillis();
        for(int i=0;i<MAX_CYC;i++){
            cglibInterceptorProxy.execute();
        }
        end = System.currentTimeMillis();
        System.out.println("cglib动态代理对象调用"+MAX_CYC+"次方法用时用时"+(end-start));
 
 
        TestServiceMethodHander javassistHander = new TestServiceMethodHander();
        proxy.dynamic.javassist.ITestService javassistService = new proxy.dynamic.javassist.TestService();
        proxy.dynamic.javassist.ITestService javassistHanderProxy = (proxy.dynamic.javassist.ITestService) javassistHander.getProxy(javassistService);
        start = System.currentTimeMillis();
        for(int i=0;i<MAX_CYC;i++){
            javassistHanderProxy.execute();
        }
        end = System.currentTimeMillis();
 
        System.out.println("javassist动态代理对象调用"+MAX_CYC+"次方法用时"+(end-start));
 
 
    }
}

结果

以上测试结果仅供参考，如有不对地方请指出。谢谢

4、总结

代理模式在很多地方都有用，是一个很实用的模式，而用来实现动态代理的技术更加有趣。