工厂模式实现--数据缓存

在开发中，需要有一个数据缓存的功能，比如一个表单需要填写用户名、身份证信息、年龄等

阶段一：

直接用sp进行缓存

问题：毫无设计可言，代码写到一堆，无任何扩展

注意：SharedPreferences的原理，也是操作文件，使用xml格式保存，注意commit提交

阶段二：

写到一个工具类里 PreferencesUtils，然后在Application中初始化

 PreferencesUtils.getInstance().init(this);

• 单例的方式去PreferencesUtils对象
• 使用链式调用去设置具体数据

public class PreferencesUtils {
    private volatile static PreferencesUtils mInstance;
    private SharedPreferences mPreferences;
    private SharedPreferences.Editor mEditor;

    private PreferencesUtils(){

    }

    public void init(Context context){
        mPreferences = context.getApplicationContext().getSharedPreferences("cache",Context.MODE_PRIVATE);
        mEditor = mPreferences.edit();
    }

    public static PreferencesUtils getInstance(){
        if(mInstance == null){
            synchronized (PreferencesUtils.class){
                if(mInstance == null){
                    mInstance = new PreferencesUtils();
                }
            }
        }
        return mInstance;
    }

    public PreferencesUtils saveString(String key,String value){
        mEditor.putString(key,value);
        return this;
    }

    public void commit(){
        mEditor.commit();
    }

    public String getString(String key){
        return mPreferences.getString(key,"");
    }
}

问题：无法做到清理部分缓存，无法实现内存缓存与磁盘缓存或者数据库缓存相结合的方式

阶段三：

使用简单工厂模式

1.定义数据存储的规范 IOHandler

public interface IOHandler {
    void save(String key,String value);

    String getString(String key);
}

2.定义具体的缓存类，如：内存缓存、SP缓存

// 内存缓存
public class MemoryIOHandler implements IOHandler {
    // 存在运行内存里面 内部原理：LinkedHashMap
    private static LruCache<String, Object> mCache = new LruCache<>(10 * 1024 * 1024); 

    @Override
    public void save(String key, String value) {
        mCache.put(key, value);
    }

    @Override
    public String getString(String key) {
        return (String) mCache.get(key);
    }
}

// SP缓存
public class SpIOHandler implements IOHandler{
    @Override
    public void save(String key, String value) {
        PreferencesUtils.getInstance().saveString(key,value);
    }

    @Override
    public String getString(String key) {
        return PreferencesUtils.getInstance().getString(key);

    }
}

3.定义工厂类

public class IOHandlerFactory {
    public enum IOType{
        MEMORY,PREFERENCES
    }
    public static IOHandler createIOHandler(IOType ioType){
        switch (ioType){
            case MEMORY:
                return new MemoryIOHandler();
            case PREFERENCES:
                return new SpIOHandler();
            default:
                return null;
        }
    }
}

问题：如果需要新增一个新的缓存方式，就要添加类型，修改工厂类

阶段四：

使用工厂方法模式，每一个工厂都对应一个产品，使用具体产品由外部调用工厂

一个IOFactory 对应 一个IOHandler

1.IOHandler不变

2.创建一个工厂接口

public interface IOFactory {
     IOHandler createIOHandler();
}

3.创建具体工厂

只生产一个产品,如果需要新增类型，只需要创建一个产品并添加该产品的方法

public class MemoryIOFactory implements IOFactory{
    @Override
    public IOHandler createIOHandler() {
        return new MemoryIOHandler();
    }
}

public class SpIOFactory implements IOFactory{
    @Override
    public IOHandler createIOHandler() {
        return new PreferencesIOHandler();
    }
}

4.外部调用

        IOFactory ioFactory = new MemoryIOFactory();
        IOHandler ioHandler = ioFactory.createIOHandler();

问题：随着功能的扩展，factory类不断增加，而且基本逻辑一样，代码冗余

阶段五：

抽象工厂模式

1.IOHandler不变

2.定义IOFactory，用一个泛型类

public interface IOFactory {
    IOHandler createIOHandler(Class<? extends IOHandler> ioHandlerClass);
}

3.使用单例创建抽象工厂，IOHandlerFactory

public class IOHandlerFactory implements IOFactory {
    private static volatile  IOHandlerFactory mInstance;
    private IOHandler mMemoryIOHandler,mSpIOHandler;

    private IOHandlerFactory(){

    }

    public static IOHandlerFactory getInstance(){
        if(mInstance == null){
            synchronized (IOHandlerFactory.class){
                if(mInstance == null){
                    mInstance = new IOHandlerFactory();
                }
            }
        }
        return mInstance;
    }

    public IOHandler createIOHandler(Class<? extends IOHandler> ioHandlerClass){
        try {
            return ioHandlerClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new PreferencesIOHandler();
    }

    public IOHandler getMemoryIOHandler(){
        if(mMemoryIOHandler == null){
            mMemoryIOHandler = createIOHandler(MemoryIOHandler.class);
        }
        return mMemoryIOHandler;
    }

    public IOHandler getDiskIOHandler(){
        return createIOHandler(DiskIOHandler.class);
    }

    public IOHandler getSpIOHandler(){
        if(mPreferencesIOHandler == null){
            mSpIOHandler = createIOHandler(SpIOHandler.class);
        }
        return mPreferencesIOHandler;
    }

    public IOHandler getDefaultIOHandler(){
        return getMemoryIOHandler();
    }
}

4.外部调用

IOHandler ioHandler =  IOHandlerFactory.getInstance().getDefaultIOHandler();

使用场景:

有共性，后期可能有多样性，需要隐藏复杂的创建细节，把对象的实例化和创建封装起来

比如：

        数据库的使用，图片加载库，网络加载库等，后期如果有新的框架，想要替换，可以使用工厂模式创建，用最小的改动替换原有的功能