黑马程序员——高新技术---代理

-------------------------android培训、java培训、期待与您交流！ ------------------------

第一讲    代理的概述

一、概念及作用

        1、生活中的代理：就是常说的代理商，从厂商将商品卖给消费者，消费者不用很麻烦的跑到厂商那里去购买。

        2、程序中的代理：要为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，如异常处理、日志、计算方法的运行时间、事物管理等等。

        3、简单示例：编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码，如：

代理架构图

代码体现：

相同接口：interfaceA{void sayHello();}

目标类：                                               代理类：

class X implements A{                          class Xproxy implements A{

         void sayHello(){                                    void sayHello(){

                 System.out.println(“Hello”);                 startTime;

          }                                                                    X. sayHello();

}                                                                              endTime;}}

目标类和代理类通常实现同一个或多个接口，一般用该接口来引用其子类(代理类)，如：

        Collection  coll = new ArrayList();

4、代理类的优点：

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

 

二、AOP

1、简述：AOP（AspectOriented Program）即面向方面的编程。

2、示意图

        系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

                                              安全      事务         日志

                StudentService ------|----------|------------|-------------

                CourseService  ------|----------|------------|-------------

                MiscService    -------|----------|------------|-------------

        安全、事务、日志等功能要贯穿于好多个模块中，所以他们就是交叉业务。

3、用具体的程序代码描述交叉业务：

        1）交叉业务的代码实现

                method1         method2          method3

                {                     {                     {

                ------------------------------------------------------切面

                  ....                    ....                  ......

                ------------------------------------------------------切面

                }                     }                      }

        2）交叉业务的编程问题即为面向方面的编程（Aspect orientedprogram ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

                ------------------------------------------------------切面

                func1         func2            func3

                {                {                   {

                ....               ....                  ......

                }                }                    }

                ------------------------------------------------------切面

        因此使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术，只要是用到面向方面的编程，就涉及到代理。

 

第二讲    动态代理技术

一、概述

1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，这时就不能全部采用静态代理的方式，因为要写成百上千个代理类是非常麻烦的，这时就需用动态代理技术。

2、动态代理类：JVM可以在运行期，动态生成类的字节码，这种动态生成的类（不是代理，只是拿来用作代理类）往往被用作代理类，即动态代理类。

注：JVM生成的动态类必须实现一或多个接口，所以JVM生成的动态代理类只能用作具有相同接口的目标类代理。

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

4、代理类各个方法通常除了调用目标相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下位置上加上系统功能代码：

        1）在调用目标方法之前

        2）在调用目标方法之后

        3）在调用目标方法前后

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

 

二、分析JVM动态生成的类

以创建实现了Collection接口的代理类为例：

1、用Proxy.getProxyClass方法创建实现了Collection接口的动态类和查看其名称，分析getProxyClass方法的各个参数。

        1）编码列出动态类中的所有构造方法和参数签名

        2）编码列出动态类中的所有方法和参数签名 

2、创建动态类的实例对象

        1）用反射获得构造方法

        2）编写一个最简单的InvocationHandler类（代理类构造方法接收的参数）

        3）调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去

        4）打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

        5）将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼匿名内部类的使用。

3、也可以直接用Proxy.newInstance方法直接一步就创建出代理对象。

示例：

[java]  view plain copy

