深入学习jdk动态代理

柔光的暖阳◎ 2022-01-26 23:05 309阅读 0赞

何为代理
代理，即代替主角完成一些额外的事情，例如，经纪人作为明星的代理人和出资洽谈片酬，排期等，而正真参与拍戏的还是明星本人，明星拍完戏后，再有经纪人代理明星去清理片酬等。
Java中的代理机制就是在目标方法执行前后执行一些额外的操作，例如安全检查，记录日志等。java中的代理分为静态代理和动态代理。

  1. 静态代理
    直接上代码，模拟登陆操作：

    public interface LoginService {

    1. void login();

    }
    public class LoginServiceImpl implements LoginService {

    1. @Override
    2. public void login() {
    3.     System.out.println("login");
    4. }

    }
    public class LoginServiceProxy implements LoginService {

    1. private LoginService loginService;
    3. public LoginServiceProxy() {
    4.     loginService = new LoginServiceImpl();
    5. }
    6. @Override
    7. public void login() {
    8.     beforeLogin();
    9.     loginService.login();
    10.     afterLogin();
    11. }
    12. private void beforeLogin() {
    13.     System.out.println("before login");
    14. }
    15. private void afterLogin() {
    16.     System.out.println("after login");
    17. }

    }
    public class Client {

    1. @Test
    2. public void test() {
    3.     LoginService loginService = new LoginServiceImpl();
    4.     LoginService loginServiceProxy = new LoginServiceProxy(loginService);
    5.     loginServiceProxy.login();
    6. }

    }

结果输出如下：

  1. before login
  2. login
  3. after login

上面代理很好理解，使用聚合方式，在登陆前执行额外操作。静态代理方式可以看到具体代理类的代码，且代码由程序员编写，在编译之后会生成相应的class文件。
缺点是：如果需要对LoginService接口中有N个方法都代理，则需要在代理类中创建N个代理方法，并且需要编写重复的代理操作代码。

概念解释：

  1. 目标接口：即对目标操作的抽象，如LoginService;
  2. 目标类：即目标接口的实现类，如LoginServiceImpl;
  3. 目标对象：即目标类的实例；
  4. 代理类：即目标类的代理，如LoginServiceProxy;
  5. 代理对象：即代理类的实例。

动态代理
动态代理，即在运行时根据目标接口动态生成的代理类。动态代理方法生成的代理类在编译后不会生成实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中使用。

  1. public interface UserService {
  2.     public String hello(String name);
  3. }
  4. public class UserServiceImpl implements UserService {
  5.     @Override
  6.     public String hello(String name) {
  7.         System.out.println("hello " + name);
  8.         return name;
  9.     }
  10. }
  11. /**
  12.  * 每次生成动态代理对象时，都需要指定一个实现了InvocationHandler接口的调用处理器对象作为参数
  13.  */
  14. public class InvocationHandlerImpl implements InvocationHandler {
  15.     //这个就是我们需要代理的真实对象，也就是真正执行业务逻辑的类
  16.     private Object target;
  17.     public InvocationHandlerImpl(Object target) {
  18.         this.target = target;
  19.     }
  20.     /**
  21.      * 该方法负责处理动态代理类上所有方法的调用
  22.      *
  23.      * @param proxy     最终生成的代理类实例
  24.      * @param method    被调用的方法
  25.      * @param args      调用上面方法时传入的参数
  26.      * @return          method对应方法的返回值
  27.      * @throws Throwable
  28.      */
  29.     @Override
  30.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  31.         startTransaction();
  32.         //当代理对象调用真实对象的方法时，会自动跳转到代理对象关联的handler对象的invoke方法来进行调用
  33.         Object result = method.invoke(target, args);//代理对象和方法参数
  34.         commitTransaction();
  35.         return result;
  36.     }
  37.     private void startTransaction() {
  38.         System.out.println("开启事物");
  39.     }
  40.     private void commitTransaction() {
  41.         System.out.println("提交事物");
  42.     }
  43. }
  44. /**
  45.  * jdk动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
  46.  */
  47. public class JDKProxyTest {
  49.     public static void main(String[] args) {
  51.         //被代理的对象
  52.         UserService userDao = new UserServiceImpl() ;
  53.         //目标对象信息
  54.         System.out.println("目标对象信息：" + userDao.getClass());
  55.         /**
  56.          * 生成一个InvocationHandler对象，需要传入被代理对象作为参数
  57.          */
  58.         InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(userDao);
  60.         Class<?> clazz = userDao.getClass();
  61.         /**
  62.          * JDK动态代理，有两个重要的类或接口：InvocationHandler, Proxy
  63.          * 每个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联了一个handler
  64.          * 当我们通过代理类对象调用这个方法时，这个方法的调用都会被转发为由InvocationHandler这个接口的invoke方法来调用
  65.          *
  66.          * 参数说明：
  67.          * 1，指定当前目标对象使用类加载器；2，一组目标对象实现的接口的类型；3，调用处理器生成动态代理类实例（事件处理器）
  68.          *
  69.          * 我们给代理对象提供了一组什么接口，那么这个代理对象就是实现这组接口，当然也可以强制转换为这组接口中的任意一个
  70.          *
  71.          * Proxy.newProxyInstance创建的代理对象是在jvm运行时动态生成的一个对象，命名方式都是以$开头，最后一个数字表示对象的标号
  72.          */
  73.         //生成动态代理对象
  74.         UserService proxy = (UserService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), invocationHandler);
  75.         //代理对象信息
  76.         System.out.println("代理对象信息：" + proxy.getClass());
  77.         String result = proxy.hello("tanhq");
  78.         System.out.println("返回值：" + result);
  79.         createProxyClassFile();
  80.     }
  81.     public static void createProxyClassFile() {
  82.         String name = "UserServiceProxy";
  83.         byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
  84.         try {
  85.             FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
  86.             out.write(data);
  87.             out.close();
  88.         } catch (Exception e) {
  89.             e.printStackTrace();
  90.         }
  91.     }
  92. }

