Android开发工具系列：SharedPreference管理工具

Androi开发工具系列：SharedPreference管理工具
Android开发工具系列：弱引用工具
Android开发工具系列：Utils工具

SharedPreferene 在Android开发中非常常见，常用于存储一些比较简单的数据。在这里将会提供自己在项目开发中自己封装的SharedPreference的管理工具 PreferenceManager。

PreferenceManager 管理工具为了能够支持原生SharedPreference本身所支持的数据存储类型，使用了策略模式提供各种存储类型的strategy，再通过简单工厂的方式实现管理。

1 strategy

1.1 PreferenceStrategy

所有的支持存储类型都实现 PreferenceStrategy，各自实现自己的存储逻辑。

public interface PreferenceStrategy {

    void put(SharedPreferences prefs, String key, Object value);

    Object get(SharedPreferences prefs, String key);
}

1.2 BooleanStrategy

public class BooleanStrategy implements PreferenceStrategy {

    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putBoolean(key, (Boolean) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getBoolean(key, false);
    }
}

1.3 FloatStrategy

public class FloatStrategy implements PreferenceStrategy {

    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putFloat(key, (Float) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getFloat(key, 0);
    }
}

1.4 IntStrategy

public class IntStrategy implements PreferenceStrategy {

    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putInt(key, (Integer) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getInt(key, 0);
    }
}

1.5 LongStrategy

public class LongStrategy implements PreferenceStrategy {

    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putLong(key, (Long) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getLong(key, 0);
    }
}

1.6 StringStrategy

public class StringStrategy implements PreferenceStrategy {

    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putString(key, (String) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getString(key, "");
    }
}

1.7 StringSetStrategy

public class StringSetStrategy implements PreferenceStrategy {

    @SuppressWarnings("unchecked")
    @Override
    public void put(SharedPreferences prefs, String key, Object value) {
        prefs.edit().putStringSet(key, (Set<String>) value).apply();
    }

    @Override
    public Object get(SharedPreferences prefs, String key) {
        return prefs.getStringSet(key, null);
    }
}

1.8 StrategyKeyConstant

这里限定了存储类型的存储规则，如果存储类型不符合存储规则，在简单工厂将会抛出异常.

public class StrategyKeyConstant {
    public static final String KEY_PREFIX_BOOLEAN = "_boolean";
    public static final String KEY_PREFIX_FLOAT = "_float";
    public static final String KEY_PREFIX_INT = "_int";
    public static final String KEY_PREFIX_LONG = "_long";
    public static final String KEY_PREFIX_STRING = "_string";
    public static final String KEY_PREFIX_STRING_SET = "_stringSet";
}

1.9 StrategyFactory

通过简单工厂模式管理支持的所有存储类型。

public class StrategyFactory {
    private static final Map<String, PreferenceStrategy> sStrategyMap = new HashMap<>();

    static {
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_BOOLEAN, new BooleanStrategy());
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_FLOAT, new FloatStrategy());
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_INT, new IntStrategy());
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_LONG, new LongStrategy());
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_STRING, new StringStrategy());
        sStrategyMap.put(StrategyKeyConstant.KEY_PREFIX_STRING_SET, new StringSetStrategy());
    }

    public static PreferenceStrategy getStrategy(String strategy) {
        PreferenceStrategy preferenceStrategy = sStrategyMap.get(strategy);
        if (preferenceStrategy == null) {
            throw new IllegalArgumentException("preference strategy not found");
        }
        return preferenceStrategy;
    }
}

2 SharedPreference管理工具

2.1 SupportStrategyType

限定了存储类型的存储规则。

@StringDef(value = {
        StrategyKeyConstant.KEY_PREFIX_BOOLEAN,
        StrategyKeyConstant.KEY_PREFIX_FLOAT,
        StrategyKeyConstant.KEY_PREFIX_INT,
        StrategyKeyConstant.KEY_PREFIX_LONG,
        StrategyKeyConstant.KEY_PREFIX_STRING,
        StrategyKeyConstant.KEY_PREFIX_STRING_SET
})
public @interface SupportStrategyType {
}

