IPC基础概念介绍

介绍一下IPC中的一些基础概念，主要包含三个方面内容:Serializable接口，Parcelable接口以及Binder，只有熟悉这三方面的内容之后，我们才能更好的理解跨进程通信的各种方式。

Serializable接口

Serializable是Java所提供的一个序列化接口，他是一个空接口，为对象提供标准的序列化和反序列化操作，使用Serializable来实现序列化相当简单，只需要在类的申明中指定一个类似下面的表示即可自动实现默认的序列化过程。

private static final long serialVersionUID=87113010083044l

相应的反序列化操作：

//序列化过程
User user=new User(0,"jake",true);
ObjectOutputStream out=new ObjectOutputStream (new FileOutputStream("cache.txt"));
out.close();
//反序列化过程
ObjectInputStream in=new ObjectInputStream(new FileInputStream("cache.txt"));
User newUser=(User)in.readObject();
in.close();

但是需要注意的是，恢复后的对象newUser和user的内容完全一样，但是两者并不是同一个对象。

上面提到的serialVersionUID到底有没有用？其实不指定serialVersionUID也可以实现序列化，但是，系统既然提供了这个serialVersionUID必然有它的用武之地，原则上，序列化后的数据中的serialVersionUID只有和当前类的serialVersionUID相同才能够正常的被反序列化。
serialVersionUID的详细工作机制是这样的：序列化的时候系统会吧当前类的serialVersionUID写入序列化的文件中，当反序列化的时候系统会去检测文件中的serialVersionUID，看他是否和当前类的serialVersionUID一致，如果一致说明序列化的类的版本和当前类的版本是相同的。这个时候可以成功反序列化，否者，则说明了发生了某些变换，比如成员变量的数量，类型可能发生了改变，这时候是无法正常反序列化的，因此会报如下错误:

java.io.InvalidClassException:Main;local class incompatible: stream classdesc serialVersionUID=87113582010083044,local class serialVersionUID=21138201003043.

一般来说我们应该手动指定serialVersionUID的值，比如1L，但是如果类结构发生了非常规性改变，比如修改了类名，修改了成员变量的类型，这个时候尽管serialVersionUID验证通过了，反序列化过程还是会失败，因为，类结构有了毁灭性的改变，根本无法从老版本的数据中还原出一个新的类结构对象。关于序列化首先，静态成员变量属于累不属于对象，所以不会参与序列化过程，其次用transient关键字标记的成员变量不参与序列化过程。

Parcelable接口

parcelable也是一个接口只要实现这个接口，一个类的对象就可以实现序列化兵可以通过Intent和Binder传递。直接上代码：

package com.zxx.binderframework.model;
 
import android.os.Parcel;
import android.os.Parcelable;
 
import com.zxx.binderframework.aidl.Book;
 
public class User implements Parcelable{
 
    private int id;
    private String name;
    private boolean isTrue;
    
    private Book book;
    public User(int id, String name, boolean isTrue) {
        super();
        this.id = id;
        this.name = name;
        this.isTrue = isTrue;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public boolean isTrue() {
        return isTrue;
    }
    public void setTrue(boolean isTrue) {
        this.isTrue = isTrue;
    }
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        // TODO Auto-generated method stub
        dest.writeInt(id);
        dest.writeString(name);
        dest.writeInt(isTrue?1:0);
        dest.writeParcelable(book, 0);
    }
    
    public static final Parcelable.Creator CREATOP=new Creator() {
        
        @Override
        public User[] newArray(int size) {
            // TODO Auto-generated method stub
            return new User[size];
        }
        
        @Override
        public User createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            return new User(source);
        }
    };
    
    private User(Parcel source) {
        // TODO Auto-generated constructor stub
        id=source.readInt();
        name=source.readString();
        isTrue=source.readInt()==1;
        book=source.readParcelable(Thread.currentThread().getContextClassLoader());
    }
}

这里先说一下Parcel,Parcel内部包装了可序列化的数据。可以在Binder中自由传递。从上面的代码可以看出来，在序列化过程中，需要实现的功能有序列化，反序列化，和内容描述。序列化是由writeToParcel方法来完成，最终是通过Parcel中的一系列write方法来完成的，反序列化功能由CREATOR来完成其内部标明了如何创建序列化对象和数组，并通过Parcel的一系列read方法来完成反序列化过程。内容描述功能由describeContents方法来完成，几乎在所有情况下，这个方法都应该返回0，仅当当前对象中存在文件描述符时，此方法返回1. 需要注意的是，在User(Parcel in) 方法中，由于book是另一个可序列化对象，所以他的反序列化过程需要传递当前线程的上下文类加载器，否则会报无法找到类的错误。

两个接口的区别：

Serializable是java中的序列化接口，其使用起来简单，但是开销很大。序列化和反序列化过程需要大量的I/O操作。而parcelable是android中的序列化方式因此更适合用在android平台上，他的缺点就是使用起来稍微麻烦点，但是他的效率很高。这是Android推荐的序列化方式。因此我们要首选parcelable。。parcelable主要用在内存序列化上，通过parcelable将对象序列化到存储设备中或者将对象序列化后通过网络传输也都是可以的。但是这个过程会稍显复杂，因此在这两种情况下建议大家使用Serializable

Binder

