Android-模块化通信-简单实用的android spi机制

最新推荐文章于 2024-01-14 23:27:57 发布
最新推荐文章于 2024-01-14 23:27:57 发布
阅读量1w 收藏 5
点赞数 1
分类专栏： Android 文章标签： android 组件化 模块化通信 spi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDNno/article/details/123830502
版权

目录

前言

为了实现Android-模块化通信-需要一套简单实用的android spi机制。

一、spi是什么？

SPI即 Service Provider Interface，它是为接口提供寻找实现服务类，类似IOC的思想。

二、ServiceLoader

java中的spi, ServiceLoader尤为重要, 抛开注解生成代码和Transform注册

  • load 可以使用map实现，需要Class<T> baseClass,String servicePath构建返回约束和访问参数
  • register 项目经常需要一些全局唯一的Service以及使用时创建Service,注册参数有 path 索引唯一路径，interfaceClass 接口类,obj 单实例/实例/惰性

·简单实现代码如下·

1.ExportTableLoader

/**
 * 作用描述: 导出表加载程序接口
 * 组件描述: #基础组件 #组件名 （子组件）
 * 组件版本: v1
 * 创建人 rentl
 * 创建日期 2022/2/4 21:23
 * 修改日期 2022/2/4 21:23
 */
public interface ExportTableLoader {

    /**
     * 输出
     *
     * @param exporter
     * @implNote {@link ExportTable#initTables(cn.mashang.export_table_java.ExportTableLoader[])}
     */
    void export(ExportTable.Exporter exporter);
}

2.ExportTable


/**
 * 作用描述: 导出表
 * 组件描述: #基础组件 #组件名 （子组件）
 * 组件版本: v1
 * 创建人 rentl
 * 创建日期 2022/2/4 21:21
 * 修改日期 2022/2/4 21:21
 */
public final class ExportTable {
    /**
     * 服务列表map
     */
    final static Map<Class<?>, List<Object>> serviceListMap = new HashMap<>();
    /**
     * 新服务地图
     */
    final static Map<String, Object> newServiceMap = new HashMap<>();
    /**
     * 单例服务图
     */
    final static Map<String, Object> singletonServiceMap = new HashMap<>();

    private static ExportTableLoader[] tables = null;
    private static final ExportTable.Exporter exporter = new ExportTable.Exporter();

    private ExportTable() {
    }

    public static void initTables(ExportTableLoader[] tables) {
        ExportTable.tables = tables;
        init();
    }

    public static Exporter getExporter() {
        return exporter;
    }

    private static void init() {
        if (tables == null) {
            return;
        }
        for (ExportTableLoader table : tables) {
            if (table == null) {
                continue;
            }
            table.export(exporter);
        }
    }

    /**
     * 导出表 出口商
     */
    public final static class Exporter {
        Exporter() {
        }

        /**
         * 将单个实例放入路线图
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param proxyObj       单实例代理对象
         */
        private void putSingletonToRoadMap(final String path, @SuppressWarnings("rawtypes") final Class interfaceClass, final Object proxyObj) {
            if (path == null || path.isEmpty()) {
                throw new IllegalArgumentException("putSingleInstance args: path is null");
            }
            if (proxyObj == null) {
                throw new IllegalArgumentException("putSingleInstance args: proxyObj is null");
            }
            if (singletonServiceMap.containsKey(path)) {
                throw new UnsupportedOperationException("putSingleInstance args: path is exist");
            }
            if (singletonServiceMap.containsValue(proxyObj)) {
                throw new UnsupportedOperationException("putSingleInstance args: proxyObj is exist");
            }
            singletonServiceMap.put(path, proxyObj);

            //all
            List<Object> objects = serviceListMap.get(interfaceClass);
            //noinspection Java8MapApi
            if (objects == null) {
                objects = new ArrayList<>();
                serviceListMap.put(interfaceClass, objects);
            }
            objects.add(proxyObj);
        }

        /**
         * 设置单实例
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param obj            单实例
         */
        public <T> void setSingleton(final String path, final Class<T> interfaceClass, final T obj) {
            putSingletonToRoadMap(path, interfaceClass, obj);
        }

