通过代码组织，让你更好的理解和使用JDK动态代理

       最近在看jdk的动态代理和aop的一些概念，发现对于jdk动态代理的使用，网上的博客大多写的都很简单，基本都是基于Object类型使用的，代码相对来说不好理解, 使用容易出错，而且没有将JDK代码与AOP关联起来。我们知道：一个好的开发视图和目录结构，能够帮助我们更好的理解代码作者的意图。经常写JDK动态代理的就可以发现，创建代理对象的过程存在很多相似之处，为此按照个人的理解，重新组织了下代码结构，形成以后可直接复用的工具API。

      使用JDK动态代理，必须要实现一个InvocationHandler类，个人觉得这种做法存在2个问题：

1、目标对象和横切逻辑没有关联，实际使用中，横切逻辑和目标对象的关联，交给了使用者来处理;
2、InvocationHandler是基于Object，不会在编译期进行类型检查，使用者容易出错;

基于这2点考虑，提供了以下工具类

package jdk.util;import java.lang.reflect.InvocationHandler;/** * JDK提供了InvocationHandler用来让使用者自行添加横切逻辑，个人觉得这有2点不好之处：<br> * 1、目标对象和横切逻辑没有关联,实际使用中, 横切逻辑和目标对象的关联,交给了客户端来处理;<br> * 2、InvocationHandler是基于Object，不会在编译期进行类型检查，使用者容易出错;<br> *  * 基于这种考虑，提供了接口IProxyCallBack用来约束目标对象和InvocationHandler的关联; * 使用了泛型,是因为一种横切逻辑应该能适用于所有类型的对象; */// T是需要代理的目标对象的类型public interface IProxyCallBack<T> extends InvocationHandler{    // 返回目标对象    public T getTargetObject();    // 返回回调(感觉好像没有什么用处)    public InvocationHandler getInvocationHandler();}

接下来我们考虑如何创建代理对象，我认为：

1、创建代理对象，对客户端来说应该是一个透明的过程,客户端只需要传递创建中需要的参数即可(目标对象,方法回调);

2、创建代理对象是一个重复而且有规律的过程,不管什么类型，只要是创建代理，都应该能使用该方法

基于这2点考虑，提供了以下类

package jdk.util;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;/** * 1、创建代理对象，对客户端来说应该是一个透明的过程,客户端只需要传递创建中需要的参数即可(目标对象,方法回调);<br> *  * 2、创建代理对象是一个重复而且有规律的过程,不管什么类型，只要是创建代理，都应该能使用该方法<br> *  * 基于以上2点考虑，提供了工具类方法，用来生成代理对象,客户端只需要传递一个参数即可,使用了泛型，用来支持不同类型的目标对象 */public final class ProxyFactory{    // 返回一个代理类对象,T是目标对象类型    @SuppressWarnings("unchecked")    public final static <T> T createProxyInstance(IProxyCallBack<T> callbcak)    {        T target = callbcak.getTargetObject();        Class<T> targetClazz = (Class<T>) target.getClass();        // jdk只支持基于接口的代理(可以借助cglib实现基于类的代理)        if (targetClazz.getInterfaces() == null)        {            throw new RuntimeException("JDK proxy baseed only interface");        }        InvocationHandler hander = callbcak.getInvocationHandler();        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),                hander);        return (T) proxy;    }}

     假设我们拥有了一个原始的接口和服务类

package jdk.original;public interface IWelcomeService {public void sayName();public void sayAge();}package jdk.original;/** * 已经编写好的服务 */public class WelcomeServiceImpl implements IWelcomeService{public void sayName(){System.out.println("my name is aty!");}public void sayAge(){System.out.println("my age is 24");}}

假如我们想增加一个日志切面，需要实现IProxyCallBack接口，代码如下：

package jdk.aspect;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import jdk.util.IProxyCallBack;//日志切面public class LoggerCallbackImpl<T> implements IProxyCallBack<T>{    // 目标对象    private T target = null;        // 代理名称    private String name = null;        public LoggerCallbackImpl(String proxyName, T target)    {        this.name = proxyName;        this.target = target;    }        @Override    public Object invoke(Object proxy, Method method, Object[] parmas) throws Throwable    {        System.out.println("begin------" + name);                // 反射执行目标对象的业务方法        Object result = method.invoke(target, parmas);                System.out.println("end------" + name);                return result;    }        @Override    public T getTargetObject()    {        return this.target;    }        @Override    public InvocationHandler getInvocationHandler()    {        return this;    }}

现在我们看下如何使用这些类，完成AOP

import jdk.aspect.LoggerCallbackImpl;import jdk.aspect.TimeCallbackImpl;import jdk.original.IWelcomeService;import jdk.original.WelcomeServiceImpl;import jdk.util.IProxyCallBack;import jdk.util.ProxyFactory;/** * 测试类主要完成2个功能: <br> * 1、创建回调对象(实现横切逻辑、绑定目标对象);<br> * 2、返回生成的代理对象;<br> *  * 结合spring的aop，个人理解:<br> * 第1步应该是由使用者实现1个横切面(实现横切逻辑),然后配置该切面需要织入到那些类的哪些方法上(绑定目标对象);<br> * 第2步由框架自动生成代理对象,用户应该感觉不到代理对象的创建;而且用户感觉不到代理对象的使用,<br> * 即用户还是使用原来的目标对象,但是却会加上横切逻辑 */public class ClientMain {public static void main(String[] args) throws Exception {// 原始对象(织入点)IWelcomeService originalObject = new WelcomeServiceImpl();// 回调对象(建立横切逻辑和织入点的关联)IProxyCallBack<IWelcomeService> firstHander = new LoggerCallbackImpl<IWelcomeService>("1级代理", originalObject);// 创建1级代理(框架创建代理对象)IWelcomeService firstProxy = (IWelcomeService) ProxyFactory.createProxyInstance(firstHander);// 客户端透明使用代理firstProxy.sayName();System.out.println("-------------------");// 创建2级代理IProxyCallBack<IWelcomeService> secondHander = new LoggerCallbackImpl<IWelcomeService>("2级代理", firstProxy);IWelcomeService secondProxy = (IWelcomeService) ProxyFactory.createProxyInstance(secondHander);secondProxy.sayName();//添加时间切面IProxyCallBack<IWelcomeService> timeHander = new TimeCallbackImpl<IWelcomeService>(firstProxy);IWelcomeService timeProxy = (IWelcomeService) ProxyFactory.createProxyInstance(timeHander);timeProxy.sayName();}}