动态代理和静态代理的详细介绍

代理模式是常用的Java设计模式，特征是代理类与委托类有相同的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象的时候，是通过代理对象来访问的，代理模式就是在访问实际对象的时候引入一定程度的间接性，因为这种间接性，可以附加多种用途。

静态代理

静态代理，由程序员创建或特定工具自动生成源代码，在编译时已经将接口，被代理类(委托类)，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成。

假定一个团购长途汽车车票的场景，有50个乘客要去客运站买长途汽车车票，由跟车人去代买50张车票。在这里，乘客有买车票的行为，跟车人也有买车票的行为，那么乘客买车票就可以由跟车人去代理执行。

首先是创建一个买票人的接口。

/**
 * 买票人接口
 */
public interface TickectBuyer { 
    // 买车票
    void buyTicket();
}

然后是创建一个乘客类(委托类)，去实现买票人接口。

/**
 * 乘客类，实现了买票人接口
 */
public class Passenger implements TickectBuyer { 
    private String name; 
    Passenger(String name) {
        this.name = name;
    } 
    @Override
    public void buyTicket() {
        System.out.println("乘客【" + name + "】买了一张车票。");
    }
}

然后是创建一个乘客代理类，同样实现买票人接口。

因为持有一个乘客类对象，所以它可以代理乘客类对象执行买车票的行为。

/**
 * 乘客代理类，也实现买票人接口
 */
public class PassengerProxy implements TickectBuyer { 
    private String name;
    // 被代理的乘客类
    private Passenger passenger;
    PassengerProxy(String name, Passenger passenger) { 
        this.name = name; 
        // 只代理乘客类
        if (passenger.getClass() == Passenger.class) {
            this.passenger = passenger;
        }
    } 
    @Override
    public void buyTicket() {
        // 委托类附加的操作
        System.out.print("代买人【" + name + "】代");
        // 调用委托类（乘客类）的方法
        passenger.buyTicket();
    }
}

最后创建一个测试类测试代理的结果。

/**
 * 乘客代理测试类
 */
public class PassengerProxyTest { 
    public static void main(String[] args) {
        // 乘客陈小鸡（乘客类）
        Passenger passenger = new Passenger("陈小鸡");
        // 跟车人（乘客代理类）
        PassengerProxy carFollower = new PassengerProxy("王小狗", passenger);
        // 由跟车人代理陈小鸡买车票
        carFollower.buyTicket();
    }
}

结果是：代买人【王小狗】代乘客【陈小鸡】买了一张车票。

这里可以看到，代理类可以通过持有委托类对象去调用委托类的方法，从而达到代理委托类去执行委托类行为的目的。然后，在调用委托类方法的时候，可以在调用的前面或者后面添加代理类自己的行为，比如上面代码中添加打印代理人信息的行为。这个就是代理模式的一个很大的优点，可以在代理点切入一些特定的、附加的操作，却不会改变原来委托要执行的行为。

动态代理

代理类在程序运行时常见的代理方式被称为动态代理。我们上面静态代理的例子中，代理类PassengerProxy是自己定义好的，在程序运行之前就已经编译完成。不同的是，动态代理的代理类并不是在Java代码中定义好的，而是在运行时根据我们在Java代码中的指示动态生成的。相比于静态代理，动态代理的优势在于可以很方便地对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。比如说，想要在每个代理的方法前都加上一个处理方法：

public void buyTicket() {
    // 在调用委托类的方法前，加入其他逻辑处理
    beforeMethod(); 
    // 调用委托类（乘客类）的方法
    passenger.buyTicket();
}

这里只有一个buyTickect()方法，就只要写一次beforeMethod()方法。可是如果有很多个地方都要调用beforeMethod()方法，就需要改很多个地方，给修改或维护带来麻烦。动态代理就是为了解决这样的麻烦，而由聪明绝顶(滑稽)的人才想出来的解决方法。

在Java的java.lang.reflect包(反射包啦，看到这应该明白动态代理是用Java的反射机制实现的了吧，不会反射的还不去先学一下反射)下提供了一个Proxy类和InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

创建一个InvocationHandler对象。

// 创建一个与代理对象相关联的InvocationHandler
InvocationHandler passengerHandler = new MyInvocationHandler<TickertBuyer>(passenger);

使用Proxy类的getProxyClass静态方法生成一个动态代理类passengerProxyClass。

Class<?> passengerProxyClass = Proxy.getProxyClass(TickectBuyer.class.getClassLoader(), new Class<?>[] {TickectBuyer.class});

获得passengerProxy中一个带InvocationHandler参数的构造器constructor。

