Android SPI

news2024/11/17 7:14:37

1.SPI

SPI全称Service Provider Interface,服务提供方接口,是Java提供的一套用来被第三方实现或者扩展的API,它可以用来启用框架扩展和替换组件。服务通常指一个接口或者一个抽象类,服务提供方是对这个接口或者抽象类的具体实现,由第三方来实现接口提供具体的服务。SPI其实就是为某个接口寻找服务的机制,它将装配的控制权移交给ServiceLoader,使用ServiceLoader去加载接口对应的实现,这样开发者就可以不用关注实现类。

开发中有时一个接口可能有多种实现方式,如果将特定实现写死在代码里面,那么要更换实现的时候就要改动代码,对原有代码进行重写,这样非常麻烦,而且也容易导致bug。使用SPI可以对接口的实现进行动态替换,即动态加载实现类。

SPI在模块开发中会比较有用,不同的模块可以基于接口编程,每个模块有不同的接口实现类,然后通过SPI机制自动注册到一个配置文件中,就可以实现在程序运行时扫描加载同一接口的不同实现类,从而实现跨模块通信。这样模块之间不会基于实现类硬编码,可插拔。

SPI整体机制如下:

291be3436da446878129cbd178f16ad4.webp

Java SPI 实际上是“基于接口的编程+策略模式+配置文件”组合实现的动态加载机制。模块之间基于接口编程,每个模块有不同的实现service provider,然后通过SPI机制自动注册到一个配置文件中,就可以实现在程序运行时扫描加载同一接口的不同service provider。这样模块之间不对实现类进行硬编码,实现解耦,而且实现可插拔替换。

 

2.SPI使用示例

SPI使用步骤:

①定义一个接口文件;

②写出多个该接口文件的实现;

③在src/main/resources/下新建/META-INF/services目录, 新增一个以接口命名的文件 , 文件内容是该接口的实现类全路径;

④使用ServiceLoader类查找这些接口的实现类。

通过例子看一下SPI在Android中的应用。先看工程结构图,有四个模块,一个是app主程序模块,一个是接口interface模块,另外两个就是接口的不同实现模块adisplay和bdisplay。

4e8dbe9df3db4ac3883a1716d80f6527.webp

要实现的功能很简单,就是点击按钮,加载不同模块实现的方法,如下图所示:

596c67b406294edc9b738ddffec978bf.webp

①接口

首先是模块之间通信接口的实现,这里单独抽出一个模块interface,后面接口的不同实现模块可以都依赖同一个接口模块。

接口里面就是一个简单的方法:

package com.example;

public interface Display {

    String display();

}

②模块实现

接下来就是用不同的模块实现接口,首先需要在模块的build.gradle中加入接口的依赖:

dependencies {

    compile fileTree(include: ['*.jar'], dir: 'libs')

    compile project(':interface')

}

然后写一个简单的实现类实现接口Display。adisplay模块的实现类就是ADisplay.java:

package com.example;

public class ADispaly implements Display{

    @Override

    public String display() {

        return "This is display in module adisplay";

    }

}

bdisplay模块的实现类就是BDisplay.java:

package com.example;

public class BDisplay implements Display{

    @Override

    public String display() {

        return "This is display in module bdisplay";

    }

}

然后要把这些接口实现类注册到配置文件中,SPI的机制就是注册到META-INF/services中。首先在java的同级目录中new一个包目录resources,然后在resources新建一个目录META-INF/services,再新建一个file,file的名称就是接口的全限定名,在该例子中就是:com.example.Display,文件中的内容就是不同实现类的全限定名,不同实现类分别一行。

adisplay模块最后的工程结构如下图所示。文件com.example.Display中的内容就是ADispaly实现类的全限定名com.example.ADispaly。

2b5478750df8459799c35e8ea469d0ad.webp

bdisplay模块的工程结构和上图类似,文件com.example.Display中的内容就是BDisplay实现类的全限定名com.example.BDisplay。

③加载不同服务

当然在主程序模块中也可以有自己的接口实现:

package com.example.spidemo;

import com.example.Display;

public class DisplayImpl implements Display {

    @Override

    public String display() {

        return "This is display in module app";

    }

}

在配置文件com.example.Display中的内容就是com.example.juexingzhe.spidemo.DisplayImpl。

在界面上放置一个按钮,点击按钮会加载所有模块配置文件中的实现类:

