精华内容
下载资源
问答
  • 包含了okHttp3所有的网络请求方式,包括了,文件,字符串,Json,添加消息头,数组等请求参数,包含了get和post请求
  • OkHttp3封装网络请求框架 网络请求是开发中最基础的功能,框架原生API不便于复用。今天在这里分享慕课一位老师基于OkHttp封装的一思路,希望对大家有帮助。 首先,我们看一下Okhttp的基本使用 发送异步GET请求 1、...

    OkHttp3封装网络请求框架

    网络请求是开发中最基础的功能,框架原生API不便于复用。今天在这里分享慕课一位老师基于OkHttp封装的一个思路,希望对大家有帮助。

    首先,我们看一下Okhttp的基本使用

    发送异步GET请求
    1、new OkHttpClient;
    2、构造Request对象;
    3、通过前两步中的对象构建Call对象;
    4、通过Call.enqueue(Callback)方法来提交异步请求;

    String url = "http://wwww.baidu.com";
    OkHttpClient okHttpClient = new OkHttpClient();
    final Request request = new Request.Builder()
            .url(url)
            .get()//默认就是GET请求,可以不写
            .build();
    Call call = okHttpClient.newCall(request);
    call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            Log.d(TAG, "onFailure: ");
        }
    
        @Override
        public void onResponse(Call call, Response response) throws IOException {
            Log.d(TAG, "onResponse: " + response.body().string());
        }
    });
    

    一个简单的get请求需要使用这么多代码,还有post请求?文件上传下载等等?

    所以在实际开发中,完全不会这么用,原因如下:
    1、代码冗余,几乎不可复用
    2、一旦底层API改动,所有上层的网络请求代码度需要改动
    3、没有进行封装

    所以我们必须对OKhttp进行封装,如何封装那?

    封装思路

    img

    主要分为3部分的封装:
    1、Request的封装

    请求参数
    url
    请求对象
    2、OKhttp核心封装

    发送请求
    配置相关参数
    HTTPS的支持
    3、Callback的封装

    处理回调函数
    异常处理
    转发消息到我们的UI线程
    讲json转化为实体对象

    Request的封装

    封装所有的请求参数到hashmap中

    import java.io.FileNotFoundException;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @author vision
     * 封装所有的请求参数到hashmap中
     */
    public class RequestParams {
    
        public ConcurrentHashMap<String, String> urlParams = new ConcurrentHashMap<String, String>();
        public ConcurrentHashMap<String, Object> fileParams = new ConcurrentHashMap<String, Object>();
    
        /**
         * Constructs a new empty {@code RequestParams} instance.
         */
        public RequestParams() {
            this((Map<String, String>) null);
        }
    
        /**
         * Constructs a new RequestParams instance containing the key/value string
         * params from the specified map.
         *
         * @param source the source key/value string map to add.
         */
        public RequestParams(Map<String, String> source) {
            if (source != null) {
                for (Map.Entry<String, String> entry : source.entrySet()) {
                    put(entry.getKey(), entry.getValue());
                }
            }
        }
    
        /**
         * Constructs a new RequestParams instance and populate it with a single
         * initial key/value string param.
         *
         * @param key   the key name for the intial param.
         * @param value the value string for the initial param.
         */
        public RequestParams(final String key, final String value) {
            this(new HashMap<String, String>() {
                {
                    put(key, value);
                }
            });
        }
    
        /**
         * Adds a key/value string pair to the request.
         *
         * @param key   the key name for the new param.
         * @param value the value string for the new param.
         */
        public void put(String key, String value) {
            if (key != null && value != null) {
                urlParams.put(key, value);
            }
        }
    
        public void put(String key, Object object) throws FileNotFoundException {
    
            if (key != null) {
                fileParams.put(key, object);
            }
        }
    
        public boolean hasParams() {
            if(urlParams.size() > 0 || fileParams.size() > 0){
    
                return true;
            }
            return false;
        }
    
    
    

    生成request对象

    import java.io.File;
    import java.util.Map;
    
    import okhttp3.FormBody;
    import okhttp3.Headers;
    import okhttp3.MediaType;
    import okhttp3.MultipartBody;
    import okhttp3.Request;
    import okhttp3.RequestBody;
    
    /**
     * @author vision
     * @function build the request
     * 生成request对象
     */
    public class CommonRequest {
        /**
         * create the key-value Request
         *
         * @param url
         * @param params
         * @return
         */
        public static Request createPostRequest(String url, RequestParams params) {
            return createPostRequest(url, params, null);
        }
    
        /**可以带请求头的Post请求
         * @param url
         * @param params
         * @param headers
         * @return
         */
        public static Request createPostRequest(String url, RequestParams params, RequestParams headers) {
            //添加请求体
            FormBody.Builder mFormBodyBuild = new FormBody.Builder();
            if (params != null) {
                for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                    mFormBodyBuild.add(entry.getKey(), entry.getValue());
                }
            }
            //添加请求头
            Headers.Builder mHeaderBuild = new Headers.Builder();
            if (headers != null) {
                for (Map.Entry<String, String> entry : headers.urlParams.entrySet()) {
                    mHeaderBuild.add(entry.getKey(), entry.getValue());
                }
            }
            FormBody mFormBody = mFormBodyBuild.build();
            Headers mHeader = mHeaderBuild.build();
    
    
            Request request = new Request.Builder().url(url).
                    post(mFormBody).
                    headers(mHeader)
                    .build();
            return request;
        }
    
        /**
         * ressemble the params to the url
         *
         * @param url
         * @param params
         * @return
         */
        public static Request createGetRequest(String url, RequestParams params) {
    
            return createGetRequest(url, params, null);
        }
    
        /**
         * 可以带请求头的Get请求
         * @param url
         * @param params
         * @param headers
         * @return
         */
        public static Request createGetRequest(String url, RequestParams params, RequestParams headers) {
            StringBuilder urlBuilder = new StringBuilder(url).append("?");
            if (params != null) {
                for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                    urlBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
                }
            }
            //添加请求头
            Headers.Builder mHeaderBuild = new Headers.Builder();
            if (headers != null) {
                for (Map.Entry<String, String> entry : headers.urlParams.entrySet()) {
                    mHeaderBuild.add(entry.getKey(), entry.getValue());
                }
            }
            Headers mHeader = mHeaderBuild.build();
            return new Request.Builder().
                    url(urlBuilder.substring(0, urlBuilder.length() - 1))
                    .get()
                    .headers(mHeader)
                    .build();
        }
    
        /**
         * @param url
         * @param params
         * @return
         */
        public static Request createMonitorRequest(String url, RequestParams params) {
            StringBuilder urlBuilder = new StringBuilder(url).append("&");
            if (params != null && params.hasParams()) {
                for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                    urlBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
                }
            }
            return new Request.Builder().url(urlBuilder.substring(0, urlBuilder.length() - 1)).get().build();
        }
    
        /**
         * 文件上传请求
         *
         * @return
         */
        private static final MediaType FILE_TYPE = MediaType.parse("application/octet-stream");
    
        public static Request createMultiPostRequest(String url, RequestParams params) {
    
            MultipartBody.Builder requestBody = new MultipartBody.Builder();
            requestBody.setType(MultipartBody.FORM);
            if (params != null) {
    
                for (Map.Entry<String, Object> entry : params.fileParams.entrySet()) {
                    if (entry.getValue() instanceof File) {
                        requestBody.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + entry.getKey() + "\""),
                                RequestBody.create(FILE_TYPE, (File) entry.getValue()));
                    } else if (entry.getValue() instanceof String) {
    
                        requestBody.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + entry.getKey() + "\""),
                                RequestBody.create(null, (String) entry.getValue()));
                    }
                }
            }
            return new Request.Builder().url(url).post(requestBody.build()).build();
        }
    }
    
    

    OKhttp核心封装

    import com.youdu.okhttp.cookie.SimpleCookieJar;
    import com.youdu.okhttp.https.HttpsUtils;
    import com.youdu.okhttp.listener.DisposeDataHandle;
    import com.youdu.okhttp.response.CommonFileCallback;
    import com.youdu.okhttp.response.CommonJsonCallback;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.concurrent.TimeUnit;
    
    import javax.net.ssl.HostnameVerifier;
    import javax.net.ssl.SSLSession;
    
    import okhttp3.Call;
    import okhttp3.Interceptor;
    import okhttp3.OkHttpClient;
    import okhttp3.Request;
    import okhttp3.Response;
    
    /**
     * @author qndroid
     * @function 用来发送get, post请求的工具类,包括设置一些请求的共用参数,https支持
     */
    public class CommonOkHttpClient {
    
    
        private static final int TIME_OUT = 30;
    
        private static OkHttpClient mOkHttpClient;
    
    
        //client 配置
        static {
            OkHttpClient.Builder okHttpClientBuilder = new OkHttpClient.Builder();
    
    
            /**
             *  为所有请求添加请求头,看个人需求
             */
            okHttpClientBuilder.addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request request = chain.request()
                            .newBuilder()
                            .addHeader("User-Agent", "Imooc-Mobile") // 标明发送本次请求的客户端
                            .build();
                    return chain.proceed(request);
                }
            });
                 okHttpClientBuilder.cookieJar(new SimpleCookieJar());
    
            //设置超时时间
            okHttpClientBuilder.connectTimeout(TIME_OUT, TimeUnit.SECONDS);
            okHttpClientBuilder.readTimeout(TIME_OUT, TimeUnit.SECONDS);
            okHttpClientBuilder.writeTimeout(TIME_OUT, TimeUnit.SECONDS);
            //支持重定向
            okHttpClientBuilder.followRedirects(true);
    
    
    
            //https支持
            okHttpClientBuilder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });
    
    
            /**
             * trust all the https point
             */
            okHttpClientBuilder.sslSocketFactory(HttpsUtils.initSSLSocketFactory(), HttpsUtils.initTrustManager());
            mOkHttpClient = okHttpClientBuilder.build();
        }
    
        public static OkHttpClient getOkHttpClient() {
            return mOkHttpClient;
        }
    
    
        /**
         * 通过构造好的Request,Callback去发送请求
         *
         * @param request
         * @param callback
         */
        public static Call get(Request request, DisposeDataHandle handle) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new CommonJsonCallback(handle));//CommonJsonCallback Callback回调
            return call;
        }
    
        public static Call post(Request request, DisposeDataHandle handle) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new CommonJsonCallback(handle));
            return call;
        }
    
        public static Call downloadFile(Request request, DisposeDataHandle handle) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new CommonFileCallback(handle));
            return call;
        }
    
    
    

    Callback的封装

    img

    定义OkHttpException

    public class OkHttpException extends Exception {
    		private static final long serialVersionUID = 1L;
    
    	/**
    	 * the server return code
    	 */
    	private int ecode;
    
    	/**
    	 * the server return error message
    	 */
    	private Object emsg;
    
    	public OkHttpException(int ecode, Object emsg) {
    		this.ecode = ecode;
    		this.emsg = emsg;
    	}
    
    	public int getEcode() {
    		return ecode;
    	}
    
    	public Object getEmsg() {
    		return emsg;
    	}
    }
    
    

    DisposeDataListener 回调事件处理

    public interface DisposeDataListener {
    
    	/**
    	 * 请求成功回调事件处理
    	 */
    	public void onSuccess(Object responseObj);
    
    	/**
    	 * 请求失败回调事件处理
    	 */
    	public void onFailure(Object reasonObj);
    
    }
    
    

    DisposeDataListener 在一层封装 DisposeDataHandle

    public class DisposeDataHandle
    {
    	public DisposeDataListener mListener = null;
    	public Class<?> mClass = null;//json->object  object.class  后面要解析的json实体类
    	public String mSource = null;
    
    	public DisposeDataHandle(DisposeDataListener listener)
    	{
    		this.mListener = listener;
    	}
    
    	public DisposeDataHandle(DisposeDataListener listener, Class<?> clazz)
    	{
    		this.mListener = listener;
    		this.mClass = clazz;
    	}
    
    	public DisposeDataHandle(DisposeDataListener listener, String source)
    	{
    		this.mListener = listener;
    		this.mSource = source;
    	}
    }
    
    

    CommonJsonCallback的封装

    import android.os.Handler;
    import android.os.Looper;
    
    import com.youdu.okhttp.exception.OkHttpException;
    import com.youdu.okhttp.listener.DisposeDataHandle;
    import com.youdu.okhttp.listener.DisposeDataListener;
    import com.youdu.okhttp.listener.DisposeHandleCookieListener;
    import com.youdu.adutil.ResponseEntityToModule;
    
    import org.json.JSONObject;
    
    import java.io.IOException;
    import java.util.ArrayList;
    
    import okhttp3.Call;
    import okhttp3.Callback;
    import okhttp3.Headers;
    import okhttp3.Response;
    
    /**
     * @author vision
     * @function
     *
     * 1、异常
     * 2、数据解析
     * 3、数据转发
     *
     */
    public class CommonJsonCallback implements Callback {
    
        /**
         * the logic layer exception, may alter in different app
         */
        protected final String RESULT_CODE = "ecode"; // 有返回则对于http请求来说是成功的,但还有可能是业务逻辑上的错误
        protected final int RESULT_CODE_VALUE = 0;
        protected final String ERROR_MSG = "emsg";
        protected final String EMPTY_MSG = "";
        protected final String COOKIE_STORE = "Set-Cookie"; // decide the server it
        // can has the value of
        // set-cookie2
    
        /**
         * the java layer exception, do not same to the logic error
         */
        protected final int NETWORK_ERROR = -1; // the network relative error
        protected final int JSON_ERROR = -2; // the JSON relative error
        protected final int OTHER_ERROR = -3; // the unknow error
    
        /**
         * 将其它线程的数据转发到UI线程
         */
        private Handler mDeliveryHandler;
        private DisposeDataListener mListener;
        private Class<?> mClass;
    
        public CommonJsonCallback(DisposeDataHandle handle) {
            this.mListener = handle.mListener;
            this.mClass = handle.mClass;
            this.mDeliveryHandler = new Handler(Looper.getMainLooper());
        }
    
        @Override
        public void onFailure(final Call call, final IOException ioexception) {
            /**
             * 此时还在非UI线程,因此要转发
             */
            mDeliveryHandler.post(new Runnable() {
                @Override
                public void run() {
                    //接口回调    到主线程
                    mListener.onFailure(new OkHttpException(NETWORK_ERROR, ioexception));
                }
            });
        }
    
        @Override
        public void onResponse(final Call call, final Response response) throws IOException {
            final String result = response.body().string();
            final ArrayList<String> cookieLists = handleCookie(response.headers());
            mDeliveryHandler.post(new Runnable() {
                @Override
                public void run() {
                    handleResponse(result);
                    /**
                     * handle the cookie
                     */
                    if (mListener instanceof DisposeHandleCookieListener) {
                        ((DisposeHandleCookieListener) mListener).onCookie(cookieLists);
                    }
                }
            });
        }
    
        private ArrayList<String> handleCookie(Headers headers) {
            ArrayList<String> tempList = new ArrayList<String>();
            for (int i = 0; i < headers.size(); i++) {
                if (headers.name(i).equalsIgnoreCase(COOKIE_STORE)) {
                    tempList.add(headers.value(i));
                }
            }
            return tempList;
        }
    
    
        /*
        处理服务器返回的数据
         */
    
        private void handleResponse(Object responseObj) {
    
            if (responseObj == null || responseObj.toString().trim().equals("")) {
                mListener.onFailure(new OkHttpException(NETWORK_ERROR, EMPTY_MSG));
                return;
            }
    
            try {
                /**
                 * 协议确定后看这里如何修改
                 */
                JSONObject result = new JSONObject(responseObj.toString());
                if (mClass == null) {
                    //不需要解析,回调到应用层
                    mListener.onSuccess(result);
                } else {
                    //将json数据解析为java对象返回到应用层
                                 //ResponseEntityToModule   自定义的json数据解析类,这里可以使用gson,fastjson等
                    Object obj = ResponseEntityToModule.parseJsonObjectToModule(result, mClass);
                    if (obj != null) {
                        mListener.onSuccess(obj);
                    } else {
                        //json不合法
                        mListener.onFailure(new OkHttpException(JSON_ERROR, EMPTY_MSG));
                    }
                }
            } catch (Exception e) {
                //其他异常
                mListener.onFailure(new OkHttpException(OTHER_ERROR, e.getMessage()));
                e.printStackTrace();
            }
        }
    }
    
    

    其实到这块
    OKhttp的底层已经封装完成了。
    为了降低耦合,我们可以在应用层在封装一下

    应用层在封装一下

    import com.youdu.module.course.BaseCourseModel;
    import com.youdu.module.recommand.BaseRecommandModel;
    import com.youdu.module.update.UpdateModel;
    import com.youdu.module.user.User;
    import com.youdu.okhttp.CommonOkHttpClient;
    import com.youdu.okhttp.listener.DisposeDataHandle;
    import com.youdu.okhttp.listener.DisposeDataListener;
    import com.youdu.okhttp.listener.DisposeDownloadListener;
    import com.youdu.okhttp.request.CommonRequest;
    import com.youdu.okhttp.request.RequestParams;
    
    /**
     * @author: vision
     * @function:
     */
    public class RequestCenter {
    
        //根据参数发送所有post请求
        public static void postRequest(String url, RequestParams params, DisposeDataListener listener, Class<?> clazz) {
            CommonOkHttpClient.get(CommonRequest.
                    createGetRequest(url, params), new DisposeDataHandle(listener, clazz));
        }
    
        /**
         * 用户登陆请求
         *
         * @param listener
         * @param userName
         * @param passwd
         */
        public static void login(String userName, String passwd, DisposeDataListener listener) {
    
            RequestParams params = new RequestParams();
            params.put("mb", userName);
            params.put("pwd", passwd);
            RequestCenter.postRequest(HttpConstants.LOGIN, params, listener, User.class);
        }
    
        /**
         * 应用版本号请求
         *
         * @param listener
         */
        public static void checkVersion(DisposeDataListener listener) {
            RequestCenter.postRequest(HttpConstants.CHECK_UPDATE, null, listener, UpdateModel.class);
        }
    
        public static void requestRecommandData(DisposeDataListener listener) {
            RequestCenter.postRequest(HttpConstants.HOME_RECOMMAND, null, listener, BaseRecommandModel.class);
        }
    
        public static void downloadFile(String url, String path, DisposeDownloadListener listener) {
            CommonOkHttpClient.downloadFile(CommonRequest.createGetRequest(url, null),
                    new DisposeDataHandle(listener, path));
        }
    
        /**
         * 请求课程详情
         *
         * @param listener
         */
        public static void requestCourseDetail(String courseId, DisposeDataListener listener) {
            RequestParams params = new RequestParams();
            params.put("courseId", courseId);
            RequestCenter.postRequest(HttpConstants.COURSE_DETAIL, params, listener, BaseCourseModel.class);
        }
    }
    
    

    http地址:

    public class HttpConstants {
    
        private static final String ROOT_URL = "http://imooc.com/api";
    
        /**
         * 请求本地产品列表
         */
        public static String PRODUCT_LIST = ROOT_URL + "/fund/search.php";
    
        /**
         * 本地产品列表更新时间措请求
         */
        public static String PRODUCT_LATESAT_UPDATE = ROOT_URL + "/fund/upsearch.php";
    
        /**
         * 登陆接口
         */
        public static String LOGIN = ROOT_URL + "/user/login_phone.php";
    
        /**
         * 检查更新接口
         */
        public static String CHECK_UPDATE = ROOT_URL + "/config/check_update.php";
    
        /**
         * 首页产品请求接口
         */
        public static String HOME_RECOMMAND = ROOT_URL + "/product/home_recommand.php";
    
        /**
         * 课程详情接口
         */
        public static String COURSE_DETAIL = ROOT_URL + "/product/course_detail.php";
    
    }
    
    
    

    具体的使用看一下:

        //发送推荐产品请求
        private void requestRecommandData() {
            RequestCenter.requestRecommandData(new DisposeDataListener() {
                @Override
                public void onSuccess(Object responseObj) {
                    mRecommandData = (BaseRecommandModel) responseObj;
                    //更新UI
                    showSuccessView();
                }
    
                @Override
                public void onFailure(Object reasonObj) {
                    //显示请求失败View
                    showErrorView();
                }
            });
        }
    
    
    展开全文
  • 基于OkHttp3封装网络请求框架

    万次阅读 2017-12-14 09:49:37
    网络请求可以说是开发一款移动APP最核心的基础功能了,通过实际工作中以及浏览了许多网络框架之后,本篇在这里分享慕课一位老师基于OkHttp封装的一轻量的网络框架,至于为什么说它轻量,因为代码少啊!在这里会...

     

    • 前言

     

    网络请求可以说是开发一款移动APP最核心的基础功能了,通过实际工作中以及浏览了许多网络框架之后,本篇在这里分享慕课一位老师基于OkHttp封装的一个轻量的网络框架,至于为什么说它轻量,因为代码少啊!在这里会实现基本的get/post请求,并且支持https加密请求,通过封装方便使用的API,来简化我们的调用方式,对于文件的上传和下载在后续的功能中我会补上这一部分,因为时间关系,前期就没有把它做进去,因为是说的是封装,所以关于okhttp的基本使用这里就不做说明了,不了解的朋友们可以自行百度或者谷歌查找相关资料,这里甩出GitHub和官网的地址,大家可以简单的了解一下。

    GitHub地址:https://github.com/square/okhttp

    官网地址:http://square.github.io/okhttp/

    一、为什么要封装?

    首先来看不封装的情况下我们来完成一个最基本的网络请求该如何去做,来看代码:

     

    //1、创建OkHttpClient对象
    OkHttpClient mOkHttpClient = new OkHttpClient();
    //2、创建一个Request
    final Request request = new Request.Builder()
            .url("https://www.baidu.com/")
            .build();
    //3、通过okhttpclient对象来构建Call对象
    Call call = mOkHttpClient.newCall(request);
    //4、请求加入调度
    call.enqueue(new Callback() {
        
        //请求失败
        @Override
        public void onFailure(@NonNull Call call, @NonNull IOException e) {
    
        }
        
        //请求成功
        @Override
        public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
    
        }
    });

    有人说了,这代码也不是很多啊,但是如果我们每个请求都这么写就显得很繁琐了,而且这还是最基本的get请求,所以实际工作中我们完全不可能这么使用,原因也说了:1、代码冗余;2:如果官方的api发生了更新,那么你每个网络请求的地方都要修改,这就有点得不偿失了;3:作为一个高逼格的程序猿,网络请求的逻辑全都暴露在了Activity里面,这肯定是不允许的,所以综合以上几点,我们肯定要对它做一个封装,接下来就来看看如何去封装。

     

    二、封装思路说明

    1、首先是封装我们的Request,创建一个类来接收请求参数和URL,然后返回给我们一个创建好的请求对象;2、然后是封装我们的okhttp核心部分,这部分首先要能完成请求的发送(主要是get和post请求,反正我在实际工作中是没有碰到过put和delete请求的),然后是配置我们的okhttp相关的参数,并且我们还添加了https请求的支持,这里是对所有https类型站点的信任;3、最后封装callback部分,我们为这部分封装了对成功和失败的回调处理以及相关的异常处理,还有就是okhttp在回调完成后此时还是处于子线程中的,这点是它框架的机制导致的,所以这时候我们还不能进行UI操作,我们需要把消息转发到主线程中去,最后为了方便应用层的处理,我们在框架层就提前将服务器返回的json数据解析成对应的实体对象,然后我们在应用层中就可以直接操作我们Bean类中的属性了,好了,思路就是这样,那说干就干,开始封装。

    三、撸起袖子加油干——代码实战

    这里我们需要创建一个框架Module,这个Module是一个Android Library,然后将封装的代码都放在这个Module中进行编写,然后让应用层的app Module依赖框架Module即可,这样不会将封装的具体实现逻辑暴露在应用层。

    1、封装Request

    封装我们的请求参数到一个HashMap中,这个类并不是我写的,是参考了之前使用的一个网络框架AsyncHttpClient中的代码,创建了两个线程安全的HashMap,将请求参数以键值对的形式放到我们的HashMap中,代码如下:

     

    package com.archie.netlibrary.okhttp.request;
    
    import java.io.FileNotFoundException;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 项目名:   NetTest2
     * 包名:     com.archie.netlibrary.okhttp.request
     * 文件名:   RequestParams
     * 创建者:   Jarchie
     * 创建时间: 17/12/13 上午10:28
     * 描述:     封装所有的请求参数到HashMap中
     * 此类是仿照AsyncHttpClient中的请求参数写的
     */
    
    @SuppressWarnings({"unused", "RedundantIfStatement"})
    public class RequestParams {
        //线程安全的HashMap
        public ConcurrentHashMap<String, String> urlParams = new ConcurrentHashMap<>();
        public ConcurrentHashMap<String, Object> fileParams = new ConcurrentHashMap<>();
    
        /**
         * Constructs a new empty {@code RequestParams} instance.
         */
        public RequestParams() {
            this((Map<String, String>) null);
        }
    
        /**
         * Constructs a new RequestParams instance containing the key/value string
         * params from the specified map.
         *
         * @param source the source key/value string map to add.
         */
        public RequestParams(Map<String, String> source) {
            if (source != null) {
                for (Map.Entry<String, String> entry : source.entrySet()) {
                    put(entry.getKey(), entry.getValue());
                }
            }
        }
    
        /**
         * Constructs a new RequestParams instance and populate it with a single
         * initial key/value string param.
         *
         * @param key   the key name for the intial param.
         * @param value the value string for the initial param.
         */
        public RequestParams(final String key, final String value) {
            this(new HashMap<String, String>() {
                {
                    put(key, value);
                }
            });
        }
    
        /**
         * Adds a key/value string pair to the request.
         *
         * @param key   the key name for the new param.
         * @param value the value string for the new param.
         */
        public void put(String key, String value) {
            if (key != null && value != null) {
                urlParams.put(key, value);
            }
        }
    
        public void put(String key, Object object) throws FileNotFoundException {
            if (key != null) {
                fileParams.put(key, object);
            }
        }
    
        public boolean hasParams() {
            if (urlParams.size() > 0 || fileParams.size() > 0) {
                return true;
            }
            return false;
        }
    
    }
    

    创建一个CommonRequest类,接收请求参数,然后生成Request对象,这里因为内容较少所有没有采用构建者的模式,二是采用公共静态的方法,在下一篇介绍对Retrofit的一个封装时我会采用构建者模式,因为它的封装过程比这个要稍微复杂一些,内容也更全面一些,敬请期待吧!这个类中我们创建了两个方法用于生成get和post类型的Request,都是通过循环遍历Map中的请求参数来完成的,不同的是,get请求的key-value是通过“&”拼接的,所以这里使用了StringBuilder来完成字符串的拼接,效率更高,post请求是通过okhttp中的FormBody对象的建造者来完成的,具体实现的代码如下:

     

    package com.archie.netlibrary.okhttp.request;
    
    import java.util.Map;
    
    import okhttp3.FormBody;
    import okhttp3.Request;
    
    /**
     * 项目名:   NetTest2
     * 包名:     com.archie.netlibrary.okhttp.request
     * 文件名:   CommonRequest
     * 创建者:   Jarchie
     * 创建时间: 17/12/13 上午10:31
     * 描述:     接收请求参数,为我们生成Request对象
     */
    
    public class CommonRequest {
    
        /**
         * 创建Get请求的Request
         *
         * @param url
         * @param params
         * @return 通过传入的参数返回一个Get类型的请求
         */
        public static Request getRequest(String url, RequestParams params) {
            StringBuilder urlBuilder = new StringBuilder(url).append("?");
    
            if (params != null) {
                for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                    urlBuilder
                            .append(entry.getKey())
                            .append("=")
                            .append(entry.getValue())
                            .append("&");
                }
            }
    
            return new Request.Builder().url(urlBuilder.substring(0, urlBuilder.length() - 1))
                    .get().build();
        }
    
        /**
         * 创建Post请求的Request
         *
         * @param url
         * @param params
         * @return 返回一个创建好的Request对象
         */
        public static Request createPostRequest(String url, RequestParams params) {
            FormBody.Builder mFromBodyBuilder = new FormBody.Builder();
    
            if (params != null) {
                for (Map.Entry<String, String> entry : params.urlParams.entrySet()) {
                    //将请求参数逐一遍历添加到我们的请求构建类中
                    mFromBodyBuilder.add(entry.getKey(), entry.getValue());
                }
            }
    
            //通过请求构建类的build方法获取到真正的请求体对象
            FormBody mFormBody = mFromBodyBuilder.build();
            return new Request.Builder().url(url).post(mFormBody).build();
        }
    
    }
    

    2、封装OkHttp核心部分

     

    这部分主要完成的功能是:1、请求的发送;2、请求参数的配置(这里配置了连接超时和读写超时时间,允许重定向);3、添加https的支持,在hostnameVerifier的回调中我们返回的是true,表明对所有类型的https证书的支持,无论是自己生成的还是购买的,对于sslSocketFactory的设置,我这里是参考网上的相关代码做了一个封装,https就是在TCP和HTTP协议之间加了一层SSL协议,是介于传输层和应用层之间的协议,需要注意的是加密算法的类型要与服务端的保持一致,一般为TSL/SSL,关于https我本人并不是太了解,讲的也不清楚,这里推荐给大家一篇鸿洋的文章,Android Https相关完全解析http://blog.csdn.net/lmj623565791/article/details/48129405。关于配置的一系列操作都是放在静态语句块中执行的,主要是通过OkHttpClient对象的Builder对象来设置的,最后我们创建了get()和post()两个方法,用于发送具体的请求,参数传入我们的Request和CallBack回调,具体代码如下:

     

    package com.archie.netlibrary.okhttp;
    
    import com.archie.netlibrary.okhttp.https.HttpsUtils;
    import com.archie.netlibrary.okhttp.listener.DisposeDataHandle;
    import com.archie.netlibrary.okhttp.response.CommonJsonCallback;
    
    import java.util.concurrent.TimeUnit;
    
    import javax.net.ssl.HostnameVerifier;
    import javax.net.ssl.SSLSession;
    
    import okhttp3.Call;
    import okhttp3.OkHttpClient;
    import okhttp3.Request;
    
    /**
     * 项目名:   NetTest2
     * 包名:     com.archie.netlibrary.okhttp
     * 文件名:   CommonOkHttpClient
     * 创建者:   Jarchie
     * 创建时间: 17/12/13 上午10:25
     * 描述:     请求的发送,请求参数的配置,https支持
     */
    
    public class CommonOkHttpClient {
    
        private static final int TIME_OUT = 30; //超时参数
        private static OkHttpClient mOkHttpClient;
    
        //为我们的Client配置参数,使用静态语句块来配置
        static {
            //创建我们Client对象的构建者
            OkHttpClient.Builder okHttpBuilder = new OkHttpClient.Builder();
            okHttpBuilder
                    //为构建者填充超时时间
                    .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                    .readTimeout(TIME_OUT, TimeUnit.SECONDS)
                    .writeTimeout(TIME_OUT, TimeUnit.SECONDS)
                    //允许重定向
                    .followRedirects(true)
                    //添加https支持
                    .hostnameVerifier(new HostnameVerifier() {
                        @Override
                        public boolean verify(String s, SSLSession sslSession) {
                            return true;
                        }
                    })
                    .sslSocketFactory(HttpsUtils.initSSLSocketFactory(), HttpsUtils.initTrustManager());
            mOkHttpClient = okHttpBuilder.build();
        }
    
        //发送具体的HTTP以及Https请求
        public static Call sendRequest(Request request, CommonJsonCallback commonCallback) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(commonCallback);
            return call;
        }
    
        //GET请求
        public static Call get(Request request, DisposeDataHandle handle) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new CommonJsonCallback(handle));
            return call;
        }
    
        //POST请求
        public static Call post(Request request, DisposeDataHandle handle) {
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new CommonJsonCallback(handle));
            return call;
        }
    
    }

     

    关于HttpsUtils的代码,文末会给出项目源码,这里就不贴出了,不然代码太多了。

    3、封装Callback

    首先我们创建一个接口类,自定义事件监听的回调,用于处理成功和失败的请求,参数中使用的是Object类型,这样能够更灵活的处理数据:

     

    public interface DisposeDataListener {
    
        //请求成功回调事件处理
        public void onSuccess(Object responseObj);
    
        //请求失败回调事件处理
        public void onFailure(Object responseObj);
    
    }

    接着新建一个类,将我们的事件回调和用于处理Json转换实体对象的字节码对象做一个封装,给出单参和双参的构造方法:

     

     

    public class DisposeDataHandle {
    
        public DisposeDataListener mListener = null;
        public Class<?> mClass = null;
    
        public DisposeDataHandle(DisposeDataListener listener) {
            this.mListener = listener;
        }
    
        public DisposeDataHandle(DisposeDataListener listener, Class<?> clazz) {
            this.mListener = listener;
            this.mClass = clazz;
        }
    
    }

    接着我们再自定义一个异常类,返回错误码和错误信息到业务层:

     

    public class OkHttpException extends Exception {
        private static final long serialVersionUID = 1L;
    
        private int ecode; //错误码
        private Object emsg; //错误消息
    
        public OkHttpException(int ecode, Object emsg) {
            this.ecode = ecode;
            this.emsg = emsg;
        }
    
        public int getEcode() {
            return ecode;
        }
    
        public Object getEmsg() {
            return emsg;
        }
    
    }

    最后我们创建一个类用于专门处理Json数据的响应,命名为CommonJsonCallback实现OKHTTP3中的Callback接口,重写onFailure和onResponse这两个失败和成功的回调函数,在这个类中我们定义了一些基本的常量,首先定义了与服务器字段的对应关系的常量,其次自定义了一些异常类型,这些字段需要和自己公司的后台开发人员进行商定,这里我只是简单的举个栗子,具体如下代码所示:

     

     

     

    //与服务器的字段的一个对应关系
    protected final String RESULT_CODE = "ecode"; //有返回则对于http请求来说是成功的,但还有可能是业务逻辑上的错误
    protected final int RESULT_CODE_VALUE = 0;
    protected final String ERROR_MSG = "emsg";
    protected final String EMPTY_MSG = "";
    
    //自定义异常类型
    protected final int NETWORK_ERROR = -1; //the network relative error
    protected final int JSON_ERROR = -2; //the JSON relative error
    protected final int OTHER_ERROR = -3; //the unknow error

    接着我们定义了一个Handler对象用于进行消息的转发,自定义回调监听用于对响应数据的回调处理,字节码文件用于对实体对象的转化,如下所示:

     

     

    private Handler mDeliveryHandler; //进行消息的转发
    private DisposeDataListener mListener;
    private Class<?> mClass;
    
    public CommonJsonCallback(DisposeDataHandle handle) {
        this.mListener = handle.mListener;
        this.mClass = handle.mClass;
        this.mDeliveryHandler = new Handler(Looper.getMainLooper());
    }

    接着是处理请求失败的回调,我们在这里用handler将异常信息通过自定义的回调监听发送到应用层中去处理,如下所示:

     

     

    //请求失败的处理
    @Override
    public void onFailure(@NonNull Call call, @NonNull final IOException e) {
        mDeliveryHandler.post(new Runnable() {
            @Override
            public void run() {
                mListener.onFailure(new OkHttpException(NETWORK_ERROR, e));
            }
        });
    }

    最后来处理请求成功的回调,这也是最重要的一步,同样的我们首先是将响应数据发送到主线程中,然后判断字节码mClass对象是否为null,如果为空则表示我们不需要转换实体对象,直接将原始的Json数据回调到应用层,你可以直接操作json数据,如果mClass对象不为空,我这里直接通过谷歌的Gson将json数据解析成了对应的实体对象返回,这样我们在应用层可以直接操作实体对象,对于异常信息也是直接回调到应用层去处理的,具体代码如下:

     

     

    //处理成功的响应
    private void handleResponse(Object responseObj) {
        //为了保证代码的健壮性
        if (responseObj == null && responseObj.toString().trim().equals("")) {
            mListener.onFailure(new OkHttpException(NETWORK_ERROR, EMPTY_MSG));
            return;
        }
        try {
            JSONObject result = new JSONObject(responseObj.toString());
            if (result.has(RESULT_CODE)) {
                //从JSON对象中取出我们的响应码,如果为0,则是正确的响应
                if (result.getInt(RESULT_CODE) == RESULT_CODE_VALUE) {
                    if (mClass == null) {
                        mListener.onSuccess(responseObj);
                    } else { //需要转化为实体对象
                        Object obj = new Gson().fromJson((String) responseObj, mClass);
                        if (obj != null) { //表明正确的转为了实体对象
                            mListener.onSuccess(obj);
                        } else {
                            mListener.onFailure(new OkHttpException(JSON_ERROR, EMPTY_MSG));
                        }
                    }
                } else { //将服务端返回的异常回调到应用层去处理
                    mListener.onFailure(new OkHttpException(OTHER_ERROR, result.get(RESULT_CODE)));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            mListener.onFailure(new OkHttpException(OTHER_ERROR, e.getMessage()));
        }
    }

    好了,这样我们就已经封装完成了基本的get/post请求,已经能够满足一般的开发要求了,关于框架层的封装就说这么多,接下来,我们去看看在应用层中该如何调用?

     

    四、测试框架是否运行正常

    1、准备服务器数据

    我这里在本地环境下开了一个Tomcat,然后在它的webapps目录下新建了一个文件夹youdu,然后在里面新建了一个test.json的文件,在里面放入了一些简单的测试数据,并且我们在本地浏览器中访问这个地址,发现可以正常访问,数据如下:

    2、根据对应的json数据,这里创建一个TestModel实体类,定义获取数据的各个字段,可以通过GsonFormat插件快速生成。

    3、定义接口管理类,统一管理接口地址(实际项目中都要这么做):

     

    public class HttpConstant {
        private static final String URL = "http://10.10.7.146:8080/";
    
        public static String HOME_RECOMMAND = URL + "youdu/test.json";
    }

    4、为了调用简单,我们在应用层中再做一层封装,定义一个RequestCenter类,在其中通过方法的重载,对外只暴露一个我们自定义的回调监听,其它几个参数都在这个类中传入即可,代码如下:

     

     

    public class RequestCenter {
    
        //根据参数发送所有的get请求
        private static void getRequest(String url, RequestParams params,
                                       DisposeDataListener listener,
                                       Class<?> clazz){
            CommonOkHttpClient.get(CommonRequest.createGetRequest(url, params),
                    new DisposeDataHandle(listener,clazz));
        }
    
        public static void requestRecommandData(DisposeDataListener listener){
            RequestCenter.getRequest(HttpConstant.HOME_RECOMMAND,null,listener, TestModel.class);
        }
    
    }

    5、这样我们在调用的时候就十分方便了,并且在回调方法中可以直接处理我们实体数据,具体的调用方法如下:

     

     

    //测试网络框架
    RequestCenter.requestRecommandData(new DisposeDataListener() {
        @Override
        public void onSuccess(Object responseObj) {
            TestModel model = (TestModel) responseObj;
            //设置名称字段显示到TextView上
            textView.setText(model.getData().getList().get(0).getUname());
        }
    
        @Override
        public void onFailure(Object responseObj) {
            Log.e("测试网络框架", "onFailure: " + responseObj.toString() );
        }
    });

    可以看到,我们的调用现在已经变的十分简单了,就这么几行代码就完成了数据请求解析以及展示的过程,来看一下程序运行的结果:

     

    双手奉上项目源码地址:https://github.com/JArchie/NetTest2

    展开全文
  • 原理呢,比较简单的,把参数以请求头的方式添加到拦截器中,然后在配置给okhttp,亦或其他网络框架。 代码实现 创建拦截器,并添加参数 public class HeaderInterceptor implements Interceptor...

    业务场景

    我们通常需要cookie持久化来保持回话统一,也因为某些业务需求,需要每个接口都传一些参数,比如token、userId等。


    原理解读

    原理呢,比较简单的,把参数以请求头的方式添加到拦截器中,然后在配置给okhttp


    代码实现

    • 创建拦截器,并添加参数
    public class HeaderInterceptor implements Interceptor {
    
        @NonNull
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request original = chain.request();
            Request.Builder requestBuilder = original.newBuilder()
                    .addHeader("version", "1.0.0")
                    .addHeader("自定义key", "自定义value");
            Request request = requestBuilder.build();
            return chain.proceed(request);
        }
    }
    
    • 配置拦截器给OkHttp
            OkHttpClient okHttpClient = new OkHttpClient.Builder()
                    ...
                    .addInterceptor(new HeaderInterceptor())
                    ...
                    .connectTimeout(20, TimeUnit.SECONDS)
                    .build();
    

    也可以用@Header@Headers注解给某一个接口单独添加一个或多个请求头。


    展开全文
  • OKHttp 3的简单请求方式

    千次阅读 2018-05-30 13:20:18
    一,OKHttp介绍okhttp是一第三方类库,用于android中请求网络。这是一开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso和LeakCanary) 。用于替代HttpUrlConnection和Apache...

    一,OKHttp介绍

    okhttp是一个第三方类库,用于android中请求网络。

    这是一个开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso和LeakCanary) 。用于替代HttpUrlConnection和Apache HttpClient(android API23 里已移除HttpClient)。

    okhttp有自己的官网,官网网址:OKHttp官网

    如果想了解原码可以在github上下载,地址是:https://github.com/square/okhttp

    在AndroidStudio中使用不需要下载jar包,直接添加依赖即可: 
    compile ‘com.squareup.okhttp3:okhttp:3.4.1’

    下面对以OKHttp3来详细介绍OKHttp的使用方法。

    二,get请求的使用方法

    使用OKHttp进行网络请求支持两种方式,一种是同步请求,一种是异步请求。下面分情况进行介绍。

    1,get的同步请求

    对于同步请求在请求时需要开启子线程,请求成功后需要跳转到UI线程修改UI。 
    使用示例如下:

    public void getDatasync(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象
                    Request request = new Request.Builder()
                            .url("http://www.baidu.com")//请求接口。如果需要传参拼接到接口后面。
                            .build();//创建Request 对象
                    Response response = null;
                    response = client.newCall(request).execute();//得到Response 对象
                    if (response.isSuccessful()) {
                    Log.d("kwwl","response.code()=="+response.code());
                    Log.d("kwwl","response.message()=="+response.message());
                    Log.d("kwwl","res=="+response.body().string());
                    //此时的代码执行在子线程,修改UI的操作请使用handler跳转到UI线程。
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    此时打印结果如下: 
    response.code()==200; 
    response.message()==OK; 
    res=={“code”:200,”message”:success};

    注意事项: 
    1,Response.code是http响应行中的code,如果访问成功则返回200.这个不是服务器设置的,而是http协议中自带的。res中的code才是服务器设置的。注意二者的区别。 
    2,response.body().string()本质是输入流的读操作,所以它还是网络请求的一部分,所以这行代码必须放在子线程。 
    3,response.body().string()只能调用一次,在第一次时有返回值,第二次再调用时将会返回null。原因是:response.body().string()的本质是输入流的读操作,必须有服务器的输出流的写操作时客户端的读操作才能得到数据。而服务器的写操作只执行一次,所以客户端的读操作也只能执行一次,第二次将返回null。

    2,get的异步请求

    这种方式不用再次开启子线程,但回调方法是执行在子线程中,所以在更新UI时还要跳转到UI线程中。 
    使用示例如下:

    private void getDataAsync() {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://www.baidu.com")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if(response.isSuccessful()){//回调的方法执行在子线程。
                    Log.d("kwwl","获取数据成功了");
                    Log.d("kwwl","response.code()=="+response.code());
                    Log.d("kwwl","response.body().string()=="+response.body().string());
                }
            }
        });
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    异步请求的打印结果与注意事项与同步请求时相同。最大的不同点就是异步请求不需要开启子线程,enqueue方法会自动将网络请求部分放入子线程中执行。

    注意事项: 
    1,回调接口的onFailure方法和onResponse执行在子线程。 
    2,response.body().string()方法也必须放在子线程中。当执行这行代码得到结果后,再跳转到UI线程修改UI。

    三,post请求的使用方法

    Post请求也分同步和异步两种方式,同步与异步的区别和get方法类似,所以此时只讲解post异步请求的使用方法。 
    使用示例如下:

    private void postDataWithParame() {
        OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
        FormBody.Builder formBody = new FormBody.Builder();//创建表单请求体
        formBody.add("username","zhangsan");//传递键值对参数
        Request request = new Request.Builder()//创建Request 对象。
                .url("http://www.baidu.com")
                .post(formBody.build())//传递请求体
                .build();
        client.newCall(request).enqueue(new Callback() {。。。});//回调方法的使用与get异步请求相同,此时略。
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    看完代码我们会发现:post请求中并没有设置请求方式为POST,回忆在get请求中也没有设置请求方式为GET,那么是怎么区分请求方式的呢?重点是Request.Builder类的post方法,在Request.Builder对象创建最初默认是get请求,所以在get请求中不需要设置请求方式,当调用post方法时把请求方式修改为POST。所以此时为POST请求。

    四,POST请求传递参数的方法总结

    在post请求使用方法中讲了一种传递参数的方法,就是创建表单请求体对象,然后把表单请求体对象作为post方法的参数。post请求传递参数的方法还有很多种,但都是通过post方法传递的。下面我们看一下Request.Builder类的post方法的声明:

    public Builder post(RequestBody body)
    • 1

    由方法的声明可以看出,post方法接收的参数是RequestBody 对象,所以只要是RequestBody 类以及子类对象都可以当作参数进行传递。FormBody就是RequestBody 的一个子类对象。

    1,使用FormBody传递键值对参数

    这种方式用来上传String类型的键值对 
    使用示例如下:

    private void postDataWithParame() {
        OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
        FormBody.Builder formBody = new FormBody.Builder();//创建表单请求体
        formBody.add("username","zhangsan");//传递键值对参数
        Request request = new Request.Builder()//创建Request 对象。
                .url("http://www.baidu.com")
                .post(formBody.build())//传递请求体
                .build();
        client.newCall(request).enqueue(new Callback() {。。。});//此处省略回调方法。
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2,使用RequestBody传递Json或File对象

    RequestBody是抽象类,故不能直接使用,但是他有静态方法create,使用这个方法可以得到RequestBody对象。

    这种方式可以上传Json对象或File对象。 
    上传json对象使用示例如下:

    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    MediaType JSON = MediaType.parse("application/json; charset=utf-8");//数据类型为json格式,
    String jsonStr = "{\"username\":\"lisi\",\"nickname\":\"李四\"}";//json数据.
    RequestBody body = RequestBody.create(JSON, josnStr);
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});//此处省略回调方法。
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    上传File对象使用示例如下:

    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    MediaType fileType = MediaType.parse("File/*");//数据类型为json格式,
    File file = new File("path");//file对象.
    RequestBody body = RequestBody.create(fileType , file );
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});//此处省略回调方法。
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3,使用MultipartBody同时传递键值对参数和File对象

    这个字面意思是多重的body。我们知道FromBody传递的是字符串型的键值对,RequestBody传递的是多媒体,那么如果我们想二者都传递怎么办?此时就需要使用MultipartBody类。 
    使用示例如下:

    OkHttpClient client = new OkHttpClient();
    MultipartBody multipartBody =new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("groupId",""+groupId)//添加键值对参数
            .addFormDataPart("title","title")
            .addFormDataPart("file",file.getName(),RequestBody.create(MediaType.parse("file/*"), file))//添加文件
            .build();
    final Request request = new Request.Builder()
            .url(URLContant.CHAT_ROOM_SUBJECT_IMAGE)
            .post(multipartBody)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    4,自定义RequestBody实现流的上传

    在上面的分析中我们知道,只要是RequestBody类以及子类都可以作为post方法的参数,下面我们就自定义一个类,继承RequestBody,实现流的上传。 
    使用示例如下: 
    首先创建一个RequestBody类的子类对象:

    RequestBody body = new RequestBody() {
        @Override
        public MediaType contentType() {
            return null;
        }
    
        @Override
        public void writeTo(BufferedSink sink) throws IOException {//重写writeTo方法
            FileInputStream fio= new FileInputStream(new File("fileName"));
            byte[] buffer = new byte[1024*8];
            if(fio.read(buffer) != -1){
                 sink.write(buffer);
            }
        }
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    然后使用body对象:

     OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    以上代码的与众不同就是body对象,这个body对象重写了write方法,里面有个sink对象。这个是OKio包中的输出流,有write方法。使用这个方法我们可以实现上传流的功能。

    使用RequestBody上传文件时,并没有实现断点续传的功能。我可以使用这种方法结合RandomAccessFile类实现断点续传的功能。

    五,设置请求头

    OKHttp中设置请求头特别简单,在创建request对象时调用一个方法即可。 
    使用示例如下:

    Request request = new Request.Builder()
                    .url("http://www.baidu.com")
                    .header("User-Agent", "OkHttp Headers.java")
                    .addHeader("token", "myToken")
                    .build();
    • 1
    • 2
    • 3
    • 4
    • 5

    其他部分代码略。

    六,下载文件

    在OKHttp中并没有提供下载文件的功能,但是在Response中可以获取流对象,有了流对象我们就可以自己实现文件的下载。代码如下: 
    这段代码写在回调接口CallBack的onResponse方法中:

    try{
        InputStream  is = response.body().byteStream();//从服务器得到输入流对象
        long sum = 0;
        File dir = new File(mDestFileDir);
        if (!dir.exists()){
            dir.mkdirs();
        }
        File file = new File(dir, mdestFileName);//根据目录和文件名得到file对象
        FileOutputStream  fos = new FileOutputStream(file);
        byte[] buf = new byte[1024*8];
        int len = 0;
        while ((len = is.read(buf)) != -1){
            fos.write(buf, 0, len);
        }
        fos.flush();
        return file;
    
    }

    展开全文
  • okhttp3带cookie请求

    2019-10-12 22:16:12
    但是OkHttp可以不用我们管理Cookie,自动携带,保存和更新Cookie。 方法是在创建OkHttpClient设置管理Cookie的CookieJar private final HashMap, List<Cookie>> cookieStore = new HashMap (); OkHttpClient ...
  • 哪位大佬springboot,怎么用okhttp3,重复请求同一个外部服务接口,并合并返回结果,有一个请求错误就停止,支持htp和https
  • I have this interceptor that i add to my OkHttp client:public class RequestTokenInterceptor implements Interceptor {@Overridepublic Response intercept(Chain chain) throws IOException {Request request ...
  • 这篇文章将对OKHttp最后一拦截器进行解析,总算快要结束了;上一篇文章讲到连接拦截器,即客户端已经与服务端进行了连接,那接下来的操作自然就是发送接收数据了,看看官网的注释 > 这是拦截器链上的最后一拦截...
  • Android OkHttp3获取完整请求链接Url

    千次阅读 2019-10-29 11:09:28
    Request request = new Request.Builder() .url(attachHttpGetParams(url, params, isHavFirst)) .build(); Logger.e("完整请求连接:"+request.httpUrl().url().toString()); //==...
  • OkHttp是一主流的网络请求的开源框架,可以非常方便的为我们提供网络请求的服务,那么OkHttp的目的就是为了代替HttpUrlConnection和Apache的HttpClient,所以说OkHttp具有很优点。(具体的就不说了,其实我自己...
  • OkHttp3请求网络回顾

    2017-12-14 15:45:15
    OkHttp的同步与异步请求 OKHttp的Interceptor
  • get请求public void getAsyn() { String mUrl = url + initParams(map); Request request = builder.url(mUrl).build(); client.newCall(request).enqueue(this); } private String initPa
  • Android okhttp3请求

    2020-08-28 17:16:21
    get请求 先写一工具类装请求... public static void sendOkHttpRequst(String address,okhttp3.Callback callback){ OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .get()
  • okhttp3同步请求使用总结

    千次阅读 2016-03-18 15:55:43
    官方文档:https://github.com/square/okhttp/wiki/Recipes https://github.com/square/okhttp ...1. okhttp3比较的地方使用了builder模式,OkHttpClient、Request、FormBody等都可以通过&l...
  • Android一点 okhttp3 简单请求

    万次阅读 2016-01-14 16:52:51
    最近有时间看了OkHttp网络请求,体验感觉上升了好几档次,get、post、文件的上传和下载的支持都比较好,很多人都选择了OkHttp。那么问题来了,OkHttp通过enqueue方法确实是开启了一线程进行了请求,但是回调的...
  • Okhttp3网络请求框架的使用简介 添加Okhttp3的依赖 dependencies { //Okhttp3 网络请求框架 implementation 'com.squareup.okhttp3:okhttp:3.10.0' } 在AndroidManifest.xml中声明一下网络权限才行: <uses-...
  • OkHttp3 HTTP请求执行流程分析

    千次阅读 2017-08-17 10:36:53
    使用OkHttp3发送Http请求并获得响应的过程大体为: 创建OkHttpClient对象。OkHttpClient为网络请求执行的一中心,它会管理连接池,缓存,SocketFactory,代理,各种超时时间,DNS,请求执行结果的分发等许多内容...
  • okhttp 同步/异步 请求方法

    千次阅读 2020-02-11 21:36:51
    代表着OKHttp请求的一客户端类,在整个okhttp库中,这OkHttpClient类是处于一很核心的地位。很功能需要通过这客户端类进行转发,或者直接由这客户端类进行实现。 它的创建方式有两种: 一、通过默认的...
  • OkHttp3-请求器(Calls) OkHttp客户端负责接收应用程序发出的请求,并且从服务器获取响应返回给应用程序。理论听起来十分简单,但是在实践中往往会出现很意想不到的因素。 请求 (Request) 每一Http请求都包含一...
  • 主要思路是请求url时加个请求头,然后在拦截器里通过本次请求的请求头来判断使用对应的baseUrl。 主要代码 import com.xxx.xxx.MyClient; import java.io.IOException; import java.util.List; import okhttp3....
  • OkHttp源码解读总结(二)--->OkHttp同步/异步请求
  • builder.addInterceptor(new Interceptor() {//添加请求头参数 @Override public Response intercept(Chain chain) throws IOException { Request original = chain.request(); Request request ...
  • 文章目录一丶问题二丶...在okhttp3中,Dispatcher对象定义了两变量: maxRequest=64 maxRequestPerHost=5 看到这里懂的都懂~~ 这里去简单查了一下 maxRequestPerHost是对单个IP+端口的限制 maxRequest这就是所有总
  • 使用OKHttp3 get请求 , post请求

    千次阅读 2018-10-16 17:45:15
    1 首先需要创建一OKHttpClient  可以直接new一 ...更的是用builder构造一 (那个addInterceptor方法是添加拦截器 , 可以不写,具体的baidu, bing, sogou) private void buildHttpClient(){   ...
  • 通过上一节,我们已经了解了如何使用OkHttp发送异步请求,下载网络图片信息并显示到ImageView控件上,从这一节开始我们就来开始研究一下其内部的实现流程和原理。因为整个流程相对而言还是比较复杂,因此对于流程的...
  • OkHttp3 配置Https证书请求

    万次阅读 2017-11-06 12:08:31
    前言:又有一段时间没更新咯,也是自己实在是懒。也想到发布文章的话不知道该发布...好了废话不说直接来正文吧正文:直接上代码/** * 关联Https请求验证证书 * * @param okHttpClient */ public OkHt...
  • 1 首先需要创建一OKHttpClient  可以直接new一 [java] view plain copy ...更的是用builder构造一 (那个addInterceptor方法是添加拦截器 , 可以不写,具体的baidu, bin

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,009
精华内容 9,603
关键字:

okhttp3多个请求