天天看点
返回

《JAVA筑基100例》「第35题」JAVA高级技术-序列化与对象克隆

#我在头条搞创作第二期#

❝

❤️作者简介：大家好,我是小虚竹。Java领域优质创作者，CSDN博客专家，华为云享专家，掘金年度人气作者，阿里云专家博主，51CTO专家博主

❤️技术活，该赏

❤️点赞 收藏 ⭐再看，养成习惯

❞

零、前言

今天是学习 「JAVA语言」 打卡的第35天，我的学习策略很简单，题海策略+ 费曼学习法。如果能把这100题都认认真真自己实现一遍，那意味着 「JAVA语言」 已经筑基成功了。后面的进阶学习，可以继续跟着我，一起走向架构师之路。

一、题目描述

题目：对象的克隆是Java一项高级技术，可以根据给定的对象，获得与其完全相同的另一个对象。

如果对象的成员变量包含可变引用类型，则需要使用深克隆技术。 你现在会发现使用clone方法来进行克隆，是很麻烦的事。所以还有另一种克隆的方式：序列化克隆

二、解题思路-序列化克隆

创建一个地址类Address

定义三个成员变量表示：国家，省和市。

使用构造方法对它们进行赋值。

并提供对应的get方法和set方法。

重写toString()方法，来输出对象。

再创建一个员工类Employee

定义三个成员变量表示：员工名字，年龄和地址

使用构造方法对它们进行赋值。

并提供对应的get方法和set方法。

重写toString()方法和。

「通常情况下，克隆对象都需要使用深克隆。」 「把对象写入本地文件的方式完成序列化」

三、代码详解

地址类：

public class Address implements Serializable {
    private static final long serialVersionUID = 4983187287403615604L;
    private String state; // 表示员工所在的国家
    private String province; // 表示员工所在的省
    private String city; // 表示员工所在的市

    public Address(String state, String province, String city) {// 利用构造方法初始化各个域
        this.state = state;
        this.province = province;
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }

    @Override
    public String toString() {// 使用地址属性表示地址对象
        StringBuilder sb = new StringBuilder();
        sb.append("国家：" + state + ", ");
        sb.append("省：" + province + ", ");
        sb.append("市：" + city);
        return sb.toString();
    }

}

员工类：

public class Employee implements Serializable {
    private static final long serialVersionUID = 3049633059823371192L;
    private String name; // 表示员工的姓名
    private int age; // 表示员工的年龄
    private Address address;// 表示员工的地址

    public Employee(String name, int age, Address address) {// 利用构造方法初始化各个域
        this.name = name;
        this.age = age;
        this.address = address;
    }
    
     public Employee() {// 利用构造方法初始化各个域
        super();
    }

    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;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {// 重写toString()方法
        StringBuilder sb = new StringBuilder();
        sb.append("姓名：" + name + ", ");
        sb.append("年龄：" + age + "\n");
        sb.append("地址：" + address);
        return sb.toString();
    }

}

测试类

public class Test {
    public static void main(String[] args) {
        System.out.println("序列化之前：");
        Address address = new Address("中国", "吉林", "长春");// 创建address对象
        Employee employee1 = new Employee("小虚竹", 30, address);// 创建employee1对象
        System.out.println("员工1的信息：");
        System.out.println(employee1);// 输出employee1对象
        System.out.println("序列化之后：");
        ObjectOutputStream out = null;
        ObjectInputStream in = null;
        Employee employee2 = null;
        try {
            out = new ObjectOutputStream(new FileOutputStream("employee.dat"));
            out.writeObject(employee1);// 将对象写入到本地文件中
            in = new ObjectInputStream(new FileInputStream("employee.dat"));
            employee2 = (Employee) in.readObject();// 从本地文件读取对象
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();// 关闭输入流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();// 关闭输出流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        if (employee2 != null) {
            employee2.getAddress().setState("中国"); // 修改员工地址
            employee2.getAddress().setProvince("四川"); // 修改员工地址
            employee2.getAddress().setCity("成都"); // 修改员工地址
            employee2.setName("大虚竹"); // 修改员工名字
            employee2.setAge(24);// 修改员工年龄
            System.out.println("员工1的信息：");
            System.out.println(employee1);// 输出employee1对象
            System.out.println("员工2的信息：");
            System.out.println(employee2);// 输出employee2对象
        }

    }

}
《JAVA筑基100例》「第35题」JAVA高级技术-序列化与对象克隆

