RxJava2和Retrofit2实现简单网络请求

RxJava2和Retrofit2实现简单网络请求

感谢来福岛的一个笑话api
api为：http://api.laifudao.com/open/xiaohua.json

添加依赖

     compile 'io.reactivex.rxjava2:rxjava:+'
     compile 'io.reactivex.rxjava2:rxandroid:+'
     compile 'com.squareup.retrofit2:retrofit:+'
     compile 'com.squareup.retrofit2:converter-gson:+'
     compile 'com.squareup.retrofit2:adapter-rxjava2:+'
     compile 'com.squareup.okhttp3:logging-interceptor:+'
     compile 'com.squareup.okhttp3:okhttp:+'
     compile 'com.jakewharton:butterknife:+'
     annotationProcessor 'com.jakewharton:butterknife-compiler:+'

构建HttpMethods

public class HttpMethods {
    
    

    private static final HttpMethods httpMethods = new HttpMethods();

    private static Retrofit retrofit;

    private static RetrofitService service = null ;

    private static final int TIME_OUT=4;



    /**
     * 私有化构造方法
     */
    private HttpMethods(){
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                Log.d("HttpLog",message);
            }
        });
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        OkHttpClient okHttpClient = new OkHttpClient();
        okHttpClient
                .newBuilder()
                .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                .addInterceptor(loggingInterceptor);

        retrofit = new Retrofit.Builder()
                .baseUrl("http://api.laifudao.com/open/")
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
    }

    public static HttpMethods getHttpMethods (){
        return httpMethods;
    }


    /**
     * 提供接口，获取RetrofitService
     * @return
     */
    public static RetrofitService getRetrofit(){
        if (service==null){
            service = retrofit.create(RetrofitService.class);
        }
        return service;
    }

}

RetrofitService

public interface RetrofitService {
    
    
    @GET("xiaohua.json")
    Observable<List<MyJoke>> getData();
}

实体类

public class MyJoke {
    
    

    private String title;
    private String content;
    private String poster;
    private String url;

    @Override
    public String toString() {
        return "MyJoke{" +
                "title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", poster='" + poster + '\'' +
                ", url='" + url + '\'' +
                '}';
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getPoster() {
        return poster;
    }

    public void setPoster(String poster) {
        this.poster = poster;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

MainActivity

public class MainActivity extends AppCompatActivity {
    
    
    @BindView(R.id.text)
    TextView text;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);


        /**
         *   在RxJava中，Scheduler相当于线程控制器，可以通过它来指定每一段代码运行的线程。
         * RxJava已经内置了几个Scheduler：
         *   Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的Scheduler。
         *   Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
         *   Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的Scheduler。行为模式和newThread()差不多，
         * 区别在于io()的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下io()比newThread()更有效率。
         * 不要把计算工作放在io()中，可以避免创建不必要的线程。
         *   Schedulers.computation(): 计算所使用的Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，
         * 例如图形的计算。这个Scheduler使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在computation()中，否则 I/O 操作的等待时间会浪费 CPU。
         *   AndroidSchedulers.mainThread()，Android专用线程，指定操作在主线程运行。
         *   参考自：http://www.jianshu.com/p/856297523728
         */
        HttpMethods.getRetrofit().getData()
                .subscribeOn(Schedulers.io()) //指定subscribe()订阅所发生的线程，即 call() 执行的线程。或者叫做事件产生的线程
                .unsubscribeOn(Schedulers.io())//设置解除订阅在哪个调度器，即线程
                .observeOn(AndroidSchedulers.mainThread())
                /*指定Observer所运行在的线程，即onNext()执行的线程。或者叫做事件消费的线程。
                  AndroidSchedulers.mainThread() Android专用线程，指定操作在主线程运行*/
                .subscribe(new Observer<List<MyJoke>>() {
                    Disposable d;

                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        this.d=d;
                    }

                    @Override
                    public void onNext(@NonNull List<MyJoke> myJokes) {
                        text.setText(myJokes.get(0).toString());
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        d.dispose();//解除订阅
                    }

                    @Override
                    public void onComplete() {
                        d.dispose();
                    }
                });

    }

}