Binder是Android中的一个类，他实现了IBinder接口，从IPC角度来说，Binder是Android的一种跨进程通信的方式，Binder是ServiceManager连接各种Manager(ActivityManager,WindowManager,等等)和相应ManagerService的桥梁。从Android应用层来说，Binder是客户端和服务端进行通信的媒介，当bindService的时候，服务端会返回一个包含了服务端业务调用的Binder对象，通过这个Binder对象，客户端就可以获取服务器端提供的服务或者数据，这里的服务包括普通服务和基于AIDL服务。
Binder主要用在Service中没包括AIDL和Messenger，其中普通的Service中的Binder不涉及进程间通信，所以较为简单，无法触及Binder的核心。而Messenger的底层其实是AIDL，所以这里悬着用AIDL来分析Binder的工作机制，为了分析Binder的机制我们需要新建一个AIDL示例。SDK会自动为我们生产AIDL所对应的Binder类，然后我们就可以分析了。这里以我的工程为例，新建包com.zxx.binderframework.aidl然后新建三个文件Book.java,Book.aidl和IBookManager.aidl,代码如下：
Book.java

package com.zxx.binderframework.aidl;
 
import android.os.Parcel;
import android.os.Parcelable;
 
public class Book implements Parcelable {
 
    public int bookId;
    public String bookName;
 
    public Book(int bookId, String bookName) {
        super();
        this.bookId = bookId;
        this.bookName = bookName;
    }
    
 
    public int getBookId() {
        return bookId;
    }
 
 
 
    public void setBookId(int bookId) {
        this.bookId = bookId;
    }
 
 
 
    public String getBookName() {
        return bookName;
    }
 
 
 
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
 
 
 
    public static Parcelable.Creator getCreator() {
        return CREATOR;
    }
 
 
 
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
 
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        // TODO Auto-generated method stub
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }
 
    public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
        @Override
        public Book createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            return new Book(source);
        }
 
        @Override
        public Book[] newArray(int size) {
            // TODO Auto-generated method stub
            return new Book[size];
        }
 
    };
 
    private Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }
 
 
    @Override
    public String toString() {
        return "Book [bookId=" + bookId + ", bookName=" + bookName + "]";
    }
    
}

Book.aidl

package com.zxx.binderframework.aidl;
 
parcelable Book;

IBookManager.aidl

package com.zxx.binderframework.aidl;
import com.zxx.binderframework.aidl.Book;
interface IBookManager{
 
    List getBookList();
    void addBook(in Book book);
}

Book.aidl是Book类在AIDL中的申明IBookManager.aidl是我们自定义的一个接口，里面有两个方法，其中getBookList是从远程服务端获取图书列表，而addBook用于往图书列表中添加一本书。需要注意的是，尽管Book类已经和IBookManager位于相同的包中，但是在IBookManager中仍要导入Book类，这就是AIDL的特殊之处。下面我们再看看系统为IBookManager.aidl生产的Binder类，在gen目录下面可以查找到I。为了方面分析，还是先上代码:

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: C:\\Users\\Administrator\\Desktop\\tempspace\\BinderFramework\\src\\com\\zxx\\binderframework\\aidl\\IBookManager.aidl
 */
package com.zxx.binderframework.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.zxx.binderframework.aidl.IBookManager
{
private static final java.lang.String DESCRIPTOR = "com.zxx.binderframework.aidl.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.zxx.binderframework.aidl.IBookManager interface,
 * generating a proxy if needed.
 */
public static com.zxx.binderframework.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.zxx.binderframework.aidl.IBookManager))) {
return ((com.zxx.binderframework.aidl.IBookManager)iin);
}
return new com.zxx.binderframework.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 _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook:
{
data.enforceInterface(DESCRIPTOR);
com.zxx.binderframework.aidl.Book _arg0;
if ((0!=data.readInt())) {
_arg0 = com.zxx.binderframework.aidl.Book.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_registerListener:
{
data.enforceInterface(DESCRIPTOR);
com.zxx.binderframework.aidl.IOnNewBookArrivedListener _arg0;
_arg0 = com.zxx.binderframework.aidl.IOnNewBookArrivedListener.Stub.asInterface(data.readStrongBinder());
this.registerListener(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_unregisterListener:
{
data.enforceInterface(DESCRIPTOR);
com.zxx.binderframework.aidl.IOnNewBookArrivedListener _arg0;
_arg0 = com.zxx.binderframework.aidl.IOnNewBookArrivedListener.Stub.asInterface(data.readStrongBinder());
this.unregisterListener(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.zxx.binderframework.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 getBookList() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.zxx.binderframework.aidl.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public void addBook(com.zxx.binderframework.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();
}
}
@Override public void registerListener(com.zxx.binderframework.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));
mRemote.transact(Stub.TRANSACTION_registerListener, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
@Override public void unregisterListener(com.zxx.binderframework.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));
mRemote.transact(Stub.TRANSACTION_unregisterListener, _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);
static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_unregisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
}
public java.util.List getBookList() throws android.os.RemoteException;
public void addBook(com.zxx.binderframework.aidl.Book book) throws android.os.RemoteException;
public void registerListener(com.zxx.binderframework.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException;
public void unregisterListener(com.zxx.binderframework.aidl.IOnNewBookArrivedListener listener) throws android.os.RemoteException;
}

为了防止篇幅过长直接接下一篇吧----

android IPC机制讲解(二)

IPC基础概念介绍

Serializable接口

Parcelable接口

Binder

你可能感兴趣的:(android IPC机制讲解(二))