RxJava ＋ OkHttp

最新推荐文章于 2024-03-22 08:54:46 发布
最新推荐文章于 2024-03-22 08:54:46 发布
阅读量382 收藏 1
点赞数
1.MainActivity 
package com.bwie.rxjavaonedemo;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import rx.Emitter;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * // 1.RxJava观察者模式
 * // 2.链式调用
 * // 3.非常灵活的线程调度，异步任务框架
 * // 4.灵活的操作符
 */
public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "MainActivity";
    // 被观察者创建的3种方式
    private Button btnJust;
    private Button btnFrom;
    private Button btnCreate;
    // 观察者创建的方式

    private Button btnObserver;
    private Button btnSubscribe;
    private Button btnAction0;
    private Button btnAction1;
    private Button btnAction2;

    // 线程调度
    private Button btnSubscribeOn;
    private Button btnObserveOn;
    private Button btnReal;

    // 操作符
    private Button btnMap;
    private Button btnFlatMap;


    private Subscription subscribe;


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

        // 被观察者
        btnJust = (Button) findViewById(R.id.btn_rx_just);
        btnFrom = (Button) findViewById(R.id.btn_rx_from);
        btnCreate = (Button) findViewById(R.id.btn_rx_create);
        btnJust.setOnClickListener(this);
        btnFrom.setOnClickListener(this);
        btnCreate.setOnClickListener(this);


        // 观察者
        btnObserver = (Button) findViewById(R.id.btn_rx_observer);
        btnSubscribe = (Button) findViewById(R.id.btn_rx_subscriber);
        btnAction0 = (Button) findViewById(R.id.btn_rx_action0);
        btnAction1 = (Button) findViewById(R.id.btn_rx_action1);
        btnAction2 = (Button) findViewById(R.id.btn_rx_action2);

        btnObserver.setOnClickListener(this);
        btnSubscribe.setOnClickListener(this);
        btnAction0.setOnClickListener(this);
        btnAction1.setOnClickListener(this);
        btnAction2.setOnClickListener(this);

        // 线程调度
        btnSubscribeOn = (Button) findViewById(R.id.btn_rx_subscribe_on);
        btnObserveOn = (Button) findViewById(R.id.btn_rx_observe_on);
        btnReal = (Button) findViewById(R.id.btn_rx_real);
        btnSubscribeOn.setOnClickListener(this);
        btnObserveOn.setOnClickListener(this);
        btnReal.setOnClickListener(this);


        // 操作符
        btnMap = (Button) findViewById(R.id.btn_rx_map);
        btnFlatMap = (Button) findViewById(R.id.btn_rx_flat_map);
        btnMap.setOnClickListener(this);
        btnFlatMap.setOnClickListener(this);

        Log.i(TAG, "onCreate: " + Thread.currentThread().getName() + " id:"
                + Thread.currentThread().getId());


    }


    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_rx_just:
                // 被观察者创建方式1
                Observable observable1 = Observable.just(1, 2, 3, 4);
                break;
            case R.id.btn_rx_from:
                // 被观察者创建方式2
                String[] strs = {"hello", "world", "android"};

                Observable observable2 = Observable.from(strs);

                break;

            case R.id.btn_rx_create:
                // 被观察者第3种创建方式
                Observable<String> observable3 = Observable.create(new Observable.OnSubscribe<String>() {

                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        subscriber.onNext("Hello");
                        subscriber.onNext("world");
                        subscriber.onNext("android");
                        subscriber.onNext("java");
                        subscriber.onCompleted();
                    }
                });
