四個工具類

① HttpCallback

public class HttpCallback implements Callback {
  private static Logger log = LoggerFactory.getLogger("netLog");

  private int successEventType;
  private int failureEventType;
  private long itemId;

  @Override
  public void onFailure(Call call, IOException e) {
    log.error("send http request fail. offer id {}, url {}", itemId, call.request().url().toString());
    log.error("send http request fail reason !", e);
//    EventBus.getInstance().push(failureEventType, itemId, null);
    HttpCallBackPool.getInstance().release(this);
  }

  @Override
  public void onResponse(Call call, Response response) throws IOException {
    HttpResponse httpResponse = buildHttpResponse(response);
//    EventBus.getInstance().push(successEventType, itemId, httpResponse);
    HttpCallBackPool.getInstance().release(this);
  }

  private HttpResponse buildHttpResponse(Response response) {
    HttpResponse httpResponse = new HttpResponse();
    httpResponse.setRequest(response.request());
    httpResponse.setCode(response.code());
    httpResponse.setLocation(response.header("Location"));
    httpResponse.setContentType(response.body().contentType());
    httpResponse.setRefresh(response.header("Refresh"));
    try {
      httpResponse.setBody(response.body().string());
    } catch (IOException e) {
      log.error("get response body fail. url: {}", response.request().url().toString());
      httpResponse.setBody("");
    }
    return httpResponse;
  }

  public void setItemId(long itemId) {
    this.itemId = itemId;
  }

  public void setSuccessEventType(int successEventType) {
    this.successEventType = successEventType;
  }

  public void setFailureEventType(int failureEventType) {
    this.failureEventType = failureEventType;
  }
}
 

②，HttpCallBackPool

public class HttpCallBackPool {
  private static HttpCallBackPool instance = new HttpCallBackPool();
  private static Logger log = LoggerFactory.getLogger(HttpCallBackPool.class);

  private Queue<HttpCallback> inactive = new LinkedList<>();

  private HttpCallBackPool() {
  }

  public static HttpCallBackPool getInstance() {
    return instance;
  }

  /**
   * 獲取一個HttpCallBack
   *
   * @return
   */
  public HttpCallback allocate(long itemId, int successEventType, int failureEventType) {
    HttpCallback httpCallback = inactive.poll();
    if (httpCallback == null) {
      httpCallback = new HttpCallback();
    }
    httpCallback.setItemId(itemId);
    httpCallback.setSuccessEventType(successEventType);
    httpCallback.setFailureEventType(failureEventType);
    return httpCallback;
  }

  /**
   * 釋放HttpCallBack
   *
   * @param
   */
  public void release(HttpCallback httpCallback) {
//    httpCallback.setItemId(EventBus.INVALID_ITEM_ID);
    inactive.add(httpCallback);
    log.info("httpCallbackPool size: {}", inactive.size());
  }

}
 

③，HttpResponse

public class HttpResponse {
  /**
   * 該response對應的request
   */
  private Request request;

  /**
   * 返回的狀態碼
   */
  private int code;

  /**
   * 跳轉連結
   */
  private String location;

  /**
   * 返回的型別
   */
  private MediaType contentType;

  /**
   * 返回的內容
   */
  private String body;

  /**
   * Refresh頭部內容
   */
  private String refresh;

  public String getRefresh() {
    return refresh;
  }

  public void setRefresh(String refresh) {
    this.refresh = refresh;
  }

  public Request getRequest() {
    return request;
  }

  public void setRequest(Request request) {
    this.request = request;
  }

  public int getCode() {
    return code;
  }

  public void setCode(int code) {
    this.code = code;
  }

  public boolean isRedirect() {
    switch (code) {
      case HTTP_PERM_REDIRECT:
      case HTTP_TEMP_REDIRECT:
      case HTTP_MULT_CHOICE:
      case HTTP_MOVED_PERM:
      case HTTP_MOVED_TEMP:
      case HTTP_SEE_OTHER:
        return true;
      default:
        return false;
    }
  }

