AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android数据层架构的实现 下篇

2017-05-30 875
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 接上篇:Android数据层架构的实现 上篇4.外观模式实现数据处理引擎框架暴露出来的api我们在使用各种开源框架的时候，大多数时候都不会对框架内部的实现进行细究，所以一个好的框架需要一个简单的入口来对整个框架进行使用，我接下来就是要讲解本框架的入口类。

接上篇:Android数据层架构的实现 上篇

4.外观模式实现数据处理引擎框架暴露出来的api

我们在使用各种开源框架的时候，大多数时候都不会对框架内部的实现进行细究，所以一个好的框架需要一个简单的入口来对整个框架进行使用，我接下来就是要讲解本框架的入口类。

public class DataEngine {
public static String TAG="DataEngine";
public static Context nowContext;
public static ObservableBoolean nowIsShowProgressBar;

public static final List<Interceptor> mInterceptors=new ArrayList<>();
public static final DataEngine sInstance;
static  {
    synchronized (DataEngine.class){
        sInstance=new DataEngine();
    }
}

private final Service memoryCacheService=new MemoryCacheServiceImpl(true);
private final Service mLocalDataService =new LocalDataServiceImpl(true) ;
private final Service networkService=new NetworkServiceImpl(true);
private DataEngine() {
    mInterceptors.add(new MemoryCacheInterceptor(memoryCacheService));
    mInterceptors.add(new NewThreadInterceptor());
    mInterceptors.add(new LocalDataInterceptor(mLocalDataService));
    mInterceptors.add(new NetworkInterceptor(networkService));
}

/**
 * 所有的数据请求，都是从这个方法开始。本方法在{@link LocalDataEngine}和{@link NetworkDataEngine}中使用。
 * @param request 传入的数据请求
 * @return
 */
public Observable<Response> request(final Request request){
    final RealInterceptorChain realInterceptorChain=RealInterceptorChain.obtain(request);
    Object response;
    try {
        response = realInterceptorChain.proceed();
    } catch (Exception e) {
        e.printStackTrace();
        // 此时抛出的异常，那么就是请求失败了，应该是内存缓存服务有问题，由于发生了未知的错误所以不应该继续运行这个请求了。
        FLog.e(TAG,"应该是内存缓存服务有问题",e);
        return Observable.just(Response.getFailedResponse(e))
                .compose(((RxAppCompatActivity)nowContext).<Response>bindToLifecycle())
                .filter(new Func1<Response, Boolean>() {
                    @Override
                    public Boolean call(Response appConfigObjectObjectResponse) {
                        //此时拦截链已经调用完毕，所以可以将RealInterceptorChain回收
                        realInterceptorChain.recycle();
                        Toast.makeText(nowContext, "操作失败，发生未知错误", Toast.LENGTH_SHORT).show();
                        if (nowIsShowProgressBar!=null)nowIsShowProgressBar.set(false);
                        return appConfigObjectObjectResponse.isSuccess();
                    }
                });
    }

    Observable<?> finalResponseObservable;
    if (response instanceof Observable){
        // 这里表示需要从其他线程获取数据数据，一般是本地储存或者网络上的数据
        finalResponseObservable = (Observable<?>) response;
    } else {
        // 这里表示直接从本线程获取数据，一般是内存中的数据
        finalResponseObservable = Observable.just(response);
    }
    return finalResponseObservable
            .compose(((RxAppCompatActivity)nowContext).bindToLifecycle())
            .observeOn(AndroidSchedulers.mainThread())
            .filter(new Func1<Object, Boolean>() {
                @Override
                public Boolean call(Object o) {
                    //此时拦截链已经调用完毕，所以可以将RealInterceptorChain回收
                    realInterceptorChain.recycle();
                    if (o instanceof Response){
                        // 这里表示在 本地储存或者网络请求或者想内存缓存存数据的时候 发生了问题，所以直接返回了请求错误的结果,
                        // 由于发生了未知的错误所以不应该继续运行这个请求了。
                        Toast.makeText(nowContext, "操作失败，发生未知错误", Toast.LENGTH_SHORT).show();
                        if (nowIsShowProgressBar!=null)nowIsShowProgressBar.set(false);
                        return ((Response) o).isSuccess();
                    }
                    return true;
                }
            }).map(new Func1<Object, Response>() {
                @Override
                public Response call(Object o) {
                    FLog.v(TAG, request.getRequestFlag()+"请求成功");
                    FLog.v("                                         ","                                     ");
                    return Response.getCommonResponseOne(o);
                }
            });
}
}

