XUtils3程式碼詳解--http

阿新 • • 發佈：2019-01-13

官方訪問網路用法：

複雜版本：

/** * 自定義實體引數類請參考: * 請求註解 {@link org.xutils.http.annotation.HttpRequest} * 請求註解處理模板介面 {@link org.xutils.http.app.ParamsBuilder} * * 需要自定義型別作為callback的泛型時, 參考: * 響應註解 {@link org.xutils.http.annotation.HttpResponse} * 響應註解處理模板介面 {@link org.xutils.http.app.ResponseParser} * * 示例: 檢視 org.xutils.sample.http 包裡的程式碼 */ 
BaiduParams params =newBaiduParams();
params.wd ="xUtils";
// 有上傳檔案時使用multipart表單, 否則上傳原始檔案流.// params.setMultipart(true);// 上傳檔案方式 1// params.uploadFile = new File("/sdcard/test.txt");// 上傳檔案方式 2// params.addBodyParameter("uploadFile", new File("/sdcard/test.txt"));Callback.Cancelable cancelable
       = x.http().get(params,
       /**        * 1. callback的泛型:        * callback引數預設支援的泛型型別參見{@link 
 org.xutils.http.loader.LoaderFactory},        * 例如: 指定泛型為File則可實現檔案下載, 使用params.setSaveFilePath(path)指定檔案儲存的全路徑.        * 預設支援斷點續傳(採用了檔案鎖和尾端校驗續傳檔案的一致性).        * 其他常用型別可以自己在LoaderFactory中註冊,        * 也可以使用{@link org.xutils.http.annotation.HttpResponse}        * 將註解HttpResponse加到自定義返回值型別上, 實現自定義ResponseParser介面來統一轉換.        * 如果返回值是json形式, 那麼利用第三方的json工具將十分容易定義自己的ResponseParser.        * 如示例程式碼{@link 
 org.xutils.sample.http.BaiduResponse}, 可直接使用BaiduResponse作為        * callback的泛型.        *        * 2. callback的組合:        * 可以用基類或介面組合個種類的Callback, 見{@link org.xutils.common.Callback}.        * 例如:        * a. 組合使用CacheCallback將使請求檢測快取或將結果存入快取(僅GET請求生效).        * b. 組合使用PrepareCallback的prepare方法將為callback提供一次後臺執行耗時任務的機會,        * 然後將結果給onCache或onSuccess.        * c. 組合使用ProgressCallback將提供進度回撥.        * ...(可參考{@link org.xutils.image.ImageLoader}        * 或 示例程式碼中的 {@link org.xutils.sample.download.DownloadCallback})        *        * 3. 請求過程攔截或記錄日誌: 參考 {@link org.xutils.http.app.RequestTracker}        *        * 4. 請求Header獲取: 參考 {@link org.xutils.http.app.RequestInterceptListener}        *        * 5. 其他(執行緒池, 超時, 重定向, 重試, 代理等): 參考 {@link org.xutils.http.RequestParams}        *        **/newCallback.CommonCallback<String>() {
           @OverridepublicvoidonSuccess(Stringresult) {
               Toast.makeText(x.app(), result, Toast.LENGTH_LONG).show();
           }

           @OverridepublicvoidonError(Throwableex, booleanisOnCallback) {
               //Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();if (ex instanceofHttpException) { // 網路錯誤HttpException httpEx = (HttpException) ex;
                   int responseCode = httpEx.getCode();
                   String responseMsg = httpEx.getMessage();
                   String errorResult = httpEx.getResult();
                   // ...
               } else { // 其他錯誤// ...
               }
               Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
           }

           @OverridepublicvoidonCancelled(CancelledExceptioncex) {
               Toast.makeText(x.app(), "cancelled", Toast.LENGTH_LONG).show();
           }

           @OverridepublicvoidonFinished() {

           }
       });

// cancelable.cancel(); // 取消請求

