精华内容
下载资源
问答
  • 概念实现 Serializable 接口, 它只是一个标记接口,不实现也能够进行序列化RMI: 远程方法调用RPC: 远程过程调用序列化ID解决了序列化反序列出现代码不一致的问题, 不一致将导致序列化失败private static final long...

    概念

    实现 Serializable 接口, 它只是一个标记接口,不实现也能够进行序列化

    RMI: 远程方法调用

    RPC: 远程过程调用

    序列化ID

    解决了序列化与反序列出现代码不一致的问题, 不一致将导致序列化失败private static final long serialVersionUID = 1L; //便于进行代码版本控制

    private static final long serialVersionUID = -5453781658505116230L; //便于控制代码结构

    静态变量序列化

    x*- 序列化的是对象,而不是类,静态变量属于类级别,所以序列化不会保存静态变量

    父类序列化与Trancient关键字

    一个子类实现了 Serializable 接口,它的父类没有实现 Serializable 接口,那么序列化子类时,父类的值都不会进行保存

    需要父类保存值 ,就需要让父类也实现Serializable 接口

    取父对象的变量值时,它的值是调用父类无参构造函数后的值,出现如 int 型的默认是 0,string 型的默认是 null, 要指定值,那么需要在父类构造方法中进行指定

    Trancient关键字指定的内容将不会被保存(阻止序列化)

    在被反序列化后,transient 变量的值被设为初始值,如 int 型的是 0,对象型的是 nul

    使用继承关系同样可以实现,Trancient一样的效果,,即为父类不需要实现Serializable接口

    利用PutField getPutField字段进行加密

    原理:

    1: 进行序列化时,JVM试图调用对象的writeObject() readObject() 方法(允许自己私有化实现)

    2:默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法

    private voidwriteObject(ObjectOutputStream out) {try{

    PutField putFields= out.putFields(); //放到

    System.out.println("原密码:" +password);

    password= "encryption";//模拟加密

    putFields.put("password", password);

    System.out.println("加密后的密码" +password);

    out.writeFields();

    }catch(IOException e) {

    e.printStackTrace();

    }

    }private voidreadObject(ObjectInputStream in) {try{

    GetField readFields=in.readFields();

    Object object= readFields.get("password", "");

    System.out.println("要解密的字符串:" +object.toString());

    password= "pass";//模拟解密,需要获得本地的密钥

    } catch(IOException e) {

    e.printStackTrace();

    }catch(ClassNotFoundException e) {

    e.printStackTrace();

    }

    }//调用的时候直接调用 out的writeObject(),或者in的readObject() 即可

    序列化存储规则

    对同一对象两次写入文件, 第一次写入实际对象的序列化后的数据,第二次写入同一个对象的引用数据.(即为指向同一个对象)

    1: 节约了磁盘存储空间

    2: 反序列化后的数据的值,应该是第一次保存的数据的值,(对于同一个对象第二次序列化,值是不会进行保存的)

    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));

    Test test = new Test();

    test.i = ; // 有效

    out.writeObject(test);

    out.flush();

    test.i = ; //无效 第二次反序列化 只写出对象的引用关系 表示为同一个 引用对象,节约了磁盘空间

    out.writeObject(test);

    out.close();

    ObjectInputStream oin = new ObjectInputStream(new FileInputStream(

    "result.obj"));

    Test t = (Test) oin.readObject();

    Test t = (Test) oin.readObject();

    System.out.println(t.i);//

    System.out.println(t.i);//

    Serializable接口的定义:

    public interfaceSerializable {} // 可以知道这个只是 一个标记接口, 并且JVM 并没有实现相应的反射代码,真的据说是起到标记作用! 那么这个标记 是在哪里进行判断的?

    标记的具体定义地方:

    writeObject0方法中有这么一段代码:

    if (obj instanceofString) {2writeString((String) obj, unshared);3 } else if(cl.isArray()) {4writeArray(obj, desc, unshared);5 } else if (obj instanceofEnum) {6 writeEnum((Enum>) obj, desc, unshared);7 } else if (obj instanceofSerializable) {8writeOrdinaryObject(obj, desc, unshared);9 } else{10 if(extendedDebugInfo) {11 throw newNotSerializableException(12 cl.getName() + "/n" +debugInfoStack.toString());13 } else{14 throw newNotSerializableException(cl.getName());15}16 }

    可以看出:  在进行序列化操作时,会判断要被序列化的类是否是Enum、Array和Serializable类型,如果不是则直接抛出 NotSerializableException

    ArrayList分析

    要实现序列化 必须实现Serializable接口,ArrayList 也实现了这个接口

    transient Object[] elementData; //为什么要让ArrayList 存储数据的结构丢弃呢?

    答案:

    ArrayList实际上是动态数组,每次在放满以后自动增长设定的长度值,如果数组自动增长长度设为100,

    而实际只放了一个元素,那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化,

    ArrayList把元素数组设置为transient (一句话只对实际有效的值进行保存)

    -* 实现策略:

    ArrayList 对writeObject readObject 方法进行了重写, 对NULL值数据进行了过滤

    具体分析:

    在ArrayList中定义了来个方法: writeObject 和 readObject

    private voidreadObject(java.io.ObjectInputStream s)2 throwsjava.io.IOException, ClassNotFoundException {3 elementData =EMPTY_ELEMENTDATA;4 //Read in size, and any hidden stuff

    5s.defaultReadObject();6 //Read in capacity

    7 s.readInt(); //ignored

    8 if (size > 0) {9 //be like clone(), allocate array based upon size not capacity

    10ensureCapacityInternal(size);11 Object[] a =elementData;12 //Read in all elements in the proper order.

    13 for (int i=0; i

    private voidwriteObject(java.io.ObjectOutputStream s)2 throwsjava.io.IOException{3 //Write out element count, and any hidden stuff

    4 int expectedModCount =modCount;5s.defaultWriteObject();6 //Write out size as capacity for behavioural compatibility with clone()

    7s.writeInt(size);8 //Write out all elements in the proper order.

    9 for (int i=0; i

    总结; 如何自定义的序列化和反序列化策略 重写 writeObject 和 readObject 方法,

    这两个方法是怎么被调用的?

    voidinvokeWriteObject(Object obj, ObjectOutputStream out)2 throwsIOException, UnsupportedOperationException3{4 if (writeObjectMethod != null) {5 try{6 writeObjectMethod.invoke(obj, newObject[]{ out });7 } catch(InvocationTargetException ex) {8 Throwable th =ex.getTargetException();9 if (th instanceofIOException) {10 throw(IOException) th;11 } else{12throwMiscException(th);13}14 } catch(IllegalAccessException ex) {15 //should not occur, as access checks have been suppressed

    16 throw newInternalError(ex);17}18 } else{19 throw newUnsupportedOperationException();20}21 }

    其中 writeObjectMethod.invoke(obj, new Object[]{ out }); 是关键,通过反射的方式调用writeObjectMethod方法。官方是这么解释这个writeObjectMethod的:

    class-defined writeObject method, or null if none

    在我们的例子中,这个方法就是我们在ArrayList中定义的writeObject方法。通过反射的方式被调用了

    那么怎么反射的呢?

    在  ObjectStreamClass这个方法中 有这么一段代码: 这样 readObjectMethod readObjectNoDataMethod 就拿到 了

    if(externalizable) {

    cons=getExternalizableConstructor(cl);

    }else{

    cons=getSerializableConstructor(cl);

    writeObjectMethod= getPrivateMethod(cl, "writeObject",new Class>[] { ObjectOutputStream.class},

    Void.TYPE);

    readObjectMethod= getPrivateMethod(cl, "readObject",new Class>[] { ObjectInputStream.class},

    Void.TYPE);

    readObjectNoDataMethod=getPrivateMethod(

    cl,"readObjectNoData", null, Void.TYPE);

    hasWriteObjectData= (writeObjectMethod != null);

    }

    domains=getProtectionDomains(cons, cl);

    writeReplaceMethod=getInheritableMethod(

    cl,"writeReplace", null, Object.class);

    readResolveMethod=getInheritableMethod(

    cl,"readResolve", null, Object.class);return null;

    }

    展开全文
  • 本文介绍了Java序列化的基本概念,序列化和反序列化的使用方法,以及实现原理等,比较全面地总结序列化相关知识点,并且使用具体例子来加以佐证。本文参考 http://www.importnew.com/17964.html和 ...

    02aa8a9459002867312ee0811ba72d0a.gif

    本文介绍了Java序列化的基本概念,序列化和反序列化的使用方法,以及实现原理等,比较全面地总结序列化相关知识点,并且使用具体例子来加以佐证。

    本文参考 http://www.importnew.com/17964.html和 https://www.ibm.com/developerworks/cn/java/j-lo-serial/

    序列化与反序列化概念

    序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介,例如档案或是记亿体缓冲等。在网络传输过程中,可以是字节或是XML等格式。而字节的或XML编码格式可以还原完全相等的对象。这个相反的过程又称为反序列化。

    Java对象的序列化与反序列化

    在Java中,我们可以通过多种方式来创建对象,并且只要对象没有被回收我们都可以复用该对象。但是,我们创建出来的这些Java对象都是存在于JVM的堆内存中的。

    只有JVM处于运行状态的时候,这些对象才可能存在。一旦JVM停止运行,这些对象的状态也就随之而丢失了。

    但是在真实的应用场景中,我们需要将这些对象持久化下来,并且能够在需要的时候把对象重新读取出来。Java的对象序列化可以帮助我们实现该功能。

    对象序列化机制(object serialization)是Java语言内建的一种对象持久化方式,通过对象序列化,可以把对象的状态保存为字节数组,并且可以在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。

    对象序列化可以很容易的在JVM中的活动对象和字节数组(流)之间进行转换。

    在Java中,对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中。

    相关接口及类

    Java为了方便开发人员将Java对象进行序列化及反序列化提供了一套方便的API来支持。其中包括以下接口和类:

    java.io.Serializable

    java.io.Externalizable

    ObjectOutput

    ObjectInput

    ObjectOutputStream

    ObjectInputStream

    Serializable 接口

    类通过实现 java.io.Serializable 接口以启用其序列化功能。

    未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。 (该接口并没有方法和字段,为什么只有实现了该接口的类的对象才能被序列化呢?)

    当试图对一个对象进行序列化的时候,如果遇到不支持 Serializable 接口的对象。在此情况下,将抛出NotSerializableException。

    如果要序列化的类有父类,要想同时将在父类中定义过的变量持久化下来,那么父类也应该集成java.io.Serializable接口。

    下面是一个实现了java.io.Serializable接口的类

    public class 序列化和反序列化 {

       public static void main(String[] args) {

       }

       //注意,内部类不能进行序列化,因为它依赖于外部类

       @Test

       public void test() throws IOException {

           A a = new A();

           a.i = 1;

           a.s = "a";

           FileOutputStream fileOutputStream = null;

           FileInputStream fileInputStream = null;

           try {

               //将obj写入文件

               fileOutputStream = new FileOutputStream("temp");

               ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

               objectOutputStream.writeObject(a);

               fileOutputStream.close();

               //通过文件读取obj

               fileInputStream = new FileInputStream("temp");

               ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

               A a2 = (A) objectInputStream.readObject();

               fileInputStream.close();

               System.out.println(a2.i);

               System.out.println(a2.s);

               //打印结果和序列化之前相同

           } catch (IOException e) {

               e.printStackTrace();

           } catch (ClassNotFoundException e) {

               e.printStackTrace();

           }

       }

    }

    class A implements Serializable {

       int i;

       String s;

    }

    Externalizable接口

    除了Serializable 之外,java中还提供了另一个序列化接口Externalizable

    为了了解Externalizable接口和Serializable接口的区别,先来看代码,我们把上面的代码改成使用Externalizable的形式。

    class B implements Externalizable {

       //必须要有公开无参构造函数。否则报错

       public B() {

       }

       int i;

       String s;

       @Override

       public void writeExternal(ObjectOutput out) throws IOException {

       }

       @Override

       public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

       }

    }

    @Test

       public void test2() throws IOException, ClassNotFoundException {

           B b = new B();

           b.i = 1;

           b.s = "a";

           //将obj写入文件

           FileOutputStream fileOutputStream = new FileOutputStream("temp");

           ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

           objectOutputStream.writeObject(b);

           fileOutputStream.close();

           //通过文件读取obj

           FileInputStream fileInputStream = new FileInputStream("temp");

           ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

           B b2 = (B) objectInputStream.readObject();

           fileInputStream.close();

           System.out.println(b2.i);

           System.out.println(b2.s);

           //打印结果为0和null,即初始值,没有被赋值

           //0

           //null

       }

    通过上面的实例可以发现,对B类进行序列化及反序列化之后得到的对象的所有属性的值都变成了默认值。也就是说,之前的那个对象的状态并没有被持久化下来。这就是Externalizable接口和Serializable接口的区别:

    Externalizable继承了Serializable,该接口中定义了两个抽象方法:writeExternal()与readExternal()。

    当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法。由于上面的代码中,并没有在这两个方法中定义序列化实现细节,所以输出的内容为空。

    还有一点值得注意:在使用Externalizable进行序列化的时候,在读取对象时,会调用被序列化类的无参构造器去创建一个新的对象,然后再将被保存对象的字段的值分别填充到新对象中。所以,实现Externalizable接口的类必须要提供一个public的无参的构造器。

    class C implements Externalizable {

       int i;

       int j;

       String s;

       public C() {

       }

       //实现下面两个方法可以选择序列化中需要被复制的成员。

       //并且,写入顺序和读取顺序要一致,否则报错。

       //可以写入多个同类型变量,顺序保持一致即可。

       @Override

       public void writeExternal(ObjectOutput out) throws IOException {

           out.writeInt(i);

           out.writeInt(j);

           out.writeObject(s);

       }

       @Override

       public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

           i = in.readInt();

           j = in.readInt();

           s = (String) in.readObject();

       }

    }

    @Test

       public void test3() throws IOException, ClassNotFoundException {

           C c = new C();

           c.i = 1;

           c.j = 2;

           c.s = "a";

           //将obj写入文件

           FileOutputStream fileOutputStream = new FileOutputStream("temp");

           ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

           objectOutputStream.writeObject(c);

           fileOutputStream.close();

           //通过文件读取obj

           FileInputStream fileInputStream = new FileInputStream("temp");

           ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

           C c2 = (C) objectInputStream.readObject();

           fileInputStream.close();

           System.out.println(c2.i);

           System.out.println(c2.j);

           System.out.println(c2.s);

           //打印结果为0和null,即初始值,没有被赋值

           //0

           //null

       }

    序列化ID

    序列化 ID 问题 情境:两个客户端 A 和 B 试图通过网络传递对象数据,A 端将对象 C 序列化为二进制数据再传给 B,B 反序列化得到 C。

    问题:C 对象的全类路径假设为 com.inout.Test,在 A 和 B 端都有这么一个类文件,功能代码完全一致。也都实现了 Serializable 接口,但是反序列化时总是提示不成功。

    解决:虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID = 1L)。清单 1 中,虽然两个类的功能代码完全一致,但是序列化 ID 不同,他们无法相互序列化和反序列化。

    package com.inout;

    import java.io.Serializable;

    public class A implements Serializable {

       private static final long serialVersionUID = 1L;

       private String name;

       public String getName()

       {

           return name;

       }

       public void setName(String name)

       {

           this.name = name;

       }

    }

    package com.inout;

    import java.io.Serializable;

    public class A implements Serializable {

       private static final long serialVersionUID = 2L;

       private String name;

       public String getName()

       {

           return name;

       }

       public void setName(String name)

       {

           this.name = name;

       }

    }

    静态变量不参与序列化

    清单 2 中的 main 方法,将对象序列化后,修改静态变量的数值,再将序列化对象读取出来,然后通过读取出来的对象获得静态变量的数值并打印出来。依照清单 2,这个 System.out.println(t.staticVar) 语句输出的是 10 还是 5 呢?

    public class Test implements Serializable {

       private static final long serialVersionUID = 1L;

       public static int staticVar = 5;

       public static void main(String[] args) {

           try {

               //初始时staticVar为5

               ObjectOutputStream out = new ObjectOutputStream(

                       new FileOutputStream("result.obj"));

               out.writeObject(new Test());

               out.close();

               //序列化后修改为10

               Test.staticVar = 10;

               ObjectInputStream oin = new ObjectInputStream(new FileInputStream(

                       "result.obj"));

               Test t = (Test) oin.readObject();

               oin.close();

               //再读取,通过t.staticVar打印新的值

               System.out.println(t.staticVar);

           } catch (FileNotFoundException e) {

               e.printStackTrace();

           } catch (IOException e) {

               e.printStackTrace();

           } catch (ClassNotFoundException e) {

               e.printStackTrace();

           }

       }

    }

    最后的输出是 10,对于无法理解的读者认为,打印的 staticVar 是从读取的对象里获得的,应该是保存时的状态才对。之所以打印 10 的原因在于序列化时,并不保存静态变量,这其实比较容易理解,序列化保存的是对象的状态,静态变量属于类的状态,因此 序列化并不保存静态变量。

    探究ArrayList的序列化

    ArrayList的序列化 在介绍ArrayList序列化之前,先来考虑一个问题:

    如何自定义的序列化和反序列化策略

    带着这个问题,我们来看java.util.ArrayList的源码

    public class ArrayList<E> extends AbstractList<E>

           implements List<E>, RandomAccess, Cloneable, java.io.Serializable

    {

       private static final long serialVersionUID = 8683452581122892189L;

       transient Object[] elementData; // non-private to simplify nested class access

       private int size;

    }

    笔者省略了其他成员变量,从上面的代码中可以知道ArrayList实现了java.io.Serializable接口,那么我们就可以对它进行序列化及反序列化。

    因为elementData是transient的(1.8好像改掉了这一点),所以我们认为这个成员变量不会被序列化而保留下来。我们写一个Demo,验证一下我们的想法:

    public class ArrayList的序列化 {

       public static void main(String[] args) throws IOException, ClassNotFoundException {

           ArrayList list = new ArrayList();

           list.add("a");

           list.add("b");

           ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("arr"));

           objectOutputStream.writeObject(list);

           objectOutputStream.close();

           ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("arr"));

           ArrayList list1 = (ArrayList) objectInputStream.readObject();

           objectInputStream.close();

           System.out.println(Arrays.toString(list.toArray()));

           //序列化成功,里面的元素保持不变。

       }

    了解ArrayList的人都知道,ArrayList底层是通过数组实现的。那么数组elementData其实就是用来保存列表中的元素的。通过该属性的声明方式我们知道,他是无法通过序列化持久化下来的。那么为什么code 4的结果却通过序列化和反序列化把List中的元素保留下来了呢?

    writeObject和readObject方法

    在ArrayList中定义了来个方法: writeObject和readObject。

    这里先给出结论:

    在序列化过程中,如果被序列化的类中定义了writeObject 和 readObject 方法,虚拟机会试图调用对象类里的 writeObject 和 readObject 方法,进行用户自定义的序列化和反序列化。

    如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。

    用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。

    来看一下这两个方法的具体实现:

    private void readObject(java.io.ObjectInputStream s)

           throws java.io.IOException, ClassNotFoundException {

           elementData = EMPTY_ELEMENTDATA;

           // Read in size, and any hidden stuff

           s.defaultReadObject();

           // Read in capacity

           s.readInt(); // ignored

           if (size > 0) {

               // be like clone(), allocate array based upon size not capacity

               ensureCapacityInternal(size);

               Object[] a = elementData;

               // Read in all elements in the proper order.

               for (int i=0; i<size; i++) {

                   a[i] = s.readObject();

               }

           }

       }

    private void writeObject(java.io.ObjectOutputStream s)

           throws java.io.IOException{

           // Write out element count, and any hidden stuff

           int expectedModCount = modCount;

           s.defaultWriteObject();

           // Write out size as capacity for behavioural compatibility with clone()

           s.writeInt(size);

           // Write out all elements in the proper order.

           for (int i=0; i<size; i++) {

               s.writeObject(elementData[i]);

           }

           if (modCount != expectedModCount) {

               throw new ConcurrentModificationException();

           }

       }

    那么为什么ArrayList要用这种方式来实现序列化呢?

    why transient

    ArrayList实际上是动态数组,每次在放满以后自动增长设定的长度值,如果数组自动增长长度设为100,而实际只放了一个元素,那就会序列化99null元素。为了保证在序列化的时候不会将这么多null同时进行序列化,ArrayList把元素数组设置为transient

    why writeObject and readObject

    前面说过,为了防止一个包含大量空对象的数组被序列化,为了优化存储,所以,ArrayList使用transient来声明elementData 但是,作为一个集合,在序列化过程中还必须保证其中的元素可以被持久化下来,所以,通过重写writeObject readObject方法的方式把其中的元素保留下来。

    writeObject方法把elementData数组中的元素遍历的保存到输出流(ObjectOutputStream)中。

    readObject方法从输入流(ObjectInputStream)中读出对象并保存赋值到elementData数组中。

    如何自定义的序列化和反序列化策略

    延续上一部分,刚刚我们明白了ArrayList序列化数组元素的原理。

    至此,我们先试着来回答刚刚提出的问题:

    如何自定义的序列化和反序列化策略

    答:可以通过在被序列化的类中增加writeObject 和 readObject方法。那么问题又来了:

    虽然ArrayList中写了writeObject 和 readObject 方法,但是这两个方法并没有显示的被调用啊。

    那么如果一个类中包含writeObject 和 readObject 方法,那么这两个方法是怎么被调用的呢?

    ObjectOutputStream 从code 4中,我们可以看出,对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的,那么带着刚刚的问题,我们来分析一下ArrayList中的writeObject 和 readObject 方法到底是如何被调用的呢?

    为了节省篇幅,这里给出ObjectOutputStream的writeObject的调用栈:

    writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

    这里看一下invokeWriteObject:

    void invokeWriteObject(Object obj, ObjectOutputStream out)

           throws IOException, UnsupportedOperationException

       {

           if (writeObjectMethod != null) {

               try {

                   writeObjectMethod.invoke(obj, new Object[]{ out });

               } catch (InvocationTargetException ex) {

                   Throwable th = ex.getTargetException();

                   if (th instanceof IOException) {

                       throw (IOException) th;

                   } else {

                       throwMiscException(th);

                   }

               } catch (IllegalAccessException ex) {

                   // should not occur, as access checks have been suppressed

                   throw new InternalError(ex);

               }

           } else {

               throw new UnsupportedOperationException();

           }

       }

    其中writeObjectMethod.invoke(obj, new Object[]{ out });是关键,通过反射的方式调用writeObjectMethod方法。官方是这么解释这个writeObjectMethod的:

    class-defined writeObject method, or null if none

    在我们的例子中,这个方法就是我们在ArrayList中定义的writeObject方法。通过反射的方式被调用了。

    至此,我们先试着来回答刚刚提出的问题:

    如果一个类中包含writeObject readObject 方法,那么这两个方法是怎么被调用的?

    答:在使用ObjectOutputStreamwriteObject方法和ObjectInputStreamreadObject方法时,会通过反射的方式调用。

    为什么要实现Serializable

    至此,我们已经介绍完了ArrayList的序列化方式。那么,不知道有没有人提出这样的疑问:

    Serializable明明就是一个空的接口,它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢?

    Serializable接口的定义:

    public interface Serializable {

    }

    读者可以尝试把code 1中的继承Serializable的代码去掉,再执行code 2,会抛出java.io.NotSerializableException

    其实这个问题也很好回答,我们再回到刚刚ObjectOutputStream的writeObject的调用栈:

    writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

    writeObject0方法中有这么一段代码:

    if (obj instanceof String) {

                   writeString((String) obj, unshared);

               } else if (cl.isArray()) {

                   writeArray(obj, desc, unshared);

               } else if (obj instanceof Enum) {

                   writeEnum((Enum>) obj, desc, unshared);

               } else if (obj instanceof Serializable) {

                   writeOrdinaryObject(obj, desc, unshared);

               } else {

                   if (extendedDebugInfo) {

                       throw new NotSerializableException(

                           cl.getName() + "\n" + debugInfoStack.toString());

                   } else {

                       throw new NotSerializableException(cl.getName());

                   }

               }

    在进行序列化操作时,会判断要被序列化的类是否是Enum、Array和Serializable类型,如果不是则直接抛出NotSerializableException。

    序列化知识点总结

    1、如果一个类想被序列化,需要实现Serializable接口。否则将抛出NotSerializableException异常,这是因为,在序列化操作过程中会对类型进行检查,要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。

    2、通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化

    3、虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID)

    序列化 ID 在 Eclipse 下提供了两种生成策略,一个是固定的 1L,一个是随机生成一个不重复的 long 类型数据(实际上是使用 JDK 工具生成),在这里有一个建议,如果没有特殊需求,就是用默认的 1L 就可以,这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢,有些时候,通过改变序列化 ID 可以用来限制某些用户的使用。

    4、序列化并不保存静态变量。

    5、要想将父类对象也序列化,就需要让父类也实现Serializable 接口。

    6、Transient 关键字的作用是控制变量的序列化,在变量声明前加上该关键字,可以阻止该变量被序列化到文件中,在被反序列化后,transient 变量的值被设为初始值,如 int 型的是 0,对象型的是 null。

    7、服务器端给客户端发送序列化对象数据,对象中有一些数据是敏感的,比如密码字符串等,希望对该密码字段在序列化时,进行加密,而客户端如果拥有解密的密钥,只有在客户端进行反序列化时,才可以对密码进行读取,这样可以一定程度保证序列化对象的数据安全。

    8、在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略

    7e66bbf282e8a728ddeae27006661d0e.png

    展开全文
  • @Java讲坛杨工Java对象为什么需要被序列化序列化能够将对象转为二进制流,对象就可以方便的在网络中被传输和保存。实现序列化的方式实现Serializable接口实现Externalizable接口这两个接口的区别是:Serializable...

    @Java讲坛杨工

    f240e733b829882a8224ad43ce7d3585.png

    Java对象为什么需要被序列化

    • 序列化能够将对象转为二进制流,对象就可以方便的在网络中被传输和保存。

    实现序列化的方式

    • 实现Serializable接口
    • 实现Externalizable接口

    这两个接口的区别是:Serializable接口会自动给对象的所有属性标记为可被序列化。而Externalizable接口默认不给任何属性标记可被序列化,如果需要序列化,需要重写两个方法,分别是writeExternal()和readExternal(),然后在这两个方法中标记需要被序列化的对象属性。

    实现这两个接口,只是表示该对象可以被序列化,真正的做序列化操作,需要ObjectOutputStream对象操作。接下来就用编码的方式体现序列化。

    1、先写个序列化操作的工具类,用于实现序列化和反序列化。

    import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;/** * 序列化操作工具类 * @author 杨33 * @date 2020/6/21 15:22 */public class SerializeUtil {    /**     * 将对象转成字节数组     * @param object 需要序列化的对象     * @return     * @throws IOException     */    public static byte[] serialize(Object object) throws IOException{        if(object == null){            return null;        }        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);        objectOutputStream.writeObject(object);        return byteArrayOutputStream.toByteArray();    }    /**     * 反序列化     * @param bytes 对象字节数组     * @throws IOException     * @throws ClassNotFoundException     */    public static Object unserialize(byte[] bytes) throws IOException, ClassNotFoundException{        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);        return objectInputStream.readObject();    }}

    先来实现一个Serializable接口

    /** * @author 杨33 * @date 2020/6/21 14:20 */public class Owner implements Serializable {    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}

    测试下:

    import java.io.IOException;/** * @author 杨33 * @date 2020/6/21 14:54 */public class Demo {    public static void main(String[] args) throws IOException, ClassNotFoundException {        Owner owner = new Owner();        owner.setName("李四");        //序列化        byte[] serialize = SerializeUtil.serialize(owner);        System.out.println("序列化的效果:" + serialize);        //反序列化        owner = (Owner)SerializeUtil.unserialize(serialize);        System.out.println("反序列化的效果:" + owner.getName());    }}

    控制台打印结果:

    序列化的效果:[B@58ca40be反序列化的效果:李四

    如果这个name字段不需要被序列化,可以使用关键字transient修饰,比如:

    private transient String name;

    此时测试一下,name字段就不会被序列化,反序列化后拿到的值就为null。

    序列化的效果:[B@4ca49360反序列化的效果:null

    再实现一个Externalizable接口

    /** * @author 杨33 * @date 2020/6/21 14:20 */public class Medium implements Externalizable {    private String name;    private String sex;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getSex() {        return sex;    }    public void setSex(String sex) {        this.sex = sex;    }        public void writeExternal(ObjectOutput out) throws IOException {        out.writeObject(name);        out.writeObject(sex);    }    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {        name = (String) in.readObject();        sex = (String) in.readObject();    }}

    测试下:

    import java.io.IOException;/** * @author 杨33 * @date 2020/6/21 14:54 */public class Demo {    public static void main(String[] args) throws IOException, ClassNotFoundException {        Medium medium = new Medium();        medium.setName("李四");        medium.setSex("女");        //序列化        byte[] serialize = SerializeUtil.serialize(medium);        System.out.println("序列化的效果:" + serialize);        //反序列化        medium = (Medium)SerializeUtil.unserialize(serialize);        System.out.println("反序列化的效果:" + medium.getName());        System.out.println("反序列化的效果:" + medium.getSex());    }}

    控制台打印结果:

    序列化的效果:[B@71d9a2ab反序列化的效果:李四反序列化的效果:女

    如果字段sex不需要被序列化,那么可以在方法writeExternal()和readExternal()中去掉设置sex字段的代码。最后测试,sex字段不会被序列化,反序列化后拿到的值就为null。

    序列化的效果:[B@746c2f2反序列化的效果:李四反序列化的效果:null

    到此,本次知识分享就结束了,谢谢大家对我的写作方面的鼓励。我会继续努力。

    阅读完此文,觉得哪里有问题,请下方留言,我会及时回复。

    展开全文
  • JDK内置同步器的实现类经常会看到java.io.Serializable接口,这个接口即是Java序列化操作,这样看来序列化也是同步器的一种机制。01关于序列化本文主要分析Java中的序列化机制,并看看AQS同步器的序列化,掌握序列化...
    JDK内置同步器的实现类经常会看到java.io.Serializable接口,这个接口即是Java序列化操作,这样看来序列化也是同步器的一种机制。01

     关于序列化

    本文主要分析Java中的序列化机制,并看看AQS同步器的序列化,掌握序列化机制才能完整理解JDK内置的同步工具的实现。

    在程序中为了能直接以Java对象的形式进行保存,然后再重新得到该Java对象,我们需要序列化能力。序列化其实可以看成是一种机制,即按照一定的格式将Java对象的状态转成介质可接受的形式,以方便存储或传输。Java中进行序列化操作需要实现Serializable或Externalizable接口。

    83b8ebb64f8cfc7f1df7f7a9b00d188d.png02

     序列化过程

    Java序列化的大致过程为:序列化时将Java对象相关的类信息、属性及属性值等等以一定的格式转为字节流,反序列化时则根据字节流表示的信息来构建出Java对象。过程中可能涉及到其它对象的引用,所以涉及到引用的对象的相关信息也要参与序列化。如下图所示,Java对象经过序列化后转为字节流,保存字节流的常见方式有文件、内存、网络、数据库。反序列化时则通过这些介质读取字节流,然后还原为Java对象。

    124ae7c038510dff54412c53ece40c01.png

    03

     序列化作用

    • 提供一种简单又可扩展的对象保存恢复机制。

    • 对于远程调用,能方便对对象进行编码和解码,就像实现对象直接传输。
    • 可以将对象持久化到介质中,就像实现对象直接存储。
    • 允许对象自定义外部存储的格式。
    04

     序列化的例子

    常见的使用方式是直接将对象写入流中,比如下面的例子中,创建了FileOutputStream对象,对应输出到tmp.o文件中。然后创建ObjectOutputStream对象嵌套前面的输出流,当我们调用writeObject方法时即能进行序列化操作。

    be3ed5123fc33f0403384f13adf1aa72.pngwriteObject方法需要特别说明一下,当我们对某个对象进行写入时,其实不仅仅序列化该对象,它还会去遍历寻找相关引用的其它对象,由自己和其它引用对象组成的一个完整的对象图关系都会被序列化。除了一些特殊指定的类,普通类必须实现Serializable或Externalizable接口才能被序列化。05

     反序列化的例子

    反序列化是序列化的反向操作,即通过字节流来还原Java对象。看下面的例子,首先创建FileInputStream对象,其对应的文件为tmp.o。然后创建ObjectInputStream对象嵌套前面的输入流,接着则可以调用readObject方法读取对象。readObject方法除了会恢复对象自己之外,它还会遍历整个完整的对象图关系,创建整个对象图包含的所有对象。036fd49f6a7ef98a2e91df85319c5b60.png06

    serialVersionUID的作用

    序列化操作时,经常会看到实现了Serializable接口的类会存在一个serialVersionUID属性,并且它是一个固定数值的静态变量。比如下面的一行代码,这个属性有什么作用?其实它主要用于验证版本的一致性。每个类都拥有这么一个ID,在序列化的时候会一起被写入流中。在反序列化的时候就被拿出来跟当前类的serialVersionUID值进行比较,两者相同则说明版本一致,可以序列化成功,而如果不同则序列化失败。c5a4b2d95b0496101930d9ff39b0eebb.png一般情况下我们可以自己定义serialVersionUID的值或者由IDE帮我们自动生成,如果我们不显示定义serialVersionUID的话,也不代表不存在serialVersionUID,而是由JDK帮我们生成。生成规则是利用类名、类修饰符、接口名、字段、静态初始化信息、构造函数信息、方法名、方法修饰符、方法签名等组成的信息,经过SHA算法生成摘要作为最终的serialVersionUID值。07

     父类的序列化

    如果一个子类实现了Serializable接口而父类没有实现该接口,则在序列化子类时,子类的属性状态会被写入而父类的属性状态将不被写入。所以如果想要父类属性状态也一起参与序列化,就要让它也实现Serializable接口。

    另外,如果父类未实现Serializable接口则反序列化生成的对象会再次调用父类的构造函数,以此完成对父类的初始化。所以父类属性初始值一般都是类型的默认值。比如下面的代码,Father类的属性不会参与序列化,反序列化时Father对象的属性的值为默认值0。

    16eda7f0aeae9af8ae223430ea20d565.png

    08

     哪些字段会被序列化

    在序列化时对象的哪些字段会参与到序列化中呢?其实有两种方式决定哪些字段会被序列化。一是默认方式,Java对象中的非静态和非transient的字段都会被定义为需要序列化的字段。另外一种方式是通过ObjectStreamField数组来声明需要序列化的对象。

    可以看到对象中普通的属性都是默认会被序列化的,而如果某些包含了敏感信息的属性我们不希望它参与序列化,那么最简单的方式就是可以将该字段声明为transient。

    如何使用ObjectStreamField呢?举个例子,如下代码中A类中有name和password两个字段,我们通过ObjectStreamField数组声明只需序列化name字段。我们不必纠结为什么这样声明,这仅仅是一个约定而已。

    2677e0ced75ac5c0f789028eb249a685.png09

     Externalizable接口

    Externalizable接口主要就是提供给用户自己控制序列化内容,虽然前面我们也看到了transient和ObjectStreamField都能定义参与序列化的字段,但实际上Externalizable接口提供了更加灵活的方式。可以看到它其实继承了Serializable接口,然后提供了writeExternal和readExternal两个方法,我们就是在这两个方法内控制序列化和反序列化。

    0a60eae0d21cf98948f7c7ca47a285cb.png

    比如下面的例子,我们可以在writeExternal方法中额外写入Date对象,然后再写入value值。对应地,反序列化时则是在readExternal方法中读取Date对象和value。这样就完成了自定义序列化操作。

    26d1b817aded6883981ac7620eca46d3.png10

     写入时代替

    正常情况下序列化某个对象时写入的正是当前的对象,但如果说我们要替换当前的对象而写入其他对象的话则可以通过writeReplace方法来实现。比如下面,person类通过writeReplace方法最终可以写入Object数组对象。所以我们在反序列化时就不再是转换成Person类型,而是要转换为Object数组对象。

    b5ba1cc7baa827f8444492f2a6a22370.png11

     读取时代替

    上面介绍了在写入时可以替换对象,而在读取时也同样支持替换对象的,它是通过readResolve方法实现的。比如下面的代码,在readResolve方法返回2222,则反序列化读取时不再是Person对象,而是2222。

    3c93d6fb1ec27715c4f2a030f8de0cbe.png12

     AQS序列化

    JDK内置并发AQS同步器实现了Serializable接口,其中head和tail变量声明为transient。也就是说如果对AQS同步器对象进行序列化的话,队列是不参与序列化的,只有同步状态会参与序列化。也就是说序列化会让AQS丢失队列信息,只能保留同步状态信息。

    50bec6ffb6e4ed08c1407f633c180c5e.png

    - END -

    3f05046142996cd2d7b39f9682939e3e.png

    展开全文
  • 序列化过程中,其对象想要被序列化,那么它的类就要实现 此接口,这个对象的所有属性(包括private属性、包括其引用的对象)都可以被序列化和反序列化来保存、传递。 比如:在本实例中,DivSort必须实现Serializable...
  • 的写入和读取,为了就是存储对象,因为我们知道,Java中存储对象,我们可以利用集合List或者Set亦或者HashTable来存储,但是在redis中,想要存储对象,必须先序列化对象,反之,读取的时候,在将对象反序列化还原...
  • 上一篇文章《Java对象的序列化与反序列化》中,简单介绍了Java中对象的序列化和反序列化的一些基础知识。看文那篇文章后,有小伙伴留言说:我终于了解了Java的序列化了。我只想说:小伙子,你真的是图样图森破啊 。...
  • 在msgpack-java 0.6 或者早期的版本中,POJO 在 MessagePack 中被序列化反序列化为数组变量。 变量的顺序是基于 Java 类中变量的内部顺序了,这种本来是一种原生的序列化方法,但是会导致一些问题。导致这些问题...
  • 文章目录了解序列化反序列化概念如何序列化/反序列化Java对象必须实现java.io.Serializable接口序列化反序列化小结 了解序列化反序列化概念 序列化是指把一个Java对象变成二进制内容,本质上就是一个byte[]...
  • 概念 序列化:将对象序列化成字节数组反序列化:将字节数组反序列化成对象。
  • <div><p>一个字节数组bytes,里面包含了若干个hessian序列化后的值,可能是基础类型,...用来实现指定反序列化某个值)</p><p>该提问来源于开源项目:apache/dubbo-go-hessian2</p></div>
  • 序列化是将实例化对象转换成字节数组反序列化是将字节数组转换成对象。 实例 前提 使需要序列化的类实现Serializable接口 public class MyMessage implements Serializable 序列化 ...
  • 序列化和反序列化的概念 序列化:把对象转换为字节序列的过程 对象序列化过程可以分为两步: 第一: 将对象转换为字节数组 ...如何实现反序列化 实现Serializable接口,具体看代码 package xfgg; im...
  • importjava.io.*;/***Createdbyjingqing.zhouon2015/6/12.*ByteArrayOutputStream:可以捕获内存缓冲区的数据,转换成字节数组。*DataInputStream&DataOutputStream关心如何将数据从高层次的形式转化成低层次的...
  • 参考资料:1、http://blog.csdn.net/u012554102/article/details/519026972、《深入分析Java Web技术内幕》许令波 著3、http://blog.csdn.net/summer_sy/article/details/70255421一、...二、Java序列化方式1、实现S...
  • import java.io.*;/*** Created by jingqing.zhou on 2015/6/12.* ByteArrayOutputStream :可以捕获内存缓冲区的数据,转换成字节数组。* DataInputStream&DataOutputStream关心如何将数据从高层次的形式转化成...
  • (一)什么是序列化和反序列化序列化(serialization)和反序列化(deserialization)是将对象转化成字节数组以方便保存或者用于网络传输,这个对象可以是一个图片,一个字符串,一个class等等,常见序列化格式有...
  • 反序列化就是将字节数组再转回对象的过程。 对于序列化和反序列化总结了几点需要注意的地方, 1、实现Serializable接口的类才能够序列化,如果是父类实现了该接口,子类也可以进行序列化 这点不过多解释,规定...
  • 在平常的工作过程中,我们经常会提到并且用到序列化和反序列化,RPC的使用就是最好的一个例子,那么到底是序列化和反序列化呢,序列化和反序列化有什么用处,Java又是如何实现序列化和反序列化的呢? 序列化是将...
  • java序列化与反序列化

    2018-11-25 17:29:13
    序列化是将对象转换成字节数组的过程,反序列化是将字节数组转换成对象的过程。 2、为啥要序列化? 简单来说,因为网络传输的都是二进制的字节流,所以如果一个对象需要在网络传输,就需要序列化。 3、java如何做...
  • java序列化、反序列化

    2020-04-14 20:25:20
    Java 序列化是 JDK 1.1 时引入的一组开创性的特性,用于将 Java 对象转换为字节数组,便于存储或传输。此后,仍然可以将字节数组转换回 ...在java中,实现Serializbale 接口的对象,都可以序列化、反序列化。Seria...
  • 利用fastjson反序列化json为对象和对象数组 利用 fastjosn 将 .json文件 反序列化为 java.class 和 java.util.List fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器,来自阿里巴巴的工程师开发。 ...
  • java序列化及反序列化

    2019-08-25 22:27:43
    java序列化 (一)java序列化的官方概念: 将对象转换为一串二进制字节数组,可以保存到磁盘或...1、实现java序列化的接口(java.io.Serializable) package com.rocket.framework.practice.serialize; import jav...
  • 当一个类实现了Seializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化序列化的目的是将一个实现了Serializable接口的对象可以转换成一个字节序列,保存对象的状态。其实就是用一个字节...
  • Java序列化与反序列化

    2019-08-24 17:57:36
    1. 序列化的含义、意义及使用场景 Java平台允许创建在内存中可以复用的java对象,但一般...**反序列化:**从IO流中恢复对象 **意义:**序列化机制允许将实现序列化的Java对象,转换为字节数组,这些字节数组可以保...
  • 导读热词下面是编程之家 jb51.cc 通过网络收集整理的.../*** Created by jingqing.zhou on 2015/6/12.* ByteArrayOutputStream :可以捕获内存缓冲区的数据,转换成字节数组。* DataInputStream&DataOutputStrea...
  • 利用fastjson反序列化json为对象和对象数组利用 fastjosn 将 .json文件 反序列化为 java.class 和 java.util.Listfastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器,来自阿里巴巴的工程师开发。...
  • Java序列化和反序列化

    2015-09-30 15:36:00
    序列化是将实例化对象转换成字节数组反序列化是将字节数组转换成对象。 实例 前提 使需要序列化的类实现Serializable接口 public class MyMessage implements Serializable 序列化 ...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 234
精华内容 93
关键字:

java实现数组序列化反序列化

java 订阅