为什么使用动态代理？

相对于静态代理，减少了一些代码量。
相对于静态代理，程序扩展性更好。
动态代理中，代理类的逻辑，与被代理类的逻辑，完全分离开来，耦合度降低
动态代理的优势就是实现无侵入式的代码扩展
动态代理实现了在原始类和接口未知的时候，就确定代理的代理行为，当代理类和原始类脱离直接联系后，就可以灵活的重用到不同的应用场景中

从静态代理说起

什么是代理模式

代理模式分为"静态代理"和"动态代理"。
代理模式主要的功能是控制对对象的访问。比如“同步”，“事务”，“权限”等。

Remember that the main intent of a proxy is to control access to
the target object, rather than to enhance the functionality of the
target object

Ways that proxies can provide access control include:
→ Synchronization
→ Authentication
→ Remote Access
→ Lazy instantiation

静态代理

先来看一个简单的接口，一个汽车的接口有启，停，前，退四个方法。

public interface IVehicle {
   public void start();
   public void stop();
   public void forward();
   public void reverse();
 }

给它一个简单的实现类:

public class Car implements IVehicle {
    public void start() {
        System.out.println("Car started");
    }
    public void stop() {
        System.out.println("Car stopped");
    }
    public void forward() {
        System.out.println("Car forwarded");
    }
    public void reverse() {
        System.out.println("Car reversed");
    }
 }

假设有个需求，要记录汽车启，停，前，退方法被调用时的时间。
最low的方法是直接修改Car这个类，但这样的程序毫无扩展性可言，也不符合面向对象的设计规范。

public class Car implements IVehicle {
    public void start() {
        System.out.println("Car started at " + new Date());
        System.out.println("Car started");
    }
    public void stop() {
        System.out.println("Car stopped at " + new Date());
        System.out.println("Car stopped");
    }
    public void forward() {
        System.out.println("Car forwarded at " + new Date());
        System.out.println("Car forwarded");
    }
    public void reverse() {
        System.out.println("Car reversed at " + new Date());
        System.out.println("Car reversed");
    }
 }

记录时间这个逻辑不应该在Car的职责范围类，所以我们引入“静态代理”来解决这个问题。

public class CarProxy implements IVehicle {
    private IVehicle vehicle;
    public CarProxy(IVehicle  vehicle){
        this.vehicle=vehicle;
    }
    public void start() {
        System.out.println("Car started at " + new Date());
        this.vehicle.start();
    }
    public void stop() {
        System.out.println("Car stopped at " + new Date());
        this.vehicle.stop();
    }
    public void forward() {
        System.out.println("Car forwarded at " + new Date());
        this.vehicle.forward();
    }
    public void reverse() {
        System.out.println("Car reversed at " + new Date());
        this.vehicle.reverse();
    }
 }

这样做的确分离了代理逻辑，但同样存在问题：

哪天IVehicle要加更多的方法进来，CarProxy不也要跟着加代码？
CarProxy里的代理逻辑看起来不重复吗？
如果其它的类，也需要如此的代理逻辑，重新给他们写个代理类吗？

动态代理

JDK 动态代理

首先实现ProxyHander，即实现代理的逻辑，也就是记录时间

public class ProxyHander implements InvocationHandler {
    private Object proxiedObject;

    public ProxyHander(Object proxiedObject) {
        this.proxiedObject = proxiedObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        //代理的逻辑，记录时间
        System.out.println("Car " + method.getName() + " at " + new Date());
        
        //调用被代理类的方法
        return method.invoke(proxiedObject, args);
        
    }
}

使用Proxy.newProxyInstance()去实例化一个代理类

public class Main {
    public static void main(String[] args) {
        
        IVehicle carProxy = (IVehicle)Proxy.newProxyInstance(
                IVehicle.class.getClassLoader(),
                new Class[]{IVehicle.class}, 
                new ProxyHander(new Car())
            );
        
        carProxy.start();
        carProxy.stop();
        carProxy.forward();
        carProxy.reverse();
    }
}

输出

Car start at Thu Mar 02 21:42:49 CST 2017
Car started
Car stop at Thu Mar 02 21:42:49 CST 2017
Car stopped
Car forward at Thu Mar 02 21:42:49 CST 2017
Car forwarded
Car stop at Thu Mar 02 21:42:49 CST 2017
Car stopped

可以看出，实现JDK的动态代理还是比较简单的，相对于静态代理，这样的实现在程序扩展性上会更好。