Android中IPC常见的方式包括：文件、Bundle、Messenger、ContentProvider、Socket和AIDL（这种可能用的最多吧）。
在使用IPC之前，必须要知道另外两个小东西-Serializable和Parcelable，这两个类是java中用来序列化对象的，他们都是接口，随便implement哪个都能实现序列化和反序列化。
1、Serializable
这个是java自带的序列化接口，一切想要被序列化的对象，只需要实现这个接口就具备序列化的功能了。
public class Book implements Serializable {
private static final long serialVersionUID = 1L;
}
String file=getExternalCacheDir().getAbsolutePath()+ File.separator+"book.txt";
Book book=new Book("android develop","Rainbow556");
try {
ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream(file));
out.writeObject(book);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
ObjectInputStream in =new ObjectInputStream(new FileInputStream(file));
Book b= (Book) in.readObject();
in.close();serialVersionUID是非常重要的，它标识着该Book类的版本，因为在把Book类写到SD卡上的时候，同时也会把 serialVersionUID也写入进去，而在反序列化的时候就会比较这个值是否相等，相等则可以反序列化，反之。
2、Parcelable
这个是Android特有的序列化类，Parcelable的在效率上比Serializable高，但实现起来比较麻烦，如下：
public class User implements Parcelable {
private String name;
private int age;
public User(String name,int age){
this.name=name;
this.age=age;
}
/**
* 用于反序列化
* @param in
*/
private User(Parcel in) {
name=in.readString();
age=in.readInt();
}
public static final Creator<User> CREATOR = new Creator<User>() {
@Override
public User createFromParcel(Parcel in) {
return new User(in);
}
@Override
public User[] newArray(int size) {
return new User[size];
}
};
@Override
public int describeContents() {
return 0;
}
/**
* 用于序列化
* @param dest
* @param flags
*/
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
几种常见的IPC方式
1、文件
就是进程之间按照约定去访问一个共享文件来实现数据交换实现通信，例如SharedPreference、File，这种方法比较简单，按照约定存数据和取数据，不多说。
2、Bundle
Bundle是可以放到Intent里的，和Map差不多，通过key-value的形式映射，但是里面的value只能是基本数据类型、String和实现了Serializable或者Parcelable接口的对象。我们在做activity跳转、发送广播和启动服务的时候都可以传入一个Intent参数，如果要启动的组件是运行在另一个进程中的话，而且又要传递一个我们自定义的对象时，这个时候之前说的Serializable和Parcelable接口就发挥作用了，因为我们实现了这个接口，就能放到Bundle中通过Intent去传递了（如果该进程是其他app的话，后面再说，因为其他app是没有我们那个自定义对象.java文件的）。
3、Messenger
翻译过来就是“信使”的意思，这是一个轻量级的IPC方式，底层是通过AIDL来实现，只不过做了封装，方便使用而已。Messenger发送消息的载体是Message，也就是handler里常用的Message，Message里只能放基本数据类型和实现了Serializable或者Parcelable接口的数据。简单的使用如下：
创建一个Service，运行在另外一个进程中：
<service
android:name=".service.MessengerService"
android:enabled="true"
android:exported="true"
android:process=":messenger"></service>
public class MessengerService extends Service {
/**
* 创建一个Messenger，并与一个handler关联
*/
private Messenger messenger=new Messenger(new ServerHandler());
public MessengerService() {
}
@Override
public IBinder onBind(Intent intent) {
//返回Messenger底层的Binder对象
return messenger.getBinder();
}
/**
* 用于接收和处理客户端发来的消息
*/
public static class ServerHandler extends Handler{
public final static int MSG_FROM_CLIENT=0;
public final static int MSG_FROM_SERVER=1;
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what==MSG_FROM_CLIENT){
Log.e("lx",msg.getData().getString("msg"));
//拿到客户端的Messenger，给客户端发消息
Messenger clientMessenger=msg.replyTo;
Message replyMsg=Message.obtain(null, MSG_FROM_SERVER);
Bundle bundle=new Bundle();
bundle.putString("msg","yes , i got it");
replyMsg.setData(bundle);
try {
clientMessenger.send(replyMsg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
}
@Override
public void onDestroy() {
super.onDestroy();
Log.e("lx","service destroyed");
}
}
public class MainActivity extends Activity {
/**给服务端发消息的Messenger*/
private Messenger messenger;
/**接收服务端消息的Messenger*/
private Messenger mGetReplyMsger =new Messenger(new ClientHandler());
private ServiceConnection mServiceConnection=new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e("lx","service connected");
//拿到服务端传来的IBinder对象实例化Messenger
messenger=new Messenger(service);
Message msg=Message.obtain(null, MessengerService.ServerHandler.MSG_FROM_CLIENT);
Bundle bundle=new Bundle();
bundle.putString("msg","this is a msg from client");
msg.setData(bundle);
//把接收服务端消息的Messenger传递给服务端，这样就可以对服务端的消息做出回应
msg.replyTo= mGetReplyMsger;
try {
messenger.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e("lx","service disconnected");
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
useMessengerForIPC();
}
/**
* 使用Messenger实现IPC
*/
private void useMessengerForIPC() {
Intent intent=new Intent(this,MessengerService.class);
bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
}
/**接收和处理服务端消息的handler*/
public static class ClientHandler extends android.os.Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if(msg.what== MessengerService.ServerHandler.MSG_FROM_SERVER){
String msgFromServer=msg.getData().getString("msg");
Log.e("lx",msgFromServer);
}
}
}需要注意的是：在同一个进程当中，我们一般使用Message.obj传递对象，不过当在不同进程中时， 只支持系统提供的某些实现了Parcelable接口的对象。如果要传输自定义的对象，我们可以使用Bundle来传输。
4、ContentProvider
看到ContentProvider我们应该不陌生吧，相信在平时的开发中我们多多少少使用过这个小东西，比如获取手机联系人、短信等数据，都是通过ContentProvider实现的，仔细想想联系人和短信都是系统app的数据，而我们在自己的app中获取其他app的数据，这也就是进程间通信了。ContentProvider只是提供操作真正数据源的接口，对于具体的数据源是来自文件或是数据库这只是ContentProvider自己需要实现的，外界要获取这些数据时，需要通过ContentResolver类。我们创建一个数据库DBHelper类，这里我们把数据库作为数据源，代码如下：
public class DBHelper extends SQLiteOpenHelper{
public static final String TABLE_NAME="book";
private static final String SQL="create table if not exists book(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, author VARCHAR) ";
public DBHelper(Context context) {
super(context, "book.db", null, 1);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("drop table if exists book");
onCreate(db);
}
}
public class BookProvider extends ContentProvider {
private static final String AUTHORITY = "com.bookprovider.www";
private static final Uri NOTIFY_URI = Uri.parse("content://" + AUTHORITY + "/books");
private static final int BOOK_ALL = 0;
private static final int BOOK_ONE = 1;
/**这里的数据源来自database数据库*/
private DBHelper dbHelper;
/**用于匹配调用者传来的Uri*/
private final static UriMatcher matcher;
//添加Uri
static {
matcher = new UriMatcher(UriMatcher.NO_MATCH);
matcher.addURI(AUTHORITY, "books", BOOK_ALL);
matcher.addURI(AUTHORITY, "books/#", BOOK_ONE);
}
public BookProvider() {
}
@Override
public boolean onCreate() {
dbHelper = new DBHelper(getContext());
return true;
}
@Override
public String getType(Uri uri) {
int type = matcher.match(uri);
switch (type) {
case BOOK_ONE:
return "";
case BOOK_ALL:
return "";
default:
throw new UnsupportedOperationException("Not yet implemented");
}
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
//先用UriMatcher匹配传入的Uri，得到type
int type = matcher.match(uri);
switch (type) {
case BOOK_ONE:
//获取uri中要操作的id，也就是book表中的_id主键
long id = ContentUris.parseId(uri);
selection = "_id=?";
selectionArgs = new String[]{String.valueOf(id)};
break;
case BOOK_ALL:
break;
default:
throw new UnsupportedOperationException("unsupport uri");
}
int rows = dbHelper.getWritableDatabase().delete(DBHelper.TABLE_NAME, selection, selectionArgs);
//如果数据库中有数据变动，则通知其他ContentObserver
if (rows > 0) {
notifyDataChanged();
}
return rows;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
int type = matcher.match(uri);
if (type != BOOK_ALL)
throw new UnsupportedOperationException("unsupport uri");
long id = dbHelper.getWritableDatabase().insert("book", null, values);
if(id!=-1)
notifyDataChanged();
return ContentUris.withAppendedId(NOTIFY_URI, id);
}
@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
int type = matcher.match(uri);
switch (type) {
case BOOK_ONE:
long id = ContentUris.parseId(uri);
selection = "_id=?";
selectionArgs = new String[]{String.valueOf(id)};
break;
case BOOK_ALL:
break;
default:
throw new UnsupportedOperationException("unsupport uri");
}
return dbHelper.getReadableDatabase().query("book", projection, selection, selectionArgs, null, null, sortOrder);
}
@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
int type = matcher.match(uri);
switch (type) {
case BOOK_ONE:
long id = ContentUris.parseId(uri);
selection = "_id=?";
selectionArgs = new String[]{String.valueOf(id)};
break;
case BOOK_ALL:
break;
default:
throw new UnsupportedOperationException("unsupport uri");
}
int rows = dbHelper.getWritableDatabase().update("book", values, selection, selectionArgs);
if (rows > 0) {
notifyDataChanged();
}
return rows;
}
private void notifyDataChanged() {
getContext().getContentResolver().notifyChange(NOTIFY_URI, null);
}
}
<provider
android:name=".provider.BookProvider"
android:authorities="com.bookprovider.www"
android:enabled="true"
android:exported="true"
android:process=":provider"></provider>接下来看如何在activity中调用，由于activity的布局比较简单，包含四个button，对应着insert、delete、update、query四个操作，直接贴上onClick方法：
@Override
public void onClick(View v) {
Uri uri=null;
ContentValues values=null;
switch (v.getId()) {
case R.id.btn_insert:
values=new ContentValues();
values.put("name","android2");
values.put("author","rainbow556");
getContentResolver().insert(URI_ALL_BOOK,values);
break;
case R.id.btn_query:
// uri= ContentUris.withAppendedId(URI_ALL_BOOK,1);
Cursor cursor=getContentResolver().query(URI_ALL_BOOK, null, null, null, null);
if(cursor!=null && cursor.getCount()>0){
while (cursor.moveToNext()){
Log.e("lx",cursor.getString(0)+" , "+cursor.getString(1)+" , "+cursor.getString(2));
}
}
if(cursor!=null){
cursor.close();
}
break;
case R.id.btn_update:
uri= ContentUris.withAppendedId(URI_ALL_BOOK,1);
values=new ContentValues();
values.put("name","c++");
getContentResolver().update(uri,values,null,null);
break;
case R.id.btn_delete:
uri= ContentUris.withAppendedId(URI_ALL_BOOK,1);
getContentResolver().delete(URI_ALL_BOOK,null,null);
break;
}
}5、Socket
由于使用Socket进行进程间通信和一般的Socket操作基本类似，所以就不细说了。步骤如下：在服务端启动一个Service，在Service创建的时候启动一个线程，在这个线程中建立一个ServerSocket监听本地一个自定义的本地端口，等待客户端的连接；而客户端只需要创建一个Socket，去连接服务端，地址为“localhost”，而端口则是之前定义的，一旦建立了连接，就可以通过Socket的流进行数据传输了。
6、AIDL
将在下一篇博客中介绍。
6453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
