blocks|key|186797|text|当您谈论NotSerializableException时，当您想序列化一个对象时抛出它，该对象没有被标记为Serializable+-仅此而已，尽管当您扩展非序列化类并添加Serializable接口时，它完全没有问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|186798|没有不能序列化的数据。|186799|entityMap^0|4|O|1I|C|2F|C|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

When you are talking about <code>NotSerializableException</code> it is throw when you want to serialize an object, which has not been marked as <code>Serializable</code> - that's all, although when you extend non serializable class, and add <code>Serializable</code> interface it is perfectly fine.

There is no data that can't be serialized.

blocks|key|2805380|text|首先，如果您不打算序列化类的实例，则甚至不需要考虑序列化它。只实现你需要的东西，并且不要仅仅为了你的类而使你的类可序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2805381|如果您的对象有一个对任何不可序列化对象的引用(可传递的或直接的)，并且此引用没有用transient关键字标记，那么您的对象将是不可序列化的。|offset|length|style|CODE|2805382|通常，序列化不能在以后或其他地方反序列化时重用的对象是没有意义的。这可能是因为对象的状态只在此时此地有意义(例如，如果它有一个对正在运行的线程的引用)，或者因为它使用了一些资源，如套接字、数据库连接或类似的资源。很多对象并不表示数据，并且不应该是可序列化的。|2805383|entityMap^0|0|15|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

First of all, if you don't plan to ever serialize an instance of your class, there is no need to even think about serializing it. Only implement what you need, and don't try to make your class serializable just for the sake of it.

If your object has a reference (transitive or direct) to any non-serializable object, and this reference is not marked with the <code>transient</code> keyword, then your object won't be serializable.

Generally, it makes no sense to serialize objects that can't be reused when deserialized later or somewhere else. This could be because the state of the object is only meaningful here and now (if it has a reference to a running thread, for example), or because it uses some resource like a socket, a database connection, or something like that. A whole lot of objects don't represent data, and shouldn't be serializable.

blocks|key|185260|text|任何不是Serializable的Serializable类都会抛出这个异常。您可以通过使用transient关键字来避免这种情况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|185261|无法序列化的常见示例包括Swing组件和线程。如果你仔细想想，这是有意义的，因为你永远不可能反序列化它们，让它变得有意义。|185262|entityMap^0|4|C|H|C|1A|9|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Anything your <code>Serializable</code> class has in it that is not <code>Serializable</code> will throw this exception. You can avoid it by using the <code>transient</code> keyword. 

Common examples of things you can't serialize include Swing components and Threads. If you think about it it makes sense because you could never deserialize them and have it make sense.

blocks|key|189580|text|所有原始数据类型和类直接扩展Serializable，|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|189581|class+MyClass+extends+Serializable{
}|code-block|syntax|javascript|189582|或间接地，|189583|class+MyClass+extends+SomeClass{
}|189584|SomeClass实现了可序列化。|189585|可以序列化。可序列化类中的所有字段都被序列化，但标记为transient的字段除外。如果一个可序列化的类包含一个不可序列化的字段(不是原语，也不是从可序列化接口扩展的)，那么NotSerializableException将被抛出。|style|CODE|189586|第二个问题的答案:正如@JB+Nizet所说的那样。如果你打算将一个类的实例写到某个流中，然后只将它标记为Serializable，否则永远不要将一个类标记为Serializable。|189587|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html^0|E|C|0|0|0|0|0|0|R|9|2F|O|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1A|8|@$A|1B|B|1C|Q|R]|$A|1D|B|1E|Q|R]]|9|@]|C|$]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

All the primitive data types and the classes extend either <a href="http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html" rel="noreferrer">Serializable</a> directly,

<pre><code>class MyClass extends Serializable{
}
</code></pre>

or indirectly,

<pre><code>class MyClass extends SomeClass{
}
</code></pre>

SomeClass implements Serializable.

can be serialized. All the fields in a serializable class gets serialized except the fields which are marked <code>transient</code>. If a serializable class contains a field which is not serializable(not primitive and do not extend from serializable interface) then <code>NotSerializableException</code> will be thrown.

Answer to the second question : As @JB Nizet said. If you are going to write the instance of a class to some stream then and then only mark it as Serializable, otherwise never mark a class Serializable.