mButton.setOnClickListener(new View.OnClickListener() {

        @Override

        public void onClick(View v) {

            loadModule();

       }

});

关键的代码其实就是下面三行,通过ServiceLoader来加载接口的不同实现类,然后会得到迭代器,在迭代器中可以拿到不同实现类全限定名,然后通过反射动态加载实例就可以调用display方法了。

ServiceLoader<Display> loader = ServiceLoader.load(Display.class);

mIterator = loader.iterator();

while (mIterator.hasNext()){

      mIterator.next().display();

}

注意:这种方法在平常组件化开发中非常便利,但是每次都需要到/META-INF/services目录建立文件,不能动态添加。因此可以采用Google的@AutoService,它可以在编译的时候动态生成这些东西。ServiceLoader + @AutoService的使用方法如下:

①添加AutoService依赖

implementation 'com.google.auto.service:auto-service:1.0'

annotationProcessor 'com.google.auto.service:auto-service:1.0'

②接口module不需要变,只需要在实现类进行改变一下即可:

@AutoService(Display.class)

public class ADispaly implements Display{

    @Override

    public String display() {

        return "This is display in module adisplay";

    }

}

只需要在具体的实现类上面加上一个@AutoService注解,参数则为接口的class类。

③最后在App模块中调用

ServiceLoader<Display> loader = ServiceLoader.load(Display.class);

mIterator = loader.iterator();

while (mIterator.hasNext()){

      mIterator.next().display();

}

注意:由于组件隔离了,其他模块除了依赖基础base库,是不能调用主模块和其他业务模块的。而SPI可以实现业务模块调用主模块的功能。在其他模块调用主模块:

ServiceLoader<Display> loader = ServiceLoader.load(Display.class);

Iterator<Display> mIterator = loader.iterator();

while (mIterator.hasNext()){

    Display next = mIterator.next();

    if(next.getClass().getSimpleName().equals( "DisplayImpl")) {

        mIterator.next().display();

    }

}

这样就走了app模块里的方法了,实现了跨组件通信。

 

3.源码分析

主要工作都是在ServiceLoader类中,这个类在java.util包中。ServiceLoader是一个简单的服务提供者加载工具,先看下几个重要的成员变量:

public final class ServiceLoader<S> implements Iterable<S> { //S 范型,就是指定的接口,实现了迭代器接口

    private static final String PREFIX = "META-INF/services/"; //PREFIX是配置文件所在的包目录路径

    private Class<S> service; //service是接口名称,在上面的例子中就是Display

    private ClassLoader loader; //loader是类加载器,其实最终都是通过反射加载实例

    private LinkedHashMap<String,S> providers = new LinkedHashMap<>(); //providers是不同实现类的缓存,key是实现类的全限定名,value是实现类的实例

    private LazyIterator lookupIterator; //lookupIterator是懒加载的迭代器,是内部类LazyIterator的实例

}

使用SPI的三个关键步骤:

ServiceLoader<Display> loader = ServiceLoader.load(Display.class);

mIterator = loader.iterator();

while (mIterator.hasNext()) {

    mIterator.next().display();

}

①第一个步骤ServiceLoader.load()

ServiceLoader提供了两个静态的load方法,如果没有传入类加载器,ServiceLoader会自动获得一个当前线程的类加载器,最终都是调用构造函数。

public static <S> ServiceLoader<S> load(Class<S> service) {

    ClassLoader cl = Thread.currentThread().ge tContextClassLoader();

    return ServiceLoader.load(service, cl);

}

public static <S> ServiceLoader<S> load( Class<S> service,ClassLoader loader) {

    return new ServiceLoader<>(service, loader);

}

在构造函数中工作很简单,就是清除实现类的缓存,实例化迭代器。

private ServiceLoader(Class<S> svc, ClassLoader cl) {

    service = svc;

    loader = cl;

    reload();

}

public void reload() {

    providers.clear();

    lookupIterator = new LazyIterator(service, loader);

}

private LazyIterator(Class<S> service, ClassLoader loader) {

    this.service = service;

    this.loader = loader;

}

其实ServiceLoader.load(Display.class)方法只是创建了LazyIterator、ServiceLoader和ClassLoader,并没有加载service provider,也就是懒加载的设计模式,这也是Java SPI的设计亮点。

那么service provider在什么地方进行加载?接着看第二个步骤loader.iterator(),其实就是返回一个迭代器。

②第二个步骤loader.iterator()

