Android之基于Realm、OkHttp3封装的公共数据管理系统DMS

任何项目中都应该有公共数据的维护系统，然而公共数据的维护也是一项耗时耗力的工作。
以用户信息为例：
* 方案一：采用静态类
    用户信息包含用户的基本属性，状态等，许多项目中会简单使用静态类来保存用户信息。
    采用静态类保存用户信息可能在手机内存不够的情况下被虚拟机释放（请参考jvm垃圾回收机制）。
    一旦用户静态类被释放，项目中调用时会面临着这空指针而导致app崩溃的风险。
* 方案二：采用数据库+单例
    将用户信息保存到数据库，采用单例实例化数据库中的用户信息，这样方式的确避免了被释放的危险，但没有处理用户信息联动效应。
    若用户信息在改变时，其他使用的地方就没有办法获取最新信息并刷新UI了。
* 结合以上需求以及问题，编写一个简洁的数据管理系统，提供公共数据单例，集合数据改变回调通知业务。
基于Realm、OkHttp3封装的公共数据管理系统：DMS
Demo已上传至github
github：https://github.com/MrZhousf/DMS

相关代码
/**
 * DMS基类
 * @author: zhousf
 */
public abstract class BaseDMS<T extends RealmObject> {

    protected abstract List<T> doHttp(Object[] params);

    protected abstract Class initModelClass();

    final List<DMSChangeListener<T>> changeListeners = new CopyOnWriteArrayList<>();

    static ExecutorService executorService;

    T model;

    List<T> modelList;

    String failedResult;

    /**
     * 发送网络获取数据命令
     * @param listener 监听器
     * @param params 参数
     */
    public void push(final DMSListener<T> listener, final Object... params){
        //初始化线程池
        initExecutorService();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                //初始化回调信息
                Result<T> result = new Result<T>();
                result.setSuccessful(false);
                failedResult = "获取网络数据失败";
                try {
                    //从网络获取数据
                    List<T> list = doHttp(params);
                    if(null != list && list.size() > 0){
                        //保存数据库
                        if(insertBeforeDeleteAll(list)){
                            T model = list.get(0);
                            result.setModel(model);
                            result.setModelList(list);
                            result.setSuccessful(true);
                            result.setRetDetail("操作成功");
                            //数据改变回调
                            changeModelCallback(result);
                        }
                    }else{
                        result.setRetDetail(failedResult);
                    }
                } catch (Exception e){
                    result.setRetDetail(failedResult+":"+e.getMessage());
                }
                //操作结果回调
                if(null != listener){
                    Message resMsg = new MainMessage<T>(
                            DMSMainHandler.CALLBACK_RESPONSE,
                            result,
                            listener)
                            .build();
                    DMSMainHandler.getInstance().sendMessage(resMsg);
                }
                init();
            }
        });
    }

    /**
     * 添加DMS模型改变监听
     */
    public void addChangeListener(DMSChangeListener<T> listener){
        if (null == listener) {
            throw new IllegalArgumentException("Listener should not be null");
        }
        if (!changeListeners.contains(listener)) {
            changeListeners.add(listener);
        }
    }

    /**
     * 移除DMS模型改变监听
     */
    public void removeChangeListener(DMSChangeListener listener){
        if (listener == null) {
            throw new IllegalArgumentException("Listener should not be null");
        }
        if(changeListeners.contains(listener)){
            changeListeners.remove(listener);
        }
    }

    protected List<T> modelToList(T model){
        List<T> list = new ArrayList<>();
        if(null != model)
            list.add(model);
        return list;
    }

    protected void setFailedResult(String failedResult) {
        this.failedResult = failedResult;
    }

    void initExecutorService(){
        if(null == executorService){
            executorService = Executors.newCachedThreadPool();
        }
    }

    /**
     * 模型改变时回调
     */
    void changeModelCallback(Result<T> result){
        try {
            for(DMSChangeListener<T> listener : changeListeners){
                Message changeMsg = new MainMessage<T>(
                        DMSMainHandler.CALLBACK_CHANGE,
                        result,
                        listener)
                        .build();
                DMSMainHandler.getInstance().sendMessage(changeMsg);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    boolean insertBeforeDeleteAll(List<T> model){
        return RealmUtil.getInstance().insertBeforeDeleteAll(model);
    }

    List<T> getDataFromDB(Class clazz){
        return RealmUtil.getInstance().findAll(clazz);
    }

    /**
     * 初始化数据模型
     */
    protected void init(){
        Class clazz = initModelClass();
        if(null == clazz)
            throw new IllegalArgumentException("please override the abstract method initModelClass and return an value of available!");
        List<T> list = getDataFromDB(clazz);
        modelList = new ArrayList<>();
        if(null != list && list.size() > 0){
            modelList = list;
            model = modelList.get(0);
        }else{//自动实例化防止获取数据时空指针
            try {
                model = (T) clazz.newInstance();
                initStringFields(model);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    /**
     * 初始化String成员变量
     */
    void initStringFields(T model){
        Field[] fields = model.getClass().getDeclaredFields();
        if(null != fields){
            try {
                for(int i=0;i<fields.length;i++){
                    if(fields[i].getType() == String.class){
                        fields[i].setAccessible(true);
                        fields[i].set(model,"");
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public T getModel() {
        return model;
    }

    public List<T> getModelList() {
        return modelList;
    }



}