IPC——android进程间通信

一,什么是IPC

IPC:inter-process communication,进程间通信或者跨进程通信。window通过剪贴板,管道等进行进程间通信。Linux通过命名管道,共享内存,信号量等进行进程间通信。android有特色的是Binder。 在android进程通信可以有以下方式:aidl,socket通信,使用Bundle,使用contentprovider,使用Messenger,使用文件共享。

二,android的序列化

在android中能用于进程间通信的对象必须是序列化的。序列的方式有两种,一种是实现Serializable接口,一种是实现Parcelable。Serializable是java提供的序列化方法,实现很简单,只要一个类实现了它就完成了序列化。可用于将对象序列化到存储设备或序列化后通过网络传输。但它的效率不高,这里重点介绍Parcelable,它是android自己的实现序列化方法,先看实现Parcelable的代码:

只要一个类实现了这个接口,就可以实现序列化并可以通过Intent和Binder传递。要实现以下方法
(1).writeToParcel(out,flags):实现序列化功能,一系列write。如下
out.writeInt(userId);
out.writeParcelable(book,0);//传另一个序列化类
(2).CREATOR:反序列化,一系列的read方法:如下
userId = in.readInt();
book = in.readParcelable(Thread.currentThread().getContextClassLoader());
(3).decribeContents:内容描述,几乎所有情况都返回0.
完整代码如下
public class Book implements Parcelable {

    public int bookId;
    public String bookName;
    public Book() {

    }

    public Book(int bookId, String bookName) {
        this.bookId = bookId;
        this.bookName = bookName;
    }

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel out, int flags) {
        out.writeInt( bookId);
        out.writeString( bookName);
    }

    public static final Parcelable.Creator<Book> CREATOR = new Parcelable.Creator<Book>() {
        public Book createFromParcel (Parcel in) {
            return new Book(in);
        }

        public Book[] newArray( int size) {
            return new Book[size];
        }
    };

    private Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }

    @Override
    public String toString() {
        return String.format("[bookId:%s, bookName:%s]" , bookId , bookName);
    }

}


系统还提供了一些实现了Parcelable接口的类,如Intent,Bundle,Bitmap.同时List和Map也可以序列化,前提是它们里所有元素都 可以序列化。
Parcelable效率比Serializable高,在内存序列化上用它合适。但在将对象序列化到存储设备或序列化后通过网络传输则建议用Serializable,比较方便。

二,Binder的介绍

Binder用于完成进程间的通信(IPC)。Binder是工作在Linux层,属于一个驱动,这个驱动不需要驱动,Binder代码运行在内核态,调用Binder是系统进行调用。

Binder是一种架构,这种架构提供服务端接口,Binder 接口,客户端接口三个模块。一个Binder 服务端就是一个Binder对象,该对象一旦创建,就会启动一个隐藏线程,该线程会接Binder 驱动发送的消息。收到消息会发调用 onTransact()方法,并按照参数执行不同的服务代码,onTransact() 的参数来源是客户端调用 transact(),若transact() 有固定的输入,onTransact()就有固定的输出 。
一个服务端被创建,会创建一个mRemote对象,它的类型也是Binder类,客户端要访问远程时是通过它。它也重载了transact()方法,重载内容如下:
1,以线程消息通信模式,向服务端发送客户端传递过来的参数。
2.挂起当前线程,并等待服务端线程执行完指定服务函数后通知。
3.接收服务端通知并执行客户端线程,并返回到客户端代码区。
它的调用图如下:

接下来我们来看看如何使用它。
新建两个文件Book.aidl,IBookManager.aidl,其中Book.aidl是上面序列化后文件的一个声明,主意名称要和序列化的类的名称一样。内容如下:
package com.lxj.aidl;

parcelable Book;
再看下 IBookManager.aidl,这个demo主要实现两个方法,所以都需要这此声明:
package com.lxj.aidl;

import com.lxj.aidl.Book;

