Retrofit2 & RxJava2实现单文件和多文件上传

水深无声 2022-06-09 11:13 469阅读 0赞

> Retrofit2 是目前Android开发主流的网络库，RxJava2也是目前开发者使用的比较多用来更优雅实现异步的库，因为最近业务需求有用到这两个库，就简单分享下它的一个实际使用场景—上传文件

*   *  集成RxJava2和Retrofit2
     *  封装OkHttpManager类
     *  封装RetrofitClient类
     *  定义上传文件接口
     *  构造MultipartBody
     *  自定义RequestBody
     *  具体使用方法
     *  总结

## 集成RxJava2和Retrofit2 ##

// Rx
        compile rootProject.ext.dependencies["rxjava"]
        compile rootProject.ext.dependencies["rxandroid"]
        compile rootProject.ext.dependencies["rxpermissions"]
    
        // network
        compile rootProject.ext.dependencies["retrofit"]
        compile rootProject.ext.dependencies["retrofit-converter-gson"]
        compile rootProject.ext.dependencies["retrofit-adapter-rxjava2"]
        compile rootProject.ext.dependencies["logging-interceptor"]

上面我将依赖统一抽取出来了，也建议大家这样做。

具体配置文件在根目录下的config.gradle

ext {
        android = [
                compileSdkVersion: 25,
                buildToolsVersion: '25.0.3',
                applicationId    : "com.tencent.bugly",
                minSdkVersion    : 16,
                targetSdkVersion : 25,
                javaVersion      : JavaVersion.VERSION_1_7,
                versionCode      : 1,
                versionName      : "1.0.0"
        ]
    
    
        def dependVersion = [
                rxJava             : "2.0.7",
                rxandroid          : "2.0.1",
                rxpermissions      : "0.9.3@aar",
                retrofit           : "2.2.0",
                okhttp3            : "3.4.1",
        ]
    
        dependencies = [
                // rx
                "rxjava"                            : "io.reactivex.rxjava2:rxjava:${dependVersion.rxJava}",
                "rxandroid"                         : "io.reactivex.rxjava2:rxandroid:${dependVersion.rxandroid}",
                "rxpermissions"                     : "com.tbruyelle.rxpermissions2:rxpermissions:${dependVersion.rxpermissions}",
    
                // network
                "retrofit"                          : "com.squareup.retrofit2:retrofit:${dependVersion.retrofit}",
                "retrofit-converter-gson"           : "com.squareup.retrofit2:converter-gson:${dependVersion.retrofit}",
                "retrofit-adapter-rxjava2"          : "com.squareup.retrofit2:adapter-rxjava2:${dependVersion.retrofit}",
                // 网络日志拦截
                "logging-interceptor"               : "com.squareup.okhttp3:logging-interceptor:${dependVersion.okhttp3}",
        ]
    }

这是依赖的部分，集成之后会从maven仓库中将我们需要的库下载到本地，这样我就可以使用了 ，不用说，这些大家都懂。

## 封装OkHttpManager类 ##

/** * OkHttp管理类. * * @author devilwwj * @since 2017/7/12 */
    public class OkHttpManager { 
    
        private static OkHttpClient okHttpClient;
    
        /** * 获取OkHttp单例，线程安全. * * @return 返回OkHttpClient单例 */
        public static OkHttpClient getInstance() {
            if (okHttpClient == null) {
                synchronized (OkHttpManager.class) {
                    if (okHttpClient == null) {
                        OkHttpClient.Builder builder = new OkHttpClient.Builder();
    
                        if (BuildConfig.DEBUG) {
                            // 拦截okHttp的日志，如果开启了会导致上传回调被调用两次
                            HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
                            interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                            builder.addInterceptor(interceptor);
                        }
    
                        // 超时时间
                        builder.connectTimeout(15, TimeUnit.SECONDS);// 15S连接超时
                        builder.readTimeout(20, TimeUnit.SECONDS);// 20s读取超时
                        builder.writeTimeout(20, TimeUnit.SECONDS);// 20s写入超时
                        // 错误重连
                        builder.retryOnConnectionFailure(true);
                        okHttpClient = builder.build();
                    }
                }
            }
            return okHttpClient;
        }
    }

这个类主要是获取OkHttpClient示例，设置它的一些参数，比如超时时间，拦截器等等.

## 封装RetrofitClient类 ##

