工廠設計模式——數據的存儲

進入公司剛開始做項目時，android只有自己一個開發人員，自己也是第一次編程做項目，在登陸模塊用戶登陸成功後，需要將用戶的賬號和密碼緩存在本地，會根據本地的緩存自動登陸；當時腦袋一過想到的就是用SharedPreferences來緩存數據；

//緩存用戶名和密碼
SharedPreferences userSharedPreferences = getSharedPreferences("user", Context.MODE_PRIVATE);
SharedPreferences.Editor edit = userSharedPreferences.edit();
edit.putString("username","劉德華");
edit.putString("password","123456");
edit.commit();

獲取緩存數據通過下面的方式獲取：

//獲取緩存的用戶名和密碼
SharedPreferences user = getSharedPreferences("user", Context.MODE_PRIVATE);
String username = user.getString("username", "");
String password = user.getString("password", "");

這樣子功能是實現了，項目中不只一個地方需要緩存數據，感覺這樣子很繁瑣，需要修改的時候很麻煩，在學習過程中就將這些封裝成一個工具類，使用起來就方便很多了；

public class SharedPreferencesUtil {
    private static volatile SharedPreferencesUtil sharedPreferencesUtil;
    private String CACHE_KEY="CACHE";
    private SharedPreferences sharedPreferences;
    private  SharedPreferences.Editor editor;
    private SharedPreferencesUtil() {

    }

    public static SharedPreferencesUtil getInstence() {
        if (sharedPreferencesUtil == null) {
            synchronized (SharedPreferencesUtil.class) {
                if (sharedPreferencesUtil == null) {
                    sharedPreferencesUtil = new SharedPreferencesUtil();
                }
            }
        }
        return sharedPreferencesUtil;
    }
    public SharedPreferencesUtil init(Context context){
        sharedPreferences = context.getApplicationContext().getSharedPreferences(CACHE_KEY, Context.MODE_PRIVATE);
        editor = sharedPreferences.edit();
        return this;
    }

    /**
     * 緩存int類型
     * @param key
     * @param value
     * @return
     */
    public SharedPreferencesUtil putInt(String key,int value){
        editor.putInt(key,value);
        return this;
    }
    /**
     * 緩存String類型
     * @param key
     * @param value
     * @return
     */
    public SharedPreferencesUtil putString(String key,String value){
        editor.putString(key,value);
        return this;
    }
    /**
     * 緩存Boolean類型
     * @param key
     * @param value
     * @return
     */
    public SharedPreferencesUtil putBoolean(String key,boolean value){
        editor.putBoolean(key,value);
        return this;
    }
    /**
     * 緩存long類型
     * @param key
     * @param value
     * @return
     */
    public SharedPreferencesUtil putLong(String key,long value){
        editor.putLong(key,value);
        return this;
    }
    /**
     * 緩存float類型
     * @param key
     * @param value
     * @return
     */
    public SharedPreferencesUtil putFloat(String key,float value){
        editor.putFloat(key,value);
        return this;
    }

    /**
     * 獲取String類型
     * @param key
     * @return
     */
    public String getString(String key){
        String string = sharedPreferences.getString(key, "");
        return string;
    }
    /**
     * 獲取int類型
     * @param key
     * @return
     */
    public Integer getInt(String key){
        int value = sharedPreferences.getInt(key, -1);
        return value;
    }
    /**
     * 獲取float類型
     * @param key
     * @return
     */
    public float getFloat(String key){
        float value = sharedPreferences.getFloat(key, 0f);
        return value;
    }
    /**
     * 獲取Boolean類型
     * @param key
     * @return
     */
    public boolean getBoolean(String key){
        boolean value = sharedPreferences.getBoolean(key, false);
        return value;
    }
    /**
     * 獲取long類型
     * @param key
     * @return
     */
    public long getLong(String key){
        long value = sharedPreferences.getLong(key, 0);
        return value;
    }

    /**
     * 提交
     */
    public void commit(){
        editor.commit();
    }
}

用了下單例模式，保證了只有一個SharedPreferencesUtil對象實例，使用時調用對應的方法去緩存或者獲取緩存數據；

//緩存用戶名和密碼
SharedPreferencesUtil
       .getInstence()
       .init(this)
       .putString("username","張小龍")
       .putString("password","aljlsjdg")
       .commit();
//獲取緩存的用戶名和密碼
String username=SharedPreferencesUtil.getInstence().getString("username");
String password=SharedPreferencesUtil.getInstence().getString("password");

隨着學習和做項目的時間久了，看到有大牛還可以使用工廠模式，感覺蠻好的，後面有跟隨大牛的腳步，又將其進行了更改；

新增一個工廠接口，提供緩存和獲取緩存的方法：

