【Android TimeCat】 Android中用intent传递对象的三种方法

Android
  1. 1. 背景
  2. 2. Serializable
  3. 3. 转化为JSON字符串
  4. 4. 使用Parcelable
  5. 5. 性能分析
  6. 6. 简化Parcel操作
    1. 6.1. parceler
  7. 7. 参考：

背景

TimeCat项目中需要根据上一个Activity的数据来初始化当前Activity，考虑到启动Activity时可以传数据，那么就用intent实现了。
Android中，Activity和Fragment之间传递对象，可以通过将对象序列化并存入Bundle或者Intent中进行传递，也可以将对象转化为JSON字符串，进行传递。

序列化对象可以使用Java的Serializable的接口、Parcelable接口。转化成JSON字符串，可以使用Gson等库。

Serializable

Model

1
2
3
4
5
6
7
8
9
10
11
12
public class Author implements Serializable{
    private int id;
 
    private String name;
 
    //...
}
public class Book implements Serializable{
    private String title;
    private Author author;
    //...
}

传递数据

1
2
3
4
5
6
7
8
9
Book book=new Book(); 
book.setTitle("Java编程思想"); 
Author author=new Author(); 
author.setId(1); 
author.setName("Bruce Eckel"); 
book.setAuthor(author); 
Intent intent=new Intent(this,SecondActivity.class); 
intent.putExtra("book",book); 
startActivity(intent);.

接收数据

1
2
3
Book book= (Book) getIntent().getSerializableExtra("book");
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());

转化为JSON字符串

Model

1
2
3
4
5
6
7
8
9
10
11
12
public class Author{
    private int id;
 
    private String name;
 
    //...
}
public class Book{
    private String title;
    private Author author;
    //...
}

传递数据

1
2
3
4
5
6
7
8
9
Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book",new Gson().toJson(book));
startActivity(intent);

接收数据

1
2
3
4
String bookJson=getIntent().getStringExtra("book");
Book book=new Gson().fromJson(bookJson,Book.class);
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());

使用Parcelable

实现Parcelable接口需要实现两个方法

describeContents方法。内容接口描述，默认返回0就可以;

writeToParcel方法。将传递的数据打包到Parcel容器中。

除了要实现这两个方法还必须创建一个Parcelable.Creator接口的实例，用于读取Parcel容器中的数据

Model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public class Author implements Parcelable{
    private int id;
 
    private String name;
 
    //setter & getter...
 
    @Override
    public int describeContents() {
 
        return 0;
    }
 
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //该方法将类的数据写入外部提供的Parcel中.即打包需要传递的数据到Parcel容器保存，
        // 以便从parcel容器获取数据
        dest.writeString(name);
        dest.writeInt(id);
 
    }
    public static final Creator<Author> CREATOR=new Creator<Author>() {
        @Override
        public Author createFromParcel(Parcel source) {
            //从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层。
            Author author=new Author();
            author.setName(source.readString());
            author.setId(source.readInt());
            return author;
        }
 
        @Override
        public Author[] newArray(int size) {
            //创建一个类型为T，长度为size的数组，仅一句话（return new T[size])即可。方法是供外部类反序列化本类数组使用。
            return new Author[size];
        }
    };
}


public class Book implements Parcelable{
    private String title;
    private Author author;
    //setter & getter...
 
    @Override
    public int describeContents() {
        return 0;
    }
 
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(title);
        dest.writeParcelable(author,flags);
    }
    public static final Creator<Book> CREATOR=new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel source) {
            Book book=new Book();
            book.setTitle(source.readString());
            book.setAuthor(source.<Author>readParcelable(Author.class.getClassLoader()));
            return book;
        }
 
        @Override
        public Book[] newArray(int size) {
            return new Book[0];
        }
    };
}

传递数据

1
2
3
4
5
6
7
8
9
Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book",book);
startActivity(intent);

接收数据

1
2
3
Book book=getIntent().getParcelableExtra("book");
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());

性能分析

经过测试，我们得到下图的效果

简化Parcel操作

可以看出，通过转换为字符串的速度是最慢的。Seralizable次之，Parcelable比Seralizable快10倍。所以从性能上考虑，我们必定优先选择Parcelable。但是Parcelable有大量重复的模板代码，如何简化这些操作，将是下面主要讲解的内容。

如果你使用android Studio 可以通过安装android-parcelable-intellij-plugin插件，或者自己配置模板进行操作。

parceler

除了上面的操作，还有大量的第三方库来简化Parcelable操作。当然使用这些库也许会降低Parcelable的性能。Parceler就是这样一个库。

Parceler使用非常简单，在定义Model时用@Parcel进行注解，在传递数据的时候使用Parcels的wrap方法来包装成一个Parcelable对象。获取数据时用Parcels的unwrap方法来获取对象。

Model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Parcel
 
public class Author {
 
   int id;
 
    String name;
 
    //setter & getter...
}
@Parcel
public class Book {
    String title;
    Author author;
    //setter & getter
}

传递对象

1
2
3
4
5
6
7
8
9
Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book", Parcels.wrap(book));
startActivity(intent);

接收对象

1
2
3
Book book= Parcels.unwrap(getIntent().getParcelableExtra("book"));
Log.d(TAG,"book title->"+book.getTitle());
Log.d(TAG,"book author name->"+book.getAuthor().getName());

除了Parceler之外，还有如auto-parcel,ParcelableCodeGenerator,ParcelableGenerator等第三方库，这里我将不进行讲解，有兴趣的朋友，可以自行研究。

参考：

Android中传递对象的三种方法

当前网速较慢或者你使用的浏览器不支持博客特定功能，请尝试刷新或换用Chrome、Firefox等现代浏览器