[读书笔记]intent.putExtra的使用与原理分析

Dear 丶 2022-03-19 02:10 293阅读 0赞

在android中用intent传递数据是非常常见的操作，我们一般会用intent.putExtra()这个方法来放入自己要传递的数据，然后再另一个地方使用getxxx()来获取，其中intent.putExtra()的传参类型有很多种：

Intent  putExtra(String name, String\[\] value)  
Intent  putExtra(String name, Parcelable value)  
Intent  putExtra(String name, long value)  
Intent  putExtra(String name, boolean value)  
Intent  putExtra(String name, double value)  
Intent  putExtra(String name, Parcelable\[\] value)  
Intent  putExtra(String name, char value)  
Intent  putExtra(String name, int\[\] value)  
Intent  putExtra(String name, int value)  
Intent  putExtra(String name, double\[\] value)                 
Intent  putExtra(String name, short value)                    
Intent  putExtra(String name, long\[\] value)                       
Intent  putExtra(String name, boolean\[\] value)                    
Intent  putExtra(String name, short\[\] value)                      
Intent  putExtra(String name, String value)                       
Intent  putExtra(String name, Serializable value)                     
Intent  putExtra(String name, float\[\] value)                      
Intent  putExtra(String name, Bundle value)                       
Intent  putExtra(String name, byte\[\] value)                       
Intent  putExtra(String name, CharSequence value)                     
Intent  putExtra(String name, char\[\] value)                       
Intent  putExtra(String name, byte value)                     
Intent  putExtras(Intent src)                     
Intent  putExtras(Bundle extras)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
可以看到其可以传递的包括基本数据类型（含基本数据类型的数组）、String(包含数组)、Parcelable（包含数组）、Serializable、Bundle、CharSequence、Intent几种类型的数据。我们点进去看下具体实现：

public Intent putExtra(String name, String value) \{  
        if (mExtras == null) \{  
            mExtras = new Bundle();  
        \}  
        mExtras.putString(name, value);  
        return this;  
    \}  
1  
2  
3  
4  
5  
6  
7  
    public Intent putExtra(String name, int value) \{  
        if (mExtras == null) \{  
            mExtras = new Bundle();  
        \}  
        mExtras.putInt(name, value);  
        return this;  
    \}  
1  
2  
3  
4  
5  
6  
7  
    public Intent putExtra(String name, boolean value) \{  
        if (mExtras == null) \{  
            mExtras = new Bundle();  
        \}  
        mExtras.putBoolean(name, value);  
        return this;  
    \}  
1  
2  
3  
4  
5  
6  
7  
我们点开了三个Intent putExtra(String name, String value),Intent putExtra(String name, int value),Intent putExtra(String name, boolean value)发现其实原理都一样，他们都通过new Bundle.putxxx()来实现的，也就是说传进来的这些数据都是通过Bundle这个容器来装然后传递，在Intent类里面维护了一个Bundle对象mExtras，如果intent已经携带了Bundle对象，那么直接向里面存储数据，否则就新建一个Bundle对象， 点开 mExtras.putxxx()方法我们会发现，

public void putxxxx(@Nullable String key, value) \{  
        unparcel();  
        mMap.put(key, value);  
    \}  
1  
2  
3  
4  
其实在BaseBundle里面维护了一个ArrayMap

ArrayMap<String, Object> mMap = null;  
1  
我们intent的put操作和get操作就是对Bundle里面的ArrayMap进行mMap.put(key, value);和mMap.get(key);操作，那Bundle到底是个什么东东呢？我们要实现intent传递对象改怎么做呢？Bundle我们可以看作是一个存储可传输的数据的容器，什么是可传输的呢？我的理解是像基本数据类型本身就可以直接转换为字节流，所以是可传输的，还有就是实现实现序列化接口（String本身就实现了Serializable接口），在android中实现序列化接口有两种方式

实现Serializable接口  
实现Parcelable接口   
其中实现Serializable接口在javase就已经支持，而Parcelable是Android特有的功能，效率比实现Serializable接口高。那他们有什么区别？

作用