blocks|key|189438|text|您需要处理自己的对象的序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|189439|Java将为您处理原始数据类型。|189440|更多信息：http://www.tutorialspoint.com/java/java_serialization.htm|offset|length|189441|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tutorialspoint.com/java/java_serialization.htm^0|0|0|5|1L|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You need to handle the serialization of your own Objects.

Java will handle the primitive data types for you.

More info: <a href="http://www.tutorialspoint.com/java/java_serialization.htm" rel="nofollow">http://www.tutorialspoint.com/java/java_serialization.htm</a>

blocks|key|2805469|text|当可序列化中的内容标记为可序列化时，将引发NotSerialisable异常。其中一种情况可能是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2805470|class+Super{}
class+Sub+implements+Serializable
{
Super+super;|code-block|syntax|javascript|2805471|这里没有提到super是可序列化的，所以会抛出NotSerializableException。|2805472|entityMap^0|L|F|0|0|N|O|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<code>NotSerialisable</code> exception is thrown when something in your serializable marked as serializable. One such case can be:

<pre><code>class Super{}
class Sub implements Serializable
{
Super super;
</code></pre>

Here super is not mentioned as serializable so will throw <code>NotSerializableException</code>.

blocks|key|3017830|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3017831|在阅读了java的序列化算法(元数据从下到上，然后是实际的实例数据从上到下)的过程后，我真的不能理解哪些数据不能通过该算法处理。|blockquote|3017832|3017833|3017834|这个问题的答案是某些系统级的类，比如线程、OutputStream及其子类，它们是不可序列化的。在oracle文档上解释得很好：http://www.oracle.com/technetwork/articles/java/javaserial-1536170.html|offset|length|3017835|摘要如下：|3017836|另一方面，某些系统级类是不可序列化的，例如|3017837|、OutputStream及其子类以及Socket。事实上，如果是这样，那就没有任何意义了。例如，在我的JVM中运行的线程将使用我的系统内存。将其持久化并尝试在JVM中运行它是毫无意义的。|3017838|3017839|entityMap|0|LINK|mutability|MUTABLE|url|http://www.oracle.com/technetwork/articles/java/javaserial-1536170.html^0|0|0|0|0|1S|1Z|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|Y|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Z|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|10|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|11|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|12|7|@]|8|@$H|13|I|14|1|15]]|9|$]]|$1|J|3|K|4|5|6|16|7|@]|8|@]|9|$]]|$1|L|3|M|4|5|6|17|7|@]|8|@]|9|$]]|$1|N|3|O|4|C|6|18|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|Q|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]]|R|$S|$4|T|U|V|9|$W|X]]]]

<blockquote>
 After reading the process of java's serialization algorithm (metadata bottom-to- top, then actual instance data top-to-bottom), I can't really understand what data cannot be processed through that algorithm.
</blockquote>

The answer to this is certain system-level classes such as Thread, OutputStream and its subclasses which are not serializable. Explained very well on the oracle documents: <a href="http://www.oracle.com/technetwork/articles/java/javaserial-1536170.html" rel="nofollow">http://www.oracle.com/technetwork/articles/java/javaserial-1536170.html</a>

Below is the abstract:

<blockquote>
 On the other hand, certain system-level classes such as Thread, OutputStream and its subclasses, and Socket are not serializable. Indeed, it would not make any sense if they were. For example, thread running in my JVM would be using my system's memory. Persisting it and trying to run it in your JVM would make no sense at all. 
</blockquote>

blocks|key|2805411|text|更实际的情况是，任何对象都不能被序列化(通过Java的内置机制)，除非它的类实现了Serializable接口。然而，成为此类实例并不是充分条件:对于要成功序列化的对象，它持有的所有非瞬态引用必须为空或引用可序列化的对象。(请注意，这是一个递归条件。)原始值、空值和瞬态变量不是问题。静态变量不属于单个对象，因此它们也不存在问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2805412|一些常见的类是可靠的序列化安全的。字符串在这里可能是最值得注意的，但原始类型的所有包装类也都是安全的。基元数组是可靠的可序列化的。如果引用类型的所有元素都可以序列化，则可以序列化引用类型的数组。|2805413|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

More practically, no object can be serialized (via Java's built-in
mechanism) unless its class implements the Serializable interface.
Being an instance of such a class is not a sufficient condition,
however: for an object to be successfully serialized, it must also be
true that all non-transient references it holds must be null or refer to
serializable objects. (Do note that that is a recursive condition.)
Primitive values, nulls, and transient variables aren't a problem.
Static variables do not belong to individual objects, so they don't
present a problem either.

Some common classes are reliably serialization-safe. Strings are
probably most notable here, but all the wrapper classes for primitive
types are also safe. Arrays of primitives are reliably serializable.
Arrays of reference types can be serialized if all their elements can be
serialized.

blocks|key|187478|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|187479|什么数据可能导致NotSerializableException？|blockquote|187480|187481|187482|在Java语言中，我们序列化object+(已经实现了Serializable接口的Java类的实例)。因此，很明显，如果一个类没有实现可序列化接口，那么它就不能被序列化(在这种情况下，将抛出NotSerializableException+)。|offset|length|style|BOLD|187483|Serializable接口只是一个标记接口，在某种程度上，我们可以说它只是一个类上的戳，只是告诉JVM类可以序列化。|187484|187485|我怎么知道我不应该为我的类添加implements+Serializable子句？|187486|187487|187488|这完全取决于你的需要。|187489|187490|如果要将对象存储在数据库中，可以将其序列化为字节序列，并将其作为持久数据存储在数据库中。|ordered-list-item|187491|您可以将对象序列化，以供在不同计算机上工作的其他JVM使用。|187492|187493|entityMap^0|0|0|0|0|R|E|1W|6|2O|O|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|13|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|14|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|15|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|16|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|17|7|@$H|18|I|19|J|K]|$H|1A|I|1B|J|K]|$H|1C|I|1D|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1E|7|@]|8|@]|9|$]]|$1|N|3|-4|4|5|6|1F|7|@]|8|@]|9|$]]|$1|O|3|P|4|C|6|1G|7|@]|8|@]|9|$]]|$1|Q|3|-4|4|5|6|1H|7|@]|8|@]|9|$]]|$1|R|3|-4|4|5|6|1I|7|@]|8|@]|9|$]]|$1|S|3|T|4|5|6|1J|7|@]|8|@]|9|$]]|$1|U|3|-4|4|5|6|1K|7|@]|8|@]|9|$]]|$1|V|3|W|4|X|6|1L|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|X|6|1M|7|@]|8|@]|9|$]]|$1|10|3|-4|4|5|6|1N|7|@]|8|@]|9|$]]|$1|11|3|-4|4|5|6|1O|7|@]|8|@]|9|$]]]|12|$]]

