Java——序列化的方式

素颜马尾好姑娘i 2022-05-10 00:33 166阅读 0赞

public interface ISerializer {
        <T> byte[] serializer(T obj);
    
        <T> T deSerializer(byte[] data, Class<T> clazz) throws ClassNotFoundException;
    }

public class User implements Serializable{
        private static final long serialVersionUID = -4688180956673504015L;
    
        public static int num=5;
        
        private String name;
        private int age;
        private String sex;
        //不可以被序列化，如果想序列化要手动将其写到流中
        private transient String hobby;
    
         /**
         * 手动将不能序列化的hobby写到流中
         * @param objectOutputStream
         * @throws IOException
         */
        private void writeObject(ObjectOutputStream objectOutputStream)throws IOException{
            objectOutputStream.defaultWriteObject();
            objectOutputStream.writeObject(hobby);
        }
    
        private void readObject(ObjectInputStream objectInputStream)throws IOException,ClassNotFoundException{
            objectInputStream.defaultReadObject();
            hobby=(String)objectInputStream.readObject();
        }
    
        public String getSex() {return sex;}
    
        public void setSex(String sex) {this.sex = sex;}
    
        public String getHobby() {
            return hobby;
        }
    
        public void setHobby(String hobby) {
            this.hobby = hobby;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", hobby='" + hobby + '\'' +
                    '}';
        }
    }

# 一、JDK序列化 #

Java提供一种API：把对象转化成流，把对象的流赋值给一个对象，同过流对象写出去

