Android OkHttp Basic Usage Details

The Android system provides two HTTP communication classes, HttpURLConnection And HttpClient .

Although Google recommends HttpURLConnection in most Android versions, this class is too difficult and weak compared with HttpClient.

OkHttp is a relatively mature solution. It is said that Android 4.4 source code can see that HttpURLConnection has been replaced by OkHttp. Therefore, we have more reason to believe that OkHttp is powerful.

Scope of use

OkHttp supports Android 2.3 and above.
For Java, JDK 1.7 or more.

Basic use

HTTP GET

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder().url(url).build();
  Response response = client.newCall(request).execute();
  if (response.isSuccessful()) {
    return response.body().string();
  } else {
    throw new IOException("Unexpected code " + response);
  }
}

Request is the request for access in OkHttp, and Builder is the helper class. Response is the response in OkHttp.

Class Response:

public boolean isSuccessful()
Returns true if the code is in [200..300), which means the request was successfully received, understood, and accepted.

response.body() Return ResponseBody Class

string can be easily obtained

public final String string() throws IOException
Returns the response as a string decoded with the charset of the Content-Type header. If that header is either absent or lacks a charset, this will attempt to decode the response body as UTF-8.
Throws:
IOException

Of course, you can also get the form of stream:

public final InputStream byteStream()

HTTP POST

POST Submit Json Data

public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
OkHttpClient client = new OkHttpClient();
String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
   .url(url)
   .post(body)
   .build();
  Response response = client.newCall(request).execute();
  f (response.isSuccessful()) {
    return response.body().string();
  } else {
    throw new IOException("Unexpected code " + response);
  }
}

Use Request Adj. post Method to submit the request body RequestBody

POST Submit key-value pairs

Most of the time, we need to transfer key-value pair data to the server through POST. OkHttp provides a very convenient way to do this.

OkHttpClient client = new OkHttpClient();
String post(String url, String json) throws IOException {

  RequestBody formBody = new FormEncodingBuilder()
  .add("platform", "android")
  .add("name", "bug")
  .add("subject", "XXXXXXXXXXXXXXX")
  .build();

  Request request = new Request.Builder()
   .url(url)
   .post(body)
   .build();

  Response response = client.newCall(request).execute();
  if (response.isSuccessful()) {
    return response.body().string();
  } else {
    throw new IOException("Unexpected code " + response);
  }
}

Note:

The official OkHttp documentation does not recommend that we create multiple OkHttpClient, so use one globally. If necessary, you can use clone method and customize it. This will be mentioned in the advanced tutorial later. enqueue provides asynchronous methods for OkHttp, which are not mentioned in the introductory tutorial, but will be explained in the advanced tutorial later.

import java.io.IOException;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.message.BasicNameValuePair;
import cn.wiz.sdk.constant.WizConstant;
import com.squareup.okhttp.Callback;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.Request;
import com.squareup.okhttp.Response; 
 
public class OkHttpUtil {
  private static final OkHttpClient mOkHttpClient = new OkHttpClient();
  static{
    mOkHttpClient.setConnectTimeout(30, TimeUnit.SECONDS);
  }
  /**
   *  This does not open asynchronous threads. 
   * @param request
   * @return
   * @throws IOException
   */
  public static Response execute(Request request) throws IOException{
    return mOkHttpClient.newCall(request).execute();
  }
  /**
   *  Open asynchronous threads to access the network 
   * @param request
   * @param responseCallback
   */
  public static void enqueue(Request request, Callback responseCallback){
    mOkHttpClient.newCall(request).enqueue(responseCallback);
  }
  /**
   *  Open asynchronous threads to access the network ,  And doesn't care about returning results (implementing null callback ) 
   * @param request
   */
  public static void enqueue(Request request){
    mOkHttpClient.newCall(request).enqueue(new Callback() {
      
      @Override
      public void onResponse(Response arg0) throws IOException {
        
      }
      
      @Override
      public void onFailure(Request arg0, IOException arg1) {
        
      }
    });
  }
  public static String getStringFromServer(String url) throws IOException{
    Request request = new Request.Builder().url(url).build();
    Response response = execute(request);
    if (response.isSuccessful()) {
      String responseUrl = response.body().string();
      return responseUrl;
    } else {
      throw new IOException("Unexpected code " + response);
    }
  }
  private static final String CHARSET_NAME = "UTF-8";
  /**
   *  Here, we use HttpClinet Adj. API . Just for convenience 
   * @param params
   * @return
   */
  public static String formatParams(List<BasicNameValuePair> params){
    return URLEncodedUtils.format(params, CHARSET_NAME);
  }
  /**
   *  For HttpGet  Adj.  url  Conveniently add multiple name value  Parameter. 
   * @param url
   * @param params
   * @return
   */
  public static String attachHttpGetParams(String url, List<BasicNameValuePair> params){
    return url + "?" + formatParams(params);
  }
  /**
   *  For HttpGet  Adj.  url  Convenient addition 1 A name value  Parameter. 
   * @param url
   * @param name
   * @param value
   * @return
   */
  public static String attachHttpGetParam(String url, String name, String value){
    return url + "?" + name + "=" + value;
  }
}

Summarize

Through the above example, we can find that OkHttp is very convenient to use in many cases, and many codes are repeated, so the following tool classes are specially sorted out.