<blockquote>
 What data may cause the NotSerializableException?
</blockquote>

In Java, we serialize object (the instance of a Java class which has already implemented the Serializable interface). So it's very clear that if a class has not implemented the Serializable interface, it cannot be serialized (then in that case NotSerializableException will be thrown).

The Serializable interface is merely a marker-interface, in a way we can say that it is just a stamp on a class and that just says to JVM that the class can be Serialized.

<blockquote>
 How should I know that I am not supposed to add the implements 
 Serializable clause for my class?
</blockquote>

It all depends on your need.

<ol>
<li>If you want to store the Object in a database, you can 
 serialize it to a sequence of byte and can store it in the 
 database as persistent data.</li>
<li>You can serialize your Object to be used by other JVM working 
on different machine. </li>
</ol>

If the <a href="http://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html" rel="noreferrer"><code>Serializable</code></a> interface is just a <a href="https://stackoverflow.com/questions/25850328/marker-interfaces-in-java">Marker-Interface</a> that is used for passing some-sort of meta-data about classes in java - I'm a bit confused:

After reading the process of java's serialization algorithm (metadata bottom-to-top, then actual instance data top-to-bottom), I can't really understand what data cannot be processed through that algorithm.

In short and formal:

<ol>
<li>What data may cause the <code>NotSerializableException</code>?</li>
<li>How should I know that I am not supposed to add the <code>implements Serializable</code> clause for my class?</li>
</ol>

Java: What can and what can't be serialized?

对象存储

数据存储

数据库

Java

如果接口只是一个用来传递java类的元数据的，那我就有点困惑了：在阅读了java的序列化算法(元数据从下到上，然后是实际的实例数据从上到下)的过程后，我真的不能理解无法通过该算法处理的数据。简而言之，：什么数据可能导致NotSerializableExceptionHow我应该知道不应该为我的类添加implements Serializable子句？

问Java:什么可以序列化，什么不可以序列化？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:什么可以序列化，什么不可以序列化？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:什么可以序列化，什么不可以序列化？
EN