  public boolean isSuccessful() {
    return code >= 200 && code < 400;
  }

  public String getLocation() {
    return location;
  }

  public void setLocation(String location) {
    this.location = location;
  }

  public MediaType getContentType() {
    return contentType;
  }

  public void setContentType(MediaType contentType) {
    this.contentType = contentType;
  }

  public String getBody() {
    return body;
  }

  public void setBody(String body) {
    this.body = body;
  }
}
 

④，OKHttpUtil

public class OKHttpUtil {

  private OKHttpUtil() {}
  private static OKHttpUtil instance = new OKHttpUtil();
  public static OKHttpUtil getInstance() {
    return instance;
  }
  
  private OkHttpClient httpClient = new OkHttpClient().newBuilder().followRedirects(false).build();  
  
  public void enqueue(String url, Callback callBack) {
    enqueue(url, callBack, null);
  }
  
  public void enqueue(String url, Callback callBack, Map<String, String> headers) {
    Builder builder = new Request.Builder().url(url);
    if(!CollectionUtils.isEmpty(headers)) {
      for(String key : headers.keySet()) {
        builder = builder.addHeader(key, headers.get(key));
      }
    }
    Request request = builder.build();
    httpClient.newCall(request).enqueue(callBack);
  }
}
 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
okhttp 實現非同步請求
     
 
                                        
                                                四個工具類 
① HttpCallback 
public class HttpCallback implements  

  
 

    

    
    