Serializable的作用是为了保存对象的属性到本地文件、数据库、网络流、rmi以方便数据传输，当然这种传输可以是程序内的也可以是两个程序间的。而Android的Parcelable的设计初衷是因为Serializable效率过慢，为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计，这些数据仅在内存中存在，Parcelable是通过IBinder通信的消息的载体。   
从上面的设计上我们就可以看出优劣了。

效率及选择  
Parcelable的性能比Serializable好，在内存开销方面较小，所以在内存间数据传输时推荐使用Parcelable，如activity间传输数据，而Serializable可将数据持久化方便保存，所以在需要保存或网络传输数据时选择Serializable，因为android不同版本Parcelable可能不同，所以不推荐使用Parcelable进行数据持久化。

总结：所以在传递对象时对于需要传递的对象的序列化选择可以加以区分，需要数据持久化的建议实现Serializable接口，只在内存间数据传输时推荐使用Parcelable。  
编程实现   
\-实现Serializable接口   
对于对于Serializable，类只需要实现Serializable接口，并提供一个序列化版本id(serialVersionUID)即可。，有人又会问了id(serialVersionUID)干啥的？   
（Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。添加serialVersionUID使得在序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。）   
下面一个bean是实现Serializable接口的一个样例:  
/\*\*  
 \* =============================================================================  
 \* Copyright (c) 2016 yuxin All rights reserved.  
 \* Packname com.jju.yuxin.disanzhou  
 \* Created by yuxin.  
 \* Created time 2016/9/18 0018 下午 10:29.  
 \* Version   1.0;  
 \* Describe :  
 \* History:  
 \* ==============================================================================  
 \*/  
public class Person implements Serializable\{

private static final long serialVersionUID = 1L;

private int id;  
    private String name;

public Person() \{  
    \}

public Person(int id, String name) \{  
        this.id = id;  
        this.name = name;  
    \}

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;  
    \}  
\}  
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  
intent数据的传递：

// 封装数据  
        Person p = new Person();  
        p.setId(320840);  
        p.setName("小伙子");  
        Intent i = new Intent(MainActivity.this, FirstActivity.class);  
        i.putExtra("Person", p);  
        startActivity(i);      
1  
2  
3  
4  
5  
6  
7  
接收数据：

Person p = (Person)getIntent().getSerializableExtra("Person");         
     　　System.out.println("身份证"+p.getId());  
     　　System.out.println("姓名"+p.getName());   
1  
2  
3  
\-实现Parcelable接口   
实现Parcelable接口稍微复杂一些，但效率更高,下面是一个实现Parcelable接口的一个样例：

/\*\*  
 \* =============================================================================  
 \* Copyright (c) 2016 yuxin All rights reserved.  
 \* Packname com.jju.yuxin.disanzhou  
 \* Created by yuxin.  
 \* Created time 2016/9/18 0018 下午 9:47.  
 \* Version   1.0;  
 \* Describe :  
 \* History:  
 \* ==============================================================================  
 \*/  
public class Student implements Parcelable \{

private int id;  
    private String name;

public Student() \{  
    \}

public Student(int id, String name) \{  
        this.id = id;  
        this.name = name;  
    \}

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;  
    \}

@Override  
    public int describeContents() \{  
        return 0;  
    \}

@Override  
    public void writeToParcel(Parcel dest, int flags) \{  
        dest.writeInt(this.id);  
        dest.writeString(this.name);  
    \}

protected Student(Parcel in) \{  
        this.id = in.readInt();  
        this.name = in.readString();  
    \}

public static final Parcelable.Creator<Student> CREATOR = new Parcelable.Creator<Student>() \{  
        @Override  
        public Student createFromParcel(Parcel source) \{  
            return new Student(source);  
        \}

@Override  
        public Student\[\] newArray(int size) \{  
            return new Student\[size\];  
        \}  
    \};  
\}  
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  
intent数据的传递：

// 封装数据  
        Student s = new Student();  
        s.setId(320840);  
        s.setName("小伙子");  
        Intent i = new Intent(MainActivity.this, FirstActivity.class);  
        i.putExtra("Student", s);  
        startActivity(i);   
1  
2  
3  
4  
5  
6  
7  
数据的接收：

Student s = (Student)getIntent().getParcelableExtra("Student");         
     　　System.out.println("学号："+s.getId());  
     　　System.out.println("姓名："+s.getName());   
