Java代理初探

川长思鸟来 2022-11-15 15:50 131阅读 0赞

在日常的开发中，需求的变动是很正常的，而且也是经常发生的，比如在我们的开发中有如下一个接口

public interface UserService {
        User query(User user);
        void save(User user);
    }

有如下的实现类，最开始的实现是这样的。

public class UserServiceImpl implements UserService {
        @Override
        public User query(User user) {
            System.out.println("查询用户成功:" + user.getName());
            return user;
        }
        @Override
        public void save(User user) {
            System.out.println("保存用户成功：" + user.getName());
        }
    }

如果某一天，需求发生变化了，需要在每一个方法执行前都加上 验证权限 和在每一个方法 执行完成后 都添加上 操作日志 的业务逻辑，那你说很简单呀，直接像下面一样改动就好了。

public class UserServiceImpl implements UserService {
        @Override
        public User query(User user) {
            System.out.println("验证权限！");
            System.out.println("查询用户成功:" + user.getName());
            System.out.println("记录操作日志！");
            return user;
        }
        @Override
        public void save(User user) {
            System.out.println("验证权限！");
            System.out.println("保存用户成功：" + user.getName());
            System.out.println("记录操作日志！");
        }
    }

但是这样的改动其实存在一些问题的：

1、我们需要对每一个接口的每一个方法都添加相应的逻辑，而且代码都大同小异的，这就会导致代码重复严重

2、验权和记录操作日志这种操作其实是通用的问题，不应该和具体的方法，具体的接口耦合在一起，可以剥离出来形成单独的框架

3、比如后续需要调整验证权限相关的逻辑，涉及到的改动很大

4、如果UserService是其他第三方开发的，我们无权修改代码，这个时候直接改原始代码就不行了

**其实上面的问题可以使用代理模式很好的解决**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljYjE5MTQ4NDU0NTE_size_16_color_FFFFFF_t_70][]

接下来我们看下静态代理

其实静态代理比较简单，为每一个类生成对应的代理类，逻辑相对来说比较简单，直接上代码

public class UserServiceImplProxy implements UserService {
        private UserService userService;
    
        public UserServiceImplProxy(UserService userService) {
            this.userService = userService;
        }
    
        @Override
        public User query(User user) {
            System.out.println("验证权限！");
    
            //委托给原始的UserService执行
            User user1 = userService.query(user);
            
            System.out.println("记录操作日志！");
            return user1;
        }
    
        @Override
        public void save(User user) {
            System.out.println("验证权限！");
            userService.save(user);
            System.out.println("记录操作日志！");
        }
    }

其实静态代理也是很繁琐的，我们需要为每一个类，每一个方法添加相应的操作。

**接下来分析下JDK动态代理**

1、首先我们来看下类Proxy

可以看到其实有两个构造函数，一个私有的构造函数，一个protected的构造函数

/**
         * Prohibits instantiation.
         */
        private Proxy() {
        }
    
        /**
         * Constructs a new {@code Proxy} instance from a subclass
         * (typically, a dynamic proxy class) with the specified value
         * for its invocation handler.
         *
         * @param  h the invocation handler for this proxy instance
         *
         * @throws NullPointerException if the given invocation handler, {@code h},
         *         is {@code null}.
         */
        protected Proxy(InvocationHandler h) {
            Objects.requireNonNull(h);
            this.h = h;
        }

第二个构造函数接收一个InvocationHandler，我们再看看InvocationHandler是什么？

其实我们可以看到InvocationHandler是一个接口，就一个方法，invoke方法。

public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
    }

下面我们基于动态代理实现上面的需求，首先定义一个InvocationHandler

public class MyInvocationHandler implements InvocationHandler {
            //代理对象
            private Object targerObject;
    
            public MyInvocationHandler(Object targetObject) {
                this.targerObject = targetObject;
            }
    
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法执行前逻辑
                System.out.println(method.getName() + ":鉴权开始！");
                
                //代理对象的方法
                Object result = method.invoke(targerObject, args);
    
                //执行后逻辑
                System.out.println(method.getName() + ":执行完成");
                System.out.println(method.getName() + ":已记录日志");
                return result;
            }
        }

接下来我们看下如何生成代理类，代码如下

public class UserServiceDynamicProxy {
        //被代理的类
        private Object targetObject;
    
        public UserServiceDynamicProxy(Object targetObject) {
            this.targetObject = targetObject;
        }
    
        //获得代理类
        public Object getProxyObject() {
            //获得实现的接口
            Class<?>[] interfaces = targetObject.getClass().getInterfaces();
            
            //获得InvocationHandler 
            InvocationHandler invocationHandler = new MyInvocationHandler(targetObject);
            return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), interfaces, invocationHandler);
        }
    }

如何使用代理类

public class Test {
        public static void main(String[] args) {
            //设置saveGeneratedFiles值为true生成class字节码到文件,JDK8下，其他版本没试过
            System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    
            User user = new User();
            user.setName("Ycb");
            //原始类
            UserService userService = new UserServiceImpl();
    
            //调用动态代理生成代理类
            UserService userServiceProxy = (UserService) new UserServiceDynamicProxy(userService).getProxyObject();
    
            //调用相关方法
            userServiceProxy.save(user);
        }
    }

