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

本文链接：https://blog.youkuaiyun.com/chinrui/article/details/79810496

代理(Proxy)是一种设计模式，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般由以下三部分组成：

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

代理角色会持有真实角色的实例，并在其前后增加一些通用功能，从而达到功能性代码与非功能性代码解耦，如：日志，事务，权限校验等。

代理模式类图

对于代理模式的实现又分为静态代理与动态代理。

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理：在程序运行时，运用反射机制动态创建而成。

静态代理实现

接口或抽象类：

public interface SystemMgr {
    String updateUser();
}

实例目标类：

public class SystemMgrImpl implements SystemMgr {
    @Override
    public String updateUser() {
        System.out.println("更新用户信息...");
        return "张三";
    }
}

静态代理类：

public class StaticSystemMgrProxy implements SystemMgr {

    private SystemMgr systemMgr;

    public StaticSystemMgrProxy(SystemMgr systemMgr) {
        this.systemMgr = systemMgr;
    }

    @Override
    public String updateUser() {
        System.out.println("开始事务...");
        String user;
        try {
            user = systemMgr.updateUser();
            System.out.println("提交事务...");
        } catch (Exception e) {
            System.out.println("回滚事务...");
            throw e;
        }
        return user;
    }
}

单元测试：

@Test
public void testStaticProxy() {
    StaticSystemMgrProxy staticProxy = new StaticSystemMgrProxy(new SystemMgrImpl());
    System.out.println(staticProxy.updateUser());
}

在上面的代码中，代理类通过构造方法注入了目标类的实例，然后在更新用户信息前后增加了事务，而对目标类代码没有任何侵入性。

动态代理

对于动态代理，常用的两种实现方式分别为 JDK 实现及 cglib 实现。

JDK 实现

代理工厂：

public class SystemMgrJdkProxyFactory {

    public static SystemMgr getProxyInstance(SystemMgr instance) {
        return (SystemMgr) Proxy.newProxyInstance(SystemMgr.class.getClassLoader(),
                new Class[]{SystemMgr.class}, new SystemMgrTxnInvocationHandler(instance));
    }

    private static class SystemMgrTxnInvocationHandler implements InvocationHandler {

        private SystemMgr instance;

        private SystemMgrTxnInvocationHandler(SystemMgr instance) {
            this.instance = instance;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("开始事务...");
            Object invoke;
            try {
                invoke = method.invoke(instance, args);
                System.out.println("提交事务...");
            } catch (Exception e) {
                System.out.println("回滚事务...");
                throw e;
            }
            return invoke;
        }
    }
}

单元测试：

@Test
public void testJDKProxy() {
    SystemMgr proxyInstance = SystemMgrJdkProxyFactory.getProxyInstance(new SystemMgrImpl(null));
    System.out.println(proxyInstance.updateUser());
}

在上面的实现中，主要用到了 Proxy 及 InvocationHandler，通过实现 InvocationHandler，并持有目标类实例，可以在目标类方法调用前后增加事务控制，与静态代理非常类似，只是代理类变成了由Proxy进行动态生成。

CGLIB 实现

代理工厂：

public class SystemMgrCglibProxyFactory {

    private static final SystemMgrTxnMethodInterceptor SYSTEM_MGR_TXN_METHOD_INTERCEPTOR = new SystemMgrTxnMethodInterceptor();

    public static <T> T newProxyInstance(Class<T> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(SYSTEM_MGR_TXN_METHOD_INTERCEPTOR);
        return clazz.cast(enhancer.create());
    }

    private static class SystemMgrTxnMethodInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("开始事务...");
            Object invokeSuper;
            try {
                invokeSuper = proxy.invokeSuper(obj, args);
                System.out.println("提交事务...");
            } catch (Exception e) {
                System.out.println("回滚事务...");
                throw e;
            }
            return invokeSuper;
        }
    }

}

单元测试：

@Test
public void testCglibProxy() {
    SystemMgrImpl proxyInstance = SystemMgrCglibProxyFactory.newProxyInstance(SystemMgrImpl.class);
    System.out.println(proxyInstance.updateUser());
}

在 cglib 的实现里面，主要用到了 Enhancer 及 MethodInterceptor，同样是动态生成代理类，与JDK 实现的区别是，CGLIB 不依赖接口，而是依赖具体的目标类。

JDK 与 CGLIB 对比

项目	JDK	CGLIB
依赖类或接口	Proxy / InvocationHandler	Enhancer / MethodInterceptor
实现方法	实现接口，并持有目标类实例对象	继承目标类
优缺点	依赖接口，如若目标类未实现某类接口，则无法进行代理 2. 可增强已有目标类实例对象的功能，需要预先创建目标类的实例对象	依赖目标类实现，目标类如果没有无参的构造方法或者被声明为final类，则无法进行代理 2. 无法增强已有目标类实例对象，无需提前创建目标类实例对象