1. package cn.itheima.demo;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.InvocationHandler;  
5. import java.lang.reflect.Method;  
6. import java.lang.reflect.Proxy;  
7. import java.util.ArrayList;  
8. import java.util.Collection;  
9.   
10. public class ProxyDemo {  
11.   
12.     public static void main(String[] args) throws Exception{  
13.         //利用Proxy的方法getProxyClass(ClassLoader loader,Class<?>... interface)方法来生成动态类  
14.         //这里以实现Collection接口的代理类为例  
15.         Class clazzProxy=Proxy.getProxyClass(ProxyDemo.class.getClassLoader(), Collection.class);  
16.         System.out.println(clazzProxy.getName());//com.sun.proxy.$Proxy0  
17.           
18.         System.out.println("----------begin constructors list----------");  
19.         /*获取这个代理类的构造方法,以下列形式输出 
20.          * $Proxy0() 
21.          * $Proxy0(InvocationHandler,int) 
22.          * */  
23.         Constructor[] constructors=clazzProxy.getConstructors();  
24.         for (Constructor constructor : constructors) {  
25.             //System.out.println(constructor);  
26.             //直接输出的结果public com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)  
27.               
28.             String name=constructor.getName();  
29.             name=name.substring(name.lastIndexOf('.')+1);//将方法名进行处理  
30.             StringBuilder sBuilder=new StringBuilder(name);//定义一个容器来存储  
31.             sBuilder.append('(');  
32.             Class[] clazzParams=constructor.getParameterTypes();//获取参数列表的类型  
33.             for (Class clazzParam : clazzParams) {  
34.                 String paramName=clazzParam.getName();//对参数类型名进行处理  
35.                 //paramName=paramName.substring(paramName.lastIndexOf('.')+1);  
36.                 sBuilder.append(paramName).append(',');  
37.             }  
38.             //如果没有构造函数或者构造函数没有参数，则删除最后一个","字符  
39.             if(clazzParams!=null&&clazzParams.length!=0){  
40.                 sBuilder.deleteCharAt(sBuilder.length()-1);  
41.             }  
42.             sBuilder.append(')');  
43.               
44.             System.out.println(sBuilder.toString());//输出  
45.         }  
46.           
47.         System.out.println("----------begin method list----------");  
48.         /*获取这个代理类具备的方法,以下列形式输出 
49.          * toString() 
50.          * hashCode() 
51.          * clear() 
52.          * addAll(java.util.Collection) 
53.          * */  
54.           
55.         Method[] methods=clazzProxy.getMethods();  
56.         for (Method method : methods) {  
57.             String name=method.getName();  
58.             name=name.substring(name.lastIndexOf('.')+1);//将方法名进行处理  
59.             StringBuilder sBuilder=new StringBuilder(name);//定义一个容易来存储  
60.             sBuilder.append('(');  
61.             Class[] clazzParams=method.getParameterTypes();//获取参数列表的类型  
62.             for (Class clazzParam : clazzParams) {  
63.                 String paramName=clazzParam.getName();//对参数类型名进行处理  
64.                 //paramName=paramName.substring(paramName.lastIndexOf('.')+1);  
65.                 sBuilder.append(paramName).append(',');  
66.             }  
67.             //如果没有构造函数或者构造函数没有参数，则删除最后一个","字符  
68.             if(clazzParams!=null&&clazzParams.length!=0){  
69.                 sBuilder.deleteCharAt(sBuilder.length()-1);  
70.             }  
71.             sBuilder.append(')');  
72.               
73.             System.out.println(sBuilder.toString());//输出      
74.         }  
75.           
76.         System.out.println("----------begin create instance object----------");  
77.         Constructor constructor =clazzProxy.getConstructor(InvocationHandler.class);  
78.         // 方式一：通过创建InvocationHandler的子类，传递给构造函数的创建实例对象方法参数，来创建实例  
79.         class MyInvocationHandler1 implements InvocationHandler{  
80.             @Override  
81.             public Object invoke(Object proxy, Method method, Object[] args)  
82.                     throws Throwable {  
83.                   
84.                 return null;  
85.             }  
86.         }  
87.         Collection proxy1 =(Collection)constructor.newInstance(new MyInvocationHandler1());  
88.         System.out.println(proxy1.toString());  
89.         proxy1.clear();//无异常  
90.         //proxy1.size();//报错，空指针异常  
91.           
92.           
93.         //方式二：利用匿名内部类来创建InvocationHandler子类对象  
94.         Collection proxy2=(Collection)constructor.newInstance(new InvocationHandler(){  
95.             @Override  
96.             public Object invoke(Object proxy, Method method, Object[] args)  
97.                     throws Throwable {  
98.                   
99.                 return null;  
100.             }  
101.         });  
102.           
103.         //方式三：利用Proxy提供的静态newProxyInstance方法来一步到位的创建代理类实例对象  
104.         Collection proxy3=(Collection)Proxy.newProxyInstance(  
105.                 //第一个参数，定义代理类的类加载器  
106.                 ProxyDemo.class.getClassLoader(),  
107.                 //第二个参数，代理类要实现的接口列表  
108.                 new Class[]{Collection.class},  
109.                 //第三个参数，代理类的构造函数的参数  
110.                 new InvocationHandler() {  
111.                     ArrayList target=new ArrayList();//指定目标  
112.                     @Override//复写invoke方法  
113.                     public Object invoke(Object proxy, Method method, Object[] args)  
114.                             throws Throwable {  
115.                         long startTime=System.currentTimeMillis();//开始时间  
116.                         Object retval=method.invoke(target, args);//调用目标  
117.                         long endTime=System.currentTimeMillis();//结束时间  
118.                         //测试方法运行时间  
119.                         System.out.println(method.getName()+"running time:"+(endTime-startTime));  
120.                         return retval;        
121.                     }  
122.                 });  
123.           
124.          //通过代理类调用目标方法，每调用一个目标的方法就会执行代理类的方法    
125.         //当调用一次add方法时，就会找一次InvocationHandler这个参数的invoke方法   
126.         proxy3.add("itheima");  
127.         proxy3.add("itcast");  
128.         proxy3.add("itshenma");  
129.         System.out.println(proxy3.size());//3  
130.         System.out.println(proxy3.getClass().getName());//com.sun.proxy.$Proxy0  
131.     }  
132. }  

