AOP代理

package cn.hunnu.aop.proxy;

public interface Dog 
{
	//info
	public void info();
	
	//run
	public void run();
}

package cn.hunnu.aop.proxy;
/**
 * Dog 实现类
 * @author 肖波
 *
 */
public class DogImpl implements Dog
{

	@Override
	public void info()
	{
		System.out.println("I am a lovely dog!");
	}

	@Override
	public void run()
	{
		System.out.println("I am running fast!");
	}
}

 

package cn.hunnu.aop.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyHandler implements InvocationHandler
{
	//需要被代理的对象
	private Object target;

	/**
	 * 执行代理的目标方法时，该invoke方法会被调用，其实这是
	 * 表面现象，实际上，在创建动态代理的时候，动态代理实现
	 * 了目标对象的所有接口，并且在指定的方法实现中，重复目标
	 * 对象的方法实现，也就是下面的method.invokke(target,args)
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable
	{
		Object result = null;
		if(method.getName().equals("info"))
		{
			System.out.println("===在调用info()方法之前的处理区域===");
			result = method.invoke(target, args);
			System.out.println("===在调用info()方法之后的处理区域===");
		}
		else if(method.getName().equals("run"))
		{
			System.out.println("===在调用run()方法之前的处理区域===");
			result = method.invoke(target, args);
			System.out.println("===在调用run()方法之后的处理区域===");
		}
			
		return result;
	}
	
	/**
	 * 该setter方法就是便于spring注入目标对象
	 * @param target：目标对象，实例中的DogImpl对象
	 */
	public void setTarget(Object target)
	{
		this.target = target;
	}
}

 

package cn.hunnu.aop.proxy;

import java.lang.reflect.Proxy;

/**
 * 代理工厂
 * @author 肖波
 *
 */
public class ProxyFactory
{
	/**
	 * 生成动态代理对象
	 * @param target ：目标对象，将被代理。
	 * @return
	 */
	public static Object getProxy(Object target)
	{
		//代理处理类
		ProxyHandler handler = new ProxyHandler();
		handler.setTarget(target);
		
		Object proxy = 
			Proxy.newProxyInstance(target.getClass().getClassLoader(), 
					target.getClass().getInterfaces(), handler);
		return proxy;
	}
}

 

package cn.hunnu.aop.proxy;
/**
 * test class
 * @author 肖波
 *
 */
public class AOPTest
{
	public static void main(String areg[])
	{
		//创建目标对象
		Dog dog = new DogImpl();
		
		//生成动态代理对象
		Dog proxy = (Dog)ProxyFactory.getProxy(dog);
		//测试代理方法AOP
		
		proxy.info();
		proxy.run();
	}
}

 

运行结果：
===在调用info()方法之前的处理区域===
I am a lovely dog!
===在调用info()方法之后的处理区域===
===在调用run()方法之前的处理区域===
I am running fast!
===在调用run()方法之后的处理区域===