IPC的几个基础知识：序列化和Binder，本章将详细介绍各种跨进程同行方式。具体的方式有很多，比如可以通过在Intent中附加extras来传递信息，或者通过共享文件的方式来共享数据，还可以采用Binder的方式来跨进程通信，另外ContentProvider天生就是支持跨进程访问的，隐藏我们也可以采用它来进行IPC。此外通过网络通信也是可以实现数据传递的，所以Socket也可以实现IPC。上述所说的各种方法都能实现IPC，它们在使用方法和侧重点上都有很大的区别，下面一一进行展开。
Android中的IPC方式
使用Bundle
我们知道，四大组件中的三大组件（Activity、Service、Receiver）都是支持在Intent中传递Bundle数据的，由于Bundle实现了Parcelable接口，所以它可以方便地在不同的进程间传输。基于这一点，当我们在一个进程中启动了另一个进程的Activity、Service
、Receiver、我们就可以在Bundle中附加我们需要传输给远程进程的信息并通过Intent发送出去。当然，我们传输的数据必须能够被序列化，比如基本类型，实现了Parcelable接口的对象，实现了Serializable接口的对象以及一些Android支持的特殊对象，具体内容可以看Bundle这个类，就可以看到所有它支持的类型。Bundle不支持的类型我们无法通过它在进程间传递数据，这个相当简单就不在做详细介绍了。
使用文件共享
共享文件也是一种不错的进程间通信方式，两个进程通过读/写同一个文件来交换数据，比如A进程把数据写入文件，B进程通过读取这个文件来获取数据。我们知道，在Window上，一个文件如果被加了排斥锁将会导致其他线程无法对其进行访问，包括读和写，而由于Android系统基于Linux，使得其并发读/写可以没有限制地进行，甚至两个线程同时对同一个文件进行写操作都是允许的，尽管这样可能会出问题，不过通过文件交换数据确实很好用。
通过文件共享这种方式对文件格式是没有具体要求的，比如可以是文本文件，也可以是XML文件，只要读/写双方约定数据格式即可。通过文件共享的方式也是有局限性的，比如并发读/写的问题，如果真的出现了并发读/写，那么我们读出的内容就又可能不是最新的，如果是并发写的话那就更严重了。因此我们要尽量避免并发写这种情况的发生或者考虑使用线程同步来限制多个线程的写操作。通过上面的分析，我们可以知道，文件共享方式适合在对数据同步要求不高的进程之间进行通信，并且要妥善处理并发读/写的问题。
当然，实际应用中我们用的比较多的还是SharedPreferences，而SharedPreferences是个特例，众所周知，SharedPreferences是Android中提供的轻量级存储方案，它通过键值对的方式来存储数据，在底层实现上它采用XML文件来存储键值对，每个应用的SharedPreferences文件都可以在当前包所在的data目录下查看到。一般来说，它的目录位于data/data/package name/shared_prefs目录下，其中package name表示的是当前应用的包名。从本质上来说，SharedPreferences也属于文件的一种，但是由于系统对它的读/写有一定的缓存策略，即在内存中会有一份SharedPreferences文件的缓存，隐藏在多进程模式下，系统对它的读/写就变得不可靠，当面对高并发的读/写访问，SharedPreferences有很大的几率会丢失数据，因此不建议在进程间通信中使用SharedPreferences。
关于SharedPreferences在进程间通信中的使用介绍可以参考下面这篇文章 通过SharedPreferences实现进程间数据共享的问题详解
使用Messenger
Messenger可以翻译为送信者，顾名思义，通过它可以在不同进程中传递Messenger对象，在Message中放入我们需要传递的数据，就可以轻松地实现数据的进程间通信了。Messenger是一种轻量级的IPC方案，它的底层实现是Binder，为什么这么说呢，我们大致看一下Messenger这个类的构造方法就明白了。下面是Messenger的两个构造方法，从构造方法的实现上我们就可以明显看出Binder的痕迹，不管是IMessenger还是Stub.asInterface这种使用方法都表明它的底层是Binder。
/**
* Create a new Messenger pointing to the given Handler. Any Message
* objects sent through this Messenger will appear in the Handler as if
* {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
* been called directly.
*
* @param target The Handler that will receive sent messages.
*/
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
/**
* Create a Messenger from a raw IBinder, which had previously been
* retrieved with {@link #getBinder}.
*
* @param target The IBinder this Messenger should communicate with.
*/
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
在这里我们
Messenger的使用方法非常简单，而且由于Messenger一次只处理一个请求，因此在服务端我们不用考虑线程同步的问题，这是因为服务端中不存在并发执行的情形。实现一个Messenger有如下几个步骤，分别为服务端和客户端。
- 1、服务端进程
首先，我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder对象即可。 - 2、客户端进程
客户端进程中，首先要绑定服务端的Service，绑定成功后用服务端返回的IBinder创建一个Messenger，通过这个Messenger就可以向服务器发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。这听起来可能有点抽象，下面我们会给出两个例子，看一下我们就明白了。首先，我们先来做一个简单点的例子，在这个例子中服务端无法回应客户端。
首先看服务端的代码，这是服务端的典型代码：
public class MessengerService extends Service {
private static final String TAG = "MessengerService";
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
Log.e(TAG, "receive msg form Client:" + msg.getData().getString("msg"));
break;
}
}
}
private final Messenger mMessenger = new Messenger(new MessengerHandler());
public MessengerService() {
}
@Override
public void onCreate() {
super.onCreate();
Log.e(TAG, mMessenger.getBinder() + "");
}
@Override
public IBinder onBind(Intent intent) {
Log.e(TAG, mMessenger.getBinder() + "");
return mMessenger.getBinder();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
然后，注册service，让其运行在单独的进程中：
<service
android:name=".MessengerService"
android:process=":remote"></service>
- 1
- 2
- 3
可以看到MessengerHandle用来处理客户端发送的消息，并从消息中取出客户端发来的文本信息。而mMessenger是一个Messenger对象，他和MessengerHandler相关联，并在onBind方法中返回它里面的Binder对象，可以看出，这里Messenger的作用就是将客户端发送的消息传递给MessengerHandler进行处理
这里我们先不着急去实现客户端代码，我们先来看下服务单Messenger的创建过程：
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
代码并不是很复杂，首先，我们是根据Messenger（Handler target）这个构造方法创建的Messenger对象，在Messenger构造方法内部，调用了Handler的getIMessenger()方法，而在getIMessenger()方法内部通过new MessengerImpl的实例返回（MessengerImpl其实是Handler的一个内部类，而且是一个继承了IMessenger.Stub的Binder对象，）到这里其实我们都差不多应该明白了 IMessenger其实就是一个系统生成的根据一个aidl文件生成的Java类，那么也就能够解释为什么在服务端的onBind方法中返回的是 mMessenger.getBinder了，其实如果你看了mMessenger.getBinder方法的内部实现，可以发现它所做的操作其实很简单，就是调用了IMessenger.Stub.asBinder方法返回了一个IBinder对象，好了服务端的代码我们就介绍到这里，下面让我们看实现下客户端的逻辑：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private Messenger mService;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg", "Hello,this is Client.");
msg.setData(data);
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MessengerService.class);
bindService(intent, mConnection, 0);
}
@Override
protected void onDestroy() {
unbindService(mConnection);
super.onDestroy();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
我们运行下程序，看一下log，很显然，服务端成功收到了客户端发来的问候语：“Hello,this is Client.”
08-28 13:16:15.283 22092-22092/com.layoutinflate.mk.www.messengerdemo E/MessengerService: receive msg form Client:Hello,this is Client.
- 1
通过上面的例子可以看出，在Messenger中进行数据传递必须将数据放入Message中，而Messenger和Message都实现了Parcelable接口，因此可以跨进程传输。简单来说，Messenger中所支持的数据类型就是Messenger 所支持的传输类型。实际上，通过Messenger来传输Message，Message中能使用的载体只有what、arg1、arg2、Bundle以及replyTo。Message中的另一个字段object在同一个进程中是很实用的，但是在进程间通信的时候，在Android2.2.以前object字段不支持跨进程传输，即便是2.2以后，也仅仅是系统提供的实现了Parcelable接口的时候才能通过它来传输。这就意味着我们自定义的Parcelable对象是无法通过object字段进行传输的，大家可以试一下，非系统的Parcelable对象的确无法通过object字段来传输，这也导致了object字段的实用性大大降低，所幸我们还有Bundle，Bundle中可以支持大量的数据类型。
上面的例子演示了如何在服务端接受客户端中发送的信息，但是有时候我们还需要能回应客户端，下面就介绍如何实现这种效果。还是采用上面的例子，但是稍微做一下修改，每当客户端发来一条消息，服务端就会自动恢复一条信息过去。
前面我们已经说过，如果想要服务端响应客户端，我们需要在客户端中创建一个Handle并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端就可以通过这个replyTo参数就可以回应客户端。我们来看下具体实现：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private Messenger mService;
//后加入代码 创建Handle对象
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.e(TAG, "recevie msg from Service :" + msg.getData().getString("reply"));
break;
}
}
}
//后加入代码 根据创建的Handle创建Messenger
private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e(TAG, service + "");
mService = new Messenger(service);
Message msg = Message.obtain(null, 0);
Bundle data = new Bundle();
data.putString("msg", "Hello,this is Client.");
Log.e(TAG, "Hello,this is Client.");
msg.setData(data);
//TODO 后加入代码 将Messenger对象通过replyTo参数传递给服务端
msg.replyTo = mGetReplyMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MessengerService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
unbindService(mConnection);
super.onDestroy();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
客户端的代码就是这么简单，下面我们来看下服务端的代码，服务端我们只需要修改MessengerHandler，当收到消息后，取出客户端给我传递过来的Messenger，然后调用send方法就可以了
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
Log.e(TAG, "receive msg form Client:" + msg.getData().getString("msg"));
//后加入代码，获取客户端传递过来的Messenger对象，发送消息到客户端
Messenger client = msg.replyTo;
Message replyMessage = Message.obtain(null, 1);
Bundle bundle = new Bundle();
bundle.putString("reply","消息已收到，稍后回复您！");
replyMessage.setData(bundle);
try {
client.send(replyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
通过上述修改，我们在运行程序，然后看一下log：
08-28 13:16:15.273 22092-22092/com.layoutinflate.mk.www.messengerdemo E/MessengerService: receive msg form Client:Hello,this is Client.
08-28 13:16:15.283 22092-22092/com.layoutinflate.mk.www.messengerdemo E/MainActivity: recevie msg from Service :消息已收到，稍后回复您！
- 1
- 2
很显然，客户端收到了服务端的回复，这说明我们的功能已经完成。
到这里，我们已经把采用Messenger进行进程间通信的方法都介绍完了，下面给出一张Messenger的工作原理图，以便更好的理解Messenger，如图所示：
使用AIDL
前面我们已经介绍了使用Messenger来进行进程间通信的方法，可以发现，Messenger是一串行的方式处理客户端发来的消息，如果大量的消息同时发送到服务端，服务端仍然只能一个个处理，如果有大量的并发请求，那么用Messenger就不太合适了。同时，Messenger的作用主要是为了传递消息，很多时候我们可能还需要跨进程调用服务端的方法，这种情形用Messenger就无法做到了，但是我们可以使用AIDL来完成跨进程的方法的调用。在上一篇博客中我们已经介绍了Binder的概念，大家对Binder也有了一定的了解，在Binder的基础上我们可以更加地容易理解AIDL。关于AIDL的用法这里不在给出，有需要详细了解AIDL的可以自行百度。
使用ContentProvider
ContentProvider是Android中专门用于不同应用间进行数据共享的方式，从这一点来看，它天生就适合进程间通信。和Messenger一样，ContentProvider的底层实现同样也是Binder。和AIDL一样这里也不再对ContentProvider进行详细介绍，有需要详细了解的自行百度把，用法都是一样的。
使用Socket
Socket也称为“套接字”，是网络通信中的概念，它分为流式套接字和用户数据包套接字两种，分别对应于网络的传输控制层中的TCP和UDP协议。TCP协议是面向连接的协议，提供稳定的双向通信功能，TCP的建立需要经过“三次握手”才能完成，为了提供稳定的数据传输功能，其本身提供了超时重传机制，因此具有很高的稳定性；而UDP是面向无连接的，提供不稳定的单向通信功能，当然UDP也可以实现双向通信功能，在性能上，UDP具有更好的效率，其缺点是不能保证数据一定能够正确传输，尤其是在网络拥塞的情况下。Socket本身可以支持传输任意字符流，这里为了简单起见，仅仅传输文本信息，很显然，这是一种IPC方式；
使用Socket来进行通信，有两点需要注意，首先需要声明权限：
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
- 1
- 2
下面就开始设计我们的聊天室程序了，比较简单，首先在远程Service建立一个TCP服务，然后在主界面中连接TCP服务，连接上了以后，就可以给服务端发消息。对于我们发送的每一条文本信息，服务端都会随机地回应我们一句话。为了更好地展示Socket的工作机制，在服务端我们做了处理，使其能够和多个客户端同时建立连接并响应。
先看一下服务端的设计，当Service启动时，会在线程中建立TCP服务，这里监听的是8688端口，然后就可以等待客户端的连接请求。当有客户端连接时，就会生成一个新的Socket，通过每次新创建的Socket就可以分别和不同的客户端通信了。服务端每收到一次客户端消息就会随机回复一句话给客户端。当客户端端口连接时，服务端这边也会相应的关闭对应Socket并结束通话线程，这点是如何做到的呢？方法有很多，这里是通过判断服务端输入流的返回值来确定的，当客户端断开连接后，服务端这边的输入流会返回null，这个时候我们就知道客户端退出了。服务端的代码如下：
public class TCPServerService extends Service {
private boolean mIsServiceDestoryed = false;
private String[] mDefineDestoryed = new String[]{
"你好啊，哈哈",
"请问你叫什么名字呀？",
"今天北京天气不错啊，shy",
"你知道吗？我可以说可以和多个人同时聊天的哦",
"给你讲个笑话吧；据说爱笑的人运气不会太差，不知道真假"
};
public TCPServerService() {
}
@Override
public void onCreate() {
new Thread(new TCPServer()).start();
super.onCreate();
}
@Override
public void onDestroy() {
mIsServiceDestoryed = true;
super.onDestroy();
}
@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
return null;
}
private class TCPServer implements Runnable {
@Override
public void run() {
ServerSocket serverSocket = null;
try {
//监听本地8688端口
serverSocket = new ServerSocket(8688);
} catch (IOException e) {
System.out.print("establish tcp server failed, port:8688");
e.printStackTrace();
return;
}
while (!mIsServiceDestoryed) {
//接受客户端请求
try {
final Socket client = serverSocket.accept();
System.out.print("accept");
new Thread() {
@Override
public void run() {
try {
responseClient(client);
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void responseClient(Socket client) throws IOException {
//用于接收客户端消息
BufferedReader in = new BufferedReader(
new InputStreamReader(client.getInputStream()));
//用于向客户端发送消息
PrintWriter out = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(client.getOutputStream())),
true);
//向客户端写入消息
out.println("欢迎来到聊天室");
while (!mIsServiceDestoryed) {
//获取客户端发送过来的消息
String msg = in.readLine();
System.out.print("msg form client:" + msg);
if (msg == null) {
//客户端断开连接
break;
}
int i = new Random().nextInt(mDefineDestoryed.length);
String s = mDefineDestoryed[i];
out.println(s);
System.out.print("send:" + s);
}
System.out.print("client quit");
//关闭流
in.close();
out.close();
client.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
代码很简单，不在详细介绍，接着看一下客户端，客户端Activity启动时，会在onCreate中开启一个线程去连接服务器Socket，至于为什么用线程是因为存在耗时操作。为了确定能够连接成功，这里采用了超时重连策略，每次连接失败后都会重新尝试建立连接。为了降低重试机制的开销，我们加入了休眠机制，即每次重试的时间间隔为1000毫秒。
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private static final int MESSAGE_RECEIVE_NEW_MSG = 1;
private static final int MESSAGE_SOCKET_CONNECTED = 2;
private Button mSendButton;
private TextView mMessageTextView;
private EditText mMessageEditText;
private PrintWriter mPrintWriter;
private Socket mClientSocket;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MESSAGE_RECEIVE_NEW_MSG:
mMessageTextView.setText(mMessageTextView.getText() + (String) msg.obj);
break;
case MESSAGE_SOCKET_CONNECTED:
mSendButton.setEnabled(true);
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mMessageTextView = (TextView) findViewById(R.id.msg_container);
mMessageEditText = (EditText) findViewById(R.id.msg);
mSendButton = (Button) findViewById(R.id.send);
mSendButton.setOnClickListener(this);
Intent service = new Intent(this, TCPServerService.class);
startService(service);
new Thread() {
@Override
public void run() {
connectTCPServer();
}
}.start();
}
@Override
protected void onDestroy() {
if (mClientSocket != null) {
try {
mClientSocket.shutdownInput();
mClientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
super.onDestroy();
}
private void connectTCPServer() {
Socket socket = null;
// while (socket == null) {
try {
socket = new Socket("10.0.2.2", 8888);
mClientSocket = socket;
mPrintWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),
true);
mHandler.sendEmptyMessage(MESSAGE_SOCKET_CONNECTED);
//接收服务端的消息
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
while (!MainActivity.this.isFinishing()) {
String msg = in.readLine();
if (msg != null) {
String time = formatDateTime(System.currentTimeMillis());
msg = "s erver" + time + ":" + msg + "\n";
mHandler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG).sendToTarget();
}
}
mPrintWriter.close();
in.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
// }
}
private String formatDateTime(long l) {
return new SimpleDateFormat("(HH:mm:ss)").format(new Date(l));
}
@Override
public void onClick(View v) {
if (v == mSendButton) {
final String msg = mMessageEditText.getText().toString();
if (!TextUtils.isEmpty(msg) && mPrintWriter != null) {
mPrintWriter.println(msg);
mMessageEditText.setText("");
String time = formatDateTime(System.currentTimeMillis());
final String showedMsg = "self" + time + ":" + "\n";
mMessageTextView.setText(mMessageTextView.getText().toString() + showedMsg);
}
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
Binder连接池
上面我们介绍了不同的IPC方式，我们知道，不同的IPC方式有不同的特点和适用场景，在这里我们要再次介绍AIDL，原因是AIDL是一种最常用的进程间通信方式，是日常开发中涉及进程间通信时的首选。
AIDL我们都会用，但是现在要考虑一种情况，比如说公司的项目越来越大了，现在有10个不同的业务模块都需要使用AIDL来进行进程间通信，那么我们该怎么处理呢？也许你会说：“就按照AIDL的实现方式一个个来吧”，这是可以的，如果使用这种方法，首先我们需要创建10个Service，这好像有点多啊！如果有100个地方需要用到AIDL呢，先创建100个Service？到这里，我们应该明白问题的所在了，随着AIDL数量的增加，我们不能无限制地增加Service，Service是四大组件之一，本身就是一种系统资源。而且太多的Service会使得我们的应用看起来和重量级，因为正在运行的Service可以在应用详情页看到，当我们的应用详情显示10个服务正在运行时，这看起来并不是什么耗时。针对上述问题，我们需要减少Service的数量，将所有的AIDL放在同一个Service中去管理。
在这种模式下，这个工作机制是这样的：每个业务模块创建自己的AIDL接口并实现此接口，这个时候不同业务模块之间是不能耦合的，所有实现细节我们要单独开来，然后向服务端提供自己的唯一标识和其对应的Binder对象；对于服务端来说，只需要一个Service就可以了，服务端提供一个queryBinder接口，这个接口能够根据业务模块的特征来返回相应的Binder对象给它们，不同的业务模块拿到所需的Binder对象后就可以进行远程方法的调用了。由此可见，Binder连接池的主要作用就是将每个业务模块的Binder请求统一转发到远程Service中去执行，从而避免了重复创建Service的过程，它的工作原理如图：
上面说了那么多，可能还是不太好理解，下面我们来通过一个例子来对Binder连接池进行说明，首先，为了说明问题，我们提供了两个AIDL接口（ISecurityCenter 和 ICompute）来模拟上面提到的多个业务模块都要使用AIDL的情况，其实ISecuityCenter 接口提送加密功能，声明如下：
interface ISecurityCenter {
String encrypt(String content);
String decrypt(String password);
}
- 1
- 2
- 3
- 4
而ICompute接口提供计算加法的功能，声明如下：
interface ICompute {
int add(int a, int b);
}
- 1
- 2
- 3
虽然说上面的两个接口的功能都比较简单，但是用于分析Binder连接池的工作原理已经足够了。接着看一下上面两个AIDL接口的实现，也比较简单，代码如下：
public class SecurityCenterImpl extends ISecurityCenter.Stub {
private static final char SECRET_CODE = '^';
@Override
public String encrypt(String content) throws RemoteException {
char[] chars = content.toCharArray();
for (int i = 0; i < chars.length; i++) {
chars[i] ^= SECRET_CODE;
}
return new String(chars);
}
@Override
public String decrypt(String password) throws RemoteException {
return encrypt(password);
}
}
public class ComputeImpl extends ICompute.Stub {
@Override
public int add(int a, int b) throws RemoteException {
return a + b;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
现在业务模块的AIDL接口定义和实现都已经完成了，注意这里并没有为介个模块的AIDL单独创建Service，接下来就是服务端和Binder连接池的工作了。
首先，为Binder连接池创建AIDL接口IBinderPool.aidl，代码如下所示：
interface IBinderPool {
IBinder queryBinder(int binderCode);
}
- 1
- 2
- 3
接着，我们来实现一下IBinderPool这个AIDL接口的实现，代码如下：
public class BinderPoolImpl extends IBinderPool.Stub {
public static final int BINDER_COMPUTE = 0;
public static final int BINDER_SECURITY_CENTER = 1;
@Override
public IBinder queryBinder(int binderCode) throws RemoteException {
IBinder binder = null;
switch (binderCode) {
case BINDER_SECURITY_CENTER:
binder = new SecurityCenterImpl();
break;
case BINDER_COMPUTE:
binder = new ComputeImpl();
break;
}
return binder;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
远程Service的实现就比较简单了，代码如下所示：
public class BinderPoolService extends Service {
private static final String TAG = "BinderPoolService";
private Binder mBinderPool = new BinderPoolImpl();
public BinderPoolService() {
}
@Override
public IBinder onBind(Intent intent) {
return mBinderPool;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
下面还剩下Binder连接池的具体实现，在他的内部首先要去绑定远程服务，绑定成功后，客户单就可以通过它的queryBinder方法去获取各自对应的Binder，拿到所需的Binder以后，不同业务模块就可以进行各自的操作了，Binder连接池的代码如下：
public class BinderPool {
private static final String TAG = "BinderPool";
public static final int BINDER_NONE = -1;
private Context mContext;
private IBinderPool mBinderPool;
private static volatile BinderPool sInstance;
private CountDownLatch mConnectBinderPoolCountDownLatch;
private ServiceConnection mBinderPoolConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mBinderPool = IBinderPool.Stub.asInterface(service);
try {
mBinderPool.asBinder().linkToDeath(mBindPoolDeathRecipent, 0);
} catch (RemoteException e) {
e.printStackTrace();
}
mConnectBinderPoolCountDownLatch.countDown();
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
private IBinder.DeathRecipient mBindPoolDeathRecipent = new IBinder.DeathRecipient() {
@Override
public void binderDied() {
mBinderPool.asBinder().unlinkToDeath(mBindPoolDeathRecipent, 0);
mBinderPool = null;
connectBinderPoolService();
}
};
private BinderPool(Context context) {
mContext = context.getApplicationContext();
connectBinderPoolService();
}
private void getInsance(Context context) {
if (sInstance == null) {
synchronized (BinderPool.class) {
if (sInstance == null) {
sInstance = new BinderPool(context);
}
}
}
}
private synchronized void connectBinderPoolService() {
mConnectBinderPoolCountDownLatch = new CountDownLatch(1);
//开启服务
Intent service = new Intent(mContext, BinderPoolService.class);
mContext.bindService(service, mBinderPoolConnection, Context.BIND_AUTO_CREATE);
}
//根据code获取对应的Binder
public IBinder queryBinder(int binderCode) {
IBinder binder = null;
try {
if (mBinderPool != null) {
binder = mBinderPool.queryBinder(binderCode);
}
} catch (RemoteException e) {
e.printStackTrace();
}
return binder;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
Binder连接池的具体实现就分析完了，它的好处是显然易见的，针对上面的例子，我们只需要创建一个Service即可完成多个AIDL接口的工作，下面我们来验证一下效果。新创建一个Activity，在线程中执行如下操作：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
BinderPool binderPool = BinderPool.getInsance(MainActivity.this);
IBinder securityBinder = binderPool.queryBinder(BinderPoolImpl.BINDER_SECURITY_CENTER);
ISecurityCenter mSecurityCenter = SecurityCenterImpl.asInterface(securityBinder);
String msg = "helloworld-安卓";
try {
String password = mSecurityCenter.encrypt(msg);
System.out.println("encrypt:" + password);
System.out.println(mSecurityCenter.decrypt(password));
} catch (RemoteException e) {
e.printStackTrace();
}
IBinder computeBinder = binderPool.queryBinder(BinderPoolImpl.BINDER_COMPUTE);
ICompute mCompute = ComputeImpl.asInterface(computeBinder);
try {
System.out.println("3 + 5 = " + mCompute.add(3, 5));
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
这个例子中用到了一个CountDownLatch 这个类到底是用来干嘛的呢？可以参考下面这几篇文章去了解下CountDownLatch：
关于例子中提到的 IBinder.DeathRecipient类的使用请参考：
选择合适的IPC方式
1、Bundle
优点：简单易用
缺点：只能传输Bundle支持的数据类型
适用场景：四大组件间的进程间通信2、文件共享
优点：简单易用
缺点：不适合高并发场景，并且无法做到进程间的即时通信
适用场景：无并发访问情形，交换简单的数据实时性不高的场景3、AIDL
优点：功能强大，支持一对多并发通信，支持实时通信
缺点：使用稍微复杂，需要处理号线程问题
适用场景：一对多通信且RPC需求4、Messenger
优点：功能一般，支持一对多串行通信，支持实时通信
缺点：不能很好的处理高并发情形，不支持RPC，数据通过Message进行传输，因此只能传输Bundle支持的数据类型。
适用场景：低并发的一对多即时通信，无RPC需求，或者无须要返回结果的RPC需求5、ContentProvider
优点：在数据源访问方面功能强大，支持一对多并发数据共享，可通过Call方法扩展其他操作
缺点：可以理解为受约束的AIDL，主要提供数据源的CRUD操作
适用场景：一对多的进程间的数据共享5、Socket
优点：功能强大，可以通过网络传输字节流，支持一对多并发实时通信
缺点：实现细节稍微有点繁琐，不支持直接的RPC
适用场景：网络数据的交换
IPC的几个基础知识：序列化和Binder，本章将详细介绍各种跨进程同行方式。具体的方式有很多，比如可以通过在Intent中附加extras来传递信息，或者通过共享文件的方式来共享数据，还可以采用Binder的方式来跨进程通信，另外ContentProvider天生就是支持跨进程访问的，隐藏我们也可以采用它来进行IPC。此外通过网络通信也是可以实现数据传递的，所以Socket也可以实现IPC。上述所说的各种方法都能实现IPC，它们在使用方法和侧重点上都有很大的区别，下面一一进行展开。