//
//                observable3.subscribeOn(AndroidSchedulers.mainThread())
//                        .observeOn(Schedulers.io())
//                        .subscribe(new Observer() {
//                            @Override
//                            public void onCompleted() {
//
//                            }
//
//                            @Override
//                            public void onError(Throwable e) {
//
//                            }
//
//                            @Override
//                            public void onNext(Object o) {
//                                Log.i(TAG, "onNext: " + o);
//                            }
//                        });
                break;


            case R.id.btn_rx_observer:
                Observable<Integer> observable4 = Observable.just(1, 2, 3, 4);

                // 第一种观察者创建方式
                Observer observer1 = new Observer<Integer>() {

                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.i(TAG, "onNext: " + integer);
                    }
                };

                // 语法上是被观察者订阅观察者，实际上是观察者订阅被观察者，为了方便语法上的链式调用
                observable4.subscribe(observer1);
                break;

            case R.id.btn_rx_subscriber:
                Observable<Integer> observable5 = Observable.just(1, 2, 3, 4);
                // 第二种观察者创建方式
                Subscriber<Integer> subscriber = new Subscriber<Integer>() {

                    @Override
                    public void onStart() {
                        super.onStart();
                    }

                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.i(TAG, "onNext: " + integer);
                    }
                };
                observable5.subscribe(subscriber);
                break;

            case R.id.btn_rx_action0:
                Observable<Integer> observable6 = Observable.just(1, 2, 3, 4);

                // 观察者第三种创建方式
                Action1<Integer> action1 = new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: " + integer);
                    }
                };

                observable6.subscribe(action1);
                break;
            // 闭包
            case R.id.btn_rx_action1:
                Observable<Integer> observable7 = Observable.create(new Observable.OnSubscribe<Integer>() {

                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        subscriber.onNext(3);
                        subscriber.onNext(4);
                        subscriber.onError(new Throwable("这是一条错误信息"));
                    }
                });
                Action1<Integer> action11 = new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: " + integer);
                    }
                };

                Action1<Throwable> action12 = new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e(TAG, "call: " + throwable.getMessage());
                    }
                };
                observable7.subscribe(action11, action12);
                break;

            case R.id.btn_rx_action2:
                Observable<Integer> observable8 = Observable.create(new Observable.OnSubscribe<Integer>() {

                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        subscriber.onNext(3);
                        subscriber.onNext(4);
                        // onCompleted和onError只能执行一个
                        subscriber.onCompleted();
//                        subscriber.onError(new Throwable("这是一条错误信息"));
                    }
                });
                Action1<Integer> action21 = new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: " + integer);
                    }
                };

                Action1<Throwable> action22 = new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e(TAG, "call: " + throwable.getMessage());
                    }
                };

                Action0 action20 = new Action0() {
                    @Override
                    public void call() {
                        Log.i(TAG, "call: onComplete");
                    }
                };
                observable8.subscribe(action21, action22, action20);
                break;

            case R.id.btn_rx_subscribe_on:
                Log.i(TAG, "click thread name: " + Thread.currentThread().getName());
                Observable.create(new Observable.OnSubscribe<Integer>() {

                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        Log.i(TAG, "create call: " + Thread.currentThread().getName());
                        Log.i(TAG, "create call: " + Thread.currentThread().getId());
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        subscriber.onNext(3);
                        subscriber.onNext(4);
                        subscriber.onCompleted();
                    }
                })
                        .subscribeOn(Schedulers.io())
                        .map(new Func1<Integer, String>() {
                            @Override
                            public String call(Integer integer) {
                                Log.i(TAG, "map call: " + Thread.currentThread().getName());
                                Log.i(TAG, "map call: " + Thread.currentThread().getId());
                                return String.valueOf(integer);
                            }
                        })
                        .subscribeOn(Schedulers.newThread())
//                        .subscribeOn(Schedulers.io())
//                        .subscribeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<String>() {
                            @Override
                            public void call(String integer) {
                                Log.i(TAG, "subscribe thread name: " + Thread.currentThread().getName());
                                Log.i(TAG, "subscribe thread id: " + Thread.currentThread().getId());
                                Log.i(TAG, "call: " + integer);
                            }
                        });

                break;
            case R.id.btn_rx_observe_on:
                Log.i(TAG, "click thread name: " + Thread.currentThread().getName());
                Observable
                        .create(new Observable.OnSubscribe<Integer>() {

                            @Override
                            public void call(Subscriber<? super Integer> subscriber) {
                                Log.i(TAG, "create call: " + Thread.currentThread().getName());
                                Log.i(TAG, "create call: " + Thread.currentThread().getId());
                                subscriber.onNext(1);
                                subscriber.onNext(2);
                                subscriber.onNext(3);
                                subscriber.onNext(4);
                                subscriber.onCompleted();
                            }
                        })

