实现类似spring的可配置的aop框架

参照张孝祥老师的视频讲解，这里模拟spring aop的实现原理，以帮助同学们更好的理解spring aop。下面来看看具体代码吧：

1.定义配置文件config.properties

#xxx=java.util.ArrayList
xxx=com.cyq.aop.ProxyFactoryBean
xxx.advice=com.cyq.aop.MyAdvice
xxx.target=java.util.ArrayList

2.创建通知接口（切点）Advice.java

package com.cyq.aop;
/**
 * 切点抽象接口
 * @author chinoukin
 *
 */
public interface Advice {

	void beforemethod();

	void aftermethod();

}

3.创建自定义通知实现MyAdvice.java

package com.cyq.aop;
/**
 * 切点自定义实现类
 * @author chinoukin
 *
 */
public class MyAdvice implements Advice {

	@Override
	public void beforemethod() {
		System.out.println("目标对象的方法调用之前");
	}

	@Override
	public void aftermethod() {
		System.out.println("目标对象的方法调用之后");
	}

}

4.创建代理工厂类ProxyFactoryBean.java

package com.cyq.aop;

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

/**
 * 代理类工厂
 * @author chinoukin
 *
 */
public class ProxyFactoryBean {

	private Advice advice;
	private Object target;

	public Advice getAdvice() {
		return advice;
	}

	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

	public Object getTarget() {
		return target;
	}

	public void setTarget(Object target) {
		this.target = target;
	}

	public Object getProxy() {
		Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						advice.beforemethod();
						Object retVal = method.invoke(target, args);
						advice.aftermethod();
						return retVal;
					}

				});
		return proxy;
	}

}

5.创建bean工厂BeanFactory.java

package com.cyq.aop;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * bean工厂
 * @author chinoukin
 *
 */
public class BeanFactory {

	Properties prop = new Properties();

	public BeanFactory(InputStream in) {
		try {
			prop.load(in);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public Object getBean(String name) {
		String className = prop.getProperty(name);
		Object bean = null;

		try {
			Class<?> clazz = Class.forName(className);
			bean = clazz.newInstance();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

		if (bean instanceof ProxyFactoryBean) {
			Object proxy = null;
			ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;

			try {
				Advice advice = (Advice) Class.forName(prop.getProperty(name + ".advice")).newInstance();
				Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				proxy = proxyFactoryBean.getProxy();
				return proxy;
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		return bean;
	}

}

6.编写测试代码

package com.cyq.aop;

import java.io.InputStream;
import java.util.Collection;

public class AopTest {

	public static void main(String[] args) {
		
		InputStream in = AopTest.class.getResourceAsStream("config.properties");
		BeanFactory factory = new BeanFactory(in);
		
		Collection<String> collection = (Collection)factory.getBean("xxx");
		System.out.println(collection.getClass().getName());
		collection.add("aa");
		collection.add("bb");
		System.out.println(collection.size());

	}

}

输出结果如下：

com.sun.proxy.$Proxy0
目标对象的方法调用之前
目标对象的方法调用之后
目标对象的方法调用之前
目标对象的方法调用之后
目标对象的方法调用之前
目标对象的方法调用之后
2