2.2 PreferenceHelper

public interface PreferenceHelper {

    void put(String strategy, String key, Object value);

    Object get(String strategy, String key);
}

public class PreferenceHelperImpl implements PreferenceHelper{
    private static volatile PreferenceHelper sInstance;

    private final SharedPreferences mPrefs;

    public static PreferenceHelper newInstance(Context context, String name) {
        if (sInstance == null) {
            synchronized (PreferenceHelperImpl.class) {
                if (sInstance == null) {
                    sInstance = new PreferenceHelperImpl(context, name);
                }
            }
        }
        return sInstance;
    }

    private PreferenceHelperImpl(Context context, String name) {
        mPrefs = context.getSharedPreferences(name, Context.MODE_PRIVATE);
    }

    @Override
    public void put(String strategy, String key, Object value) {
        PreferenceStrategy preferenceStrategy = StrategyFactory.getStrategy(strategy);
        preferenceStrategy.put(mPrefs, key, value);
    }

    @Override
    public Object get(String strategy, String key) {
        PreferenceStrategy preferenceStrategy = StrategyFactory.getStrategy(strategy);
        return preferenceStrategy.get(mPrefs, key);
    }
}

2.3 PreferenceManager

public class PreferenceManager {
    private static final String PREFERENCE_NAME = "prefs";
    private PreferenceHelper mPreferenceHelper;

    private static class PreferenceManagerHolder {
        private static final PreferenceManager INSTANCE = new PreferenceManager();
    }

    private PreferenceManager() {
        mPreferenceHelper = PreferenceHelperImpl.newInstance(KonkaApplication.getContext(), PREFERENCE_NAME);
    }

    public static PreferenceManager getInstance() {
        return PreferenceManagerHolder.INSTANCE;
    }

    public void putBoolean(String key, boolean value) {
        put(StrategyKeyConstant.KEY_PREFIX_BOOLEAN, key, value);
    }

    public void putFloat(String key, float value) {
        put(StrategyKeyConstant.KEY_PREFIX_FLOAT, key, value);
    }

    public void putInt(String key, int value) {
        put(StrategyKeyConstant.KEY_PREFIX_INT, key, value);
    }

    public void putLong(String key, long value) {
        put(StrategyKeyConstant.KEY_PREFIX_LONG, key, value);
    }

    public void putString(String key, String value) {
        put(StrategyKeyConstant.KEY_PREFIX_STRING, key, value);
    }

    public void putStringSet(String key, Set<String> value) {
        put(StrategyKeyConstant.KEY_PREFIX_STRING_SET, key, value);
    }

    public boolean getBoolean(String key) {
        return (boolean) get(StrategyKeyConstant.KEY_PREFIX_BOOLEAN, key);
    }

    public float getFloat(String key) {
        return (float) get(StrategyKeyConstant.KEY_PREFIX_FLOAT, key);
    }

    public int getInt(String key) {
        return (int) get(StrategyKeyConstant.KEY_PREFIX_INT, key);
    }

    public long getLong(String key) {
        return (long) get(StrategyKeyConstant.KEY_PREFIX_LONG, key);
    }

    public String getString(String key) {
        return (String) get(StrategyKeyConstant.KEY_PREFIX_STRING, key);
    }

    @SuppressWarnings("unchecked")
    public Set<String> getStringSet(String key) {
        return (Set<String>) get(StrategyKeyConstant.KEY_PREFIX_STRING_SET, key);
    }

    private void put(@SupportStrategyType String strategy, String key, Object value) {
        mPreferenceHelper.put(strategy, key, value);
    }

    private Object get(@SupportStrategyType String strategy, String key) {
        return mPreferenceHelper.get(strategy, key);
    }
}