【Java】封装带有泛型的序列化文件工具类

分析

可以用接口或者抽象类的方法，我的话会倾向于接口。 但是需要知道的是—— 接口定义了一种规范；抽象类提供了一个模板。

泛型的话其实就是要我们定义带泛型的接口或者抽象类，实现的时候表明类型，针对一个特定的类型。

封装文件操作的类，自然需要单例，这是很自然的，所以需要做一下简单的实现。

实现

我们可以定义这样的一个接口，带泛型：

public interface IFileSerialization {
    
    /**
     * 反序列化
     * @return
     */
    T readObject();
    
    /**
     * 序列化
     * @param object
     */
    void writeObject(T object);

}

实现类举例一则：

import java.io.*;

public class MedicineInfoMapper implements IFileSerialization {

    private MedicineInfoMapper() {}

    private static MedicineInfoMapper mapper;

    /**
     * 获取单例
     * @return 单例
     */
    public static MedicineInfoMapper getInstance() {
        if (mapper == null) {
             mapper = new MedicineInfoMapper();
        }
        return mapper;
    }

    /**
     * 反序列化从文件中读取PatientList的序列化对象
     */
    @Override
    public AllMedicinesMap readObject() {
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(ALL_MEDICINES_FILENAME))) {
            AllMedicinesMap medicinesMap = (AllMedicinesMap)ois.readObject();
            return medicinesMap;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 序列化对象
     */
    @Override
    public void writeObject(AllMedicinesMap object) {
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(ALL_MEDICINES_FILENAME))) {
            oos.writeObject(object);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

这样就完成了简单的单例模式（线程不安全的懒汉式），并将文件操作统一封装，带有泛型。