簡單版本：

RequestParams params =newRequestParams("https://www.baidu.com/s");
    params.setSslSocketFactory(...); // 設定ssl
    params.addQueryStringParameter("wd", "xUtils");
    x.http().get(params, newCallback.CommonCallback<String>() {
        @OverridepublicvoidonSuccess(Stringresult) {
            Toast.makeText(x.app(), result, Toast.LENGTH_LONG).show();
        }

        @OverridepublicvoidonError(Throwableex, booleanisOnCallback) {
            Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
        }

        @OverridepublicvoidonCancelled(CancelledExceptioncex) {
            Toast.makeText(x.app(), "cancelled", Toast.LENGTH_LONG).show();
        }

        @OverridepublicvoidonFinished() {

        }
    });


帶有快取的請求示例:

BaiduParams params =newBaiduParams();
params.wd ="xUtils";
// 預設快取存活時間, 單位:毫秒.(如果服務沒有返回有效的max-age或Expires)
params.setCacheMaxAge(1000*60);
Callback.Cancelable cancelable
        // 使用CacheCallback, xUtils將為該請求快取資料.= x.http().get(params, newCallback.CacheCallback<String>() {

    privateboolean hasError =false;
    privateString result =null;

    @OverridepublicbooleanonCache(Stringresult) {
        // 得到快取資料, 快取過期後不會進入這個方法.// 如果服務端沒有返回過期時間, 參考params.setCacheMaxAge(maxAge)方法.//// * 客戶端會根據服務端返回的 header 中 max-age 或 expires 來確定本地快取是否給 onCache 方法.//   如果服務端沒有返回 max-age 或 expires, 那麼快取將一直儲存, 除非這裡自己定義了返回false的//   邏輯, 那麼xUtils將請求新資料, 來覆蓋它.//// * 如果信任該快取返回 true, 將不再請求網路;//   返回 false 繼續請求網路, 但會在請求頭中加上ETag, Last-Modified等資訊,//   如果服務端返回304, 則表示資料沒有更新, 不繼續載入資料.//this.result = result;
        returnfalse; // true: 信任快取資料, 不在發起網路請求; false不信任快取資料.
    }

    @OverridepublicvoidonSuccess(Stringresult) {
        // 注意: 如果服務返回304或 onCache 選擇了信任快取, 這裡將不會被呼叫,// 但是 onFinished 總會被呼叫.this.result = result;
    }

    @OverridepublicvoidonError(Throwableex, booleanisOnCallback) {
        hasError =true;
        Toast.makeText(x.app(), ex.getMessage(), Toast.LENGTH_LONG).show();
        if (ex instanceofHttpException) { // 網路錯誤HttpException httpEx = (HttpException) ex;
            int responseCode = httpEx.getCode();
            String responseMsg = httpEx.getMessage();
            String errorResult = httpEx.getResult();
            // ...
        } else { // 其他錯誤// ...
        }
    }

    @OverridepublicvoidonCancelled(CancelledExceptioncex) {
        Toast.makeText(x.app(), "cancelled", Toast.LENGTH_LONG).show();
    }

    @OverridepublicvoidonFinished() {
        if (!hasError && result !=null) {
            // 成功獲取資料Toast.makeText(x.app(), result, Toast.LENGTH_LONG).show();
        }
    }
});

原始碼檢視：

首先還是入口：http相關的介面和實現類。HttpManager和HttpManagerImpl
介面很簡單。定義了三個非同步請求和四個同步請求的方法簽名。

