关于java:Java序列化浅析

定义

Java序列化是指将Java对象保留为二进制字节码的过程；Java反序列化示意将二级制字节码转化为Java对象的过程。

Java序列化的起因

1. 因为Java对象的生命周期比JVM短，JVM进行运行之后，Java对象就不复存在，如果想要在JVM进行运行之后，获取Java对象，就须要对其进行序列化后进行保留。
2. 须要将Java对象通过网络传输时（rmi），通过将Java对象序列化为二进制的模式在网络中传输。

Java序列化的原理

1. 能够通过ObjectInputStream和ObjectOutputStream的readObject() 和 writeObject() 办法进行反序列化和序列化。

   实现代码：

   待序列化对象

    @Data
    @ToString
    public class LearnDTO implements Serializable {
        private String name;
        private int age;
        private String nation;
    }

   序列化办法

   public class SerializableLearning {
   
       public static void main(String[] args) {
           LearnDTO dto = new LearnDTO();
           dto.setName("gavin");
           dto.setAge(18);
           dto.setNation("汉");
           System.out.println("序列化对象----开始");
           writeObject(dto);
           System.out.println("序列化对象----完结");
   
           System.out.println("反序列化对象----开始");
           readObject();
           System.out.println("反序列化对象----完结");
       }
   
       public static void writeObject(LearnDTO dto) {
           try (FileOutputStream file = new FileOutputStream(new File("test"));
                ObjectOutputStream os = new ObjectOutputStream(file)) {
               os.writeObject(dto);
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   
       public static void readObject() {
           try (FileInputStream file = new FileInputStream(new File("test"));
                ObjectInputStream oi = new ObjectInputStream(file)) {
               LearnDTO o = (LearnDTO) oi.readObject();
               System.out.println(o.toString());
           } catch (FileNotFoundException e) {
               e.printStackTrace();
           } catch (IOException e) {
               e.printStackTrace();
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           }
       }
   }

   运行后果

       序列化对象----开始
       序列化对象----完结
       反序列化对象----开始
       LearnDTO(name=gavin, age=18, nation=汉)
       反序列化对象----完结

2. 序列化的对象必须实现 java.io.Serializable接口。

   ObjectOutputStream在实现序列化的办法中，限度了序列化对象必须是String、Array、Enum以及实现了Serializable接口的类型。因而自定义的对象要进行序列化必须实现java.io.Serializable接口。

   源代码

   // remaining cases
   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());
       }
   }

3. 在序列化对象时，如果有一些变量的值不想被记录下来，能够通过static（动态变量）或者 transient（瞬态变量）关键词润饰变量。留神：static变量 反序列化的值为 类中被赋予的初始值。

   源代码

   Java序列化中通过ObjectStreamClass保留序列化对象的信息，在通过对象class初始化ObjectStreamClass对象时，通过getDefaultSerialFields办法保留要序列化的字段，此时会查看字段是否被static、transient关键词润饰。

   private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
       Field[] clFields = cl.getDeclaredFields();
       ArrayList<ObjectStreamField> list = new ArrayList<>();
       // Modifier.STATIC | Modifier.TRANSIENT
       int mask = Modifier.STATIC | Modifier.TRANSIENT;
   
       for (int i = 0; i < clFields.length; i++) {
           if ((clFields[i].getModifiers() & mask) == 0) {
               list.add(new ObjectStreamField(clFields[i], false, true));
           }
       }
       int size = list.size();
       return (size == 0) ? NO_FIELDS :
           list.toArray(new ObjectStreamField[size]);
   }

4. 在待序列化的对象中通常要指定serialVersionUID值。否则当你改变对象的任何字段后，改变前就曾经保留的序列化对象将无奈再进行反序列化，在反序列化时将抛出java.io.InvalidClassException异样。

   源代码

   在readObject() 反序列化办法内，通过读取序列化文件的数据获取 sid的值和序列化对象的sid的值进行一致性判断。

   if (model.isEnum != osc.isEnum) {
       throw new InvalidClassException(model.isEnum ?
               "cannot bind enum descriptor to a non-enum class" :
               "cannot bind non-enum descriptor to an enum class");
   }
   
   if (model.serializable == osc.serializable &&
           !cl.isArray() &&
           suid != osc.getSerialVersionUID()) {
       throw new InvalidClassException(osc.name,
               "local class incompatible: " +
                       "stream classdesc serialVersionUID = " + suid +
                       ", local class serialVersionUID = " +
                       osc.getSerialVersionUID());
   }

5. 通过实现java.io.Externalizable接口，而后重写writeExternal()和readExternal()办法，能够自定义序列化以及反序列化的形式。Externalizable接口继承了Serializable接口。在ObjectInputStream 和 ObjectOutputStream进行序列化和反序列化时会判断是否实现此接口，从而决定是否调用重写的writeExternal()和readExternal()办法。

   源代码

   ObjectOutputStream.writeOrdinaryObject办法中判断是否实现Externalizable接口。并在writeExternalData办法中调用重写的writeExternal办法。

   private void writeOrdinaryObject(Object obj,
                                    ObjectStreamClass desc,
                                    boolean unshared)
       throws IOException
   {
              ...
       if (desc.isExternalizable() && !desc.isProxy()) {
           writeExternalData((Externalizable) obj);
       } else {
           writeSerialData(obj, desc);
       }
              ...
   }

Java序列化的毛病

1. Java本身的序列化性能，必须和Java对象类型绑定。如果反序列化的我的项目没有对应的Java类型，则在反序列化时就会抛出ClassNotFoundException异样。这大大限度了Java序列化的应用场景。
2. Java序列化的数据流通过byte[]数组传输，生成的字节数组流太大不仅占用内存空间，而且不利于进行网络传输。

针对Java序列化的毛病，我的项目中很少应用Java序列化的性能，在设计对象序列化时通常采纳第三方的序列化框架，罕用的序列化工具备：转JSON类工具、Hessian、Kryo、Xstream、Protobuf等。

具体的序列化工具剖析能够参考一下文章：

https://juejin.im/post/6844903918879637518#heading-5