4、让JVM创建动态类及其实例对象，需要提供的信息：

        1）生成类中的哪些方法，通过让其实现哪些接口的方式进行告知。

        2）产生的类字节码必须有一个关联的类加载器对象

        3）生成的类中的方法的代码是怎么样的，也得由我们自己提供。把我们的代码写在一个约定好的子接口对象的方法中，把对象传给它，它调用我们的方法，即相当于插入了我们自己的代码。提供执行代码的对象就是InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的，在上面的InvocationHandler对象的invoke方法中，加一点代码就可以看到这些代码被调用运行了。

 

三、分析动态生成的类的内部代码

1、如上示例中，动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个接收InvocationHandler参数的构造方法。接受此对象的用处：在类中定义这个对象的引用，以便在需要时应用它。

2、实现Collection接口的动态类中的各个方法的代码的解析：

        InvocationHandler接口中定义的invoke方法接受三个参数的含义：

       第一、Client(客户端)程序调用objProxy.add(“avc”)方法时，涉及到了三个要素，分别为：objProxy对象，add方法，”avc”参数。代码如下：

[java]  view plain copy

1. class Proxy${  
2.   add(Object obj){  
3.       return handler.invoke(Object proxy, Method method, Object[] args);  
4.    }  
5. }  

        第二、其中的Object proxy即为objProxy对象，Method method对应add方法，Object[] args就是”avc”参数。在使用newProxyInstance的方式创建代理对象实现时，当前正在调用的代理对象（Object proxy），调用当前对象的哪个方法（Method method），调用此对象方法时传入的参数（Object[] args）。

4、对于上面代码中的Object retVal = method.invoke(target,args)的分析：

        目标对象target执行完返回一个值为retVal，接着将值作为结果return回去，则代理方法就会收到一个返回值。其中还可以定义一个过滤器，对参数args（即当前对象的方法传入的参数）进行过滤（修改）。

