---

title: 设计模式之代理模式
date: 2018-08-15 20:25:42
tags:

• 设计模式
• 笔记
• Java

---

设计模式之代理模式

代理模式是给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介，用自己的话来讲就是给处理业务逻辑的真实对象增加一下额外的功能，从而实现高拓展性。

---

常见的代理模式

• 远程代理
• 虚拟代理
• 保护代理
• 智能引用代理（静态代理和动态代理）

本文只介绍静态代理和动态代理

如果按照代理创建的时期来进行分类的话， 可以分为两种：静态代理、动态代理。静态代理是由程序员创建或特定工具自动生成源代码，在对其编译。在程序员运行之前，代理类.class文件就已经被创建了。动态代理是在程序运行时通过反射机制动态创建的。

1. 静态代理

1.1 不使用静态代理

假如我们有一个汽车类实现了Movable方法，需要在行驶方法前后添加一些其他方法来拓展功能

public interface Movable {
    void move();
}
public class Car implements Movable {
    public void move() throws InterruptedException {
    System.out.println("车辆行驶中");
    Thread.sleep((long) (Math.random()*1000));
    }
}

添加其它非业务逻辑代码会不符合开闭原则(可以说是十分不优雅的写法)

public class Car implements Movable {
public void move() throws InterruptedException {
    long startTime = System.currentTimeMillis();
    System.out.println("车辆行驶中");
    Thread.sleep((long) (Math.random()*1000));
    long endTime = System.currentTimeMillis();
    System.out.println("行驶了"+(endTime-startTime)+"毫秒");
}
}

1.2 使用集成的方式实现静态代理

public class Car2 extends Car {
    @Override
    public void move() throws InterruptedException {
        long startTime = System.currentTimeMillis();
        super.move();
        long endTime = System.currentTimeMillis();
        System.out.println("行驶了"+(endTime-startTime)+"毫秒");
    }

}

1.3 使用聚合的方式实现静态代理

public class Car3 implements Movable {
    private Car car;
    public Car3(Car car) {
        this.car = car;
    }

    public void move() throws InterruptedException {
        long startTime = System.currentTimeMillis();
        car.move();
        long endTime = System.currentTimeMillis();
        System.out.println("行驶了"+(endTime-startTime)+"毫秒");
    }

}

1.4 集成和聚合两种方式的优劣

集成的方式每次添加方法就要重新定义一个类，比如添加访问权限，而且添加方法的顺序也被固定了，比如Car3（权限控制）继承Car2（日志记录），那么拓展功能的执行顺序为权限控制-->日志记录；总之拓展很麻烦。

public class PromissionCar extends Car2 {
    @Override
    public void move() throws InterruptedException {
        System.out.println("权限控制");
        super.move();
    }
}

聚合可以实现很方便的拓展

定义日志代理类

public class LogCar  implements  Movable{
    private Movable movable;

    public LogCar(Movable movable) {
        this.movable = movable;
    }

    public void move() throws InterruptedException {
        System.out.println("日志开始");
        movable.move();
        System.out.println("日志结束");
    }
}

定义时间记录代理类
public class TimeCar implements Movable {
private Movable movable;

    public TimeCar(Movable movable) {
        this.movable = movable;
    }

    public void move() throws InterruptedException {
        System.out.println("开始计时");
        long startTime = System.currentTimeMillis();
        movable.move();
        long endTime = System.currentTimeMillis();
        System.out.println("行驶了"+(endTime-startTime)+"毫秒");
    }
}

多个代理类之间可以随意组合，实现极高的拓展性

Car car = new Car();
TimeCar time = new TimeCar(car);
LogCar log = new LogCar(time);
log.move();
System.out.println("----------第二辆车----------");
LogCar log2 = new LogCar(car);
TimeCar time2 = new TimeCar(log2);
time2.move();

运行结果：

日志开始
开始计时
车辆行驶中
行驶了950毫秒
日志结束
----------第二辆车----------
开始计时
日志开始
车辆行驶中
日志结束
行驶了686毫秒

2. JDK动态代理

实现过程：

1. 编写需要被代理的方法的接口及其实现类
2. 自定义处理器实现InvocationHandler
3. 通过Proxy类的newProxyInstance方法获取代理类
4. 调用代理类的方法

首先JDK动态代理是依赖于接口的

public interface Movable2 {
    void move();
    void addOil(String oilNo);
}

需要被代理的类

public class LitterCar  implements Movable2 {
    public void move() {
        System.out.println("车辆行驶中");
    }
    public void addOil(String oilNo) {
        System.out.println("车辆正加"+oilNo+"号油");
    }
}

拓展功能需要定义一个类实现InvocationHandler接口的invoke方法

proxy:　　指代JDK动态生成的最终代理对象
method:　 指代的是我们所要调用真实对象的某个方法的Method对象
args:　　 指代的是调用真实对象某个方法时接受的参数
Object invoke(Object proxy, Method method, Object[] args)

自定义Handler

public class TimeHandler implements InvocationHandler {
    private Object object;

    public TimeHandler(Object o) {
        this.object = o;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始计时");
        long startTime = System.currentTimeMillis();
        method.invoke(object,args);
        long endTime = System.currentTimeMillis();
        System.out.println("行驶了" + (endTime - startTime) + "毫秒");
        return null;
    }
}

代理类生成需要使用Proxy类的newProxyInstance方法

loader:　　　　一个ClassLoader对象，定义了由哪个ClassLoader来对生成的代理对象进行加载
interfaces:　　 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

@Test
public void testJDKProxy() throws InterruptedException {
    LitterCar car = new LitterCar();
    Class<?> cls = car.getClass();
    TimeHandler t = new TimeHandler(car);
    Movable2 m  = (Movable2) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), t);
    m.move();
    m.addOil("93");
}

3. CgLib实现动态代理

CgLib是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。
JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

因为是使用继承来实现的，所以不能代理Final类

实现过程：

3.1 创建被代理类

public class Train {
    public void move() {
        System.out.println("火车行驶中");
    }
}

3.2. 创建MethodInterceptor方法拦截器实现类（核心）

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 o           目标类的实例
* @param method      目标方法的反射对象
* @param args        方法的参数
* @param methodProxy 代理类的实例
* @return
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println("Cglib动态代理开始");
    //代理类调用父类的方法
    Object result = methodProxy.invokeSuper(o, args);
    System.out.println("Cglib动态代理开始");
    return result;
    }
}

3.3. 通过拦截器实现类创建代理对象调用方法

@Test
public void testCglibProxy(){
    CglibProxy proxy = new CglibProxy();
    //getProxy(SuperClass.class)方法传入父类的字节码
    Train t = (Train) proxy.getProxy(Train.class);
    t.move();
}