        /**
         * 使用惰性设置单实例
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param obj            单实例
         * @param <T>            泛型类
         */
        public <T> void setSingletonByLazy(final String path, final Class<T> interfaceClass, final LazyLoader<T> obj) {
            putSingletonToRoadMap(path, interfaceClass, obj);
        }


        /**
         * 将新实例放入路线图 （全局）
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param proxyObj       单实例代理对象
         */
        private void putNewInstanceToRoadMap(final String path, @SuppressWarnings("rawtypes") final Class interfaceClass, final Object proxyObj) {
            if (path == null || path.isEmpty()) {
                throw new IllegalArgumentException("setNewInstance args: path is null");
            }
            if (proxyObj == null) {
                throw new IllegalArgumentException("setNewInstance args: proxyObj is null");
            }
            if (newServiceMap.containsKey(path)) {
                throw new UnsupportedOperationException("setNewInstance args: path is exist");
            }
            if (newServiceMap.containsValue(proxyObj)) {
                throw new UnsupportedOperationException("setNewInstance args: proxyObj is exist");
            }
            newServiceMap.put(path, proxyObj);

            //all
            List<Object> objects = serviceListMap.get(interfaceClass);
            //noinspection Java8MapApi
            if (objects == null) {
                objects = new ArrayList<>();
                serviceListMap.put(interfaceClass, objects);
            }
            objects.add(proxyObj);
        }

        /**
         * 设置对象实例惰性创建（推荐）
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param obj            单实例
         * @param <T>            泛型类
         */
        public <T> void setNewInstanceByLazy(final String path, final Class<T> interfaceClass, final LazyLoader<T> obj) {
            putNewInstanceToRoadMap(path, interfaceClass, obj);
        }

        /**
         * 设置对象实例反射创建（不推荐）
         *
         * @param path           索引唯一路径
         * @param interfaceClass 接口类
         * @param implementClass 单实例
         * @param <T>            泛型类
         */
        public <T> void setNewInstanceClass(final String path, final Class<T> interfaceClass, final Class<T> implementClass) {
            putNewInstanceToRoadMap(path, interfaceClass, implementClass);
        }

    }
}

3.LazyLoader

/**
 * 作用描述: 懒加载程序
 * 组件描述: #基础组件 #组件名 （子组件）
 * 组件版本: v1
 * 创建人 rentl
 * 创建日期 2022/2/8 15:02
 * 修改日期 2022/2/8 15:02
 */
public class LazyLoader<T> {
    private final Object lock = new Object();
    private final Supplier<T> initializer;
    private volatile T value;

    public LazyLoader(Supplier<T> initializer) {
        this.initializer = initializer;
    }

    /**
     * 直接创建value
     */
    public T createValue() {
        return initializer.get();
    }

    /**
     * 获取value，如果null则创建
     */
    public T getValue() {
        if (value == null) {
            synchronized (lock) {
                if (value == null) {
                    value = initializer.get();
                }
            }
        }
        return value;
    }

    public boolean isCreated() {
        return value != null;
    }
}

4.ServiceLoader<T>

package cn.mashang.export_table_java;

import java.util.ArrayList;
import java.util.List;

/**
 * 作用描述: 服务加载程序
 * 组件描述: #基础组件 #组件名 （子组件）
 * 组件版本: v1
 * 创建人 rentl
 * 创建日期 2022/2/8 20:12
 * 修改日期 2022/2/8 20:12
 */
public final class ServiceLoader<T> {

    private final Class<T> serviceBaseClass;
    private final String serviceName;

    public static <T> ServiceLoader<T> build(Class<T> baseClass) {
        if (baseClass == null) {
            throw new RuntimeException("ServiceLoader baseClass class can't be null");
        }
        return new ServiceLoader<>(baseClass);
    }

    private ServiceLoader(Class<T> serviceBaseClass) {
        this.serviceBaseClass = serviceBaseClass;
        this.serviceName = serviceBaseClass.getName();
    }

    /**
     * 获取所有服务
     */
    public List<T> getAllService() {
        List<Object> objects = ExportTable.serviceListMap.get(serviceBaseClass);
        List<T> tList = new ArrayList<>();
        if (objects != null && !objects.isEmpty()) {
            for (Object object : objects) {
                if (object instanceof LazyLoader) {
                    Object value = ((LazyLoader) object).getValue();
                    try {
                        tList.add((T) value);
                    } catch (ClassCastException e) {
                        e.printStackTrace();
                    }
                    continue;
                }
                try {
                    tList.add((T) object);
                } catch (ClassCastException e) {
                    e.printStackTrace();
                }
            }
        }
        return tList;
    }

