（自我学习篇）一步一步简单实现一个retrofit+rxjava+mvp来解析一个接口

咱们先来知道一下他们都是做什么和怎么用的

retrofit     一个网络加载框架 里面封装了一个OKhttp，可以这么理解它是一个网络请求的库，直接调用即可，使用需要导一个retrofit的依赖（如下）  就是实现一个api的拼接 可以用get 和post 的用注解的形式来实现的（下面是用的get，前半部分的api通过拼接，当然你也可以不拼接直接把全部接口写在这里也是可以的,接口是网上找的）

//retrofit
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
//gson
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
//rxjava
    compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
//rx安卓
    compile 'io.reactivex:rxandroid:1.2.0'

//retrofit的拼接  接口
public interface RetrofitService {
    @GET("book/search")
    Class<BookBase> getServiceBook(
            @Query("q") String name,
            @Query("tag") String tag,
            @Query("start") int start,
            @Query("count") int count
    );

}

 这是retrofit单独使用的方法

        //此代码是refit单独使用的
        Retrofit build = new Retrofit.Builder()
                .baseUrl("https://api.douban.com/v2/")
                //添加gson的方法
                .addConverterFactory(GsonConverterFactory.create(new                     GsonBuilder().create()))
                //支持rxjava
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();

        //进行拼接
        RetrofitService retrofitService = build.create(RetrofitService.class);
        //传入参数
        Call<BookBase> call = retrofitService.getServiceBook("金瓶梅", null, 0, 1);
       
        call.enqueue(new Callback<BookBase>() {
            @Override
            public void onResponse(Call<BookBase> call, Response<BookBase> response) {
                int total = response.body().getTotal();
                tv.setText(total+"");
            }

            @Override
            public void onFailure(Call<BookBase> call, Throwable t) {

            }
        });

 rxjava  是一个可观察序列来编写异步和基于事件的程序的库

就是一个方便开发的库（这里我是结合retrofit 来使用的）

//
public interface RetrofitService {
    @GET("book/search")
    Observable<BookBase> getServiceBook(
            @Query("q") String name,
            @Query("tag") String tag,
            @Query("start") int start,
            @Query("count") int count
    );

Retrofit build = new Retrofit.Builder()
                .baseUrl("https://api.douban.com/v2/")
                //添加gson的方法
                .addConverterFactory(GsonConverterFactory.create(new GsonBuilder().create()))
                //支持rxjava
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        RetrofitService retrofitService = build.create(RetrofitService.class);
        Observable<BookBase> obseervab = retrofitService.getServiceBook("金瓶梅", null, 0, 1);
                obseervab.subscribeOn(Schedulers.io())//请求数据时间发生在io中
                .observeOn(AndroidSchedulers.mainThread())//请求完成后在主线程更显UI     需要写入rx安卓的依赖
                .subscribe(new Observer<BookBase>() {
                    @Override
                    public void onCompleted() {
//所有事件都完成，可以做些操作。。。
                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                        //请求过程中发生错误
                    }

                    @Override
                    public void onNext(BookBase bookBase) {
                        //实体类
                        int count = bookBase.getCount();
                        tv.setText(count);
                    }
                });

可以对比一下与上面的区别，  一个接口  里面   一个是Class一个是Observable   好像rx越显得比较麻烦了

再说一下这个retrofit+rxjava+mvp  mvp就是通过P层把M层和V层彻底分离  M层（网络请求层）V层（ui层）

具体步骤就是 先从M层 做一个网络请求 直接上代码（可以进行封装的这里为了方便观看没有做太多处理）

//网络请求的方法  
public class RetrofitHelper {
    OkHttpClient client = new OkHttpClient();

    GsonConverterFactory factory = GsonConverterFactory.create(new GsonBuilder().create());

    private static RetrofitHelper instance = null;
    private Retrofit mRetrofit = null;