解题思路二：把对象写入内存，完成序列化

使用ByteArrayInputStream和ByteArrayOutputStream 两个基于内存的流

注：

  • 调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
  • 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放

代码详解 

public class Test2 {
    public static void main(String[] args) {
        System.out.println("序列化之前：");
        Address address = new Address("中国", "吉林", "长春");// 创建address对象
        Employee employee1 = new Employee("小虚竹", 30, address);// 创建employee1对象
        System.out.println("员工1的信息：");
        System.out.println(employee1);// 输出employee1对象
        System.out.println("序列化之后：");
       
        Employee employee2 = null;
        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bout);
            oos.writeObject(employee1);
            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            employee2 = (Employee) ois.readObject();// 从内存读取对象
        } catch (Exception e) {
            e.printStackTrace();
        } 

        if (employee2 != null) {
            employee2.getAddress().setState("中国"); // 修改员工地址
            employee2.getAddress().setProvince("四川"); // 修改员工地址
            employee2.getAddress().setCity("成都"); // 修改员工地址
            employee2.setName("大虚竹"); // 修改员工名字
            employee2.setAge(24);// 修改员工年龄
            System.out.println("员工1的信息：");
            System.out.println(employee1);// 输出employee1对象
            System.out.println("员工2的信息：");
            System.out.println(employee2);// 输出employee2对象
        }

    }

}
《JAVA筑基100例》「第35题」JAVA高级技术-序列化与对象克隆

解题思路三：引用springframework

springframework有一个工具方法，常用于对象的克隆

❝

BeanUtils.copyProperties(employee1,employee2);

❞

注意：「BeanUtils.copyProperties」 方法本质上只是浅克隆，对于引用类型的参数是无法克隆的，「只是复制引用，不是克隆值」 ，所以要额外处理

代码详解

pom引入

<properties>
        <org.springframework.version>4.3.25.RELEASE</org.springframework.version>   
    </properties>
    
    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
    </dependencies>

测试类

public class Test3 {
    public static void main(String[] args) {
        System.out.println("序列化之前：");
        Address address = new Address("中国", "吉林", "长春");// 创建address对象
        Employee employee1 = new Employee("小虚竹", 30, address);// 创建employee1对象
        System.out.println("员工1的信息：");
        System.out.println(employee1);// 输出employee1对象
        System.out.println("序列化之后：");
       
        Employee employee2 = new Employee();
        BeanUtils.copyProperties(employee1,employee2);
        employee2.setAddress(new Address("中国","四川","成都"));
            employee2.setName("大虚竹"); // 修改员工名字
            //employee2.setAge(24);// 修改员工年龄
            System.out.println("员工1的信息：");
            System.out.println(employee1);// 输出employee1对象
            System.out.println("员工2的信息：");
            System.out.println(employee2);// 输出employee2对象
    }

}
《JAVA筑基100例》「第35题」JAVA高级技术-序列化与对象克隆

如图

解题思路四：引用使用kryo序列化

Kryo 序列化:基于Java的快速高效的对象序列化框架，旨在提供快速、高效和易用的API。

Kryo的优势是序列化后size小且速度快，代码简单,号称 Java 中最快的序列化框架。

创建一个SerializationKryoUtils工具类

提供serializationObject序列化对象方法

提供deserialization反序列化对象方法

支持从对象--》字节--》对象的克隆。

代码详解

pom引入

