进程间通信 Messenger

2024-06-16 09:48
文章标签 间通信 进程 messenger

本文主要是介绍进程间通信 Messenger，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

使用Messenger进行通信的方式要比aidl写起来方便的多，这种方式大概的流程为：



这种方式可以做到双向通信


那么下面就是代码了，首先是服务端：我自己的测试的项目在另一台电脑上，所以就拿借鉴的博主的代码来了，其实

我自己写的是差不多的

[java]  view plain copy
  1. package com.example.aidlClientdemo;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Handler;  
  6. import android.os.HandlerThread;  
  7. import android.os.IBinder;  
  8. import android.os.Message;  
  9. import android.os.Messenger;  
  10. import android.os.RemoteException;  
  11.   
  12. public class ProcessCommonicationService extends Service{  
  13.     private static final int MSG_SUM = 0x110;  
  14.       
  15.     HandlerThread handlerThread = new HandlerThread("myHandlerThread");         
  16.   
  17.     //这里在handler构造器内传入handlerThread的Lopper，可以让handleMessage在handlerThread的线程内队列执行  
  18.     private Messenger mMessenger = new Messenger(new Handler(handlerThread.getLooper())  
  19.     {  
  20.         @Override  
  21.         public void handleMessage(Message msgfromClient)  
  22.         {  
  23.             Message msgToClient = Message.obtain(msgfromClient);//返回给客户端的消息  
  24.             switch (msgfromClient.what)  
  25.             {  
  26.                 //msg 客户端传来的消息  
  27.                 case MSG_SUM:  
  28.                     msgToClient.what = MSG_SUM;  
  29.                     try  
  30.                     {  
  31.                         //模拟耗时  
  32.                         Thread.sleep(2000);  
  33.                         msgToClient.arg2 = msgfromClient.arg1 + msgfromClient.arg2;  
  34.                         msgfromClient.replyTo.send(msgToClient);  
  35.                     } catch (InterruptedException e)  
  36.                     {  
  37.                         e.printStackTrace();  
  38.                     } catch (RemoteException e)  
  39.                     {  
  40.                         e.printStackTrace();  
  41.                     }  
  42.                     break;  
  43.             }  
  44.   
  45.             super.handleMessage(msgfromClient);  
  46.         }  
  47.     });  
  48.       
  49.     @Override  
  50.     public void onCreate() {  
  51.         super.onCreate();  
  52.         //使用handlerThread可以进行队列执行  
  53.         handlerThread.start();  
  54.     }  
  55.   
  56.     @Override  
  57.     public IBinder onBind(Intent intent)  
  58.     {  
  59.         return mMessenger.getBinder();  
  60.     }  
  61. }  

客户端代码结束之后就是服务端的代码

