Android中Parcel的分析以及使用

                                                 

Android中Parcel的分析以及使用


        简单点来说:Parcel就是一个存放读取数据的容器,Android系统中的binder进程间通信(IPC)就使用了Parcel类来进行客户端与服务端数据的交互,而且AIDL的数据也是通过Parcel来交互的。在Java空间和C++都实现了Parcel,由于它在C/C++中,直接使用了内存来读取数据,因此,它更有效率。

分析Binder机制中的客户端与服务器端进行实际操作ontransact()函数:

[java]

  1. //参数说明:  

  2. // code :是请求的ID号   

  3. // data :客户端请求发送的参数  

  4. // reply:服务器端返回的结果  

  5. // flags:一些额外的标识,如FLAG_ONEWAY等,通常为0.  

  6. virtual status_t    onTransact( uint32_t code,  

  7.                                 const Parcel& data,  

  8.                                 Parcel* reply,  

  9.                                 uint32_t flags = 0);  

从中我们可以看到Parcel的重要性以及窥探它的使用情况,接下来,我主要分析它的存储机制。 

     

   常用方法介绍:

           obtain()                        获得一个新的parcel,相当于new一个对象

           dataSize()                     得到当前parcel对象的实际存储空间

           dataCapacity()              得到当前parcel对象的已分配的存储空间,>=dataSize()值 (以空间换时间)

           dataPostion()                获得当前parcel对象的偏移量(类似于文件流指针的偏移量)

           setDataPosition()          设置偏移量

           recyle()                          清空、回收parcel对象的内存

           writeInt(int)                    写入一个整数

           writeFloat(float)             写入一个浮点数

           writeDouble(double)      写入一个双精度数

           writeString(string)          写入一个字符串

        当然,还有更多的writeXXX()方法,与之对应的就是readXXX(),具体方法请参阅SDK

         其中几个值得注意的方法为:

             writeException()       Parcel队头写入一个异常

             writeException()       Parcel队头写入“无异常“

             readException()       Parcel队头读取,若读取值为异常,则抛出该异常;否则,程序正常运行。

 

一、Parcel的分析

 

      相信看了前面的值,对Parcel的使用该有了初步印象。那么,Parcel的内部存储机制是怎么样的?偏移量又是

 什么情况?让我们回忆一下基本数据类型的取值范围:

                  boolean    1bit          1字节

                  char         16bit         2字节

                  int            32bit        4字节

                  long         64bit        8字节

                  float         32bit        4字节

                 double      64bit         8字节

 

       如果大家对C语言熟悉的话,C语言中结构体的内存对齐和Parcel采用的内存存放机制一样,即读取最小字节

32bit,也即4个字节。高于4个字节的,以实际数据类型进行存放,但得为4byte的倍数。基本公式如下:

            实际存放字节:

                      判别一: 32bit     (<=32bit)            例如:booleancharint

                      判别二: 实际占用字节(>32bit)    例如:longfloatString,数组等

       当我们使用readXXX()方法时,读取方法也如上述:

             实际读取字节:

                       判别一:  32bit     (<=32bit)           例如:booleancharint

                       判别二: 实际字节大小(>32bit)    例如:longfloatString,数值等

     由上可以知道,当我们写入/读取一个数据时,偏移量至少为4byte(32bit),于是,偏移量的公式如下:

                f(x)=4x  (x=0,1,…n)

       事实上,我们可以显示的通过setDataPostion(intpostion) 来直接操作我们欲读取数据时的偏移量。毫无疑问,

你可以设置任何偏移量,但所读取的值是类型可能有误。因此显示设置偏移量读取值的时候,需要小心。

      

     另外一个注意点就是我们在writeXXX()readXXX()时,导致的偏移量是共用的,例如,我们在writeInt(23)后,

此时的datapostion=4,如果我们想读取5,简单的通过readInt()是不行的,只能得到0。这时我们只能通过

setDataPosition(0)设置为起始偏移量,从起始位置读取四个字节,即23。因此,在读取某个值时,可能需要使用

