阅读 3382

Android端简单易用的SPI框架 —— SPA

SPI(Service Provider Interface)是Java提供的一种动态服务发现机制。通过SPI机制,我们可以直接跨模块查找到想要的接口实现类,从而避免不必要的模块间依赖,降低模块之间的耦合性。这对Android组件间通信非常重要的意义。试想一下如果有一个组件能提供这样一种能力,我们的组件通信是否会变得很容易: 通过一个接口,我可以很容易的查找到这个接口在任意模块下的任意一个或多个实现类的对象;而且,可以按你自己想要的方式缓存对象(简单对象、单例、强弱引用、自定义等);接口实现类对象的每个方法执行时都可以被自定义拦截策略和拦截器拦截; 如果这个接口有多个实现类,可以自由选择具体使用哪一个、多个实现类,这个组件就是本文要跟大家介绍的SPA(Service Pool for Android)。(有点抽象, 往后看)

介绍SPA之前, 我们先看看Java提供的SPI机制是怎样的

Java内置的SPI机制是通过ServiceLoader查找某个接口的所有实现类,并实例化。每个需要实例化模块下需要以该接口的全限定名(包名+类名)为文件名放到resources/META-INF/services/目录下,然后将他的实现类的全限定名按行依次写到该文件中,假设有接口com.sample.IPrinter,

  • A模块下有他的实现类com.sample.a.APrinter, 那将有如下图的目录结构

  • B模块下有他的实现类com.sample.b.BPrinter, 那将有如下图的目录结构

  • 假设C模块也有他的实现类com.sample.c.CPrinter,但是C模块没有定义resources/META-INF/services/,目录结构如下图:

  • 现在我们在任何一个模块中,通过ServiceLoader(java.util.ServiceLoader)去加载IPrinter:
// 查找出所有IPrinter实现类
// 这里没有CPrinter,因为C没有定义/META-INF/services/com.sample.interface.IPrinter
ServiceLoader<IPrinter> printers = ServiceLoader.load(IPrinter.class);
for (IPrinter printer: printers) {
      printer.print();
}
复制代码
  • 输出:
this is A
this is B
复制代码

这就是Java提供的SPI机制,它的确能够做到实例化跨了模块的对象, Android也的确支持这个SPI机制。但这个模式适用的场景太少,在Android开发场景下,并没有什么太多的用武之地。我总结了一下几点原因:

  1. 配置太过繁琐,需要为每个接口的每个实现类配置/META-INF/services/xxx文件,如果我的业务需要很多的接口,那么配置将异常复杂和混乱 (SPA只需要一个注解)
  2. 实现类对象直接由ServiceLoader实例化,对象的生命周期不可控,也不利于多模块协作 (SPA创建的实例可以是单例、软、弱引用、普通对象或自定义生命周期)
  3. ServiceLoader只能通过Class查找实现类,不支持path/id形式查找 (这一点对两端统一方案和配置化能力都非常重要)
  4. 当存在多个实现类对象,ServiceLoader只是提供了一个Iterator, 没法精确拿到具体实现类对象 (SPA可以通过优先级、手动指定、拦截策略三种方式拿到具体实现类对象)
  5. 当存在多个实现类,ServiceLoader没有任何管理策略 (SPA可以自定义多实现类执行顺序)
  6. ServiceLoader创建出的对象执行方法时,没有很好的拦截策略 (SPA可以通过拦截策略,实现路由拦截、进程RPC通信机制等能力)
  7. ServiceLoader是通过Classloader加载和读取resources目录下的文件,涉及文件流读写,性能损耗较大

写在前面,SPA能做什么?

  • Activity路由 (spa中的独立组件, sprouter)
  • RPC通信 (spa中的一个独立组件, sprpc)
  • 组件路由
  • 服务分发
  • 组件Mock

SPA有哪些优势

  1. 简洁
  2. 自由度高,扩展能力强
  3. 高效,无性能损耗

废话了这么多,SPA到底是一个怎样的SPI框架呢

SPA的接入方式请参考README.md, 这里只讲SPA的用法, 先上一张简易图 如上图所示, SPA其实可以简单理解为一个可以跨模块创建对象工具, 我们先上图中的模型,代码应该怎么写。

** interfaces模块 —— IPrinterService.java **

//注意: 接口一定要继承IService, IService是一个空接口
public interface IPrinterService extends IService {
    void print();
}
复制代码

** A模块 —— APrinterService **