1  
2  
3  
我们发现在实现Parcelable接口比较复杂在于要实现的几个方法不清楚是什么意思，我们来看下：

@Override  
    public int describeContents() \{  
        return 0;  
    \}

@Override  
    public void writeToParcel(Parcel dest, int flags) \{  
        dest.writeInt(this.id);  
        dest.writeString(this.name);  
    \}

protected Student(Parcel in) \{  
        this.id = in.readInt();  
        this.name = in.readString();  
    \}

@Override  
        public Student\[\] newArray(int size) \{  
            return new Student\[size\];  
        \}  
    \};  
\}  
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  
我们可以看到在方法中有很多个Parcel对象。这个类是用来封装数据的容器，封装后的数据可以通过Intent或IPC传递，除了基本类型外，只有实现了Parcelable接口的类才能放入parcel中，也就是说实现了Parcelable接口后可以把数据打包成Parcel对象对象来传递，并且只有实现了Parcelable接口的类才能放入parcel中，那实现了Parcelable接口的对象是如何打包和读取的呢？我们会发现两个方法

public void writeToParcel(Parcel dest, int flags);   
这个方法就是传入一个空的Parcel对象，然后将我们要存储的对象的属性写进Parcel中去（注意写入顺序，因为在读取是时要按照写入顺序来读取）  
 @Override  
    public void writeToParcel(Parcel dest, int flags) \{  
        dest.writeInt(this.id);  
        dest.writeString(this.name);  
    \}  
1  
2  
3  
4  
5  
还有一个就是：   
\- public Student createFromParcel(Parcel source)   
从方法名我们就可以看出他是从Parcel对象中获取值来创建一个我们需要传递的的Student 对象

@Override  
        public Student createFromParcel(Parcel source) \{  
            return new Student(source);  
        \}  
1  
2  
3  
4  
它这调用了Student的构造方法

protected Student(Parcel in) \{  
        this.id = in.readInt();  
        this.name = in.readString();  
    \}  
1  
2  
3  
4  
也就是说对于对象传递时需要打包成Parcel对象传递，而打包和解包的过程都是我们自己来写的。

题外话：对于实现Parcelable接口实现方法十分容易写错，如果你用android studio的话，安装个\*Android   
Parcelable code generator\*插件在你要实现Parcelable接口的bean上按住   
alt+insert选择Parcelable，就可以快速生成Parcelable代码  
总结上面所有intent的数据传递的重写的方法，我们会发现都是将数据放入Bundle中然后传递的，那Bundle究竟是什么呢？他是怎么工作的？在Android 系统中所有进程间通信不是基于Binder机制嘛？而允许数据在进程间传递不是基于Parcel的吗？关Bundle和Bundle里面的ArrayMap什么事？我们来看下之前我们一直忽略的一个方法， unparcel();在所有map的putxxx()之前我们都会看到这个方法

public void putxxxx(@Nullable String key, value) \{  
        unparcel();  
        mMap.put(key, value);  
    \}  
1  
2  
3  
4  
点开unparcel()

/\*\*  
     \* If the underlying data are stored as a Parcel, unparcel them  
     \* using the currently assigned class loader.  
     \*/  
    /\* package \*/ synchronized void unparcel() \{  
        if (mParcelledData == null) \{  
            if (DEBUG) Log.d(TAG, "unparcel " + Integer.toHexString(System.identityHashCode(this))  
                    + ": no parcelled data");  
            return;  
        \}

if (mParcelledData == EMPTY\_PARCEL) \{  
            if (DEBUG) Log.d(TAG, "unparcel " + Integer.toHexString(System.identityHashCode(this))  
                    + ": empty");  
            if (mMap == null) \{  
                mMap = new ArrayMap<String, Object>(1);  
            \} else \{  
                mMap.erase();  
            \}  
            mParcelledData = null;  
            return;  
        \}

int N = mParcelledData.readInt();  
        if (DEBUG) Log.d(TAG, "unparcel " + Integer.toHexString(System.identityHashCode(this))  
                + ": reading " + N + " maps");  
        if (N < 0) \{  
            return;  
        \}  
        if (mMap == null) \{  
            mMap = new ArrayMap<String, Object>(N);  
        \} else \{  
            mMap.erase();  
            mMap.ensureCapacity(N);  
        \}  
        mParcelledData.readArrayMapInternal(mMap, N, mClassLoader);  
        mParcelledData.recycle();  
        mParcelledData = null;  
        if (DEBUG) Log.d(TAG, "unparcel " + Integer.toHexString(System.identityHashCode(this))  
                + " final map: " + mMap);  
    \}  
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  
我们会发现BaseBundle不光维护了一个ArrayMap还有，Parcel对象   
，那BaseBundle是如何将传进来的数据传给Parcel的呢？我们又看到了一个方法void writeToParcelInner(Parcel parcel, int flags)这方法就类似与我们自己实现Parcelable接口里面实现的打包方法public void writeToParcel(Parcel dest, int flags)

