一种组件化框架的探究之旅

我会带着你远行 2021-11-17 02:28 268阅读 0赞

概述

本文主要就组件化中服务实现类的实例化方法做简要探究，希望可以探索出一种简洁易用的组件化框架，本文到的主要技术有：

  • 编译时注解
  • javapoet的使用
  • 反射的使用

问题的引入

在软件开发中，当一款软件的规模和功能不断增多、丰富，原先的“一勺烩”架构往往显得捉襟见肘，为了便于团队协作、便于维护、便于升级，我们往往需要将一个软件划分为若干个模块（即我们所说的模块化），而这若干个模块又是依赖于很多个组件的（即我们所说的组件化），这里涉及了两个概念，即模块化和组件化，经常有读者反映搞不清楚这二者的区别，这里我帮大家总结了一下模块化与组件化的区别与联系：

image-20190718111759360

以抖音APP为例，其可以这样进行模块和组件的划分：

aHR0cDovL3BpY3R1cmUtcG9vbC5pbWctY24tYmVpamluZy5hbGl5dW5jcy5jb20vMjAxOS0wNy0yNi0wNjM4NDYuZ2lm

如上图所示，按照业务，可以将抖音分为首页模块、直播模块、视频模块、消息模块4个模块（实际肯定比这个分的多，这里只是为了说明问题），每个模块完成了一定的业务逻辑，而这4个模块又是基于下面的视频播放组件、IO组件、网络组件等若干个组件来实现自己的业务逻辑的，这些组件反映在Android项目中就是若干个 'com.android.library'，组件为模块提供服务（Service），模块并不关心组件是如何实现服务的，只关心组件提供了什么服务，反映在代码上就是，使用组件的模块只知道组件暴露出来的接口，不清楚对应接口在组件中是由谁实现的（实现类是什么），这样就有一个问题，组件的使用者在使用组件的时候应该如何实例化对象？因为接口是不能被实例化的，比如：

组件A提供服务IServiceA，将接口IServiceA暴露给外界，IServiceA的实现类为ServiceAImpl，组件的使用者模块B要使用组件A提供的服务IServiceA。按照常理来说，最直接的方法就是模块B使用new关键字实例化一个ServiceAImpl类的对象，然后基于这个对象调用IServiceA提供的各个功能（方法），但是问题是模块B只知道自己所需要的功能是由组件A的IServiceA接口定义的，它根本不知道IServiceA具体的实现类是什么，而IServiceA是不能使用new关键字进行对象的实例化的的的（因为不能实例化接口），那么怎么解决这个问题呢？

问题的解决思路

我们可以使用编译时注解，为服务的实现类添加我们自定义的注解，然后在编译时对所有添加我们自定义注解的类进行遍历，将遍历的结果写入文件，然后在运行时将文件读出，这样模块就可以知晓服务的具体实现类，自然可以成功实例化，整体思路如下图所示：

gifhome\_480x277\_11s

具体到代码层面，思路如下：

  • 定义注解Component，用来修饰服务（接口）的实现类，其接收一个Class类型的参数，这个参数的意义是该类实现的服务（接口）的Class类
  • 自定义AbstractProcessor类，在该类的process（）方法中遍历被@Component修饰的类（称作Service类），并拿到注解对应的参数即Service类对应的服务接口（称作IService），然后将IService-Service作为键值对添加到Map中，最终解析完所有被@Component注解修饰的类后将Map的内容转换为json字符串（记为jsonString）

  • 使用代码生成一个ComponentResource类：

    • 将上一步生成的jsonString作为ComponentResource的成员变量
    • 在ComponentResource类的构造方法中将jsonString解析为map，并且将map作为ComponentResource的成员变量
    • 为ComponentResource类生成String getServiceImplUrl(String iServiceClassName)方法，即根据IService的类名查找到其实现类的URL并返回，方法的内容自然是返回map.get(iServiceClassName)

  • 定义ServiceManager类，即我们框架的管理类：

    • 定义register(Application application)方法，利用反射实例化编译期间生成的ComponentResource类(生成的实例作为ServiceManager的成员变量)
    • 定义getService(Class<T> clazz)方法，在该方法中首先调用ComponentResource.getServiceImplUrl（clazz.getCanonicalName()）方法获取当前IService对应实现类的URL，然后利用反射实例化该URL对应的类，然后将实例返回
  • 在应用启动的时候（比如Application的onCreate方法中），手动调用ServiceManager的register(Application application)方法
  • 当某模块需要IService实现类的实例时，调用ServiceManager的getService(Class<T> clazz)方法，获得接口类对应的实现类的实例