/** * RetrofitClient. * * @author devilwwj * @since 2017/7/12 */
    public class RetrofitClient { 
        private static RetrofitClient mInstance;
        private static Retrofit retrofit;
    
        private RetrofitClient() {
            retrofit = RetrofitBuilder.buildRetrofit();
        }
    
        /** * 获取RetrofitClient实例. * * @return 返回RetrofitClient单例 */
        public static synchronized RetrofitClient getInstance() {
            if (mInstance == null) {
                mInstance = new RetrofitClient();
            }
            return mInstance;
        }
    
        private <T> T create(Class<T> clz) {
            return retrofit.create(clz);
        }
    
        /** * 单上传文件的封装. * * @param url 完整的接口地址 * @param file 需要上传的文件 * @param fileUploadObserver 上传回调 */
        public void upLoadFile(String url, File file,
                        FileUploadObserver<ResponseBody> fileUploadObserver) {
    
            UploadFileRequestBody uploadFileRequestBody =
                            new UploadFileRequestBody(file, fileUploadObserver);
    
            create(UploadFileApi.class)
                            .uploadFile(url, MultipartBuilder.fileToMultipartBody(file,
                                            uploadFileRequestBody))
                            .subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
                            .subscribe(fileUploadObserver);
    
        }
    
        /** * 多文件上传. * * @param url 上传接口地址 * @param files 文件列表 * @param fileUploadObserver 文件上传回调 */
        public void upLoadFiles(String url, List<File> files,
                        FileUploadObserver<ResponseBody> fileUploadObserver) {
    
            create(UploadFileApi.class)
                            .uploadFile(url, MultipartBuilder.filesToMultipartBody(files,
                                            fileUploadObserver))
                            .subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
                            .subscribe(fileUploadObserver);
    
        }
    
    }

这个是Retrofit客户端类，获取它的单例然后去调用它的上传文件的方法，可以看到我这里封装了两个方法，uploadFile是上传单个文件，uploadFiles方法上传多个文件.

因为我们需要构造一个Retrofit对象，所以这里有一个RetrofitBuilder类：

/** * Retrofit构造器. * * @author devilwwj * @since 2017/7/13 */
    public class RetrofitBuilder { 
        private static Retrofit retrofit;
    
        public static synchronized Retrofit buildRetrofit() {
            if (retrofit == null) {
                Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
                GsonConverterFactory gsonConverterFactory = GsonConverterFactory.create(gson);
                retrofit = new Retrofit.Builder().client(OkHttpManager.getInstance())
                        .baseUrl(AppConfig.HTTP_SERVER)
                        .addConverterFactory(gsonConverterFactory)
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        .build();
            }
            return retrofit;
        }
    }

可以看到，想构造Retrofit对象是需要获取OkhttpClient实例的。

## 定义上传文件接口 ##

/** * 上传API. * * @author devilwwj * @since 2017/7/12 */
    public interface UploadFileApi { 
        String UPLOAD_FILE_URL = AppConfig.HTTP_SERVER + "file/upload";
    
        @POST
        Observable<ResponseBody> uploadFile(@Url String url, @Body MultipartBody body);
    }

这里就是Retrofit定义接口的形式，通过注解来表示各个参数，@POST表示发起post请求，@Url表示这是个请求地址，@Body表示这是请求体，关于Retrofit的各种注解的使用这里不多说，大家可以自行了解。

## 构造MultipartBody ##

上一步定义好了上传的接口，我们最终是要去构造MultipartBody，这一块就需要跟后台同学进行沟通了，根据接口定义来实现，这里是我们的实现：

/** * MultipartBuilder. * * @author devilwwj * @since 2017/7/13 */
    public class MultipartBuilder { 
    
        /** * 单文件上传构造. * * @param file 文件 * @param requestBody 请求体 * @return MultipartBody */
        public static MultipartBody fileToMultipartBody(File file, RequestBody requestBody) {
            MultipartBody.Builder builder = new MultipartBody.Builder();
    
            JsonObject jsonObject = new JsonObject();
            jsonObject.addProperty("fileName", file.getName());
            jsonObject.addProperty("fileSha", Utils.getFileSha1(file));
            jsonObject.addProperty("appId", "test0002");
    
            builder.addFormDataPart("file", file.getName(), requestBody);
    
            builder.addFormDataPart("params", jsonObject.toString());
            builder.setType(MultipartBody.FORM);
            return builder.build();
        }
    
        /** * 多文件上传构造. * * @param files 文件列表 * @param fileUploadObserver 文件上传回调 * @return MultipartBody */
        public static MultipartBody filesToMultipartBody(List<File> files,
                        FileUploadObserver<ResponseBody> fileUploadObserver) {
            MultipartBody.Builder builder = new MultipartBody.Builder();
            JsonArray jsonArray = new JsonArray();
    
            Gson gson = new Gson();
            for (File file : files) {
                UploadFileRequestBody uploadFileRequestBody =
                                new UploadFileRequestBody(file, fileUploadObserver);
                JsonObject jsonObject = new JsonObject();
    
                jsonObject.addProperty("fileName", file.getName());
                jsonObject.addProperty("fileSha", Utils.getFileSha1(file));
                jsonObject.addProperty("appId", "test0002");
    
                jsonArray.add(jsonObject);
                LogUtil.d(jsonObject.toString());
                builder.addFormDataPart("file", file.getName(), uploadFileRequestBody);
            }
    
            builder.addFormDataPart("params", gson.toJson(jsonArray));
    
            LogUtil.d(gson.toJson(jsonArray));
            builder.setType(MultipartBody.FORM);
            return builder.build();
        }
    
    }