/**
 * Created by wyouflf on 15/6/17.
 * http請求介面
*/
public interface HttpManager {
/**
     * 非同步GET請求
*/
<T> Callback.Cancelable get(RequestParams entity, Callback.CommonCallback<T> callback);
/**
     * 非同步POST請求
*/
<T> Callback.Cancelable post(RequestParams entity, Callback.CommonCallback<T> callback);
/**
     * 非同步請求
*/
<T> Callback.Cancelable request(HttpMethod method, RequestParams entity, Callback.CommonCallback<T> callback);


/**
     * 同步GET請求
<T> T getSync(RequestParams entity, Class<T> resultType) throws Throwable;
/**
     * 同步POST請求
     */
<T> T postSync(RequestParams entity, Class<T> resultType) throws Throwable;

/**
     * 同步請求
     */
<T> T requestSync(HttpMethod method, RequestParams entity, Class<T> resultType) throws Throwable;

/**
     * 同步請求
     */
<T> T requestSync(HttpMethod method, RequestParams entity, Callback.TypedCallback<T> callback) throws Throwable;
}

先看非同步的一些實現方法：

HttpManagerImpl: 看原始碼我們得知。非同步請求最後都會呼叫到這個方法：request（···）。
在這個方法中發現會new一個HttpTask 並放到執行緒池中執行。
在上一篇部落格可以知道 x.task().start(task) 其實就是呼叫task的doBackground方法。


@Override
public <T> Callback.Cancelable request(HttpMethod method, RequestParams entity, Callback.CommonCallback<T> callback) {
    entity.setMethod(method);
Callback.Cancelable cancelable = null;
    if (callback instanceof Callback.Cancelable) {
        cancelable = (Callback.Cancelable) callback;
}
    HttpTask<T> task = new HttpTask<T>(entity, cancelable, callback);
    return x.task().start(task);
}

我們繼續跟進來檢視HttpTask：

我們發現httpTask 中有哦很多成員變數。作者程式碼註釋的也比較清楚。

/**
 * Created by wyouflf on 15/7/23.
 * http 請求任務
*/
public class HttpTask<ResultType> extends AbsTask<ResultType> implements ProgressHandler {
// 請求相關
private RequestParams params;
private UriRequest request;
private RequestWorker requestWorker;
private final Executor executor;
private final Callback.CommonCallback<ResultType> callback;
// 快取控制
private Object rawResult = null;
private final Object cacheLock = new Object();
private volatile Boolean trustCache = null;
// 擴充套件callback
private Callback.CacheCallback<ResultType> cacheCallback;
private Callback.PrepareCallback prepareCallback;
private Callback.ProgressCallback progressCallback;
private RequestInterceptListener requestInterceptListener;
// 檔案下載執行緒數限制
private Type loadType;
private final static int MAX_FILE_LOAD_WORKER = 3;
private final static AtomicInteger sCurrFileLoadCount = new AtomicInteger(0);

// 檔案下載任務
private static final HashMap<String, WeakReference<HttpTask<?>>>
DOWNLOAD_TASK = new HashMap<String, WeakReference<HttpTask<?>>>(1);

private static final PriorityExecutor HTTP_EXECUTOR = new PriorityExecutor(5, true);
private static final PriorityExecutor CACHE_EXECUTOR = new PriorityExecutor(5, true);
}

HttpTask建構函式中,先用了兩個斷言來確保params 和callback 不為空。
並賦值給成員變數。判斷是哪個callback 並賦值給想應的callback
。初始化tracker 日誌跟蹤系統。初始化執行緒池 executor.