输出结果：

  1. 目标对象信息：class com.dalingjia.proxy.jdk.UserServiceImpl
  2. 代理对象信息：class com.sun.proxy.$Proxy0
  3. 开启事物
  4. hello tanhq
  5. 提交事物
  6. 返回值：tanhq

JDK动态代理方法实现代理的步骤如下：

  1. 编写目标接口；
  2. 编写目标接口的实现类，实现目标方法的具体逻辑；
  3. 编写一个代理处理器类实现InvocationHandler接口，重写invoke方法，用于指定运行时将生成的代理类需要完成的具体操作，包括startTransaction和commitTransaction。代理对象调用任何代理方法都会调用这个invoke方法；
  4. 使用Proxy.newProxyInstance静态方法创建代理对象，使用代理对象调用代理方法。

上面步骤主要涉及2个类：

  1. java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy
  2. InvocationHandler是一个接口，代理类的调用处理器，每个代理类都要实现该接口。该接口有一个invoke方法，代理对象调用任何目标对象的方法时都会调用这个invoke方法，在这个方法中进行目标类的目标方法的调用。
  3. Proxy提供静态方法用于创建动态代理类的实例，同时使用它创建的代理类的实例都是他的子类。该类主要关注这个方法public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)；
    a，loader参数用于指示使用哪个类加载器加载这个代理类；
    b，interfaces表示代理类实现的接口列表；
    c，h表示使用哪个调用处理器

代理类解密
对于JDK动态代理，生成的代理类是什么样的？为什么调用代理类的任何方法时都一定会调用invoke方法？
动态代理是在运行时动态生成字节码，编译期看不到相应的class文件，所以不能直观的看到代理内容。先从newProxyInstance方法开始。

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                           Class<?>[] interfaces,
  3.                                           InvocationHandler h)  throws IllegalArgumentException{
  4.         Objects.requireNonNull(h);
  5.         final Class<?>[] intfs = interfaces.clone();
  6.         final SecurityManager sm = System.getSecurityManager();
  7.         if (sm != null) {
  8.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  9.         }
  10.         //1, 生成代理Class对象
  11.         Class<?> cl = getProxyClass0(loader, intfs);
  12.         try {
  13.             if (sm != null) {
  14.                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
  15.             }
  16.             //2，获取构造器
  17.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  18.             final InvocationHandler ih = h;
  19.             if (!Modifier.isPublic(cl.getModifiers())) {
  20.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
  21.                     public Void run() {
  22.                         cons.setAccessible(true);
  23.                         return null;
  24.                     }
  25.                 });
  26.             }
  27.             //3，返回代理对象实例
  28.             return cons.newInstance(new Object[]{h});
  29.         } catch (IllegalAccessException|InstantiationException e) {
  30.             throw new InternalError(e.toString(), e);
  31.         } catch (InvocationTargetException e) {
  32.             Throwable t = e.getCause();
  33.             if (t instanceof RuntimeException) {
  34.                 throw (RuntimeException) t;
  35.             } else {
  36.                 throw new InternalError(t.toString(), t);
  37.             }
  38.         } catch (NoSuchMethodException e) {
  39.             throw new InternalError(e.toString(), e);
  40.         }
  41.     }