由于本框架适配了Rxjava，所以需要大家对Rxjava比较熟悉

  • 1.前三个静态变量不需要细究，List<Interceptor> mInterceptors是静态final变量，在DataEngine单例创建的时候会把拦截器放入其中。DataEngine sInstance是静态final单例，使用同步的方式在类被加载的时候初始化，由于DataEngine的构造器是private的，所以这个类不能再创建其他对象了。
  • 2.我们由代码可以看出，所有的Service和List<Interceptor> mInterceptors都是被多线程共用的，所以此时就会出现线程安全问题。由于mInterceptors中的拦截器都是不可变类，所以这个不需要担心。但是所有Service的实现就需要对某些操作进行同步了，Service的实现和同步会在后面讲到。
  • 3.再下来我们就可以看见，惟一一个public的方法request(final Request request)：
    • 1.方法首先会去RealInterceptorChain的对象池中获取一个对象，然后调用realInterceptorChain#proceed()获取结果。注意这里的调用都是在主线程进行的，如果大家对前面的MemoryCacheInterceptor还有印象的话，就会知道这里要么返回数据类Object，要么返回一个Observable。数据类Object是从内存中获取的不会在其他线程，而Observable并没有调用subscribe()，所以其只是对一个请求的封装，真正的请求还没被调用。
    • 2.在获取到response之后，要判断这个response到底是数据类Object还是Observable，如果是数据类Object将其再用Observable封装。
    • 3.再进行了上面的操作之后，返回的请求就都变成Observable了，此时我们先将线程切换为主线程，然后用一个filter过滤掉出现异常的请求，最后将成功获取的数据映射成一个Response。注意：此时返回的是Observable，真正的调用会由客户端触发

5.服务的实现

前面我们在讲拦截链的时候，使用的都是Service接口，那么每个拦截器的具体实现是怎么样的呢？接下来我就来讲解一下我们app登录时，每个服务的实现。

@ThreadSafe