[java]  view plain copy
  1. package com.imooc.messenger_client;  
  2.   
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.IBinder;  
  10. import android.os.Message;  
  11. import android.os.Messenger;  
  12. import android.os.RemoteException;  
  13. import android.support.v7.app.AppCompatActivity;  
  14. import android.util.Log;  
  15. import android.view.View;  
  16. import android.widget.Button;  
  17. import android.widget.LinearLayout;  
  18. import android.widget.TextView;  
  19.   
  20. public class MainActivity extends AppCompatActivity  
  21. {  
  22.     private static final String TAG = "MainActivity";  
  23.     private static final int MSG_SUM = 0x110;  
  24.   
  25.     private Button mBtnAdd;  
  26.     private LinearLayout mLyContainer;  
  27.     //显示连接状态  
  28.     private TextView mTvState;  
  29.   
  30.     private Messenger mService;  
  31.     private boolean isConn;  
  32.   
  33.   
  34.     private Messenger mMessenger = new Messenger(new Handler()  
  35.     {  
  36.         @Override  
  37.         public void handleMessage(Message msgFromServer)  
  38.         {  
  39.             switch (msgFromServer.what)  
  40.             {  
  41.                 case MSG_SUM:  
  42.                     TextView tv = (TextView) mLyContainer.findViewById(msgFromServer.arg1);  
  43.                     tv.setText(tv.getText() + "=>" + msgFromServer.arg2);  
  44.                     break;  
  45.             }  
  46.             super.handleMessage(msgFromServer);  
  47.         }  
  48.     });  
  49.   
  50.   
  51.     private ServiceConnection mConn = new ServiceConnection()  
  52.     {  
  53.         @Override  
  54.         public void onServiceConnected(ComponentName name, IBinder service)  
  55.         {  
  56.             mService = new Messenger(service);  
  57.             isConn = true;  
  58.             mTvState.setText("connected!");  
  59.         }  
  60.   
  61.         @Override  
  62.         public void onServiceDisconnected(ComponentName name)  
  63.         {  
  64.             mService = null;  
  65.             isConn = false;  
  66.             mTvState.setText("disconnected!");  
  67.         }  
  68.     };  
  69.   
  70.     private int mA;  
  71.   
  72.     @Override  
  73.     protected void onCreate(Bundle savedInstanceState)  
  74.     {  
  75.         super.onCreate(savedInstanceState);  
  76.         setContentView(R.layout.activity_main);  
  77.   
  78.         //开始绑定服务  
  79.         bindServiceInvoked();  
  80.   
  81.         mTvState = (TextView) findViewById(R.id.id_tv_callback);  
  82.         mBtnAdd = (Button) findViewById(R.id.id_btn_add);  
  83.         mLyContainer = (LinearLayout) findViewById(R.id.id_ll_container);  
  84.   
  85.         mBtnAdd.setOnClickListener(new View.OnClickListener()  
  86.         {  
  87.             @Override  
  88.             public void onClick(View v)  
  89.             {  
  90.                 try  
  91.                 {  
  92.                     int a = mA++;  
  93.                     int b = (int) (Math.random() * 100);  
  94.   
  95.                     //创建一个tv,添加到LinearLayout中  
  96.                     TextView tv = new TextView(MainActivity.this);  
  97.                     tv.setText(a + " + " + b + " = caculating ...");  
  98.                     tv.setId(a);  
  99.                     mLyContainer.addView(tv);  
  100.   
  101.                     Message msgFromClient = Message.obtain(null, MSG_SUM, a, b);  
  102.                     msgFromClient.replyTo = mMessenger;  
  103.                     if (isConn)  
  104.                     {  
  105.                         //往服务端发送消息  
  106.                         mService.send(msgFromClient);  
  107.                     }  
  108.                 } catch (RemoteException e)  
  109.                 {  
  110.                     e.printStackTrace();  
  111.                 }  
  112.             }  
  113.         });  
  114.   
  115.     }  
  116.   
  117.     private void bindServiceInvoked()  
  118.     {  
  119.         Intent intent = new Intent();  
  120.         intent.setAction("com.zhy.aidl.calc");  
  121.         bindService(intent, mConn, Context.BIND_AUTO_CREATE);  
  122.         Log.e(TAG, "bindService invoked !");  
  123.     }  
  124.   
  125.     @Override  
  126.     protected void onDestroy()  
  127.     {  
  128.         super.onDestroy();  
  129.         unbindService(mConn);  
  130.     }  
  131.   
  132.   
  133. }  


在上面的例子中，是传递了基本类型的参数，而我们实际使用中则很多都会需要用到传递自定义类型，这种时候只需要这么做就行了

[java]  view plain copy
  1. Message msgFromClient = Message.obtain(null, MSG_SUM, a, b);  
  2.         msgFromClient.replyTo = mMessenger;  
  3.         Bundle bundle = new Bundle();  
  4.         bundle.putParcelable("data", new User());  
  5.         msgFromClient.setData(bundle);  
  6.           
  7.         if (isConn)  
  8.         {  
  9.             //往服务端发送消息  
  10.             mService.send(msgFromClient);  
  11.         }  
就是通过在Message中添加Bundle来传递我们自定义的对象，这个对象需要实现Parcelable接口


通过上面的方式可以方便的进行进程间的通讯


那么，为什么通过这种方式可以进行进程间通讯呢？这一点在我解读的文章中也有描述


之前我了解过aidl的进程通讯方式，在aidl的通讯方式可以发现与这里非常相似


1、bindService的方式

2、ServiceConnection的使用

3、aidl接口的对象获取，其实可以发现这里也是一样的

这里调用的通讯方式为Messenger mService = new Messenger(service);

而aidl的接口对象获取方式为：ICalcAIDL mCalcAidl = ICalcAIDL.Stub.asInterface(service);

表面上看起来好像有点不同，但是，如果我们去看Messenger的构造器

[java]  view plain copy
  1. public Messenger(IBinder target) {  
  2.         mTarget = IMessenger.Stub.asInterface(target);  
  3.     }  


这里返回的mTarget对象为

private final IMessenger mTarget;

跟aidl客户端的方式一模一样，在调用通讯方法send(Message message)我们再去看

[java]  view plain copy
  1. public void send(Message message) throws RemoteException {  
  2.         mTarget.send(message);  
  3.     }  
很明显，其实内部的逻辑方式就是使用的aidl



那么客户端我们发现了是一样的，再去看服务端呢？

在服务端我们的代码是

