如果您仅仅因为为了执行而重新编号(如果您为<条码>的序列号/代码>而重新编号,例如,如果它储存或不储存的话,你可能不关心<条码>的代号/代码>。

如果您实际上重新使用序列化,则只有在你计划直接使用序列化储存和检索物体的情况下,才会有问题。serialVersionUID代表了你的班级版本,如果你的班级目前版本与原版本不一致,你就应当予以加固。

Most of the time, you will probably not use serialization directly. If this is the case, generate a default SerialVersionUID by clicking the quick fix option and don t worry about it.

我可以借此机会借这个机会,将Juan 。 第10章是 Java序列化的不可支配资源。

内在的航空化机制(in.defaultReadObject()将拒绝从旧的数据版本中进行脱射。 但是,如果您能够界定自己的readObject(-Function,读取旧数据。 然后,该海关编码可以检查<代码>航天器识别符号<>,以便了解数据中哪一种版本,并决定如何将其转换。 如果你储存能够保存几版法典的序列化数据,这一版本的技术是有用的。

但是,如此长的时间里储存序列化数据并不常见。 更常见的情况是,利用序列化机制临时撰写数据,例如,藏匿点或将数据从网络上传送到另一个具有相同版本的编码数据库相关部分的方案。

在这种情况下,你不希望保持落后的兼容性。 你们只关心确保沟通的守则基础确实具有相同的版本。 为了便利进行这种检查,你必须维持<编码>航天飞机。 就像以前一样,也不要忘记在改变你的班级时更新。

如果你确实忘记更新这个领域的话,你最终可以采用两种不同的类别,其结构不同,但采用相同的<代码>航天器/代码”。 如果发生这种情况,缺省机制(in.defaultReadObject()将无法发现任何差异,并试图使不兼容的数据脱轨。 现在,你可能会最后出现加密操作时间错误或无声故障(核田)。 这些类型的错误可能难以找到。

为了帮助这一使用案例, Java平台向您提供了一种选择,即不以人工方式订立<编码> 用户识别符号。 相反,在汇编时将产生一个分类结构的洗衣,用作补贴。 这一机制将确保你永远不会有相同的班级结构,因此,你不会得到上述这些难以操作的周期性故障。

但是,汽车产生的补贴战略背后。 也就是说,同一类别产生的胎盘在编造者之间可能有所不同(如Joon Skeet上所述)。 因此,如果你将汇编成册的编码数据与不同的汇编者进行交流,则建议用人工操作的方式保存这些编号。

如果你与前面提到的第一起使用案件中一样的数据相差,你也很可能想保持 yourself。 这样做是为了获得可读物,并对何时和如何变化拥有更大的控制权。

是什么?

<代码>SerialVersionUID是每一类别独一无二的识别符号,JVM用于比较确保同一类别在Serialization期间被装上。

如果你没有具体说明,那么对一个人进行投机就会产生更大的控制。 不同汇编者之间所产生的价值可能有所不同。 此外,有时你只是出于某种原因想禁止旧序列化物体的脱硫[backward incompatibility],在这种情况下,你只得改变序列号。

www.un.org/Depts/DGACM/index_spanish.htm javadocs 编码<>Serializable > ::

the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, and can thus result in unexpected InvalidClassExceptions during deserialization.

www.un.org/Depts/DGACM/index_spanish.htm 因此,你必须申报序列 FCCC/SBI/2008/12。

第条对这个专题有一些好的意见。

最初的问题要求说明为什么重要,例如,这一“编码”将有用。 我已经找到了。

页: 1 固定的汽车物体在档案系统中滞留一段时间。 同时,如果对<代码>Car类别进行修改,增加一个新的领域。 后来,当你试图读到(即海流)固定的<代码>Car物体时,请上<代码>java.io.InvalidClassException——因为所有可序列的类别都自动获得独特的识别符号。 当该类识别符号不等于固定物体的识别特征时,就会出现这一例外。 如果你真的想到,由于增加了新的领域,这一例外被推翻。 你们可以避免这种例外,通过宣布一个明确的序列号来控制海隆。 在明确宣布<代码>航天器/代码>(因此不必计算)方面,也有一些小的业绩效益。 因此,在你创建时,最好在你可以使用的类别中增加你自己的序列号识别符号,如下所示:

public class Car {
    static final long serialVersionUID = 1L; //assign a long value
}

First I need to explain what serialization is.

<>Serialization允许将物体转换成溪流,因为将物体从OR Save的网络上发送,以备日后使用。

There are some rules for serialization.

• 只有当物体的舱面或超舱面能运行时,该物体才会具有序列性。

• An object is serializable (itself implements the Serializable interface) even if its superclass is not. However, the first superclass in the hierarchy of the serializable class, that does not implements Serializable interface, MUST have a no-arg constructor. If this is violated, readObject() will produce a java.io.InvalidClassException in runtime

• 所有原始类型都是可序列的。

• 瞬间田地(有透水层)是NOT序列化的(即没有被节约或恢复)。 采用可乘飞机的班级必须标明不支持序列化的班级(例如档案流)。

• 法定领域(有静态变体)没有序列化。

当Object时,Java Rontime将序号aka、serialVersionID联系起来。

Where we need serialVersionID:

During the deserialization to verify that sender and receiver are compatible with respect to serialization. If the receiver loaded the class with a different serialVersionID then deserialization will end with InvalidClassCastException.
A serializable class can declare its own serialVersionUID explicitly by declaring a field named serialVersionUID that must be static, final, and of type long.

举一个例子来尝试。

import java.io.Serializable;

public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    private String empname;
    private byte empage;

    public String getEmpName() {
        return name;
    }

    public void setEmpName(String empname) {
        this.empname = empname;
    }

    public byte getEmpAge() {
        return empage;
    }

    public void setEmpAge(byte empage) {
        this.empage = empage;
    }

    public String whoIsThis() {
        return getEmpName() + " is " + getEmpAge() + "years old";
    }
}

创造宇宙 目的

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Writer {
    public static void main(String[] args) throws IOException {
        Employee employee = new Employee();
        employee.setEmpName("Jagdish");
        employee.setEmpAge((byte) 30);

        FileOutputStream fout = new
                FileOutputStream("/users/Jagdish.vala/employee.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fout);
        oos.writeObject(employee);
        oos.close();
        System.out.println("Process complete");
    }
}

物体的去向

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Reader {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
        Employee employee = new Employee();
        FileInputStream fin = new FileInputStream("/users/Jagdish.vala/employee.obj");
        ObjectInputStream ois = new ObjectInputStream(fin);
        employee = (Employee) ois.readObject();
        ois.close();
        System.out.println(employee.whoIsThis());
    }
}

NOTE: Now change the seriesVersionUID of the Employee category and Save:

private static final long serialVersionUID = 4L;

And execute the Reader class. Not to execute the Writer class and you will get the exception.

Exception in thread "main" java.io.InvalidClassException: 
com.jagdish.vala.java.serialVersion.Employee; local class incompatible: 
stream classdesc serialVersionUID = 1, local class serialVersionUID = 4
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at com.krishantha.sample.java.serialVersion.Reader.main(Reader.java:14)

如果你将永远不需要将物体序列化,以通过阵列并发送/储存,那么你就不必担心。 如果是的话,那么你必须考虑您的序列VersionUID,因为该物体的旋转器将与其舱载体相符。 更多了解 Java语规格。

If you get this warning on a class you don t ever think about serializing, and that you didn t declare yourself implements Serializable, it is often because you inherited from a superclass, which implements Serializable. Often then it would be better to delegate to such a object instead of using inheritance.

因此,而不是

public class MyExample extends ArrayList<String> {

    public MyExample() {
        super();
    }
    ...
}

do

public class MyExample {
    private List<String> myList;

    public MyExample() {
         this.myList = new ArrayList<String>();
    }
    ...
}

and in the relevant methods call myList.foo() instead of this.foo() (or super.foo()). (This does not fit in all cases, but still quite often.)

I often see people extending JFrame or such, when they really only need to delegate to this. (This also helps for auto-completing in a IDE, since JFrame has hundreds of methods, which you don t need when you want to call your custom ones on your class.)

发出警告(或序列VersionUID)是不可避免的一个案例,是你从“摘要行动”中伸出援手,通常是匿名的,只是增加了“方法”。 我认为,在这种情况下有警示(因为你通常可以进行可靠的序列化,并且把这种匿名的课堂按不同版本的顺序排列),但我不敢肯定编辑如何能够承认这一点。

为了了解外地序列号动力学的重要性,人们应当了解Serialization/Deserialization是如何运作的。

When a Serializable class object is serialized Java Runtime associates a serial version no.(called as serialVersionUID) with this serialized object. At the time when you deserialize this serialized object Java Runtime matches the serialVersionUID of serialized object with the serialVersionUID of the class. If both are equal then only it proceeds with the further process of deserialization else throws InvalidClassException.

因此,我们得出结论,为使航空化/航空化进程取得成功,序列化物体的序列号识别符号必须等同于该类序列号识别符号。 如果方案管理员在方案中明确指明序列VersionUID的价值,那么无论序列化和脱硫化平台如何,这种数值将与序列化物体和类别挂钩(例如,在像管理窗口这样的平台上,可以通过使用日落或日元数据,将序列化和代谢化放在不同的平台,使用Zing JVER)。

但如果是序列 版本 当时,在任何物体的航空化过程中,Java的运行时间使用自己的算法计算时,没有由方案主管具体规定。 这一序列VersionUID的计算法各不相同。 该物体被序列化的环境也有可能使用一种JRE(ex:SUN JVER)和出现蒸气化的环境正在使用LC 15(zing)。 在这种情况下,与序列化物体有关的序列号识别符号将不同于在航空化环境中计算出来的序列号识别符号。 而脱硫则不会成功。 因此,为了避免出现这种情况/问题,方案管理员必须始终具体指明可飞行的序列号。

例如,失踪的序列号识别符号可能会造成一个问题:

I m从事 this E应用软件的工作,该软件由使用模块的网络模块组成。 网站单元将<代码>EJB模块远程连接,并作为论点通过POJO实施<代码> 可空间。

这个POJO s 班在EJB jar内包装,在WEB-INF/lib网站模块内装设。 他们实际上属于同一类别,但在我包裹EJB模块I时,没有把POJO sjar与EJB模块一起包装。

对<代码>EJB的电话由于我已宣布其<代码>航天器/代码>:

Caused by: java.io.IOException: Mismatched serialization UIDs : Source
 (Rep.
 IDRMI:com.hordine.pedra.softbudget.domain.Budget:5CF7CE11E6810A36:04A3FEBED5DA4588)
 = 04A3FEBED5DA4588 whereas Target (Rep. ID RMI:com.hordine.pedra.softbudget.domain.Budget:7AF5ED7A7CFDFF31:6227F23FA74A9A52)
 = 6227F23FA74A9A52

Don t bother, the default calculation is really good and suffice for 99,9999% of the cases. And if you run into problems, you can - as already stated - introduce UID s as the need arrise (which is highly unlikely)

一、一般情况下使用<代码>射电离心>。 我知道,它将离开 Java证书的范畴。

I would know this when I to use ObjectInputStream and ObjectOutputStream for my application or if I know a library/framework I use will use it. The serialVersionID ensures different Java VMs of varying versions or vendors will inter-operate correctly or if it is stored and retrieved outside the VM for example HttpSession the session data can remain even during a restart and upgrade of the application server.

在所有其他情况下,我使用

@SuppressWarnings("serial")

由于大多数时间的缺席,<代码>射电离心/代码>就足够了。 其中包括<代码>Exception,HttpServlet。

Field data represents some information stored in the class. Class implements the Serializable interface, so eclipse automatically offered to declare the serialVersionUID field. Lets start with value 1 set there.

如果你不希望发出这种警告的话,则使用:

@SuppressWarnings("serial")

www.un.org/Depts/DGACM/index_spanish.htm 为什么使用<条码>SerialVersionUID,载于<条码>,可在Java使用<条/条>。

在<代码>航空化>期间, Java的运行时间为某类产品设定一个编号,以便以后能够将其降级。 这份编号为SerialVersionUID。

SerialVersionUID is used to version serialized data. You can only de-serialize a class if it s SerialVersionUID matches with the serialized instance. When we don t declare SerialVersionUID in our class, Java runtime generates it for us but its not recommended. It s recommended to declare SerialVersionUID as private static final long variable to avoid default mechanism.

当你通过实施标记界面(java.io.Serializable宣布一个类别为Serializable时, Java使用默认的Serialization机制将这一类别持续进行下去,条件是你没有使用<代码>可再生接口对这一过程进行定制。

另见:可乘级内使用SerialVersionUID

阅读更多:http://javarevisited.blogspot.com/204/top-10-java-serialization-interview.html#ixzz3VQxnpOPZ

如果一个可序列类别没有明确申报序列VersionUID,则按领域、方法等类别的不同方面计算该类序列VersionUID的数值, 您可参阅 rel=“nofollow noreferer”>。