这个就是懒加载实现的地方,首先会到providers中去查找有没有存在的实例,有就直接返回,没有再到LazyIterator中查找。

public Iterator<S> iterator() {

    return new Iterator<S>() {

        Iterator<Map.Entry<String,S>> knownProviders = providers.entrySet().iterator(); //providers就是开始定义的不同接口实现类的缓存,获取到linkedhashmap的迭代器了

        public boolean hasNext() {

            if (knownProviders.hasNext())

                return true;

            return lookupIterator.hasNext();

        }

        public S next() {

            if (knownProviders.hasNext())

                return knownProviders.next().getValue();

            return lookupIterator.next();

        }

        public void remove() {

            throw new UnsupportedOperationException();

        }

    };

}

上面hasNext、next、remove的实现主要依赖knownProviders的实现,但从定义就知道他只是个缓存工具,具体还是要看lookupIterator的实现。

在hasNext()方法中,一开始knownProviders中是没有缓存实例的,knownProviders.hasNext()会返回false的,走lookupIterator.hasNext()方法,即会到LazyIterator中查找,去看看LazyIterator,先看下它的hasNext()方法:

public boolean hasNext() {

    return hasNextService();

}

private boolean hasNextService() {

    if (nextName != null) { //nextName定义的k-v

        return true;

    }

    if (configs == null) { //是一个URL集合

        try {

            String fullName = PREFIX + service.getName(); //service就是传进来的接口的Class对象,fullName = META-INF/services/ + 接口全路径,所以定义的时候就是按照上面格式定义的文件                 

            if (loader == null)

                configs = ClassLoader.getSystemResources(fullName);

            else

                configs = loader.getResources( fullName);

        } catch (IOException x) {

            fail(service, "Error locating configuration files", x);

        }

    }

    //这个循环条件中pending是待办的拦截器,第一次为null

    while ((pending == null) || !pending.hasNext()) {

        if (!configs.hasMoreElements()) {

            return false;

        }

        pending = parse(service, configs.nextElement()); //parse函数会返回String类型集合的迭代器,实际操作就是使用BufferedReader读取fullName配置文件里面的内容,这个配置文件是合并后的,包含所有模块下的fullName里面的内容,也就是实现接口类的实现类的全路径类名。配置文件千万不能写错,因为后面要用到反射             

    }

    nextName = pending.next(); //pending会返回当前fullName对应的全路径包名字符串 

    return true;

}

首先拿到配置文件名fullName,上面的例子中是com.example.Display。然后通过类加载器获得所有模块的配置文件configs。接着依次扫描每个配置文件的内容,返回配置文件内容Iterator<String> pending,每个配置文件中可能有多个实现类的全限定名,所以pending也是个迭代器。

总结下hasNext方法的操作,就是根据全路径文件名,打开一个io流,读取里面配置,就是实现接口的实现类的全路径,返回一个包含全路径类名的String类型迭代器,迭代器存在值就返回true,并定义了nextName的值,方便nextService方法的调用。

在hasNext()方法中拿到的nextName就是实现类的全限定名,接下来看具体实例化工作的地方,即LazyIterator的next()方法:

public S next() {

    return nextService();

}

private S nextService() {

    if (!hasNextService()) {

        throw new NoSuchElementException();

    }

    String cn = nextName; //拿到hasNextService找到的实现类路径

    nextName = null; //再清空,方便下次处理

    Class<?> c = null;

    try {

        c = Class.forName(cn, false, loader); //根据全路径反射获取Class

    } catch (ClassNotFoundException x) {

        fail(service, "Provider " + cn + " not found", x);

    }

    try {

        S p = service.cast(c.newInstance()); //调用newInstance创建实例

        providers.put(cn, p); //放入缓存 

        return p;

    } catch (Throwable x) {

        fail(service, "Provider " + cn + " could not be instantiated: " + x, x);

    }

    throw new Error(); // This cannot happen

}

首先根据nextName,通过Class.forName加载拿到具体实现类的class对象。然后通过Class.newInstance()实例化拿到具体实现类的实例对象。接着将实例对象通过service.cast转化为service接口。并通过providers.put(cn, p)将实例对象放到缓存中,其中key是实现类的全限定名,value是实例对象。最后返回实例对象。

这里用到的主要思想其实就是懒加载的思想。通过LazyIterator类获取META-INF/services/目录下接口对应的文件,并读取里面的继承类名,然后通过类实例化返回,最终就可以获取到接口对应的实现的子类了。