public class JavaSerializer implements ISerializer {
        /**
         * 序列化：
         * Java提供一种API，把对象转化成流，把对象的流赋值给一个对象，同过流对象写出去
         * @param obj
         * @param <T>
         * @return
         */
        @Override
        public <T> byte[] serializer(T obj) {
            ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream=null;
            try {
                objectOutputStream=new ObjectOutputStream(byteArrayOutputStream);
                objectOutputStream.writeObject(obj);
                return byteArrayOutputStream.toByteArray();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(objectOutputStream!=null){
                    try {
                        objectOutputStream.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
    
                }
                try {
                    byteArrayOutputStream.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        /**
         * 反序列化：
         * @param data
         * @param clazz
         * @param <T>
         * @return
         * @throws ClassNotFoundException
         */
        @Override
        public <T> T deSerializer(byte[] data, Class<T> clazz) throws ClassNotFoundException {
            ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(data);
            ObjectInputStream objectInputStream=null;
            try {
                objectInputStream=new ObjectInputStream(byteArrayInputStream);
              return   (T)objectInputStream.readObject();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(objectInputStream!=null){
                    try {
                        objectInputStream.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
                try {
                    byteArrayInputStream.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            return null;
        }
    }

public static void main(String[] args) throws ClassNotFoundException {
            //Java序列化
            ISerializer iSerializer=new JavaSerializer();
            User user=new User();
            user.setAge(20);
            user.setName("whm");
            user.setHobby("爱好");
            User.num=10;
            byte[] bytes=iSerializer.serializer(user);
            //Java反序列化
            User user1=iSerializer.deSerializer(bytes,User.class);
            System.out.println(user1+"==============="+User.num);
        }

![image.png][]

## 基于文件的序列化 ##

利用基于文件的序列化来演示serialVersionUID的作用，序列化和反序列化的serialVersionUID不一样时会抛**InvalidClassException**异常,这样是为了保证数据的安全性，不写serialVersionUID时默认情况下会根据当前class对象生成一个64位的hash值

public class FileSerializer implements ISerializer{
        @Override
        public <T> byte[] serializer(T obj) {
            ObjectOutputStream objectOutputStream=null;
            try {
                objectOutputStream=new ObjectOutputStream(new FileOutputStream(new File("user")));
                objectOutputStream.writeObject(obj);
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(objectOutputStream!=null){
                    try {
                        objectOutputStream.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }
    
        @Override
        public <T> T deSerializer(byte[] data, Class<T> clazz) throws ClassNotFoundException {
            ObjectInputStream objectInputStream=null;
            try {
                objectInputStream=new ObjectInputStream(new FileInputStream(new File("user")));
                return   (T)objectInputStream.readObject();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(objectInputStream!=null){
                    try {
                        objectInputStream.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
    
                }
            }
            return null;
        }
    }

public static void main(String[] args) throws ClassNotFoundException {
            //先序列化
            ISerializer iSerializer=new FileSerializer();
            User user=new User();
            user.setAge(20);
            user.setName("whm");
            user.setHobby("爱好");
            User.num=10;
            byte[] bytes=iSerializer.serializer(user);
    
            //反序列化
            User user1=iSerializer.deSerializer(bytes,User.class);
            System.out.println(user1+"==============="+User.num);
        }

![image.png][image.png 1]

## idea设置生成serialVersionUID ##

![image.png][image.png 2]

## 使用序列化实现克隆 ##

**浅克隆：**  
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象  
**深克隆：**  
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍

public class Person implements Cloneable,Serializable{ 
        private String name;
        private Email email;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Email getEmail() { 
            return email;
        }
    
        public void setEmail(Email email) { 
            this.email = email;
        }
    
        public Person(String name) { 
            this.name = name;
        }
    
        /** * 浅复制 * @return * @throws CloneNotSupportedException */
        @Override
        protected Person clone() throws CloneNotSupportedException { 
            return (Person)super.clone();
        }
    
        /** * 深复制 * @return * @throws IOException * @throws ClassNotFoundException */
        public Person deepClone()throws IOException,ClassNotFoundException{ 
            ByteArrayOutputStream bos=new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(bos);
            objectOutputStream.writeObject(this);
    
            ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream objectInputStream=new ObjectInputStream(bis);
            return (Person)objectInputStream.readObject();
        }
    }

public class Email implements Serializable{ 
        private String content;
    
        public String getContent() { 
            return content;
        }
    
        public void setContent(String content) { 
            this.content = content;
        }
    }

/** * 克隆 */
    public class CloneRun { 
    
        public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException { 
            lightClone();
            deepClone();
        }
    
        /** * 浅复制 * @throws CloneNotSupportedException */
        public static void lightClone() throws CloneNotSupportedException { 
            Email email=new Email();
            email.setContent("今天晚上9:00有大雨");
            Person p1=new Person("whm");
            p1.setEmail(email);
    
            Person p2=p1.clone();
            p2.setName("tcr");
            p2.getEmail().setContent("今天晚上9:30有大雨");
    
            System.out.println("浅复制：===="+p1.getName()+"-->"+p1.getEmail().getContent());
            System.out.println("浅复制：===="+p2.getName()+"-->"+p2.getEmail().getContent());
        }
    
    
        /** * 深复制 * @throws CloneNotSupportedException * @throws IOException * @throws ClassNotFoundException */
        public static void deepClone() throws CloneNotSupportedException, IOException, ClassNotFoundException { 
            Email email=new Email();
            email.setContent("今天晚上9:00有大雨");
            Person p1=new Person("whm");
            p1.setEmail(email);
    
            Person p2=p1.deepClone();
            p2.setName("tcr");
            p2.getEmail().setContent("今天晚上9:30有大雨");
    
            System.out.println("深复制：===="+p1.getName()+"-->"+p1.getEmail().getContent());
            System.out.println("深复制：===="+p2.getName()+"-->"+p2.getEmail().getContent());
        }
    }

![image.png][image.png 3]

#  #

# 二、xml序列化 #

优点：可读性高  
缺点：序列化后字节码大，性能不高

<dependency>
          <groupId>com.thoughtworks.xstream</groupId>
          <artifactId>xstream</artifactId>
          <version>1.4.10</version>
        </dependency>

public class XmlSerialzer implements ISerializer{ 
        XStream xStream=new XStream(new DomDriver());
    
        @Override
        public <T> byte[] serializer(T obj) { 
            XStream.setupDefaultSecurity(xStream);
            xStream.allowTypes(new Class[]{ User.class});
            return xStream.toXML(obj).getBytes();
        }
    
        @Override
        public <T> T deSerializer(byte[] data, Class<T> clazz) throws ClassNotFoundException { 
            return (T)xStream.fromXML(new String(data));
        }
    }

public static void main(String[] args) throws ClassNotFoundException { 
            ISerializer iSerializer=new XmlSerialzer();
            User user=new User();
            user.setAge(20);
            user.setName("whm");
            user.setHobby("爱好");
            byte[] bytes=iSerializer.serializer(user);
    
            System.out.println(new String(bytes));
            User user1=iSerializer.deSerializer(bytes,User.class);
            System.out.println(user1);
        }

![image.png][image.png 4]

#  #

# 三、FastJson #

<dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.29</version>
        </dependency>

public class FastjsonSerializer implements ISerializer { 
        @Override
        public <T> byte[] serializer(T obj) { 
            return JSON.toJSONString(obj).getBytes();
        }
    
        @Override
        public <T> T deSerializer(byte[] data, Class<T> clazz) throws ClassNotFoundException { 
            return JSON.parseObject(new String(data),clazz);
        }
    }

public static void main(String[] args) throws ClassNotFoundException { 
            ISerializer iSerializer=new FastjsonSerializer();
            User user=new User();
            user.setAge(20);
            user.setName("whm");
            user.setHobby("爱好");
            byte[] bytes=iSerializer.serializer(user);
    
            System.out.println(new String(bytes));
            User user1=iSerializer.deSerializer(bytes,User.class);
            System.out.println(user1);
        }

![image.png][image.png 5]

#  #

# 四、protobuf序列化 #

[image.png]: /images/20220510/a5b421027c914b15ab19af43d7751fe0.png
[image.png 1]: /images/20220510/552a14aa33b14db4acdf9627ece71348.png
[image.png 2]: /images/20220510/8584d6a20e114076bb1df352349dfd2e.png
[image.png 3]: /images/20220510/766cd1dec5f34136bb1909d7557074da.png
[image.png 4]: /images/20220510/355ed17c70684bebb2f0817bc0b0b02c.png
[image.png 5]: /images/20220510/3b044485458f4c0d967f255845549078.png