将以上步骤形象化可以表示为：

gifhome\_1900x1064\_20s

代码实现

定义注解

注解的定义很简单，需要注意的是，注解的@Target要设置为TYPE，因为我们定义的这个注解是要应用到类上的，另外一点，我们定义的这个注解接收一个Class类型的参数，我们希望将接口类的class传递进来，以便下一步生成键值对：

  1. @Retention(RUNTIME)
  2. @Target(TYPE)
  3. public @interface Component {
  5.     Class value();
  6. }
定义AbstractProcessor类

要想在编译时解析被特定注解修饰的类，我们就需要使用AbstractProcessor，该类在编译时会被自动执行，java api会调用AbstractProcessor的process（）方法并传入相关参数，我们只需要在process方法中找到被@Component注解修饰的类，并且拿到注解中的参数即可：

  1. public class UgComponentProcessor extends AbstractProcessor {
  3.     private Filer filer;
  4.     private HashMap<String, Set<String>> map = new HashMap<>();
  5.     ...
  7.     @Override
  8.     public synchronized void init(ProcessingEnvironment env) {
  10.         super.init(env);
  11.       //获取当前env，用于后面代码的写入
  12.         filer = env.getFiler();
  13.         ...
  14.     }
  18.     @Override
  19.     public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
  21.           //寻找并解析被@Component注解修饰的类，并将类和接口以键值对的形式塞进map中
  22.         findAndParseTargets(roundEnvironment);
  23.       //将map转换为json字符串
  24.         String jsonString = generateJsonString(map);
  25.                 //生成ComponentResources类的代码文件，将jsonString作为ComponentResources的成员变量
  26.         JavaFile javaFile = brewJava(jsonString);
  28.         try {
  30.           //将生成的代码文件进行写入
  31.             javaFile.writeTo(filer);
  32.         } catch (IOException e) {
  34.             System.out.println("warning:多次写入filter");
  35.         }
  36.         return false;
  37.     }
  39. }

我们来一步一步进行代码的实现，首先是寻找并解析被@Component注解修饰的类，并将类和接口以键值对的形式塞进map中，我们定义一个findAndParseTargets（）方法进行实现：

  1. public class UgComponentProcessor extends AbstractProcessor {
  3.     ...
  5.     /**
  6.      * 寻找被 @Component注解修饰的类
  7.      *
  8.      * @param env
  9.      * @return
  10.      */
  11.     private void findAndParseTargets(RoundEnvironment env) {
  14.         // 遍历被@Component修饰的元素
  15.         for (Element element : env.getElementsAnnotatedWith(Component.class)) {
  17.             try {
  19.                     //解析被@Component修饰的元素
  20.                 parseComponentAnimation(element);
  21.             } catch (Exception e) {
  23.             }
  24.         }
  26.     }
  28.     /**
  29.      * 解析被 @Component修饰的元素
  30.      *
  31.      * @param element
  32.      */
  33.     private void parseComponentAnimation(Element element) {
  36.         //实现类的类名
  37.         String name = element.getSimpleName().toString();
  39.         //实现类的包名
  40.         PackageElement e = (PackageElement) element.getEnclosingElement();
  41.         String implPackageName = e.getQualifiedName().toString();
  43.         //接口的包名+类名
  44.         String interfacePackageWithClassName = getUgValueTypeMirror(element.getAnnotation(Component.class));
  46.                 //实现类对应的URL
  47.         String implUrl = implPackageName + "." + name;
  48.         Set<String> impls = new HashSet<>(map.get(interfacePackageWithClassName));
  49.         if (impls.size() == 0) {
  51.             impls = new LinkedHashSet<>();
  52.             impls.add(implUrl);
  53.         } else if (impls.contains(implUrl)) {
  55.             return;
  56.         } else {
  58.             impls.add(implUrl);
  59.         }
  60.         //put 进map
  61.         map.put(interfacePackageWithClassName, impls);
  63.     }
  64. }

