Java序列化总结(最全)

概念

• 实现 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 void writeObject(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 void readObject(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 interface Serializable {} // 可以知道这个只是 一个标记接口, 并且JVM 并没有实现相应的反射代码,真的据说是起到标记作用! 那么这个标记 是在哪里进行判断的?

标记的具体定义地方:

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

if (obj instanceof String) {
 2                writeString((String) obj, unshared);
 3            } else if (cl.isArray()) {
 4                writeArray(obj, desc, unshared);
 5            } else if (obj instanceof Enum) {
 6                writeEnum((Enum<?>) obj, desc, unshared);
 7            } else if (obj instanceof Serializable) {
 8                writeOrdinaryObject(obj, desc, unshared);
 9            } else {
10                if (extendedDebugInfo) {
11                    throw new NotSerializableException(
12                        cl.getName() + "/n" + debugInfoStack.toString());
13                } else {
14                    throw new NotSerializableException(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 void readObject(java.io.ObjectInputStream s)
 2        throws java.io.IOException, ClassNotFoundException {
 3        elementData = EMPTY_ELEMENTDATA;
 4        // Read in size, and any hidden stuff
 5        s.defaultReadObject();
 6        // Read in capacity
 7        s.readInt(); // ignored
 8        if (size > 0) {
 9            // be like clone(), allocate array based upon size not capacity
10            ensureCapacityInternal(size);
11            Object[] a = elementData;
12            // Read in all elements in the proper order.
13            for (int i=0; i<size; i++) {
14                a[i] = s.readObject();
15            }
16        }
17    }

private void writeObject(java.io.ObjectOutputStream s)
 2        throws java.io.IOException{
 3        // Write out element count, and any hidden stuff
 4        int expectedModCount = modCount;
 5        s.defaultWriteObject();
 6        // Write out size as capacity for behavioural compatibility with clone()
 7        s.writeInt(size);
 8        // Write out all elements in the proper order.
 9        for (int i=0; i<size; i++) {
10            s.writeObject(elementData[i]);
11        }
12        if (modCount != expectedModCount) {
13            throw new ConcurrentModificationException();
14        }
15    }

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

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

void invokeWriteObject(Object obj, ObjectOutputStream out)
 2        throws IOException, UnsupportedOperationException
 3    {
 4        if (writeObjectMethod != null) {
 5            try {
 6                writeObjectMethod.invoke(obj, new Object[]{ out });
 7            } catch (InvocationTargetException ex) {
 8                Throwable th = ex.getTargetException();
 9                if (th instanceof IOException) {
10                    throw (IOException) th;
11                } else {
12                    throwMiscException(th);
13                }
14            } catch (IllegalAccessException ex) {
15                // should not occur, as access checks have been suppressed
16                throw new InternalError(ex);
17            }
18        } else {
19            throw new UnsupportedOperationException();
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;
                }