实现一个简单的数据本地存储

在使用Java开发简单的应用程序时，经常会需要实现数据本地存储的功能，这时使用Oracle、mysql这些专业的数据库就显得杀鸡用牛刀了，所以我实现了一个简单的缓存类，可以提供基础的数据缓存、本地持久化功能。
在设计考虑到了数据加密功能，具体的加密函数需要根据需要自己实现。

public class Cache {
    static {
        load();//在初始化时加载持久化数据
    }

    private static Map<String, Object> storage;
    private static String storagePersistDirPath = "C://persist";
    private static String storagePersistFilePath = "C://persist/storage.ser";

    /**获取完整的缓存数据*/
    public static Map<String, Object> fetchCompleteStorage() {
        return storage;
    }

    /**
     * 以Object类型获取数据
     * @param fieldName 字段名
     * @return 获取到的数据，如果未找到对应字段则返回null
     */
    public static Object fetchObject(String fieldName) {
        return storage.get(fieldName);
    }

    /**
     * 以字符串类型获取数据
     * @param fieldName 字段名
     * @return 获取到的数据，如果未找到对应字段则返回null
     */
    public static String fetchString(String fieldName) {
        Object value = storage.get(fieldName);
        return value != null ? value.toString() : null;
    }

    /**
     * 存放数据
     * @param fieldName 字段名
     * @param data 数据
     */
    public static void put(String fieldName, Object data) {
        storage.put(fieldName, data);
    }

    /**
     * 将数据加密后存储,仅支持字符串类型数据,
     * 以这种方式存储的数据请使用fetchSafetyString函数进行获取；
     * @param fieldName 字段名
     * @param data 需要加密存储的字符串类型数据
     */
    public static void safetyPut(String fieldName, String data) {
        storage.put(fieldName, encrypt(data));
    }


    /**
     * 获取加密存储的字符串数据
     * @param fieldName 字段名
     * @return 解密后的数据，如果未找到对应字段的数据，则返回null
     */
    public static String fetchSafetyString(String fieldName) {
        String cipherText = (String) storage.get(fieldName);
        return cipherText != null ? decrypt(cipherText) : null;
    }

    /**加密函数*/
    private static String encrypt(String data) {
        return null;
    }

    /**解密函数*/
    private static String decrypt(String cipherText) {
        return null;
    }

    /**
     * 将storage中的缓存数据持久化
     */
    public static void persist() throws IOException {
        //检查目录是否存在，不存在则创建
        File storagePersistDir = new File(storagePersistDirPath);
        if (!storagePersistDir.exists()) {
            storagePersistDir.mkdirs();
        }
        //检查持久化文件是否存在，不存在则创建
        File storagePersistFile = new File(storagePersistFilePath);
        if (!storagePersistFile.exists()) {
            storagePersistFile.createNewFile();
        }
        //序列化的方式持久化
        FileOutputStream fileOutputStream = new FileOutputStream(storagePersistFile);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        objectOutputStream.writeObject(storage);
        objectOutputStream.close();
        fileOutputStream.close();
    }

    /**
     * 从持久化文件中加载数据
     */
    private static void load() {
        File storagePersistFile = new File(storagePersistFilePath);
        try {
            if (storagePersistFile.exists()) {
                //持久化文件存在则从文件恢复数据
                FileInputStream fileInputStream = new FileInputStream(storagePersistFile);
                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                storage = (Map<String, Object>) objectInputStream.readObject();
            } else {
                //持久化文件不存在则创建一个空的HashMap
                storage = new HashMap<>();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}