深入学习jdk动态代理

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

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

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

public interface LoginService {
        void login();
    }
    public class LoginServiceImpl implements LoginService {
        @Override
        public void login() {
            System.out.println("login");
        }
    }
    public class LoginServiceProxy implements LoginService {
        private LoginService loginService;
        
    	public LoginServiceProxy() {
            loginService = new LoginServiceImpl();
        }
        @Override
        public void login() {
            beforeLogin();
            loginService.login();
            afterLogin();
        }
        private void beforeLogin() {
            System.out.println("before login");
        }
        private void afterLogin() {
            System.out.println("after login");
        }
    }
    public class Client {
        @Test
        public void test() {
            LoginService loginService = new LoginServiceImpl();
            LoginService loginServiceProxy = new LoginServiceProxy(loginService);
            loginServiceProxy.login();
        }
    }

结果输出如下：

before login
    login
    after login

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

***概念解释：***

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

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

public interface UserService {
        public String hello(String name);
    }
    public class UserServiceImpl implements UserService {
        @Override
        public String hello(String name) {
            System.out.println("hello " + name);
            return name;
        }
    }
    /**
     * 每次生成动态代理对象时，都需要指定一个实现了InvocationHandler接口的调用处理器对象作为参数
     */
    public class InvocationHandlerImpl implements InvocationHandler {
        //这个就是我们需要代理的真实对象，也就是真正执行业务逻辑的类
        private Object target;
        public InvocationHandlerImpl(Object target) {
            this.target = target;
        }
        /**
         * 该方法负责处理动态代理类上所有方法的调用
         *
         * @param proxy     最终生成的代理类实例
         * @param method    被调用的方法
         * @param args      调用上面方法时传入的参数
         * @return          method对应方法的返回值
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            startTransaction();
            //当代理对象调用真实对象的方法时，会自动跳转到代理对象关联的handler对象的invoke方法来进行调用
            Object result = method.invoke(target, args);//代理对象和方法参数
            commitTransaction();
            return result;
        }
        private void startTransaction() {
            System.out.println("开启事物");
        }
        private void commitTransaction() {
            System.out.println("提交事物");
        }
    }
    /**
     * jdk动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
     */
    public class JDKProxyTest {
    
        public static void main(String[] args) {
    
            //被代理的对象
            UserService userDao = new UserServiceImpl() ;
            //目标对象信息
            System.out.println("目标对象信息：" + userDao.getClass());
            /**
             * 生成一个InvocationHandler对象，需要传入被代理对象作为参数
             */
            InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(userDao);
    
            Class<?> clazz = userDao.getClass();
            /**
             * JDK动态代理，有两个重要的类或接口：InvocationHandler, Proxy
             * 每个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联了一个handler
             * 当我们通过代理类对象调用这个方法时，这个方法的调用都会被转发为由InvocationHandler这个接口的invoke方法来调用
             *
             * 参数说明：
             * 1，指定当前目标对象使用类加载器；2，一组目标对象实现的接口的类型；3，调用处理器生成动态代理类实例（事件处理器）
             *
             * 我们给代理对象提供了一组什么接口，那么这个代理对象就是实现这组接口，当然也可以强制转换为这组接口中的任意一个
             *
             * Proxy.newProxyInstance创建的代理对象是在jvm运行时动态生成的一个对象，命名方式都是以$开头，最后一个数字表示对象的标号
             */
            //生成动态代理对象
            UserService proxy = (UserService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), invocationHandler);
            //代理对象信息
            System.out.println("代理对象信息：" + proxy.getClass());
            String result = proxy.hello("tanhq");
            System.out.println("返回值：" + result);
            createProxyClassFile();
        }
        public static void createProxyClassFile() {
            String name = "UserServiceProxy";
            byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
            try {
                FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
                out.write(data);
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

输出结果：

目标对象信息：class com.dalingjia.proxy.jdk.UserServiceImpl
    代理对象信息：class com.sun.proxy.$Proxy0
    开启事物
    hello tanhq
    提交事物
    返回值：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方法开始。

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)  throws IllegalArgumentException{
            Objects.requireNonNull(h);
            final Class<?>[] intfs = interfaces.clone();
            final SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
            }
    		//1, 生成代理Class对象
            Class<?> cl = getProxyClass0(loader, intfs);
            try {
                if (sm != null) {
                    checkNewProxyPermission(Reflection.getCallerClass(), cl);
                }
    			//2，获取构造器
                final Constructor<?> cons = cl.getConstructor(constructorParams);
                final InvocationHandler ih = h;
                if (!Modifier.isPublic(cl.getModifiers())) {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        public Void run() {
                            cons.setAccessible(true);
                            return null;
                        }
                    });
                }
                //3，返回代理对象实例
                return cons.newInstance(new Object[]{h});
            } catch (IllegalAccessException|InstantiationException e) {
                throw new InternalError(e.toString(), e);
            } catch (InvocationTargetException e) {
                Throwable t = e.getCause();
                if (t instanceof RuntimeException) {
                    throw (RuntimeException) t;
                } else {
                    throw new InternalError(t.toString(), t);
                }
            } catch (NoSuchMethodException e) {
                throw new InternalError(e.toString(), e);
            }
        }