@Service(priority = 1)
public class APrinterService implements IPrinterService {
    @Override
    public void print() {
        System.out.println("this is a printer service.");
    }
}
复制代码

** B模块 —— BPrinterService **

@Service(path="b_printer", priority = 2)
public class BPrinterService implements IPrinterService {
    @Override
    public void print() {
        System.out.println("this is b printer service.");
    }
}
复制代码

** C模块 —— CPrinterService **

@Service(priority = 3)
public class CPrinterService implements IPrinterService {
    @Override
    public void print() {
        System.out.println("this is c printer service.");
    }
}
复制代码

** 最后是Main模块, 下面的逻辑也可以存在于是A,B,C模块中 **

IPrinterService printer = Spa.getService(IPrinterService.class); //取最高优先级
printer.print(); // 输出: this is c printer service.

APrinterService aprinter = Spa.getFixedService(APrinterService.class);
aprinter.print();// 输出: this is a printer service.

BPrinterService bPrinter = Spa.getFixedService(BPrinterService.class);
bPrinter.print();// 输出: this is b printer service.

// 和上面的Spa.getFixedService(BPrinterService.class)等价
IPrinterService pathPrinter = Spa.getService("b_printer"); //是不是有路由的感觉
pathPrinter.print(); // 输出: this is b printer service.

复制代码

这就是SPA最基本的用法,到目前为止他已经有了SPI机制的能力了,是不是很简单!!! 难道SPA只有这点内容吗, 当然不是!

SPA创建的对象的生命周期是怎样的?

对于上面的示例大家有没有一个疑问, bPrinter和pathPrinter都是实现类BPrinterService对象,那么这两个对象相等吗, bPrinter == pathPrinter?

** 下面介绍一下@Service注解的 scope属性 **

scope定义一个对象的生命周期,SPA内置的scope有

  • normal, 普通对象,每次都返回一个新创建对象, 默认scope
  • global, 全局对象,可以看做是一个单例,每次返回的都是同一个对象, 对象将在第一次被使用时创建
  • weak, 对象使用弱引用缓存,如果没有被gc回收,则不会重新创建
  • soft, 对象使用软引用缓存,如果没有被gc回收,则不会重新创建
  • custom, 自定义缓存策略, 当scope不是上面列出的值时,会被认为是自定义缓存策略,自定义缓存策略将在Spa进阶篇中介绍

那么bPrinter和pathPrinter相等吗? 答案就显而易见了,因为SPA对象默认的生命周期是nornal,也就是每次都会创建一个新对象,所以 bPrinter != pathPrinter。 如果想要 bPrinter == pathPrinter, 只需要将BPrinterService的scope定义为 global!

@Service(path="b_printer", priority = 2, scope=Spa.Scope.GLOBAL) //scope 设置为 global
public class BPrinterService implements IPrinterService {
    @Override
    public void print() {
        System.out.println("this is b printer service.");
    }
}
复制代码

SPA的方法拦截能力

SPA并不是简单的创建并返回一个对象,SPA实际返回的是目标对象的代理,通过代理,对象执行方法时,我们就能对该对象实施拦截,

** SPA有灵活的拦截能力,不仅仅可以设置拦截器,还可以设置拦截策略 **

  • 自定义拦截器,多个拦截器默认按优先级顺序依次执行拦截
  • 自定义拦截策略,多个拦截器时,这些拦截器的执行顺序、执行方式由拦截策略决定

自定义拦截策略放到后面进阶篇,这里先说一下拦截器的用法,我们先看一下SPA执行方法的流程图,流程图演示的是上一节示例的CPrinterService的print方法调用过程

** 拦截器代码中是如何使用的? **

实现IServiceInterceptor接口并被@Service标记的类会被SPA认为是一个方法调用拦截器

  • 先定义一个高优先级的拦截器
@Service(priority = Spa.Priority.MAX)
public class MaxPriorityServiceInterceptor implements IServiceInterceptor {
    @Override
    public void intercept(Class<? extends IService> originClass, IService source, Method method, Object[] args, IServiceInterceptorCallback callback) {
    	System.out.println("this is a max priority interceptor.")
        callback.onContinue(method, args);

    }
}
复制代码
  • 再定义一个普通优先级的拦截器
@Service
public class NormalServiceInterceptor implements IServiceInterceptor {