setDataPostion(intpostion)使偏移量装换到我们的值处。

 

      巧用setDataPosition()方法,当我们的parcel对象中只存在某一类型时,我们就可以通过这个方法来快速的读取

所有值。具体方法如下:

 

[html]

  1. /**  

  2.      前提条件,Parcel存在多个类型相同的对象,本例子以10float对象说明:  

  3.      */  

  4.     public void readSameType() {  

  5.         Parcel parcel =Parcel.obtain() ;  

  6.         for (int i = 0; i < 10; i++) {  

  7.             parcel.writeDouble(i);  

  8.             Log.i(TAG, "write double ----> " + getParcelInfo());  

  9.         }  

  10.         //方法一 ,显示设置偏移量   

  11.         int i = 0;  

  12.         int datasize = parcel.dataSize();  

  13.         while (i < datasize) {  

  14.             parcel.setDataPosition(i);  

  15.             double fvalue = parcel.readDouble();  

  16.             Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  

  17.             i += 8; // double占用字节为 8byte   

  18.         }  

  19. //      方法二,由于对象的类型一致,我们可以直接利用readXXX()读取值会产生偏移量  

  20. //      parcel.setDataPosition(0)  ;  //  

  21. //      while(parcel.dataPosition()<parcel.dataSize()){  

  22. //          double fvalue = parcel.readDouble();  

  23. //          Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  

  24. //      }  

  25.     }  



    由于可能存在读取值的偏差,一个默认的取值规范为:

            1、 读取复杂对象时: 对象匹配时,返回当前偏移位置的该对象;

                              对象不匹配时,返回null对象;

            2、 读取简单对象时: 对象匹配时,返回当前偏移位置的该对象;

                              对象不匹配时,返回0  

下面,给出一张浅显的Parcel的存放空间图,希望大家在理解的同时,更能体味其中滋味。有点简单,求谅解。

               

相信通过前面的介绍,你一定很了解了了Parcel的存储机制,下面给定一应用程序来实践。

    1、布局文件如下:

[html]

  1. <?xml version="1.0" encoding="utf-8"?>  

  2. <LinearLayout xmlns:Android="http://schemas.android.com/apk/res/android"  

  3.     android:orientation="vertical" android:layout_width="fill_parent"  

  4.     android:layout_height="fill_parent">  

  5.     <TextView android:layout_width="fill_parent"  

  6.         android:layout_height="wrap_content" android:text="@string/hello" />  

  7.     <LinearLayout android:orientation="horizontal"  

  8.         android:layout_width="fill_parent" android:layout_height="wrap_content">  

  9.         <Button android:id="@+id/btWriteByte" android:layout_width="wrap_content"  

  10.             android:layout_height="wrap_content" android:text="写入一个byte"></Button>  

  11.         <Button android:id="@+id/btWriteInt" android:layout_width="wrap_content"  

  12.             android:layout_height="wrap_content" android:text="写入一个int"></Button>  

  13.     </LinearLayout>  

  14.     <LinearLayout android:orientation="horizontal"  

  15.         android:layout_width="fill_parent" android:layout_height="wrap_content">  

  16.         <Button android:id="@+id/btWriteDouble" android:layout_width="wrap_content"  

  17.             android:layout_height="wrap_content" android:text="写入一个double"></Button>  

  18.         <Button android:id="@+id/btWriteString" android:layout_width="wrap_content"  

  19.             android:layout_height="wrap_content" android:text="写入一个String"></Button>  

  20.     </LinearLayout>  

  21.     <View android:layout_width="fill_parent" android:layout_height="2dip"  

  22.         android:background="#FF1493"></View>  

  23.     <LinearLayout android:orientation="horizontal"  

  24.         android:layout_marginTop="5dip" android:layout_width="fill_parent"  

  25.         android:layout_height="wrap_content">  

  26.         <Button android:id="@+id/btReadByte" android:layout_width="wrap_content"  

  27.             android:layout_height="wrap_content" android:text="读取一个byte"></Button>  

  28.         <Button android:id="@+id/btReadInt" android:layout_width="wrap_content"  

  29.             android:layout_height="wrap_content" android:text="读取一个int"></Button>  

  30.     </LinearLayout>  

  31.     <LinearLayout android:orientation="horizontal"  

  32.         android:layout_width="fill_parent" android:layout_height="wrap_content">  

  33.         <Button android:id="@+id/btReadDouble" android:layout_width="wrap_content"  

  34.             android:layout_height="wrap_content" android:text="读取一个double"></Button>  

  35.         <Button android:id="@+id/btReadString" android:layout_width="wrap_content"  

  36.             android:layout_height="wrap_content" android:text="读取一个String"></Button>  

  37.     </LinearLayout>  

  38.     <View android:layout_width="fill_parent" android:layout_height="2dip"  

  39.         android:background="#FF1493"></View>  

  40.     <Button android:id="@+id/btSameType" android:layout_width="wrap_content"  

  41.         android:layout_height="wrap_content" android:text="利用setDataPosition读取多个值"></Button>  

  42. </LinearLayout>   

 2、配置文件如下:

