Android中Parcelable接口用法

最新推荐文章于 2022-03-10 14:12:53 发布

双刃剑客

最新推荐文章于 2022-03-10 14:12:53 发布

阅读量571

点赞数

分类专栏： android开发

android开发专栏收录该内容

213 篇文章 3 订阅

订阅专栏

转：https://www.cnblogs.com/renqingping/archive/2012/10/25/Parcelable.html

1. Parcelable接口

Interface for classes whose instances can be written to and restored from a Parcel。 Classes implementing the Parcelable interface must also have a static field called CREATOR， which is an object implementing the Parcelable.Creator interface。

2.实现Parcelable就是为了进行序列化，那么，为什么要序列化？

1）永久性保存对象，保存对象的字节序列到本地文件中；

2）通过序列化对象在网络中传递对象；

3）通过序列化在进程间传递对象。

3.实现序列化的方法

Android中实现序列化有两个选择：一是实现Serializable接口（是JavaSE本身就支持的），一是实现Parcelable接口（是Android特有功能，效率比实现Serializable接口高效，可用于Intent数据传递，也可以用于进程间通信（IPC））。实现Serializable接口非常简单，声明一下就可以了，而实现Parcelable接口稍微复杂一些，但效率更高，推荐用这种方法提高性能。

注：Android中Intent传递对象有两种方法：一是Bundle.putSerializable(Key，Object)，另一种是Bundle.putParcelable(Key，Object)。当然这些Object是有一定的条件的，前者是实现了Serializable接口，而后者是实现了Parcelable接口。

4.选择序列化方法的原则

1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。

2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。

3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable 。

5.应用场景

需要在多个部件(Activity或Service)之间通过Intent传递一些数据，简单类型（如：数字、字符串）的可以直接放入Intent。复杂类型必须实现Parcelable接口。

6、Parcelable接口定义

public interface Parcelable 
{
    //内容描述接口，基本不用管
    public int describeContents();
    //写入接口函数，打包
    public void writeToParcel(Parcel dest, int flags);
    //读取接口，目的是要从Parcel中构造一个实现了Parcelable的类的实例处理。因为实现类在这里还是不可知的，所以需要用到模板的方式，继承类名通过模板参数传入
    //为了能够实现模板参数的传入，这里定义Creator嵌入接口,内含两个接口函数分别返回单个和多个继承类实例
    public interface Creator<T> 
    {
           public T createFromParcel(Parcel source);
           public T[] newArray(int size);
    }
}

7、实现Parcelable步骤

1）implements Parcelable

2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据

3）重写describeContents方法，内容接口描述，默认返回0就可以

4）实例化静态内部对象CREATOR实现接口Parcelable.Creator

public static final Parcelable.Creator<T> CREATOR

注：其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcel in) 实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话即可（return new T[size]），供外部类反序列化本类数组使用。

简而言之：通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的顺序和读的顺序必须一致。

代码如下：

public class MyParcelable implements Parcelable 
{
     private int mData;

     public int describeContents() 
     {
         return 0;
     }

     public void writeToParcel(Parcel out, int flags) 
     {
         out.writeInt(mData);
     }

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

         public MyParcelable[] newArray(int size) 
         {
             return new MyParcelable[size];
         }
     };
     
     private MyParcelable(Parcel in) 
     {
         mData = in.readInt();
     }
 }

8、Serializable实现与Parcelabel实现的区别

1）Serializable的实现，只需要implements Serializable 即可。这只是给对象打了一个标记，系统会自动将其序列化。

2）Parcelabel的实现，不仅需要implements Parcelabel，还需要在类中添加一个静态成员变量CREATOR，这个变量需要实现 Parcelable.Creator 接口。

两者代码比较：

1）创建Person类，实现Serializable

public class Person implements Serializable
{
    private static final long serialVersionUID = -7060210544600464481L;
    private String name;
    private int age;
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
    
    public int getAge()
    {
        return age;
    }
    