5、对于上面代码中的proxy3.add(“sdfd”)的分析：

        1）代理对象调用add方法，传递了sdfd参数。

        2）add方法内部会找到InvocationHandler中的invoke方法，将代理对象proxy传进去，把add方法传入，将“sdfd”参数传入代理对象中的handler参数，返回了一个结果给了add方法，add方法继续向外返回给调用的对象proxy3，即最终结果。

 

四、问题

1、在上面的方式一的代码中，调用无返回值的方法返回的是null，而调用有返回值方法的时候会报NullPointException异常的原因：

        在proxy1.size()方法中，size()会调用Object invoke()方法，而对其覆写时的返回值是null，而size()本身会返回int类型，两者返回的类型不相等，所以就会报错。

        而对于proxy3.size()不报错，是因为size()返回值与invoke()方法返回值是一致的，当前目标返回什么，代理就返回什么，所以不会报错。

注意：目标返回值和代理返回值必须是同一类型。

2、为何动态类的实例对象的getClass()方法返回了正确结果：

        因为只有调用代理对象从Object类继承的hashCode,equals,或toString这几个方法时，代理对象会将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。所以对于getClass()方法，还是Object实例的原方法。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。

实现代码如下：

[java]  view plain copy

1. $Proxy0 implements Collection  
2. {  
3.     InvocationHandler handler;  
4.     public $Proxy0(InvocationHandler handler)  
5.     {  
6.         this.handler = handler;  
7.     }  
8.     //生成的Collection接口中的方法的运行原理  
9.     int size()  
10.     {  
11.         return handler.invoke(this,this.getClass().getMethod("size"),null);  
12.     }  
13.     void clear(){  
14.         handler.invoke(this,this.getClass().getMethod("clear"),null);  
15.     }  
16.     boolean add(Object obj){  
17.         handler.invoke(this,this.getClass().getMethod("add"),obj);  
18.     }  
19. }  

 

五、总结分析动态代理类的统计原理和结构

1、怎样将目标传进去：

        1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是没有实际意义。

        2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。

        3）让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。

2、动态代理的工作原理：

        1）Client(客户端)调用代理，代理的构造方法接收一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。

示意图：

 

        2）将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标，同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

       在这里将InvocationHandler加入到Proxy的构造方法中，因此，在创建出来的对象，就会存有构造方法中InvocationHandler的一些功能和信息，因为我们把想要运行的代码封装在InvocationHandler对象，把它传入到构造函数中，那么就实现了代理对象每次调用与目标方法相同方法（因为实现了同一接口）时，都会调用我们加入到InvocationHandler对象中的代码。这就保证了每次调用代理时，可以在目标上加入我们自己加入的功能。

3、把系统功能代理模块化，即切面代码也改为通过参数形式提供，怎么把要执行的系统功能代码以参数的形式提供：

        1）把要执行的代码装到一个对象的某个方法中，然后把此对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外接提供的代码。

        2）为getProxy方法增加一个Advice参数。

示例：

[java]  view plain copy