    /**
     * 获取单实例
     *
     * @return <T>
     */
    public T getSingletonService(final String servicePath) {
        if (servicePath == null || servicePath.isEmpty()) {
            throw new IllegalArgumentException("getSingleInstance args: path is null");
        }
        try {
            Object o = ExportTable.singletonServiceMap.get(servicePath);
            if (o instanceof LazyLoader) {
                return (T) ((LazyLoader<?>) o).createValue();
            }
            return (T) o;
        } catch (ClassCastException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 新实例
     *
     * @param servicePath
     */
    public T newInstance(final String servicePath) {
        if (servicePath == null || servicePath.isEmpty()) {
            throw new IllegalArgumentException("newInstance args: path is null");
        }
        final Object o = ExportTable.newServiceMap.get(servicePath);
        if (o instanceof LazyLoader) {
            try {
                return (T) ((LazyLoader<?>) o).createValue();
            } catch (ClassCastException e) {
                e.printStackTrace();
            }
        }
        try {
            return (T) o.getClass().getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

三、应用

lib_arouter

/**
 * 作用描述: ARouter应用程序生命周期
 * 组件描述:
 * 创建人 rentl
 * 创建日期 2022/2/9
 * 修改日期 2022/2/9
 */
public class ARouterApplicationLifeCycle extends BaseApplicationLifeCycle {

    public ARouterApplicationLifeCycle(int initOrder) {
        super(initOrder);
    }

    @Override
    public void onCreate() {
        if (ProcessHelper.isMainProcess()) { //根据需要
            ARouterApp.initARouter(BaseAndroid.StaticCall.sApplication);
        }
    }
}

public class LibOkHttpExportTable implements ExportTableLoader {

    @Override
    public void export(ExportTable.Exporter exporter) {
        exporter.setSingleton(TableConstants.Path.OkhttpApplicationLifeCycle, ApplicationLifeCycle.class, new OkhttpApplicationLifeCycle(999));
    }
}

public class LibARouterExportTable implements ExportTableLoader {
    @Override
    public void export(ExportTable.Exporter exporter) {
        exporter.setSingleton(TableConstants.Path.ARouterApplicationLifeCycle, ApplicationLifeCycle.class, new ARouterApplicationLifeCycle(1000));
    }
}

lib_okhttp

public class OkhttpApplicationLifeCycle extends BaseApplicationLifeCycle {
}

lib_baseAndroid

public class BaseAndroidApplication extends Application {
  @Override
    protected void attachBaseContext(Context base) {
    uper.attachBaseContext(base);
        MultiDex.install(this);
        BaseAndroid.installRun(this);
        List<ApplicationLifeCycle> allService = ServiceLoader.build(ApplicationLifeCycle.class).getAllService();
        Collections.sort(allService, (o1, o2) -> Integer.compare(o2.getInitOrder(), o1.getInitOrder()));
        mApplicationLifeCycles = allService;
        for (ApplicationLifeCycle applicationLifeCycle : mApplicationLifeCycles) {
            applicationLifeCycle.onBaseContextAttached(base);
        }
    }
}

app

public final class AppExtTable implements ExportTableLoader {

    public static void init() {
        ExportTable.initTables(new ExportTableLoader[]{
                new AppExtTable(),
                new LibOkHttpExportTable(),
                new LibARouterExportTable(),
                //动态集成模块table可以用反射
        });
    }

    @Override
    public void export(ExportTable.Exporter exporter) {
        ExportTable.getExporter().setSingleton(TableConstants.ConstantsPath.APP_BUILD_COMPUTER_TIME, long.class, BuildEvn.BUILD_COMPUTER_TIME);
    }
}

注册ExportTableLoader 相关类可以通过gradle 分配一个文件夹
baseAndroid.gradle

android {
    sourceSets {
        main {
            if (export_table) {
                def export_table_src_dir = 'src/export_table' //java代码文件夹
                if (hasAppPlugin) {
                    //默认包目录
                    def javaFiles = new File(projectDir, "$export_table_src_dir/cn/mashang/export_table")
                    if (!javaFiles.exists()) {
                        javaFiles.mkdirs()
                    }
                }
                java.srcDir(project.file(export_table_src_dir))
            }
        }
    }
}

在这里插入图片描述

四、总结

例如：以上就是简单实用的android spi机制。

ExtraLazy
关注
专栏目录
Android组件模块间解耦及通信轻量级实现方案
pangrui201的专栏
08-01 1519
Android组件模块间解耦及通信轻量级实现方案。随着Android APP业务需求的不断迭代，业务功能越来越多，代码量也越来越多，组件间难免会因为方法功能调用页面访问等场景存在相互访问依赖耦合。为此，探索一种可行方案彻底解决组件模块间耦合同时还能满足组件间相互通信访问显得十分必要。经过不断努力探索调研结合过去工作经验项目总结推出本方案。.........
Android模块化之组件间通信
weixin_40929353的博客
07-31 601
结构描述部分 Android组件化的文章网上一搜一大推，基本上大同小异，在这里我就不再细说了。今天我主要是将我之前根据微信的架构思路的重构经验做个记录（微信Android模块化架构重构实践），这里我也主要是说组件间通信。 先讲一下我的重构目标：按照大方向的业务功能分模块，我想让我的app是由多个独立的小系统似的组成，系统间不共用业务代码完全解耦。比如我的app有主页、发现、我的三个业务模块（这...
Android Things——SPI通信
tangjianing的博客
09-09 1620
1 SPI 1.1 概念 SPI是串行外设接口（Serial Peripheral Interface）的缩写，SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便。SPI的原理以及通信过程不是本文要研究的内容，如有兴趣可以自行查找资料。 1.2 特性 （1）SPI总线是一种同步的串行接口： SPI是属于串行通信的一种，这就意味着SPI依赖于共享的时钟信号来同步设备之间的数据传输。控制时钟信号的设备被称为Master。其它所有
安卓 模块化通信SPI
qq_33624695的博客
03-19 302
通过SPI技术去实现的解耦合工作的出色工程还有很多很多，比如我们用的APT，还有didi开源的Booster，都有用到这方面的知识。
Android中的SPI实现
最新发布
虎哥LoveDroid
01-14 1564
SPI是JVM世界中的标准API，但在Android应用程序中并不常用。然而，它可以非常有用地实现插件架构。让我们探讨一下如何在Android中利用SPI。
Android SPI
zenmela2011的专栏
06-26 655
总结下hasNext方法的操作，就是根据全路径文件名，打开一个io流，读取里面配置，就是实现接口的实现类的全路径，返回一个包含全路径类名的String类型迭代器，迭代器存在值就返回true，并定义了nextName的值，方便nextService方法的调用。SPI在模块开发中会比较有用，不同的模块可以基于接口编程，每个模块有不同的接口实现类，然后通过SPI机制自动注册到一个配置文件中，就可以实现在程序运行时扫描加载同一接口的不同实现类，从而实现跨模块通信。源码中也用来了懒加载的思想，开发中可以借鉴。
android 初识SPI
HUandroid的博客
03-22 668
android 初识SPI SPI全名是Service Provide Interface 官方解释：为某个接口提供服务的机制。 由ServiceLoader通过加载接口类或者抽象类，再通过模块的配置文件，以此扫描获取到多个实现类的全限定名后通过反射操作获取实例来跨模块通信。 官方文档：https://docs.oracle.com/javase/6/docs/api/java/util/ServiceLoader.html 使用 这里的使用仅仅对于android方向的 android组件化通信可以使用SP
Android设备 Spi协议 通信
10-19
在Android系统中，SPI（Serial Peripheral Interface）是一种广泛使用的串行通信协议，它允许设备之间进行全双工数据传输。SPI协议通常用于连接微控制器、传感器、存储器和其他外设，其灵活性和高速特性使其在...
spi,Android组件化的SPI。.zip
09-25
在Android系统中，虽然没有直接使用Java SPI，但Android的组件化思想与SPI有相似之处，尤其是在构建可扩展、模块化的应用程序时。本文将深入探讨Android组件化的SPI概念，并基于提供的"spi,Android组件化的SPI。.zip...
Android 组件化开发module间通信
11-12
module间Activity相互启动，传值方面直接看activityrouter官方文档https://github.com/mzule/ActivityRouter
Android代码-Andromeda简化了Android模块化的本地远程通信
08-06
Andromeda Andromeda provides communication among modules for both local and remote service. Anno:The reason that differentiate local service from remote service is that parameter types in remote service can only be primitive type or custom type that implements Parcelable, while parameter types in local service can be any type such as View and Context. 文档，还是中文好 Features Aidl interface and implemention are the only thing developers need do. bindService() and Service definition are not necessa
android spi 简书,SPI
weixin_42468413的博客
06-03 253
背景最近看到了SPI这个东西，搜了几篇文章有了大概的认识，在这里记录一下。简介SPI(Service Provider Interface)，是JDK内置的一种 服务提供发现机制，可以用来替换不同的实现，Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是 解耦。使用场景其实SPI已经接触过很多次了，只是自己之前没有注意过。JDBC就是使用了SP...
login组件的两种用法_Android-模块化、组件化、插件化、热修复-组件化-组件间的通信(本地，下沉，bus，路由)...
weixin_39622988的博客
12-04 235
延续上一篇 MonkeyLei：Android-模块化、组件化、插件化、热修复-组件化工程构建+页面路由多种方式实践 ，我们进行搞下组件之间的通信。比如登录成功后怎么通知其他页面刷新： 方式可能有很多，列举几种：sharedpreferences，这种适合一些长期本地存储的值（比如用户登录账号信息） basemodule里面新建一个公共数据类，存储全局数据，临时通信时使用，提供set/get方...
在Android上实现SPI通信之(1)------在Ubuntu12.04环境下编译android源码
u011514076的专栏
05-22 1069
在Android上实现SPI通信之(1)——在Ubuntu12.4环境下编译android源码作为一个Android应用开发者，突然接到一下需求，需要在应用层传递一个信号到外设，传递方式用SPI通信，没有做过，甚是头大，遇到了好多坑，所以记录成册，希望对后来的开发者，有那么一点点的帮助，如果有不正确的地方，还请指正。目前我实现的大体思路是： 应用层传递一个数据到JNI层 JNI层传递一个数据到HAL
Android中SPI的使用
王三的专栏
05-10 9434
SPI全称是Service Provider Interface，服务提供方接口，服务通常是指一个接口或者一个抽象类，服务提供方是对这个接口或者抽象类的具体实现，由第三方来实现接口提供具体的服务。SPI提供了一种动态的对应用程序进行扩展的机制，通常用作框架服务的拓展或者可替换的服务组件，但是在Android中并没有广泛的使用。
SPI原理以及SPI在Android中的实战
SOHU_TECH的博客
09-22 1285
本文字数：13862字预计阅读时间：35分钟1、前言在开题之前大家有没有这个疑惑，就是随着业务的不断发展和壮大，我们的工程结构以及代码量越来越大，交织在一起，你中有我，我 中有你，导致项目结构分工不是很明确，职责不清晰，如果线上有紧急问题需要排查的时候，我们可能就手忙脚忙了，有时候也不知道问题出现在哪个模块，导致问题排查效率低下,同时不利于项目复盘和明确职责,又或者老板想看下业务成功率，服务成...
Android 模块化之 模块间通信 完整解决之道
Java和Android架构
06-11 3047
热文导读|点击标题阅读互联网寒冬下，程序员如何突围提升自己？移动APP质量优化框架 - Booster“37岁，年薪50万，一夜被裁”：伪上班，毁掉了多少中国年轻人...
android spi 简书,SPI协议
weixin_39636707的博客
06-03 572
SPI的定义SPI 是串行外设接口的英文缩写，是一种高速全双工通信总线。简单易用，最主要的是占用的管脚数量少，一般为4。SPI基本概念首先，介绍SPI通信中重要的四根线，分别是：CS，CLK，SDI， SDO，按照我个人理解的含义如下：CS：片选标识，用来确定数据有效性；CLK：时钟，越快读写也就越快；SDI：数据输入端口；SDO：数据输出端口。这里也写一下比较官方的解释：CS – 从设备使能信号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值