interface IBookManager {
     List<Book> getBookList();
     void addBook(in Book book);

}
除了基本数据类型外,其它数据类型都要以in out inout来标识,in表示输入,out表示输出,inout即可表示输入也可表示输出。
这时系统会自动生成一个 IBookManager.java文件,内容如下:
package com.lxj.aidl;
public interface IBookManager extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.lxj.aidl.IBookManager
{
private static final java.lang.String DESCRIPTOR = "com.lxj.aidl.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.lxj.aidl.IBookManager interface,
 * generating a proxy if needed.
 */
public static com.lxj.aidl.IBookManager asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.lxj.aidl.IBookManager))) {
return ((com.lxj.aidl.IBookManager)iin);
}
return new com.lxj.aidl.IBookManager.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder()
{
return this;
}
@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_getBookList:
{
data.enforceInterface(DESCRIPTOR);
java.util.List<com.lxj.aidl.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook:
{
data.enforceInterface(DESCRIPTOR);
com.lxj.aidl.Book _arg0;
if ((0!=data.readInt())) {
_arg0 = com.lxj.aidl.Book.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.lxj.aidl.IBookManager
{
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;
}
@Override public java.util.List<com.lxj.aidl.Book> getBookList() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<com.lxj.aidl.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.lxj.aidl.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public void addBook(com.lxj.aidl.Book book) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book!=null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.util.List<com.lxj.aidl.Book> getBookList() throws android.os.RemoteException;
public void addBook(com.lxj.aidl.Book book) throws android.os.RemoteException;
}
asInterface:用于将服务端的Binder对象转换成客户端所需的AIDL对象,同一进程返回的是服务端的Stub,不同进程返回系统封闭后的Stub.proxy对象。
asBinder:用于返回当前 的Binder对象。
onTransact(code,data,reply,flags):运行在服务端的Binder线程池中,客户端发出的请求会在此处理。code可以确定客户端的请求目标方法是什么,data取出参数,运行完把结果赋给reply。如果返回false,则客户端请求会失败(可用于权限判断)。
getBookList:首先创建输入输出的Parcel对象_data,_reply。接着调用transact方法来发起RPC(远程过程调用)请求,同时挂起线程,然后服务端onTransact会调用,直到RPC执行完,当前线程继续执行,并从_reply取出RPC结果。返回。

四,AIDL进程间调用

aidl是最常见的进程调用方式。我们先创建两个应用,模拟进程间通信(不同应用)。客户端的代码如下:
protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		Intent intent = new Intent("com.lxj.servicetest.MyAIDLService");
        bindService(intent, connection, Context.BIND_AUTO_CREATE);
	}
	private ServiceConnection connection = new ServiceConnection() {
		
		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub
			
		}
		
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// TODO Auto-generated method stub
			IBookManager bookManager = IBookManager.Stub.asInterface(service);
			try {
				List<Book> list = bookManager.getBookList();
				Log.e("list", list.toString());
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	};
通过bindService绑定服务端Binder,然后通过IBookManager.Stub.asInterface()来获得服务端返回的AIDL对象,就可以调用到服务端的方法(getBookList)。再看下服务端代码:
public class MyBookService extends Service {
	private CopyOnWriteArrayList<Book> mBooks = new CopyOnWriteArrayList<Book>();
	
	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		super.onCreate();
		mBooks.add(new Book(1,"java虚拟机"));
		mBooks.add(new Book(2,"android疯狂讲义"));
	}

	private Binder mBinder = new IBookManager.Stub() {
		//虽然IBinder只能传输List,但是服务端之所以可以用CopyOnWriteArrayList是因为它会自动在传输时转化为list
		@Override
		public List<Book> getBookList() throws RemoteException {
			// TODO Auto-generated method stub
			return mBooks;
		}
		
		@Override
		public void addBook(Book book) throws RemoteException {
			// TODO Auto-generated method stub
			mBooks.add(book);
		}
	};

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return mBinder;
	}

}
自定义了一个Service并在list中添加两本书,所以客户端就能在控制台上打印出这两本书。注意要在AndroidFest.xml添加上Service的声明:
   <service
            android:name="com.lxj.aidl.MyBookService"
            >
            <intent-filter>  
            <action android:name="com.lxj.servicetest.MyAIDLService"/>  
        </intent-filter> 
        </service>

四,Messenger进程间通信

android提供Messenger可以实现不同进程间的信息传递,相比AIDL它的调用简单很多,但是它是有缺点的,它只能串行处理发送的信息,如里信息过多就会阻塞。其次它只能传输基本数据类型,What,arg1,Bundle等,并不能传输自定义的对象。Messenger是一种种轻量级的IPC方案,一次处理一个请求。
1.服务端:
创建一个Service来处理客户端连接请求,同时创建一个Handler并通过它来创建一个Message对象,然后在OnBinder中返回这个Binder。
2.客户端:
首先绑定服务端Service,通过返回的IBinder创建一个messager。这个就可以给服务端发消息了,如果需要服务端返回,则也要跟服务端一个创建Handler,通过Message的replyTo参数传递给服务端。
先看下客户端的代码:
先看客户端代码:
public class MainActivity extends Activity {
	TextView txvTextView ;
	private Messenger mService;
	private Messenger clientMessenger = new Messenger(new MessengerHandler());
	private static class MessengerHandler extends Handler{

		@Override
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			switch(msg.what){
			case 1:
				Log.e("msg from service",  msg.getData().getString("reply"));
				break;
			 default:
	        super.handleMessage(msg);
			}
		}
		
	}
	private ServiceConnection connection = new ServiceConnection(){

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// TODO Auto-generated method stub
			 mService = new Messenger(service);
			Message msgMessage = Message.obtain(null,0);
			Bundle b = new Bundle();
			b.putString("client", "Hi,i am client");
			msgMessage.setData(b);
			msgMessage.replyTo = clientMessenger;
			try {
				mService.send(msgMessage);
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub
			
		}


	};
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		txvTextView = (TextView)super.findViewById(R.id.txv);
		Intent i = new Intent(this,MessengerService.class);
		bindService(i, connection, Context.BIND_AUTO_CREATE);
	}

	   @Override
	    protected void onDestroy() {
	        unbindService(connection);
	        super.onDestroy();
	    }

}
看到上面的代码我们可以很清楚的看到,Messenger也是用AIDL实现进程间通信的。通过Messenger发送消息到服务端,handler中获取服务端返回的replyto。再看下服务端代码:
public class MessengerService extends Service{
	private final Messenger mMessenger = new Messenger(new MessengerHandler());
	private static class MessengerHandler extends Handler{

		@Override
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			switch(msg.what){
			case 0:
				Log.e("msg from client",  msg.getData().getString("client"));
				Message message = Message.obtain(null,1);
				Messenger messenger = msg.replyTo;//从客户端得到的messenger,用于在客户端中显示
				Bundle bundle = new Bundle();
				
				bundle.putString("reply", "Hi,i am service");
				message.setData(bundle);
				try {
					Thread.sleep(1000);
					messenger.send(message);
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				break;
			 default:
	        super.handleMessage(msg);
			}
		}
		
	}

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return  mMessenger.getBinder();
	}

}
这里就是获取到信息后再把信息发送回客户端。完成了不同进程的信息传递。
这里只是简单介绍两种IPC方式,还有很多常用方式如socket通信,ContentProvider等都可以实现IPC。本文只是总结下自己对IPC的认识。





评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值