实现InvocationHandler的类

1. import java.lang.reflect.InvocationHandler;
   
2. import java.lang.reflect.Method;
   
3. 
   
4. import org.omg.CORBA.portable.InvokeHandler;
   
5. public class MyInvocationHandler implements InvocationHandler
   
6. {
   
7.             Object sub = null;
   
8.             public MyInvocationHandler(Object sub)
   
9.             {
   
10.                      this.sub = sub;
    
11.             }
    
12.             
    
13.            @Override
    
14.         public Object invoke(Object proxy, Method method, Object[] args)
    
15.         throws Throwable
    
16.         {   
    
17.                return method.invoke(sub,args);
    
18.         }
    
19. }
    

复制代码

主体接口类

1. public interface Subject
   
2. {
   
3.             public abstract int add( int a ,int b);
   
4.            
   
5. 
   
6. }
   

复制代码

实现主体接口的真实类
public class RealSubject implements Subject
{
                @Override
                public int add(int a, int b)
                {
                        return a+b;
                }
}

测试类

1. import java.lang.reflect.Constructor;
   
2. import java.lang.reflect.InvocationHandler;
   
3. import java.lang.reflect.Proxy;
   
4. 
   
5. public class DynamicTest
   
6. {
   
7.         public static void main(String[] args) throws Exception
   
8.         {
   
9.                 Subject  subject = new RealSubject();
   
10.                 InvocationHandler handler = new MyInvocationHandler(subject);
    
11.                     Class proxyClass = Proxy.getProxyClass
    
12.                                                          (Subject.class.getClassLoader(),
    
13.                                                                 subject.getClass().getInterfaces());
    
14.                     Constructor con = proxyClass.getConstructor(handler.getClass());
    
15.                     Subject subProxy = (Subject)con.newInstance(handler);
    
16.                     System.out.println(subProxy.add(12,12));            
    
17.                     
    
18. 
    
19.         }
    
20. 
    
21. }

复制代码

以上代码执行报错，可是找了半天真的找不出错误。
Exception in thread "main" java.lang.NoSuchMethodException: $Proxy0.<init>(com.Dynamic.MyInvocationHandler)
        at java.lang.Class.getConstructor0(Unknown Source)
        at java.lang.Class.getConstructor(Unknown Source)
        at com.Dynamic.DynamicTest.main(DynamicTest.java:16)

用什么工具编的代码，在这里不报错吗？   没有返回值

Yuan先生 发表于 2013-9-11 21:20
用什么工具编的代码，在这里不报错吗？   没有返回值

Eclipse ，这里是构造方法，怎么会报错？你可以试试看就知道了

兜兜转转 发表于 2013-9-11 21:25
Eclipse ，这里是构造方法，怎么会报错？你可以试试看就知道了

MyGod，真是失误，看错了

MyInvocationHandler

MyInvocationHandler  还可以自定义构造函数，构造函数不是人家已经写好的吗，我们只要覆盖覆盖他们的方法

风叶漂 发表于 2013-9-11 21:38
MyInvocationHandler  还可以自定义构造函数，构造函数不是人家已经写好的吗，我们只要覆盖覆盖他们的方法 ...

构造函数也能覆盖？

兜兜转转 发表于 2013-9-11 21:45
构造函数也能覆盖？

不是，我是说用eclipse直接都覆盖那个invoke方法。其他都不需要操作。

Constructor con = proxyClass.getConstructor(handler.getClass());这句话不能这样写，要写成
Constructor con = proxyClass.getConstructor(InvocationHandler.class)

package handler;

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

public class DynamicTest
{
        public static void main(String[] args) throws Exception
        {
                Subject subject = new RealSubject();
                InvocationHandler handler = new MyInvocationHandler(subject);
                Class<?> proxyClass = Proxy.getProxyClass(Subject.class
                                .getClassLoader(), subject.getClass().getInterfaces());
              
                //我是查java帮助文档。下面注释是帮助文档说明。
               
                /*
                 *
                 * public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException
                               返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：
              Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });
                  Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。

                 *
                 * */
  //这里的字节码类只能写成InvocationHandler的字节码类不能写成自己实现接口类的字节码
                Constructor<?> con = proxyClass.getConstructor(InvocationHandler.class);
                //这里生成对象的时候传入自己的实现类对象
                Subject subProxy = (Subject) con.newInstance(handler);
               
                //也可以以下面这种方式简写，一部完成
                 Subject subProxy1 = (Subject)Proxy.newProxyInstance(subject.getClass()
                .getClassLoader(), subject.getClass().getInterfaces(),
                new MyInvocationHandler(subject));
                System.out.println(subProxy.add(12, 12));
                System.out.println(subProxy1.add(13, 12));

        }


输出结果为 ：
24
25