深入下面这行代码

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

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

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

进入get方法：

public V get(K key, P parameter) {
            Objects.requireNonNull(parameter);
            expungeStaleEntries();
            Object cacheKey = CacheKey.valueOf(key, refQueue);
          
            ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
            if (valuesMap == null) {
                ConcurrentMap<Object, Supplier<V>> oldValuesMap
                    = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
                if (oldValuesMap != null) {
                    valuesMap = oldValuesMap;
                }
            }
           
            Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
            Supplier<V> supplier = valuesMap.get(subKey);
            Factory factory = null;
    		//下面代码省略
        }

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

@Override
            public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    
               //1，上面代码省略，只看核心代码，生成代理类的包名
                String proxyPkg = null;     // package to define proxy class in
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
                for (Class<?> intf : interfaces) {
                    int flags = intf.getModifiers();
                    if (!Modifier.isPublic(flags)) {
                        accessFlags = Modifier.FINAL;
                        String name = intf.getName();
                        int n = name.lastIndexOf('.');
                        String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                        if (proxyPkg == null) {
                            proxyPkg = pkg;
                        } else if (!pkg.equals(proxyPkg)) {
                            throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                        }
                    }
                }
    
                if (proxyPkg == null) {
                    // if no non-public proxy interfaces, use com.sun.proxy package
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
                //2，生成代理类的类名，由一个原子类AtomicLong生成
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    			//3, 这里就是真正创建代理类的地方
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
                try {
                    return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    throw new IllegalArgumentException(e.toString());
                }
            }

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

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
            ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
            final byte[] var4 = var3.generateClassFile();
            if (saveGeneratedFiles) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        try {
                            int var1 = var0.lastIndexOf(46);
                            Path var2;
                            if (var1 > 0) {
                                Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                                Files.createDirectories(var3);
                                var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                            } else {
                                var2 = Paths.get(var0 + ".class");
                            }
                            Files.write(var2, var4, new OpenOption[0]);
                            return null;
                        } catch (IOException var4x) {
                            throw new InternalError("I/O exception saving generated file: " + var4x);
                        }
                    }
                });
            }
            return var4;
        }

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

public static void createProxyClassFile() {
            String name = "UserServiceProxy";
            byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
            try {
                FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
                out.write(data);
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

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

import com.dalingjia.proxy.jdk.UserService;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    public final class UserServiceProxy  extends  Proxy  implements UserService{
      private static Method m1;
      private static Method m2;
      private static Method m3;
      private static Method m0;
      public UserServiceProxy(InvocationHandler paramInvocationHandler)
      {
        super(paramInvocationHandler);
      }
      public final boolean equals(Object paramObject)
      {
        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 String toString()
      {
        try
        {
          return (String)this.h.invoke(this, m2, null);
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      public final String hello(String paramString)
      {
        try
        {
          return (String)this.h.invoke(this, m3, new Object[] { paramString });
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      public final int hashCode()
      {
        try
        {
          return ((Integer)this.h.invoke(this, m0, null)).intValue();
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
      }
      static
      {
        try
        {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          m3 = Class.forName("com.dalingjia.proxy.jdk.UserService").getMethod("hello", new Class[] { Class.forName("java.lang.String") });
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          return;
        }
        catch (NoSuchMethodException localNoSuchMethodException)
        {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException)
        {
          throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
      }
    }

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RocXR6cQ_size_16_color_FFFFFF_t_70]: /images/20220127/ca9c793485ce42558c8b135c878b46bb.png