The use of OkHttp and simple encapsulation

Preface

Network programming is essential in Android development. An app that does not connect to the Internet will not be profitable. Without further ado, let's take a look at the evolution of network requests in Android:

From HttpURLConnection, Apache HTTP Client, Volley to the current OKHttp, there are always people who are better than you. Why is OKHttp so popular? I believe the following introduction will tell you the answer.

Introduction to OKHttp

First, give the OKHttp project address: https://github.com/square/okhttp

Android provides us with two ways of HTTP interaction: HttpURLConnection and Apache HTTP Client. Although both support HTTPS, stream upload and download, configuration timeout, IPv6 and connection pool, they are enough to meet our various HTTP request needs. But using HTTP more efficiently can make your application run faster and save more traffic. The OkHttp library is born for this purpose. OkHttp is an efficient HTTP library:

1.Support SPDY, share the same Socket to handle all requests from the same server

2. If SPDY is not available, use connection pooling to reduce request latency

3. Seamlessly support GZIP to reduce data traffic

1. Cache response data to reduce repeated network requests

2. General get request

3. General post request

4. File upload based on Http

5. File Download

6. Loading images

7.Support request callback and directly return objects and object collections

8.Support session retention

OkHttp will automatically recover from many common connection problems. If your server is configured with multiple IP addresses, when the first IP connection fails, it will automatically try the next IP. OkHttp also handles proxy server problems and SSL handshake failures. (Concurrent) You don't need to rewrite the network code in your program to use OkHttp. OkHttp implements almost the same API as java.net.HttpURLConnection. If you use Apache HttpClient, OkHttp also provides a corresponding okhttp-apache module. From the simple introduction above, we can see that although it is not much simpler in programming, some functions inside OKHttp can help us automatically complete some very complex operations. I personally think that the biggest selling point is to greatly save user traffic.

Basic use of OKHttp

1. Introduce the dependency library of CardView in Gradle.

 compile 'com.squareup.okhttp:okhttp:3.8.0'  

2. Before using OKHttp, you must first understand the following core classes and their functions.

• OkHttpClient client object
• Request is the request accessed in OkHttp, and the Post request needs to contain RequestBody
• Builder is an auxiliary class used to produce objects
• Response is the response in OkHttp. The response can get whether the return is successful and the returned data
• MediaType data type, used to indicate a series of formats such as JSON
• RequestBody request data, used in Post request
• client.newCall(request).execute() is a synchronous request method
• client.newCall(request).enqueue(Callback callBack) is an asynchronous request method, but the code in Callback is executed in the child thread, so the UI cannot be updated.

3. Basic steps for using OKHttp (taking POST to get JSON data from the server as an example)

• Create an OkHttpClient object. The official documentation requires us to use the singleton mode first, which will be mentioned later when encapsulating OKHttp.
• If it is a post request, you need to create a RequestBody object through FormEncodingBuilder and specify the parameters to be passed in. This is not necessary for get requests.
• Create a Request object, which is a request object and needs to specify the URL. The RequestBody object needs to be specified for post requests, but not for get requests.
• Call the newCall method of OkHttpClient, pass the Request object into it, and then execute or enqueue the method. The difference between the two has been mentioned above. The onResponse method in CallBack can do what you need to do. The parameter of the onResponse callback is response. In general, if we want to get the returned string, we can get it through response.body().string(); if we want to get the returned binary byte array, call response.body().bytes(); if you want to get the returned inputStream, call response.body().byteStream(). Seeing this, you may be surprised that you can get the returned inputStream. Seeing this, at least you can realize that large file downloads are supported here. With inputStream, we can write files through IO. However, it also shows a problem. The thread executed by this onResponse is not the UI thread. Indeed, if you want to operate controls, you still need to use handlers, etc.

 OkHttpClient client = new OkHttpClient(); 
 
    RequestBody body = new FormEncodingBuilder()
            . add ( "type" , "1" )
            .build(); Request request = new Request.Builder()
            .url(Constants.URL_BANNER)
 .post(body)
 .build(); 
 
    client.newCall(request).enqueue(new Callback() {
 @Override
 public void onFailure(Request request, IOException e) { 
 
 } 
 
 @Override
 public void onResponse(Response response) throws IOException {
            if (response.isSuccessful()) { 
 
                android.os.Message msg = new Message();
 msg.what = 1;
                msg.obj = response.body().string();
                mHandler.sendMessage(msg);
 }
 }
 });