深入下面这行代码

  1. Class<?> cl = getProxyClass0(loader, intfs);

我们看到如下代码：继续深入

  1. private static Class<?> getProxyClass0(ClassLoader loader,
  2.                                            Class<?>... interfaces) {
  3.         if (interfaces.length > 65535) {
  4.             throw new IllegalArgumentException("interface limit exceeded");
  5.         }
  6.         return proxyClassCache.get(loader, interfaces);
  7.     }

进入get方法：

  1. public V get(K key, P parameter) {
  2.         Objects.requireNonNull(parameter);
  3.         expungeStaleEntries();
  4.         Object cacheKey = CacheKey.valueOf(key, refQueue);
  6.         ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
  7.         if (valuesMap == null) {
  8.             ConcurrentMap<Object, Supplier<V>> oldValuesMap
  9.                 = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
  10.             if (oldValuesMap != null) {
  11.                 valuesMap = oldValuesMap;
  12.             }
  13.         }
  15.         Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
  16.         Supplier<V> supplier = valuesMap.get(subKey);
  17.         Factory factory = null;
  18.         //下面代码省略
  19.     }

主要看subKeyFactory.apply(key, parameter) ，继续深入
在这里插入图片描述
看到的接口的抽象方法，我们看他的实现类ProxyClassFactory的apply方法
我们会看到生成代理类的包名，以及类名

  1. @Override
  2.         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  4.            //1，上面代码省略，只看核心代码，生成代理类的包名
  5.             String proxyPkg = null;     // package to define proxy class in
  6.             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
  7.             for (Class<?> intf : interfaces) {
  8.                 int flags = intf.getModifiers();
  9.                 if (!Modifier.isPublic(flags)) {
  10.                     accessFlags = Modifier.FINAL;
  11.                     String name = intf.getName();
  12.                     int n = name.lastIndexOf('.');
  13.                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  14.                     if (proxyPkg == null) {
  15.                         proxyPkg = pkg;
  16.                     } else if (!pkg.equals(proxyPkg)) {
  17.                         throw new IllegalArgumentException(
  18.                             "non-public interfaces from different packages");
  19.                     }
  20.                 }
  21.             }
  23.             if (proxyPkg == null) {
  24.                 // if no non-public proxy interfaces, use com.sun.proxy package
  25.                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  26.             }
  27.             //2，生成代理类的类名，由一个原子类AtomicLong生成
  28.             long num = nextUniqueNumber.getAndIncrement();
  29.             String proxyName = proxyPkg + proxyClassNamePrefix + num;
  30.             //3, 这里就是真正创建代理类的地方
  31.             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
  32.             try {
  33.                 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
  34.             } catch (ClassFormatError e) {
  35.                 throw new IllegalArgumentException(e.toString());
  36.             }
  37.         }

继续分析代码，进入generateProxyClass方法

  1. public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
  2.         ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
  3.         final byte[] var4 = var3.generateClassFile();
  4.         if (saveGeneratedFiles) {
  5.             AccessController.doPrivileged(new PrivilegedAction<Void>() {
  6.                 public Void run() {
  7.                     try {
  8.                         int var1 = var0.lastIndexOf(46);
  9.                         Path var2;
  10.                         if (var1 > 0) {
  11.                             Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
  12.                             Files.createDirectories(var3);
  13.                             var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
  14.                         } else {
  15.                             var2 = Paths.get(var0 + ".class");
  16.                         }
  17.                         Files.write(var2, var4, new OpenOption[0]);
  18.                         return null;
  19.                     } catch (IOException var4x) {
  20.                         throw new InternalError("I/O exception saving generated file: " + var4x);
  21.                     }
  22.                 }
  23.             });
  24.         }
  25.         return var4;
  26.     }

