代理模式-JDK动态代理-蒲公英云

对比静态代理

静态代理：是指在程序运行前就已经定义好了目标类的代理类。代理类与目标类的代理关系在程序运行之前就确立了。

动态代理：是指程序在整个运行过程中根本就不存在目标类的代理类，目标对象的代理对象只是代理生成工具（如代理工厂类）在程序运行时由JVM根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。

概念

动态代理类类似与普通当事人与聘请的律师间的关系。律师是在“官司”发生后，才由当事人聘请的。即代理关系是在“官司”发生后才确立的。

动态代理的实现方式常用的有两种：使用JDK的Proxy，与通过CGLIB生产代理。

分析

①通过JDK的java.lang.relect.Proxy类实现动态代理，会使用其静态方法newProxyInstance(),依据目标对象、业务接口及增强逻辑三者，自动生成一个动态代理对象。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
loader:目标类的类加载器，通过目标对象的反射可获取
interfaces:目标类实现的接口数组，通过目标对象的反射可获取
handler:业务增强逻辑，需要再定义
InvocationHandler 是个接口，其具体介绍如下：实现了InvocationHandler 接口的类用于加强目标类的主业务逻辑。这个接口中有一个方法invoke()，具体加强的代理逻辑就是定义在该方法中的。程序调用主业务逻辑时，会自动调用invoke()方法。

②invoke()方法的介绍如下：

public Object invoke(Object proxy, Method method, Object[] args)
proxy:代表生成的代理对象
method:代表目标方法
args:代表目标方法的参数
由于该方法是由代理对象自动调用的，所以这三个参数的值不用开发人员给出。

③第二个参数为Method类对象，该类有一个方法也叫invoke()，可以调用目标类目标的方法。这两个invoke()方法，虽然同名，但无关。

public Object invoke(Object obj, Object... args)
obj:表示目标对象
args:表示目标方法参数，就是其上一层invoke方法的第三个参数
该方法的作用是：调用执行obj对象所属类的方法，这个方法由其调用者Method对象确定。
在代码中，一般写法为method.invoke(target, args);
其中，method为上一层invoke方法的第二个参数。这样，即可调用了目标类的目标方法。

大家单看分析还不够清晰，下面看一下代理实现与解析

（1）定义业务接口GameService，其中含有抽象方法gameStart()

public interface GameService {
    //主业务逻辑
    void gameStart();
}

（2）定义目标类GameServiceImpl，该类实现了业务接口。在对接口方法的实现上，只实现主业务逻辑。这个方法称为目标方法。

public class GameServiceImpl implements GameService {
    /**
     * 目标方法
     */
    @Override
    public void gameStart() {
        System.out.println("这里调用Dao层等，完成gameStart()");
    }
}

（3）定义主业务增强逻辑类JdkDynamic，该类需实现接口InvocationHandler。在该类中定义一个Object类型的成员变量，还要定义一个带参的构造器，这个参数为Object对象。目的是，将目标对象引入该类，以便通过反射调用目标方法。

当然，也可以将这个属性定义为GameService接口类型，但最好不要这样做，最好将其定义为Object。因为，这样这个主业务增强逻辑可以使用于本项目中的任何类型的目标类，而不仅仅拘泥于一个类。

/*
 * 定义代理类，与目标类实现相同的业务接口，增强逻辑
 */
public class JdkDynamic implements InvocationHandler {
    //声明业务接口对象
    private Object target;
    public JdkDynamic(){}
    public JdkDynamic(Object target){
        this.target = target;
    }
    /* 代理方法，实现对目标方法的功能增强 */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 增加主业务逻辑代码
        System.out.println("对用户进行身份验证");
        // 无论主业务方法有无参数，有无返回值，下面的方法均可兼顾到
        return method.invoke(target, args);
    }
}

（4）定义客户类Client。客户类中主要语句有三句：

A、定义目标对象。在生成代理对象时会需要目标对象对其初始化。

B、定义代理对象。需要注意的是，代理类Proxy会通过反射机制，自动实现GameService接口。代理对象需要使用目标对象对其进行初始化。

C、代理对象调用主业务方法。

public static void main(String[] args) throws IOException {
        //定义目标对象
        GameService target = new GameServiceImpl();
        //创建代理对象，并使用目标对象初始化它
        GameService service = (GameService) Proxy.newProxyInstance(
        target.getClass().getClassLoader(), // 获取目标对象的类加载器
        target.getClass().getInterfaces(), // 获取目标类失效的所有接口
        new JdkDynamic(target)); // 增强业务逻辑
        //此时执行的内容，就是对目标对象增加过的内容
        service.gameStart();
        //将JDK动态代理生成的代理类，通过流的形式保存到磁盘中
        System.out.println(service.getClass()); // class com.sun.proxy.$Proxy0
        /**
         * 上面生成的代理对象字节码 com.sun.proxy.$Proxy0 是在内存中的
         * 这里将其对象写到文件中，通过反编译查看
         */
        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{GameService.class});
        FileOutputStream fos = new FileOutputStream("D://code/$Proxy0.class");
fos.write(bytes);
fos.flush();
        System.out.println("文件写入成功");
    }

（5）将JDK动态生成的代理类，通过流的形式保存到磁盘中，使用反编译工具查看：

import com.proxyDemo.jdkProxy.service.GameService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy
  implements GameService
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;
  public $Proxy0(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)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final void gameStart()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("com.proxyDemo.jdkProxy.service.GameService").getMethod("gameStart", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      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动态生成的代理类

1.生成的代理类继承Proxy类并实现业务接口，并生成了被代理类的全部方法，包括toString、equals等等所有方法
2.Java是单继承的，代理类实现了【需要被代理类的实现接口】以供我们可以将其强转；
3.这里生成的代理类继承自Proxy，在Proxy中有这么一段代码：protected InvocationHandler h;
这是在生成代理类的时候传入的InvocationHandler的实现，【开发的代理增强代码（实现InvocationHandler重写invoke()方法）】都写在invoke()方法中，最终代理类执行代理也是通过调用父类Proxy中的InvocationHandler接口的invoke()方法;
在调用【被代理】方法时，代理类通过调用生成的同名方法然后调用super.h.invoke()方法，最终就到了我们实现InvocationHandler时所写的invoke()增强方法；在此时，method.invoke()才真正通过反射调用了我们自身所写的方法