设计模式-代理模式

Dear 丶 2022-05-20 05:17 174阅读 0赞

*   *  摘要
     *  1 准备工作
     *  2 静态代理
     *  3 动态代理
        
         *  3.1 JDK动态代理
         *  3.2 Cglib动态代理

## 摘要 ##

我的理解就是为目标类提供一个代理类，目的在于代理目标类对象的行为。

## 1 准备工作 ##

准备目标接口和目标类，用于代理

// 目标接口
    public interface ITarget{ 
        void do();
    }
    // 目标类
    public class Target implements ITarget{ 
        @Override
        public void do(){
            System.out.println("target do");
        }
    }

## 2 静态代理 ##

通过代理类，代替目标对象进行操作，可以达到某种控制，如加入日志功能。

// 静态代理类
    public class Proxy implements ITarget{ 
        private ITarget target;
        public Proxy(ITarget target){
            this.target=target;
        }
        @Override
        public void do(){
            // 代理方法前置操作
            target.do();
            // 代理方法后置操作
        }
    }

缺点：针对每个接口都要新增代理类

## 3 动态代理 ##

### 3.1 JDK动态代理 ###

核心接口：Proxy、InvocationHandler  
原理：在内存中生成一个类，该类实现了被代理类的接口，通过反射代理方法  
缺点：被代理类必须实现接口

Mybatis等框架基于接口编程都使用了该方式。

public class ProxyFactory<T> implements InvocationHandler { 
    
        private T target;
    
        private ProxyFactory(T target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 代理方法前置处理
            Object result = method.invoke(target, args);
            // 代理方法后置处理
            return result;
        }
    
        public static <T> T getProxy(T t) {
            return (T) Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new ProxyFactory(t));
        }
    }
    
    public class Test { 
        public static void main(String[] args) {
            ITarget target = ProxyFactory.getProxy(new Target());
            target.doSomething();
        }
    }

### 3.2 Cglib动态代理 ###

核心接口：MethodInterceptor、Enhancer  
原理：在内存中生成被代理类的子类，通过继承的方式拦截所有父类方法的调用  
缺点：生成慢，final方法不能代理  
优点：运行性能高

Cglib动态代理实现方式，通过生成代理类，继承目标类。

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.1</version>
    </dependency>
    
    public class ProxyFactory implements MethodInterceptor {
    
        public static <T> T getProxy(Class<T> clazz) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(new ProxyFactory());
            return (T) enhancer.create();
        }
    
        @Override
        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 null;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            ITarget target = ProxyFactory.getProxy(new Target());
            target.doSomething();
        }
    }