Android组件间通信

最新推荐文章于 2024-04-21 02:12:29 发布
最新推荐文章于 2024-04-21 02:12:29 发布
阅读量2.0k 收藏 8
点赞数 1
分类专栏： 组件化 文章标签： 组件化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyhlmy/article/details/102907054
版权

Android组件间通信

组件间通信是什么

我们通常把一个module认为是一个组件，组件间通信是两个不存在依赖关系的module间进行通信的方式。在Android中由于module间不可以双向依赖，所以如果你想调用某个没有依赖关系的组件的服务往往是做到的，而组件间通信正好可以解决这样的问题。组件间通信在组件化和插件化中扮演了重要角色。

手机用户可以点这里查看

组件间通信实现

实现组件间通信的三个关键点，接口下沉，反射调用，代理访问。

接口下沉
要访问一个不存在依赖关系的module，直接通过调用具体类是不行的，具体类是在各自module里定义并实现的，所以是无法直接访问到的，只能通过接口访问。所以需要定义一个公共组件，让其他组件都依赖于它，需要暴露服务给第三方调用的组件在公共组件里去定义它们的接口，并且在各自组件内部去实现，第三方只能通过这些接口来访问其提供的服务。

反射调用
在公共组件定义其他组件对外服务的接口，那么通过这些接口要能够访问到其他组件才行。因为公共组件会被其他组件依赖，没办法直接调用其他组件的方法，所以只能通过反射调用。但是也不可能说每个方法都通过反射来调用，这样太麻烦，而且代码会变得很不好维护，所以其他组件需要实现一个统一接口，把所有需要对外暴露的方法都在里面定义，并以在公共组件定义的接口返回。这样公共组件只需要通过反射访问到这个统一接口，就可以访问到其对外提供的所有服务。

代理访问
前面说了公共组件可以通过反射访问到其他组件对外暴露的一个统一接口，进而访问其提供的所有服务。那么第三方组件想访问这些服务，就需要通过公共组件间接调用实现，因为公共组件只是一个代理对象，真正提供服务的是各个组件，所以这里就用到了代理机制。组件间通信需要通过公共组件代理实现。

说了这么多，我们看下一个简单的框架图
在这里插入图片描述
假如位于ModuleA的ClientA想访问位于ModuleB的ServiceB，那么它需要通过公共组件提供的ProxyB实现。ProxyB会先通过反射访问到ComponentB，ComponentB就是ModuleB实现的对外提供服务的统一接口，然后再通过ComponentB访问到ServiceB。

接下来，我们直接上代码，通过代码会把问题变得更加清晰。

前期准备

假设现在有一个项目包含了视频组件video和音乐组件music。这两个module不存在依赖关系，其中video组件提供直播和短视频服务，music组件提供听歌和唱歌服务，现在要想在视频组件调用音乐组件提供的服务，在音乐组件调用视频组件提供的服务。我们看下要怎么实现。

定义基础库

组件间通信需要通过代理接口实现，所以需要引入一个公用的基础库来定义一些公共接口。假如这个基础库叫baselib，让video和music组件都依赖baselib。在baselib中定义如下接口：

1.IMusicComponent：音乐组件接口，对外提供音乐组件相关的服务，新增服务需要在这里定义。

public interface IMusicComponent {
    /**
     * 获取听歌服务
     * @return
     */
    IListenerService getListenerService();

    /**
     * 获取唱歌服务
     * @return
     */
    ISingService getSingService();
}

2.IListenerService：听歌服务

public interface IListenerService {
    void playMusic();

    void pauseMusic();
}

3.ISingService：唱歌服务

public interface ISingService {
    void startSing();

    void stopSing();
}

4.IVideoComponent：视频组件接口，对外提供视频组件相关的服务，新增服务需要在这里定义。

public interface IVideoComponent {
    /**
     * 获取直播服务
     * @return
     */
    ILiveService getLiveService();

    /**
     * 获取短视频服务
     * @return
     */
    IShortVideoService getShortVideoService();
}

5.ILiveService：直播服务

public interface ILiveService {
    void enterLive();
    
    void leaveLive();
}

6.IShortVideoService：短视频服务

public interface IShortVideoService {
    void startRecord();

    void stopRecord();
}

7.IComponentFactory：组件工厂接口，定义项目中所有对外提供服务的组件

public interface IComponentFactory {
    IVideoComponent createVideoComponent();

    IMusicComponent createMusicComponent();
}