    public void setAge(int age)
    {
        this.age = age;
    }
}

2）创建Book类，实现Parcelable

public class Book implements Parcelable
{
    private String bookName;
    private String author;
    private int publishDate;
    
    public Book()
    {
        
    }
    
    public String getBookName()
    {
        return bookName;
    }
    
    public void setBookName(String bookName)
    {
        this.bookName = bookName;
    }
    
    public String getAuthor()
    {
        return author;
    }
    
    public void setAuthor(String author)
    {
        this.author = author;
    }
    
    public int getPublishDate()
    {
        return publishDate;
    }
    
    public void setPublishDate(int publishDate)
    {
        this.publishDate = publishDate;
    }
    
    @Override
    public int describeContents()
    {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel out, int flags)
    {
        out.writeString(bookName);
        out.writeString(author);
        out.writeInt(publishDate);
    }
    
    public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>()
    {
        @Override
        public Book[] newArray(int size)
        {
            return new Book[size];
        }
        
        @Override
        public Book createFromParcel(Parcel in)
        {
            return new Book(in);
        }
    };
    
    public Book(Parcel in)
    {
        bookName = in.readString();
        author = in.readString();
        publishDate = in.readInt();
    }
}

通过序列化在进程间传递对象举例

转：https://www.cnblogs.com/xinyuyu/p/3715926.html

Parcelable使用的一个地方就是在进程间传递一个自定义的较为复杂的对象，对Parcelable学习了一下写下自己的观点。

将一个对象比如说一个名字为Cartoon的自定义类，由一个activity传递到另外一个activity去，这个时候就要用到Parcelable了。首先我们先构建一个bean。

package com.example.sendobjfromactivity.bean;

import android.graphics.Bitmap;

public class Cartoon {
    private Bitmap figure;
    private String name;
    private String creator;
    
    public Bitmap getFigure() {
        return figure;
    }
    public void setFigure(Bitmap figure) {
        this.figure = figure;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getCreator() {
        return creator;
    }
    public void setCreator(String creator) {
        this.creator = creator;
    }
}

这就是我们要传输的数据的格式，下面就思考，要将其在线程间进行传输，就要对其实现序列化，在Android中也就是实现Parcelable接口，这个接口中需要我们实现的主要方法有writeToParcel，describeContents ，Parcelable.Creator<T>。完成完成序列化是依靠writeToParcel方法，而对对象进行反序列化并且返回一个对象实例的是依靠ContentsParcelable.Creator<T>。

下面来看这样一段代码，ParcelableCartoon类实现了Parcelable接口

package com.example.sendobjfromactivity.bean;

import android.graphics.Bitmap;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;

public class ParcelableCartoon implements Parcelable {

    private Cartoon cartoon;
    private static final String MSG = "MESSAGE"; 
    
    public ParcelableCartoon(Cartoon cartoon){
        Log.i(MSG, "ParcelableCartoon::ParcelableCartoon@Cartoon");
        this.cartoon = cartoon;
    }
    
    // 将对象写入Parcel容器中去
    // 完成对对象的序列化
    /**
     * Flatten this object in to a Parcel.
     * 
     * @param dest The Parcel in which the object should be written.
     * @param flags Additional flags about how the object should be written.
     * May be 0 or {@link #PARCELABLE_WRITE_RETURN_VALUE}.
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        Log.i(MSG, "ParcelableCartoon::writeToParcel");
        dest.writeString(cartoon.getName());
        dest.writeString(cartoon.getCreator());
        dest.writeParcelable(cartoon.getFigure(), PARCELABLE_WRITE_RETURN_VALUE);
    }
    
    
    // 完成对序列化的对象反序列化
    public static final Parcelable.Creator<ParcelableCartoon> CREATOR = new Parcelable.Creator<ParcelableCartoon>(){
        // 从Parcel容器中获取序列化的对象，并将其反序列化，得到该对象的实例
        /**
         * Create a new instance of the Parcelable class, instantiating it
         * from the given Parcel whose data had previously been written by
         * {@link Parcelable#writeToParcel Parcelable.writeToParcel()}.
         * 
         * @param source The Parcel to read the object's data from.
         * @return Returns a new instance of the Parcelable class.
         */
        @Override
        public ParcelableCartoon createFromParcel(Parcel source) {
            Log.i(MSG, "ParcelableCartoon::Parcelable.Creator::createFromParcel");
            return new ParcelableCartoon(source);
        }