[html]

  1. <?xml version="1.0" encoding="utf-8"?>  

  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  

  3.       package="com.qinjuning.parcel"  

  4.       android:versionCode="1"  

  5.       android:versionName="1.0">  

  6.     <application android:icon="@drawable/icon" android:label="@string/app_name">  

  7.         <activity android:name=".MainActivity"  android:label="@string/app_name">  

  8.             <intent-filter>  

  9.                 <action android:name="android.intent.action.MAIN" />  

  10.                 <category android:name="android.intent.category.LAUNCHER" />  

  11.             </intent-filter>  

  12.         </activity>  

  13.     </application>  

  14. </manifest>   

    3、程序主文件如下:

[html]

  1. public class MainActivity extends Activity implements OnClickListener {  

  2.   

  3.     private static String TAG = "PARCELTEST";  

  4.     // Button ID  

  5.     private static int[] btIds = new int[] { R.id.btWriteByte, R.id.btWriteInt,  

  6.             R.id.btReadDouble, R.id.btWriteString, R.id.btReadByte,  

  7.             R.id.btReadInt, R.id.btReadDouble, R.id.btReadString,  

  8.             R.id.btSameType };  

  9.     // 每种类型的当前值  

  10.     private byte cur_byte = 1; // 每次总写入 false  

  11.     private int cur_int = 10; // 写入值 cur_int ++ ;  

  12.     private double cur_float = 100.0d; // 写入值 cur_float++ ;  

  13.     private String cur_str = "QinJun -->" + cur_int; // 写入值 "QinJun -->"+cur_int  

  14.   

  15.     private Parcel parcel = null;  

  16.   

  17.     @Override  

  18.     public void onCreate(Bundle savedInstanceState) {  

  19.         super.onCreate(savedInstanceState);  

  20.         setContentView(R.layout.main);  

  21.         for (int i = 0; i < btIds.length; i++) {  

  22.             Button bt = (Button) findViewById(btIds[i]);  

  23.             bt.setOnClickListener(this);  

  24.         }  

  25.         parcel = Parcel.obtain(); // 获得一个Parcel对象 ,相当于new一个,初始大小为0  

  26.         Log.i(TAG, "The original parcel info" + getParcelInfo());  

  27.     }  

  28.   

  29.     @Override  

  30.     public void onClick(View view) {  

  31.         // TODO Auto-generated method stub  

  32.         int viewviewId = view.getId();  

  33.         switch (viewId) {  

  34.         case R.id.btWriteByte:  

  35.             parcel.setDataPosition(0);  

  36.             parcel.writeByte(cur_byte);  

  37.             Log.i(TAG, " after write byte, --->" + getParcelInfo());  

  38.             break;  

  39.         case R.id.btWriteInt:  

  40.             parcel.writeInt(cur_int);  

  41.             Log.i(TAG, " after write int, --->" + getParcelInfo());  

  42.             break;  

  43.         case R.id.btWriteDouble:  

  44.             parcel.writeDouble(cur_float);  

  45.             Log.i(TAG, " after write float, --->" + getParcelInfo());  

  46.             break;  

  47.         case R.id.btWriteString:  

  48.             parcel.writeString(cur_str);  

  49.             Log.i(TAG, " after write String, --->" + getParcelInfo());  

  50.             break;  

  51.         case R.id.btReadByte:  

  52.             byte b = parcel.readByte();  

  53.             Log.i(TAG, " read byte is=" + b + ", --->" + getParcelInfo()  

  54.                     + "String");  

  55.             break;  

  56.         case R.id.btReadInt:  

  57.             int i = parcel.readInt();  

  58.             Log.i(TAG, " read int is=" + i + ", --->" + getParcelInfo());  

  59.             break;  

  60.         case R.id.btReadDouble:  

  61.             float f = parcel.readFloat();  

  62.             readSameType();  

  63.             Log.i(TAG, " read float is=" + f + ", --->" + getParcelInfo());  

  64.             break;  

  65.         case R.id.btReadString:  

  66.             parcel.setDataPosition(0);  

  67.             String str = parcel.readString();  

  68.             Log.i(TAG, " read float is=" + str + ", --->" + getParcelInfo());  

  69.             break;  

  70.         case R.id.btSameType:  

  71.             readSameType();  

  72.             break;  

  73.         default:  

  74.             break;  

  75.         }  

  76.     }  

  77.   

  78.     private String getParcelInfo() {// 得到parcel的信息  

  79.         return "dataSize = " + parcel.dataSize() + ", dataCapacity="  

  80.                 + parcel.dataCapacity() + ", dataPositon = "  

  81.                 + parcel.dataPosition();  

  82.     }  

  83.   

  84.     /**  

  85.      前提条件,Parcel存在多个类型相同的对象,本例子以10float对象说明:  

  86.      */  

  87.     public void readSameType() {  

  88.           

  89.         for (int i = 0; i < 10; i++) {  

  90.             parcel.writeDouble(i);  

  91.             Log.i(TAG, "write double ----> " + getParcelInfo());  

  92.         }  

  93.         //方法一 ,显示设置偏移量   

  94.         int i = 0;  

  95.         int datasize = parcel.dataSize();  

  96.         while (i < datasize) {  

  97.             parcel.setDataPosition(i);  

  98.             double fvalue = parcel.readDouble();  

  99.             Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  

  100.             i += 8; // double占用字节为 8byte   

  101.         }  

  102. //      方法二,由于对象的类型一致,我们可以直接利用readXXX()读取值会产生偏移量  

  103. //      parcel.setDataPosition(0)  ;  //  

  104. //      while(parcel.dataPosition()<parcel.dataSize()){  

  105. //          double fvalue = parcel.readDouble();  

  106. //          Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  

  107. //      }  

  108.     }  

  109. }  

  110.    