//                        .subscribeOn(Schedulers.io())
//                        .observeOn(Schedulers.newThread())
                        // 执行subscribeOn所有之前的操作所在的线程，只生效一次
                        .subscribeOn(Schedulers.newThread())
                        // observeOn每做一次就执行一次线程切换，下一个操作符的线程
                        .observeOn(Schedulers.io())
                        .map(new Func1<Integer, String>() {
                            @Override
                            public String call(Integer integer) {
                                Log.i(TAG, "map call: " + Thread.currentThread().getName());
                                Log.i(TAG, "map call: " + Thread.currentThread().getId());
                                return String.valueOf(integer);
                            }
                        })

                        .observeOn(AndroidSchedulers.mainThread())

//                        .subscribeOn(Schedulers.io())
//                        .subscribeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<String>() {
                            @Override
                            public void call(String integer) {
                                Log.i(TAG, "subscribe thread name: " + Thread.currentThread().getName());
                                Log.i(TAG, "subscribe thread id: " + Thread.currentThread().getId());
                                Log.i(TAG, "call: " + integer);
                            }
                        });

                break;
            case R.id.btn_rx_real:
                subscribe = Observable.create(new Observable.OnSubscribe<Integer>() {


                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(2);
                        subscriber.onNext(4);
                        subscriber.onNext(5);
                        subscriber.onNext(6);
                        subscriber.onCompleted();
                    }
                })
                        .delay(3, TimeUnit.SECONDS)
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Integer>() {
                            @Override
                            public void call(Integer integer) {
                                Log.i(TAG, "call: " + integer);
                            }
                        });

                break;

            case R.id.btn_rx_map:
                Observable.just(1, 2, 3, 4)
                        // 变换操作
                        .map(new Func1<Integer, Student>() {
                            @Override
                            public Student call(Integer integer) {
                                Student stu = new Student();
                                stu.setId(integer);
                                stu.setOrderName("序号为" + integer);
                                return stu;
//                                return "这是第" + integer + "个数据";
                            }
                        })
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Student>() {
                            @Override
                            public void call(Student stu) {
                                Log.i(TAG, "call: id is" + stu.getId());
                                Log.i(TAG, "call: ordername is" + stu.getOrderName());
                            }
                        });
                break;
            case R.id.btn_rx_flat_map:
//                List<>
                List<Student> stus = initData();
                Observable.from(stus)
                        // 平铺
                        .flatMap(new Func1<Student, Observable<Score>>() {
                            @Override
                            public Observable<Score> call(Student student) {
                                List<Score> scores = student.getScores();
                                return Observable.from(scores);
                            }
                        })
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Score>() {
                            @Override
                            public void call(Score score) {
                                Log.i(TAG, "call: " + score.getThoeryScore());
                            }
                        });

                break;
        }

    }

    private List<Student> initData() {
        List<Student> stus = new ArrayList<>();

        List<Score> scores1 = new ArrayList<>();
        Score score1 = new Score(10, 20);
        Score score2 = new Score(20, 30);
        Score score3 = new Score(30, 40);
        scores1.add(score1);
        scores1.add(score2);
        scores1.add(score3);
        stus.add(new Student(1, "a1", scores1));

        List<Score> scores2 = new ArrayList<>();
        Score score21 = new Score(30, 10);
        Score score22 = new Score(40, 30);
        Score score23 = new Score(30, 40);
        scores2.add(score21);
        scores2.add(score22);
        scores2.add(score23);
        stus.add(new Student(2, "a2", scores2));

        List<Score> scores3 = new ArrayList<>();
        Score score31 = new Score(40, 20);
        Score score32 = new Score(0, 30);
        Score score33 = new Score(30, 90);
        scores3.add(score31);
        scores3.add(score32);
        scores3.add(score33);
        stus.add(new Student(3, "a3", scores3));

        return stus;

    }

    @Override
package com.bwie.rxjavaonedemo;

import java.util.List;

/**
 * Created by WuXirui
 * Create Time: 2017/12/4
 * Description:
 */

public class Student {
    private int id;
    private String orderName;
    private List<Score> scores;

    public Student() {
    }