        @Override
        public ParcelableCartoon[] newArray(int size) {
            Log.i(MSG, "ParcelableCartoon::Parcelable.Creator::newArray");
            return new ParcelableCartoon[size];
        }
        
    };
    
    public ParcelableCartoon(Parcel in){
        Log.i(MSG, "ParcelableCartoon::ParcelableCartoon@Parcel");
        cartoon = new Cartoon();
        String name = in.readString();
        
        cartoon.setName(name);
        cartoon.setCreator(in.readString());
        cartoon.setFigure((Bitmap)in.readParcelable(Bitmap.class.getClassLoader()));
    }
    
    public Cartoon getCartoon() {
        Log.i(MSG, "ParcelableCartoon::getCartoon");
        return cartoon;
    }
    
    @Override
    public int describeContents() {
        Log.i(MSG, "ParcelableCartoon::describeContents");
        return 0;
    }
}

该类中用英文的注释引用了Android文档中的注释。在该类中涉及到一个Parcel，它是一个容器，它的主要任务是对需要序列化的对象进行写入，对需要反序列化的对象进行写出（构造一个实例）。

完成了这些，就可以对对象进行序列化了，也就是说我们可以传递对象了。

下面完成俩个activity，一个负责发送数据，一个用来接收数据。

SendObjFromActivity.java完成发送

package com.example.sendobjfromactivity;

import java.io.InputStream;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

import com.example.sendobjfromactivity.bean.Cartoon;
import com.example.sendobjfromactivity.bean.ParcelableCartoon;

public class SendObjFromActivity extends Activity {
    
    private Button sendData;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sendData = (Button)this.findViewById(R.id.button1);
        sendData.setOnClickListener(new OnClickListener(){

            @Override
            public void onClick(View v) {
                Cartoon cartoon = new Cartoon();
                cartoon.setName("Android");
                cartoon.setCreator("Google");
                InputStream is = getResources().openRawResource(R.drawable.ic_launcher);
                Bitmap bitmap = BitmapFactory.decodeStream(is);
                cartoon.setFigure(bitmap);

                Intent intent = new Intent(SendObjFromActivity.this, ReceiveObjActivity.class);
                // 完成对象的序列化操作
                ParcelableCartoon parcelableCartoon = new ParcelableCartoon(cartoon);
                intent.putExtra("msg", parcelableCartoon);
                startActivity(intent);
                
            }});
    }
}

ReceiveObjActivity.java完成对数据的接收

package com.example.sendobjfromactivity;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.widget.ImageView;
import android.widget.TextView;

import com.example.sendobjfromactivity.bean.Cartoon;
import com.example.sendobjfromactivity.bean.ParcelableCartoon;

public class ReceiveObjActivity extends Activity {
    
    private ImageView showImage;
    private TextView showText;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.i("MESSAGE", "进入到了另外的一个activity中去");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.display_obj);
        showImage = (ImageView)this.findViewById(R.id.imageView1);
        showText = (TextView)this.findViewById(R.id.textView1);
        
        Intent intent = getIntent();
        ParcelableCartoon parcelableCartoon = (ParcelableCartoon) intent
                .getParcelableExtra("msg");
        Cartoon cartoon = parcelableCartoon.getCartoon();
        showImage.setImageBitmap(cartoon.getFigure());
        showText.setText(cartoon.getName()+"\n"+cartoon.getCreator());
    }
}

在这个程序中会调用Parcelable.Creator<ParcelableCartoon>内的方法，来完成反序列化。