public HttpTask(RequestParams params, Callback.Cancelable cancelHandler,
                Callback.CommonCallback<ResultType> callback) {
    super(cancelHandler);

    assert params != null;
    assert callback != null;

    // set params & callback
    this.params = params;
    this.callback = callback;
    if (callback instanceof Callback.CacheCallback) {
        this.cacheCallback = (Callback.CacheCallback<ResultType>) callback;
    }
    if (callback instanceof Callback.PrepareCallback) {
        this.prepareCallback = (Callback.PrepareCallback) callback;
    }
    if (callback instanceof Callback.ProgressCallback) {
        this.progressCallback = (Callback.ProgressCallback<ResultType>) callback;
    }
    if (callback instanceof RequestInterceptListener) {
        this.requestInterceptListener = (RequestInterceptListener) callback;
    }

    // init tracker
    {
        RequestTracker customTracker = params.getRequestTracker();
        if (customTracker == null) {
            if (callback instanceof RequestTracker) {
                customTracker = (RequestTracker) callback;
            } else {
                customTracker = UriRequestFactory.getDefaultTracker();
            }
        }
        if (customTracker != null) {
            tracker = new RequestTrackerWrapper(customTracker);
        }
    }

    // init executor
    if (params.getExecutor() != null) {
        this.executor = params.getExecutor();
    } else {
        if (cacheCallback != null) {
            this.executor = CACHE_EXECUTOR;
        } else {
            this.executor = HTTP_EXECUTOR;
        }
    }
}

doBackground 方法：非同步請求的最主要的方法。我把這個方法截斷了。這部分主要是做一些準備工作。比如說初始化，快取等。

@Override
@SuppressWarnings("unchecked")
protected ResultType doBackground() throws Throwable {

    if (this.isCancelled()) {
        throw new Callback.CancelledException("cancelled before request");
    }

    // 初始化請求引數
    ResultType result = null;
    resolveLoadType();
    request = createNewRequest();
    checkDownloadTask();
    // retry 初始化
    boolean retry = true;
    int retryCount = 0;
    Throwable exception = null;
    HttpRetryHandler retryHandler = this.params.getHttpRetryHandler();
    if (retryHandler == null) {
        retryHandler = new HttpRetryHandler();
    }
    retryHandler.setMaxRetryCount(this.params.getMaxRetryCount());

    if (this.isCancelled()) {
        throw new Callback.CancelledException("cancelled before request");
    }

    // 檢查快取
    Object cacheResult = null;
    if (cacheCallback != null && HttpMethod.permitsCache(params.getMethod())) {
        // 嘗試從快取獲取結果, 併為請求頭加入快取控制引數.
        try {
            clearRawResult();
            LogUtil.d("load cache: " + this.request.getRequestUri());
            rawResult = this.request.loadResultFromCache();
        } catch (Throwable ex) {
            LogUtil.w("load disk cache error", ex);
        }

        if (this.isCancelled()) {
            clearRawResult();
            throw new Callback.CancelledException("cancelled before request");
        }

        if (rawResult != null) {
            if (prepareCallback != null) {
                try {
                    cacheResult = prepareCallback.prepare(rawResult);
                } catch (Throwable ex) {
                    cacheResult = null;
                    LogUtil.w("prepare disk cache error", ex);
                } finally {
                    clearRawResult();
                }
            } else {
                cacheResult = rawResult;
            }

            if (this.isCancelled()) {
                throw new Callback.CancelledException("cancelled before request");
            }

            if (cacheResult != null) {
                // 同步等待是否信任快取
                this.update(FLAG_CACHE, cacheResult);
                while (trustCache == null) {
                    synchronized (cacheLock) {
                        try {
                            cacheLock.wait();
                        } catch (Throwable ignored) {
                        }
                    }
                }

                // 處理完成
                if (trustCache) {
                    return null;
                }
            }
        }
    }

    if (trustCache == null) {
        trustCache = false;
    }

    if (cacheResult == null) {
        this.request.clearCacheHeader();
    }

發請求的程式碼: 請求程式碼中主要就是重試機子和傳送機制。欄位retry 是控制重試的開關。請求正常則retry一直為false。否則異常處理程式碼塊裡編寫有重試的規則。

在程式碼裡面傳送請求的是物件RequestWorker的run（）；方法。所有我們去看看RequestWorker物件。

    // 發起請求
    retry = true;
    while (retry) {
        retry = false;

        try {
            if (this.isCancelled()) {
                throw new Callback.CancelledException("cancelled before request");
            }

            // 由loader發起請求, 拿到結果.
            this.request.close(); // retry 前關閉上次請求

            try {
                clearRawResult();
                // 開始請求工作
                LogUtil.d("load: " + this.request.getRequestUri());
                requestWorker = new RequestWorker();
                if (params.isCancelFast()) {
                    requestWorker.start();
                    requestWorker.join();
                } else {
                    requestWorker.run();
                }
                if (requestWorker.ex != null) {
                    throw requestWorker.ex;
                }
                rawResult = requestWorker.result;
            } catch (Throwable ex) {
                clearRawResult();
                if (this.isCancelled()) {
                    throw new Callback.CancelledException("cancelled during request");
                } else {
                    throw ex;
                }
            }

            if (prepareCallback != null) {

                if (this.isCancelled()) {
                    throw new Callback.CancelledException("cancelled before request");
                }

                try {
                    result = (ResultType) prepareCallback.prepare(rawResult);
                } finally {
                    clearRawResult();
                }
            } else {
                result = (ResultType) rawResult;
            }

            // 儲存快取
            if (cacheCallback != null && HttpMethod.permitsCache(params.getMethod())) {
                this.request.save2Cache();
            }

            if (this.isCancelled()) {
                throw new Callback.CancelledException("cancelled after request");
            }
        } catch (HttpRedirectException redirectEx) {
            retry = true;
            LogUtil.w("Http Redirect:" + params.getUri());
        } catch (Throwable ex) {
            if (this.request.getResponseCode() == 304) { // disk cache is valid.
                return null;
            } else {
                exception = ex;
                if (this.isCancelled() && !(exception instanceof Callback.CancelledException)) {
                    exception = new Callback.CancelledException("canceled by user");
                }
                retry = retryHandler.retryRequest(exception, ++retryCount, this.request);
            }
        }

    }

    if (exception != null && result == null && !trustCache) {
        throw exception;
    }

    return result;
}

