使用Retrofit2.0上传文件，可以监听上传进度[客户端+服务器端代码]

最新推荐文章于 2022-11-20 10:29:13 发布

microhex

最新推荐文章于 2022-11-20 10:29:13 发布

阅读量1w

点赞数 4

分类专栏： android进阶

本文链接：https://blog.csdn.net/u013762572/article/details/51824645

版权

android进阶专栏收录该内容

53 篇文章 1 订阅

订阅专栏

闲话少说啊，最近项目随大流，用上了传说中的Retrofit进行网络交互，个人负责的模块上有个检测文件上传的进度【这里吐槽一下砸门办公室的网速真TM差，真想把PM打一顿】。以前使用的XUtils中有个方法自带了上传回调的方法，现在用了这个Retrofit，虽说网上有些人说过怎么检测，但大多没有什么代码，按照他们的说法，我好像没成功，自己来吧。对于Retrofit2.0本屌丝也是个新手，有些地方刚开始学习，大神勿喷。

服务器端代码

这个比较简单，由于是从web端转Android的，使用了servelt接收上传文件即可，主要是使用了apache的两个文件处理包：commons-fileupload-1.2.1.jar，commons-io-1.4.jar，具体代码如下：在文章末尾会有war代码链接：

public class UploadFileServlet extends HttpServlet {

    private static final long serialVersionUID = -3926471828171571807L;

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        // 创建文件项目工厂对象
        DiskFileItemFactory factory = new DiskFileItemFactory();

        // 设置文件上传路径
        String upload = this.getServletContext().getRealPath("/");
        // 获取系统默认的临时文件保存路径，该路径为Tomcat根目录下的temp文件夹
        String temp = System.getProperty("java.io.tmpdir");
        // 设置缓冲区大小为 5M
        factory.setSizeThreshold(1024 * 1024 * 5);
        // 设置临时文件夹为temp
        factory.setRepository(new File(temp));
        // 用工厂实例化上传组件,ServletFileUpload 用来解析文件上传请求
        ServletFileUpload servletFileUpload = new ServletFileUpload(factory);

        // 解析结果放在List中
        try {
            List<FileItem> list = servletFileUpload.parseRequest(request);

            for (FileItem item : list) {
                String name = item.getFieldName();
                InputStream is = item.getInputStream();

                System.out.println( "the current name is " + name);

                if (name.contains("file")) {
                    try {
                        inputStream2File(is,upload + "\\" + System.currentTimeMillis() + item.getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }else {
                        String key  = item.getName() ;
                        String value = item.getString() ;
                        System.out.println(key + "---" + value);
                }
            }

            out.write("success");
        } catch (FileUploadException e) {
            e.printStackTrace();
            out.write("failure");
        }

        out.flush();
        out.close();
    }

    // 流转化成字符串
    public static String inputStream2String(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int i = -1;
        while ((i = is.read()) != -1) {
            baos.write(i);
        }
        return baos.toString();
    }

    // 流转化成文件
    public static void inputStream2File(InputStream is, String savePath)
            throws Exception {
        System.out.println("the file path is  :" + savePath);
        File file = new File(savePath);
        InputStream inputSteam = is;
        BufferedInputStream fis = new BufferedInputStream(inputSteam);
        FileOutputStream fos = new FileOutputStream(file);
        int f;
        while ((f = fis.read()) != -1) {
            fos.write(f);
        }
        fos.flush();
        fos.close();
        fis.close();
        inputSteam.close();

    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doPost(req, resp) ;
    }

大部分代码都有注释，相信大家基本能看懂，如果只是针对Android开发，这段可以不看，毕竟现在php也很牛逼，实现相应的功能也不算是大问题。

Android端代码

由于对Retrofit也是接触不久，很多知识点不是特别懂，为此将自己的步骤记录一下：
1.gradle配置：

    compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'
    compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4'
    compile 'com.squareup.okhttp3:logging-interceptor:3.1.2'
    compile 'io.reactivex:rxandroid:1.1.0'

2.编写Retrofit帮助类：

public class RetrofitUtil {

    public static Retrofit retrofit;
    private static OkHttpClient okHttpClient = new OkHttpClient();

    static {
        //设定连接时间为5s
        okHttpClient.newBuilder().connectTimeout(5000, TimeUnit.MILLISECONDS);
        //设置log配置
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
    }

    public static <T> T createService(Class<T> clazz) {
        if (retrofit == null) {
            synchronized (RetrofitUtil.class) {
                Retrofit.Builder builder = new Retrofit.Builder();
                //此处是本人的Tomcat服务器，在使用时应该换成自己的
                retrofit = builder.baseUrl("http://192.168.100.104:8080/UploadFileServer/")
                        .client(okHttpClient)
                        .addConverterFactory(GsonConverterFactory.create())
                        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                        .build();
            }
        }
        return retrofit.create(clazz);
    }
}

3.编写网络请求接口：

public interface UploadService {

    @POST("upload")
    @Multipart
    Observable<ResponseBody> uploadFileInfo(@QueryMap Map<String, String> options,
                                            @PartMap Map<String, RequestBody> externalFileParameters) ;

}

4.分析上传进度:
在retrofit上传文件中，都需要将file转换成RequestBody，一般都是这样：

RequestBody body = RequestBody.create(MediaType.parse("multipart/form-data"), file) ;

刚开始的思路是使用Retrofit.addConverterFactory() 一直去找相应的转换器，后来发现了一个google官方的下载监听的类：
ChunkingConverter，自己也仿了一个，但是发现没什么卵用，尼玛那方法它就是不走，走不通啊，咋办了，后来还是把眼镜瞄在了RequestBody上面了，想到你RequestBody上传时肯定会写数据流吧，那好吧，我就包装一个RequestBody试试，代码如下：
首先发个上传监听接口：

public interface ProgressListener {
        void onProgress(long hasWrittenLen, long totalLen, boolean hasFinish);
    }

现在是RequestBody的包装类：

public class UploadFileRequestBody extends RequestBody {

    private RequestBody mRequestBody;
    private ProgressListener mProgressListener;

    private BufferedSink bufferedSink;


    public UploadFileRequestBody(File file , ProgressListener progressListener) {
        this.mRequestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file) ;
        this.mProgressListener = progressListener ;
    }

    public UploadFileRequestBody(RequestBody requestBody, ProgressListener progressListener) {
        this.mRequestBody = requestBody;
        this.mProgressListener = progressListener;
    }

    //返回了requestBody的类型，想什么form-data/MP3/MP4/png等等等格式
    @Override
    public MediaType contentType() {
        return mRequestBody.contentType();
    }

    //返回了本RequestBody的长度，也就是上传的totalLength
    @Override
    public long contentLength() throws IOException {
        return mRequestBody.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        if (bufferedSink == null) {
            //包装
            bufferedSink = Okio.buffer(sink(sink));
        }
        //写入
        mRequestBody.writeTo(bufferedSink);
        //必须调用flush，否则最后一部分数据可能不会被写入
        bufferedSink.flush();
    }

    private Sink sink(Sink sink) {
        return new ForwardingSink(sink) {
            //当前写入字节数
            long bytesWritten = 0L;
            //总字节长度，避免多次调用contentLength()方法
            long contentLength = 0L;

            @Override
            public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);
                if (contentLength == 0) {
                    //获得contentLength的值，后续不再调用
                    contentLength = contentLength();
                }
                //增加当前写入的字节数
                bytesWritten += byteCount;
                //回调上传接口
                mProgressListener.onProgress(bytesWritten, contentLength, bytesWritten == contentLength);
            }
        };
    }