<!--        使用kryo序列化-->
        <dependency>
            <groupId>com.esotericsoftware</groupId>
            <artifactId>kryo</artifactId>
            <version>4.0.2</version>
        </dependency>
        <dependency>
            <groupId>de.javakaffee</groupId>
            <artifactId>kryo-serializers</artifactId>
            <version>0.45</version>
        </dependency>

SerializationKryoUtils

package com.xiaoxuzhu;

import de.javakaffee.kryoserializers.UnmodifiableCollectionsSerializer;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;

import org.objenesis.strategy.StdInstantiatorStrategy;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;

/**
 * Description: 使用kryo序列化工具包
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修改记录:
 * 修改后版本         修改人  修改日期   修改内容
 * 2022/4/19.1     xiaoxuzhu  2022/4/19      Create
 * </pre>
 * @date 2022/4/19
 */
public class SerializationKryoUtils {


    private static final ThreadLocal<Kryo> kryoThreadLocal = new ThreadLocal<Kryo>() {
        @Override
        protected Kryo initialValue() {
            Kryo kryo = new Kryo();
            UnmodifiableCollectionsSerializer.registerSerializers(kryo);
            kryo.setRegistrationRequired(false);
            kryo.setInstantiatorStrategy(new Kryo.DefaultInstantiatorStrategy(new StdInstantiatorStrategy()));
            return kryo;
        }
    };

    public static Kryo getInstance() {
        return kryoThreadLocal.get();
    }


    /**
     * 序列化对象
     *
     * @param source 对象
     * @param <T>
     * @return
     */
    public static <T extends Serializable> byte[] serializationObject(T source) {
        Kryo kryo = getInstance();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        Output output = new Output(byteArrayOutputStream);
        try {
            kryo.writeClassAndObject(output, source);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            kryoThreadLocal.remove();
        }
        output.flush();
        output.close();
        byte[] bytes = byteArrayOutputStream.toByteArray();
        try {
            byteArrayOutputStream.flush();
            byteArrayOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bytes;

    }

    /**
     * 反序列化对象
     *
     * @param source
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T deserializationObject(byte[] source) {
        Kryo kryo = getInstance();
        try {
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(source);
            Input input = new Input(byteArrayInputStream);
            return (T) kryo.readClassAndObject(input);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            kryoThreadLocal.remove();
        }
        return null;
    }


}

测试类：

package com.xiaoxuzhu;

/**
 * Description: 测试类
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修改记录:
 * 修改后版本         修改人  修改日期   修改内容
 * 2022/4/19.1     xiaoxuzhu  2022/4/19      Create
 * </pre>
 * @date 2022/4/19
 */
public class Test4 {
    public static void main(String[] args) {
        System.out.println("序列化之前：");
        Address address = new Address("中国", "吉林", "长春");// 创建address对象
        Employee employee1 = new Employee("小虚竹", 30, address);// 创建employee1对象
        System.out.println("员工1的信息：");
        System.out.println(employee1);// 输出employee1对象
        System.out.println("序列化之后：");
       
        Employee employee2 =null;
        byte[] bytes =  SerializationKryoUtils.serializationObject(employee1);
        employee2 =  SerializationKryoUtils.deserializationObject(bytes);
        employee2.setAddress(new Address("中国","四川","成都"));
            employee2.setName("大虚竹"); // 修改员工名字
            //employee2.setAge(24);// 修改员工年龄
            System.out.println("员工1的信息：");
            System.out.println(employee1);// 输出employee1对象
            System.out.println("员工2的信息：");
            System.out.println(employee2);// 输出employee2对象
    }

}
《JAVA筑基100例》「第35题」JAVA高级技术-序列化与对象克隆

我是虚竹哥，我们下一题见～

高级技术 对象克隆
上一篇: 新一代数据保险箱助力数据资产管理（下）
下一篇: dedeCMS /data/mysql_error_trace.php DB error rais

继续阅读