动态代理

最新推荐文章于 2025-03-19 08:00:00 发布

转载最新推荐文章于 2025-03-19 08:00:00 发布 · 140 阅读

本文深入解析Java中的代理模式，包括静态代理和动态代理的概念、实现方式及其应用场景。通过实例讲解如何利用反射机制创建动态代理，以及JDK动态代理的工作原理。

理解java的代理模式

刘德华会唱歌，跳舞（唱歌，跳舞是个接口，刘德华实现了这个接口，怎么唱，怎么跳），但找刘德华，你必须去找他的代理人，作为刘德华的代理人，代理人也必须会唱歌，跳舞（代理人也要实现这个接口），这样很多事就不用刘德华去做，而是交给代理人去做了。

反射1.java机制
理解代理模式的前提的英文先理解的java中的反射机制，先看一个例子：

JDBC加载驱动时，Class.forName（“com.mysql.jdbc.Driver”）;此时
通过反射加载连接mysql数据库的jar包，该句等价于import com.mysql.jdbc.Driver;
可是为什么不直接导入呢？这就是反射设计的合理之处了。
<1>，用反射可以在运行时动态导入，直接导入是在编译时就确定com.mysql.jdbc.Driver包必须存在，否则编译不过，这样看来，加上反射，可执行的范围增大了。
<2>，提高复用率，加上反射，Class.forName（“从配置文件读取具体的包内容”），这样，当你换数据库时，只需更改配置文件，而不用像导入的方式那样挨个更换你的导入
.java反射就是在运行时动态获取类的信息，方法，构造方法等信息。可以加载一个在运行时才确定其名称信息的类，并确定该类的基本信息。

2.由反射引出的设计模式-模式代理
代理模式概念理解：我自己能做的事情，让别人代替我来做，例如，我点了份菜，可以自己下楼去拿，但我现在比较忙，就让外卖小哥帮忙送上来，这块，外卖小哥就充当一个中间人的角色，帮我把事情做了。

3.代理静态模式
代理类由程序员自己实现的就是再定义一个实现被代理类所实现的接口的代理类。
具体：

public interface People {
    public void execute();

}

public class My implements People {

    @Override
    public void execute() {
         System.out.println("拿外卖");

    }

}

public class WaiMaiXiaoGe implements People {

    public My my;
    public WaiMaiXiaoGe(My my){
        this.my=my;
    }
    @Override
    public void execute() {
        System.out.println("打包外卖");
        my.execute();
        System.out.println("送外卖结束");

    }

}

4.动态代理模式
概念：在运行的过程中运用反射动态创建代理类。
<1> JDK动态代理
01具体过程：
1。定义一个事件管理器类实现invocationHandle接口，并重写invoke（代理类，被代理的方法，方法的参数列表）方法
。2 .实现被代理类及其实现的接口，
3。调用Proxy.newProxyInstance（类加载器，类实现的接口，事务处理器对象）;生成一个代理实例。
4，通过该代理实例调用方法.02
代码实现：

public interface People {
    public void execute();

}

package com.Dream.Design;

/**
 * @author wangpei
 * @version 创建时间：2017年4月22日 下午4:20:23 类说明
 */
public class My implements People {

    @Override
    public void execute() {
        System.out.println("拿外卖");
    }

}

package com.Dream.Design;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author wangpei
 * @version 创建时间：2017年4月22日 下午5:31:23 类说明
 */
public class Handler implements InvocationHandler {
    private Object o = null;

    public Handler(Object o) {
        this.o = o;

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("外卖小哥取外卖");
        method.invoke(o, args);
        System.out.println("送外卖完成");
        return null;
    }

}

package com.Dream.Design;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author wangpei
 * @version 创建时间：2017年4月22日 下午5:31:23 类说明
 */
public class Handler implements InvocationHandler {
    private Object o = null;

    public Handler(Object o) {
        this.o = o;

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("外卖小哥取外卖");
        method.invoke(o, args);
        System.out.println("送外卖完成");
        return null;
    }

}

结果：

外卖小哥取外卖
拿外卖
送外卖完成

动态代理：

(5)动态代理

我们先直接上动态代理的代码，之后再分析代码的行为，上面的Person接口和Student被代理类保持不变。

/**
 * 动态代理,动态代理类不要显示的实现被代理类所实现的接口
 * @author yujie.wang
 *
 */
public class MyInvocationHandler implements InvocationHandler{
    
    private Object object;
    
    public MyInvocationHandler(Object object){
        this.object = object;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("MyInvocationHandler invoke begin");
        System.out.println("proxy: "+ proxy.getClass().getName());
        System.out.println("method: "+ method.getName());
        for(Object o : args){
            System.out.println("arg: "+ o);
        }
        //通过反射调用 被代理类的方法
        method.invoke(object, args);
        System.out.println("MyInvocationHandler invoke end");
        return null;
    }
    