RequestWorker： 是HttpTask的內部類，主要的功能是請求傳送和載入資料執行緒.

內部run()方法分析：
- 下載另作處理
- 請求前回調 requestInterceptListener.beforeRequest(request);
- 請求 this.result = request.loadResult(); 得到結果
- 請求後回撥 requestInterceptListener.afterRequest(request);
- http重定向類的異常處理。

/**
 * 請求傳送和載入資料執行緒.
 * 該執行緒被join到HttpTask的工作執行緒去執行.
 * 它的主要作用是為了能強行中斷請求的連結過程;
 * 並輔助限制同時下載檔案的執行緒數.
 * but:
 * 建立一個Thread約耗時2毫秒, 優化?
 */
private final class RequestWorker extends Thread {
    /*private*/ Object result;
    /*private*/ Throwable ex;

    private RequestWorker() {
    }

    public void run() {
        try {
            if (File.class == loadType) {
                while (sCurrFileLoadCount.get() >= MAX_FILE_LOAD_WORKER
                        && !HttpTask.this.isCancelled()) {
                    synchronized (sCurrFileLoadCount) {
                        try {
                            sCurrFileLoadCount.wait(100);
                        } catch (Throwable ignored) {
                        }
                    }
                }
                sCurrFileLoadCount.incrementAndGet();
            }

            if (HttpTask.this.isCancelled()) {
                throw new Callback.CancelledException("cancelled before request");
            }

            // intercept response
            if (requestInterceptListener != null) {
                requestInterceptListener.beforeRequest(request);
            }

            try {
                this.result = request.loadResult();
            } catch (Throwable ex) {
                this.ex = ex;
            }

            // intercept response
            if (requestInterceptListener != null) {
                requestInterceptListener.afterRequest(request);
            }

            if (this.ex != null) {
                throw this.ex;
            }
        } catch (Throwable ex) {
            this.ex = ex;
            if (ex instanceof HttpException) {
                HttpException httpEx = (HttpException) ex;
                int errorCode = httpEx.getCode();
                if (errorCode == 301 || errorCode == 302) {
                    RedirectHandler redirectHandler = params.getRedirectHandler();
                    if (redirectHandler != null) {
                        try {
                            RequestParams redirectParams = redirectHandler.getRedirectParams(request);
                            if (redirectParams != null) {
                                if (redirectParams.getMethod() == null) {
                                    redirectParams.setMethod(params.getMethod());
                                }
                                // 開始重定向請求
                                HttpTask.this.params = redirectParams;
                                HttpTask.this.request = createNewRequest();
                                this.ex = new HttpRedirectException(errorCode, httpEx.getMessage(), httpEx.getResult());
                            }
                        } catch (Throwable throwable) {
                            this.ex = ex;
                        }
                    }
                }
            }
        } finally {
            if (File.class == loadType) {
                synchronized (sCurrFileLoadCount) {
                    sCurrFileLoadCount.decrementAndGet();
                    sCurrFileLoadCount.notifyAll();
                }
            }
        }
    }
}

