结构型-代理模式

源码地址|https://github.com/DingMouRen/DesignPattern

代理模式：在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。

静态代理类

在不改变原始类（或叫被代理类）的情况下，通过引入代理类来给原始类附加功能。一般情况下，我们让代理类和原始类实现同样的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的。在这种情况下，我们可以通过让代理类继承原始类的方法来实现代理模式。

/**
 * 抽象接口
 */
public interface Manager {

    void doSomething();
}

/**
 * 被代理类
 */
public class Admin implements Manager{
    @Override
    public void doSomething() {
        System.out.println("Admin--doSomething");
    }
}

/**
 * 代理类
 */
public class AdminProxy1 implements Manager {

    private Admin admin;

    public AdminProxy1(Admin admin) {
        this.admin = admin;
    }

    @Override
    public void doSomething() {
        System.out.println("adminProxy1 -- doSomething");
        admin.doSomething();
    }
}

/**
 * 代理类
 */
public class AdminProxy2 implements Manager {

    private Admin admin;

    public AdminProxy2(Admin admin) {
        this.admin = admin;
    }

    @Override
    public void doSomething() {
        System.out.println("adminProxy2 -- doSomething");
        admin.doSomething();
    }
}

/**
 * 使用类
 */
public class Client {

    public static void main(String[] args) {
        Admin admin = new Admin();

        //代理1执行
        AdminProxy1 adminProxy1 = new AdminProxy1(admin);
        adminProxy1.doSomething();

        //代理2执行
        AdminProxy2 adminProxy2 = new AdminProxy2(admin);
        adminProxy2.doSomething();
    }
}

缺点：静态代理中，需要将被代理类中所有的方法实现一遍，并且为每个方法附加相似的代码逻辑；另外如果要添加的附加功能
的类有多个，需要针对每个类创建一个代理类，增加维护成本。

动态代理

不用事先为每个原始类编写代理类，而是在运行的时候，动态的创建原始类对应的代理类，然后在系统中庸代理类替换原始类。
Java 语言本身就已经提供了动态代理的语法。

/**
 * 抽象接口
 */
public interface Moveable {

    void move();
}

/**
 * 被代理类
 */
public class Car implements Moveable {
    @Override
    public void move() {
        System.out.println("汽车行驶中...");
    }
}

/**
 * 事务处理器
 */
public class TimeHandler implements InvocationHandler {
    private Object target;

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


    /**
     *
     * @param proxy 被代理的对象
     * @param method 被代理对象的方法
     * @param args 方法参数
     * @return  方法返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        method.invoke(target,args);
        long stopTime = System.currentTimeMillis();
        System.out.println("汽车结束行驶");
        System.out.println("汽车行驶时间："+(stopTime - startTime)+"毫秒");
        return null;
    }
}

/**
 * 使用类
 */
public class Client {
    public static void main(String[] args) {
        Car car = new Car();

        ClassLoader classLoader = car.getClass().getClassLoader();
        Class<?>[] clsArr = car.getClass().getInterfaces();
        InvocationHandler handler = new TimeHandler(car);

        Moveable moveable = (Moveable) Proxy.newProxyInstance(classLoader,
                                                    clsArr,
                                                    handler);
        moveable.move();
    }
}

cglib代理

cglib代理使用需要引入额外的jar包 cglib.jar

/**
 * 被代理类
 */
public class Train {
    public void move(){
        System.out.println("火车行驶中...");
    }
}

/**
 * 代理类
 */
public class CGLibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class<?> clazz){
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    /**
     * 拦截所有目标类方法的调用
     * @param obj 目标实例对象，被代理类
     * @param method 被代理类的反射对象
     * @param args 方法参数
     * @param methodProxy 代理类的实例
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("日志开始");
        methodProxy.invokeSuper(obj,args);
        System.out.println("日志结束");
        return null;
    }
}


/**
 * 使用类
 */
public class Client {
    public static void main(String[] args) {
        CGLibProxy proxy = new CGLibProxy();
        Train train = (Train) proxy.getProxy(Train.class);
        train.move();
    }
}

代理模式的应用场景

• 在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、日志等。我们将这些附加功能与业务功能解耦，放在代理类中统一处理，
• 开发一个接口请求，一个支持缓存，一个支持实时查询。开发两个接口增加开发成本，应该是动态代理。如果是基于 Spring 框架来开发的话，那就可以在 AOP 切面中完成接口缓存的功能。在应用启动的时候，我们从配置文件中加载需要支持缓存的接口，以及相应的缓存策略（比如过期时间）等。当请求到来的时候，我们在 AOP 切面中拦截请求，如果请求中带有支持缓存的字段（比如http://…?..&cached=true），我们便从缓存（内存缓存或者 Redis 缓存等）中获取数据直接返回。

附：
静态代理需要代理类与被代理类同时实现接口
动态代理类需要被代理类实现接口
cglib不需要代理类或者被代理类实现接口