    public static void main(String [] args){
        //创建需要被代理的类
        Student s = new Student();
        //这一句是生成代理类的class文件，前提是你需要在工程根目录下创建com/sun/proxy目录，不然会报找不到路径的io异常
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        //获得加载被代理类的 类加载器
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //指明被代理类实现的接口
        Class<?>[] interfaces = s.getClass().getInterfaces();
        // 创建被代理类的委托类,之后想要调用被代理类的方法时，都会委托给这个类的invoke(Object proxy, Method method, Object[] args)方法
        MyInvocationHandler h = new MyInvocationHandler(s);
        //生成代理类
        Person proxy = (Person)Proxy.newProxyInstance(loader, interfaces, h);
        //通过代理类调用 被代理类的方法
        proxy.sayHello("yujie.wang", 20);
        proxy.sayGoodBye(true, 100);
        System.out.println("end");
    }
 
}

运行测试代码输出如下结果：

MyInvocationHandler invoke begin
proxy: com.sun.proxy.$Proxy0
method: sayHello
arg: yujie.wang
arg: 20
student say helloyujie.wang 20
MyInvocationHandler invoke end
MyInvocationHandler invoke begin
proxy: com.sun.proxy.$Proxy0
method: sayGoodBye
arg: true
arg: 100.0
student sayGoodBye 100.0 true
MyInvocationHandler invoke end
end

仔细分析上面的动态代理实现代码，我们看到这里涉及到java反射包下的一个接口InvocationHandler和一个类Proxy。

package java.lang.reflect;
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable;
}
这个接口只有一个invoke方法，我们在通过代理类调用被代理类的方法时，最终都会委托给这个invoke方法执行，
       //通过代理类调用被代理类的方法
       proxy.sayHello("yujie.wang", 20);
       proxy.sayGoodBye(true, 100);

所以我们就可以在这个invoke方法中对被代理类进行增强或做一些其他操作。
Proxy类的public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法内部通过拼接字节码的方式来创建代理类，后面我会反编译出它所创建的代理类看看内容。

我们看这个方法的三个参数：

ClassLoader loader：指定一个动态加载代理类的类加载器

Class<?>[] interfaces：指明被代理类实现的接口，之后我们通过拼接字节码生成的类才能知道调用哪些方法。

InvocationHandler h：这是一个方法委托类，我们通过代理调用被代理类的方法时，就可以将方法名和方法参数都委托给这个委托类。

你看我们现在有了类加载器、类实现的接口、要调用方法的方法名和参数，那么我们就可以做很多事情了。

(6)反编译Proxy.newProxyInstance所创建的代理类

//这一句是生成代理类的class文件，前提是你需要在工程根目录下创建com/sun/proxy目录，不然会报找不到路径的io异常
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

我们在代码中加入上述代码，代码就会保存生成的代理类，名称为$Proxy0.class

通过jd-gui反编译代码如下，其中注释是我加上去的：


package com.sun.proxy;
 
import com.yujie.proxy.dynamic.Person;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
/**
*代理类也实现了Person接口，看起来和静态代理的方式也会一样的 
*同时代理类也继承了Proxy类
*/ 
public final class $Proxy0 extends Proxy implements Person{
  private static Method m4;
  private static Method m1;
  private static Method m0;
  private static Method m3;
  private static Method m2;
  
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
   //实现了Person接口的方法，这就是我们调用这个方法Proxy.newProxyInstance必须提供第二个参数的作用 
  public final void sayGoodBye(boolean paramBoolean, double paramDouble)
    throws 
  {
    try
    {
    // 我们看到通过调用代理类的方法时，最终方法都会委托给InvocationHandler实现类的invoke方法
    // m4为代理类通过反射获得的Method
      this.h.invoke(this, m4, new Object[] { Boolean.valueOf(paramBoolean), Double.valueOf(paramDouble) });
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  //实现了Person接口的方法，这就是我们调用这个方法Proxy.newProxyInstance必须提供第二个参数的作用 
  public final void sayHello(String paramString, int paramInt)
    throws 
  {
    try
    {
      // 我们看到通过调用代理类的方法时，最终方法都会委托给InvocationHandler实现类的invoke方法
      // m4为代理类通过反射获得的Method
      this.h.invoke(this, m3, new Object[] { paramString, Integer.valueOf(paramInt) });
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  static
  {
    try
    {//代理类通过反射 获得的接口方法Method
      m4 = Class.forName("com.yujie.proxy.dynamic.Person").getMethod("sayGoodBye", new Class[] { Boolean.TYPE, Double.TYPE });
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      //代理类通过反射 获得的接口方法Method
      m3 = Class.forName("com.yujie.proxy.dynamic.Person").getMethod("sayHello", new Class[] { Class.forName("java.lang.String"), Integer.TYPE });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

总结一下：
jdk的代理让我们在不直接访问某些对象的情况下，通过代理机制也可以访问被代理对象的方法，这种技术可以应用在很多地方比如RPC框架，Spring AOP机制，但是我们看到jdk的代理机制必须要求被代理类实现某个方法，这样在生成代理类的时候才能知道重新那些方法。这样一个没有实现任何接口的类就无法通过jdk的代理机制进行代理，当然解决方法是使用cglib的代理机制进行代理。