SharedPreferences管理

管理SharedPreferences 存储，把每个Class类当成一个文件进行存储，用到了Gson 解析，所以Gradle 先导入gson

保存

DataEntry dataEntry = new DataEntry();
boolean save = SharedPreferencesManager.create(DataEntry.class).save(dataEntry);

获取：

DataEntry obtain = SharedPreferencesManager.obtain(DataEntry.class);

实现：

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.SharedPreferences;
import androidx.annotation.NonNull;
import com.google.gson.Gson;


import java.io.File;
import java.util.HashMap;
import java.util.Map;


import static android.content.Context.MODE_PRIVATE;

/**
 * SharedPreferences 管理类
 * 使用方式：
 * <p>
 *  保存：
 *      DataEntry dataEntry = new DataEntry();
 *      boolean save = SharedPreferencesManager.create(DataEntry.class).save(dataEntry);
 *
 *  获取：
 *   DataEntry obtain = SharedPreferencesManager.obtain(DataEntry.class);
 * <p/>
 *
 * 把一个 Class 类型当做一个文件存储；
 * 其实就是一个xml 文件中 key为 对应类的名称，value 为经Gson 转换后的json 字符串，
 * 然后获取的时候，根据类名找到对应的文件，拿出文件的内容在通过Gson 解析成对应类型
 *
 */
public class SharedPreferencesManager<T> {

    private static final String TAG = "SharedPreferencesManager_Log";
    private static Context sContext = null;

    private static Gson gson = new Gson();

    /**
     * 每个文件对应一个 SharedPreferences
     */
    private SharedPreferences sharedPreferences;

    private static Map<String, SharedPreferencesManager> classCache = new HashMap<>();

    public static void init(Context context) {
        sContext = context.getApplicationContext();
    }

    private SharedPreferencesManager(String clzssName) {
        sharedPreferences = sContext.getSharedPreferences(clzssName, MODE_PRIVATE);
    }

    /**
     * 创建当前保存类的 一个 SharedPreferencesGenerater 对象
     */
    public static <T> SharedPreferencesManager<T> create(Class<T> entityClass) {
        if (sContext == null) {
            throw new RuntimeException("SharedPreferencesGenerater uninitialized , context is null");
        }
        String name = entityClass.getName();
        //查找缓存中有没有对应文件的管理对象
        SharedPreferencesManager spg = classCache.get(name);
        if (spg == null) {
            spg = new SharedPreferencesManager(name);
            classCache.put(name, spg);
        }
        return spg;
    }

    /**
     * 保存，每次调用会覆盖以前的值 ，就算值为null 一样会覆盖
     */
    public boolean save(@NonNull T t) {
        if (sContext == null) {
            throw new RuntimeException("SharedPreferencesGenerater uninitialized , context is null");
        }
        Class<?> EntryClass = t.getClass();
        String name = EntryClass.getName();
        SharedPreferences.Editor edit = sharedPreferences.edit();
        String json = gson.toJson(t);
        edit.putString(name, json);
        edit.commit();
        return true;
    }

    private T getInstace(String name, Class<?> entityClass) {
        String jsonString = sharedPreferences.getString(name, null);
        if (TextUtils.isEmpty(jsonString)) {
            return null;
        } else {
            return (T) gson.fromJson(jsonString, entityClass);
        }
    }


    /**
     * 获取对应类的存储数据
     *
     * @param entityClass
     * @param <T>
     * @return
     */
    public static <T> T obtain(Class<T> entityClass) {
        if (sContext == null) {
            throw new RuntimeException("SharedPreferencesGenerater uninitialized , context is null");
        }
        String name = entityClass.getName();
        SharedPreferencesManager generater;
        boolean b = classCache.containsKey(name);
        if (b) {//缓存中有对应类
            generater = classCache.get(name);
            return (T) generater.getInstace(name, entityClass);
        }
        //判断文件是否存储
        if (isExist(name)) {
            generater = new SharedPreferencesManager(name);
            classCache.put(name, generater);
            return (T) generater.getInstace(name, entityClass);
        }
        return null;
    }

    /**
     * 判断对应的存储文件是否存在
     *
     * @param name
     * @return
     */
    private static boolean isExist(String name) {
        File file = new File("/data/data/" + sContext.getPackageName() + "/shared_prefs", name + ".xml");
        if (file.isFile() && file.exists()) {
            return true;
        }
        return false;
    }

    @SuppressLint("LongLogTag")
    public static <T> void clear(Class<T> entityClass) {
        if (sContext == null) {
            throw new RuntimeException("SharedPreferencesGenerater uninitialized , context is null");
        }
        String name = entityClass.getName();
        boolean b = classCache.containsKey(name);
        if (b) {
            SharedPreferencesManager generater = classCache.get(name);
            generater.sharedPreferences.edit().clear().commit();
            classCache.remove(name);
        } else if (isExist(name)) {
            sContext.getSharedPreferences(name, MODE_PRIVATE).edit().clear().commit();
            File file = new File("/data/data/" + sContext.getPackageName() + "/shared_prefs", name + ".xml");
            file.delete();
        } else {
            Log.d(TAG, "不需要清理");
        }
    }

}