输出结果，其实我们看到，经过上面的InvocationHandler的创建，代理类的生成，以及最终的调用，已经实现了相关的效果，而且我们没有和具体的接口，具体的方法绑定，更加灵活，那是怎么达到我们的需求的？

![20210402191430352.png][]  
其实我们可以通过反编译生成的动态代理的字节码文件看一下究竟，使用的是JDK8，可以添加上 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 就可以拿到生成的代理类的字节码文件了，其他版本的JDK，估计不能这样玩，没试过。

我们可以看下生成的代理类，如下。

package com.sun.proxy;
    
    public final class $Proxy0 extends Proxy implements UserService {
    
       private static Method m1;
       private static Method m2;
       private static Method m4;
       private static Method m3;
       private static Method m0;
    
    
       public $Proxy0(InvocationHandler var1) throws  {
          super(var1);
       }
    
       public final boolean equals(Object var1) throws  {
          try {
             return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
          } catch (RuntimeException | Error var3) {
             throw var3;
          } catch (Throwable var4) {
             throw new UndeclaredThrowableException(var4);
          }
       }
    
       public final String toString() throws  {
          try {
             return (String)super.h.invoke(this, m2, (Object[])null);
          } catch (RuntimeException | Error var2) {
             throw var2;
          } catch (Throwable var3) {
             throw new UndeclaredThrowableException(var3);
          }
       }
    
       public final User query(User var1) throws  {
          try {
             return (User)super.h.invoke(this, m4, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
             throw var3;
          } catch (Throwable var4) {
             throw new UndeclaredThrowableException(var4);
          }
       }
    
       public final void save(User var1) throws  {
          try {
             super.h.invoke(this, m3, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
             throw var3;
          } catch (Throwable var4) {
             throw new UndeclaredThrowableException(var4);
          }
       }
    
       public final int hashCode() throws  {
          try {
             return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
          } catch (RuntimeException | Error var2) {
             throw var2;
          } catch (Throwable var3) {
             throw new UndeclaredThrowableException(var3);
          }
       }
    
       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]);
             m4 = Class.forName("com.Ycb.proxy.UserService").getMethod("query", new Class[]{Class.forName("com.Ycb.proxy.User")});
             m3 = Class.forName("com.Ycb.proxy.UserService").getMethod("save", new Class[]{Class.forName("com.Ycb.proxy.User")});
             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          } catch (NoSuchMethodException var2) {
             throw new NoSuchMethodError(var2.getMessage());
          } catch (ClassNotFoundException var3) {
             throw new NoClassDefFoundError(var3.getMessage());
          }
       }
    }

我们通过这个代理类可以看到，其实这个代理是实现了 我们 需要代理的类实现的接口，比如上面的UserService接口，而且继承了Proxy类。

1、最开始定义了几个静态的Method，static静态块中通过反射获取了类相关的方法。

2、接下来可以看到一个构造函数，调用了super(var1)，其实就是Proxy中的protected接口，传递的InvocationHandler接口就是我们调用Proxy.newProxyInstance时设置的。

public $Proxy0(InvocationHandler var1) throws  {
          super(var1);
       }

接下来就是一些方法，我们具体看save方法，其实代码很简单，就是一句super.h.invoke（this,m3,new Object\[\]\{var1\}）;

public final void save(User var1) throws  {
          try {
             super.h.invoke(this, m3, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
             throw var3;
          } catch (Throwable var4) {
             throw new UndeclaredThrowableException(var4);
          }
       }

super.h不就是我们自己定义的InvovationHandler吗？m3就是前面所讲的方法，参数就是我们传递的参数。其实到这里动态代理的过程已经很清楚了。

其实通过上面的调用，我们可以看到，第一个参数proxy，传进来的是this，其实也就是生成的代理类实例，method其实就是我们调用的method，第三个就是参数，

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法执行前逻辑
                System.out.println(method.getName() + ":鉴权开始！");
                
                //代理对象的方法
                Object result = method.invoke(targerObject, args);
    
                //执行后逻辑
                System.out.println(method.getName() + ":执行完成");
                System.out.println(method.getName() + ":已记录日志");
                return result;
            }

所以我们在invoke方法中执行如下语句时要特别小心，对象别弄错。

//代理对象的方法
    Object result = method.invoke(targerObject, args);

我们也可以看到JDK动态代理的弊端，被代理的类需要实现接口，那不实现接口可以代理吗？后续单独开博文来讲解，CGLIB，后续再更新啦

个人学习记录有错误麻烦指出。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljYjE5MTQ4NDU0NTE_size_16_color_FFFFFF_t_70]: /images/20221022/8e44ffd9d20c4cc38468694814c63ca8.png
[20210402191430352.png]: /images/20221022/1904b35bd05f4bcf82d68be9a0740918.png