JDK动态代理技术

动态代理最常见应用是AOP(面向切面编程)。通过AOP，我们能够地拿到我们的程序运行到某个节点时的方法、对象、入参、返回参数，并动态地在方法调用前后新添一些新的方法逻辑，来满足我们的新需求，比如日志记录等。
动态代理常见有两种方式：基于JDK的反射技术的动态代理和基于CGLib的动态代理。

使用反射技术创建动态代理

JDK创建动态代理的核心是java.lang.reflect.InvocationHandler接口和java.lang.reflect.Proxy类。让我们先分析需求，拿出模型示例，再依据示例来进行讲解这两个核心接口/类的用法。

需求分析：

面对一个大型项目，里面的类可能已设计得非常庞大臃肿，一个类里可能有上十个方法，现在，我们需要为对每个方法进行性能监控。统计方法的运行时间。如果我们通过直接在设计好的每个类方法开始结束记录时间戳来计算方法运行耗时，会有如下缺点：
1. 我们的日志记录是侵入式，同时还嵌入了大量重复冗杂的代码，如果日后需要修改，则要针对每个方法修改一遍，既不符合开放封闭的设计原则，同时也不便维护还容易出错。
2. 从业务逻辑角度来看，这些性能统计的代码和我们既有类实现的业务功能没有任何关系，如果把它们整合在一起，会造成两个不相关功能之间的耦合，不符合职责分明的原则。
那么，有没办法既不修改我们的原有类，同时又能增强我们的类功能呢？比如这里为我们的类每个方法都添加性能监控？答案便是使用动态代理。

实例展示

1. 定义我们的代理接口

package com.proxy.demo1;

public interface MyProxy {

    void method1() throws InterruptedException;
    void method2() throws InterruptedException;
    void method3() throws InterruptedException;
}

2. 定义我们的被代理对象——庞大臃肿的“老类”

package com.proxy.demo1;
//这是我们项目中“历史悠久”的类，功能完整，有很多方法。现在我们需要为每个方法都实现性能统计
//我们的被代理类要实现我们的代理接口,总某种程度讲，这也是侵入式的。但是最微弱的侵入。
public class OldClass implements MyProxy {
    @Override
    public void method1() throws InterruptedException{
        System.out.println("正在处理业务逻辑1");
        Thread.sleep(100);//模拟处理业务逻辑4过程
        System.out.println("业务逻辑1处理完成");
    }
    @Override
    public void method2() throws InterruptedException{
        System.out.println("正在处理业务逻辑2");
        Thread.sleep(200);//模拟处理业务逻辑2过程
        System.out.println("业务逻辑2处理完成");
    }
    @Override
    public void method3() throws InterruptedException{
        System.out.println("正在处理业务逻辑3");
        Thread.sleep(300);//模拟处理业务逻辑3过程
        System.out.println("业务逻辑3处理完成");
    }
    //下面还有很多很多方法。。
}

3. 定义我们的invokationHandler

package com.proxy.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//这里我们使用了泛型，假设我们有很多的类都需要进行性能监控，就可以通过在创建本类对象时在泛型标识处改成对应需要监控的类即可。
//注意需要实现JDK反射包中的InvocationHandler接口
public class //这里我们使用了泛型，假设我们有很多的类都需要进行性能监控，就可以通过在创建本类对象时在泛型标识处改成对应需要监控的类即可。
//注意需要实现JDK反射包中的InvocationHandler接口<E> implements InvocationHandler {
    //需要被代理的对象
    private E target;

    public MyInvokationHandler(E target){
        this.target = target;
    }
    /**
     * @param：
    *  proxy : 在其上调用方法的代理实例
    *  method : 对应于在目标对象调用的方法。
    *  args : 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null
    *           基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。 
    *  @return  从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，
*           则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。
    *       如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException
    *       否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。 
    *  @throws  Throwable - 从代理实例上的方法调用抛出的异常。
    *        该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型
    *        或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。
    *            如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型.
    *            代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Long beginTime = System.currentTimeMillis();//记录开始时间
        //调用目标对象的方法，同时获取该方法的返回值，作为我们本代理方法(invoke)的返回值
        Object returnValue = method.invoke(target, args);//target为我们方法所在的目标类，args为方法参数
        System.out.println("方法" + method.getName() + "调用结束，耗时"+ (System.currentTimeMillis() - beginTime));
        return returnValue;
    }

}

从字面意思理解是InvocationHandler是调用处理器，在这里，它是一个方法调用处理器。更通俗来说，我们可以将它理解成一个拦截器，当我们调用被代理类中的方法时，就会被MyInvocationHandler拦截下来，再调用我们的invoke方法。

4. 测试方法

package com.proxy.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class MainTest {
    public static void main(String args[]) throws InterruptedException{
        //新建我们的被代理对象
        OldClass oldClass = new OldClass();
        //创建我们的“拦截器”，并注入被代理对象
        InvocationHandler handler = new MyInvocationHandler<OldClass>(oldClass);
        /*getProxy返回一个指定接口的代理类实例，
        该接口可以将方法调用指派到指定的调用处理程序,这里是我们自定义的handler
        第一个参数 - 定义代理类的类加载器
        第二个参数 - 代理类要实现的接口列表
        第三个参数- 指派方法调用的调用处理程序 InvocationHandler
        */
        MyProxy myProxy = (MyProxy)Proxy.newProxyInstance(MyProxy.class.getClassLoader(),new Class[]{MyProxy.class},handler);

        myProxy.method1();
        myProxy.method2();
        myProxy.method3();
    }
}

5. 打印结果

正在处理业务逻辑1
业务逻辑1处理完成
方法method1调用结束，耗时101
正在处理业务逻辑2
业务逻辑2处理完成
方法method2调用结束，耗时200
正在处理业务逻辑3
业务逻辑3处理完成
方法method3调用结束，耗时301

我们通过代理类来调用OldClass的方法，实现了对OldClass类中所有方法耗时统计的性能监控功能，但我们并未在OldClass中嵌入任何相关的业务逻辑代码，唯一的修改就是实现了我们的代理接口。

实例分析

我们方法调用的核心实现在于使用invocationHandler，实际上，我们在通过代理接口调用被代理对象的方法如myProxy.method1()的时候，我们实际调用的是我们自定义的handler里面的invoke方法，只是，我们在invoke方法又根据传入对象（oldClass）和参数（这里没有传参），重新调用了我们oldClass里面的method1而已。而且通过这种动态代理，我们还需要修改我们的上层接口，比如我是在oldClassBoss中调用oldClass的method1方法的，现在要在我们的oldClassBoss中创建代理并通过myProxy.method1();来实现我们对原发的性能监控增强功能。这是我们需要明确的。

源码下载

本篇文章的实例源码如果需要请到https://github.com/jeanhao/spring的jdkProxy文件夹下载