    public Student(int id, String orderName, List<Score> scores) {
        this.id = id;
        this.orderName = orderName;
        this.scores = scores;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public List<Score> getScores() {
        return scores;
    }

    public void setScores(List<Score> scores) {
        this.scores = scores;
    }
}



protected void onDestroy() { super.onDestroy(); // 当Activity销毁的时候取消订阅时间，防止内存泄漏 if (subscribe != null) { if (subscribe.isUnsubscribed()) { subscribe.unsubscribe(); } } }}



2.Student







package com.bwie.rxjavaonedemo;

import java.util.List;

/**
 * Created by WuXirui
 * Create Time: 2017/12/4
 * Description:
 */

public class Student {
    private int id;
    private String orderName;
    private List<Score> scores;

    public Student() {
    }

    public Student(int id, String orderName, List<Score> scores) {
        this.id = id;
        this.orderName = orderName;
        this.scores = scores;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
package com.bwie.rxjavaonedemo;

import java.util.List;

import retrofit2.Call;
import retrofit2.http.GET;
import rx.Observable;

/**
 * Created by WuXirui
 * Create Time: 2017/12/5
 * Description:
 */

public interface ApiService {
    @GET("product/getCatagory")
    Observable<MessageBean<List<Category>>> getCatagory();
}



this.orderName = orderName; } public List<Score> getScores() { return scores; } public void setScores(List<Score> scores) { this.scores = scores; }}



3.ApiService



package com.bwie.rxjavaonedemo;

import java.util.List;

import retrofit2.Call;
import retrofit2.http.GET;
import rx.Observable;

/**
 * Created by WuXirui
 * Create Time: 2017/12/5
 * Description:
 */

public interface ApiService {
    @GET("product/getCatagory")
    Observable<MessageBean<List<Category>>> getCatagory();
}

4.Score


package com.bwie.rxjavaonedemo;

/**
 * Created by WuXirui
 * Create Time: 2017/12/4
 * Description:
 */

public class Score {
    private int thoeryScore;
    private int scaleScore;

    public Score() {
    }

    public Score(int thoeryScore, int scaleScore) {
        this.thoeryScore = thoeryScore;
        this.scaleScore = scaleScore;
    }

    public int getThoeryScore() {
        return thoeryScore;
    }

    public void setThoeryScore(int thoeryScore) {
        this.thoeryScore = thoeryScore;
    }

    public int getScaleScore() {
        return scaleScore;
    }

    public void setScaleScore(int scaleScore) {
        this.scaleScore = scaleScore;
    }
}



















































































































































































                

        

        

    




    

      

        

            

              
                
                  LXYNLYXY
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
OKHttp + RxJava请求数据

				
			

			

				

					南城一点风雨的博客
				

				

					11-05
					
					2046
					
				

			

		

		

			
				
很多人对于现在的网络请求需求都非常不一样，下面我给大家介绍一种网络请求的一种方式：OKHttp+ RxJava
OKHttp本身就是用来请求网络数据的，前面封装的OK处理异步用的是Handler对象，这篇文章就是将Handler替换成了最近使用的一种处理异步的框架RxJava
具体使用
1.添加依赖
RxJava的依赖：

compile 'io.reactivex:rxjava:1.

			
		

	



                

              
                



	

		

			

				
					
OkHttp、rxJava、Retrofit联合网络请求，太完整了

					
最新发布

				
			

			

				

					2401_83974345的博客
				

				

					03-29
					
					944
					
				

			

		

		

			
				
最后我想说：对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，

			
		

	



                


  
              

                


	

		

			

				
					
OKHttp+RxJava+RxAndroid MVP详解

				
			

			

				

					听海的博客
				

				

					06-06
					
					1937
					
				

			

		

		

			
				
Android开发中常用的技术架构有三种，MVC，MVP，MVVM。具体讲解1. MVC M：Model：模型层主要用来获取数据，数据的来源包括接口获取，数据库获取，SharedPreferences获取等等途径。并将其解析成Bean对象回调给Controller层。 V：View：视图层主要用来绘制各个视图，即Activity/Fragment对应的布局XML文件。 C：Controller：控制层主要接收Model层的回调，控制View层的显示。

			
		

	





	

		

			

				
					
Okhttp网络请求+Rxjava

				
			

			

				

					wanghuan3825393的博客
				

				

					11-08
					
					345
					
				

			

		

		

			
				
我们要需要的依赖和相关的导的依赖这次全部发出来！compile 'com.nostra13.universalimageloader:universal-image-loader:1.9.5'
compile 'com.android.support:recyclerview-v7:26.0.0-alpha1'
compile 'com.squareup.retrofit2:retrofit:2.

			
		

	



		

			
		



	

		

			

				
					
RXJava3+OKHTTP3+Retrofit2（观察者设计模式）讲解+实战

				
			

			

				

					m0_58764843的博客
				

				

					11-15
					
					3998
					
				

			

		

		

			
				
RX Java3+OKHTTP3+Retrofit2（观察者设计模式）讲解+实战

			
		

	





	

		

			

				
					
Android 网络请求：OkHttp + Retrofit + RxJava 工具类详解

				
			

			

				

					weixin_51522235的博客
				

				

					11-18
					
					1828
					
				

			

		

		

			
				
Android 网络请求：OkHttp + Retrofit + RxJava 工具类详解

			
		

	





	

		

			

				
					
RXjava加okhttp 请求请求网络数据

				
			

			

				

					W2316的博客
				

				

					11-01
					
					648
					
				

			

		

		

			
				
有很多方式
实现我介绍Rxjava 加上Okhttp的请求方式
首先我们需要导入依赖
compile 'io.reactivex:rxjava:1.0.10'
    compile 'io.reactivex:rxandroid:1.2.0'
    compile 'com.google.code.gson:gson:2.8.2'
    compile 'com.squareup.ok

			
		

	





	

		

			

				
					
RxJava+Retrofit+OkHttp实现多文件下载之断点续传

				
			

			

				

					08-28
				

			

		

		

			
				
RxJava+Retrofit+OkHttp实现多文件下载之断点续传  本篇文章主要介绍了使用RxJava、Retrofit和OkHttp实现多文件下载之断点续传的技术。断点续传下载一直是移动开发中必不可少的一项重要的技术，通过RxJava和Retrofit...

			
		

	





	

		

			

				
					
RxJava+Retrofit+OkHttp实现文件上传

				
			

			

				

					08-28
				

			

		

		

			
				
RxJava+Retrofit+OkHttp实现文件上传  RxJava是一种基于观察者模式的响应式编程库，Retrofit是一个基于OkHttp的HTTP客户端库，OkHttp是一个高效的HTTP客户端库。今天，我们将学习如何使用RxJava、Retrofit和OkHttp来...

			
		

	





	

		

			

				
					
Android retrofit+rxjava+okhttp 学习案例

				
			

			

				

					09-25
				

			

		

		

			
				
在Android开发中，Retrofit、RxJava和OkHttp是三个非常重要的库，它们共同构建了高效、简洁的网络请求框架。下面将详细讲解这三个库及其结合使用的知识点。  **Retrofit** 是一个由Square公司开发的Android和Java...

			
		

	





	

		

			

				
					
rxjava+retrofit+okhttp实现网络请求

				
			

			

				

					12-24
				

			

		

		

			
				
rxjava+retrofit+okhttp网络封装请求，完整代码包。。。

			
		

	





	

		

			

				
					
深入浅出RxJava+Retrofit+OkHttp网络请求

				
			

			

				

					01-05
				

			

		

		

			
				
浅谈RxJava+Retrofit+OkHttp 封装使用 之前发出后收到很多朋友的关注，原本只是自己学习后的一些经验总结，但是有同学运用到实战当中，这让我很惶恐，所有后续一直更新了很多次版本，有些地方难免有所变动导致之前的博客有所出入，正好最近受到掘金邀请内测博客，所以决定重新写一版，按照最后迭代完成的封装详细的讲述一遍，欢迎大家关注！

注意：由于本章的特殊性，后续文章比较长而且复杂，涉及内容也很多，所以大家准备好茶水，前方高能预警。
简介：
Retrofit: Retrofit是Square 公司开发的一款正对Android 网络请求的框架。底层基于OkHttp 实现，OkHttp 已经

			
		

	





	

		

			

				
					
RxHttp:对RxJava2+Retrofit2+OkHttp3的封装

				
			

			

				

					05-28
				

			

		

		

			
				
RxHttp对RxJava2+Retrofit2+OkHttp3的封装，优雅实现接口请求和文件下载功能简介网络请求（RxRequest）支持监听请求声明周期，如开始结束和网络错误支持多BaseUrl，可针对不同请求重定向支持针对不同请求设置不同...

			
		

	





	

		

			

				
					
RxJava+Retrofit+okhttp上传图片给后台

				
			

			

				

					12-08
				

			

		

		

			
				
本知识点将详细介绍如何利用RxJava、Retrofit和OkHttp这三个强大的库来实现图片上传到后端服务器的功能。  首先，`RxJava`是一个响应式编程库，它提供了一种优雅的方式来处理异步操作和事件流。通过观察者模式，它...

			
		

	





	

		

			

				
					
Retrofit+OKHttp+RxJava的使用

				
			

			

				

					N_Y_S的博客
				

				

					08-12
					
					1058
					
				

			

		

		

			
				
响应式编程是一种基于异步数据 流概念的编程模式。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一 条流合并为一条新的流。RxJava 是一种响应式编程，来创建基于事件的异步操作库。基于事件流的链式调用、逻辑清晰简洁。RxJava 我的理解是将事件从起点（上游）流向终点（下游），中间有很多卡片对数据进操作并传 递，每个卡片获取上一个卡片传递下来的结果然后对事件进行处理然后将结果传递给下一个卡片， 这样事件就从起点通过卡片一次次传递直到流向终点。...

			
		

	





	

		

			

				
					
Retrofit-+-RxJava-＋-OkHttp-让网络请求变的简单-封装篇

				
			

			

				

					I8929545452_VD的博客
				

				

					03-22
					
					1151
					
				

			

		

		

			
				
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司19年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。

			
		

	





	

		

			

				
					
Android 网络框架黄金搭档 OkHttp+Retrofit+RxJava2

				
			

			

				

					m0_57487205的博客
				

				

					05-17
					
					1456
					
				

			

		

		

			
				
一、前言

    在APP开发中基本都需要进行网络请求，从而实现客户端与服务端进行数据交换，提到网络请求可能你第一个想到的就是Okhttp,Okhttp是由Square公司开源的网络请求框架，可以代替传统的HttpUrlConnection实现网络请求。而Retrofit实际上是对Okhttp的进行了二次封装，Okhttp与Retrofit，RxJava2这两个框架的结合可是可以实现数据的快速解析，直接转成我们的JavaBean。接下来我们通过写一个简单的Demo研究一下这个黄金搭档的用法。

二...

			
		

	





	

		

			

				
					
网络连接框架 OKHTTP Retrofit RxJAVA

				
			

			

				

					suiyue010211的博客
				

				

					08-12
					
					1189
					
				

			

		

		

			
				
同步需要开启线程，异步不需要开启线程同步和异步都需要跳转到UI线程修改UIRxJava 是一种响应式编程，来创建基于事件的异步操作库。基于事件流的链式调用、逻辑清晰简 洁。RxJava 我的理解是将事件从起点（上游）流向终点（下游），中间有很多卡片对数据进操作并传 递，每个卡片获取上一个卡片传递下来的结果然后对事件进行处理然后将结果传递给下一个卡片， 这样事件就从起点通过卡片一次次传递直到流向终点。......

			
		

	





	

		

			

				
					
网络请求--RXJava+okhttp 进行网络下载操作

				
			

			

				

					yoyo_0316的博客
				

				

					05-15
					
					4021
					
				

			

		

		

			
				
下载文件（实时返回下载进度）

RxJava中的事件源（被观察者）：这里配合OkHttp进行进行网络操作，


File path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
File file = new File(path,"/okhttpdownload");
/**
 * ...

			
		

	





	

		

			

				
					
RxJava2 + Retrofit2 + OKHttp post请求

				
			

			

				

					06-12
				

			

		

		

			
				
使用RxJava2 + Retrofit2 + OKHttp进行POST请求，可以按照以下步骤进行：  1. 添加依赖  在项目的build.gradle文件中添加以下依赖：  ``` dependencies {  implementation 'io.reactivex.rxjava2:rxjava:2.2.19'  ...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值