同步的一些實現方法：

HttpManagerImpl： 最終都會內部呼叫到requestSync（···）的方法。
在這個方法中我們可以發現。作者也建立了一個HttpTask。並呼叫了x.task().startSync(task);的方法。這個方法我們task的實現類發現實際呼叫的是
TaskControllerImpl.startSync( AbsTask task)

Override
public <T> T getSync(RequestParams entity, Class<T> resultType) throws Throwable {
    return requestSync(HttpMethod.GET, entity, resultType);
}

@Override
public <T> T postSync(RequestParams entity, Class<T> resultType) throws Throwable {
    return requestSync(HttpMethod.POST, entity, resultType);
}

@Override
public <T> T requestSync(HttpMethod method, RequestParams entity, Class<T> resultType) throws Throwable {
    DefaultSyncCallback<T> callback = new DefaultSyncCallback<T>(resultType);
    return requestSync(method, entity, callback);
}

@Override
public <T> T requestSync(HttpMethod method, RequestParams entity, Callback.TypedCallback<T> callback) throws Throwable {
    entity.setMethod(method);
    HttpTask<T> task = new HttpTask<T>(entity, null, callback);
    return x.task().startSync(task);
}

TaskControllerImpl.startSync( AbsTask task) 找到這個方法我們發現呼叫的是AbsTask的四個方法。onWaiting onStarted doBackground
onSuccess 我們知道其實就是httpTask的這個四個方法。通過字面意思我們也可以知道就是等待，開始，子執行緒執行和成功四個方法。

@Override
public <T> T startSync(AbsTask<T> task) throws Throwable {
    T result = null;
    try {
        task.onWaiting();
        task.onStarted();
        result = task.doBackground();
        task.onSuccess(result);
    } catch (Callback.CancelledException cex) {
        task.onCancelled(cex);
    } catch (Throwable ex) {
        task.onError(ex, false);
        throw ex;
    } finally {
        task.onFinished();
    }
    return result;
}

HttpTask的這四個方法： 在onSuccess方法中出現一個callback。回溯到TaskControllerImpl，我們發現了這個callback。它為外部傳遞的。外部沒有傳遞的化。有個預設的DefaultSyncCallback。

@Override
protected void onWaiting() {
    if (tracker != null) {
        tracker.onWaiting(params);
    }
    if (progressCallback != null) {
        progressCallback.onWaiting();
    }
}
@Override
protected void onStarted() {
    if (tracker != null) {
        tracker.onStart(params);
    }
    if (progressCallback != null) {
        progressCallback.onStarted();
    }
}
@Override
protected void onSuccess(ResultType result) {
    if (tracker != null) {
        tracker.onSuccess(request, result);
    }
    if (result != null) {
        callback.onSuccess(result);
    }
}

DefaultSyncCallback： 此物件傳遞一個泛型。此泛型就為onSuccess 中返回的結果。需要再構建DefaultSyncCallback物件時候傳遞。