public class MemoryCacheServiceImpl implements Service{
private final MemoryCache<CacheKey,Object> mainMemoryCache=new CountingLruMapMemoryCacheImpl<CacheKey, Object>(200,new DefaultCacheListener());
private final MemoryCache minorMemoryCache=null;
private boolean enable;

public MemoryCacheServiceImpl(boolean enable) {
    this.enable = enable;
}

@Override
public Object in(Request request, Object in) throws Exception {
    return mainMemoryCache.cache(request.getCacheKey(),in==null?request.getParam():in);
}

@Override
public Object out(Request request) throws Exception {
    return mainMemoryCache.get(request.getCacheKey());
}

@Override
public boolean isEnabled() {
    return enable;
}

@Override
public void setEnable(boolean enable) {
    this.enable=enable;
}

}

  • 1.MemoryCacheServiceImpl是内存服务的实现类。

      1. MemoryCache<CacheKey,Object> mainMemoryCache：是一个接口，由于我们可以使用第三方类库实现缓存，也可以写一个自制缓存，如果在内存缓存服务中使用实际的类，那么在以后要进行更换内存缓存实现的时候就需要改动很多地方。而MemoryCache<CacheKey,Object>就是我定义了一组内存缓存组件的标准，只要实现了这个标准的内存缓存组件都能用于这个内存缓存服务。
    • 2.MemoryCache minorMemoryCache：是副缓存，目前没有赋值。
    • 3.接下来的四个方法就是对Service的实现，可以看见对于in()代码中就直接调用的是缓存组件的cache()来对，传入的参数或者返回的结果进行缓存。out()中就是直接从缓存组件中根据Request中的CacheKey获取缓存的数据。

    代码

          public interface ToLocalDataRequest<OUT,IN> {
              OUT updateAndGetAppConfig(Request request, IN in)throws Exception;
              OUT getAppConfig(Request request, IN in)throws Exception ;
              OUT updateAndGetUserConfig(Request request, IN in) throws Exception;
              OUT getUserConfig(Request request, IN in)throws Exception ;
      }
      public interface ToNetworkRequest<OUT,IN> {
         OUT patrolAccountAction_login(Request request, IN in)throws Exception ;
          OUT initAppData(Request request, IN in)throws Exception ;
      }

  • 2.在讲本地储存服务和网络服务的时候，先来介绍两个接口。ToLocalDataRequest<OUT,IN>和ToNetworkRequest<OUT,IN>。我们都知道内存缓存中存取数据是比较简单的，但是到了硬盘和服务器上就不一样了。有时我们会用数据库实现硬盘缓存，有时候会用文件系统实现硬盘缓存，在这个时候对于不同种类的请求要进行的操作是不同的，同样对于向服务器的请求也是一样的。所以我们需要对本地存储请求和服务器请求分别创建接口，然后让本地存储服务和网络请求服务去实现他们，最后根据不同的请求来调用不同的被覆盖的方法。

@ThreadSafe

public class LocalDataServiceImpl implements Service,ToLocalDataRequest,ToNetworkRequest{
private static String TAG="LocalDataServiceImpl";

private final DaoMaster daoMaster = new DaoMaster(new DaoMaster.DevOpenHelper(MyApplication.myApplication, "my.db", null).getWritableDb());
private final DiskCache<SimpleCacheKey> sharePreferenceDiskCache =new SharePreferenceDiskCacheImpl<>(MyApplication.myApplication,new DefaultCacheListener());
private boolean enable;

public LocalDataServiceImpl(boolean enable) {
    this.enable = enable;
}

@Override
public Object in(Request request,Object in) throws Exception {
    return TransformDataMethodDispatch.dispatch(this,this,request,in);
}

@Override
public Object out(Request request) throws Exception {
    return TransformDataMethodDispatch.dispatch(this,this,request,null);
}

@Override
public Object patrolAccountAction_login(Request request, Object in) throws IOException {
    return null;
}

@Override
public Object initAppData(Request request, Object in) throws IOException {
    if (in==null)return null;
    FlushData flushData=(FlushData)in;
    ArrayList<MissionInfoEntity> mInfoEntityArrayList=flushData.getFlushData().getInfoEntityArrayList();
    ArrayList<PolicePeopleEntity> mPeopleArrayList=flushData.getFlushData().getPeopleArrayList();
    ArrayList<UnitBaseEntity> mUnitBaseArrayList=flushData.getFlushData().getUnitBaseArrayList();

    if (mInfoEntityArrayList!=null&&mInfoEntityArrayList.size()!=0){
        for (MissionInfoEntity m:mInfoEntityArrayList){
            daoMaster.newSession().getMissionInfoDao().insert(new MissionInfo(m));
        }
    }

    if (mPeopleArrayList!=null&&mPeopleArrayList.size()!=0){
        for (PolicePeopleEntity p :mPeopleArrayList){
            daoMaster.newSession().getPolicePeopleDao().insert(new PolicePeople(p));
        }
    }

    if (mUnitBaseArrayList!=null&&mUnitBaseArrayList.size()!=0){
        for (UnitBaseEntity u :mUnitBaseArrayList){
            daoMaster.newSession().getUnitBaseDao().insert(new UnitBase(u));
        }
    }
    request.setCacheToMemory(false);
    FLog.v(TAG,"向数据库初始化数据成功");
    return in;
}

@Override
public Object updateAndGetAppConfig(Request request, Object in) throws Exception {
    if (request.getParam()==null){
        FLog.e(TAG,"appConfig插入时为null");
        throw new NullPointerException();
    }
    AppConfig appConfig=(AppConfig)request.getParam();
    List<DBMap> dbMapList=appConfig.transformToDBMap();
    daoMaster.newSession().getDBMapDao().insertOrReplaceInTx(dbMapList);
    FLog.v(TAG,"向数据库更新appConfig成功");
    return appConfig;
}

@Override
public Object getAppConfig(Request request, Object in){
    AppConfig appConfig = null;
    List<DBMap> dbMapList=daoMaster.newSession().getDBMapDao().loadAll();
    if (dbMapList==null||dbMapList.size()==0)return null;
    appConfig=new AppConfig(dbMapList);
    FLog.v(TAG,"从数据库获取的appConfig");
    return appConfig;
}

@Override
public Object updateAndGetUserConfig(Request request, Object in) throws Exception {
    if (request.getParam()==null){
        FLog.e(TAG,"userConfig插入时为null");
        throw new NullPointerException();
    }
    UserConfig userConfig=(UserConfig) request.getParam();
    sharePreferenceDiskCache.cache((SimpleCacheKey) request.getCacheKey(),JsonUtil.objectToJson(userConfig));
    FLog.v(TAG,"向sharePreferenceDiskCache更新userConfig成功");
    return userConfig;
}

@Override
public Object getUserConfig(Request request, Object in) throws IOException {
    UserConfig userConfig= JsonUtil.jsonToObject((String) sharePreferenceDiskCache.get((SimpleCacheKey) request.getCacheKey()),UserConfig.class);
    FLog.v(TAG,"从sharePreferenceDiskCache获取的userConfig");
    return userConfig;
}

@Override
public boolean isEnabled() {
    return enable;
}

@Override
public void setEnable(boolean enable) {
    this.enable=enable;
}
}
  • 3.LocalDataServiceImpl是本地存储服务的实现类，可以看见这个类实现了Service,ToLocalDataRequest,ToNetworkRequest这三个接口，Service不必多说。可能有人要问为什么要实现ToNetworkRequest呢？那是因为在一些向服务器的请求之中，可能在本地中已经有缓存了，那么此时并不需要去服务器中取数据。我们在前面的本地储存拦截器中也有介绍到这一点。
    • 1.可以看见这个类中有GreenDao(一种数据库的ORM)和DiskCache<SimpleCacheKey> sharePreferenceDiskCache这两个实现，GreenDao内部实现不是由我们实现的所以不需要抽象为接口。而sharePreferenceDiskCache是一个本地储存抽象出来的接口和前面讲的内存缓存接口是一个道理。我目前用的是sharePreference，当然以后有需要还可以换成用文件系统实现，换起来也很方便。
    • 2.接下来是实现了Service的in()和out()方法，本来是需要在这两个方法中根据请求的种类使用switch将请求分派到各个方法中的，这里我使用了TransformDataMethodDispatch来分派，内部实现是一样的。
    • 3.接下来的几个方法就是对ToLocalDataRequest,ToNetworkRequest这两个接口的实现了，这里需要根据具体的业务逻辑进行考虑。

@ThreadSafe