Here is just a simple post request to get data from the server. As for the get request, it just removes the RequestBody object. As for how to submit data to the server, you can refer to the official WIKI (GitHub introduction document) after you are familiar with the basic usage above.

Simple encapsulation of OKHttp

Looking back at the above code, imagine that if you write so much repeated code for each request, it will seriously reduce the development efficiency, so you need to encapsulate OKHttp. Encapsulating the code is the basic quality of our most object-oriented programmers, reducing duplicate code, and reducing maintenance difficulty and cost.

There is also a package for OKHttp on GitHub, called OKHttpUtils. But here we will do it ourselves and learn how to encapsulate it. The specific points to note are as follows:

1. First of all, OKHttp officially requires us to use the OKHttpClient class in singleton mode, so we customize an OKHttpHelper class and use the singleton mode.

2. Encapsulate the get and post methods. The main idea is to extract the common code, such as the request method extracted from the code.

3. Expose some static methods to the public, including get and post methods.

4. Callback base class, encapsulates OKHttp callback. This class contains a type, which is convenient for using Gson to parse JSON in the callback. When using Callback, you only need to pass in Data or List<Data> in the generic type to use JSON conveniently.

5. Since the original callback is not in the main thread, we need to use Handler to put the callback into the main thread.

The rest can refer to the code, which has detailed comments.

 /**
 * This class is used to assist OKHttp
 */ public class OkHttpHelper { /**
 * Use OkHttpClient in singleton mode
 */
    private static OkHttpHelper mOkHttpHelperInstance;
    private static OkHttpClient mClientInstance;
 private Handler mHandler;
    private Gson mGson; /**
 * Singleton mode, private constructor, some initialization in the constructor
 */
 private OkHttpHelper() {
        mClientInstance = new OkHttpClient(); 
 
        mClientInstance.setConnectTimeout(10, TimeUnit.SECONDS);
        mClientInstance.setReadTimeout(10, TimeUnit.SECONDS);
        mClientInstance.setWriteTimeout(30, TimeUnit.SECONDS);
 mGson = new Gson(); 
 
        mHandler = new Handler(Looper.getMainLooper());
 } /**
 * Get an instance
 *
 * @return  
 */
 public   static OkHttpHelper getinstance() {
        if (mOkHttpHelperInstance == null ) {
            synchronized (OkHttpHelper.class) {
                if (mOkHttpHelperInstance == null ) {
                    mOkHttpHelperInstance = new OkHttpHelper();
 }
 }
        } return mOkHttpHelperInstance;
 } /**
 * Encapsulate a request method, which will be used in both post and get methods
 */
 public void request(final Request request, final BaseCallback callback) { //What to do before the request, such as popping up a dialog box, etc.
        callback.onRequestBefore(); 
 
        mClientInstance.newCall(request).enqueue(new Callback() {
 @Override
 public void onFailure(Request request, IOException e) { //Return failure
                callbackFailure(request, callback, e);
            } @Override
 public void onResponse(Response response) throws IOException {
 if (response.isSuccessful()) { //Return successful callback
                    String resString = response.body().string();
 if (callback.mType == String.class) { //If we need to return String type
                        callbackSuccess(response, resString, callback);
 } else { //If the returned type is other than Gson, use Gson to parse it
 try {
                            Object o = mGson.fromJson(resString, callback.mType);
                            callbackSuccess(response, o, callback);
                        } catch (JsonParseException e) {
                            e.printStackTrace();
                            callbackError(response, callback, e);
 }
 } 
 
 } else { //Return error
                    callbackError(response, callback, null );
 }
 }
 });
 } /**
 * Callback executed in the main thread
 *
 * @param response
 * @param resString
 * @param callback
 */
    private void callbackSuccess(final Response response, final Object o, final BaseCallback callback) {
        mHandler.post(new Runnable() {
 @Override
 public void run() {
                callback.onSuccess(response, o);
 }
 });
 } /**
 * Callback executed in the main thread
 * @param response
 * @param callback
 * @param e
 */
    private void callbackError(final Response response, final BaseCallback callback, final Exception e) {
        mHandler.post(new Runnable() {
 @Override
 public void run() {
                callback.onError(response, response.code(), e);
 }
 });
 } /**
 * Callback executed in the main thread
 * @param request
 * @param callback
 * @param e
 */
    private void callbackFailure(final Request request, final BaseCallback callback, final Exception e) {
        mHandler.post(new Runnable() {
 @Override
 public void run() {
                callback.onFailure(request, e);
 }
 });
 } /**
 * Public get method
 *
 * @param url
 * @param callback
 */
 public void get(String url, BaseCallback callback) {
        Request request = buildRequest(url, null , HttpMethodType.GET);
        request(request, callback);
 } /**
 * Public post method
 *
 * @param url
 * @param params
 * @param callback
 */
 public void post(String url, Map<String, String> params, BaseCallback callback) {
        Request request = buildRequest(url, params, HttpMethodType.POST);
        request(request, callback);
 } /**
 * Build a request object
 *
 * @param url
 * @param params
 * @param type
 * @return  
 */
    private Request buildRequest(String url, Map<String, String> params, HttpMethodType type) {
        Request.Builder builder = new Request.Builder();
 builder.url(url);
            if (type == HttpMethodType.GET) {
 builder.get();
        } else if (type == HttpMethodType.POST) {
            builder.post(buildRequestBody(params));
        } return builder.build();
 } /**
 * Build the body of the request object through the key-value pairs of Map
 *
 * @param params
 * @return  
 */
    private RequestBody buildRequestBody(Map<String, String> params) { 
 
        FormEncodingBuilder builder = new FormEncodingBuilder();
            if (params != null ) {
 for (Map.Entry<String, String> entity : params.entrySet()) {
                builder.add (entity.getKey(), entity.getValue());
 }
        } return builder.build();
 } /**
 * This enumeration is used to indicate which submission method is used
 */
 enum HttpMethodType {
 GET,
 POST
 } 
 
 }

