JDK动态代理的代码组织与AOP

       最近在看jdk的动态代理和aop的一些概念，发现jdk的动态代理，网上大多写的都很简单，基本都是基于Object类型使用的，导致难以理解, 使用容易出错。按照个人的理解，组织了下jdk动态代理的结构。

 

util包 ：  放置供客户端使用的api

aspect：包放系统中需要的切面实现

 

 

        经常写JDK动态代理的就可以发现，创建代理对象的过程存在很多相似之处，为此按照个人的理解，提供了以下工具API。

 

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();

}

 

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");
	}
}

 

使用代理的客户端代码如下

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();
	}
}