generateJsonString（）方法的主要作用是将map转为json字符串，是借助gson实现的，代码比较简单，这里不再赘述，然后我们看看brawJava()方法的实现：

  1. public class UgComponentProcessor extends AbstractProcessor {
  4.       //生成java代码
  5.     private JavaFile brewJava(String jsonStringValue) {
  9.         jsonStringValue = jsonStringValue.replaceAll("\"", "\\\\\"");
  10.         jsonStringValue = "\"" + jsonStringValue + "\"";
  12.         ClassName gson = ClassName.get("com.google.gson", "Gson");
  13.         ClassName arrayList = ClassName.get("java.util", "ArrayList");
  15.         MethodSpec cons = MethodSpec.constructorBuilder()
  16.                 .beginControlFlow("if (\"\".equals(jsonString) || jsonString == null)")
  17.                 .addStatement("return")
  18.                 .endControlFlow()
  19.                 .addStatement("$T gson = new $T()", gson, gson)
  20.                 .addStatement("maps = gson.fromJson(jsonString, HashMap.class)")
  21.                 .addModifiers(Modifier.PUBLIC)
  22.                 .build();
  25.         MethodSpec getInstanceOfService = MethodSpec.methodBuilder("getServiceImplUrl")
  26.                 .addModifiers(Modifier.PUBLIC)
  27.                 .returns(String.class)
  28.                 .addParameter(String.class, "iServiceClassName")
  29.                 .addStatement("$T<String> list = ($T<String>) maps.get(iServiceClassName)", arrayList, arrayList)
  30.                 .beginControlFlow("if(list==null)")
  31.                 .addStatement("return null")
  32.                 .endControlFlow()
  33.                 .addStatement("return list.get(0)")
  34.                 .addAnnotation(Override.class)
  35.                 .build();
  37.         FieldSpec jsonString = FieldSpec.builder(String.class, "jsonString", Modifier.PRIVATE)
  38.                 .initializer(jsonStringValue).build();
  40.         FieldSpec hashMap = FieldSpec.builder(HashMap.class, "maps", Modifier.PRIVATE)
  41.                 .initializer("new HashMap<>()").build();
  44.         ClassName serviceCacheInterface = ClassName.get("com.bytedance.annotation", "IComponentResource");
  46.         TypeSpec My_Component = TypeSpec.classBuilder("ComponentResource")
  47.                 .addSuperinterface(serviceCacheInterface)
  48.                 .addModifiers(Modifier.PUBLIC)
  49.                 .addField(jsonString)
  50.                 .addField(hashMap)
  51.                 .addMethod(cons)
  52.                 .addMethod(getInstanceOfService)
  53.                 .build();
  56.         return JavaFile.builder("com.component", My_Component)
  57.                 .build();
  59.     }
  61.     ...
  63. }

这样就可以生成一个包含IService与ServiceImpl键值对的ComponentResource类文件，就像这样：

  1. public class ComponentResource implements IComponentResource {
  3.   private String jsonString = "{\"com.modelb.IServiceB\":[\"com.modelb.ServiceBimpl2\",\"com.modelb.ServiceBimpl1\"],\"com.componentframe.IServiceA\":[\"com.componentframe.ServiceAImpl2\",\"com.componentframe.ServiceAImpl1\"]}";
  5.   private HashMap maps = new HashMap<>();
  7.   public ComponentResourceBeta() {
  9.     if ("".equals(jsonString) || jsonString == null) {
  11.       return;
  12.     }
  13.     Gson gson = new Gson();
  14.     maps = gson.fromJson(jsonString, HashMap.class);
  15.   }
  17.   @Override
  18.   public String getServiceImplUrl(String iServiceClassName) {
  20.     ArrayList<String> list = (ArrayList<String>) maps.get(iServiceClassName);
  21.     if(list==null) {
  23.       return null;
  24.     }
  25.     return list.get(0);
  26.   }
  27. }

