Retrofit2+RXJava1（操作符篇）

最新推荐文章于 2025-06-18 12:51:34 发布

原创最新推荐文章于 2025-06-18 12:51:34 发布 · 589 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#rxjava #retrofit2 #retrofit-上传文件

Android 同时被 2 个专栏收录

20 篇文章

订阅专栏

java

8 篇文章

订阅专栏

本文详细介绍RxJava和Retrofit的结合使用方法，包括版本声明、Retrofit接口注解及应用场景、基本用法，以及RxJava的操作符使用技巧。同时，还提供了网络请求的实际案例，如GET、POST请求，单文件和多文件上传等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一：rxjava和retrofit版本gradle声明

//引入rxjava
compile 'io.reactivex:rxjava:1.2.0'
compile 'io.reactivex:rxandroid:1.2.1'
//引入retrofit
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'

二：熟悉一下retrofit接口的几种注解及使用场景：

1.@path：URL中有参数

2.@query：参数在URL问号之后，（get请求）

3.@queryMap：相当于多个@Query，（对于get请求）

4.@Field：用于POST请求，提交单个数据（post请求）

5.@body：相当于多个@Field，以对象的形式提交（post请求）

6.@Multipart：用于单多文件上传（post请求）

三：retrofit的接口基本用法

//get基本使用

@GET("/user/getUser")
Observable<ResponseBody> getData(@Query("id") String id);

@GET("{url}")
Observable<ResponseBody> executeGet( @Path("url") String url, @QueryMap Map<String, String> maps);

//post基本使用

@POST("{url}")
Observable<ResponseBody> executePost(@Path("url") String url, @FieldMap Map<String, String> maps);

四：rxjava的相关使用方法（主要看变换操作符的灵活使用）：

操作符的区别：

>1. from和just的区别：在变换和订阅过程中，from会依次传递结果，而just会一次性传递整个结果，from（List<Object> Object）会依次传递每一个object对象，而just（List<Object> Object）会传递整个list，然而对于just（Object object1，Object object2）会先传递object1，再传递object2

 >2. 不完整回调Action0和Action1的区别：一个有返回参数，一个没有,Action0相当于subscribe将onCompleted()方法打包的接口对象，而Action1相当于subscribe将onNext(Object o)方法打包的接口

 >3. filter的用法，过滤一些数据：通过filter（new Function1）在call方法中返回过滤的对象

 >4. map和flatMap：map是针对一对一的对应关系，而flatmap是针对一对一、一对多的对应关系。

1.基本使用

private void basicUse() {
        //创建观察者
        Subscriber subscriber = new Subscriber<String>() {

            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.e(TAG, "basicUse: " + s);

            }
        };
        //创建被观察者
        Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("第一个");
                subscriber.onNext("第二个");
                subscriber.onNext("第三个");
                subscriber.onCompleted();
            }

        });
        observable.subscribe(subscriber);
    }

2.from的使用


public void fromUse() {
        //创建观察者
        Subscriber subscriber = new Subscriber<UserModel>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(UserModel user) {
                Log.e(TAG, "fromUse: " + user.getName() + "," + user.getSex());

            }
        };
        String[] words = {"hello", "rxjava"};
        List<UserModel> list = new ArrayList<>();
        list.add(new UserModel("boy", "男"));
        list.add(new UserModel("girl", "女"));
        Observable observable = Observable.from(list);
        observable.subscribe(subscriber);
    }

3.just的使用

public void justUse() {
        //创建观察者
        Subscriber subscriber = new Subscriber<List<UserModel>>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(List<UserModel> users) {
                for (UserModel model : users) {
                    Log.e(TAG, "justUse: " + model.getName() + "," + model.getSex());
                }

            }
        };
        String[] words = {"hello", "rxjava"};
        List<UserModel> list = new ArrayList<>();
        list.add(new UserModel("boy", "男"));
        list.add(new UserModel("girl", "女"));
        Observable observable = Observable.just(list);
        observable.subscribe(subscriber);
    }

4.interval的使用

private void intervalUse() {
        //interval的用法,定时器的
        Observable observable = Observable.interval(2, TimeUnit.SECONDS);
        observable.subscribe(new Action1<Long>() {
            @Override
            public void call(Long s) {
                Log.e(TAG, "intervalUse: " + s.intValue());

            }
        });
    }

5.range的使用

private void rangeUse() {
        //range的用法
        Observable observable = Observable.range(1, 10).repeat(2);
        observable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG, "rangeUse: " + integer.intValue());
            }
        });
    }

6.filter的使用

public void filter() {
        Observable.just(1, 2, 3, 4).filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer i) {
                return i > 2;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e(TAG, "filter:" + "i=" + integer);
            }
        });
    }