由于取值时,可能存在类型的转换,因此点击按钮时,可能不会产生预期结果。因此,得保证偏移量对应数值的正确性。


二、Parcel的使用 

关于Parcel的使用,请参考如下两票文章,小生也就不再赘述了。

AndroidIntent传递对象的两种方法(Serializable,Parcelable)!http://www.linuxidc.com/Linux/2012-02/53067.htm

Android中的AIDL!!!  http://www.linuxidc.com/Linux/2012-02/53068.htm



:转自 http://www.linuxidc.com/Linux/2012-02/53066.htm

<think> 我们正在讨论的是关于在Android中实现Parcelable接口的类存在,但在序列化/反序列化时抛出ClassNotFoundException的问题。这通常发生在跨进程通信(如广播、Intent传递)或应用状态保存(如onSaveInstanceState)的场景中。根据引用内容,我们可以归纳出几种常见原因及其解决方案。 关键原因分析: 1. 类加载器问题:当使用Bundle传递Parcelable对象时,如果接收方未正确设置类加载器,系统无法找到对应的类定义(引用[1])。 2. 混淆问题:ProGuard/R8可能移除了Parcelable类或CREATOR字段(引用[4])。 3. 跨进程传递问题:在系统进程(如广播接收)中,如果传递的Bundle包含自定义Parcelable对象,系统进程可能无法访问应用的自定义类(引用[5])。 4. 多模块/类加载隔离:在多DEX或动态加载环境下,类可能位于不同的DEX文件中,导致加载失败(引用[4])。 解决方案如下: ### 步骤1: 显式设置Bundle的类加载器(针对广播等跨组件通信) 在接收方(如Activity、Service、BroadcastReceiver)中,从Intent获取Bundle后,必须显式设置当前类的类加载器: ```java Bundle bundle = getIntent().getExtras(); if (bundle != null) { bundle.setClassLoader(MyParcelable.class.getClassLoader()); // 设置正确的类加载器 MyParcelable data = bundle.getParcelable("key"); } ``` - **原理**:默认情况下,Bundle使用系统类加载器,无法加载应用的自定义类。显式设置后,Bundle会在当前应用的上下文中查找类。 - 引用[1][^1]和引用[2][^2]直接指出该方法是解决三星等设备上类加载失败的关键。 ### 步骤2: 检查Parcelable实现规范 确保自定义Parcelable类完全符合要求: 1. 实现`Parcelable`接口,并包含静态变量`CREATOR`: ```java public class MyParcelable implements Parcelable { private int mData; // 其他字段... protected MyParcelable(Parcel in) { mData = in.readInt(); // 其他字段读取... } public static final Creator<MyParcelable> CREATOR = new Creator<MyParcelable>() { @Override public MyParcelable createFromParcel(Parcel in) { return new MyParcelable(in); } @Override public MyParcelable[] newArray(int size) { return new MyParcelable[size]; } }; @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(mData); // 其他字段写入... } } ``` 2. **必须检查要点**: - `CREATOR`字段必须是`public static final`。 - 构造方法必须是`protected`或`public`(以便系统反射调用)。 - 字段读写顺序必须一致(writeToParcel和构造方法中的读取顺序需匹配)。 ### 步骤3: 修复混淆配置(Release版本专有) 在ProGuard/R8规则文件中添加保留语句: ```proguard # 保留Parcelable实现类和CREATOR字段 -keep class * implements android.os.Parcelable { public static final ** CREATOR; } # 若使用AIDL生成的Parcelable,也需保留 -keep class **$$Parcelable { *; } ``` - 混淆会导致类名或方法名被篡改,从而使系统无法通过反射创建对象(引用[4][^4])。 ### 步骤4: 避免在系统进程传递自定义Parcelable(高级场景) 引用[5][^5]指出系统进程(如通知栏、PendingIntent)无法识别应用的自定义类。解决方案: - **替代方案1**:使用基本类型或系统预定义的Parcelable类型(如String, Intent, Uri)。 - **替代方案2**:将自定义对象转换为JSON字符串传递,然后在接收方解析(需性能权衡): ```java // 发送方 Intent intent = new Intent(this, ReceiverActivity.class); String json = new Gson().toJson(myParcelableObject); intent.putExtra("data", json); // 接收方 String json = getIntent().getStringExtra("data"); MyParcelable data = new Gson().fromJson(json, MyParcelable.class); ``` - **替代方案3**:仅在同一应用进程内传递自定义Parcelable对象(如Activity之间),避免跨应用/系统进程传递。 ### 步骤5: 多模块/类加载隔离处理 若应用使用多DEX分包或动态加载,确保: 1. 自定义Parcelable类在主DEX文件中(通过`multiDexKeepFile`配置)。 2. 在动态加载场景中,手动将自定义类的包名加入DexClassLoader的加载路径。 ### 附加诊断建议 - **日志分析**:检查`adb logcat`输出,确认缺失的类名。若为匿名内部类(如`XXX$1`),可能是混淆导致的CREATOR字段损坏。 - **设备兼容性测试**:某些厂商设备(如三星)修改了类加载逻辑(引用[2][^2]),需重点测试。 通过上述步骤,绝大多数Parcelable相关的ClassNotFoundException问题可被解决。核心在于确保类加载器正确、实现规范、避免跨进程传递复杂对象。 §§相关问题§§ 1. 如何正确地在Android不同组件(Activity/Service/Broadcast)之间传递Parcelable对象? 2. 在Android开发中,如何配置ProGuard规则以保留Parcelable类? 3. 除了Parcelable,还有哪些高效的数据序列化方案适用于Android跨进程通信? </think> ### Android实现Parcelable类存在但报ClassNotFoundException的解决方案 该问题通常发生在跨进程通信或状态恢复场景中,系统尝试反序列化自定义Parcelable对象时找不到类定义。以下是系统性解决方案: #### 1. 显式设置ClassLoader(核心修复) 在接收Parcelable数据的组件中,必须显式设置Bundle的类加载器: ```java // Activity/Fragment中 Bundle bundle = getIntent().getExtras(); if (bundle != null) { bundle.setClassLoader(getClass().getClassLoader()); // 关键设置 MyParcelable data = bundle.getParcelable("data_key"); } // BroadcastReceiver中 @Override public void onReceive(Context context, Intent intent) { Bundle bundle = intent.getExtras(); bundle.setClassLoader(getClass().getClassLoader()); // 关键设置 MyParcelable data = bundle.getParcelable("data_key"); } ``` **原理**:Android系统默认使用系统类加载器,无法加载应用自定义类。显式设置后使用应用类加载器[^1][^2]。 #### 2. 验证Parcelable实现规范 确保完全符合Parcelable接口规范: ```java public class MyParcelable implements Parcelable { private int value; // 必须包含CREATOR字段(public static final) 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]; } }; // 必须包含Parcel构造函数 private MyParcelable(Parcel in) { value = in.readInt(); // 顺序必须与writeToParcel一致 } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(value); } } ``` 常见错误:缺少CREATOR、构造函数非public、字段读写顺序不一致[^3]。 #### 3. 修复混淆配置 在proguard-rules.pro中添加: ```proguard # 保留Parcelable实现类和CREATOR -keep class * implements android.os.Parcelable { public static final ** CREATOR; } # 保留自定义类 -keep class com.example.MyParcelable { *; } ``` 混淆会移除CREATOR字段导致反序列化失败[^4]。 #### 4. 跨进程通信特殊处理 当通过广播或跨进程传递时: ```java // 发送方 Intent intent = new Intent("CUSTOM_ACTION"); intent.putExtra("data", new MyParcelable()); // 接收方必须设置ClassLoader(见方案1) ``` **替代方案**:对于系统进程(如通知栏),建议改用JSON序列化: ```java // 发送方 Gson gson = new Gson(); intent.putExtra("data_json", gson.toJson(myParcelable)); // 接收方 MyParcelable data = gson.fromJson(getIntent().getStringExtra("data_json"), MyParcelable.class); ``` 系统进程无法加载自定义类[^5]。 #### 5. 验证多模块依赖 若Parcelable类在独立模块中: ```gradle // 确保依赖传递 implementation(project(":parcelable-module")) { transitive = true // 允许传递类加载 } ``` 使用`./gradlew :app:dependencies`检查依赖树。 #### 诊断技巧 1. 捕获完整堆栈: ```java try { bundle.getParcelable("key"); } catch (BadParcelableException e) { Log.e("TAG", "Class loading failed", e); Log.e("TAG", "ClassLoader: " + getClassLoader()); // 验证加载器 } ``` 2. 检查设备日志: ``` adb logcat | grep -E "ClassNotFoundException|BadParcelableException" ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值