1. package cn.itheima.demo;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6. import java.util.ArrayList;  
7. import java.util.Collection;  
8.   
9. public class ProxyDemo {  
10.   
11.     public static void main(String[] args) throws Exception{  
12.         final ArrayList target=new ArrayList();//指定目标  
13.         Advice advice=new MyAdvice();//将要添加的代码封装成对象  
14.         //使用Proxy提供的静态newProxyInstance方法来一步到位的创建代理类实例对象  
15.         Collection proxy3 = (Collection)getProxy(target,advice);  
16.            
17.         proxy3.add("itheima");  
18.         proxy3.add("itcast");  
19.         proxy3.add("itshenma");  
20.         System.out.println(proxy3.size());//3  
21.     }  
22.   
23.     //作为一个通用的方法，就使用Object    
24.     //传入一个目标，并传入一个接口，此接口作为通信的契约，才能调用额外的方法  
25.     private static Object getProxy(final Object target,final Advice advice) {  
26.         Object proxy3=Proxy.newProxyInstance(  
27.                 //第一个参数，定义代理类的类加载器  
28.                 target.getClass().getClassLoader(),  
29.                 //第二个参数，代理类要实现的接口列表，这里要与target实现相同的接口  
30.                 //new Class[]{Collection.class},  
31.                 target.getClass().getInterfaces(),  
32.                 //第三个参数，代理类的构造函数的参数  
33.                 new InvocationHandler() {  
34.                       
35.                     @Override//复写invoke方法  
36.                     public Object invoke(Object proxy, Method method, Object[] args)  
37.                             throws Throwable {  
38.                           
39.                         //使用约定的对象中的方法  
40.                         advice.beforeMehod();  
41.                         Object retval=method.invoke(target, args);//调用目标  
42.                         advice.afterMethod(method);  
43.                         return retval;    
44.                     }  
45.                 });  
46.         return proxy3;  
47.     }  
48. }  
49.   
50. import java.lang.reflect.Method;  
51. //只要实现Advice中的方法，里面的代码功能可以随便定义，调用代理时就会被使用  
52. public class MyAdvice implements Advice {  
53.     long startTime;  
54.     @Override  
55.     public void beforeMehod() {  
56.         System.out.println("学习结束。。。");  
57.         startTime=System.currentTimeMillis();  
58.     }  
59.   
60.     @Override  
61.     public void afterMethod(Method method) {  
62.         System.out.println("开始学习...");  
63.         long endTime=System.currentTimeMillis();  
64.         System.out.println(method.getName()+"  running time:"+(endTime-startTime));  
65.     }  
66. }  
67.   
68. import java.lang.reflect.Method;  
69.   
70. /*接口中需要实现四个方法  
71.  * 调用目标方法之前  
72.  * 调用目标方法之后  
73.  * 调用目标方法前后  
74.  * 在处理目标方法异常的catch块中  
75.  */    
76. //这里用两个作为示例，创建Advice接口  
77. public interface Advice {  
78.     void beforeMehod();  
79.     void afterMethod(Method method);  
80. }  

 

第三讲     实现AOP功能的封装与配置

一、工厂类BeanFactory

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。

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

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

        #xxx=java.util.ArrayList

        xxx=cn.itcast.test3.aopframework.ProxyFactoryBean

        xxx.advice=cn.itcast.test3.MyAdvice

        xxx.target=java.util. ArrayList

注意：其中的#代表注释当前行。

4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：

        目标（target）  

        通知（advice）

5、BeanFactory和ProxyFactoryBean：

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

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

 

二、实现类似spring的可配置的AOP框架的思路

1、创建BeanFactory类：

        1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。

        2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。

        3）通过其字节码对象创建实例对象bean。

        4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。

2、创建ProxyFactoryBean(接口)，此处直接定义为类做测试，其中有一个getProxy方法，用于获得代理类对象。

3、编写实现Advice接口的类和在配置文件中进行配置。

4、定义一个测试类：AopFrameworkTest，也称客户端，调用BeanFactory获取对象。

示例：

配置文件信息：

        xxx=java.util.ArrayList

        xxx=cn.itheima.demo.aopframework.ProxyFactoryBean

        xxx.target=java.util.ArrayList

        xxx.advice=cn.itheima.demo.MyAdvice

[java]  view plain copy

