码迷,mamicode.com
首页 > 编程语言 > 详细

JavaSE-序列化和反序列化

时间:2018-05-26 15:34:59      阅读:38      评论:0      收藏:0      [点我收藏+]

标签:mon   反射   getters   lda   ++   before   expec   href   序列   

什么是序列化,什么时候要进行序列化?

  序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,将数据分解成字节流,以便存储在文件中或在网络上传输。

  我们在对java对象进行IO流操作或者进行网络传输的时候就要进行序列化。

Java对象序列化的方式

  一、实现Serializable接口

package org.burning.sport.javase.serializable.demo1;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {

    private static final long serialVersionUID = -6330597348767194997L;

    private String name;

    private int age;

    private Date birthday;

    private transient String gender;

    setters();getters();toString();
}
package org.burning.sport.javase.serializable.demo1;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class SerializableDemo {
    public static void main(String[] args) {
        User user = new User();
        user.setName("hollis");
        user.setGender("male");
        user.setAge(23);
        user.setBirthday(new Date());
        System.out.println("serializable before:" + user);

        /**
         * 将对象持久化到文件中
         */
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("temp"));
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /**
         * 从文件中读取对象
         */
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("temp"));
            User readUser = (User)ois.readObject();
            System.out.println("serializable after:" + readUser);
        } catch (Exception e) {
            e.printStackTrace();
        }  finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// output
//serializable before:User{name=‘hollis‘, age=23, birthday=Sat May 26 11:35:06 CST 2018, gender=‘male‘}
//serializable after:User{name=‘hollis‘, age=23, birthday=Sat May 26 11:35:06 CST 2018, gender=‘null‘}

小结:

  1、在Java中,只要一个类实现了 java.io.Serializable 接口,那么它就可以被序列化。

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

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

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

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

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

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

ArrayList序列化有什么不一样?

  我们先看看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;
}

  我们看到elementData是transient的,所以我们认为elementData是不会被序列化保留下来的,下面做个Demo:

package org.burning.sport.javase.serializable.demo1;

import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class ArrayListSerializableDemo {
    public static void main(String[] args) throws Exception{
        List<String> stringList = new ArrayList<String>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("hollis");
        stringList.add("chuang");
        System.out.println("init StringList" + stringList);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
        objectOutputStream.writeObject(stringList);

        IOUtils.closeQuietly(objectOutputStream);
        File file = new File("stringlist");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        List<String> newStringList = (List<String>)objectInputStream.readObject();
        IOUtils.closeQuietly(objectInputStream);
        if(file.exists()){
            file.delete();
        }
        System.out.println("new StringList" + newStringList);
    }
}

// output~
//init StringList[hello, world, hollis, chuang]
//new StringList[hello, world, hollis, chuang]

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

  答案就在ArrayList中的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();
        }
    }

小结:

  在序列化过程中,如果被序列化的类中定义了writeObject 和 readObject 方法,虚拟机会试图调用对象类里的 writeObject 和 readObject 方法,进行用户自定义的序列化和反序列化。如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。

  那有个问题,为什么AarrayList要把elementDate给transient呢?

  ArrayList实际上是动态数组,每次在放满以后自动增长设定的长度值,如果数组自动增长长度设为100,而实际只放了一个元素,那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化,ArrayList把元素数组设置为transient。但是,作为一个集合,在序列化过程中还必须保证其中的元素可以被持久化下来,所以,通过重写 writeObject 和 readObject 方法的方式把其中的元素保留下来。

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

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

  所以如果想自定义序列化和反序列化策略就可以模仿ArrayList的做法。  

ObjectOuptStream&ObjectInputStream

  在上个面讲到的ArrayList的例子中,有个问题就是,我们没有看到writeObject和readObject的调用啊,这两个方法是怎么被调用的呢?原因就是ObjectOuptStream&ObjectInputStream

  看一下ObjectOuptStream的调用栈是怎样的?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 方法,那么这两个方法是怎么被调用的?

  答:在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时,会通过反射的方式调用。

  至此,我们已经介绍完了ArrayList的序列化方式。

总结:

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

   2、在变量声明前加上该关键字,可以阻止该变量被序列化到文件中。

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

 

 https://gitee.com/play-happy/base-project

参考:

【1】博客,https://www.cnblogs.com/Qian123/articles/5665671.html

【2】博客,https://blog.csdn.net/tlycherry/article/details/8986720

JavaSE-序列化和反序列化

标签:mon   反射   getters   lda   ++   before   expec   href   序列   

原文地址:https://www.cnblogs.com/happyflyingpig/p/9092417.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!