private class DefaultSyncCallback<T> implements Callback.TypedCallback<T> {

    private final Class<T> resultType;

    public DefaultSyncCallback(Class<T> resultType) {
        this.resultType = resultType;
    }

    @Override
    public Type getLoadType() {
        return resultType;
    }

    @Override
    public void onSuccess(T result) {

    }

    @Override
    public void onError(Throwable ex, boolean isOnCallback) {

    }

    @Override
    public void onCancelled(CancelledException cex) {

    }

    @Override
    public void onFinished() {

    }
}

從task的onwaiting 可以得到。同步請求會一直等待直到請求返回或者請求超時。

XUtils3程式碼詳解--http

官方訪問網路用法：複雜版本： /** * 自定義實體引數類請參考: * 請求註解 {@link org.xutils.http.annotation.HttpRequest} * 請求註解處理模板介面 {@link org.xutils.htt

XUtils3--程式碼詳解(一)

官方readme.me xUtils 包含了很多實用的android工具. xUtils 支援超大檔案(超過2G)上傳，更全面的http請求協議支援(11種謂詞)，擁有更加靈活的ORM，更多的事件註解支援且不受混淆影響… xUtils 最低相容And

HTTP 返回狀態程式碼詳解

如果某項請求傳送到您的伺服器要求顯示您網站上的某個網頁（例如，使用者通過瀏覽器訪問您的網頁或 Googlebot 抓取網頁時），伺服器將會返回 HTTP 狀態程式碼以響應請求。 1xx （臨時響應）表示臨時響應並需要請求者繼續執行操作的狀態程式碼。 &n

各類 HTTP 返回狀態程式碼詳解

一、HTTP狀態碼如果某項請求傳送到您的伺服器要求顯示您網站上的某個網頁（例如，使用者通過瀏覽器訪問您的網頁或 Googlebot 抓取網頁時），伺服器將會返回 HTTP 狀態程式碼以響應請求。此狀態程式碼提供關於請求狀態的資訊，告訴 Googlebot 關於您的網站和請求的網頁的資訊。

iOS開發--HTTP的網路請求狀態程式碼詳解

網路請求是iOS專案的一個大部分,而且大部分的iOS的專案的網路請求是根據AFN進行的二次封裝,我們檢視返回的結果或者error的網路錯誤code,從而確認錯誤型別,針對行的進行除錯修改. 說明:一下整理內容來自網路或者書籍,同時也加上了自己的修改和補充,主要

HTTP頭部資訊和錯誤程式碼詳解-《HTTP權威指南》

最近在除錯前後端分離的請求測試，遇到了一個405錯誤，無法接受，於是開始了人肉搜尋405。最後還是HTTP頭部資訊裡的Accept:application/json 這個Accept 導致的，後端設定了只允許application/json 這種形式，so前端模擬請求的時候，你也要和後端溝通好，

轉載 logback的使用和logback.xml詳解 http://www.cnblogs.com/warking/p/5710303.html

version tor red java代碼根節點 ext private 字符串 npe logback的使用和logback.xml詳解一、logback的介紹　　Logback是由log4j創始人設計的另一個開源日誌組件,官方網站： http://logb

詳解http和https的作用與區別

就是免費證書構建難題原理過程完全 mod 支持 PS: https就是http和TCP之間有一層SSL層，這一層的實際作用是防止釣魚和加密。防止釣魚通過網站的證書，網站必須有CA證書，證書類似於一個解密的簽名。另外是加密，加密需要一個密鑰交換算法，雙方通過交換後

二十行貪吃蛇程式碼詳解

文章目錄完整原始碼詳解完整原始碼原文：https://blog.csdn.net/hj7jay/article/details/51011269 <!doctype html> <html> <bod

TensorFlow中Sequence-to-Sequence樣例程式碼詳解

　　在NLP領域，sequence to sequence模型有很多應用，比如機器翻譯、自動應答機器人等。在看懂了相關的論文後，我開始研讀TensorFlow提供的原始碼，剛開始看時感覺非常晦澀，現在基本都弄懂了，我在這裡主要介紹Sequence-to-Sequence Models用到

TensorFlow中RNN樣例程式碼詳解

　　關於RNN的理論部分已經在上一篇文章中講過了，本文主要講解RNN在TensorFlow中的實現。與theano不同，TensorFlow在一個更加抽象的層次上實現了RNN單元，所以呼叫tensorflow的API來實現RNN是比較容易的。這裡先介紹TensorFlow中與RNN相關的

優化版本對生成對抗網路生成手寫數字集(附程式碼詳解)

# 先匯入必要的庫 import os import cv2 import tensorflow as tf import numpy as np # 把結果儲存到本地的一個庫 import pickle import matplotlib.pyplot as plt from tensor

擷取拼接成新的字串System.arraycopy()如何一分鐘快速掌握（示例程式碼詳解）

//該示例程式碼直接執行即可，喜歡我的文章請關注我，你們是我動力的源泉，謝謝 public static void main(String[] args) { //宣告一個字串型別的變數，在實際開發中變數為獲取的引數 String signDate="AAAAAAAAAAAAAAAAAAAA

進階版Venn plot：Upset plot入門實戰程式碼詳解——UpSetR包介紹

網上已有一些帖子講解了Upset plot的背景知識和實現方法，本文旨在從實戰角度出發，解讀Upset plot實現的一些途徑及其優劣勢以及如何通過upsetR包實現Upset plot的繪製，並提供程式碼和input格式示例。另博主在使用

nginx rtmp module 程式碼詳解各模組主要功能

ngx_rtmp_dash_module http模組裡播放MPEG-DASH相關處理 ngx_rtmp_mp4_module 主要支援rtmp MP4這塊點播相關功能，支援seek操作 ngx_rtmp_flv_module 主要是flv檔案格式的點播相關功能，支援seek操作 ng

Linux網路程式設計---詳解HTTP協議

HTTP 簡介 HTTP協議是Hyper Text Transfer Protocol（超文字傳輸協議）的縮寫,是用於從全球資訊網（WWW:World Wide Web ）伺服器傳輸超文字到本地瀏覽器的傳送協議。。 HTTP是一個基於TCP/IP通訊協議來傳遞資料（HTML 檔案,

使用派克斯軟體連線時最常出現的錯誤程式碼詳解

在使用派克斯軟體時，通常會有各種各樣的錯誤出現而導致連線不上，大家若自己觀察就會發現，凡是連不上的都會出現連不上的錯誤程式碼提示，這就是錯誤資訊，錯誤編碼或兩者同時出現。以下主要是常見的錯誤程式碼資訊的一覽表，也是對出現錯誤的詳解及處理方式。錯誤程式碼1: 連線伺服器失敗。請確認網路連

SparkStream WordCount程式碼詳解

下面我要引用的程式碼來自於sparkStream的官網案例，案例內容為從kafka讀取資料進行wordcount計算 package org.apache.spark.examples.streaming; import java.util.HashMap; import java.util.

OHEM演算法及Caffe程式碼詳解

版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/u014380165/article/details/73148073 這是CVPR2016的一篇論文，用於目標檢測，本篇博文先介紹這個演算法，然後介紹其Caffe程

batchnorm原理及程式碼詳解（筆記2）

Batchnorm原理詳解前言：Batchnorm是深度網路中經常用到的加速神經網路訓練，加速收斂速度及穩定性的演算法，可以說是目前深度網路必不可少的一部分。本文旨在用通俗易懂的語言，對深度學習的常用演算法–batchnorm的原理及其程式碼實現做一個詳細的解讀。本文主要包括以下幾個

XUtils3程式碼詳解--http

官方訪問網路用法：

原始碼檢視：

相關推薦