需要到两个xml布局文件：display_obj.xml，main.xml。比较简单不再叙述。

在AndroidManifest.xml中配置下activity。这样就完成了一个小的数据传输程序了，看下运行结果

在控制台中输出来的信息

这样可以看出来Parcelable的运行方式以及顺序。

总结一下我们基本数据类型、对象、数组、list等做Parcelable的方法

package com.suning.mobile.paysdk.pay;
 
import java.util.ArrayList;
 
import android.os.Parcel;
import android.os.Parcelable;
 
import com.yaya.test.OrderInfoBean;
 
/**
 * 
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉 数据类型序列化
 */
public class ParcelableType implements Parcelable {
    /** int 类型 */
    int age;
    /** String 类型 */
    String name;
    /** boolean 注意该boolean的get和set方法 **/
    boolean isGood;
    /** boolean 类型 **/
    boolean complete;
    /** 数组 **/
    private String[] ids;
    /** 对象 [内部已经序列化] **/
    private OrderInfoBean bean;
    /** list **/
    private ArrayList<orderinfobean> listBeans;
 
    /**
     * 默认构造方法
     */
    public ParcelableType() {
        // TODO Auto-generated constructor stub
    }
 
    public ParcelableType(Parcel in) {
        readFromParcel(in);
    }
 
    /***
     * 默认实现
     */
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
 
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        /** int 写入 **/
        dest.writeInt(age);
        /** string 写入 **/
        dest.writeString(name);
        /** boolean 写入 **/
        dest.writeInt(isGood ? 1 : 0);
        /** boolean 写入 **/
        dest.writeInt(complete ? 1 : 0);
        /** 数组 写入 **/
        if (ids != null) {
            dest.writeInt(ids.length);
        } else {
            dest.writeInt(0);
        }
        dest.writeStringArray(ids);
        /** 对象 写入 **/
        dest.writeParcelable(bean, flags);
        /** list 写入 **/
        dest.writeList(listBeans);
 
    }
 
    @SuppressWarnings("unchecked")
    private void readFromParcel(Parcel in) {
 
        /** int 读出 */
        age = in.readInt();
        /** stirng 读出 */
        name = in.readString();
        /** boolean 读出 */
        isGood = (in.readInt() == 1) ? true : false;
        /** boolean 读出 */
        complete = (in.readInt() == 1) ? true : false;
        /** 数组 读出 */
        int length = in.readInt();
        ids = new String[length];
        in.readStringArray(ids);
        /** 对象 读出 */
        bean = in.readParcelable(OrderInfoBean.class.getClassLoader());
        /** list 读出 */
        listBeans = in.readArrayList(OrderInfoBean.class.getClassLoader());
 
    }
 
    public static final Parcelable.Creator<parcelabletype> CREATOR = new Parcelable.Creator<parcelabletype>() {
        public ParcelableType createFromParcel(Parcel in) {
            return new ParcelableType(in);
        }
 
        public ParcelableType[] newArray(int size) {
            return new ParcelableType[size];
        }
    };
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    /**
     * 
     * 功能描述: <br>
     * 〈功能详细描述〉 fastJson解析时需要格式
     */
    public boolean isIsGood() {
        return isGood;
    }
 
    public void setIsGood(boolean isGood) {
        this.isGood = isGood;
    }
 
    public boolean isComplete() {
        return complete;
    }
 
    public void setComplete(boolean complete) {
        this.complete = complete;
    }
 
    public String[] getIds() {
        return ids;
    }
 
    public void setIds(String[] ids) {
        this.ids = ids;
    }
 
    public OrderInfoBean getBean() {
        return bean;
    }
 
    public void setBean(OrderInfoBean bean) {
        this.bean = bean;
    }
 
    public ArrayList<orderinfobean> getListBeans() {
        return listBeans;
    }
 
    public void setListBeans(ArrayList<orderinfobean> listBeans) {
        this.listBeans = listBeans;
    }
 
}