    //用于获取实例化自身 并且实例化一次
    public static RetrofitHelper getInstance(Context context) {
        if (instance == null) {
            instance = new RetrofitHelper(context);
        }
        return instance;
    }

    private RetrofitHelper(Context mContext) {
        init();
    }

    //初始化
    private void init() {
        resetApp();
    }

    //Retrofit的创建
    private void resetApp() {
        mRetrofit = new Retrofit.Builder()
                .baseUrl("https://api.douban.com/v2/")
                .client(client)
                .addConverterFactory(factory)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
    }

    //实例化 new Retrofit.Builder()
    public RetrofitService getServer() {
        return mRetrofit.create(RetrofitService.class);
    }
}

这里为了方便p层的调用咱把数据请求出来

//让代码的调取更简单
public class DataManager {
    private RetrofitService mRetrofitService;
    //获取helper里面的方法
    public DataManager(Context context) {
      this.mRetrofitService= RetrofitHelper.getInstance(context).getServer();
    }
    //调用接口里面的方法
    public Observable<BookBase> getSearchBooks(String name, String tag, int start, int count) {
        return mRetrofitService.getServiceBook(name, tag, start, count);
    }

}

P层的方法  （1.为了方便使用先创建一个P层的接口）

/**
 * 模仿ac里面的生命周期，方便调用
 */

public interface Presenter {

    void oncreate();

    void onstop();

    void attachview(view view);
}

BookP  的使用

public class BookP implements Presenter {
    Context context;
    private DataManager dataManager;
    private CompositeSubscription compositeSubscription;
    private Bookview mbookview;

    //获取BookP 的上下文
    public BookP(Context context) {
        this.context = context;
    }

    //生命周期的onreate 开始
    @Override
    public void oncreate() {
        dataManager = new DataManager(context);
        //订阅者
        compositeSubscription = new CompositeSubscription();
    }

    //生命周期的onstop  结束
    @Override
    public void onstop() {
        //清除掉订阅关系   防止内存泄漏
        compositeSubscription.unsubscribe();
    }

    //获取view的接口   （传数据）
    @Override
    public void attachview(view view) {
        mbookview = (Bookview) view;
    }

    //创建一个  getSearchBooks 方法  用于传4个回调参数
    public void getSearchBooks(String name, String tag, int start, int count) {
        //rxjava
        compositeSubscription.add(dataManager.getSearchBooks(name,tag,start,count)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<BookBase>() {

                    private BookBase mbookBase;

                    @Override
                    public void onCompleted() {
                        if (mbookBase!=null)
                        {
                            mbookview.onsuess(mbookBase);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                        mbookview.onerror("请求数据错误");
                    }

                    @Override
                    public void onNext(BookBase bookBase) {
                        mbookBase = bookBase;
                    }
                })
        );
    }

}

P层  就是通过 接口给V层请求出来的数据 

//先创建一个空的view 用于与系统的view进行区分
public interface View {
}

 刚在创建P层接口的时候有一个接受view的  就是用来放这个的

//定义一个成功的方发，一个失败的方法
public interface Bookview extends view {
    void onsuess(BookBase bookBase);
    void onerror(String result);
}

在v层

public class MainActivity extends AppCompatActivity {

    private TextView tv;
    private BookP bookP;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.tv);
        bookP = new BookP(this);
        bookP.oncreate();
        bookP.attachview(mbookview);
        bookP.getSearchBooks("金瓶梅",null,0,1);

    }
    //获取bookview厉害从p层取出来的值
    private Bookview mbookview=new Bookview() {
        @Override
        public void onsuess(BookBase bookBase) {
            tv.setText(bookBase.getTotal()+"");
        }

        @Override
        public void onerror(String result) {
            Toast.makeText(MainActivity.this, result+"", Toast.LENGTH_SHORT).show();
        }
    };
//防止内存泄漏
    @Override
    protected void onDestroy() {
        super.onDestroy();
        bookP.onstop();
    }
}

这就是具体的 解析方法