1. package Study.ProxyStudy;
   
2. 
   
3. import java.lang.reflect.Constructor;
   
4. import java.lang.reflect.InvocationHandler;
   
5. import java.lang.reflect.InvocationTargetException;
   
6. import java.lang.reflect.Method;
   
7. import java.lang.reflect.Proxy;
   
8. 
   
9. public class ProxyTestThree {
   
10. 
    
11.         /**创建代理类的三种方式
    
12.          * @param args
    
13.          * @throws InvocationTargetException
    
14.          * @throws IllegalArgumentException
    
15.          * @throws IllegalAccessException
    
16.          * @throws InstantiationException
    
17.          * @throws SecurityException
    
18.          * @throws NoSuchMethodException
    
19.          */
    
20.         public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    
21.                 // TODO Auto-generated method stub
    
22.                 fun_A();
    
23.                 fun_B();
    
24.         }
    
25.         public static void fun_A() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    
26.                 Class<?> clazz = Proxy.getProxyClass(Test.class.getClassLoader(), A.class, B.class);
    
27.                 Constructor<?> con = clazz.getConstructor(InvocationHandler.class);       
    
28.                 //创建的代理类对象引用委托类实现接口A
    
29.                 A obj = (A) con.newInstance(new InvocationHandler(){
    
30.                         Test t = new Test();   //先在匿名内部类的成员位置创建一个目标类（委托类）对象
    
31.                         @Override
    
32.                         public Object invoke(Object proxy, Method method, Object[] args)
    
33.                                         throws Throwable {
    
34.                                 // TODO Auto-generated method stub       
    
35.                                 Object obj = method.invoke(t, args);
    
36.                                 System.out.println("为代理类添加的功能一般是：安全、事务、日志方面的功能");
    
37.                                 return obj;
    
38.                         }       
    
39.                 });
    
40.                 obj.println_1();    //只能通过代理类调用接口中覆盖的方法
    
41.                 //obj.println_2();    //报错
    
42.         }
    
43.         public static void fun_B(){
    
44.                 B obj = (B) Proxy.newProxyInstance(Test.class.getClassLoader(), new Class[]{A.class, B.class},
    
45.                                 new InvocationHandler() {
    
46.                                         Test t = new Test();
    
47.                                         @Override
    
48.                                         public Object invoke(Object proxy, Method method, Object[] args)
    
49.                                                         throws Throwable {
    
50.                                                 // TODO Auto-generated method stub
    
51.                                                 Object obj = method.invoke(t, args);
    
52.                                                 System.out.println("为代理类添加的功能一般是：安全、事务、日志方面的功能");
    
53.                                                 return obj;
    
54.                                         }
    
55.                                 });
    
56.                 obj.println_2();
    
57.         }
    
58. }
    
59. interface A{
    
60.         void println_1();
    
61. }
    
62. interface B{
    
63.         void println_2();
    
64. }
    
65. //给Test类设计一个代理类
    
66. class Test implements A, B{
    
67.         @Override
    
68.         public void println_1() {
    
69.                 // TODO Auto-generated method stub
    
70.                 System.out.println("覆盖接口A中的方法");
    
71.         }
    
72.         @Override
    
73.         public void println_2() {
    
74.                 // TODO Auto-generated method stub
    
75.                 System.out.println("覆盖接口B中的方法");
    
76.         }
    
77.         public void print3(int i){
    
78.                 if(i > 0 ){
    
79.                         this.println_1();
    
80.                 }
    
81.                 else{
    
82.                         this.println_2();
    
83.                 }
    
84.         }
    
85. }

复制代码

以上代码中的委托类Test实现了两个接口A、B，本想尝试一下用两种创建代理类的方法(构造器创建、字节码直接创建)来调用委托类中的覆盖方法，可结果是：实现的代理类只能调用自己一个接口中的覆盖方法，如果想调用另外一个接口中的方法，必须再创建一个委托类；并且创建的代理类还不能调用委托类自身的方法？这到底是怎么回事，是不是我的代码和思路出了一点小问题没有发现还是说代理类只能调用一个接口的方法并且不能调用委托类自身的方法，求解释

实现的代理类只能调用自己一个接口中的覆盖方法，如果想调用另外一个接口中的方法，必须再创建一个委托类？

通过查看创建的代理类中的方法，可以看到代理类中确实有println_1和println_2方法，但是创建的对象只能是A接口或B接口中的一个，创建了A接口的对象就只能用A接口中的方法，你可以这样，创建一个接口C，让A接口和B接口继承自C接口，然后创建C接口的实例对象，就可以调用两个方法了。

并且创建的代理类还不能调用委托类自身的方法？

可以调用委托类自身，在InvocationHandler的invoke方法中只调用委托类方法，不加系统功能不就是委托类原来的方法吗？但是这样做没有什么意义，因为你使用代理类本身就是要区别委托类的方法，如果要使用委托类的方法，可以直接创建委托类的对象啊。

WakeUp 发表于 2014-9-30 23:58
实现的代理类只能调用自己一个接口中的覆盖方法，如果想调用另外一个接口中的方法，必须再创建一个委托类？ ...

感谢，实现代理类调用两个委托接口中的方法问题解决了
但是调用委托类特有方法的问题还是没有解决？可能是我技术所限，有点没听懂你的解释