通过代码组织，让你更好的理解和使用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();
	}
}