[java]  view plain copy
  1. private Messenger mMessenger = new Messenger(new Handler(handlerThread.getLooper())  
  2. {  
  3.     @Override  
  4.     public void handleMessage(Message msgfromClient)  
  5.     {  
  6.         Message msgToClient = Message.obtain(msgfromClient);//返回给客户端的消息  
  7.         switch (msgfromClient.what)  
  8.         {  
  9.             //msg 客户端传来的消息  
  10.             case MSG_SUM:  
  11.                 msgToClient.what = MSG_SUM;  
  12.                 try  
  13.                 {  
  14.                     //模拟耗时  
  15.                     Thread.sleep(2000);  
  16.                     msgToClient.arg2 = msgfromClient.arg1 + msgfromClient.arg2;  
  17.                     msgfromClient.replyTo.send(msgToClient);  
  18.                 } catch (InterruptedException e)  
  19.                 {  
  20.                     e.printStackTrace();  
  21.                 } catch (RemoteException e)  
  22.                 {  
  23.                     e.printStackTrace();  
  24.                 }  
  25.                 break;  
  26.         }  
  27.   
  28.         super.handleMessage(msgfromClient);  
  29.     }  
  30. });  
然后是

[java]  view plain copy
  1. @Override  
  2. public IBinder onBind(Intent intent)  
  3. {  
  4.     return mMessenger.getBinder();  
  5. }  


而aidl的通讯方式是

[java]  view plain copy
  1. private final ICalcAIDL.Stub mBinder = new ICalcAIDL.Stub()    
  2.     {    
  3.     
  4.         @Override    
  5.         public int add(int x, int y) throws RemoteException    
  6.         {    
  7.             return x + y;    
  8.         }    
  9.     
  10.         @Override    
  11.         public int min(int x, int y) throws RemoteException    
  12.         {    
  13.             return x - y;    
  14.         }    
  15.     
  16.     };    

然后

[java]  view plain copy
  1. public IBinder onBind(Intent t)    
  2. {    
  3.     Log.e(TAG, "onBind");    
  4.     return mBinder;    
  5. }    
就是将一个实现了我们自定义的aidl对象的Stub接口的对象作为通讯方式返回


那么，现在的Messenger方式又是怎样的呢

我们首先来看Messenger的构造器，来看看这这里面做了什么

[java]  view plain copy
  1. public Messenger(Handler target) {  
  2.        mTarget = target.getIMessenger();  
  3.    }  
这里从我们传入的handler中取出了IMessenger对象


这个IMessenger，其实是依赖一个aidl生成的类

于：frameworks/base/core/java/android/os/IMessenger.aidl.

[java]  view plain copy
  1. package android.os;    
  2.   
  3. import android.os.Message;    
  4.   
  5. /** @hide */    
  6. oneway interface IMessenger {    
  7.     void send(in Message msg);    
  8. }    

这样，在服务端就只差一个东西了，就是实现了 IMessenger.Stub的对象，这个对象我们去哪里找？

然后我们去看

[java]  view plain copy
  1. public Messenger(Handler target) {  
  2.        mTarget = target.getIMessenger();  
  3.    }  

这里的target.getMessenger()方法，我们进去看一下，可以看到

[java]  view plain copy
  1. final IMessenger getIMessenger() {  
  2.     synchronized (mQueue) {  
  3.         if (mMessenger != null) {  
  4.             return mMessenger;  
  5.         }  
  6.         mMessenger = new MessengerImpl();  
  7.         return mMessenger;  
  8.     }  
  9. }  
  10.   
  11.  private final class MessengerImpl extends IMessenger.Stub {  
  12.     public void send(Message msg) {  
  13.         msg.sendingUid = Binder.getCallingUid();  
  14.         Handler.this.sendMessage(msg);  
  15.     }  
  16. }  
找到了！这个MessengerImpl对象就是实现了IMessenger.Stub的对象


这样一来，需要的要素就都齐了，按照现在的代码来推测的话，不难推测出

[java]  view plain copy
  1. @Override  
  2. public IBinder onBind(Intent intent)  
  3. {  
  4.     return mMessenger.getBinder();  
  5. }  
这里返回的mMessenger.getBinder()应该是 MessengerImpl对象，不过我们还是得去确认一下


[java]  view plain copy
  1. public IBinder getBinder() {  
  2.     return mTarget.asBinder();  
  3. }  

这里调用了asBinder()方法，再进去看

[java]  view plain copy
  1. @Override public android.os.IBinder asBinder()  
  2. {  
  3. return this;  
  4. }  
可以看到，asBinder方法就是返回的mTarget对象自己，就是 MessengerImpl对象


这里这个asBinder方法的源码是aidl文件在gen路径下生成的类里面可以看到的，如果读者想看的话，可以在aidl的例子中查看，就可以看到


