Question

在我的项目中，我有一个模型，其中包含有关模型的基本信息。例如，假设模型是汽车。然后有许多不同种类的汽车，它们分配了不同的数据。所有型号必须是parcelables。

不同车型之间的差异非常小，可能只是一些数据领域。所以这可以通过为不同的汽车创建演示者（只是一个保存数据的类）来解决。然后，演示者将知道它应该保留哪些额外数据。因为演示者本身不是可分区的，所以它的所有数据都有一个Bundle，然后Car类将添加到parcelable。我不想让主持人成为可能的人。

因此，Car从演示者那里获取Bundle并将其放入其包裹中：

  public void writeToParcel(Parcel parcel, int flags) {
    parcel.writeBundle(getPresenter().getBundle());
  }

然后它将用：

解压缩

  public Car(Parcel parcel) {    
    getPresenter().setBundle(parcel.readBundle());
  }

这可以正常工作，直到演示者将可分配的对象添加到包中。然后我收到了这个错误：

11-16 15:06:37.255: E/AndroidRuntime(15193): FATAL EXCEPTION: main
11-16 15:06:37.255: E/AndroidRuntime(15193): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example/com.example.activity}: android.os.BadParcelableException: ClassNotFoundException when unmarshalling: com.example.model.engine
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2185)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2210)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.app.ActivityThread.access$600(ActivityThread.java:142)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1208)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Handler.dispatchMessage(Handler.java:99)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Looper.loop(Looper.java:137)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.app.ActivityThread.main(ActivityThread.java:4931)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at java.lang.reflect.Method.invokeNative(Native Method)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at java.lang.reflect.Method.invoke(Method.java:511)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:791)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:558)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at dalvik.system.NativeStart.main(Native Method)
11-16 15:06:37.255: E/AndroidRuntime(15193): Caused by: android.os.BadParcelableException: ClassNotFoundException when unmarshalling: com.example.model.engine
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Parcel.readParcelable(Parcel.java:2077)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Parcel.readValue(Parcel.java:1965)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Parcel.readMapInternal(Parcel.java:2226)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Bundle.unparcel(Bundle.java:223)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at android.os.Bundle.getString(Bundle.java:1055)
11-16 15:06:37.255: E/AndroidRuntime(15193):         at com.example.cars.CarPresenter.getExtraString(CarPresenter.java:34)
11-16 15:06:37.255: E/AndroidRuntime(15193):         ... 11 more

所以它以某种方式无法从Bundle中读取任何内容。

这可以通过将readBundle调用修改为：

来解决

  public Car(Parcel parcel) {    
    getPresenter().setBundle(parcel.readBundle(engine.class.getClassLoader()));
  }

但是，这不是说我的捆绑中只能有一种类型的parcelables吗？例如，如果另一个演示者想要将另一个可分配的对象添加到捆绑包中该怎么办？

有人可以对此有所了解吗？

Answer 1

您在评论中写道：

但是，我的问题更多的是为什么在这种情况下我甚至必须指定一个类加载器

Android框架工程师Dianne Hackborn，writes：

当捆绑包从包裹中读取时，它只是提取数据。直到稍后从捆绑中检索内容时，它实际上并不会从该数据中取消。

在Bundle source code中，我们看到setClassLoader()方法设置字段mClassLoader：

public void setClassLoader(ClassLoader loader) {
     mClassLoader = loader;
 }

如果我们不使用setClassLoader()或构造函数Bundle(ClassLoader loader)，则mClassLoader字段将设置为默认ClassLoader：

public Bundle(int capacity) {
     //...
     mClassLoader = getClass().getClassLoader();
 }

然后使用

mClassLoader在unparcel()方法中解组分区数据：

 mParcelledData.readMapInternal(mMap, N, mClassLoader);
 mParcelledData.recycle();
 mParcelledData = null;

净，如果您未设置ClassLoader，则在解组其分区数据时，系统会{/ 1}}默认为系统{}，并且在解组我们的自定义时会得到ClassLoader { {1}}对象数据，

Answer 2

ClassLoaders是Java中最不了解的功能之一。它们提供“命名空间”，实际上这些命名空间可以“嵌套”，因为如果当前的ClassLoader找不到类，它可以检查“Parent”ClassLoader。

对于Android应用程序，有两个ClassLoader。有一个知道如何从你的APK加载类和一个知道如何从Android框架加载类的类。前者将后者设置为“父”类加载器，因此通常您不会注意到。但是，由于Bundle是一个框架类，并且由框架类加载器加载，因此您需要告诉它有关用于在APK中查找类的ClassLoader。 Bundle默认使用的类加载器是框架ClassLoader，它是一个“低”命名空间，而不是包含APK类的命名空间。