/\*\*  
     \* Writes the Bundle contents to a Parcel, typically in order for  
     \* it to be passed through an IBinder connection.  
     \* @param parcel The parcel to copy this bundle to.  
     \*/  
    void writeToParcelInner(Parcel parcel, int flags) \{  
        if (mParcelledData != null) \{  
            if (mParcelledData == EMPTY\_PARCEL) \{  
                parcel.writeInt(0);  
            \} else \{  
                int length = mParcelledData.dataSize();  
                parcel.writeInt(length);  
                parcel.writeInt(BUNDLE\_MAGIC);  
                parcel.appendFrom(mParcelledData, 0, length);  
            \}  
        \} else \{  
            // Special case for empty bundles.  
            if (mMap == null || mMap.size() <= 0) \{  
                parcel.writeInt(0);  
                return;  
            \}  
            int lengthPos = parcel.dataPosition();  
            parcel.writeInt(-1); // dummy, will hold length  
            parcel.writeInt(BUNDLE\_MAGIC);

int startPos = parcel.dataPosition();  
            parcel.writeArrayMapInternal(mMap);  
            int endPos = parcel.dataPosition();

// Backpatch length  
            parcel.setDataPosition(lengthPos);  
            int length = endPos - startPos;  
            parcel.writeInt(length);  
            parcel.setDataPosition(endPos);  
        \}  
    \}  
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  
在 parcel.writeArrayMapInternal(mMap);时候将map数据写入了Parcel，有打包的过程，那一定就有解包的过程

/\*\*  
     \* Reads the Parcel contents into this Bundle, typically in order for  
     \* it to be passed through an IBinder connection.  
     \* @param parcel The parcel to overwrite this bundle from.  
     \*/  
    void readFromParcelInner(Parcel parcel) \{  
        int length = parcel.readInt();  
        if (length < 0) \{  
            throw new RuntimeException("Bad length in parcel: " + length);  
        \}  
        readFromParcelInner(parcel, length);  
    \}

private void readFromParcelInner(Parcel parcel, int length) \{  
        if (length == 0) \{  
            // Empty Bundle or end of data.  
            mParcelledData = EMPTY\_PARCEL;  
            return;  
        \}  
        int magic = parcel.readInt();  
        if (magic != BUNDLE\_MAGIC) \{  
            //noinspection ThrowableInstanceNeverThrown  
            throw new IllegalStateException("Bad magic number for Bundle: 0x"  
                    + Integer.toHexString(magic));  
        \}

// Advance within this Parcel  
        int offset = parcel.dataPosition();  
        parcel.setDataPosition(offset + length);

Parcel p = Parcel.obtain();  
        p.setDataPosition(0);  
        p.appendFrom(parcel, offset, length);  
        if (DEBUG) Log.d(TAG, "Retrieving "  + Integer.toHexString(System.identityHashCode(this))  
                + ": " + length + " bundle bytes starting at " + offset);  
        p.setDataPosition(0);

mParcelledData = p;  
    \}  
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  
总总结：我们会发现Intent的参数传递是先将参数传给一个ArrayMap，然后再将ArrayMap打包成一个Parcel在进程间传递，在实现Parcelable接口时我们知道，打包和解包是我们自己定义的，其实是一个将值复制给Parcel对象并在获取的时候解包的过程，所以Intent的参数传递后其实已经不是原来的那个参数了，传过来的只是一个复制品。  
我的博客网站：http://huyuxin.top/欢迎大家访问！评论！