原本的MVP模式在Presenter中调用Service请求网络数据。这里为了实现数据的缓存，加入Repository模块，Presenter不再直接调用Service请求数据，而是调用Repository获取数据。数据的来源逻辑在Repository中处理，Presenter不知道数据是从网络获取的还是从本地缓存获取的。

流程图：

包结构如下：

BaseMvpView.class：

public interface BaseMvpView {

    Context getContext();
}

BaseMvpPresenter.class：

public abstract class BaseMvpPresenter<T extends BaseMvpView> {

    private WeakReference<T> mViewWeakReference;

    public BaseMvpPresenter(T view) {
        mViewWeakReference = new WeakReference<>(view);
    }

    public T getView() {
        if (mViewWeakReference != null) {
            return mViewWeakReference.get();
        }
        return null;
    }

    public abstract void initData(Bundle bundle);

    public void release() {
        if (mViewWeakReference != null) {
            mViewWeakReference.clear();
            mViewWeakReference = null;
        }
    }
}

BaseMvpActivity.class：

public abstract class BaseMvpActivity<T extends BaseMvpPresenter> extends AppCompatActivity{

    public T mPresenter;

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

        mPresenter = initPresenter();
        mPresenter.initData(getIntent().getExtras());
    }

    public abstract T initPresenter();
}

NetworkBoundResource.class ：

public abstract class NetworkBoundResource<T> {

    public abstract T getFromDb();

    public abstract boolean shouldFetchRemoteSource();

    public abstract T getRemoteSource();

    public abstract void saveRemoteSource(T remoteSource);

    public Observable<T> getAsObservable(){
        return Observable.create(new ObservableOnSubscribe<T>() {
            @Override
            public void subscribe(ObservableEmitter<T> e) throws Exception {
                T localData = getFromDb();
                if (localData != null) {
                    e.onNext(localData);
                }
                if (shouldFetchRemoteSource()) {
                    T remoteData = getRemoteSource();
                    if (remoteData != null) {
                        saveRemoteSource(remoteData);
                        e.onNext(remoteData);
                    }
                }
            }
        });
    }
}

TestRepository.class :

public class TestRepository {

    public static Observable<String> loadData() {

        return new NetworkBoundResource<String>() {

            @Override
            public String getFromDb() {
                return TestCache.getDataFromDb();
            }

            @Override
            public boolean shouldFetchRemoteSource() {
                return false;
            }

            @Override
            public String getRemoteSource() {
                return TestService.getData();
            }

            @Override
            public void saveRemoteSource(String remoteSource) {

            }
        }.getAsObservable();
    }
}

TestView.class :

public interface TestView extends BaseMvpView{

    void refreshUI(String result);
}

TestPresenter.class :

public class TestPresenter extends  BaseMvpPresenter<TestView>{

    public TestPresenter(TestView view) {
        super(view);
    }

    @Override
    public void initData(Bundle bundle) {
        loadData();
    }

    private void loadData() {
        TestRepository.loadData().subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                if (getView() != null) {
                    getView().refreshUI(s);
                }
            }
        });
    }
}

TestActivity.class :

public class TestActivity extends BaseMvpActivity<TestPresenter> implements TestView {

    @Override
    public TestPresenter initPresenter() {
        return new TestPresenter(this);
    }

    @Override
    public void refreshUI(String result) {
    }

    @Override
    public Context getContext() {
        return this;
    }
}