有一点可能不理解,为啥能读到不同模块下配置的路径名,其实在app运行是会有合并操作的,各模块下根据路径合并的。这里分析apk文件可以看出:

a102bbd6b893404fa03365831c080abc.png

 

4.SPI机制的优缺点

①优点

SPI只提供服务接口,具体服务由其他组件实现,接口和具体实现分离,同时能够通过系统的ServiceLoader得到这些实现类的集合,统一处理。

SPI机制可以实现不同模块之间方便的面向接口编程,拒绝了硬编码的方式,解耦效果很好。用起来也简单,只需要在目录META-INF/services中配置实现类就行。源码中也用来了懒加载的思想,开发中可以借鉴。

②缺点

通过Java的SPI机制有一个缺点就是在运行时通过反射加载类实例,这个对性能会有点影响。

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/687773.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

kafka常见问题

1.为什么要用mq&#xff08;mq的作用&#xff09;&#xff1f; 2.引入mq会多哪些问题&#xff1f; 3. 如何解决这些问题&#xff1f; 1.1实现异步发送 有些复杂的业务系统&#xff0c;一次用户请求可能会同步调用N个系统的接口&#xff0c;需要等待所有的接口都返回了&#…

虹科分享 | 高考大数据可视化志愿填报分析-基于虹科Domo BI工具

高考是中国教育系统中一项极为重要的考试&#xff0c;它不仅是学生完成高中学业的重要标志&#xff0c;也是进入大学的门槛。每年高考都会吸引数百万学生参加&#xff0c;同时也吸引了各地高校和招生部门的关注。高考招生数据是教育研究和政策制定的重要依据&#xff0c;通过对…

技术管理第二板斧建团队-知人善用

1、什么是知人善用 知人善用就是指技术 Leader 怎么用对人&#xff1f;用好人&#xff1f;核心在于怎么给事情安排对的人&#xff1f;怎么给人安排合适的事情&#xff1f;其中&#xff0c;“人”与“事”相辅相成&#xff0c;如果把事情安排给对的人&#xff0c;不光会取得好结…

干货丨如何实现WinApp的UI自动化测试?自动化工具如何选择人?

WinApp&#xff08;WindowsAPP&#xff09;是运行在Windows操作系统上的应用程序&#xff0c;通常会提供一个可视的界面&#xff0c;用于和用户交互。例如运行在Windows系统上的Microsoft Office、PyCharm、Visual Studio Code、Chrome&#xff0c;都属于WinApp。常见的WinApp&…

Arduino IDE 2.1.0 下安装ESP32(2.0.9)

很久没玩Arduino了。新装了一台电脑&#xff0c;想重新捡起ESP32-WROOM-32开发板玩玩。官网上下了Arduino IDE 2.1.0&#xff0c;然后配置ESP32开发环境。 下载及安装Arduino IDE略过不谈。装完后还是老规矩&#xff0c;文件 -> 首选项&#xff0c;先把自定义板管理地址填入…

好程序员:2023年自学Java四阶段学习法,真滴好用麻啦!

同学们&#xff0c;我是好程序员小源&#xff0c;今天给大家整理了自学Java的四个阶段&#xff0c;大家可以按照这四个阶段学习哦~会更加规划系统一点&#xff01; 第一阶段: JavaSE[5周] 本阶段从零基础起步&#xff0c;荃面深入的学系JavaSE课程&#xff0c;主要内容包括Java…

支付“清结算”体系的设计方法

支付完成以后进行履约&#xff0c;履约完成以后就需要清算各方利益并最终进行结算&#xff0c;清结算体系与支付体系并行是支付范畴另一个非常庞大的体系。 一、清算系统设计 我们都知道一笔支付最终都是要进行清算的&#xff0c;业务一般都会有众多参与者或者利益方&#xff…

ESP32网络应用 -- ESP32-S3使用MQTT协议与其他设备进行数据交互

在嵌入式物联网技术领域,MQTT(Message Queuing Telemetry Transport,消息队列遥测传输)协议是一种非常常见且应用广泛的消息协议,它基于发布/订阅范式进行数据传输。关于MQTT协议的详细介绍,网络上不乏相关文章,此处不再进行详细论述。 ESP32-S3是一款应用广泛的物联网…

WPF实现登录页面设计