Callback Encapsulation

 package com.nan.cnshop.http; 
 
 import com.google.gson.internal.$Gson$Types;
 import com.squareup.okhttp.Request;
 import com.squareup.okhttp.Response; 
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;/**
 * Basic callback
 */ public abstract class BaseCallback<T> { /**
 * type is used to facilitate JSON parsing
 */
 public Type mType; /**
 * Convert type to the corresponding class. You don’t need to understand it here.
 *
 * @param subclass
 * @return  
 */
 static Type getSuperclassTypeParameter(Class<?> subclass) {
        Type superclass = subclass.getGenericSuperclass();
        if (superclass instanceof Class) {
            throw new RuntimeException( "Missing type parameter." );
 }
        ParameterizedType parameterized = (ParameterizedType) superclass;
 return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
 } /**
 * Get the class of type during construction
 */
 public BaseCallback() {
        mType = getSuperclassTypeParameter(getClass());
 } /**
 * Called before request
 */
 public abstract void onRequestBefore();
 /**
 * Request failed to call (network problem)
 *
 * @param request
 * @param e
 */
 public abstract void onFailure(Request request, Exception e);
 /**
 * Called when the request succeeds and there are no errors
 *
 * @param response
 * @param t
 */
 public abstract void onSuccess(Response response, T t);
 /**
 * Called when the request succeeds but there is an error, such as Gson parsing error, etc.
 *
 * @param response
 * @param errorCode
 * @param e
 */
 public abstract void onError(Response response, int errorCode, Exception e); 
 
 }

Use after OKHttp encapsulation

As shown in the code below. First, get the singleton of OkHttpHelper, and then call the get method. Since it inherits Gson, it is necessary to pass the data type corresponding to JSON in the generic type of BaseCallback. Here, the author uses List<Banner>. *** In the onSuccess method, we can do what we want.

 mHttpHelper=OkHttpHelper.getinstance();
 mHttpHelper.get(Constants.URL_BANNER, new BaseCallback<List<Banner>>() {
 @Override
 public void onRequestBefore() { 
 
 } @Override
 public void onFailure(Request request, Exception e) { 
 
 } @Override
 public void onSuccess(Response response, List<Banner> banners) {
 initBanners(banners);
 } @Override
 public void onError(Response response, int errorCode, Exception e) { 
 
 }
 });

Do you think that the use of OKHttp becomes very simple after encapsulation? This is the power of encapsulation. Well, today's notes stop here.

PS: Here we only introduce the use of OKHttp get and post. Please complete the rest of the use, such as file download and upload and the corresponding code encapsulation by yourself~(≧▽≦)/~ la la la. The full text also contains the code of BaseCallback and OkHttpHelper. Please read the original text.