1. package cn.itheima.demo.aopframework;  
2.   
3. import java.io.InputStream;  
4. import java.util.Collection;  
5. //测试类  
6. public class AopFrameworkTest {  
7.   
8.     public static void main(String[] args) {  
9.         //用输入流关联配置文件  
10.         InputStream in=AopFrameworkTest.class.getResourceAsStream("config.properties");  
11.         Object bean =new BeanFactory(in).getBean("xxx");//获取bean对象  
12.         System.out.println(bean.getClass().getName());//打印获得的bean对象  
13.         ((Collection)bean).toString();//测试使用  
14.     }  
15. }  
16.   
17.   
18. import java.io.IOException;  
19. import java.io.InputStream;  
20. import java.util.Properties;  
21.   
22. import cn.itheima.demo.Advice;  
23. //创建BeanFactory类，用于创建目标类或者代理类的实例对象。  
24. public class BeanFactory {  
25.     Properties properties=new Properties();//定义properties集合  
26.     public BeanFactory(InputStream in){  
27.         try {  
28.             properties.load(in);  
29.         } catch (IOException e) {  
30.               
31.             e.printStackTrace();  
32.         }  
33.     }  
34.     //从配置文件中获取对象  
35.     public Object getBean(String name){  
36.         String className=properties.getProperty(name);//获取配置文件中的值  
37.         Object bean=null;  
38.         try {  
39.             Class clazz=Class.forName(className);//通过反射创建对象  
40.             bean=clazz.newInstance();  
41.         } catch (Exception e) {  
42.               
43.             e.printStackTrace();  
44.         }   
45.         //如果创建的对象是ProxyFactoryBean类型,则通过getProxy方法获取代理类对象  
46.         if (bean instanceof ProxyFactoryBean) {  
47.             Object proxy=null;  
48.             //已知bean的类型  
49.             ProxyFactoryBean proxyFactoryBean=(ProxyFactoryBean)bean;  
50.             try {  
51.                 //从配置文件中获取代理类额外添加的代码封装成的对象  
52.                 Advice advice=(Advice)Class.forName(properties.getProperty(name+".advice")).newInstance();  
53.                 //从配置文件中获取目标  
54.                 Object target=Class.forName(properties.getProperty(name+".target")).newInstance();  
55.                 proxyFactoryBean.setAdvice(advice);  
56.                 proxyFactoryBean.setTartget(target);  
57.                 //调用getProxy方法，获取代理对象  
58.                 proxy= proxyFactoryBean.getProxy(target, advice);  
59.             } catch (InstantiationException | IllegalAccessException  
60.                     | ClassNotFoundException e) {  
61.                   
62.                 e.printStackTrace();  
63.             }  
64.             return proxy;  
65.         }  
66.         return bean;  
67.     }  
68. }  
69.   
70.   
71. import java.lang.reflect.InvocationHandler;  
72. import java.lang.reflect.Method;  
73. import java.lang.reflect.Proxy;  
74.   
75. import cn.itheima.demo.Advice;  
76. //创建ProxyFactoryBean类，用于产生代理类实例对象  
77. public class ProxyFactoryBean {  
78.     private Advice advice;  
79.     private Object target;   
80.     public Advice getAdvice() {  
81.         return advice;  
82.     }  
83.     public void setAdvice(Advice advice) {  
84.         this.advice = advice;  
85.     }  
86.     public Object getTartget() {  
87.         return target;  
88.     }  
89.     public void setTartget(Object tartget) {  
90.         this.target = tartget;  
91.     }  
92.     public Object getProxy(final Object target,final Advice advice) {  
93.         Object proxy3=Proxy.newProxyInstance(  
94.                 //第一个参数，定义代理类的类加载器  
95.                 target.getClass().getClassLoader(),  
96.                 //第二个参数，代理类要实现的接口列表，这里要与target实现相同的接口  
97.                 //new Class[]{Collection.class},  
98.                 target.getClass().getInterfaces(),  
99.                 //第三个参数，代理类的构造函数的参数  
100.                 new InvocationHandler() {  
101.                       
102.                     @Override//复写invoke方法  
103.                     public Object invoke(Object proxy, Method method, Object[] args)  
104.                             throws Throwable {  
105.                           
106.                         //使用约定的对象中的方法  
107.                         advice.beforeMehod();  
108.                         Object retval=method.invoke(target, args);//调用目标  
109.                         advice.afterMethod(method);  
110.                         return retval;    
111.                     }  
112.                 });  
113.         return proxy3;  
114.     }  
115.       
116. }  

     -------------------------android培训、java培训、期待与您交流！ ------------------------