我们可以很直白的看到，生成的代理类的字节码文件被输出到了某个目录下，这个字节码文件很难找到，但是我们可以重用generateProxyClass方法，再外面调用generateProxyClass方法，把生成的字节码文件输出到指定位置。也就是上面一开始写的createProxyClassFile();

  1. public static void createProxyClassFile() {
  2.         String name = "UserServiceProxy";
  3.         byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
  4.         try {
  5.             FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
  6.             out.write(data);
  7.             out.close();
  8.         } catch (Exception e) {
  9.             e.printStackTrace();
  10.         }
  11.     }

我们把字节码文件输出到我的/Users/tanhq/test/目录下，找到它，然后用反编译工具JD-GUI打开。下面是我反编译后的字节码文件

  1. import com.dalingjia.proxy.jdk.UserService;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. import java.lang.reflect.UndeclaredThrowableException;
  6. public final class UserServiceProxy  extends  Proxy  implements UserService{
  7.   private static Method m1;
  8.   private static Method m2;
  9.   private static Method m3;
  10.   private static Method m0;
  11.   public UserServiceProxy(InvocationHandler paramInvocationHandler)
  12.   {
  13.     super(paramInvocationHandler);
  14.   }
  15.   public final boolean equals(Object paramObject)
  16.   {
  17.     try
  18.     {
  19.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
  20.     }
  21.     catch (Error|RuntimeException localError)
  22.     {
  23.       throw localError;
  24.     }
  25.     catch (Throwable localThrowable)
  26.     {
  27.       throw new UndeclaredThrowableException(localThrowable);
  28.     }
  29.   }
  30.   public final String toString()
  31.   {
  32.     try
  33.     {
  34.       return (String)this.h.invoke(this, m2, null);
  35.     }
  36.     catch (Error|RuntimeException localError)
  37.     {
  38.       throw localError;
  39.     }
  40.     catch (Throwable localThrowable)
  41.     {
  42.       throw new UndeclaredThrowableException(localThrowable);
  43.     }
  44.   }
  45.   public final String hello(String paramString)
  46.   {
  47.     try
  48.     {
  49.       return (String)this.h.invoke(this, m3, new Object[] { paramString });
  50.     }
  51.     catch (Error|RuntimeException localError)
  52.     {
  53.       throw localError;
  54.     }
  55.     catch (Throwable localThrowable)
  56.     {
  57.       throw new UndeclaredThrowableException(localThrowable);
  58.     }
  59.   }
  60.   public final int hashCode()
  61.   {
  62.     try
  63.     {
  64.       return ((Integer)this.h.invoke(this, m0, null)).intValue();
  65.     }
  66.     catch (Error|RuntimeException localError)
  67.     {
  68.       throw localError;
  69.     }
  70.     catch (Throwable localThrowable)
  71.     {
  72.       throw new UndeclaredThrowableException(localThrowable);
  73.     }
  74.   }
  75.   static
  76.   {
  77.     try
  78.     {
  79.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
  80.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
  81.       m3 = Class.forName("com.dalingjia.proxy.jdk.UserService").getMethod("hello", new Class[] { Class.forName("java.lang.String") });
  82.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
  83.       return;
  84.     }
  85.     catch (NoSuchMethodException localNoSuchMethodException)
  86.     {
  87.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
  88.     }
  89.     catch (ClassNotFoundException localClassNotFoundException)
  90.     {
  91.       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  92.     }
  93.   }
  94. }

从上面的代码我们可以很明显的发现在调用hello方法时调用了invoke方法，很明白的解释了为什么调用目标方法时一定会调用invoke方法。

发表评论

表情：
评论列表 （有 0 条评论，309人围观）

还没有评论，来说两句吧...

相关阅读

    相关 代理-jdk动态代理

    1、基于接口的实现，要jdk动态代理的类必须要实现一个接口； 2、中介类：实现了InvocationHandler，并重写这个接口的 方法（public Object inv

    男娘i男娘i/ 0 赞/ 209 阅读

    相关 深入理解JDK动态代理机制

    一、现实生活中的代理？         在现实生活中，我们常见的有服务器代理商、联想PC代理商、百事可乐、火车票、机票等代理商，为什么会有这些个代理商呢？设想以买火车票为

    蔚落蔚落/ 0 赞/ 376 阅读

    相关 深入学习jdk动态代理

    何为代理 代理，即代替主角完成一些额外的事情，例如，经纪人作为明星的代理人和出资洽谈片酬，排期等，而正真参与拍戏的还是明星本人，明星拍完戏后，再有经纪人代理明星去清理片酬等

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 310 阅读