OkHttp下载文件并使用服务器返回的文件名字

开发中有这么个场景,Android端下载文件,文件名字大多数都由我们app端定义,假如说,产品说,为了不让我们客户端写死,可以直接使用服务器返回的文件名字.好那么我们今天来研究一下

看下效果

调用的代码

 OkHttpUtil.donwloadFile("https://d.qiezzi.com/qiezi-clinic.apk", Constant.FileRoot, "", new DonwloadResponseListener() {
            @Override
            public void OnSuccess(long bytesRead, long contentLength, boolean done) {
                pbTestDownload.setProgress((int) ((100 * bytesRead) / contentLength));
            }

            @Override
            public void onfailure() {
                showToast(TestListActivity.this, "下载失败");
            }

            @Override
            public void onSuccess(String fileName) {
                showToast(TestListActivity.this, "下载成功" + fileName);
            }
        });

使用okhttp封装一个下载请求

下载文件工具类

package com.qiezzi.clinic.chengqi.common.net;

import android.content.Context;
import android.content.Intent;
import android.text.TextUtils;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.hyphenate.chat.EMClient;
import com.qiezzi.clinic.QiezziApplication;
import com.qiezzi.clinic.chengqi.common.config.Constant;
import com.qiezzi.clinic.chengqi.common.utils.L;
import com.qiezzi.clinic.chengqi.common.utils.SPUtil;
import com.qiezzi.clinic.chengqi.login.activity.LoginActivity;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.util.concurrent.TimeUnit;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.CertificatePinner;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

/**
 * Created by yukuoyuan on 2017/9/8.
 * 这是一个封装的网络请求
 */
public class OKHttpUtils {
    private static OKHttpUtils sInstance;
    private static final OkHttpClient mOkHttpClient = new OkHttpClient();
    //请求类型
    public static final MediaType mJSON = MediaType.parse("application/json; charset=utf-8");

    private OKHttpUtils() {
        /**
         * 设置连接超时时间为40s
         */
        mOkHttpClient.newBuilder().connectTimeout(40, TimeUnit.SECONDS);
        /**
         * 读取超时时间
         */
        mOkHttpClient.newBuilder().readTimeout(60, TimeUnit.SECONDS);
        /**
         * 写入超时时间
         */
        mOkHttpClient.newBuilder().writeTimeout(60, TimeUnit.SECONDS);
        /**
         * 证书验证
         */
        mOkHttpClient.newBuilder().certificatePinner(new CertificatePinner
                .Builder()
                .add("publicobject.com", "sha256/afwiKY3RxoMmLkuRW1l7QsPZTJPwDS2pdDROQjXw8ig=")
                .build()).build();
    }

    /**
     * 单例模式
     *
     * @return
     */
    public static OKHttpUtils instance() {
        if (sInstance == null) {
            synchronized (OKHttpUtils.class) {
                if (sInstance == null) {
                    sInstance = new OKHttpUtils();
                }
            }
        }
        return sInstance;
    }

    /**
     * 这是一个get请求拼接请求路径的方法
     *
     * @param requestPacket
     * @return
     */
    private static String appendUrl(RequestPacket requestPacket) {
        return requestPacket.url + "?" + appendArguments(requestPacket);
    }

