OkHttp的封装

添加依赖：compile 'com.squareup.okhttp3:okhttp:3.8.0'

这次只是简单的封装，介绍封装的流程。

public class OkhttpDemo {

    private  static  OkhttpDemo mInstance;
    private  OkHttpClient mOkHttpClient;
    private Handler mHandler;
    private Gson mGson;


    private  OkhttpDemo(){
        mOkHttpClient = new OkHttpClient();
        // 初始化okhttp 创建一个OKHttpClient对象，一个app里最好实例化一个此对象
        mOkHttpClient.newBuilder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS);
        mHandler = new Handler(Looper.getMainLooper());
        mGson = new Gson();
    }

    public  static OkhttpDemo getInstance(){
        if (mInstance==null){
            synchronized (OkhttpDemo.class){
                if (mInstance==null){
                    mInstance = new OkhttpDemo();
                }
            }
        }
        return mInstance;
    }

    /**
     * 同步psot请求
     * @param url
     * @param params
     * @return Response
     * @throws IOException
     */
    private   Response postSync(String url, Map<String,String> params) throws IOException {
        RequestBody requestBody;
        FormBody.Builder builder = new FormBody.Builder();
        for(Map.Entry<String ,String> map : params.entrySet()){
            String key = map.getKey();
            String value;
            if (map.getValue() == null){
                value = "";
            }else{
                value = map.getValue();
            }
            builder.add(key,value);
        }
        requestBody = builder.build();
        final Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        Call call = mOkHttpClient.newCall(request);
        Response response = call.execute();
        return response;
    }

    private   Response postSync(String url) throws IOException {
        final Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = mOkHttpClient.newCall(request);
        Response response = call.execute();
        return response;
    }

    /**
     * 同步post请求
     * @param url
     * @param params
     * @return String
     * @throws IOException
     */
    public   String postSyncStr(String url, Map<String,String> params) throws IOException {
        Response execute = postSync(url, params);
        return execute.body().string();
    }

    /**
     * 异步post请求
     * @param url
     * @param params
     * @throws IOException
     */
    private  void  postAsync(String url, Map<String,String> params,final DataCallBack callBack) throws IOException {
        RequestBody requestBody;
        FormBody.Builder builder = new FormBody.Builder();
        for(Map.Entry<String ,String> map : params.entrySet()){
            String key = map.getKey();
            String value;
            if (map.getValue() == null){
                value = "";
            }else{
                value = map.getValue();
            }
            builder.add(key,value);
        }
        requestBody = builder.build();
        final Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callBack);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callBack);
            }
        });
    }
    private  void  postAsync(String url, final DataCallBack callBack) throws IOException {
        final Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callBack);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callBack);
            }
        });
    }

    /**
     * 同步get请求
     * @param url
     * @return Response
     * @throws IOException
     */
    private Response getSync(String url) throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient();
        final Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = okHttpClient.newCall(request);
        Response response = call.execute();
        return response;
    }

    /**
     *  同步get请求
     * @param url
     * @param params
     * @return String
     * @throws IOException
     */
    private String getSyncStr(String url, Map<String,String> params) throws IOException {
        Response response = getSync(url);
        return response.body().string();
    }

    /**
     * 异步get请求
     * @param url
     * @param params
     * @throws IOException
     */
    private  void  gettAsync(String url, Map<String,String> params,final DataCallBack callBack) throws IOException {
        RequestBody requestBody;
        FormBody.Builder builder = new FormBody.Builder();
        for(Map.Entry<String ,String> map : params.entrySet()){
            String key = map.getKey();
            String value;
            if (map.getValue() == null){
                value = "";
            }else{
                value = map.getValue();
            }
            builder.add(key,value);
        }
        requestBody = builder.build();
        final  Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callBack);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callBack);
            }
        });
    }

    /**
     *同步post文件上传
     * @param url
     * @param files
     * @param fileKeys
     * @param params
     * @return Response
     * @throws IOException
     */
    private Response filePostloadSync(String url, File[] files,String[] fileKeys,Param... params) throws IOException {
        Request request = buildMultipartForm(url, files, fileKeys, params);
        return mOkHttpClient.newCall(request).execute();
    }
    private Response filePostloadSync(String url, File file, String fileKey) throws IOException
    {
        Request request = buildMultipartForm(url, new File[]{file}, new String[]{fileKey}, null);
        return mOkHttpClient.newCall(request).execute();
    }
    private Response filePostloadSync(String url, File file, String fileKey, Param... params) throws IOException
    {
        Request request = buildMultipartForm(url, new File[]{file}, new String[]{fileKey}, params);
        return mOkHttpClient.newCall(request).execute();
    }

    /**
     * 异步基于post的文件上传
     * @param url
     * @param callback
     * @param files
     * @param fileKeys
     * @param params
     * @throws IOException
     */
    private void filePostLoadAsync(String url,final DataCallBack callback,File[] files, String[] fileKeys, Param... params) throws  IOException{

        final Request request = buildMultipartForm(url,files,fileKeys,params);
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callback);
            }
        });
    }

    /**
     *  异步基于post的文件上传，单文件不带参数上传
     * @param url
     * @param callback
     * @param file
     * @param fileKey
     * @throws IOException
     */
    private void filePostLoadAsync(String url, final DataCallBack callback, File file, String fileKey) throws IOException{
        final Request request = buildMultipartForm(url, new File[]{file}, new String[]{fileKey}, null);
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callback);
            }
        });
    }

    /**
     * 异步基于post的文件上传，单文件且携带其他form参数上传
     * @param url
     * @param callback
     * @param file
     * @param fileKey
     * @param params
     * @throws IOException
     */
    private void filePostLoadAsync (String url, final DataCallBack callback, File file, String fileKey, Param... params) throws IOException{
        final Request request = buildMultipartForm(url, new File[]{file}, new String[]{fileKey}, params);
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String result = response.body().string();
                deliverDataSuccess(result, callback);
            }
        });
    }

    /**
     * 异步下载文件
     * @param url
     * @param destFileDir 本地文件存储的文件夹
     * @param callback
     */
    private void fileDownAsync(final String url, final String destFileDir, final DataCallBack callback) throws IOException{
        final Request request = new Request.Builder()
                .url(url)
                .build();

        final Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                deliverDataFailure(request, e, callback);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                InputStream inputStream =null;
                FileOutputStream fileOutputStream = null;
                byte[] buff = new byte[2048];
                int len = 0;
                try {
                    inputStream = response.body().byteStream();
                    fileOutputStream = new FileOutputStream(new File(destFileDir,getFileName(url)));//下载到
                    while ((len = inputStream.read(buff)) != -1){
                        fileOutputStream.write(buff,0,len);
                    }
                    fileOutputStream.flush();;
                }catch (IOException e){
                    e.printStackTrace();
                    deliverDataFailure(response.request(), e, callback);
                }
               finally {
                    try {
                        if (inputStream !=null){
                            inputStream.close();
                        }
                    }catch (IOException o){

                    }
                    try {
                        if (fileOutputStream != null){
                            fileOutputStream.close();
                        }
                    }catch (IOException o){

                    }
                }
            }
        });
    }

    /**
     * 下载图片
     * @param view
     * @param url
     * @param errorResId
     */
    private void loadImage(final ImageView view, final String url, final int errorResId){

        final Request request = new Request.Builder()
                .url(url)
                .build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                setErrorResId(view, errorResId);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response !=null && response.isSuccessful()){
                    byte[] data = response.body().bytes();
                    final Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                view.setImageBitmap(bitmap);
                            }
                        });
                }
            }
        });

    }
    private void setErrorResId(final ImageView view, final int errorResId)
    {
        mHandler.post(new Runnable()
        {
            @Override
            public void run()
            {
                view.setImageResource(errorResId);
            }
        });
    }
    private String getFileName(String path)
    {
        int separatorIndex = path.lastIndexOf("/");
        return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());
    }

    private Param[] validateParam(Param[] params)
    {
        if (params == null)
            return new Param[0];
        else return params;
    }

    private Request buildMultipartForm(String url, File[] files,
                                              String[] fileKeys, Param[] params)
    {
        params = validateParam(params);

        MultipartBody.Builder builder=  new MultipartBody.Builder().setType(MultipartBody.FORM);
        for (Param param : params)
        {
            builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + param.key + "\""),
                    RequestBody.create(null, param.value));
        }
        if (files != null)
        {
            RequestBody requestBody = null;
            for (int i = 0; i < files.length; i++)
            {
                File file = files[i];
                String fileName = file.getName();
                requestBody = RequestBody.create(MediaType.parse(guessMimeType(fileName)), file);
                //根据文件名设置contentType
                builder.addPart(Headers.of("Content-Disposition",
                        "form-data; name=\"" + fileKeys[i] + "\"; filename=\"" + fileName + "\""),
                        requestBody);
            }
        }

        RequestBody requestBody = builder.build();
        return new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
    }

    private String guessMimeType(String path)
    {
        FileNameMap fileNameMap = URLConnection.getFileNameMap();
        String contentTypeFor = fileNameMap.getContentTypeFor(path);
        if (contentTypeFor == null)
        {
            contentTypeFor = "application/octet-stream";
        }
        return contentTypeFor;
    }
    /**
     * 分发失败的时候调用
     *
     * @param request  request
     * @param e        e
     * @param callBack callBack
     */
    private  void deliverDataFailure(final Request request, final IOException e, final DataCallBack callBack) {
        /**
         * 在这里使用异步处理
         */
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.requestFailure(request, e);
                }
            }
        });
    }

    /**
     * 分发成功的时候调用
     * @param string
     * @param callBack
     */
    private  void deliverDataSuccess(final String   string , final DataCallBack callBack) {
        /**
         * 在这里使用异步线程处理
         */
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    try {
                        callBack.requestSuccess(string);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }



    public static class Param
    {
        public Param()
        {
        }

        public Param(String key, String value)
        {
            this.key = key;
            this.value = value;
        }

        String key;
        String value;
    }

    /**
     * 数据回调接口
     */
    public interface  DataCallBack {

        void requestSuccess(String  result) throws Exception;
        void requestFailure(Request request, IOException e);
    }

    //对外公布方法

    /**
     * 同步psot请求
     * @param url
     * @param params
     * @return Response
     * @throws IOException
     */
    public static Response postSyncT(String url, Map<String,String> params) throws IOException {
        return  getInstance().postSync(url,params);
    }

    /**
     * 同步post请求
     * @param url
     * @param params
     * @return String
     * @throws IOException
     */
    public static String postSyncStrT(String url, Map<String,String> params) throws IOException{
        return getInstance().postSyncStr(url,params);
    }
    /**
     * 异步post请求
     * @param url
     * @param params
     * @throws IOException
     */
    public static void  postAsyncT(String url, Map<String,String> params,final DataCallBack callBack) throws IOException {
        getInstance().postAsync(url,params,callBack);
    }

    /**
     * 同步get请求
     * @param url
     * @return Response
     * @throws IOException
     */
    public static Response getSyncT(String url) throws IOException{
        return getInstance().getSync(url);
    }

    /**
     *  同步get请求
     * @param url
     * @param params
     * @return String
     * @throws IOException
     */
    public static String getSyncStrT(String url, Map<String,String> params) throws IOException{
        return getInstance().getSyncStr(url,params);
    }

    /**
     * 异步get请求
     * @param url
     * @param params
     * @throws IOException
     */
    public  static void  gettAsyncT(String url, Map<String,String> params,final DataCallBack callBack) throws IOException{
        getInstance().gettAsync(url,params,callBack);
    }

    /**
     *同步post文件上传
     * @param url
     * @param files
     * @param fileKeys
     * @param params
     * @return Response
     * @throws IOException
     */
    public static Response filePostloadSyncT(String url, File[] files,String[] fileKeys,Param... params) throws IOException{
        return getInstance().filePostloadSync(url,files,fileKeys,params);
    }

    public static Response filePostloadSyncT(String url, File file, String fileKey) throws IOException{
        return getInstance().filePostloadSync(url,file,fileKey);
    }

    public Response filePostloadSyncT(String url, File file, String fileKey, Param... params) throws IOException{
        return getInstance().filePostloadSync(url,file,fileKey,params);
    }

    /**
     * 异步基于post的文件上传
     * @param url
     * @param callback
     * @param files
     * @param fileKeys
     * @param params
     * @throws IOException
     */
    public static void filePostLoadAsyncT(String url,final DataCallBack callback,File[] files, String[] fileKeys, Param... params) throws  IOException{
        getInstance().filePostLoadAsync(url,callback,files,fileKeys,params);
    }

    /**
     *  异步基于post的文件上传，单文件不带参数上传
     * @param url
     * @param callback
     * @param file
     * @param fileKey
     * @throws IOException
     */
    public static void filePostLoadAsyncT(String url, final DataCallBack callback, File file, String fileKey) throws IOException{
        getInstance().filePostLoadAsync(url,callback,file,fileKey);
    }

    /**
     * 异步基于post的文件上传，单文件且携带其他form参数上传
     * @param url
     * @param callback
     * @param file
     * @param fileKey
     * @param params
     * @throws IOException
     */
    public static void filePostLoadAsyncT (String url, final DataCallBack callback, File file, String fileKey, Param... params) throws IOException{
        getInstance().filePostLoadAsync(url,callback,file,fileKey,params);
    }

    /**
     * 异步下载文件
     * @param url
     * @param destFileDir 本地文件存储的文件夹
     * @param callback
     */
    public static void fileDownAsyncT(final String url, final String destFileDir, final DataCallBack callback) throws IOException{
        getInstance().fileDownAsync(url,destFileDir,callback);
    }

    /**
     * 下载图片
     * @param view
     * @param url
     * @param errorResId
     */
    public static void loadImageT(final ImageView view, final String url, final int errorResId){
        getInstance().loadImage(view,url,errorResId);
    }
}

具体用法

 String url = "xxxxxxxx";//请求的路径
    HashMap<String, String> params = new HashMap<>();
    // 添加请求参数
    params.put("key", "value");
    Response response = OkhttpDemo.postSyncT(url, params);
    OkhttpDemo.postAsyncT(url,params, new OkhttpDemo.DataCallBack() {
        @Override
        public void requestSuccess(String result) throws Exception {

        }

        @Override
        public void requestFailure(Request request, IOException e) {

        }
    });
}

参考 Android OkHttp完全解析 是时候来了解OkHttp了