好了，基本的类都介绍完了，看看我们的MainActivity：

public class MainActivity extends AppCompatActivity {

    UploadImageView uploadImageView ;

    String picPath = Environment.getExternalStorageDirectory() + "/test.jpg"  ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });

        initViews();
    }

    private void initViews() {
        uploadImageView = (UploadImageView) findViewById(R.id.iv_image);
        uploadImageView.setImageBitmap(BitmapFactory.decodeFile(picPath));
    }

    public void uploadFile(View v) {
        File file = new File(picPath);
        UploadService uploadFileService = RetrofitUtil.createService(UploadService.class);
        Map<String, String> optionMap = new HashMap<>();
        optionMap.put("Platformtype", "Android");
        optionMap.put("userName","zhangsan") ;

        Map<String, RequestBody> requestBodyMap = new HashMap<>();
        UploadFileRequestBody fileRequestBody = new UploadFileRequestBody(file, new DefaultProgressListener(mHandler,1));
        requestBodyMap.put("file\"; filename=\"" + file.getName(), fileRequestBody);

        uploadFileService.uploadFileInfo(optionMap, requestBodyMap).
                subscribeOn(Schedulers.io()).
                observeOn(AndroidSchedulers.mainThread()).
                subscribe(new Subscriber<ResponseBody>() {
                    @Override
                    public void onCompleted() {}

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("---the error is ---" + e);
                    }

                    @Override
                    public void onNext(ResponseBody s) {
                        try {
                            System.out.println("---the next string is --" + s.string());
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.arg1) {
                case 1:
                    if (msg.what > 0) {
                        uploadImageView.updatePercent(msg.what);
                    }
                    break;
            }
        }
    };

对应的layout为：

这里写代码片<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    app:layout_behavior="@string/appbar_scrolling_view_behavior"
    tools:context="micro.com.knight.uploadfilebyretrofit.MainActivity"
    tools:showIn="@layout/activity_main">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/btn"
        android:onClick="uploadFile"
        android:text="uploadFile" />

    <micro.com.knight.uploadfilebyretrofit.view.UploadImageView
        android:layout_below="@id/btn"
        android:id="@+id/iv_image"
        android:layout_width="300dp"
        android:layout_height="250dp" />

</RelativeLayout>