    @Override
    public void intercept(Class<? extends IService> originClass, IService source, Method method, Object[] args, IServiceInterceptorCallback callback) {
        System.out.println("this is a normal priority interceptor.")
        callback.onContinue(method, args);
    }
}
复制代码
  • 再定义一个低优先级的拦截器
@Service(priority = Spa.Priority.MIN)
public class MinPriorityServiceInterceptor implements IServiceInterceptor {
    @Override
    public void intercept(Class<? extends IService> originClass, IService source, Method method, Object[] args, IServiceInterceptorCallback callback) {
    	System.out.println("this is a min priority interceptor.")
        if ("chao.sample.c.CPrinterService".equalse(originClass.getName()) && "print".equals(method.getName())) { // 当拦截的是CPrinterService的print方法时,拦截!
            callback.onInterrupt(null); //如果方法有返回值,null可以替换为拦截的值
        } else {
            callback.onContinue(method, args);
        }
    }
}
复制代码
  • 执行print方法
IPrinterService printService = Spa.getService(IPrinterService.class); //cPrinter
printService.print(); 
复制代码
  • 最后看输出结果
this is a max priority interceptor.
this is a normal priority interceptor.
this is a min priority interceptor.
# this is c printer service.  cPrinter的print被拦截,没有被执行,所以不会有这条输出
复制代码
  • 再看下整个流程的时序图

SPA应用实战1 —— 子模块如何获取主模块的BuildConfig信息

多模块开发/组件化开发过程中,主模块(plugin为com.android.application的模块,一般指app模块)可以依赖任何模块,但是子模块无法依赖主模块,如果子模块想拿主模块的内容要怎么办呢? 下面演示如何通过Spa来获取主模块的Context和BuildConfig中的内容。 ** 先在接口层定义一个BuildService**

BuildService.java

public interface BuildService extends IService {
    String buglyId(); // build.gradle中使用buildConfigField定义的buglyId

    boolean debuggable();

    String versionName();

    int versionCode();

    String applicationId();

    String buildType();
}
复制代码

** 在app模块中,实现这个service接口并使用@Service标记 **

  1. BuildServiceImpl.java
@Service(scope = Spa.Scope.GLOBAL) //Global可以看做是单例
public class BuildServiceImpl implements BuildService {
    @Override
    public String buglyId() {
        return BuildConfig.BUGLY_ID;
    }

    @Override
    public boolean debuggable() {
        return BuildConfig.DEBUG;
    }

    @Override
    public String versionName() {
        return BuildConfig.VERSION_NAME;
    }

    @Override
    public int versionCode() {
        return BuildConfig.VERSION_CODE;
    }

    @Override
    public String applicationId() {
        return BuildConfig.APPLICATION_ID;
    }

    @Override
    public String buildType() {
        return BuildConfig.BUILD_TYPE;
    }
}
复制代码

** 准备工作已经完成,现在我们在pages模块的BuildInfoActivity中应用它 **

BuildInfoActivity.java

public class BuildInfoActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        BuildInfoPageBinding viewBinding = BuildInfoPageBinding.inflate(LayoutInflater.from(this));
        setContentView(viewBinding.getRoot());

        BuildService buildService = Spa.getService(BuildService.class);
        viewBinding.applicationId.setText("applicationId: " + buildService.applicationId());
        viewBinding.versionName.setText("versionName: " + buildService.versionName());
        viewBinding.versionCode.setText("versionCode: " + buildService.versionCode() + "");
        viewBinding.buildType.setText("buildType: " + buildService.buildType());
        viewBinding.debuggable.setText("debuggable: " + buildService.debuggable());
        viewBinding.buglyId.setText("buglyId:" + buildService.buglyId());
    }
}}
复制代码

** 看看最终的效果 ** 这是SPA最简单的一个应用场景,更多应用实战将会在SPA的进阶篇中介绍

上面涉及到的所有示例代码都在这里

进阶篇链接:

总结

本文主要介绍了Android端简单易用的SPI框架 —— SPA(Service Pool for Android)的能力和用法, 并和Java的SPI机制做了对比。相信大家看得出SPA更强大,更简洁而且消耗更低。后续还会出进阶篇,给大家逐步介绍我在SPI基础上开发的包括sprouter, sprpc, 服务分发, 组件Mock等等一系列扩展能力。 如果您对我的项目感兴趣,欢迎扫一扫下面的二维码,添加我个人的工作微信,让我们一起研究和探讨。这里是我的github地址,您的star/fork是我前进最大的动力,感谢!