    /**
     * 这是一个拼接get请求请求参数的方法
     *
     * @param requestPacket
     * @return
     */
    private static String appendArguments(RequestPacket requestPacket) {
        String argument = "";
        for (String key : requestPacket.arguments.keySet()) {
            if (requestPacket.getArgument(key) != null) {
                if (argument.equals("")) {
                    argument = key + "=" + requestPacket.getArgument(key);
                } else {
                    argument = argument + "&" + key + "=" + requestPacket.getArgument(key);
                }
            }
        }
        return argument;
    }
    /**
     * 这是一个下载文件的方法
     *
     * @param filepath                 文件路径
     * @param filename                 文件名字
     * @param donwloadResponseListener 回调监听
     */
    public void donwloadFile(final String filepath, RequestPacket requestPacket, final String filename, final DonwloadResponseListener donwloadResponseListener) {
        Request request = null;
        Request.Builder builder = new Request.Builder();
        request = builder.url(appendUrl(requestPacket)).build();
        L.d("下载文件的路径", appendUrl(requestPacket));
        //发送异步请求
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                /**
                 * 失败回调监听
                 */
                QiezziApplication.getMainHandler().post(new Runnable() {
                    @Override
                    public void run() {
                        donwloadResponseListener.onfailure();
                    }
                });
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.code() != 200) {
                    /**
                     * 失败回调监听
                     */
                    QiezziApplication.getMainHandler().post(new Runnable() {
                        @Override
                        public void run() {
                            donwloadResponseListener.onfailure();
                        }
                    });
                    return;
                }
                //将返回结果转化为流，并写入文件
                int len;
                byte[] buf = new byte[2048];
                InputStream inputStream = response.body().byteStream();
                /**
                 * 写入本地文件
                 */
                String responseFileName = getHeaderFileName(response);
                File file = null;
                /**
                 *如果服务器没有返回的话,使用自定义的文件名字
                 */
                if (TextUtils.isEmpty(responseFileName)) {
                    file = new File(filepath + filename);
                } else {
                    file = new File(filepath + responseFileName);
                }
                FileOutputStream fileOutputStream = new FileOutputStream(file);
                while ((len = inputStream.read(buf)) != -1) {
                    fileOutputStream.write(buf, 0, len);
                }
                donwloadResponseListener.onSuccess(file);
                fileOutputStream.flush();
                fileOutputStream.close();
                inputStream.close();
            }

        });
    }

    /**
     * 解析文件头
     * Content-Disposition:attachment;filename=FileName.txt
     * Content-Disposition: attachment; filename*="UTF-8''%E6%9B%BF%E6%8D%A2%E5%AE%9E%E9%AA%8C%E6%8A%A5%E5%91%8A.pdf"
     */
    private static String getHeaderFileName(Response response) {
        String dispositionHeader = response.header("Content-Disposition");
        if (!TextUtils.isEmpty(dispositionHeader)) {
            dispositionHeader.replace("attachment;filename=", "");
            dispositionHeader.replace("filename*=utf-8", "");
            String[] strings = dispositionHeader.split("; ");
            if (strings.length > 1) {
                dispositionHeader = strings[1].replace("filename=", "");
                dispositionHeader = dispositionHeader.replace("\"", "");
                return dispositionHeader;
            }
            return "";
        }
        return "";
    }
}

其他用的类

package com.qiezzi.clinic.chengqi.common.net;

import java.io.File;

/**
 * Created by yukoyuan on 16/7/10.
 * 这是一个下载文件的回调监听
 */
public interface DonwloadResponseListener {
    /**
     * @param bytesRead     已下载字节数
     * @param contentLength 总字节数
     * @param done          是否下载完成
     * @deprecated 计算方式是 (100 * bytesRead) / contentLength
     * 日志为 45%...
     */
    void OnSuccess(long bytesRead, long contentLength, boolean done);

    /**
     * 下载失败的回调方法
     */
    void onfailure();

    /**
     * 这是一个下载成功之后,返回文件路径的方法
     *
     * @param file
     */
    void onSuccess(File file);
}

请求实体类

package com.qiezzi.clinic.chengqi.common.net;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by yukuo on 2016/3/18.
 * 这是一个请求实体类
 */
public class RequestPacket implements Serializable {
    public static final int POST = 1000, GET = 1001;// 定义两个请求类型
    public String url;// 请求的网络地址
    public Map<String, Object> arguments = new HashMap<>();// 请求参数
    public Map<String, String> headers = new HashMap<>();// 请求头
    /**
     * 是否是post请求
     */
    private boolean isPost = false;

    public boolean isPost() {
        return isPost;
    }

    /**
     * 设置是否是post请求
     *
     * @param post
     */
    public void setPost(boolean post) {
        isPost = post;
    }

    /**
     * 这是一个添加请求参数的方法
     *
     * @param key
     * @param value
     */
    public void addArgument(String key, Object value) {
        arguments.put(key, value);
    }

    /**
     * 这是一个添加头信息参数的方法
     *
     * @param key
     * @param value
     */
    public void addHeader(String key, String value) {
        headers.put(key, value);
    }

    /**
     * 这是一个根据键获取参数值得方法
     *
     * @param key
     * @return
     */
    public Object getArgument(String key) {
        return arguments.get(key);
    }

    /**
     * 这是一个根据键获取头信息值得方法
     *
     * @param key
     * @return
     */
    public String getHeader(String key) {
        return headers.get(key);
    }
}