设计模式从入门到放弃(十二)代理模式

基本概念

代理模式，是为被调用对象创建一个代理对象，通过代理对象访问目标对象。被代理对象可以在原来的基础上进行功能的增强，扩展目标对象的功能。

java的代理主要分为三种静态代理，基于JDK的动态代理，基于Cglib的动态代理

基于JDK的动态代理需要依赖接口

Cglib动态代理不需要依赖接口

UML

角色分析

Client 客户端 : 目标调用发起者

ProxyFactory 代理工厂: 返回代理对象的工厂

TargetClass: 被代理对象

代码演示

静态代理

// 被代理对象顶级接口
public interface TargetService {

    void doSomething();

}
// 被代理对象实现类
public class TargetServiceImpl implements TargetService {
    @Override
    public void doSomething() {
        System.out.println("target Class do something");
    }
}

// 代理工厂 这里通过构造器传入了被代理对象
public class TargetServiceProxy {

    private TargetService targetService;

    public TargetServiceProxy(TargetService targetService) {
        this.targetService = targetService;
    }
	
    // 创建一个与被代理对象相同的方法 里面调用了该方法然后再方法前后实现自己的增加逻辑
    void doSomething() {
        System.out.println("before proxy do something ");
        targetService.doSomething();
        System.out.println("after proxy do something ");
    }

}

基于JDK的动态代理

//被代理对象接口 基于JDK的动态代理必须要接口
public interface TargetService {

    void doSomething();

}

// 基于JDK 的动态代理实现
public class JdkProxyFactory {
	// 被代理对象 通过构造器传入
    private final Object target;

    public JdkProxyFactory(Object target) {
        this.target = target;
    }

    // 调用 jdk中的Proxy的newProxyInstance静态方法创建代理对象
    public Object getProxy() {
        /*
		 *  public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
            2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
            3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入
		 */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("before jdk proxy do something");
                        // 调用被代理对象的目标方法
                        Object result = method.invoke(target, args);
                        System.out.println("after jdk proxy do something");
                        return result;
                    }
                });
    }
}

基于Cglib的动态代理

   <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>

// 注意这里是直接使用的类没有接口
public class TargetClass {

    void doSomething(){
        System.out.println("Target Class do Something");
    }
}

// 实现了cglib中的方法拦截器
public class CglibProxyFactory implements MethodInterceptor {

    private final Object target;

    public CglibProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        // 1. 创建enhancer 增强器
        Enhancer enhancer = new Enhancer();
        // 2.设置被代理对象父类
        enhancer.setSuperclass(target.getClass());
        // 3.设置一个回调函数 这里我直接实现MethodInterceptor 就将callback设置成了自己
        enhancer.setCallback(this);
        // 4.调用增强器创建方法
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before cglib proxy ");
        // 调用被代理对象方法
        Object result = method.invoke(target, args);
        System.out.println("after cglib proxy ");
        return result;
    }
}

使用细节

三种动态代理各种特点静态代理使用简单，理解容易，直接拿一个类重新包一层即可

基于JDK的动态代理实现相对简单，但是需要被代理对象要实现接口，然后调用Proxy.newProxyInstance方法，该方法核心需要实现InvocationHandler，里面参数传入了被代理对象的方法信息

基于Cglib的动态代理无需实现接口，可以直接使用类进行代理增强

• Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类

• 被代理类不能是final

• 目标对象的方法如果为 final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.