Java动态代理

最新推荐文章于 2024-09-15 19:46:31 发布

草捏子

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量251

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/u014591781/article/details/78415062

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java动态代理

引言

最近在看AOP代码，其中利用到了Java动态代理机制来实现AOP织入。所以好好地把Java动态代理学习了一遍。其中重点感谢《Java动态代理机制分析及扩展》这篇博文。受益匪浅，比《Thinking in Java》讲的还要详细。本文在原文的基础上增加了些其他参考资料的内容和自己的测试Demo及理解。

代理模式

首先，先来理解下什么是代理模式。

代理模式：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。

代理模式包含如下角色：

Subject：抽象主题角色
Proxy：代理主题角色
RealSubject：真实主题角色

代理模式类图

Client将不直接调用RealSubject。而是通过Proxy作为中间人。Proxy可在调用RealSubject的request()方法前后加上一些处理。例如写日志等。

//: typeinfo/SimpleProxyDemo.java
import static net.mindview.util.Print.*;

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);
  }
}   

class SimpleProxy implements Interface {
  private Interface proxied;
  public SimpleProxy(Interface proxied) {
    this.proxied = proxied;
  }
  public void doSomething() {
    print("SimpleProxy doSomething");
    proxied.doSomething();
  }
  public void somethingElse(String arg) {
    print("SimpleProxy somethingElse " + arg);
    proxied.somethingElse(arg);
  }
}   

class SimpleProxyDemo {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    consumer(new RealObject());
    consumer(new SimpleProxy(new RealObject()));
  }
} /* Output:
doSomething
somethingElse bonobo
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse bonobo
somethingElse bonobo
*///:~

Java的动态代理比代理的思想更向前迈进一步。因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理上，它的工作是揭示调用的类型并确定相应的对策。

下面是利用动态代理改写后的。其中看不懂的类和接口，在下一部分会进行解释。

//: typeinfo/SimpleDynamicProxy.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);
  }
}   

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);
  }
} /* Output: (95% match)    
doSomething
somethingElse bonobo
**** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null
doSomething
**** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@42e816
  bonobo
somethingElse bonobo
*///:~

代理机制

四个步骤：

通过实现 InvocationHandler 接口创建自己的调用处理器；
通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); 

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 

// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 

// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

还有更为简便的方法，Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下：

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..); 

// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
     new Class[] { Interface.class }, 
     handler );

下面了解一下，动态生成的代理类的特点：

包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象（进行了缓存），而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。
类继承关系：该类的继承关系如图：

动态代理类的继承图

由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。

下面了解一下动态代理类实例的一些特点。

每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。

多代理接口中方法重复：当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。

public interface InterfaceA {
    void doSomething();
    void doA();
}

public interface InterfaceB {
    void doSomething();
    void doB();
}

public class RealObject implements InterfaceA, InterfaceB {
    public void doSomething() {}
    public void doA() {}
    public void doB() {}
}

public class InvocationHandlerImpl implements InvocationHandler{
    private Object proxied;
    public InvocationHandlerImpl(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 main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, InterruptedException {

        RealObject object = new RealObject();

        InvocationHandler handler = new InvocationHandlerImpl(object);

        Class clazz = Proxy.getProxyClass(
                RealObject.class.getClassLoader(),
                new Class[] {InterfaceB.class, InterfaceA.class});

        Constructor constructor = clazz.getConstructor(
                new Class[] {InvocationHandler.class});

        InterfaceA proxy = (InterfaceA) constructor.newInstance(new Object[] {handler});

        proxy.doSomething();
    }
} /* Output:
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceB.doSomething(), args: null
*/

虽然代理类实例 proxy 正以接口 InterfaceA 的形式被外部引用。但获取的方法对象是在 getProxyClass 方法排前面的 InterfaceB 中的。

再谈多代理：之前一直不理解为什么会有多代理的存在，一个代理类实例只能以一种接口形式被调用。后来明白，所谓的多代理是针对代理类而言的，代理类的实例可以有多种接口形式的选择。如下：

public class SimpleDynamicProxy {
    public static void consumer(InterfaceB iface) {
        iface.doSomething();
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, InterruptedException {

        RealObject object = new RealObject();

        InvocationHandler handler = new InvocationHandlerImpl(object);

        Class clazz = Proxy.getProxyClass(
                RealObject.class.getClassLoader(),
                new Class[] {InterfaceA.class, InterfaceB.class});

        Constructor constructor = clazz.getConstructor(
                new Class[] {InvocationHandler.class});

        InterfaceA proxy_a = (InterfaceA) constructor.newInstance(new Object[] {handler});
        InterfaceB proxy_b = (InterfaceB) constructor.newInstance(new Object[] {handler});

        proxy_a.doSomething();
        proxy_a.doA();
        proxy_b.doSomething();
        proxy_b.doB();
    }
} /*Output:
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doSomething(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doA(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doSomething(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceB.doB(), args: null
*/