php實現非同步請求
     
 index.php 
 
  1 <?php
 2 //非同步請求
 3 $host = "localhost";
 4 $path = '/index2.php';
 5 $port = 80;
 6 $data = ['email'=>'[email protected]','nam 

  
 

    

    
    
vue使用axios實現非同步請求
     
  
 
  
  
 首先，安裝axios和qs 然後，在main.js中引入 
 import axios from 'axios'
import qs from 'qs'

Vue.prototype.$axios =  axios
// @TODO 這裡qs怎麼全域性引入？我是前端小白。
 
 在vue 

  
 

    

    
    
用AsyncTask來實現非同步請求網路資料
     
 
							
							
							public class HelperAsnc { 
    public HelperAsnc(){}

//get請求
public HelperAsnc get(String url){
    doHttp(url,"GET","");
    retu 

  
 

    

    
    
AJAX:基於js和xml來實現非同步請求
     
 
                要談AJAX，就不得不提同步與非同步的概念了

同步互動：使用者傳送一個請求，在收到伺服器的應答之前，不可以做任何操作。並且在收到應答後，會重新整理整個頁面。在網
絡不好的情況下使用者體驗不好。非同步互動：使用者傳送一個請求，在收到伺服器的應答之前，可以向伺服器傳送新的請求。 

  
 

    

    
    
React Hooks實現非同步請求例項—useReducer、useContext和useEffect代替Redux方案
     
 
 本文是學習了2018年新鮮出爐的React Hooks提案之後，針對
 非同步請求資料寫的一個案例。注意，本文假設了：
 1.你已經初步瞭解
 hooks的含義了，如果不瞭解還請移步
 官方文件。（其實有過翻譯的想法，不過印記中文一直在翻譯，就是比較慢啦）
 2.你使用
 Redux實現過非同步
 Act 

  
 

    

    
    
ajax實現非同步請求模態登陸
     
 ajax實現模態登陸 
  Ajax 即“Asynchronous Javascript And XML”（非同步 JavaScript 和 XML），是指一種建立互動式網頁應用的網頁開發技術。   Ajax = 非同步 JavaScript 和 XML（標準通用標記語 

  
 

    

    
    
原生AJAX實現非同步請求
     
 
								
								            
						
                

   引言

   之前就沒有怎麼學習過ajax的理論知識，但是在專案中用的非常的熟練。因為我一直在用jQuery封裝好的，在

使用的過程中非常的方便，只要我們按照那個格式寫就會得到我們想要的結果 

  
 

    

    
    
使用JQuery編寫AJax實現非同步請求
     
 
                
上一篇已經介紹了關於Ajax的作用和使用場景，並且介紹了使用JS進行編寫的AJax，下面就直接介紹使用JQuery版本得Ajax非同步重新整理。
$. post()以post請求方式傳送 ajax
格式：JQuery.post ( url , [data] , [callb 

  
 

    

    
    
利用jquery的ajax實現非同步請求傳送資料到後臺
     
 
								
								            
						
                
很多時候，作為一個使用者在前臺操作的時候，處理資料的時候並不一定要後臺實時處理然後再返回訊息，這樣，我們可以實用jquery的$.ajax方法實現非同步請求，在頁面不重新整理的情況下，將資料傳到後臺， 

  
 

    

    
    
Ajax實現非同步請求的整個過程
     
  
        //這個回撥函式主要用來檢測伺服器是否把資料返回給非同步物件
 xhr.setRequestHeader("If-Modified-Since","0");  //設定瀏覽器不使用快取
        xhr.onreadystatechange = function () {
      

  
 

    

    
    
OkHttp同步非同步請求
     
 
                 OkHttpClient okHttpClient = new OkHttpClient();
FormBody.Builder builder = new FormBody.Builder();
builder.add("key","value");
FormBody b 

  
 

    

    
    
用谷歌的AsyncHttpClient簡單模仿安卓的AsyncHttpClient，實現非同步請求回撥函式返回值
     
 
							
							
							



實現思路


  既然要呼叫Future.get() 才能激發訪問，那麼就想到了使用一個執行緒去訪問。我們就不需要等待阻塞了。 
  模仿安卓的AsyncHttpClient回撥。根據狀態回撥不同的函式。


實現的效果



    執行程式碼...
 

  
 

    

    
    
CAT中實現非同步請求的呼叫鏈檢視
     
 CAT簡介

CAT（Central Application Tracking），是美團點評基於 Java 開發的一套開源的分散式實時監控系統。美團點評基礎架構部希望在基礎儲存、高效能通訊、大規模線上訪問、服務治理、實時監控、容器化及叢集智慧排程等領域提供業界領先的、統一的解決方案，CAT 目前在美團點評的產 

  
 

    

    
    
續上篇，改用struts2實現JQuery的ajax非同步請求
     
  
  
  
 ·······························································································································  前面的兩篇因為是在csdn文字上編 

  
 

    

    
    
OKHTTP-RecyclerView實現網路請求資料
     
  
  
  
 build.gradle中匯入需要依賴 
 implementation ‘com.google.code.gson:gson:2.8.5’ implementation ‘com.android.support:design:27.1.1’ compile ‘cn.yipianfengye 

  
 

    

    
    
定義內部類 繼承 AsyncTask 來實現非同步網路請求
     
     //非同步任務處理
    //建立內部類,來實現網路非同步請求
    //新建內部類 繼承 AsyncTask
    @SuppressLint("StaticFieldLeak")
    class RequestNetworkDataTask extends AsyncTask&l 

  
 

    

    
    
OKHttp get同步請求網路+post非同步請求網路+上傳圖片
     
  
 
 導依賴 
     implementation 'com.squareup.okhttp3:okhttp:3.11.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.11.0'
 
   
 public  

  
 

    

    
    
原生js實現ajax非同步請求
     
  
 
 
 function createXMLHttpRequest() {
            var xmlHttp;
            try {
                xmlHttp = new XMLHttpRequest();
            } catch (e) 

  
 

    

    
    
layui自定義驗證規則 實現傳送非同步請求校驗手機號是否已註冊
     
 
								
								            
							
							
							//自定義驗證規則
form.verify({
name: function(value, item){//value：表單的值、item：表單的DOM物件
if(!new RegExp(’1+′).t