Bean 工厂（AOP）

BeanFactory.java

package reflect.aop;

import java.io.InputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Properties;
import static java.lang.System.out;
public class BeanFactory {
	
	
	// 给出一个字符串，返回这个字符串对应的类的Bean对象
	// 如果是代理类，则返回代理，否则，则返回bean
	// 产生代理类前，要设置代理的目标、通知
	Properties proper = new Properties();
	public BeanFactory(InputStream in) {
		try {
			this.proper.load(in);
		}catch(Exception ex) {
			
		}
	}
	public Object getBean(String name) {
		
		Object bean = null;
		Class clazz = null;
		try {
			
		clazz = Class.forName(this.proper.getProperty(name));
		bean = clazz.newInstance(); // 得到一个bean 如果这个是一个代理，则得到它的代理bean
		if(bean instanceof ProxyFactoryBean)// 如果是代理类，设置其代理目标，代理消息,然后返回代理类
		{
			ProxyFactoryBean b = (ProxyFactoryBean)bean;
			b.setTarget(Class.forName(proper.getProperty("target")).newInstance());
			b.setAdvice((Advice)Class.forName(proper.getProperty("advice")).newInstance());
			return b.getProxy(); 
		}
		}catch(Exception ex) {
			ex.printStackTrace();
		}
		return bean;
	}
	// +------------  Main ------------------
	public static void main(String args[]) {
		InputStream in = BeanFactory.class.getResourceAsStream("config.properties");
		BeanFactory factory = new BeanFactory(in);
		Action bean = (Action)factory.getBean("aaa");
		out.println(bean.getClass());
		bean.cry();
	}
}
class ProxyFactoryBean
{
	private Object target = null;
	private Advice advice = null;
	public void setTarget(Object target) { // 设置代理类的代理目标
		this.target = target ;
	}
	public void setAdvice(Advice adv) {
		this.advice = adv; // 设置代理的处理消息
	}
	public Object getProxy() // 得到代理类，并执行adivce.beforeMethod advice.afterMethod
	{
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				Object result = null;
				advice.beforeMethod();
				result = method.invoke(target, args);
				advice.afterMethod();
				return result;
			}
		});
	}
}
class Advice {    // 在执行 method.invoke(target,args) 方法前执行的内容封闭成类
	public void beforeMethod()
	{
		out.println("Method start");
	}
	public void afterMethod() {
		out.println("Method end");
	}
}

Action.java

package reflect.aop;
import static java.lang.System.out;
public interface Action {//目标的接口
	
	void say();
	void smile();
	void cry();
}
class Person implements Action// 目标类
{
	@Override
	public void cry() {
		out.println("Person crying..");
	}
	@Override
	public void say() {
		out.println("Person crying..");
		
	}
	@Override
	public void smile() {
		out.println("Person crying..");
		
	}
}

配置文件

#aaa=java.lang.String
aaa=reflect.aop.ProxyFactoryBean
target= reflect.aop.Person
advice=reflect.aop.Advice