JDK动态代理

什么是动态代理

动态代理简单来说就是在程序执行过程中，创建代理对象，通过代理对象执行方法，给目标类的方法增加额外的功能，也叫做功能增强。

JDK动态代理的实现步骤

1.首先我们需要有一个目标类，在目标类的基础上通过动态代理实现功能增强
2.创建InvocationHandler接口的实现类，在这个类中实现invoke方法，在invoke方法中实现给目标类的方法增强功能
3.通过JDK中的Proxy创建代理，通过代理调用目标类中的方法，实现功能增强

JDK动态代理的代码实现

创建一个接口：

public interface SomeService {
    void doSome();
    void doOther();
}

目标类实现这个接口：

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome() {
        System.out.println("执行doSome");
    }

    @Override
    public void doOther() {
        System.out.println("执行doOther");
    }
}

创建一个工具类，里面是增强的功能：

public class ServiceTools {

    public static void doLog(){
        System.out.println("方法的执行时间：" + new Date());
    }

    public static void doTrans(){
        System.out.println("方法执行完毕，提交事务");
    }

}

创建InvocationHandler接口的实现类

public class MyInvocationHandler implements InvocationHandler {
    //目标对象
    private Object target;

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

    //通过代理对象执行方法时，会调用执行这个invoke()方法

    /**
     *
     * @param proxy 代理类实例
     * @param method 被代理的方法
     * @param args 方法的参数数组
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("执行MyInvocationHandler中的invoke方法");

        //打印被调用的目标类中的方法名
        System.out.println(method.getName());

        Object res = null;

        //此方法是通过动态代理实现的增强的功能
        ServiceTools.doLog();

        //执行目标类方法，通过Method实现
        res = method.invoke(target, args);

        //此方法是通过动态代理实现的增强的功能
        ServiceTools.doTrans();

        //返回目标方法的执行结果
        return res;
    }
}

通过Proxy创建代理

public class MyApp {
    public static void main(String[] args) {
        //创建目标对象
        SomeService target = new SomeServiceImpl();

        //创建InvocationHandler对象
        InvocationHandler handler = new MyInvocationHandler(target);

        //使用Proxy创建代理
        SomeService proxy = (SomeService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler
        );

        //通过代理执行方法，会调用handle中的invoke()方法
        proxy.doSome();
    }
}

运行结果如下：

通过运行结果我们可以看到，通过动态代理，我们可以在不修改目标类源代码的情况下，对目标类的功能进行增强。我们可以总结一下动态代理的作用：
1.在目标类源代码不改变的情况下，增加目标类的功能
2.当涉及到多个方法都需要增加某些同样的功能时，使用动态代理可以减少代码的重复
3.可以使目标类专注于业务逻辑代码
4.实现解耦合，让业务功能和日志、事务和非事务功能分离