Constructor<?> constructor = passengerProxy.getConstructor(InvocationHandler.class);

通过构造器constructor来创建一个动态实例passengerProxy。

TickectBuyer passengerProxy = (TickectBuyer) constructor.newInstance(passengerHandler);

这样，一个动态代理对象passengerProxy就创建完毕了。另外的，上面四个步骤可以通过Proxy类的newProxyInstancs方法来简化：

// 创建一个与代理对象相关联的InvocationHandler
InvocationHandler passengerHandler = new MyInvocationHandler<TickectBuyer>(passenger);
// 创建一个代理对象passengerProxy，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
TickectBuyer passengerProxy= (TickectBuyer) Proxy.newProxyInstance(TickectBuyer.class.getClassLoader(), new Class<?>[]{TickectBuyer.class}, passengerHandler);

那么动态代理是要如何执行，如何通过代理对象来执行被代理对象的方法呢。我们可以通过完整的动态代理的例子来说明。还是上面跟车人帮乘客代买车票的例子。

首先是定义一个TickectBuyer接口，其中有一个未实现的buyTickect()方法。

public interface TickectBuyer { 
    // 买车票
    void buyTicket();
}

然后是创建需要被代理的乘客类。

public class Passenger implements TickectBuyer { 
    private String name; 
    Passenger(String name) {
        this.name = name;
    } 
    @Override
    public void buyTicket() {
        try {
            // 假设买一张票要5秒
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("乘客【" + name + "】买了一张车票。");
    }
}

然后定义一个检测方法执行时间的工具类，在任何方法执行之前先调用start()方法，执行后调用finish()方法，就可以计算出该方法的运行时间，这也是一个最简单的方法执行时间检测工具。

public class MonitorUtil 
    private static ThreadLocal<Long> tl = new ThreadLocal<>(); 
    public static void start() {
        tl.set(System.currentTimeMillis());
    }
    // 结束时打印耗时
    public static void finish(String methodName) {
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName + "方法耗时" + (finishTime - tl.get()) + "ms");
    }
}

然后创建PassengerInvocationHandler类，实现InvocationHandler接口。这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke()方法，所有执行代理对象的方法都会被替换成执行invoke()方法。在invoke()方法中执行被代理对象target的相应方法。当然，在代理过程中，我们可以在真正执行被代理对象的方法前加入自己的其他处理。这也是Spring中AOP实现的主要原理，其实就是Java基础的反射机制，没有什么神秘的黑科技啦。

public class PassengerInvocationHandler<T> implements InvocationHandler {
    // InvocationHandler持有的被代理对象
    private T target; 
    public PassengerInvocationHandler(T target) {
        this.target = target;
    } 
    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行" + method.getName() + "方法");
        // 代理过程中插入监测方法，计算该方法耗时
        MonitorUtil.start();
        Object result = method.invoke(target, args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

做完上面的工作后，我们就可以具体来创建动态代理对象了。

public class PassengerProxyTest2 {
    public static void main(String[] args) {
        // 创建一个实例对象，这个对象是被代理的对象
        TickectBuyer zhangsan = new Passenger("张三"); 
        // 创建一个与代理对象相关联的InvocationHandler
        InvocationHandler passengerHandler = new PassengerInvocationHandler<TickectBuyer>(zhangsan); 
        // 创建一个代理对象passengerProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        TickectBuyer passengerProxy = (TickectBuyer) Proxy.newProxyInstance(TickectBuyer.class.getClassLoader(),
                new Class<?>[]{TickectBuyer.class}, passengerHandler);
        // 代理执行买车票的方法
        passengerProxy.buyTicket();
    }
}

我们执行这个PassengerProxyTest2类之前，先想以下，我们创建了一个需要被代理的乘客张三，将张三对象传给了passengerHandler，在创建代理对象passengerProxy时，将passengerHandler作为参数，上面有说到所有执行代理对象的方法都会被替换成执行invoke()方法，也就是说，最后执行的是passengerInvocationHandler中的invoke()方法。

上面说到，动态代理的优势在于可以很方便地对代理类的方法进行统一的处理，而不用修改每个代理类中的方法，这是因为所有被代理执行的方法，都是通过InvocationHandler中的invoke()方法调用的，我们只要在invoke()方法中统一处理，就可以给所有被代理的方法进行统一添加相同的操作了。例如这里的方法计时，所有的被代理对象执行的方法都会被计时。

Java动态代理模式的过程，代理对象和被代理对象的关系不像静态代理那样一目了然，清晰明了。因为动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地看到动态代理中被代理对象是怎么被代理的，也不知道为什么代理对象执行的方法都会通过InvocationHandler中的invoke()方法执行。