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() {@Overridepublic 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{@Overridepublic void after(Method method) {System.out.println("this is after");}@Overridepublic void before(Method method) {System.out.println("this is before");}}

配置文件#className=java.util.ArrayListclassName=com.aop.ldh.MyPorxyclassName.advice=com.test.MyAdviceclassName.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());}}