java反射机制与动态代理

最新推荐文章于 2025-02-18 23:00:00 发布

原创最新推荐文章于 2025-02-18 23:00:00 发布 · 109 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java #JVM #SUN #F# #工作

本文介绍了Java反射机制的基础，包括Class类与相关API的使用，以及如何利用反射机制实现动态代理。通过具体代码示例展示了动态代理的工作原理，并探讨了其在实际应用中的价值。

java反射机制与动态代理

1 java反射机制：运行时的类信息

Class类与java.lang.reflect类库一起对反射概念进行了支持，该类库包含了Field，Method以及Constructor类。这些类型的对象是由JVM在运行时创建的，用以表示未知类里对应的成员。这样就可以使用Constructor创建新的对象，用get（）与set（）方法读取与修改与Field对象相关的字段，用invoke（）方法调用与Method对象相关的方法等等。

2 动态代理：

代理模式：为了提供额外的或不同的操作，而插入的用来代替“实际”对象。这些操作通常涉及与“实际”对象的通讯，因此代理通常充当着中间人的角色。

动态代理：所有的调用都会被重定向到单一的调用处理器上，他的工作是揭示调用的类型并确定相应的对策。

java反射机制实现动态代理的源码：

   Java代码 
  
interface Interface {  
  void doSomething();  
  void somethingElse(String arg);  
}  
  
class RealObject implements Interface {  
  public void doSomething() { print("doSomething"); }  
  public void somethingElse(String arg) {  
    print("somethingElse " + arg);  
  }  
}  

   Java代码 
  
import java.lang.reflect.*;  
  
class DynamicProxyHandler implements InvocationHandler {  
    private Object proxied;  
  
    public DynamicProxyHandler(Object proxied) {  
        this.proxied = proxied;  
    }  
  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        System.out.println("**** proxy: " + proxy.getClass() + ", method: "  
                + method + ", args: " + args);  
        if (args != null)  
            for (Object arg : args)  
                System.out.println("  " + arg);  
        return method.invoke(proxied, args);  
    }  
}  
  
public class SimpleDynamicProxy {  
    public static void consumer(Interface iface) {  
        iface.doSomething();  
        iface.somethingElse("bonobo");  
    }  
  
    public static void main(String[] args) {  
        RealObject real = new RealObject();  
        consumer(real);  
        // Insert a proxy and call again:  
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class  
                .getClassLoader(), new Class[] { Interface.class },  
                new DynamicProxyHandler(real));  
        consumer(proxy);  
    }  
}  

当我们查看java.lang.reflect.Proxy源码，我们发现起核心作用的是ProxyGenerator.generateProxyClass(String paramString, Class[] paramArrayOfClass)，最令人疑惑的问题是，代理对象和如何调用DynamicProxyHandler的invoke方法的，从源码里面我们很难发现如何处理的，对于ProxyGenerator写了一个测试类ProxyClassFile

   Java代码 
  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
import sun.misc.ProxyGenerator;  
  
public class ProxyClassFile {  
  
    public static void main(String[] args) {  
  
        String proxyName = "SimpleDynamicProxy";  
  
        RealObject t = new RealObject();  
  
        Class[] interfaces = t.getClass().getInterfaces();  
  
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
  
        proxyName, interfaces);  
  
        File f = new File("E:/workspace/TIJ4/bin/typeinfo/SimpleDynamicProxy.class");  
  
        try {  
  
            FileOutputStream fos = new FileOutputStream(f);  
  
            fos.write(proxyClassFile);  
  
            fos.flush();  
  
            fos.close();  
  
        } catch (FileNotFoundException e) {  
  
            e.printStackTrace(); // To change body of catch statement use File |  
                                    // Settings | File Templates.  
  
        } catch (IOException e) {  
  
            e.printStackTrace(); // To change body of catch statement use File |  
                                    // Settings | File Templates.  
  
        }  
  
    }  
  
}

反编译SimpleDynamicProxy.class，代码初看起来有点复杂，仔细观察还是很有规律的，将SimpleDynamicProxy5个方法都重定向到invoke（）方法，equals（），hashCode（）和toString（）都是父类Object方法，doSomething（）和somethingElse（）为接口方法。

   Java代码 
  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import java.lang.reflect.UndeclaredThrowableException;  
import typeinfo.Interface;  
  
public final class SimpleDynamicProxy extends Proxy  
  implements Interface  
{  
  private static Method m1;  
  private static Method m0;  
  private static Method m3;  
  private static Method m4;  
  private static Method m2;  
  
  public SimpleDynamicProxy(InvocationHandler paramInvocationHandler)  
    throws   
  {  
    super(paramInvocationHandler);  
  }  
  
  public final boolean equals(Object paramObject)  
    throws   
  {  
    try  
    {  
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  
    }  
    catch (RuntimeException localRuntimeException)  
    {  
      throw localRuntimeException;  
    }  
    catch (Throwable localThrowable)  