然后我们需要定义一个ServiceManager来将用户和ComponentResource连接起来：

  1. public class ServiceManager {
  4.     private static boolean inited = false;
  5.     private static IComponentResource iComponentResource = null;
  7.     public static boolean register(Application application) {
  9.         if (inited) {
  11.             return true;
  12.         } else {
  15.             try {
  17.                 Class<?> serviceCacheClass = application.getClass().getClassLoader().loadClass("com.component.ComponentResource");
  18.                 Constructor constructor = serviceCacheClass.getConstructor();
  19.                 iComponentResource = (IComponentResource) constructor.newInstance();
  21.             } catch (ClassNotFoundException e) {
  23.                 e.printStackTrace();
  24.             } catch (NoSuchMethodException e) {
  26.                 e.printStackTrace();
  27.             } catch (IllegalAccessException e) {
  29.                 e.printStackTrace();
  30.             } catch (InstantiationException e) {
  32.                 e.printStackTrace();
  33.             } catch (InvocationTargetException e) {
  35.                 e.printStackTrace();
  36.             }
  38.             inited = true;
  39.             return true;
  40.         }
  41.     }
  43.     public static <T> T getService(Class<T> clazz) {
  45.         if (!inited) {
  47.             return null;
  48.         }
  49.         String targetUrl = iComponentResource.getServiceImplUrl(clazz.getCanonicalName());
  50.         Class<?> serviceClazz = null;
  51.         T service = null;
  52.         try {
  54.             serviceClazz = Class.forName(targetUrl);
  55.             Constructor constructor = serviceClazz.getConstructor();
  56.             service = (T) constructor.newInstance();
  58.         } catch (ClassNotFoundException e) {
  60.             e.printStackTrace();
  61.         } catch (NoSuchMethodException e) {
  63.             e.printStackTrace();
  64.         } catch (InstantiationException e) {
  66.             e.printStackTrace();
  67.         } catch (IllegalAccessException e) {
  69.             e.printStackTrace();
  70.         } catch (InvocationTargetException e) {
  72.             e.printStackTrace();
  73.         }
  74.         return service;
  77.     }
  78. }

在使用的时候我们只需要：

  1. ServiceManager.register(this);
  2.  IServiceB serviceB = ServiceManager.getService(IServiceB.class);

即可获得IServiceB的实现类的实例。

改进

上面的实现思路是先将Map转化为json String，然后写入ComponentResource类文件，当实例化ComponentResource的时候再将json String解析为Map，这样由于json的解析比较耗时，势必导致编译速度过慢，改进方法是略去map与String互转的步骤，直接将map的内容写在ComponentResource的构造方法中，即将生成ComponentResource的brewJava（）方法改进为：

  1. private JavaFile brewJava(HashMap<String, Set<String>> hashMap) {
  5.         ClassName arrayList = ClassName.get("java.util", "ArrayList");
  6.         ClassName linckedHashSet = ClassName.get("java.util", "LinkedHashSet");
  7.         ClassName collection = ClassName.get("java.util", "Collection");
  8.         ClassName hashSet = ClassName.get("java.util", "HashSet");
  10.         StringBuilder mapStr = new StringBuilder();
  13.         for (Map.Entry entry : hashMap.entrySet()) {
  17.             String key = (String) entry.getKey();
  18.             Set<String> value = new HashSet<String>((Collection<? extends String>) entry.getValue());
  19.             StringBuilder implSetStr = new StringBuilder();
  21.             mapStr.append("implSet.clear();\n");
  24.             for (String str : value) {
  26.                 implSetStr.append("implSet.add(\"").append(str).append("\");\n");
  27.             }
  28.             mapStr.append(implSetStr);
  29.                 mapStr.append("interfaceToImplUrlMap.put(").append("\"").append(key).append("\"").append(",new HashSet<>(implSet));\n");
  30.         }
  32.         MethodSpec cons = MethodSpec.constructorBuilder()
  33.                 .addModifiers(Modifier.PUBLIC)
  34.                 .addStatement("$T<String> implSet=new $T<>()", hashSet, linckedHashSet)
  35.                 .addCode(mapStr.toString())
  36.                 .build();
  39.         MethodSpec getInstanceOfService = MethodSpec.methodBuilder("getServiceImplUrl")
  40.                 .addModifiers(Modifier.PUBLIC)
  41.                 .returns(String.class)
  42.                 .addParameter(String.class, "iServiceClassName")
  43.                 .addStatement("$T<String> list = new ArrayList<String>(($T<? extends String>) interfaceToImplUrlMap.get(iServiceClassName))", arrayList, collection)
  44.                 .beginControlFlow("if(list==null)")
  45.                 .addStatement("return null")
  46.                 .endControlFlow()
  47.                 .addStatement("return list.get(0)")
  48.                 .addAnnotation(Override.class)
  49.                 .build();
  52.         FieldSpec interfaceToImplUrlMap = FieldSpec.builder(HashMap.class, "interfaceToImplUrlMap", Modifier.PRIVATE)
  53.                 .initializer("new HashMap<>()").build();
  56.         ClassName ugInterface = ClassName.get("com.annotation", "IComponentResource");
  58.         TypeSpec Ug_Component = TypeSpec.classBuilder("ComponentResource")
  59.                 .addSuperinterface(ugInterface)
  60.                 .addModifiers(Modifier.PUBLIC)
  61.                 .addField(interfaceToImplUrlMap)
  62.                 .addMethod(cons)
  63.                 .addMethod(getInstanceOfService)
  64.                 .build();
  67.         return JavaFile.builder("com.component", Ug_Component)
  68.                 .build();
  70.     }