通过告诉捆绑包使用哪个ClassLoader，你告诉它需要检查APK ClassLoader的类。它默认检查框架APK，因为它是加载Bundle类的ClassLoader，因此它是唯一知道如何查找类的“命名空间”。

Answer 3

您写道：

这可以通过将readBundle调用修改为：
来解决
public Car(Parcel parcel) {           getPresenter().setBundle(parcel.readBundle(engine.class.getClassLoader()));   }

然而，这不意味着我只能拥有一种类型   我的捆绑包中的parcelables？例如，如果另一位演示者怎么办？   想要在捆绑包中添加另一个可分配的对象吗？

实际上，没有。当您将classLoader设置为engine.class.getClassLoader()时，您实际上提供了一个知道如何从APK加载所有类的类加载器。因此，您可以使用相同的类加载器来解压缩应用程序中实现Parcelable的所有其他自定义类。

您遇到的问题是，当不指定类加载器时，（默认）系统类加载器用于取消Bundle的取消。系统类加载器只知道如何加载Android系统已知的类，并且不知道如何加载任何特定于应用程序的类。

只是为了澄清，（一般来说）没有“每个类的类加载器”，有一个系统类加载器，然后有一个“每个应用程序的类加载器”。我希望这能回答你的问题。

Answer 4

这是我实现Parcelable的模型：

public class ProgramModel implements Parcelable
{
    private int id = -1;
    private String title = "";
    private String time = "";
    private String day = "";
    private String organization = "";
    private String participants = "";
    private String description = "";
    private String descriptionFull = "";
    private String location = "";
    private String locationCaption = "";
    private int locationCode = 0;
    private String locationMap = "";
    private String imageUrl = "";
    private String color = "";
    private int colorId = -1;
    private int columnId = -1;
    private String startTime = "";
    private String endTime = "";
    private Date convertedTimeStart = null;
    private Date convertedTimeEnd = null;
    private String theme = "";
    private ArrayList<TagModel> tags = new ArrayList<TagModel>();
    private ArrayList<Integer> tagsId = new ArrayList<Integer>();

    public ProgramModel()
    {
    }

    private ProgramModel(Parcel in)
    {
        id = in.readInt();
        title = in.readString();
        time = in.readString();
        day = in.readString();
        organization = in.readString();
        participants = in.readString();
        description = in.readString();
        descriptionFull = in.readString();
        location = in.readString();
        locationCaption = in.readString();
        locationCode = in.readInt();
        locationMap = in.readString();
        imageUrl = in.readString();
        color = in.readString();
        colorId = in.readInt();
        columnId = in.readInt();
        startTime = in.readString();
        endTime = in.readString();
        convertedTimeStart = new Date(in.readLong());
        convertedTimeEnd = new Date(in.readLong());
        theme = in.readString();
        in.readTypedList(tags, TagModel.CREATOR);
        in.readList(tagsId, Integer.class.getClassLoader());
    }

    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }

    // Other getters and setters

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

    // this is used to regenerate your object
    public static final Parcelable.Creator<ProgramModel> CREATOR = new Parcelable.Creator<ProgramModel>()
    {
        public ProgramModel createFromParcel(Parcel in)
        {
            return new ProgramModel(in);
        }

        public ProgramModel[] newArray(int size)
        {
            return new ProgramModel[size];
        }
    };

    @Override
    public void writeToParcel(Parcel out, int flags)
    {
        out.writeInt(id);
        out.writeString(title);
        out.writeString(time);
        out.writeString(day);
        out.writeString(organization);
        out.writeString(participants);
        out.writeString(description);
        out.writeString(descriptionFull);
        out.writeString(location);
        out.writeString(locationCaption);
        out.writeInt(locationCode);
        out.writeString(locationMap);
        out.writeString(imageUrl);
        out.writeString(color);
        out.writeInt(colorId);
        out.writeInt(columnId);
        out.writeString(startTime);
        out.writeString(endTime);
        out.writeLong(convertedTimeStart.getTime());
        out.writeLong(convertedTimeEnd.getTime());
        out.writeString(theme);
        out.writeTypedList(tags);
        out.writeList(tagsId);
    }
}

将数据写入Activity中的意图：

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("ProgramModel", programDetailsModel);
startActivity(intent);

在Activity中读取数据包中的数据：

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    savedInstanceState = getIntent().getExtras();
    if (savedInstanceState != null)
    {
        fromBundleModel = savedInstanceState.getParcelable("ProgramModel");
    }
}

可添加到Parcel的可分配内部包

4 个答案: