Android最好用的项目框架搭建

本篇先记录下当前项目中涉及的主要技术要点。也算是对所作项目的一次总结。如果这个过程能对你有些许的帮助，那可能就显得有意义点了。

一个完整的Android项目会涉及后台和前端。我们只关注于前端，也就是我们的app本身。

下面列出项目架构需要具备的技术点。(以当前所作项目为例)
1.项目结构(MVP设计模式)
2.屏幕适配
3.程序启动页
4.运行权限获取
5.基类(BaseActivity/BaseFragment/BaseApplication)
6.Retrofit(最流行的网络请求框架)+RxJava(链式编程风格+异步)
7.程序崩溃界面处理

1.项目结构

项目采用MVP设计架构。
关于MVC，MVP,MVVM设计模式的升级改造做如下说明：

MVC模式：
M 指模型层（网络IO、文件IO等操作）
V 指视图层（对应Android中的Layout和Activity/Fragment）
C 指控制层（对应Android中的Activity/Fragment）

在Android中，Activity/Fragment既充当控制层又充当视图层,这就导致了V和C这两层耦合在一起，当业务比较复杂时，Activity/Fragment文件就很庞大，导致难以维护和测试，于是MVP模式便应用而生。

MVP模式：
M 指模型层（同MVC）
V 指视图层（同MVC）
P 指业务层（业务逻辑）

Activity/Fragment只充当视图层，不做任何的业务逻辑，将业务逻辑全部放在业务层，由Presenter和Model进行交互，避免Model直接操作View。MVP的优点：将业务从Activity/Fragment分离，便于后期维护和测试。MVP使用特点是面向接口编程（View/Presenter/Model都定义一套接口）。可以说MVP模式的出现主要是将MVC中Control控制层进行解耦，View-视图层中需要展示数据则通过Present-业务层调用Model-模型层去获取，Present-业务层拿到数据后以接口形式回传给View-视图层，View-视图层只需要注册监听Present-业务层用于更新View-视图层的接口就行了。

关于MVC和MVP的区别，大家可以参考 Android中MVC/MVP模式区别 ,里面介绍的很清楚，简单易懂。

有了MVP就够了，为什么又出来了一个MVVM呢？
关于MVP和MVVM模式的区别，网上资料多而杂，看过一圈之后，你可能会感觉更晕了。这个时候你可以继续往下看我的总结。

MVC和MVVM的唯一区别就是MVVM中多了一个DataBinding，其他基本无差别。
DataBinding 是谷歌官方发布的一个框架，顾名思义即为数据绑定，是 MVVM 模式在 Android 上的一种实现，用于降低布局和逻辑的耦合性，使代码逻辑更加清晰。MVVM 相对于 MVP，其实就是将 Presenter 层替换成了 ViewModel 层。DataBinding 能够省去我们一直以来的 findViewById() 步骤，大量减少 Activity 内的代码，数据能够单向或双向绑定到 layout 文件中。

关于DataBinding框架你可以参考 Android DataBinding 从入门到进阶，但是我没有在项目中使用。尝试用了一下，发现不好用。
 

原因如下：
第一条，DataBindding优势在于支持数据绑定(单向和双向)，这意味着MVP模式中Present-业务层通过接口回调的方式来通知View-视图层来进行界面更新操作流程不存在了，取而代之的是通过标签绑定的形式来进行更新。如此，layout.xml中可能会进行一些简单的业务逻辑处理。虽然是简单的业务逻辑，我还是感觉和我们一致提倡的视图&&业务分离的理念相悖。

第二条，.使用DataBinding不方便维护。我曾尝试将MVP模式的项目代码改为DataBinding+MVVM的实现方式。结果很是不爽。举个例子，在使用DataBinding设置监听事件的时候，对点击事件的引用是不会进行错误提示的，一旦你定义的名字和实际引用的存在大小写不匹配的情况，很难排查出错点。Android IDE对代码补全的支持还不是很友好。

3.使用DataBinding的使用率不是很高。别的我不知道，我身边的人也仅限于了解过活着写过简单的Demo去学习其用法。但是实际项目中没有用到。因此使用DataBinding的话还需谨慎，如果多人维护同一个项目的话，那么大家都会DataBinding的使用，不然日后维护绝对是个坑。

4.网上介绍的关于DataBinding的用法的介绍，我不想吐槽。好多都是直接复制粘贴过来的，都是些基本的不能再基本的用法，高级用法介绍的很少。有些连基本用法都没讲清楚。比如，我们经常在layout.xml中来使用include来进行布局的复用(虽然不能减少层级嵌套)，但是在include中的Layout中使用clickListener的时候，需要由父布局层层传递下去，才能起作用。但是这种很重要的用法，有些文章连提都没提。

算了，不吐槽了。不然该有小伙伴拿“存在即合理”来反驳我了。

当项目界面比较复杂控件比较多的时候，可能会需要写大量的findById(R.id.xxx),如果你看着别扭的话，可以使用开源库Butterknife(黄油刀)来进行替换。不一定要使用DataBindding。算了，你们还是自己回头在实际项目中用一下吧，如果你们觉得好用，麻烦告诉我以下，我们再交流交流。

如果对于MVC/MVP设计架构不清楚的话，推荐大家阅读:
Android App的设计架构：MVC,MVP,MVVM与架构经验谈,文章中有段话说的特别好：

刚开始理解这些概念的时候认为这几种模式虽然都是要将view和model解耦，但是非此即彼，没有关系，一个应用只会用一种模式。后来慢慢发现世界绝对不是只有黑白两面，中间最大的一块其实是灰色地带，同样，这几种模式的边界并非那么明显，可能你在自己的应用中都会用到。实际上也根本没必要去纠结自己到底用的是MVC、MVP还是MVVP，不管黑猫白猫，捉住老鼠就是好猫。

通俗表述就是，不要刻意的是自己的代码故意去迎合某种设计模式，而是通过这种"视图&&业务逻辑解耦"的思想去引贯穿和引导自己去写代码。

 

2.屏幕适配
 

 

前面受限于截图，特此将values/dimens.xml文件展开如上图。android项目开发，屏幕适配是首先要考虑的问题关于屏幕适配，大家可参照另一篇文章：
Android 屏幕适配方案

3.程序启动页

AndroidMantifest.xml

...

        
            
                
                
            
        
...

上述中的

@mipmap/startup

就是启动页的图。
 
HRSplashActivity.java

public class HRSplashActivity extends FragmentActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
      //todo:可在此处添加关于启动页面的延时操作eg(延时2s): 
      try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        startActivity(new Intent(HRSplashActivity.this, HRLoginActivity.class));
        finish();
    }

}

4.运行权限获取

正常情况下程序运行的流程图下：
启动页----->登录页----->程序首页
没错，但是在从启动页跳转到登录页的时候，涉及到权限授予，主要是针对Android 6.0权限的授予。也许你会问，我在用到权限的时候再申请不行么？ 答案是：可以，但是不建议。如果如果只有少量界面需要申请权限，即用即申请是可以的。但是如果需要权限的界面很多，这就比较麻烦了-------我们需要在每个界面都要判断所需权限是否已经授予了，如果没有的话就继续申请。权限申请逻辑比较分散，不便于后续维护。

因此最好的办法就是在程序开启时就要进行权限申请，如果所需权限没有全部被授予**(记住：所需权限必须全部被授予)**，就不允许用户登录。事实上QQ就是这么做的，当权限被用户手动拒绝之后，会弹出提示框，从而引导用户去设置中手动设置。

废话不说，直接贴出权限工具类，这个工具类其实还有些别的权限相关的方法，怕影响阅读，我把它阉割掉了，如果想看完整的，也可移步
Android常用的工具类汇总（方便日后使用）
PermissionUtils .java
 

public final class PermissionUtils {

    /**
     * Return whether you have granted the permissions.
     *
     * @param permissions The permissions.
     * @return {@code true}: yes
{@code false}: no
     */
    public static boolean isGranted(final String... permissions) {
        for (String permission : permissions) {
            if (!isGranted(permission)) {
                return false;
            }
        }
        return true;
    }

    private static boolean isGranted(final String permission) {
        return Build.VERSION.SDK_INT < Build.VERSION_CODES.M
                || PackageManager.PERMISSION_GRANTED
                == ContextCompat.checkSelfPermission(Utils.getApp(), permission);
    }

    /**
     * Launch the application's details settings.
     */
    public static void launchAppDetailsSettings() {
        Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
        intent.setData(Uri.parse("package:" + Utils.getApp().getPackageName()));
        Utils.getApp().startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
    }

    /**
     * 批量申请权限（如果当前没有权限的话)。授权结果在onRequestPermissionsResult中处理
     */
    public static void requestPermissionsIfNeed(Activity activity, String[] perms, int requestCode) {
        if (perms.length == 0) {
            return;
        }

        HashSet needPerms = new HashSet<>();
        for (String perm : perms) {
            if (!isGranted(perm)) {
                needPerms.add(perm);
            }
        }

        if (needPerms.size() == 0) {
            return;
        } else {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                activity.requestPermissions(needPerms.toArray(new String[needPerms.size()]), requestCode);
            }
        }
    }

}

上述保留了最基本的权限申请逻辑，完全能满足需求。

至于怎么在程序入口处调用，很简单，看程序入口。
HRLoginActivity.java

public class HRLoginActivity extends HRBaseActivity implements View.OnClickListener {

    private final int PERMISSION_REQUEST_CODE = 0x183;
    private final String perms[] = {
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.MODIFY_AUDIO_SETTINGS,
            Manifest.permission.INTERNET,
            Manifest.permission.ACCESS_WIFI_STATE,
            Manifest.permission.CAMERA,
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CHANGE_NETWORK_STATE
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestPermissions();
        ....
        ....
        ....
    }

    private void requestPermissions() {
        PermissionUtils.requestPermissionsIfNeed(this, perms, PERMISSION_REQUEST_CODE);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.login_confirm:
                if (PermissionUtils.isGranted(perms)) {
                    login();
                } else {
                    requestPermissions();
                }
                break;

            default:
                break;
        }
    }

    /**
     * 某一权限没有被授予，弹出提示框
     */
    private void showPermissionDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this)
                .setTitle("温馨提示")
                .setMessage("请在设置中开启所需权限，以正常使用xxx功能")
                .setNeutralButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        finish();
                    }
                })
                .setNegativeButton("去设置", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        PermissionUtils.launchAppDetailsSettings();
                        finish();
                    }
                });

        final AlertDialog dialog = builder.show();
        dialog.setCanceledOnTouchOutside(false);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode != PERMISSION_REQUEST_CODE) {
            return;
        }

        for (int i = 0; i < grantResults.length; i++) {
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                showPermissionDialog();
                return;
            }
        }
    }

}

逻辑很简单：如果权限没授予，就弹出提示框，引导用户去“设置”中手动授予权限，如果在弹框中点击“取消”，则退出程序。下次进来，依旧如此，直至所有权限全部被授予。

5.基类(BaseActivity/BaseFragment/BaseApplication)

BaseActivity.java(完整版)

public abstract class HRBaseActivity extends RxFragmentActivity {

    protected final String TAG = getClass().getSimpleName();
    protected HRBaseActivity mContext;
    protected WeakHandler mHandler = new WeakHandler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            handlerMsg(msg);
            return false;
        }
    });


    private AlertDialog mDialogLoading;
    private HRBaseActivityMonitor mHRBaseActivityMonitor;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LogUtils.d(TAG, String.format("%s onCreate", TAG));
        mContext = this;
        initLoading();

        setContentView(initLayout());
        initView();
        initData();
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        LogUtils.d(TAG, String.format("%s onNewIntent", TAG));
    }

    @Override
    protected void onResume() {
        super.onResume();
        LogUtils.d(TAG, String.format("%s onResume", TAG));
    }

    @Override
    protected void onPause() {
        super.onPause();
        hideLoading();
        LogUtils.d(TAG, String.format("%s onPause", TAG));
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        LogUtils.d(TAG, String.format("%s onDestroy", TAG));
        if(mHRBaseActivityMonitor != null) {
            mHRBaseActivityMonitor.destroy();
        }
        hideLoading();
        mHandler.removeCallbacksAndMessages(null);
    }

    protected void quitActivity() {
        sendBroadcast(new Intent(ConstantUtils.Action.ACTION_QUIT));
    }

    private void initLoading() {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        mDialogLoading = builder.create();
        mDialogLoading.setCanceledOnTouchOutside(false);
    }

    public void showLoading() {
        if(mDialogLoading != null && !mDialogLoading.isShowing()) {
            mDialogLoading.show();
            View view = LayoutInflater.from(mContext).inflate(R.layout.dialog_progress, null);
            mDialogLoading.setContentView(view);
            mDialogLoading.getWindow().setLayout(WindowManager.LayoutParams.WRAP_CONTENT, WindowManager.LayoutParams.WRAP_CONTENT);
            mDialogLoading.getWindow().getDecorView().setBackgroundColor(0x00000000);
            mDialogLoading.getWindow().getDecorView().setPadding(0, 0, 0, 0);
        }
    }

    public void hideLoading() {
        if(mDialogLoading != null && mDialogLoading.isShowing()) {
            mDialogLoading.dismiss();
        }
    }

    public WeakHandler getHandler() {
        return mHandler;
    }

    public void setMonitorListener(HRBaseActivityMonitor.Listener listener) {
        if(mHRBaseActivityMonitor == null) {
            mHRBaseActivityMonitor = new HRBaseActivityMonitor(this);
        }
        mHRBaseActivityMonitor.setListener(listener);
    }

    /**
     * 设置根布局
     */
    public abstract int initLayout();

    /**
     * 初始化布局
     */
    public abstract void initView();

    /**
     * 设置数据
     */
    public abstract void initData();

    /**
     * 处理handler消息
     */
    public void handlerMsg(Message msg) {};

}

下面我会详细讲解下BaseActivity.java基类到底包含哪些东西。
首先思考下何为基类？
我理解的基类就是做一些比较通用的工作，并且对子类中的通用模块进行封装。
子类中通用的模块包括什么呢？包含以下几点：

1.布局/控件/数据的初始化,如下

 /**
     * 设置根布局
     */
    public abstract int initLayout();

    /**
     * 初始化布局
     */
    public abstract void initView();

    /**
     * 设置数据
     */
    public abstract void initData();

2.ProgressBar加载框。现在Android应用通常在界面跳转的时候，往往会发起网络请求。网络请求时候，一般都通过ProgressBar“转圈圈”来显示网络加载的过程。因此在BaseActivity.java基类中应该封装用于装显示和隐藏转圈圈的接口，子类中可以在发起网络请求的同时showLoading()，在网络请求有结果返回的时候hideLoading()。进行关于加载框，大家按需分配，如果项目需要就用，如果项目不需要，可以不用,代码如下：
 

/**
     * 初始化转圈圈
     */
    private void initLoading() {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        mDialogLoading = builder.create();
        mDialogLoading.setCanceledOnTouchOutside(false);
    }

    /**
     * 显示转圈圈
     */
    public void showLoading() {
        if(mDialogLoading != null && !mDialogLoading.isShowing()) {
            mDialogLoading.show();
            View view = LayoutInflater.from(mContext).inflate(R.layout.dialog_progress, null);
            mDialogLoading.setContentView(view);
            mDialogLoading.getWindow().setLayout(WindowManager.LayoutParams.WRAP_CONTENT, WindowManager.LayoutParams.WRAP_CONTENT);
            mDialogLoading.getWindow().getDecorView().setBackgroundColor(0x00000000);
            mDialogLoading.getWindow().getDecorView().setPadding(0, 0, 0, 0);
        }
    }

    /**
     *隐藏转圈圈
     */
    public void hideLoading() {
        if(mDialogLoading != null && mDialogLoading.isShowing()) {
            mDialogLoading.dismiss();
        }
    }

目前转圈圈的布局中只含有一个ProgressBar，你完全可以进行扩充，比如添加加载动效等等。

dialog_progress.xml

 

3.Handler消息处理。 项目中或多或少都会涉及线程间通信，或延时，定时操作。这时候自然就少不了Handler了消息处理机制了。Handler使用不当很容易造成内存泄漏。初学者往往不在意，下面就是一个典型的Handler造成的内存泄漏的例子。(相信下面的代码有小伙伴没少写吧，至少我写过)

.....
.....
.....
private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.what == MSG_WHAT) {
                String str = (String) msg.obj;
                Log.i(TAG, "handleMessage:str::" + str);
            }
        }
    };
.....
.....
.....

泄漏原因：非静态内部类默认持有外部类的引用。
具体描述可以移步 Handler导致的内存泄露分析以及内存泄露检测工具LeakCanary的集成，那里对Handler造成的内存泄漏的原因以及解决方案做了详细说明。

为了避免大家的不注意造成的Handler滥用的情况，特此从网上淘了一个大牛封装好的WeakHandler.java文件，相关文档见 WeakHandler:避免内存泄漏的Handler

集成方式：
(1).可以将此文件拷贝出来用
(2).在app 的build.gradle文件中添加添加依赖(见链接)
关于WeakHandler.java的文件我也就不贴了。

基类中BaseActivity.java中涉及到的Handler的代码如下

......
......
......
  protected WeakHandler mHandler = new WeakHandler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            handlerMsg(msg);
            return false;
        }
    });
......
.....
......
    /**
     * 处理handler消息
     */
    public void handlerMsg(Message msg) {};
    .....
    ....

在子类中重写 handlerMsg(Message msg)即可处理handler消息。简单粗暴。
 

4.广播监听。看到基类中的如下代码，你可能有点疑问------这玩意是干啥的？

......
   .....
   .....
    private HRBaseActivityMonitor mHRBaseActivityMonitor;
....
....
....
    public void setMonitorListener(HRBaseActivityMonitor.Listener listener) {
        if(mHRBaseActivityMonitor == null) {
            mHRBaseActivityMonitor = new HRBaseActivityMonitor(this);
        }
        mHRBaseActivityMonitor.setListener(listener);
    }
....
...
...

网上提供的基类往往很少涉及这块。但是它很重要。举个例子，我的App中正在进行 屏幕录制(举个例子) 操作，这个时候突然有人打电话进来了。那这个时候我们的App运行时就被接电话给打断了，毕竟接打电话具有最高的优先级。那这个时候我们的app处在一种什么状态呢？不好意思，我也不清楚。但是在接电话的时候，对当前正在运行的app做一些额外的操作还是很有必要的。比如来电话的时候，我将录制的屏幕视频保存到指定目录下，或者直接销毁当前活动等。

所以，mHRBaseActivityMonitor.java就是用来做这个工作的。
BaseActivity.java中涉及到的广播的封装类文件如下:
BaseActivityMonitor.java

public class HRBaseActivityMonitor extends HRBaseMonitor {

    private Listener mListener;

    public HRBaseActivityMonitor(Context context) {
        super(context);
    }

    @Override
    public IntentFilter register() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(ConstantUtils.Action.ACTION_QUIT);
        filter.addAction(ConstantUtils.Action.ACTION_SHUTDOWN);
        filter.addAction(ConstantUtils.Action.ACTION_PHONE_STATE);
        filter.addAction(ConstantUtils.Action.ACTION_NEW_OUTGOING_CALL);
        return filter;
    }

    @Override
    public void handleReceive(Context context, Intent intent) {
        String action = intent.getAction();
        LogUtils.d("onReceive, action = " + action);

        switch(action) {
            case ConstantUtils.Action.ACTION_QUIT:
            case ConstantUtils.Action.ACTION_PHONE_STATE:
            case ConstantUtils.Action.ACTION_NEW_OUTGOING_CALL:
            case ConstantUtils.Action.ACTION_SHUTDOWN:
                if(mListener != null) {
                    mListener.finish();
                }
                break;

            default:break;
        }
    }

    public void setListener(Listener listener) {
        mListener = listener;
    }

    public void destroy(){
        unRegister();
        mListener = null;
    }

/*********************************************Interface*************************************************************/

    public interface Listener {
        void finish();
    }


}

其中

  case ConstantUtils.Action.ACTION_QUIT:
            case ConstantUtils.Action.ACTION_PHONE_STATE:
            case ConstantUtils.Action.ACTION_NEW_OUTGOING_CALL:
            case ConstantUtils.Action.ACTION_SHUTDOWN:

是一些写在常量文件中的系统广播，比如来电和拨出等

  public static final String ACTION_PHONE_STATE = "android.intent.action.PHONE_STATE"; // 来电
    public static final String ACTION_NEW_OUTGOING_CALL = "android.intent.action.NEW_OUTGOING_CALL"; // 拨出

自己按照需要来增添相应的广播即可。在需要进行打断监听的子类中直接设置监听即可，操作如下：

setMonitorListener(new HRBaseActivityMonitor.Listener() {
            @Override
            public void finish() {
                //todo 在此处添加有来电话时候的处理逻辑
                quit();
            }
        });

好了，细心的你可能发现在BaseActivity中我们集成的是RxFragmentActivity 。

public abstract class HRBaseActivity extends RxFragmentActivity {
....
.....
}

RxFragmentActivity 是什么玩意，不都是继承AppcompatActivity么？
前缀是Rx,你能想到啥？Rxjava吧。 Retrofit(最流行的网络请求框架)+RxJava(链式编程风格+异步) 是目前Android 开发最流程的开发框架。Retrofit+Rxjava是基于订阅的。但是发布的订阅如果没有被及时取消的化，就会造成内存泄漏，因此我们通过继承Rx****Activity.java来控制组件生命周期结束时，自动取消对Observable订阅。后面讲到Rxjava+Retrofit的时候会说。
至于为什么不是继承RxAppCompatActivity而是继承RxFragmentActivity，那是因为我的子类会涉及到Fragment的切换，所以只能用RxFragmentActivity了。

关于RxFragmentActivity，确切的说是RxLifecycler的使用可参考 Rxlifecycle使用详解
 
好了说完BaseActivity基类，下面该说BaseFragment基类了。
BaseFragment.java(完整版)
 

public abstract class HRBaseFragment extends Fragment {

    protected HRBaseActivity activity;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(initLayout(), container, false);
        initView(view);
        initData();
        return view;
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        activity = (HRBaseActivity) getActivity();
    }

    /**
     * 设置根布局
     */
    public abstract int initLayout();

    /**
     * 初始化布局
     */
    public abstract void initView(View root);

    /**
     * 设置数据
     */
    public abstract void initData();

    /**
     * 设置TitleBar
     * @param HRTitleBar
     */
    public abstract void setTitleBar(HRTitleBar HRTitleBar);
}

可以看到BaseFragment.java中和BaseActivity.java相比多了下面一点差异化的东西

/**
     * 设置TitleBar
     * @param HRTitleBar
     */
    public abstract void setTitleBar(HRTitleBar HRTitleBar);

在实际开发中，涉及到Activity中切换Fragment的时候，往往都需要对TitleBar做些许的改动。Activity和Fragment中应该共用一套TitleBar 。示意图如下：

首先，这个TitleBar是在Activity层面的。这样为何便于各个不同的Fragment对TitleBar进行更改，于是我们需要在各个继承了BaseFragment的子Fragment中重写setTitleBar()即可。

....
....
....
 @Override
    public void setTitleBar(HRTitleBar titleBar) {
      //todo 在此处设置TitleBar上各个控件的显示以及控件的监听事件
      
        titleBar.reset();
        titleBar.setTitleText(getString(R.string.member_title));

        titleBar.showRightImageView(true);
        titleBar.setRightImageResource(R.mipmap.member_add);
        titleBar.setRightLayoutMargins(0, 0, getResources().getDimensionPixelSize(R.dimen.dp10), 0);
        titleBar.setRightClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                showAddMemberPopWindow();
            }
        });
    }
....
....
.....

那么在Activity中如何处理TitleBar呢，如下

......
.....
.....
  private void initTitleBar() {
   //设置titlebar
        HRTitleBar titleBar = new HRTitleBar(findViewById(R.id.title_bar));
        titleBar.setTitleBarBackground(ContextCompat.getDrawable(this, R.drawable.shape_statistic_detail_title_bar_bg));
        titleBar.setLeftLayoutMargins(getResources().getDimensionPixelSize(R.dimen.dp11), 0, 0, 0);
        titleBar.setTitleTextColor(Color.parseColor("#FFFFFF"));
        titleBar.setTitleText(getString(R.string.statistics_data_title));

        titleBar.setLeftLayoutMargins(getResources().getDimensionPixelSize(R.dimen.dp11), 0, 0, 0);
        titleBar.setLeftImageResource(R.mipmap.ic_back);
        titleBar.showLeftImageView(true);
        titleBar.showLeftTextView(false);
        titleBar.setLeftClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                hideLoading();
                finish();
            }
        });

        titleBar.showRightImageView(false);
        titleBar.showRightTextView(false);
    }
......
......
......

其中的布局文件引用，大家可以自己定义，顺便提供一个吧

.....
.....
.....
   
....
.....

Titlebar的布局实现如下:
title_bar.xml

预览效果如下：

那么Activity优势如何将TiltleBar对象传给Fragment的呢？

....
   .....
   //在切换到对应的Fragment中及逆行设置
        ((HRBaseFragment)curFragment).setTitleBar(mHRTitleBar);
       
  ......
  .....

下面附上最重要的titlebar实现类代码(依赖于上面提供的布局文件，自己可修改)
TitleBar.java

public class HRTitleBar {
    private View mRoot;
    private TextView mTitleView;
    private ImageView mLeftImageView;
    private TextView mLeftTextView;
    private LinearLayout mLeftLayout;
    private TextView mRightTextView;
    private ImageView mRightImageView;
    private LinearLayout mRightLayout;

    public HRTitleBar(View root) {
        mRoot = root;
        mTitleView = mRoot.findViewById(R.id.title);
        mLeftImageView = mRoot.findViewById(R.id.left_image);
        mLeftTextView = mRoot.findViewById(R.id.left_text);
        mLeftLayout = mRoot.findViewById(R.id.left_layout);
        mRightImageView = mRoot.findViewById(R.id.right_image);
        mRightTextView = mRoot.findViewById(R.id.right_text);
        mRightLayout = mRoot.findViewById(R.id.right_layout);

        mTitleView.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
        reset();
    }

    /**
     *隐藏titlebar中的所有控件
     */
    public void reset() {
        mLeftImageView.setVisibility(View.GONE);
        mLeftTextView.setVisibility(View.GONE);
        mRightImageView.setVisibility(View.GONE);
        mRightTextView.setVisibility(View.GONE);

        mRightLayout.setOnClickListener(null);
        mLeftLayout.setOnClickListener(null);

        mTitleView.setTextColor(Color.parseColor("#000000"));
        mLeftTextView.setTextColor(Color.parseColor("#6D6D6D"));
        mRightTextView.setTextColor(Color.parseColor("#6D6D6D"));
        mRoot.setBackgroundColor(Color.parseColor("#FFFFFF"));
    }

    /**
     * 设置titlebar的背景色
     * @param color, color res id
     */
    public void setTitleBarBackground(int color) {
        mRoot.setBackgroundColor(color);
    }


    /**
     * 设置titlebar的背景色
     * @param drawable
     */
    public void setTitleBarBackground(Drawable drawable) {
        mRoot.setBackground(drawable);
    }

    /**
     * 设置titilebar 标题
     * @param text
     */
    public void setTitleText(String text) {
        mTitleView.setText(text);
    }

    /**
     * titilebar 右边图标是否显示
     * @param show
     */
    public void showRightImageView(boolean show) {
        mRightImageView.setVisibility(show ? View.VISIBLE : View.GONE);
    }

    /**
     * titlebar右图标旁的文本是否显示
     * @param show
     */
    public void showRightTextView(boolean show) {
        mRightTextView.setVisibility(show ? View.VISIBLE : View.GONE);
    }

    /**
     * 设置titlebar标题字体颜色
     * @param color
     */
    public void setTitleTextColor(int color) {
        mTitleView.setTextColor(color);
    }

    /**
     * 设置titlebar右边文本的颜色
     * @param color
     */
    public void setRightTextColor(int color) {
        mRightTextView.setTextColor(color);
    }

    /**
     * 设置titlebar右边图标
     * @param res, res id
     */
    public void setRightImageResource(int res) {
        mRightImageView.setImageResource(res);
    }

    /**
     * 设置titlebar右边图标文本
     * @param text
     */
    public void setRightText(String text) {
        mRightTextView.setText(text);
    }

    /**
     * 设置titilbar右边控件(图标+文本)的监听事件
     * @param l
     */
    public void setRightClickListener(View.OnClickListener l) {
        mRightLayout.setOnClickListener(l);
    }

    /**
     * 设置titlebar左图标
     * @param res, res id
     */
    public void setLeftImageResource(int res) {
        mLeftImageView.setImageResource(res);
    }


    /**
     * titilebar左边文本是否显示
     * @param show
     */
    public void showLeftTextView(boolean show) {
        mLeftTextView.setVisibility(show ? View.VISIBLE : View.GONE);
    }

    /***********************************设置titlebar文本与图片相对位置************************************/

    public void setLeftCompoundDrawablesRelativeWithIntrinsicBounds(int left, int top, int right, int bottom) {
        mLeftTextView.setCompoundDrawablesRelativeWithIntrinsicBounds(left, top, right, bottom);
    }

    public void setLeftCompoundDrawables(Drawable left, Drawable top, Drawable right, Drawable bottom) {
        mLeftTextView.setCompoundDrawables(left, top, right, bottom);
    }

    public void setLeftCompoundDrawablePadding(int padding) {
        mLeftTextView.setCompoundDrawablePadding(padding);
    }

    public void setRightCompoundDrawablesRelativeWithIntrinsicBounds(int left, int top, int right, int bottom) {
        mRightTextView.setCompoundDrawablesRelativeWithIntrinsicBounds(left, top, right, bottom);
    }

    public void setRightCompoundDrawables(Drawable left, Drawable top, Drawable right, Drawable bottom) {
        mRightTextView.setCompoundDrawables(left, top, right, bottom);
    }

    public void setRightCompoundDrawablePadding(int padding) {
        mRightTextView.setCompoundDrawablePadding(padding);
    }

    public void setRightLayoutMargins(int left, int top, int right, int bottom) {
        FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(mRightLayout.getLayoutParams());

        layoutParams.leftMargin   = left > 0   ? left   : layoutParams.leftMargin;
        layoutParams.topMargin    = top > 0    ? top    : layoutParams.topMargin;
        layoutParams.rightMargin  = right > 0  ? right  : layoutParams.rightMargin;
        layoutParams.bottomMargin = bottom > 0 ? bottom : layoutParams.bottomMargin;
        layoutParams.gravity = Gravity.CENTER_VERTICAL|Gravity.END;

        mRightLayout.setLayoutParams(layoutParams);
    }

    public void setLeftText(String text) {
        mLeftTextView.setText(text);
    }

    public void setLeftLayoutMargins(int left, int top, int right, int bottom) {
        FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(mLeftLayout.getLayoutParams());

        layoutParams.leftMargin   = left > 0   ? left   : layoutParams.leftMargin;
        layoutParams.topMargin    = top > 0    ? top    : layoutParams.topMargin;
        layoutParams.rightMargin  = right > 0  ? right  : layoutParams.rightMargin;
        layoutParams.bottomMargin = bottom > 0 ? bottom : layoutParams.bottomMargin;
        layoutParams.gravity = Gravity.CENTER_VERTICAL;

        mLeftLayout.setLayoutParams(layoutParams);
    }

    public void showLeftImageView(boolean show) {
        mLeftImageView.setVisibility(show ? View.VISIBLE : View.GONE);
    }

    public void setLeftClickListener(View.OnClickListener l) {
        mLeftLayout.setOnClickListener(l);
    }

    public void setTitleCompoundDrawables(Drawable left, Drawable top, Drawable right, Drawable bottom) {
        mTitleView.setCompoundDrawables(left, top, right, bottom);
    }

    public void setTitleCompoundDrawablePadding(int padding) {
        mTitleView.setCompoundDrawablePadding(padding);
    }

    public void setTitleClickListener(View.OnClickListener l) {
        mTitleView.setOnClickListener(l);
    }

}

好了，基类的介绍就到这了。如果想专门看看TitleBar的封装，也可移步 Android打造通用的TitleBar,内容一样，无非其中的接口注释是中文还是英文。
顺便提一嘴，关于BaseApplication基类所承载的工作一般是一些配置文件的初始化，比如某些库的初始化配置等等。有可能用不到。所以不在赘述。

 

6.Retrofit(最流行的网络请求框架)+RxJava(链式编程风格+异步)

关于Retrofit+Rxjava我不打算详解。可参考：
Android Retrofit 2.0 的详细 使用攻略（含实例讲解）

那么提及这一点的目的很简单，给Retrofit+RXJava组合方式使用有疑问的同学，提供下参考(代码中涉及到项目中的关键代码，我会做屏蔽处理)
主体HttpManager .java
 

/**
 * 处理网络请求管理类
 */
public class HttpManager {

    private final String TAG = "HttpManager";
    private final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");

    private volatile static HttpManager INSTANCE;
    private IHttpRequest mHttpRequest;

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

    private HttpManager() {
        Retrofit retrofit = new Retrofit.Builder()
                .client(new OkHttpManager().getOkHttpClient())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .baseUrl(HrWebConstantUtils.Url.URL_SAAS)
                .build();

        mHttpRequest = retrofit.create(IHttpRequest.class);
    }

    private void subscribe(RxFragmentActivity activity, Observable observable, HttpCallBack subscriber) {
        observable.compose(activity.bindUntilEvent(ActivityEvent.DESTROY))
                /** http请求线程 */
                .subscribeOn(Schedulers.io())
                /** 回调线程 */
                .observeOn(AndroidSchedulers.mainThread())
                /** 结果判断 */
                .subscribe(subscriber);
    }

    public void reqLogin(RxFragmentActivity activity, String userName, String pwd, HttpCallBack subscriber) {
        HrWebConstantUtils.AUTHOR_TOKEN = "";
        subscribe(activity, mHttpRequest.reqLogin(HrWebConstantUtils.Url.URL_ACCOUNT + "v1/auth/login", Credentials.basic(userName, pwd)), subscriber);
    }

    public void reqCommonConfig(RxFragmentActivity activity, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqCommonConfig(), subscriber);
    }

    public void reqSections(RxFragmentActivity activity, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqSections(), subscriber);
    }

    public void reqIPCList(RxFragmentActivity activity, String nodeId, int curPage, int pageSize, String sn, HttpCallBack subscriber) {
        JSONObject jsonBody = new JSONObject();
        try {
            jsonBody.put("current", curPage);
            jsonBody.put("page_size", pageSize);
            jsonBody.put("node_id", nodeId);
            if(!TextUtils.isEmpty(sn)) {
                jsonBody.put("ipc_sn", sn.trim());
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, jsonBody.toString());
        subscribe(activity, mHttpRequest.reqIPCList(body), subscriber);
    }

    public void reqAddIPC(RxFragmentActivity activity, String nodeId, String sn, String location, HttpCallBack subscriber) {
        JSONObject jsonBody = new JSONObject();
        try {
            jsonBody.put("ipc_sn", sn);
            jsonBody.put("node_id", nodeId);
            jsonBody.put("location", location);
        } catch (JSONException e) {
            e.printStackTrace();
        }

        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, jsonBody.toString());
        subscribe(activity, mHttpRequest.reqAddIPC(body), subscriber);
    }

    public void reqNodeInfo(RxFragmentActivity activity, String nodeId, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqNodeInfo(nodeId), subscriber);
    }

    public void reqMemberList(RxFragmentActivity activity, String nodeId, int curPage, int pageSize, String memType, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqMemberList(nodeId, curPage, pageSize, memType), subscriber);
    }

    public void reqMemberDetails(RxFragmentActivity activity, String memId, String memType, String nodeId, int curPage, int pageSize, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqMemberDetails(memId, memType, nodeId, curPage, pageSize), subscriber);
    }

    public void reqAccountInfo(RxFragmentActivity activity, HttpCallBack subscriber) {
        subscribe(activity, mHttpRequest.reqAccountnfo(), subscriber);
    }

    public void reqAddMember(RxFragmentActivity activity, ReqMemberInfo memberAdd, HttpCallBack subscriber) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, new Gson().toJson(memberAdd));
        subscribe(activity, mHttpRequest.reqAddMember(body), subscriber);
    }

    public void reqUpdateMember(RxFragmentActivity activity, ReqMemberInfo memberAdd, HttpCallBack subscriber) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, new Gson().toJson(memberAdd));
        subscribe(activity, mHttpRequest.reqUpdateMember(body), subscriber);
    }

    public void reqArrivalList(RxFragmentActivity activity, ReqArrivalQuery arrivalQuery, HttpCallBack subscriber) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, new Gson().toJson(arrivalQuery));
        subscribe(activity, mHttpRequest.reqArrivalList(body), subscriber);
    }

    public void reqStatisticsTraffics(RxFragmentActivity activity, ReqTraffics reqTraffics, HttpCallBack subscriber) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, new Gson().toJson(reqTraffics));
        subscribe(activity, mHttpRequest.reqStatisticsTraffics(body), subscriber);
    }

    public void reqStatisticAttributes(RxFragmentActivity activity, ReqTraffics reqTraffics, HttpCallBack subscriber) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, new Gson().toJson(reqTraffics));
        subscribe(activity, mHttpRequest.reqStatisticsAttributes(body), subscriber);
    }
}

下面是HttpManager中用到的一些类:
OkHttpManager.java

/**
 * okhttp的管理类
 */
public class OkHttpManager {

    private final String TAG = "OkHttpManager";
    private OkHttpClient mOkHttpClient;

    public OkHttpManager() {
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .retryOnConnectionFailure(true)//断网重连
                .connectTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .addInterceptor(getHttpLoggingInterceptor())
                .addInterceptor(new CommonHeaderInterceptor());

        if(HrWebConstantUtils.Url.URL_SAAS.contains("https")) {
            builder.hostnameVerifier(new HostnameVerifier() {
                        @Override
                        public boolean verify(String hostname, SSLSession session) {
                            return true;
                        }
                    })
                    .sslSocketFactory(SSLUtils.createSSLSocketFactory());

        }

        mOkHttpClient = builder.build();
    }

    public OkHttpClient getOkHttpClient() {
        return mOkHttpClient;
    }

    private class CommonHeaderInterceptor implements Interceptor {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();

            Request.Builder requestBuilder = request.newBuilder();
            if(!TextUtils.isEmpty(HrWebConstantUtils.AUTHOR_TOKEN)) {
                requestBuilder.addHeader("Authorization", "Bearer " + HrWebConstantUtils.AUTHOR_TOKEN);
            }
            requestBuilder.addHeader("Content-Type", "application/json; charset=utf-8");
            requestBuilder.addHeader("Accept", "application/json; charset=utf-8");
//            requestBuilder.addHeader("Connection", "close");

            return chain.proceed(requestBuilder.build());
        }

    }

    private HttpLoggingInterceptor getHttpLoggingInterceptor(){
        if(!HrLogUtils.DEBUG) {
            return null;
        }

        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                HrLogUtils.d(TAG, message);
            }
        });
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        return loggingInterceptor;
    }

}

和Rxjava相关的用于处理http网络请求的回调接口
HttpCallBack.java

package com.hobot.webserver.library;

import android.text.TextUtils;

import com.hobot.webserver.library.model.BaseResponse;
import com.hobot.webserver.library.model.RespLogin;
import com.hobot.webserver.library.utils.HrWebConstantUtils;
import com.hobot.webserver.library.utils.HrLogUtils;

import java.lang.reflect.ParameterizedType;

import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

/**
 * 用于网络请求数据的返回
 * @param 
 */
public abstract class HttpCallBack implements Observer> {

    private final String TAG = "HttpCallBack";

    public abstract void onSuccess(T t);
    public abstract void onFailure(int code, String msg);

    @Override
    public void onComplete() {

    }

    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onError(Throwable e) {
        onFailure(HrWebConstantUtils.Response.FAILTURE, e.toString());
    }

    @Override
    public void onNext(BaseResponse response) {
        if(response.getCode() != HrWebConstantUtils.Response.SUCCESS) {
            onFailure(response.getCode(), "from onNext");
            return;
        }

        if(TextUtils.isEmpty(HrWebConstantUtils.AUTHOR_TOKEN)) {
            ParameterizedType pt = (ParameterizedType)this.getClass().getGenericSuperclass();
            Class cls = (Class) pt.getActualTypeArguments()[0];
            if(cls.equals(RespLogin.class)) {
                HrWebConstantUtils.AUTHOR_TOKEN = ((RespLogin)response.getData()).getToken();
                HrLogUtils.d(TAG, "AUTHOR_TOKEN = " + HrWebConstantUtils.AUTHOR_TOKEN);
            }
        }

        onSuccess(response.getData());
    }
}

http网络请求结果数据的封装类
BaseResponse.java

package com.hobot.webserver.library.model;

public class BaseResponse {

    private String msg;
    private int code;
    private T data;

    public void setMsg(String msg){
        this.msg = msg;
    }

    public String getMsg(){
        return msg;
    }

    public void setCode(int code){
        this.code = code;
    }

    public int getCode(){
        return code;
    }

    public void setData(T data){
        this.data = data;
    }

    public T getData(){
        return data;
    }

}

用于打印http请求和响应信息的日志类，在Interceptor拦截器中进行调用
HrLogUtils.java

public class HrLogUtils {

    public static final boolean DEBUG = true;

    public static void d(String tag, String msg) {
        if(DEBUG) {
            Log.d(tag, "[HrLogUtils-server]: " + msg);
        }
    }

    public static void e(String tag, String msg) {
        if(DEBUG) {
            Log.e(tag, "[HrLogUtils-server]: " + msg);
        }
    }

    public static void i(String tag, String msg) {
        if(DEBUG) {
            Log.i(tag, "[HrLogUtils-server]: " + msg);
        }
    }

}

Retrofit中用到的BaseUrl等常量类:
HrWebConstantUtils.java

public class HrWebConstantUtils {

    public static String AUTHOR_TOKEN = "";

    public static class Url {
    .....
    .....
    .....
        /** 测试用 */
        public static final String URL_SAAS = "http://xxxx-pexxxx.axxx/api/";
.....
.....
    }

    public static class Response {
        public static final int SUCCESS = 0;
        public static final int FAILTURE = 1;
    }

}

创建网络接口的示例(重点)
IHttpRequest.java

/**
 * 创建 网络请求接口实例
 */
public interface IHttpRequest {

    @POST
    Observable> reqLogin(@Url String url, @Header("Authorization") String author);

    @Headers("Content-Type: application/x-www-form-urlencoded")
    @GET("v1/organization/xxxxx")
    Observable>> reqSections();

    @GET("v1/common/xxxx")
    Observable> reqCommonConfig();

    @POST("v1/ipc/query/xxxx")
    Observable> reqIPCList(@Body RequestBody json);

    @POST("v1/ipc/create/xxxx")
    Observable> reqAddIPC(@Body RequestBody json);

    @GET("v1/organization/xxxx")
    Observable> reqNodeInfo(@Query("node_id") String nodeId);

    @Headers("Content-Type: application/json")
    @GET("v1/member/xxxxx")
    Observable> reqMemberList(
            @Query("node_id") String nodeId,
            @Query("current") int current,
            @Query("page_size") int pageSize,
            @Query("mem_type") String memType);


    @GET("v1/member/xxxxx")
    Observable> reqMemberDetails(
            @Query("member_id") String memId,
            @Query("mem_type") String memType,
            @Query("node_id") String nodeId,
            @Query("current") int current,
            @Query("page_size") int pageSize);

    @Headers("Content-Type: application/json")
    @GET("v1/account/xxxxx")
    Observable> reqAccountnfo();

    @POST("v1/member/xxxxx")
    Observable> reqAddMember(@Body RequestBody json);

    @POST("v1/member/xxxxx")
    Observable> reqUpdateMember(@Body RequestBody json);

    @POST("v1/statistics/xxxxxx")
    Observable> reqArrivalList(@Body RequestBody json);

    @POST("v1/statistics/xxxxx")
    Observable> reqStatisticsTraffics(@Body RequestBody json);

    @POST("v1/statistics/attributes/xxxxx")
    Observable> reqStatisticsAttributes(@Body RequestBody json);
}

发起http请求示例如下：

....
....
....
//发起网络请求
   HttpManager.getInstance().reqMemberDetails(mActivity, memId, memType,nodeId, curPage, pageSize, new HttpCallBack() {
            @Override
            public void onSuccess(RespMemberDetails memDetails) {
            //todo 请求成功
                if (memDetails != null) {
                      mView.loadSuccess(memDetails);                 
                }
                ......
                ......
            }

            @Override
            public void onFailure(int code, String msg) {
            //todo 请求失败
                LogUtils.e(TAG, "msg::" + msg);
                String resMsg = mActivity.getString(R.string.member_query_fail);
                switch (code) {
                    case ERROR_CODE_NO_MEMBER:
                        resMsg = mActivity.getString(R.string.member_not_exist);
                        break;
                    default:
                        mView.loadFailture("");
                        break;
                }
                mView.loadFailture(resMsg);
            }
        });
......
......
.....

好了关于Retrofit+Rxjava就讲这么多。

7.程序崩溃界面处理

一般讲android项目框架搭建的可能会遗漏掉这块。如果项目要上线的话，为了在程序异常崩溃的时候能够让用户选择重启app和反馈，提升用户体验，集成程序崩溃框架—CustomActivityOnCrash还是很有必要的。

关于CustomActivityOnCrash框架的使用，不赘述了。大家可移步：
android程序崩溃框架—CustomActivityOnCrash

好了，一个完整的Android项目从搭建到正式上线，除了以上这些，还包含添加混淆，发布release版本等。

关于混淆,推荐链接:5分钟搞定android混淆

关于发布lelease版本,推荐链接 教你如何使用android studio发布release 版本（完整版）