public class NetworkServiceImpl implements Service,ToNetworkRequest{
private boolean enable;

public NetworkServiceImpl(boolean enable) {
    this.enable = enable;
}

@Override
public Object in(Request request, Object in) throws Exception {
    return null;
}

@Override
public Object out(Request request) throws Exception {
    return TransformDataMethodDispatch.dispatch(this,null,request,null);
}

@Override
public Object patrolAccountAction_login(Request request, Object in) throws IOException {
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    LoginEntity.Response response=new LoginEntity.Response(new LoginEntity.UserEntity(1,"13030512957","1",(byte) 1,"男"),"杭州",1,4,"");
    return response;
}

@Override
public Object initAppData(Request request, Object in) throws IOException {
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public boolean isEnabled() {
    return enable;
}

@Override
public void setEnable(boolean enable) {
    this.enable = enable;
}
}
  • 4.NetworkServiceImpl就是网络请求服务的实现了
    • 1.这里我只是模拟了网络请求，大家可以使用任何网络框架比如：Retrofit Okhttp之类的
    • 2.注意这里的in()方法是空实现，是不会被调用到的，前面在介绍拦截器的时候已经说过了，不再赘述。
    • 3.和本地存储服务一样，out()方法中也使用了TransformDataMethodDispatch进行请求的分派。

以上就是Service的各个实现类，大家可能发现了，我并没有讲解类似于内存缓存，本地储存以及网络请求的具体实现，但是整个逻辑依旧是非常清晰的。所以看到这里我想有些同学已经理解了，到底该如何设计一个框架：框架的每个层次都需要使用接口进行抽象，能使用接口进行交互的地方就别使用实现类，在改变了一个具体子功能的实现之后其他模块并不会受到影响。 能做到前面说的几点，我想写出来的代码应该算是一个比较容易扩展的架构了。

6.更加上层的封装

我们前面将了DataEngine就算是我们的暴露给客户端的api了，但是这个类用起来还是有点麻烦的，比如说我们的Reponse的泛型参数还没有用起来，这样可能在某些地方需要我们手动进行类型转化，一不小心可能还会将类型转错了。所以接下来我们再在DataEngine之上封装一层api。

public class Transform<Response1,Response2 ,Response3> implements ToLocalDataRequest<Observable<Response<Response1,Response2,Response3>>,Observable<Response>>,
    ToNetworkRequest<Observable<Response<Response1,Response2,Response3>>,Observable<Response>> {

public static <Response1> Observable<Response<Response1,Object,Object>> transformOne(Request request) {
    Transform<Response1,Object,Object> transform=new Transform<>();
    try {
        return TransformDataMethodDispatch.dispatch(transform,transform,request, DataEngine.sInstance.request(request));
    } catch (Exception e) {
        e.printStackTrace();
        return Observable.just(Response.<Response1,Object,Object>getFailedResponse(e));
    }
}

public static <Response1,Response2> Observable<Response<Response1,Response2,Object>> transformTwo(Request request) {
    Transform<Response1,Response2,Object> transform=new Transform<>();
    try {
        return TransformDataMethodDispatch.dispatch(transform,transform,request, DataEngine.sInstance.request(request));
    } catch (Exception e) {
        e.printStackTrace();
        return Observable.just(Response.<Response1,Response2,Object>getFailedResponse(e));
    }
}
public static <Response1,Response2,Response3> Observable<Response<Response1,Response2,Response3>> transformThree(Request request) {
    Transform<Response1,Response2,Response3> transform=new Transform<>();
    try {
        return TransformDataMethodDispatch.dispatch(transform,transform,request, DataEngine.sInstance.request(request));
    } catch (Exception e) {
        e.printStackTrace();
        return Observable.just(Response.<Response1,Response2,Response3>getFailedResponse(e));
    }
}


@Override
public Observable<Response<Response1, Response2, Response3>> updateAndGetAppConfig(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}

@Override
public Observable<Response<Response1, Response2, Response3>> getAppConfig(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}

@Override
public Observable<Response<Response1, Response2, Response3>> updateAndGetUserConfig(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}

@Override
public Observable<Response<Response1, Response2, Response3>> getUserConfig(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}

@Override
public Observable<Response<Response1, Response2, Response3>> patrolAccountAction_login(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}

@Override
public Observable<Response<Response1, Response2, Response3>> initAppData(Request request, Observable<Response> responseObservable) throws Exception {
    return responseObservable
            .map(new Func1<Response, Response<Response1, Response2, Response3>>() {
                @Override
                public Response<Response1, Response2, Response3> call(Response response) {
                    return response;
                }
            });
}
}
  • 1.这个类就是对DataEngine的封装，这个封装可以将DataEngine#request()中返回的数据类，转换成多个界面上可以直接使用的数据类。当由于不同种类的请求用到的数据类型和数量各不相同，所以这个类需要实现ToLocalDataRequest和ToNetworkRequest这两个接口，对不同的请求返回的结果，进行不同的转换。
    • 1.transformOne()、transformTwo()、transformThree()这三个方法，分别表示最后转换的结果是一个、两个、三个。
    • 2.后面的方法都是两个接口的实现，我举的例子中都是不需要转换的数据请求。

7.例子代码

我前面已经给出了一个app登录界面的整套运行流程，项目已经测试过了问题应该不大有问题可以加我QQ，内部有数据引擎的完整代码，项目是用MVVM+Rxjava+GreenDao写的，大家有兴趣可以去下载看看，能给个star就更好了，没兴趣的同学给大家欣赏一下我们登录界面的链式代码。不得不说Rxjava让代码逻辑变得非常清晰，而MVVM的databinding则完美的与数据引擎结合了起来。

`   isShowProgressBar.set(true);
    LocalDataEngine.getAppConfig()
            .flatMap(new Func1<AppConfig, Observable<AppConfig>>() {
                @Override
                public Observable<AppConfig> call(AppConfig appConfig) {
                    //如果为null表示第一次打开app，所以进行全局数据初始化
                    if (appConfig==null) appConfig=new AppConfig(true,"13030512957",false,false);
                    FLog.v(TAG,String.valueOf(appConfig.isFirstOpenApp()));
                    //如果不是第一次打开app，将appConfig传入下面一个环节
                    appConfig.setAutoLogin(true);
                    appConfig.setRememberPassword(true);
                    if (appConfig.isFirstOpenApp()){
                        return LocalDataEngine.updateAndGetAppConfig(appConfig);
                    }else {
                        return Observable.just(appConfig);
                    }
                }
            }).flatMap(new Func1<AppConfig, Observable<AppConfig>>() {
                @Override
                public Observable<AppConfig> call(AppConfig appConfig) {
                    //如果是第一次打开app,那么去服务器拉去数据表
                    if (appConfig.isFirstOpenApp()){
                        return NetworkDataEngine.initAppData(appConfig);
                    }else {
                        //否则，将appConfig传入下面一个环节
                        return Observable.just(appConfig);
                    }
                }
            }).filter(new Func1<AppConfig, Boolean>() {
                @Override
                public Boolean call(AppConfig appConfig) {
                    //此时如果是第一次打开app，那么数据已经全部初始化完毕，更变第一次打开app的flag
                    //同时AppConfig已经准备好，可以进行接下来的操作了。
                    if (appConfig.isFirstOpenApp())
                        appConfig.setFirstOpenApp(false);
                    return true;
                }
            }).filter(new Func1<AppConfig, Boolean>() {
                @Override
                public Boolean call(AppConfig appConfig) {
                    //设置界面上的：记住密码 和 自动登录 的checkBox
                    isRememberPassword.set(appConfig.isRememberPassword());
                    isAutoLogin.set(appConfig.isAutoLogin());
                    //如果全局设置中，既不需要记住密码，也不需要自动登录，那么就不去获取默认的用户信息，直接显示登录界面。
                    if ((!appConfig.isRememberPassword())&&(!appConfig.isAutoLogin())){
                        isShowProgressBar.set(false);
                        return false;
                    }
                    return true;
                }
            }).flatMap(new Func1<AppConfig, Observable<UserConfig>>() {
                @Override
                public Observable<UserConfig> call(AppConfig appConfig) {
                    //根据全局配置获取默认用户的帐号，然后去SharePreference中获取默认用户数据
                    return LocalDataEngine.getUserConfig(appConfig.getNowUserPhone());
                }
            }).filter(new Func1<UserConfig, Boolean>() {
                @Override
                public Boolean call(UserConfig userConfig) {
                    // 如果默认用户数据为null，说明用户数据缓存被清空了，或者app是第一次被打开,此时app不需要自动登录。
                    if (userConfig==null){
                        //弹出toast说明自动登录失败的原因，并将登录界面显示出来
                        Toast.makeText(mBaseActivity, "用户缓存被清空，请手动登录", Toast.LENGTH_SHORT).show();
                        isShowProgressBar.set(false);
                        return false;
                    }else {
                        //数据准备就绪，进行自动登录
                        usernameObservable.set(userConfig.getRememberedPhone());
                        passwordObservable.set(userConfig.getRememberedPassword());
                        username=usernameObservable.get();
                        password=passwordObservable.get();
                        return true;
                    }
                }
            }).subscribe(new Action1<UserConfig>() {
                @Override
                public void call(UserConfig userConfig) {
                    login();
                }
            });`

本篇博客只是给大家一个启示，告诉大家如何实现一个数据引擎的架构，内部必然会出现一些纰漏，有兴趣的同学可以和我在QQ上交流。

最后大家对MVVM架构有兴趣的可以看看我的这两篇博客

MVVM架构篇之databinding源码解析

MVVM架构之自动增删改的极简RecycleView的实现

文章标签：
缓存
Android开发
数据库
存储
API
前端开发
数据处理
数据安全/隐私保护
关键词：
Android架构
Android数据
架构数据
架构android
Android实现
何时夕阳
目录
相关文章
喜欢猪猪
|
9天前
|
消息中间件 存储 缓存
十万订单每秒热点数据架构优化实践深度解析
【11月更文挑战第20天】随着互联网技术的飞速发展，电子商务平台在高峰时段需要处理海量订单，这对系统的性能、稳定性和扩展性提出了极高的要求。尤其是在“双十一”、“618”等大型促销活动中，每秒需要处理数万甚至数十万笔订单，这对系统的热点数据处理能力构成了严峻挑战。本文将深入探讨如何优化架构以应对每秒十万订单级别的热点数据处理，从历史背景、功能点、业务场景、底层原理以及使用Java模拟示例等多个维度进行剖析。
喜欢猪猪
30 8
yuanzhengme
|
11天前
|
存储 分布式计算 数据挖掘
数据架构 ODPS 是什么？
数据架构 ODPS 是什么？
yuanzhengme
89 7
叫个什么名字
|
11天前
|
Android开发 Swift iOS开发
深入探索iOS与Android操作系统的架构差异及其对应用开发的影响
在当今数字化时代，移动设备已经成为我们日常生活和工作不可或缺的一部分。其中，iOS和Android作为全球最流行的两大移动操作系统，各自拥有独特的系统架构和设计理念。本文将深入探讨iOS与Android的系统架构差异，并分析这些差异如何影响应用开发者的开发策略和用户体验设计。通过对两者的比较，我们可以更好地理解它们各自的优势和局限性，从而为开发者提供有价值的见解，帮助他们在这两个平台上开发出更高效、更符合用户需求的应用。
叫个什么名字
26 2
yuanzhengme
|
11天前
|
数据采集 搜索推荐 数据管理
数据架构 CDP 是什么？
数据架构 CDP 是什么？
yuanzhengme
36 2
聚优云惠
|
1月前
|
前端开发 JavaScript 测试技术
android做中大型项目完美的架构模式是什么？是MVVM吗？如果不是，是什么？
android做中大型项目完美的架构模式是什么？是MVVM吗？如果不是，是什么？
聚优云惠
102 2
聚优云惠
|
1月前
|
存储 前端开发 Java
Android MVVM架构模式下如何避免内存泄漏
Android采用MVVM架构开发项目，如何避免内存泄漏风险？怎样避免内存泄漏？
聚优云惠
95 1
liuliunaina
|
2月前
|
IDE Android开发 iOS开发
深入解析Android与iOS的系统架构及开发环境差异
本文旨在探讨Android和iOS两大主流移动操作系统在系统架构、开发环境和用户体验方面的显著差异。通过对比分析，我们将揭示这两种系统在设计理念、技术实现以及市场策略上的不同路径，帮助开发者更好地理解其特点，从而做出更合适的开发决策。
liuliunaina
172 2
游客762btuqu5wybw666
|
13天前
|
Java Linux Android开发
深入探索Android系统架构：从Linux内核到应用层
本文将带领读者深入了解Android操作系统的复杂架构，从其基于Linux的内核到丰富多彩的应用层。我们将探讨Android的各个关键组件，包括硬件抽象层（HAL）、运行时环境、以及核心库等，揭示它们如何协同工作以支持广泛的设备和应用。通过本文，您将对Android系统的工作原理有一个全面的认识，理解其如何平衡开放性与安全性，以及如何在多样化的设备上提供一致的用户体验。
游客762btuqu5wybw666
28 3
萝卜带泥
|
12天前
|
安全 Android开发 iOS开发
深入探讨Android与iOS的系统架构差异
本文旨在通过对比分析Android和iOS两大移动操作系统的系统架构，揭示它们在设计理念、安全性、应用生态及开发环境等方面的显著差异。我们将从底层架构出发，逐步剖析至用户界面层面，为开发者和科技爱好者提供一份详尽的技术参考。
萝卜带泥
21 1
悟道了凡
|
20天前
|
前端开发 JavaScript 测试技术
android做中大型项目完美的架构模式是什么？是MVVM吗？如果不是，是什么？
在 Android 开发中，选择合适的架构模式对于构建中大型项目至关重要。常见的架构模式有 MVVM、MVP、MVI、Clean Architecture 和 Flux/Redux。每种模式都有其优缺点和适用场景，例如 MVVM 适用于复杂 UI 状态和频繁更新，而 Clean Architecture 适合大型项目和多平台开发。选择合适的架构应考虑项目需求、团队熟悉度和可维护性。
悟道了凡
48 6

热门文章

最新文章

