[编程语言][java][java se]代理(学习)

1.代理
给目标类的方法增加一些系统功能，如异常处理、日志、计算方法的运行时间、事物管理等等，增加公共后的类就是代理。

2.代理类的优点：
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类还是代理类。这样以后很容易切换，如果想要日志功能时，就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想换掉系统功能也很容易。

3.AOP
交叉业务的编程问题即为面向方面的编程（Aspect Oriented Program，简称为AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，与之直接在方法中编写切面代码的运行效果是一致的。

4.动态代理类
JVM可在运行时，动态生成类的字节码，这种动态（不是代理，只是拿出来作为代理类）生成的类往往被用作代理类，即动态代理类。
代理类各个方法通常除了调用目标相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下位置上加上系统功能代码：

1）在调用目标方法之前

2）在调用目标方法之后

3）在调用目标方法前后

4）在处理目标方法异常的catch块中。

5.动态代理类原理和结构：
1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个
2）把系统功能代理模块化，即切面代码也改为通过参数形式提供，怎么把要执行的系统功能代码以参数的形式提供：把要执行的代码装到一个对象的某个方法中，然后把此对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外接提供的代码。方法)。

6.CGLIB库
CGLIB库可以动态生成一个类的子类，一个类的子类也可以作为该类的代理，所以，如果要为一个没有实现接口的类生成动态代理，那么可以使用CGLIB库。

7.Spring小框架模拟
1）工厂类BeanFactory负责创建目标类或代理类的实例对象，通过配置文件进行信息的修改。

2）getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。

3）BeanFactory的构造方法接收代表配置文件的输入流对象的配置文件格式如下：

xxx=java.util.ArrayList
#xxx=enhance.test.proxy.aopframework.ProxyFactoryBean
xxx.advice=enhance.test.proxy.MyAdvice
xxx.target=java.util.ArrayList

4）ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：
目标（target）
建议（advice）

5）BeanFactory和ProxyFactoryBean：

BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。

ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。

代码演示：

[java]  view plain copy

1. import java.lang.reflect.Method;  
2.   
3. public interface Advice {  
4.     //定义执行前后的两个方法  
5.     void beforeMethod (Method method);  
6.     void afterMethod (Method method);  
7. }  
8.   
9. import java.io.InputStream;  
10.   
11. public class AopFrameworkTest {  
12.     public static void main(String[] args) throws Exception {  
13.         //流对象获取配置文件信息  
14.         InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");  
15.         //传入一个参数  
16.         Object bean = new BeanFactory(ips).getBean("xxx");  
17.         System.out.println(bean.getClass().getName());  
18.     }  
19. }  
20.   
21.   
22.   
23. import java.io.*;  
24. import java.util.Properties;  
25.   
26. public class BeanFactory {  
27.     //配置文件存储对象  
28.     Properties props = new Properties();  
29.     public BeanFactory(InputStream ips){  
30.         try {  
31.             props.load(ips);  
32.         } catch (IOException e) {  
33.             // TODO Auto-generated catch block  
34.             e.printStackTrace();  
35.         }  
36.     }  
37.       
38.     //getBean方法  
39.     public Object getBean(String name) throws Exception {  
40.         //从配置文件获取要创建的Bean名  
41.         String className = props.getProperty(name);  
42.           
43.         Object bean = null;  
44.           
45.         try {  
46.             //根据className得到相应的class对象  
47.             Class clazz = Class.forName(className);  
48.               
49.             //对象实例化  
50.             bean = clazz.newInstance();  
51.         } catch (Exception e) {  
52.             // TODO Auto-generated catch block  
53.             e.printStackTrace();  
54.         }  
55.           
56.         //判断如果传入的bean为ProxyFactoryBean的实例化对象，则创建代理进行处理，否则返回bean  
57.         if(bean instanceof ProxyFactoryBean){  
58.             ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;  
59.             //通过配置文件获得Advice实例对象、target对象  
60.             Advice advice = (Advice) Class.forName(props.getProperty(name + ".advice")).newInstance();  
61.             Object target = Class.forName(props.getProperty(name + ".target")).newInstance();  
62.             //赋值  
63.             proxyFactoryBean.setAdvice(advice);  
64.             proxyFactoryBean.setTarget(target);  
65.             Object proxy = proxyFactoryBean.getProxy(proxyFactoryBean,advice);  
66.             return proxy;  
67.         }  
68.         return bean;  
69.     }  
70. }  
71.   
72.   
73.   
74. import java.lang.reflect.Method;  
75.   
76. public class MyAdvice implements Advice {  
77.   
78.     long startTime = 0;  
79.     long endTime = 0;  
80.     @Override  
81.     public void afterMethod(Method method) {  
82.         // TODO Auto-generated method stub  
83.         System.out.println("---------------end---------------");  
84.         System.out.println(method.getName()+" running time of "+(endTime - startTime));  
85.     }  
86.   
87.     @Override  
88.     public void beforeMethod(Method method) {  
89.         // TODO Auto-generated method stub  
90.         System.out.println("--------------start--------------");  
91.         startTime = System.currentTimeMillis();  
92.     }  
93.   
94. }  
95.   
96.   
97.   
98.   
99. config.properties  

[java]  view plain copy

1. import java.lang.reflect.InvocationHandler;  
2. import java.lang.reflect.Method;  
3. import java.lang.reflect.Proxy;  
4.   
5. public class ProxyFactoryBean {  
6.     private Advice advice;  
7.     private Object target;  
8.       
9.     public Advice getAdvice() {  
10.         return advice;  
11.     }  
12.     public void setAdvice(Advice advice) {  
13.         this.advice = advice;  
14.     }  
15.     public Object getTarget() {  
16.         return target;  
17.     }  
18.     public void setTarget(Object target) {  
19.         this.target = target;  
20.     }  
21.     //获得Proxy对象  
22.     public Object getProxy(final Object target,final Advice advice) {  
23.         //传递三个参数创建一个proxy对象  
24.         Object proxy1 = Proxy.newProxyInstance(  
25.                 target.getClass().getClassLoader(),  
26.                 target.getClass().getInterfaces(),   
27.                 new InvocationHandler(){  
28.   
29.                     @Override  
30.                     public Object invoke(Object proxy, Method method,  
31.                             Object[] args) throws Throwable {  
32.                         advice.beforeMethod(method);  
33.                           
34.                         Object retValue = method.invoke(target, args);  
35.                         advice.afterMethod(method);  
36.                           
37.                         return retValue;  
38.                     }  
39.                 }  
40.         );  
41.         return proxy1;  
42.     }  
43.       
44. }  
45.   
46.   
47. #xxx=java.util.ArrayList  
48. xxx=com.itheima.highProject.aopframework.ProxyFactoryBean  
49. xxx.advice=com.itheima.highProject.aopframework.MyAdvice  
50. xxx.target=java.util.ArrayList  

原文链接：http://blog.csdn.net/xuchangqun/article/details/11884647