java spring aop 的代理的简单实现

</pre><pre class="html" name="code">

解释一下对代理的理解，我们通常在程序中有一些特殊功能，每个类都要实现，放在类的前面和后面。就像每个上班组，早上都要坐车，晚上也要坐车一样。这些东西我们可以在方法调用前调用一下， 之后再调用一下。这就是简单的静态代理类。

后来我们想，要是有1w个类，我们是不是要这种方法写1w变，很麻烦，这时候，java 中提供一种代理类，我们可以以借口模型，动态生成一个代理，代理将通用代码放在前面或后面。你所实现的功能，传到代理中，有代理，代替你执行，比如你调用add，不是你直接调用list。add 而是你调用代理，代理调用list。add。这样就有了动态代理。

spring 的aop 就是这种技术，你的通用功能如日志，我们把他放到advice中，代理自动调用，在把你的目标类配置好，也会自动调用。

<span style="color:#ff0000;">BeanFactory.class</span>

package com.aop.ldh;

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

public class BeanFactory {
	private String getProperties(String key) {
		String retVal=null;
		//1.实例化配置文件
		Properties prop = new Properties();
		//2.获得输入流
		InputStream in = this.getClass().getResourceAsStream("config.properties");
		try {
		//3.加载输入流
			prop.load(in);
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		//4.获得属性
		retVal = prop.getProperty(key);
		return retVal;
	}
	public Object getBean(){
		Object bean =null;
		try {
			//1.从配置文件获得类名，得到类的实例
			String className = this.getProperties("className");
			Class<?> clazz  = Class.forName(className);
			bean = clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		//2.判断是否是代理
		if(bean instanceof MyPorxy){
			Object  proxyBean = null;
			try {
				//2.1创建代理
				MyPorxy proxy = new MyPorxy();
				//2.2获得配置的代理源，和代理系统方法，对代理工厂进行设置
				String strTarger = getProperties("className.targer");
				String strAdvice = getProperties("className.advice");
				Object targer = Class.forName(strTarger).newInstance();
				Advice advice = (Advice)Class.forName(strAdvice).newInstance();
				proxy.setAdvice(advice);
				proxy.setTarger(targer);
				//2.3获得代理bean
				proxyBean = proxy.getProxyBean();
			} catch (Exception e) {
				// TODO Auto-generated catch block
			}
			return proxyBean;
		}
		return bean ;
	}

}

MyPorxy.class

package com.aop.ldh;

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



public class MyPorxy  {

	private  Object targer;
	private  Advice advice; 
	public   Object getProxyBean() {
/*api proxy 看一下， 第一个参数，是类加载器， 第二个参数，你目标程序实现的接口，

第三个参数，InvocationHanlder接口，有点类似监听的用法，内部类，然后实现其中的一个方法，会自动调用。

*/
		Object AretVal = Proxy.newProxyInstance(
				targer.getClass().getClassLoader(), 
				targer.getClass().getInterfaces(), 
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						advice.before(method);
						Object retVal = method.invoke(targer, args);
						advice.after(method);
						return retVal;
					}
					
		
				
				});
		return AretVal;
	
	}
	public Object getTarger() {
		return targer;
	}
	public void setTarger(Object targer) {
		this.targer = targer;
	}
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

}

advice.接口

package com.aop.ldh;

import java.lang.reflect.Method;

public interface Advice {
	void before(Method method);
	void after(Method method);
}

myadvice的实现类

package com.test;

import java.lang.reflect.Method;

import com.aop.ldh.Advice;

public class MyAdvice implements Advice{

	@Override
	public void after(Method method) {
		System.out.println("this is after");
		
	}

	@Override
	public void before(Method method) {
		System.out.println("this is before");
		
	}

}

配置文件

#className=java.util.ArrayList
className=com.aop.ldh.MyPorxy
className.advice=com.test.MyAdvice
className.targer=java.util.ArrayList

测试类

package com.test;

import java.util.Collection;

import com.aop.ldh.BeanFactory;


public class Test {
	public static void main(String[] args) {
		BeanFactory bean = new BeanFactory();
//		People people = (People)bean.getBean();
//		people.setAge(0);
//		people.getAge();
		Collection<String> coll = (Collection<String>)bean.getBean();
		coll.add("10");
		System.out.println(coll.size());
	}
}