最后生成的代码就像这样：

  1. public class ComponentResource implements IComponentResource {
  3.   private HashMap interfaceToImplUrlMap = new HashMap<>();
  5.   public ComponentResource() {
  7.     HashSet<String> implSet=new LinkedHashSet<>();
  8.     implSet.clear();
  9.     implSet.add("com.modelb.ServiceBimpl2");
  10.     implSet.add("com.modelb.ServiceBimpl1");
  11.     interfaceToImplUrlMap.put("com.modelb.IServiceB",new HashSet<>(implSet));
  12.     implSet.clear();
  13.     implSet.add("com.componentframe.ServiceAImpl1");
  14.     implSet.add("com.componentframe.ServiceAImpl2");
  15.     interfaceToImplUrlMap.put("com.componentframe.IServiceA",new HashSet<>(implSet));
  16.   }
  18.   @Override
  19.   public String getServiceImplUrl(String iServiceClassName) {
  21.     ArrayList<String> list = new ArrayList<String>((Collection<? extends String>) interfaceToImplUrlMap.get(iServiceClassName));
  22.     if(list==null) {
  24.       return null;
  25.     }
  26.     return list.get(0);
  27.   }
  28. }

我们来测试一下改进前后的区别：

  1. public class MyApplication extends Application {
  3.     @Override
  4.     public void onCreate() {
  6.         super.onCreate();
  7.         long start = System.currentTimeMillis();
  8.         ServiceManagerBefore.register(this);
  9.         IServiceB serviceBfromBefore = ServiceManagerBefore.getService(IServiceB.class);
  10.         String value = serviceBfromBefore.getValue();
  11.         Log.e(MyApplication.class.getSimpleName(), "改进前测试：" + value);
  12.         long end = System.currentTimeMillis();
  13.         Log.e(MyApplication.class.getSimpleName(), "改进前总耗时：" + (end - start));
  15.         start = System.currentTimeMillis();
  16.         ServiceManager.register(this);
  17.         IServiceB serviceBfromAfter = ServiceManager.getService(IServiceB.class);
  19.         value = serviceBfromAfter.getValue();
  20.         Log.e(MyApplication.class.getSimpleName(), "改进后测试：" + value);
  21.         end = System.currentTimeMillis();
  22.         Log.e(MyApplication.class.getSimpleName(), "改进后总耗时：" + (end - start));
  25.     }
  26. }

运行效果如下：

image-20190729172322004

可见改进后的速度比改进前快了不止一点点。

待完成

  • 为@Component增加参数，使其适应一个借口多个实现类的场景下，按照用户传入参数的不同实例化不同的实现类的返回给用户

发表评论

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

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

相关阅读

    相关 Scrum之探究(一)

    [原文链接][Link 1] 作者：Mark Levison 机械的Scrum对比真正的Scrum，差别在哪里？ 最近，我和一个朋友聊到了他们公司实施Scrum的情况。

    悠悠悠悠/ 0 赞/ 278 阅读