8.ComponentFactory：组件工厂，负责各个组件的创建。这里需要注意因为baselib不依赖于各个组件所以只能通过反射的方式来创建组件。

public class ComponentFactory implements IComponentFactory{
    private IVideoComponent mVideoComponent;
    private IMusicComponent mMusicComponent;


    private ComponentFactory() {
    }

    private static class Holder{
        private static final ComponentFactory sInstance = new ComponentFactory();
    }

    public static ComponentFactory getInstance(){
        return Holder.sInstance;
    }

    @Override
    public synchronized IVideoComponent createVideoComponent() {
        if(mVideoComponent == null){
            try {
                //MusicComponent是music模块的类，通过反射拿到该类
                Class<?> clazz = Class.forName("com.hyh.video.VideoComponent");
                //获取有参构造函数
                Constructor c= clazz.getConstructor(Context.class);
                //通过有参构造创建对象
                mVideoComponent = (IVideoComponent) c.newInstance(MyApplication.getApplication());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return mVideoComponent;
    }

    @Override
    public synchronized IMusicComponent createMusicComponent() {
        if(mMusicComponent == null){
            try {
                //MusicComponent是music模块的类，通过反射拿到该类
                Class<?> clazz = Class.forName("com.hyh.music.MusicComponent");
                //获取有参构造函数
                Constructor c= clazz.getConstructor(Context.class);
                //通过有参构造创建对象
                mMusicComponent = (IMusicComponent) c.newInstance(MyApplication.getApplication());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return mMusicComponent;
    }
}

视频组件

实现对外提供的服务

1.LiveService：直播服务

public class LiveService implements ILiveService {

    private Context mContext;

    public LiveService(Context context) {
        mContext = context;
    }

    @Override
    public void enterLive() {
        Toast.makeText(mContext,"开始直播",Toast.LENGTH_SHORT).show();
    }

    @Override
    public void leaveLive() {
        Toast.makeText(mContext,"结束直播",Toast.LENGTH_SHORT).show();
    }
}

2.ShortVideoService：短视频服务

public class ShortVideoService implements IShortVideoService {

    private Context mContext;

    public ShortVideoService(Context context) {
        mContext = context;
    }

    @Override
    public void startRecord() {
        Toast.makeText(mContext,"开始录制",Toast.LENGTH_SHORT).show();
    }

    @Override
    public void stopRecord() {
        Toast.makeText(mContext,"结束录制",Toast.LENGTH_SHORT).show();
    }
}

3.VideoComponent：视频组件实现类，通过它创建所提供的服务

public class VideoComponent implements IVideoComponent {
    private Context mContext;
    private ILiveService mLiveService;
    private IShortVideoService mShortVideoService;

    public VideoComponent(Context context) {
        mContext = context;
    }

    @Override
    public synchronized ILiveService getLiveService() {
        if(mLiveService == null){
            mLiveService = new LiveService(mContext);
        }
        return mLiveService;
    }

    @Override
    public synchronized IShortVideoService getShortVideoService() {
        if(mShortVideoService == null){
            mShortVideoService = new ShortVideoService(mContext);
        }
        return mShortVideoService;
    }
}

实现访问音乐组件的服务代理

要访问其他组件的服务需要通过代理实现。
1.ListenerServiceProxy：通过听歌服务代理访问音乐组件的听歌服务

public class ListenerServiceProxy implements IListenerService {
    private IListenerService mListenerService;

    public ListenerServiceProxy() {
        mListenerService = ComponentFactory.getInstance().createMusicComponent().getListenerService();
    }

    @Override
    public void playMusic() {
        mListenerService.playMusic();
    }

    @Override
    public void pauseMusic() {
        mListenerService.pauseMusic();
    }
}

2.SingServiceProxy：通过唱歌服务代理访问音乐组件的唱歌服务

public class SingServiceProxy implements ISingService {
    private ISingService mSingService;

    public SingServiceProxy() {
        mSingService = ComponentFactory.getInstance().createMusicComponent().getSingService();
    }

    @Override
    public void startSing() {
        mSingService.startSing();
    }

    @Override
    public void stopSing() {
        mSingService.stopSing();
    }
}

音乐组件

实现对外提供的服务

1.ListenerService：听歌服务

public class ListenerService implements IListenerService {
    private Context mContext;

    public ListenerService(Context context) {
        mContext = context;
    }

    @Override
    public void playMusic() {
        Toast.makeText(mContext,"开始播歌",Toast.LENGTH_SHORT).show();
    }

    @Override
    public void pauseMusic() {
        Toast.makeText(mContext,"暂停播歌",Toast.LENGTH_SHORT).show();
    }
}

2.SingService：唱歌服务

public class SingService implements ISingService {
    private Context mContext;

    public SingService(Context context) {
        mContext = context;
    }

    @Override
    public void startSing() {
        Toast.makeText(mContext,"开始唱歌",Toast.LENGTH_SHORT).show();
    }

    @Override
    public void stopSing() {
        Toast.makeText(mContext,"停止唱歌",Toast.LENGTH_SHORT).show();
    }
}

3.MusicComponent：音乐组件实现类，通过它创建所提供的服务

public class MusicComponent implements IMusicComponent {
    private Context mContext;
    private ListenerService mListenerService;
    private SingService mSingService;

    public MusicComponent(Context context) {
        mContext = context;
    }

    @Override
    public synchronized IListenerService getListenerService() {
        if(mListenerService == null){
            mListenerService = new ListenerService(mContext);
        }
        return mListenerService;
    }

    @Override
    public ISingService getSingService() {
        if(mSingService == null){
            mSingService = new SingService(mContext);
        }
        return mSingService;
    }
}

实现访问视频组件的服务代理

要访问其他组件的服务需要通过代理实现。
1.LiveServiceProxy：通过直播服务代理访问视频组件的直播服务

public class LiveServiceProxy implements ILiveService {
    private ILiveService mLiveService;

    public LiveServiceProxy() {
        mLiveService = ComponentFactory.getInstance().createVideoComponent().getLiveService();
    }

    @Override
    public void enterLive() {
        mLiveService.enterLive();
    }

    @Override
    public void leaveLive() {
        mLiveService.leaveLive();
    }
}

2.ShortVideoServiceProxy：通过短视频服务代理访问视频组件的短视频服务

public class ShortVideoServiceProxy implements IShortVideoService {
    private IShortVideoService mShortVideoService;

    public ShortVideoServiceProxy() {
        mShortVideoService = ComponentFactory.getInstance().createVideoComponent().getShortVideoService();
    }

    @Override
    public void startRecord() {
        mShortVideoService.startRecord();
    }

    @Override
    public void stopRecord() {
        mShortVideoService.stopRecord();
    }
}

总结

组件间通信主要用到的技术是反射和代理接口。只要理解了反射和代理在其中发挥的作用，组件间通信其实也不难。

源码

github地址
如果对你有帮助希望帮忙点个赞哈

辉猿走壁
关注
专栏目录
Android组件之间通信
xiaoxiao_job的专栏
11-07 3891
我们首先梳理下一般我们在安卓中不同组件之间通信有哪些方式  (Tips:以下讨论除了文件存储和ContentProvider等，一般都是指在同一进程内通信，如果要实现跨进程的通信，还需要借助Messenger或者AIDL等技术，后续还会抽时间详细介绍，暂不讨论) 方式一： 使用Intent进行传值: (Activity与Activity之间)  传值实例：  Intent intent
android组建之间通信_Android组件化开发实践（四）：组件间通信问题
weixin_39938875的博客
12-31 178
记得第一次实施项目组件化时，遇到的最大困扰就是，组件之间的通信问题。例如：怎么从这个组件跳转到另一个组件的页面；组件之间怎么传递数据；怎么获取其他组件的数据或服务；组件怎么通知其他组件响应某个事件；1. 页面跳转统一采用路由在Android中，页面跳转都是通过startActivity来实现的。但是我们组件化之后，上层的业务组件之间是不能相互依赖的，也就是说现在无法通过startActivity来...
Android 组件化开发module间通信
11-12
module间Activity相互启动，传值方面直接看activityrouter官方文档https://github.com/mzule/ActivityRouter
Android 组件之间通信
分享Android开发知识
07-13 1576
一、背景 Android开发中你的模块（Module）一般只有一个app主模块，随着功能不断扩展你会发现一个模块的缺点就是各种业务高度耦合，你就想测试登录模块，那么你可能会把支付模块也编译进去了，代价就是编译耗时，降低效率。 大牛就提出了组件化开发的概念，假如一个App包括登录，选购，支付三个模块，那么就分成三个app，一个用来做登录，一个用来展示商品让用户选购，一个用来做支付，这样互相不影响而且编译的话只会编译当前模块的代码，提高了时间效率。 二、原理 箭头表示依赖关系，举例：BaseModule指向m
Android组件化专题 - 路由框架进阶模块间的业务通信
weixin_34192816的博客
12-20 118
上一篇文章，讲解了路由框架实现的原理，并实现了基本的路由框架 页面路由的跳转 Android组件化专题 - 路由框架原理。 本篇文章来对基础的路由框架进阶，来实现模块间的业务通信功能。 代码地址 我们来看以下实现的效果图： app --&gt; module1 module1 --&gt; module2 首先我们先回顾，路由框架的设计思路，如下图： 通过注解 Acti...
android组件之间的通信
pvmsmfchcs的博客
02-25 326
1，在配置文件gradle中，判断模块组件是否存在，如果存在则引入组件 complie project{":modulea"} complie project{":moduleb"} 如果不存在，则一般引入base与common组件 2，android组件之间的通信实用intent进行通信，一般使用ActivityRouter于EventBus 3，组件化拆分 整体框架实用activity+fra...
Android组件间通信的模糊测试方法.pdf
09-21
《Android组件间通信的模糊测试方法》这篇论文主要探讨了在Android操作系统中，如何通过模糊测试技术来检测和评估应用组件间通信的健壮性。Android系统的组件间通信是其核心特性之一，它允许不同组件之间通过意图...
Android组件间通信--深入理解Intent与IntentFilter
09-05
总之，Intent和IntentFilter是Android组件间通信的核心，它们使得应用可以灵活地互相交互和扩展功能。理解并熟练掌握这两者，对于开发高效、健壮的Android应用至关重要。在实际开发中，合理使用显式和隐式Intent，...
Android组件间通信–深入理解Intent与IntentFilter
01-20
在Android开发中，Intent和IntentFilter是两个至关重要的概念，它们构成了Android组件间通信的核心机制。Intent作为消息载体，能够连接应用内的不同组件，如Activity、Service，甚至跨应用进行通信，实现组件级别的...
Android-一款高效的组件间通信方案0反射仅需简单配置即可方便的进行组件间通信
08-13
一款高效的组件间通信方案，0反射，仅需简单配置，即可方便的进行组件间通信
Android 自己实现组件间通信框架EventBus
11-14
代码为博客的实例代码：http://blog.csdn.net/lmj623565791/article/details/41096639 有问题请博客留言
深入理解Android组件间通信机制对面向对象特性的影响详解
09-05
其次，由于Intent通信机制的限制，多态在Android组件间通信中难以实现。以一个Service为例，若想通过统一接口处理不同类型的请求，理想情况下可以定义一个抽象的Transaction类，并为每种特定的Transaction实现子类。...
android组建之间通信_Android组件化架构 - 2. 组件间通信机制
weixin_29619251的博客
12-23 156
本地广播LocalBroadcastManager说到组件间通信第一个肯定想到广播BroadcastReceiver，但是这里要说的是一个更优的选择---本地广播LocalBroadcastManager；优点：只在app内传播, 信息不会泄露,也不会被别人的广播干扰, 且比全局广播更高效;缺点：但是本地广播传输消息时将一切都交给系统负责,无法干预传输中的步骤；使用观察者模式使用demo：本质：看...
Android四大组件之间通信方案
最新发布
weixin_42487687的博客
04-21 946
Android四大组件之间的通信方案多样且灵活，开发者可以根据具体需求选择合适的通信方式。通过Intent、Binder、Broadcast和ContentProvider等机制，四大组件可以相互协作，实现数据的传递和功能的调用，从而构建出功能丰富、性能优良的Android应用。在实际开发中，建议开发者深入了解这些通信方案的工作原理和最佳实践，以提高应用的稳定性和用户体验。同时，随着Android技术的不断发展，新的通信方案也在不断涌现，开发者需要保持对新技术的学习和关注。
android组件间通信
weixin_30345055的博客
04-13 68
这是一个基本问题，早就应该弄懂总结了。 Intent是基本的通信手段。 Activity可以使用startActivityForResult来调用另一个Activity的处理逻辑。（一般来说，这是一个与用户交互的逻辑） Activity可以bind到Service来RPC，使用aidl。 但是aidl实现起来比较繁琐，在简单的情形下，可以使用startService发送包含自定义的acti...
Android 框架炼成 教你如何写组件间通信框架EventBus
modabobo
11-20 815
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/41096639，本文出自：【张鸿洋的博客】1、概述 关于Eventbus的介绍，前面已经有两篇：Android EventBus实战 没听过你就out了和Android EventBus源码解析 带你深入理解EventBus， 如果你觉得还有问题，没关系，接下来我带大家手把手打造从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值