public interface SharedPreferencesCache<T extends SharedPreferencesCache> {
    //緩存方法
    T putString(String key,String value);
    T putInt(String key,int value);
    T putFloat(String key,float value);
    T putBoolean(String key,boolean value);
    T putLong(String key,long value);
    void commit();
    //獲取緩存的方法
    String getString(String key);
    int getInt(String key);
    long getLong(String key);
    boolean getBoolean(String key);
    float getFloat(String key);
}

定義具體的緩存方式，實現SharedPreferencesCache接口：

public class SharedPreferencesCacheImp implements SharedPreferencesCache{
    private SharedPreferencesUtil preferencesUtil;
    public SharedPreferencesCacheImp(Context context){
        preferencesUtil  = SharedPreferencesUtil.getInstence().init(context);
    }
    @Override
    public SharedPreferencesCacheImp putString(String key, String value) {
        preferencesUtil.putString(key,value);
        return this;
    }

    @Override
    public SharedPreferencesCacheImp putInt(String key, int value) {
        preferencesUtil.putInt(key,value);
        return this;
    }

    @Override
    public SharedPreferencesCacheImp putFloat(String key, float value) {
        preferencesUtil.putFloat(key,value);
        return this;
    }

    @Override
    public SharedPreferencesCacheImp putBoolean(String key, boolean value) {
        preferencesUtil.putBoolean(key,value);
        return this;
    }

    @Override
    public SharedPreferencesCacheImp putLong(String key, long value) {
        preferencesUtil.putLong(key,value);
        return this;
    }

    @Override
    public void commit() {
        preferencesUtil.commit();
    }

    @Override
    public String getString(String key) {
        String string = SharedPreferencesUtil.getInstence().getString(key);
        return string;
    }

    @Override
    public int getInt(String key) {
        Integer anInt = SharedPreferencesUtil.getInstence().getInt(key);
        return anInt;
    }

    @Override
    public long getLong(String key) {
        long aLong = SharedPreferencesUtil.getInstence().getLong(key);
        return aLong;
    }

    @Override
    public boolean getBoolean(String key) {
        boolean aBoolean = SharedPreferencesUtil.getInstence().getBoolean(key);
        return aBoolean;
    }

    @Override
    public float getFloat(String key) {
        float aFloat = SharedPreferencesUtil.getInstence().getFloat(key);
        return aFloat;
    }
}

定義一個簡單工程方法類，根據不同的緩存方式，返回對應的實例對象：

public class CacheFactory {
    public enum CacheType{
        MEMORY,PREFERENCES,DISK
    }
    public static SharedPreferencesCache createCache(Context context,CacheType type){
        switch (type){
            case DISK:
                return new DiskCache();
            case PREFERENCES:
                return new SharedPreferencesCacheImp(context);
            default:
                return null;
        }
    }
}

使用時去實例化CacheFactory就可以了：

SharedPreferencesCache cache = CacheFactory.createCache(this, CacheFactory.CacheType.PREFERENCES);
        //緩存用戶名和密碼
        cache.putString("username", "趙六六")
        .putString("password", "ljsjdgkjlg")
        .commit();
//獲取緩存的用戶名和密碼
String username = cache.getString("username");
String password = cache.getString("password");

這樣根據配置的緩存類型使用不同的緩存方式，代碼就靈活多了，這就是簡單工廠方法模式，但是每新增一種新的緩存方式都要去CacheFactory工廠類中新增新的緩存類型和實例化新的緩存實例對象，感覺還是有點美中不足；

在簡單工廠方法的基礎上新增IoFactory接口，提供一個創建具體工廠的方法；具體由SharedPreferencesFactory工廠類去實現；

public interface IoFactory<T extends SharedPreferencesCache> {
    T createFactory();
}

public class SharedPreferencesFactory implements IoFactory<SharedPreferencesCacheImp>{
    private Context context;
    public SharedPreferencesFactory(Context context){
        this.context=context;
    }

    @Override
    public SharedPreferencesCacheImp createFactory() {
        return new SharedPreferencesCacheImp(context);
    }
}

在使用實例化對象時，就不需要想簡單工廠方法那樣需要傳入緩存的類型，如果使用SharedPreferences方式緩存直接實例化SharedPreferencesFactory類：

SharedPreferencesCacheImp cache =new SharedPreferencesFactory(this).createFactory();
        //緩存用戶名和密碼
                cache.putString("username", "趙六六")
                .putString("password", "ljsjdgkjlg")
                .commit();
        //獲取緩存的用戶名和密碼
        String username = cache.getString("username");
        String password = cache.getString("password");

這樣子雖然導致類數量的增加，但是在新增新的緩存方式時，不需要去修改之前的代碼，只需要增加緩存方式對應的工廠類，比較符合開閉原則，這就是工廠方法模式；還有抽象工廠模式，這裏就不去弄了，具體使用什麼實現方式，可以根據項目的需要來實現。