模拟Spring中的AOP编程

建立自己程序的目录如上

package javatribe.fts.aopframework;

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

import javatribe.fts.proxy.Advice;

/*
 * 此类的构造方法接收代表配置未见的输入流对象，配置文件的格式如下
 * #fts=java.util.ArrayList
 * fts=javatribe.fts.aopframework.ProxyFactoryBean
 * fts.advice=javatribe.fts.proxy.MyAdvice
 * fts.target=java.util.ArrayList
 * 这是一个纯粹的工厂，bean工厂
 */
public class BeanFactory {
	Properties props=new Properties();
	//客户端传入一个InputStream
    public BeanFactory(InputStream ips){
    	try {
			props.load(ips);
		} catch (IOException e) {
			e.printStackTrace();
		}
    	
    }
    //对外方法得到一个bean
    public Object getBean(String name){
    	//获取到类名的全路径，例如java.util.ArrayList
    	String className=props.getProperty(name);
    	//System.out.println(className);
    	Object bean=null;
    	try {
    		//获取一个Class
			Class clazz=Class.forName(className);
			//创建一个不带参数的构造方法bean
			bean=clazz.newInstance();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		//判断这个bean是否属于ProxyFactoryBean的实例
		//如果是则创建一个代理对象，否则直接返回bean
    	if(bean instanceof ProxyFactoryBean){
    		Object proxy=null;
    		ProxyFactoryBean proxyFactoryBean=(ProxyFactoryBean)bean;
    		try {
				Advice advice=(Advice) Class.forName(props.getProperty(name+".advice")).newInstance();
				Object target=Class.forName(props.getProperty(name+".target")).newInstance();
				proxyFactoryBean.setAdvice(advice);
				proxyFactoryBean.setTarget(target);
				proxy=proxyFactoryBean.getProxy();
			} catch (Exception e) {
				e.printStackTrace();
			} 
    		return proxy;
    	}
    	
    	return bean;
    }
    
}

package javatribe.fts.aopframework;

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

import javatribe.fts.proxy.Advice;

/*
 * 充当封装生成动态代理的工厂，需要为工厂类提供一些配置参数信息，例如：目标和通知
 */
public class ProxyFactoryBean {
	//advice是一个接口
	private Advice advice;
	//目标值target
	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 proxy2=Proxy.newProxyInstance(
				   target.getClass().getClassLoader(),
				  target.getClass().getInterfaces(),
				  new InvocationHandler(){
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {						
						advice.beforeMethod(method);
						Object retValue=method.invoke(target, args);
						advice.afterMethod(method);
						return retValue;
					 }		  
				   }
				  );
		return proxy2;
	}
}

接下来是一个配置文件的内容：

#fts=java.util.ArrayList
fts=javatribe.fts.aopframework.ProxyFactoryBean
fts.advice=javatribe.fts.proxy.MyAdvice
fts.target=java.util.ArrayList

编写一个测试类：

package javatribe.fts.aopframework;

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

public class AopFrameworkTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		InputStream ips=AopFrameworkTest.class.getResourceAsStream("config.properties");
        Object bean=new BeanFactory(ips).getBean("fts");
        System.out.println(bean.getClass().getName());
        ((Collection)bean).clear();
        
	}

}

通过以上程序，就编写了自己一个简单的AOP框架

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#fts=java.util.ArrayList
fts=cn.itcast.ProxyFactoryBean
fts.target=java.util.ArrayList
fts.advice=cn.itcast.MyAdvice
ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供目标和通知配置参数信息。
编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象