那么Messenger配合Handler的进程间通信的原理到这里就分析结束了，从这个看来的话，其实我们完全也可以自己写一个类似于Messenger的对象用来进行进程间通信，并且利用Message可以传递数据的特性来进行数据的传递，可以说还是非常方便的

这篇关于进程间通信 Messenger的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1066121。

相关文章

Windows的CMD窗口如何查看并杀死nginx进程

Windows的CMD窗口如何查看并杀死nginx进程

《Windows的CMD窗口如何查看并杀死nginx进程》：本文主要介绍Windows的CMD窗口如何查看并杀死nginx进程问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录Windows的CMD窗口查看并杀死nginx进程开启nginx查看nginx进程停止nginx服务
阅读更多...
Java进程CPU使用率过高排查步骤详细讲解

Java进程CPU使用率过高排查步骤详细讲解

《Java进程CPU使用率过高排查步骤详细讲解》：本文主要介绍Java进程CPU使用率过高排查的相关资料,针对Java进程CPU使用率高的问题,我们可以遵循以下步骤进行排查和优化,文中通过代码介绍... 目录前言一、初步定位问题1.1 确认进程状态1.2 确定Java进程ID1.3 快速生成线程堆栈二、分析
阅读更多...
Python多进程、多线程、协程典型示例解析(最新推荐)

Python多进程、多线程、协程典型示例解析(最新推荐)

《Python多进程、多线程、协程典型示例解析(最新推荐)》：本文主要介绍Python多进程、多线程、协程典型示例解析(最新推荐),本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定... 目录一、multiprocessing（多进程）1. 模块简介2. 案例详解：并行计算平方和3. 实现逻
阅读更多...
C#通过进程调用外部应用的实现示例

C#通过进程调用外部应用的实现示例

《C#通过进程调用外部应用的实现示例》本文主要介绍了C#通过进程调用外部应用的实现示例,以WINFORM应用程序为例,在C#应用程序中调用PYTHON程序,具有一定的参考价值,感兴趣的可以了解一下... 目录窗口程序类进程信息类 系统设置类 以WINFORM应用程序为例，在C#应用程序中调用python程序
阅读更多...
Python如何精准判断某个进程是否在运行

Python如何精准判断某个进程是否在运行

《Python如何精准判断某个进程是否在运行》这篇文章主要为大家详细介绍了Python如何精准判断某个进程是否在运行,本文为大家整理了3种方法并进行了对比,有需要的小伙伴可以跟随小编一起学习一下... 目录一、为什么需要判断进程是否存在二、方法1：用psutil库（推荐）三、方法2：用os.system调用
阅读更多...
Java程序进程起来了但是不打印日志的原因分析

Java程序进程起来了但是不打印日志的原因分析

《Java程序进程起来了但是不打印日志的原因分析》：本文主要介绍Java程序进程起来了但是不打印日志的原因分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Java程序进程起来了但是不打印日志的原因1、日志配置问题2、日志文件权限问题3、日志文件路径问题4、程序
阅读更多...
Linux中的进程间通信之匿名管道解读

Linux中的进程间通信之匿名管道解读

《Linux中的进程间通信之匿名管道解读》：本文主要介绍Linux中的进程间通信之匿名管道解读,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、基本概念二、管道1、温故知新2、实现方式3、匿名管道（一）管道中的四种情况（二）管道的特性总结一、基本概念我们知道多
阅读更多...
Linux进程终止的N种方式详解

Linux进程终止的N种方式详解

《Linux进程终止的N种方式详解》进程终止是操作系统中,进程的一个重要阶段,他标志着进程生命周期的结束,下面小编为大家整理了一些常见的Linux进程终止方式,大家可以根据需求选择... 目录前言一、进程终止的概念二、进程终止的场景三、进程终止的实现3.1 程序退出码3.2 运行完毕结果正常3.3 运行完毕
阅读更多...
Windows命令之tasklist命令用法详解(Windows查看进程)

Windows命令之tasklist命令用法详解(Windows查看进程)

《Windows命令之tasklist命令用法详解(Windows查看进程)》tasklist命令显示本地计算机或远程计算机上当前正在运行的进程列表,命令结合筛选器一起使用,可以按照我们的需求进行过滤... 目录命令帮助1、基本使用2、执行原理2.1、tasklist命令无法使用3、筛选器3.1、根据PID
阅读更多...
linux本机进程间通信之UDS详解

linux本机进程间通信之UDS详解

《linux本机进程间通信之UDS详解》文章介绍了Unix域套接字（UDS）的使用方法,这是一种在同一台主机上不同进程间通信的方式,UDS支持三种套接字类型：SOCK_STREAM、SOCK_DGRA... 目录基础概念本机进程间通信socket实现AF_INET数据收发示意图AF_Unix数据收发流程图A
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2