7.map的使用

private void mapUse() {
        List<UserModel> list = new ArrayList<>();
        list.add(new UserModel("boy", "男"));
        list.add(new UserModel("girl", "女"));
        Observable observable = Observable.from(list);
        observable.map(new Func1<UserModel, String>() {
            @Override
            public String call(UserModel user) {
                return user.getName();
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.e(TAG, "mapUse: " + s);
            }
        });
    }

8.flatmap的使用

private void justFlatMapUse() {
        List<UserModel> list = new ArrayList<>();
        list.add(new UserModel("boy", "男"));
        list.add(new UserModel("girl", "女"));
        Observable observable = Observable.just(list);
        observable.flatMap(new Func1<List<UserModel>, Observable<?>>() {
            @Override
            public Observable<?> call(List<UserModel> users) {
                return Observable.from(users);
            }
        }).cast(UserModel.class).subscribe(new Action1<UserModel>() {
            @Override
            public void call(UserModel user) {
                Log.e(TAG, "justFlatMapUse: " + user.getName());

            }
        });
    }

9.from配合Flatmap的使用

private void fromFlatMapUse() {
        List<UserModel> list = new ArrayList<>();
        list.add(new UserModel("boy", "男"));
        list.add(new UserModel("girl", "女"));
        Observable observable = Observable.from(list);
        observable.flatMap(new Func1<UserModel, Observable<String>>() {
            @Override
            public Observable<String> call(UserModel user) {
                return Observable.just("名称：" + user.getName());
            }
        }).cast(String.class).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e(TAG, "fromFlatMapUse: " + s);

            }
        });
    }

五：rxjava配合retrofit的相关使用：

1.接口使用

//接口部分
 @GET("user/getAllUser")
 Observable<List<User>> getAllUser();
 
//调用
private void initData() {
        ApiClient.getApiService().getAllUser()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<User>>() {
                    @Override
                    public void call(List<User> users) {
                        String content = users.get(0).getUserName() + "," + users.get(0).getPassword();
                        Log.e(TAG, "onNext: " + content);
                        contextTv.setText("内容为：" + content);
                    }
                });
    }

2.单文件上传使用

//接口部分，，part
@Multipart
@POST("upload/uploadOneFile")
Observable<HttpResult<Void>> uploadOnePic(@Part("file\"; filename=\"avatar.png\"") RequestBody file);
//调用
public void uploadOneFile(String path) {
        //单个文件上传，也可以通过多文件上传partMap的方式
        File file = new File(path);
        RequestBody requestBody = RequestBody.create(MediaType.parse("image/*"), file);
        ApiClient.getApiService().uploadOnePic(requestBody)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<HttpResult<Void>>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError: " + e.getMessage());

                    }

                    @Override
                    public void onNext(HttpResult<Void> result) {
                        Toast.makeText(LocalServerFileUploadActivity.this,"单个文件上传成功",Toast.LENGTH_LONG).show();
                        Log.e(TAG, "单个文件上传:" + result.getMessage() + " " + result.getResultCode());

                    }
                });
    }

3.多文件上传使用（当然也同样适用于单文件上传）

//接口部分
@Multipart
@POST("upload/uploadMultiFile")
Observable<HttpResult<Void>> uploadMultiPic(@PartMap Map<String, RequestBody> params);
//调用
public void uploadMultiFile(List<File> files) {
        //组装partMap对象
        Map<String, RequestBody> partMap = new HashMap<>();
        for (File file : files) {
            RequestBody fileBody = RequestBody.create(MediaType.parse("image/*"), file);
            String fileName = "image_" + System.currentTimeMillis() + "." + file.getPath().split("\\.")[1];
            partMap.put("file\"; filename=\"" + fileName + "\"", fileBody);
        }
        ApiClient.getApiService().uploadMultiPic(partMap)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<HttpResult<Void>>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError: " + e.getMessage());

                    }

                    @Override
                    public void onNext(HttpResult<Void> result) {
                        Toast.makeText(LocalServerFileUploadActivity.this,"多个文件上传成功",Toast.LENGTH_LONG).show();
                        Log.e(TAG, "多个文件上传:" + result.getMessage() + " " + result.getResultCode());

                    }
                });
    }

最后，网络请求框架有很多，okhttp、volley、xutils、nohttp等等都是很不错的框架。当然retrofit和rxjava相信大家多多少少都了解一些了，强大的注解库，链式的请求方式，任意地切换线程，每个人都有一套自己的学习总结，当然我也不例外。我会不断地完善rxjava和retrofit的用法，也希望大家多提建议。