JAVA代理模式

什么是代理模式

代理类和被代理类实现同一个接口,也就是说他们有着相同的功能,区别在于,被代理类持有代理类的引用,被代理类中所有功能的实现都是由代理类来完成的

为什么要使用代理模式

一个优秀的软件设计,对于类似功能的模块,其中相同的逻辑,应该做到抽取与封装,来保证代码的简洁和可维护性,而对于其中不同的部分,则应该提供相应的方法来进行个性化定制.
现在有三个功能相似的类,他们有很多类似的方法,首先,把这些方法抽取出来,变成一个接口,然后写一个代理类实现这个接口,所有相同的逻辑,都抽取出来放在这个代理类中,三个类再调用这个代理类来完成相应的逻辑,不同的部分则正好可以在方法中自定义
还有第二种情况,一个接口中,有很多的方法,这些方法的实现中有很多的相同之处,比如retrofit的service接口,里面的方法都是网络请求的方法,比如我们现在要对所有的网络请求加缓存,难道所有的方法中都要写一次吗,显然不符合我们的设计规范,这里就可以用动态代理.

如何设计一个静态代理模式

  • 首先定义一个接口

      public interface NetWorkService {
          //获取用户名的网络请求
          String getUserName(int userId);
      
          //给文章点赞的网络请求
          Boolean likedThisArticle(int articleId);
      }
    
  • 接着是代理类

      public class NetWorkServiceImp implements NetWorkService {
          @Override
          public String getUserName(int userId) {
              //这里就来一个假的实现吧
              return "KingSlayer";
          }
      
          @Override
          public Boolean likedThisArticle(int articleId) {
              return true;
          }
      }
    
  • 然后是被代理类

      public class NetWorkServiceProxy implements NetWorkService {
          private NetWorkService netWorkServiceImp;
      
          public void attach(NetWorkService netWorkServiceImp) {
              this.netWorkServiceImp = netWorkServiceImp;
          }
      
          @Override
          public String getUserName(int userId) {
              //这里提出一个新的要求,将请求结果存入缓存
              String userName = netWorkServiceImp.getUserName(userId);
              CacheUtils.put(String.valueOf(userId), userName);
              return userName;
          }
      
          @Override
          public Boolean likedThisArticle(int articleId) {
              Boolean isActionSuccess = netWorkServiceImp.likedThisArticle(articleId);
              CacheUtils.put(String.valueOf(articleId), isActionSuccess);
              return isActionSuccess;
          }
      }
    

总结:上面这个静态代理完成之后,如果有别的类也需要这两个请求方法,只需要实现这个接口,然后绑定NetWorkServiceImp的对象就好了,非常的方便简洁,也利于维护

如何设计一个动态代理模式

  • 首先我们来看这个静态方法

      public static Object newProxyInstance(ClassLoader loader,
                                            Class[] interfaces,
                                            InvocationHandler h)
              throws IllegalArgumentException {
          Objects.requireNonNull(h);
      
          final Class[] intfs = interfaces.clone();
          // Android-changed: sm is always null
          // final SecurityManager sm = System.getSecurityManager();
          // if (sm != null) {
          //     checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
          // }
      
          /*
           * Look up or generate the designated proxy class.
           */
          Class cl = getProxyClass0(loader, intfs);
      
          /*
           * Invoke its constructor with the designated invocation handler.
           */
          try {
              // Android-changed: sm is always null
              // if (sm != null) {
              //     checkNewProxyPermission(Reflection.getCallerClass(), cl);
              // }
      
              final Constructor cons = cl.getConstructor(constructorParams);
              final InvocationHandler ih = h;
              if (!Modifier.isPublic(cl.getModifiers())) {
                  // Android-changed: Removed AccessController.doPrivileged
                  cons.setAccessible(true);
              }
              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);
          }
      }
    
  • 我们关注一下这个方法的第三个参数

      public class NetWorkServiceProxyHandler implements InvocationHandler {
      
          private NetWorkService netWorkService;
      
          public NetWorkServiceProxyHandler(NetWorkService netWorkService) {
              this.netWorkService = netWorkService;
          }
      
          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              Object invoke = method.invoke(netWorkService, args);
              CacheUtils.put(String.valueOf(args[0]), invoke);
              return invoke;
          }
      }
    

在这里,我们创建一个类实现InvocationHandler接口,在这个类中,有一个invoke方法,我们拿到代理类,通过反射调用接口中所有的方法,同时也正好在这里把每个请求方法的结果都存入缓存中,就不用每个请求方法都写一遍了,我觉得这正是retrofit中通过动态代理获取service对象的原因.

你可能感兴趣的:(JAVA代理模式)