## 自定义RequestBody ##

构造MultipartBody是需要去创建每个文件对应的ReqeustBody，但我们这边需要监听到文件上传成功、失败和进度的状态，所以需要去自定义：

/** * 上传文件请求body. * * @author devilwwj * @since 2017/7/12 */
    public class UploadFileRequestBody extends RequestBody { 
    
        private RequestBody mRequestBody;
        private FileUploadObserver<ResponseBody> fileUploadObserver;
    
        public UploadFileRequestBody(File file, FileUploadObserver<ResponseBody> fileUploadObserver) {
            this.mRequestBody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
            this.fileUploadObserver = fileUploadObserver;
        }
    
    
        @Override
        public MediaType contentType() {
            return mRequestBody.contentType();
        }
    
        @Override
        public long contentLength() throws IOException {
            return mRequestBody.contentLength();
        }
    
        @Override
        public void writeTo(BufferedSink sink) throws IOException {
    
            CountingSink countingSink = new CountingSink(sink);
            BufferedSink bufferedSink = Okio.buffer(countingSink);
            // 写入
            mRequestBody.writeTo(bufferedSink);
            // 刷新
            // 必须调用flush，否则最后一部分数据可能不会被写入
            bufferedSink.flush();
    
        }
    
        /** * CountingSink. */
        protected final class CountingSink extends ForwardingSink { 
    
            private long bytesWritten = 0;
    
            public CountingSink(Sink delegate) {
                super(delegate);
            }
    
            @Override
            public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);
    
                bytesWritten += byteCount;
                if (fileUploadObserver != null) {
                    fileUploadObserver.onProgressChange(bytesWritten, contentLength());
                }
    
            }
    
        }
    }

这里有个RxJava2的Observer的抽象类，主要是用来收到Rxjava2的事件：

/** * 上传文件的RxJava2回调. * * @author devilwwj * @since 2017/7/12 * * @param <T> 模板类 */
    public abstract class FileUploadObserver<T> extends DefaultObserver<T> {
    
        @Override
        public void onNext(T t) {
            onUploadSuccess(t);
        }
    
        @Override
        public void onError(Throwable e) {
            onUploadFail(e);
        }
    
        @Override
        public void onComplete() {
    
        }
    
        // 上传成功的回调
        public abstract void onUploadSuccess(T t);
    
        // 上传失败回调
        public abstract void onUploadFail(Throwable e);
    
        // 上传进度回调
        public abstract void onProgress(int progress);
    
        // 监听进度的改变
        public void onProgressChange(long bytesWritten, long contentLength) {
            onProgress((int) (bytesWritten * 100 / contentLength));
        }
    }

ok，到现在完整的代码实现已经说完。

## 具体使用方法 ##

RetrofitClient.getInstance().upLoadFiles(UploadFileApi.UPLOAD_FILE_URL, files,
                    new FileUploadObserver<ResponseBody>() {
                        @Override
                        public void onUploadSuccess(ResponseBody responseBody) {
    
                            if (responseBody == null) {
                                LogUtil.e("responseBody null");
                                return;
                            }
    
                            try {
                                JSONObject jsonObject = new JSONObject(responseBody.string());
    
                                ArrayList<String> fileIds = new ArrayList<String>();
                                fileIds.add(jsonObject.getString("fileId"));
    
                            } catch (IOException e) {
                                e.printStackTrace();
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
    
                        }
    
                        @Override
                        public void onUploadFail(Throwable e) {
                        }
    
                        @Override
                        public void onProgress(int progress) {
                            LogUtil.d(String.valueOf(progress));
                        }
                    });

笔者这里是上传到文件服务器，成功会返回对应的fileId。

## 总结 ##

通篇代码实现很多，但可以看到使用Retrofit2和RxJava2的结合起来使用还是挺方便的，再也不用自己去控制线程的切换了，也不用去关注http的具体实现，少写了不少代码，实现起来也优雅不少，希望这篇文章能帮助到大家。