1、文件架构 2、CommandBase.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Input;namespace CourseManagement.Common {public class CommandBase : ICommand{public ev…

EXCEL和VBA如何改变字母大小写 和 大小写互换?我写的自定义函数

目录 1 EXCEL里改变大小写的内置函数 2.1 转换大小写的函数 2.2 神奇的把数字和中文大小写转换的函数 2 VBA里改变大小写的内置函数 2.1 改变大小写 的内置函数 2.2 使用 excel的WorksheetFunction. text() 函数 3 如果想交换字母的大小写呢&#xff1f; 3.1 ASCII码里…

Java Servlet 技术

一、Servlet 简介 Servlet 是 JavaEE 的规范之一&#xff0c;通俗的来说就是 Java 接口&#xff0c;将来我们可以定义 Java 类来实现这个接口&#xff0c;并由 Web 服务器运行 Servlet &#xff0c;所以 TomCat 又被称作 Servlet 容器。 Servlet 提供了动态 Web 资源开发技术…

偷偷爆料下工资特别高的8个开发岗。。。。。

外国网站 devjobsscanner 统计了全年需求量大的8种编程语言&#xff0c;基本上薪资很高的&#xff0c;也就是这几个方向了。 对于跳槽、找工作、转行、转语言等&#xff0c;都有一定的参考意义。 接下来结合网站统计和招聘网站的数据&#xff0c;可以做一个对照。 NO.1 Java…

MongoDB的基本操作

MongoDB的基本操作 MongoDB MongoDB是一个基于分布式文件存储的数据库&#xff0c;由C语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB是一个介于关系数据库和非关系数据库之间的产品&#xff0c;是非关系数据库当中功能最丰富&#xff0c;最像关系数…

游泳带什么防水耳机好,最佳游泳耳机的推荐排行榜

在炎炎夏日&#xff0c;玩水无疑是降温的最佳方式。既可以在室内游泳馆通过游泳锻炼身体&#xff0c;也可以到海滨浴场享受游泳和日光浴的乐趣。因此&#xff0c;选购一款适合水上活动的游泳耳机变得尤为重要。音乐的力量可以让原本单调乏味的游泳运动变得更具活力&#xff0c;…

Linux基础服务4——ftp

文章目录 一、基本了解1.1 C/S型架构1.2 数据连接模式1.3 用户认证 二、安装服务端2.1 安装vsftpd2.2 配置文件2.3 主配置文件参数2.4 windows访问服务端2.4.1 系统用户访问2.4.2 匿名用户访问2.4.2 开启客户端上传权限2.4.3 开启客户端其他权限2.4.4 开启客户端删除、修改权限…

hvv 文件上传和文件包含考点

天眼如何判断文件上传漏洞是否成功 数据包分析 观察客户端请求数据&#xff1a;是否包含webshell流量特征观察服务器返回信息&#xff1a;是否有“上传成功”或“success upload”等信息提示 尝试寻找上传的文件&#xff1a;访问上传的文件看是否存在&#xff1b;查看文件上传…

Redisson分布式锁-源码分析

Redisson分布式锁整体流程图 Redisson分布式锁源码流程图 Redisson分布式锁源码解析 获取分布式锁lock private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {//获取当前线程IDlong threadId Thread.currentThread().get…

参与 2023 第二季度官方 Flutter 开发者调查

Flutter 3.10 已经正式发布&#xff0c;每个季度一次的 Flutter 开发者调查也来啦&#xff01;邀请社区的各位成员们填写&#xff1a; 调研旨在了解你对 Flutter 的满意程度以及对其各个子系统的反馈。你的意见将对我们改进 Flutter 的功能和性能产生重要影响。 在这次调研中&a…

Linux——软硬链接的理解

目录 那什么是链接&#xff1f; 链接命令的生成&#xff1a; 实验案例&#xff1a; 硬链接概念&#xff1a; 软链接概念&#xff1a; 情况1&#xff1a;删除myfile.txt&#xff1a; 情况2&#xff1a;重新创建一个新的myfile.txt文件&#xff1a; 软链接作用&#xff1…

推特引流:社交引流的技巧与方法

推特是一个广泛使用的社交媒体平台&#xff0c;可以用于引流和推广您的品牌、产品或服务。以下是一些社交引流的技巧和方法&#xff0c;可以帮助您在推特上获得更多的关注和流量&#xff1a; 优化个人资料&#xff1a;确保您的推特个人资料完整并具有吸引力。包括一个清晰的头…