(原)Java动态代理实现（简单AOP实现）

最新推荐文章于 2023-12-25 15:22:15 发布

iteye_13492

最新推荐文章于 2023-12-25 15:22:15 发布

阅读量75

点赞数

文章标签： Java AOP

本文链接：https://blog.csdn.net/iteye_13492/article/details/81882044

版权

本文介绍了一种简单的AOP（面向切面编程）实现方法，通过定义Aspect接口和使用动态代理来实现在目标方法调用前后增加特定行为的功能。文章提供了完整的代码示例，包括Aspect接口、动态代理工厂类、代理执行类以及测试代码。

摘要由CSDN通过智能技术生成

本文介绍了简单Aop实现的方法，意在抛砖引玉。

首先是简单的Aspect接口

package org.aspect;

/**
 * 切面接口
 */
public interface Aspect {

	/**
	 * 事先执行
	 */
	public void doBefore();

	/**
	 * 事后执行
	 */
	public void doAfter();
}

然后是代理工厂

package org.aspect;

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

/**
 * 代理工厂类
 */
public class DynamicProxyFactory {

	/**
	 * 私有构造方法
	 */
	private DynamicProxyFactory() {}

	/**
	 * 工厂方法
	 * 
	 * @param instance 代理目标类实例对象
	 * @param aspect 切面对象
	 */
	public static Object newInstance(Object instance, Aspect aspect) {

		List<Aspect> aspectList = new ArrayList<Aspect>();
		aspectList.add(aspect);

		return newInstance(instance, aspectList);
	}

	/**
	 * 工厂方法
	 * 
	 * @param instance 代理目标类实例对象
	 * @param aspectList 切面集合
	 */
	public static Object newInstance(Object instance, List<Aspect> aspectList) {
		SimpleInvocationHandler hander = new SimpleInvocationHandler();
		hander.setAspectList(aspectList);
		hander.setSource(instance);
		return Proxy.newProxyInstance(instance.getClass().getClassLoader(), 
									  instance.getClass().getInterfaces(), 
									  hander);
	}
}

最后是代理执行类

package org.aspect;

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

/**
 * 代理委托接口实现
 */
public class SimpleInvocationHandler implements InvocationHandler {


	private Object source = null;

	private List<Aspect> aspectList = null;


	public Object getSource() {
		return source;
	}


	public void setSource(Object source) {
		this.source = source;
	}


	public List<Aspect> getAspectList() {
		return aspectList;
	}


	public void setAspectList(List<Aspect> aspectList) {
		this.aspectList = aspectList;
	}

	/**
	 * 委托方法
	 * 
	 * @param proxy 代理对象
	 * @param method 代理方法
	 * @param args 方法参数
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {

		for (Aspect aspect : aspectList) {
			aspect.doBefore();
		}

		Object retObj = method.invoke(getSource(), args);

		for (int index = aspectList.size() - 1; index >= 0; index--) {
			aspectList.get(index).doAfter();
		}

		return retObj;
	}

}

测试代码

public interface Student {
	public void sayHello();
}

import org.aspect.Aspect;

public class StudentAspectOne implements Aspect {

	@Override
	public void doAfter() {
		System.out.println("do After One");

	}

	@Override
	public void doBefore() {
		System.out.println("do Before One");

	}

}

import org.aspect.Aspect;


public class StudentAspectTwo implements Aspect{
	@Override
	public void doAfter() {
		System.out.println("do After Two");

	}

	@Override
	public void doBefore() {
		System.out.println("do Before Two");

	}
}

public class StudentImpl implements Student {

	@Override
	public void sayHello() {
		System.out.println("Student");
	}

}

import java.util.ArrayList;
import java.util.List;

import org.aspect.Aspect;
import org.aspect.DynamicProxyFactory;

public class Test {

	public static void main(String[] args) {

		List<Aspect> aspectList = new ArrayList<Aspect>();

		aspectList.add(new StudentAspectOne());
		aspectList.add(new StudentAspectTwo());
		Student s = (Student)DynamicProxyFactory.newInstance(new StudentImpl(), aspectList);
		s.sayHello();
	}

}