上篇文章介绍了IPC机制的基本概念以及简单使用，文章链接：Android 关于IPC机制的理解(一) 这篇文章主要是关于IPC的方式，也就是用什么方式来进行进程间通信；
介绍使用前首先我们得了解几个概念，就是序列化和反序列以及Binder。
序列化和反序列化
在Java中序列化是指把java对象转换成字节码的过程，反序列化是指把字节码恢复为Java对象的过程，既然涉及进程间的通信那就必须涉及到序列化了和反序列化，在Android中一共有两个接口可以完成，第一个是Serializable另一个是Parcelable；
Serializable是Java1.1出来的一个特性，它是一个空接口，用它可以为对象提供序列化和反序列化操作，Serializable使用起来不困难，只要在实体类实现这个接口然后自定义添加一个唯一标识就可以了，这里就不在举例了；
值得说一说的是Parceable，Parcelable是Android为我提供的一个实现序列化方法的接口，只要一个对象实现这个接口就可以实现了序列化然后用Intent、Binder来传递这个对象了，可能我们会有疑问，既然有了Serializable为什么Android还要提供这个接口来实现序列化呢？其实是有原因的，Serializable虽然使用简单但是开销很大，因为Serializable是通过I/O操作来实现的，在序列化过程中用到了大量的反射，产生了很多临时变量，Parceable相对来说会更轻便，性能上要优于Serializable，所以Android也推荐使用Parceable来实现序列化。下面用一个例子实现Parcelable然后讲解里面的方法。
public class ParcelableBean implements Parcelable {
String name;
int year;
/**
* 返回当前对象的内容描述
* @return
*/
@Override
public int describeContents() {
return 0;//如果有文件扫描符，返回1，没有返回0
}
/**
* 将当前对象写入序列化结构中
*
* @param dest 序列化对象
* @param flags 标识值
*/
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(this.name);
dest.writeInt(this.year);
}
public ParcelableBean() {
}
/**
* 从序列化后的对象中创建原始对象
* @param in 序列化后的对象
*/
protected ParcelableBean(Parcel in) {
this.name = in.readString();//读取序列化对象中的字符串值
this.year = in.readInt();
}
/**
* 反序列化功能
*/
public static final Parcelable.Creator<ParcelableBean> CREATOR = new Parcelable.Creator<ParcelableBean>() {
/**
* 从序列化后的对象中创建原始对象
* @param source
* @return
*/
@Override
public ParcelableBean createFromParcel(Parcel source) {
return new ParcelableBean(source);
}
/**
* 创建指定长度的原始对象数组
* @param size
* @return
*/
@Override
public ParcelableBean[] newArray(int size) {
return new ParcelableBean[size];
}
};
}
Binder
Binder要研究起来是可以很深入和很复杂得，这里就不在详述，如果有兴趣可以参考这篇文章<<Android Bander设计与实现 - 设计篇>>,本文就大概介绍，Binder是Android中的一个实现了IBinder接口的类，也是一种跨进程通信的方式，从Android应用框架层(Android Framework)来说它是ServiceManager链接各种Manager和相应ManagerService的桥梁；从Android应用层(Android Applications)来说Binder是客户端和服务端进行通信的中介，比如Service中的bindService时服务端会返回一个包含Binder对象，同过这个对象就可以获取服务端提供的数据，在Android中Binder主要用在Service中，下文讲Android中跨进程通信的方式时也会说到Binder。
Android进行跨进程通信的方式
(1).使用Bundle
在Android中，Activity、Service、Receiver都可以用Bundle进行数据传递，这是因为Bundle实现了Parcelable接口，这个我们在日常开发应该是经常使用的，值得注意的是在使用Bundle附加需要传输的数据时要确定传输的数据可以被序列化，也就是传递的对象必须实现了Parcelable或Serializable接口。
(2).文件共享
就是两个进程读/写同一个文件来进行数据交互但是在使用这种方式进行通信的同时要注意并发的问题，避免两个进程同时并发写当前文件，这种方式适合在对数据同步性要求不高的进程间进行通信。
(3).使用Messenger
通过在Messenger中存放需要进行交互的数据，然后就可以在进程间进行传递,下面用一个例子来说明如何使用Messenger在不同进程中进行数据传递，例子很简单，就是Activity中通过Messenger给Service发送段话，首先是Activity的代码。
public class MainActivity extends Activity {
MyServiceConnection con;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MyService.class);
con = new MyServiceConnection();
bindService(intent, con, BIND_AUTO_CREATE);//绑定服务
}
/**
* 服务连接
*/
class MyServiceConnection implements ServiceConnection {
/**
* 已经建立连接
*
* @param name
* @param service
*/
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Messenger msgr = new Messenger(service);
Message msg = new Message();
msg.what = 1;//标示
Bundle data = new Bundle();
data.putString("msg", "哈喽");
msg.setData(data);
try {
msgr.send(msg);//发送消息
} catch (RemoteException e) {
e.printStackTrace();
}
}
/**
* 连接失败
*
* @param name
*/
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(con);//解绑服务
}
}接着是Service，这里我已经给Service设置了不同的进程
<service
android:name=".MyService"
android:process=":messenger" />Service代码为
public class MyService extends Service {
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == 1) {
Log.d("print", msg.getData().getString("msg"));
}
}
};
private final Messenger msgr = new Messenger(handler);
@Nullable
@Override
public IBinder onBind(Intent intent) {
return msgr.getBinder();
}
}
通过上面的小例子我们就完成了一次使用Messenger在不同进程间通信了。但是用Messenger是有一定局限性的，因为Messenger是用串行的方式来处理消息，如果数据大量的话，也只能是一个个来发送和处理，这样应对数据并发显然不大可能，而且这只是数据交互，如果想调用不同进程方法显然更不可能。
(4)使用AIDL
AIDL(Android interface definition language)安卓接口定义语言，它的作用就是进行跨进程通信，下面用一个示例来演示两个进程间通信， 在Activity中调用另一个进程中Service的方法，我用的是Android studio，在这个工具中使用AIDL跟Eclipse略有不同，下面我一步来说明怎么实现功能：
首先右键新建一个aidl文件，这里我命名为IMyAidlInterface .aidl,这时as会自动帮我生成一个.aidl的文件，如图：
然后修改.aidl文件代码如下
// IMyAidlInterface.aidl
package com.sjr.ipcdemo;
// Declare any non-default types here with import statements
/**
* 注意AIDL只支持下面几种类型：基本数据类型，String、CharSequence、ArrayList、Map、
* 实现了Parcelable的接口对象、其他AIDL接口,
*/
interface IMyAidlInterface {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.\
*
*/
void show();
}上面的void show()方法是我想要共享的方法，这时gen目录并没有生成对应的接口文件（跟Eclipse不同），我们在AS中点击Build->Make Project(快捷键Ctrl+F9),这样gen目录就生成了对应的接口文件了，如图
生成的接口文件为(这里没兴趣的可以跳过，只是我加了点注释便于理解Android为我们生成的是什么，有点深入了)
/*
* This file is auto-generated. DO NOT MODIFY.(这个文件是自动生成的，不要修改！！！！)
* Original file: D:\\sjr\\lianyiwork\\MyApplication\\ipcdemo\\src\\main\\aidl\\com\\sjr\\ipcdemo\\IMyAidlInterface.aidl
*/
package com.sjr.ipcdemo;
// Declare any non-default types here with import statements（声明非默认的类型和导入语句）
public interface IMyAidlInterface extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.sjr.ipcdemo.IMyAidlInterface {
/**
* BInder的唯一标识，一般用当前Binder的类名来表示
*/
private static final java.lang.String DESCRIPTOR = "com.sjr.ipcdemo.IMyAidlInterface";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.sjr.ipcdemo.IMyAidlInterface interface,
* generating a proxy if needed.
* 将被请求共享进程的Binder对象转换成请求共享进程所需的AIDL接口类型对象
* (区分进程，如果在同一进程返回的是被请求进程的Stub本身，否则返回的是系统封装之后的Stub.proxy对象)
*/
public static com.sjr.ipcdemo.IMyAidlInterface asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.sjr.ipcdemo.IMyAidlInterface))) {
return ((com.sjr.ipcdemo.IMyAidlInterface) iin);
}
return new com.sjr.ipcdemo.IMyAidlInterface.Stub.Proxy(obj);
}
/**
* 返回当前的Binder对象
* @return
*/
@Override
public android.os.IBinder asBinder() {
return this;
}
/**
* 运行在Service中的Binder线程池中,当有跨进程请求时，远程请求会通过系统底层封装后交由此方法处理
* @param code 请求码
* @param data 数据
* @param reply 写入返回值
* @param flags 标示
* @return 返回false的共享请求会失败
* @throws android.os.RemoteException
*/
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_show: {
data.enforceInterface(DESCRIPTOR);
this.show();
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
/**
* 要请求共享的进程请求调用时执行
*/
private static class Proxy implements com.sjr.ipcdemo.IMyAidlInterface {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.\
* 方法名跟调用的方法名一样
*/
@Override
public void show() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_show, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_show = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.\
* 方法名跟调用的方法名一样
*/
public void show() throws android.os.RemoteException;
}然后是Service的方法，然后更换为其他进程，这里给Service加了个action，是考虑到如果是不同应用时Intent跳转不能用this,XXX.class，只能根据action来跳，单个应用可用不用设置action，一样是可行的。
<service
android:name=".TestAIDLService"
android:process=":hello">
<intent-filter>
<action android:name="com.sjr.ipcdemo.hello" />
</intent-filter>
</service>Service代码为：
public class TestAIDLService extends Service {
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new Intermediary();
}
/**
* 用一个中介类去继承自己写好的接口
*/
class Intermediary extends IMyAidlInterface.Stub {
/**
* 然后在这个回调方法里调用Service方法
*
* @throws RemoteException
*/
@Override
public void show() throws RemoteException {
TestAIDLService.this.show();
}
}
public void show() {
Log.d("print", "哈喽这是Service的方法");
}
}public class MainActivity extends Activity {
MyServiceConnection con;
IMyAidlInterface mAidl;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
con = new MyServiceConnection();
//5.0以后Service必须显示启动
// 否则异常 java.lang.IllegalArgumentException: Service Intent must be explicit: Intent { act=com.sjr.ipcdemo.hello }
Intent intent = new Intent("com.sjr.ipcdemo.hello").setPackage("com.sjr.ipcdemo");
bindService(intent, con, BIND_AUTO_CREATE);
Button btn1 = (Button) findViewById(R.id.btn1);
btn1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
mAidl.show();
} catch (RemoteException e) {
e.printStackTrace();
}
}
});
}
class MyServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mAidl = IMyAidlInterface.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(con);
}
}当我点击按钮就调用Service的方法打出Log，Log为：
这样就完成了一次使用AIDL进行简单的跨进程通信了，有点需要注意的是在5.0以后Service必须是显示启动。
（5）.使用ContentProvider(内容提供者)
ContentProvider是Android四大组件之一，也是Android提供的专门用于不同应用数据共享的方式，所以ContentProvider也是跨进程通信的方式之一，ContentProvider底层也是Binder，也同样是因为它是Android系统提供的共享数据方式之一，所以Android对ContentProvider进行了良好的封装，我们不用关心底层实现就可以实现跨进程通信，系统也提供了很多ContentProvider，比如通讯录、短信等，要操作这些数据使用的是ContentResolver。下面用一个示例来演示ContentProvider实现多进程通信，例子比较简单，就是利用ContentProvider给一个数据库插入一条语句，然后提供给其他进程的Activity操作
首先是先创建数据库：
public class MyOpenHelper extends SQLiteOpenHelper {
public MyOpenHelper(Context context) {
super(context, "people.db", null, 1);
}
/**
* 创建数据库表
*
* @param db
*/
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table person(_id integer primary key, name char(10), age integer(20))");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}public class PersonProvider extends ContentProvider {
private MyOpenHelper mHelper;
private SQLiteDatabase mDatabase;
//创建uri匹配器对象
private static UriMatcher mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
//匹配uri
static {
mMatcher.addURI("com.sjr.ipcdmo.people", "person", 1);
}
@Override
public boolean onCreate() {
mHelper = new MyOpenHelper(getContext());
mDatabase = mHelper.getWritableDatabase();//获取一个可写的数据库
//开启新线程插入一条数据
new Thread(new Runnable() {
@Override
public void run() {
mDatabase.execSQL("delete from person");
mDatabase.execSQL("insert into person values(1,'李子明',2);");
}
}).start();
return false;
}
/**
* 查询
* @param uri
* @param projection
* @param selection
* @param selectionArgs
* @param sortOrder
* @return
*/
@Nullable
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
Cursor cursor = null;
if (mMatcher.match(uri) == 1)
cursor = mDatabase.query("person", projection, selection,
selectionArgs, null, null, sortOrder, null);
else
throw new IllegalArgumentException("uri不对");
return cursor;
}
@Nullable
@Override
public String getType(Uri uri) {
if (mMatcher.match(uri) == 1)
return "van.android.cursor.dir/person";
return null;
}
/**
* 其他应用调用，用于忘数据库里插入数据
*
* @param uri 内容提供者的地址
* @param values 由其他应用传入，用于封装要插入的数据
* @return
*/
@Nullable
@Override
public Uri insert(Uri uri, ContentValues values) {
if (mMatcher.match(uri) == 1) {
mDatabase.insert("person", null, values);
//发送数据改变通知,所有注册在这个uri的内容观察者都可以收到这个通知
getContext().getContentResolver().notifyChange(uri, null);
} else
throw new IllegalArgumentException("uri不对");
return uri;
}
/**
* 删除
* @param uri
* @param selection
* @param selectionArgs
* @return
*/
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
return 0;
}
/**
* 更新
* @param uri
* @param values
* @param selection
* @param selectionArgs
* @return
*/
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
return 0;
}
}
<provider
android:name=".provider.PersonProvider"
android:authorities="com.sjr.ipcdmo.people"
android:process=":provider" />然后在Activity中使用ContentResolver来对数据库操作：
public class ContentProviderActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//在Activity中也插入一条数据，这时应该有两条了
ContentResolver resolver = getContentResolver();
ContentValues values = new ContentValues();
values.put("_id", 2);
values.put("name", "李大哥");
values.put("age", 5);
resolver.insert(Uri.parse("content://com.sjr.ipcdmo.people/person"), values);
//查询所有
Cursor query = resolver.query(Uri.parse("content://com.sjr.ipcdmo.people/person"), new String[]{"name", "age"}, null, null, null);
while (query.moveToNext()){
Log.d("print","姓名:"+query.getString(0)+"年龄:"+query.getString(1));
}
}
}
上面就是一个使用ContentProvider进行跨进程通信的一个小示例；有一个注意的是Provider的query、update、insert、delete存在多线程并发访问时方法内部要做好线程同步。
（6）.使用Socket
Socket也叫"套接字"，是网络中的概念，下面用Socket来演示一个跨进程通信的示例：
首先是服务端:
public class TCPServerService extends Service {
private boolean mIsServiceDestoryed = false;
private String[] mMessages = new String[]{
"哈喽", "嗨", "你好", "吃饭了吗"
};
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
new Thread(new Runnable() {
@Override
public void run() {
ServerSocket socket = null;
try {
socket = new ServerSocket(8068);
} catch (IOException e) {
e.printStackTrace();
return;
}
while (!mIsServiceDestoryed) {
try {
final Socket client = socket.accept();//接受客户端请求
Log.d("print","accept");
new Thread(new Runnable() {
@Override
public void run() {
try {
responseClient(client);
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}).start();
}
@Override
public void onDestroy() {
super.onDestroy();
mIsServiceDestoryed = true;
}
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("welcom");
while (!mIsServiceDestoryed) {
String str = in.readLine();
Log.d("print","msg from client:" + str);
if (str == null) {
break;
}
int i = new Random().nextInt(mMessages.length);
String msg = mMessages[i];
out.println(msg);
Log.d("print","send :" + msg);
}
Log.d("print","client quit.");
// 关闭流
if (out != null)
out.close();
if (in != null)
in.close();
client.close();
}
} <service
android:name=".socket.TCPServerService"
android:process=":service" /><pre name="code" class="html"><uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />接着是客户端Activity：
public class TCPClentActivity extends Activity 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;
@SuppressLint("HandlerLeak")
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;
}
default:
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tcpclient);
mMessageTextView = (TextView) findViewById(R.id.msg_container);
mSendButton = (Button) findViewById(R.id.send);
mSendButton.setOnClickListener(this);
mMessageEditText = (EditText) findViewById(R.id.msg);
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();
}
@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 + ":" + msg + "\n";
mMessageTextView.setText(mMessageTextView.getText() + showedMsg);
}
}
}
@SuppressLint("SimpleDateFormat")
private String formatDateTime(long time) {
return new SimpleDateFormat("(HH:mm:ss)").format(new Date(time));
}
private void connectTCPServer() {
Socket socket = null;
while (socket == null) {
try {
socket = new Socket("localhost", 8068);
mClientSocket = socket;
mPrintWriter = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(socket.getOutputStream())), true);
mHandler.sendEmptyMessage(MESSAGE_SOCKET_CONNECTED);
System.out.println("connect server success");
} catch (IOException e) {
SystemClock.sleep(1000);
Log.d("print","connect tcp server failed, retry...");
}
}
try {
// 接收服务器端的消息
BufferedReader br = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
while (!TCPClentActivity.this.isFinishing()) {
String msg = br.readLine();
System.out.println("receive :" + msg);
if (msg != null) {
String time = formatDateTime(System.currentTimeMillis());
final String showedMsg = "server " + time + ":" + msg
+ "\n";
mHandler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG, showedMsg)
.sendToTarget();
}
}
System.out.println("quit...");
if (mPrintWriter!=null)
mPrintWriter.close();
if (br!=null)
br.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
当Activity启动时会连接服务端Socket，因为主线程不能联网，所以新开一个线程去连接，然后为了确定连接成功，采用了超时重连策略，重试时间为1秒，重上面的两个类就可以完成一次使用Socket进行通信的示例了，效果为：
总结
跨进程通信就是上述几个了，他们的优缺点为：
源码地址：http://download.csdn.net/detail/lxzmmd/9527343
1322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