  • 1
    最新发布！阿里云卓越架构框架重磅升级
  • 2
    日交易笔百万级，Ping++的大数据平台架构
  • 3
    『MongoDB』MongoDB高可用部署架构——复制集篇（Replica Set）
  • 4
    深入理解MVVM架构模式
  • 5
    富士通咨询在博科SDN架构上构建新一代IP网络以支持全球业务增长
  • 6
    究竟啥才是互联网架构“高并发”
  • 7
    深入linux内核架构读书笔记-进程管理和调度
  • 8
    【转】Linux 概念架构的理解
  • 9
    实战分层架构
  • 10
    大型网站的核心架构要素
  • 1
    Android应用开发：实现自定义View的高效绘制
    70
  • 2
    构建高效Android应用：Kotlin协程的实践指南
    74
  • 3
    jenkins编译H5做的android端编译卫士app记录
    50
  • 4
    利用Bundle实现Android Activity间消息的传递
    53
  • 5
    Intent在Android中的几种用法
    79
  • 6
    Android如何在Activity和Service之间传递数据
    301
  • 7
    android TextView HTML 的效果
    42
  • 8
    Android下自定义Button样式
    48
  • 9
    Android Launcher研究(二)-----------Launcher为何物，究竟是干什么
    203
  • 10
    Android网络访问超时
    56

    • 相关课程

    更多
  • 架构的演进
  • 开源Android容器化框架Atlas开发者指南
  • MySQL企业常见架构与调优经验分享
  • 企业Web常用架构LAMP-LNMP实战
  • 企业级互联网分布式系统应用架构学习
  • 高校精品课-上海交通大学 -企业级应用体系架构

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline

    • 相关实验场景

    更多
  • 每个IT人都想学的“Web应用上云经典架构”实战
  • MySQL引擎及架构优化
  • 基于数据湖架构的网站访问行为分析
  • 使用SLB+2ECS+NAS，部署电商web网站的高可用架构
  • 使用EDA架构部署在线外卖订单系统
  • 部署高可用架构
    • 下一篇
    无影云桌面