Spring动态代理之JDK

谁践踏了优雅 2023-06-04 07:54 5阅读 0赞

## 什么是JDK动态代理？ ##

jdk动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。

1.  定义一个需要动态代理的接口：

/**
     1. 需要动态代理的接口
     */
    public interface UserService {
        public String hello(String name);
    }

1.  定义一个需要被代理的类，实现该接口

/**
     1. 被代理的类
     */
    public class UserServiceImpl implements UserService {
        @Override
        public String hello(String name) {
            System.out.println("hello " + name);
            return name;
        }
    }

1.  每次生成动态代理对象时，都需要指定一个实现了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("提交事物");
        }
    }

1.  定义一个测试类进行测试

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);
            //生成代理类的class文件
            createProxyClassFile();
        }
    
        /**
         * 生成代理类的class文件
         */
        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文件，然后反编译，代码如下：

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

我们看上面代码第57行，当代理对象调用真实对象的hello()方法时，会自动跳转到代理对象关联的handler对象的invoke方法来进行调用。