xUtils3源码解析之-----Http(s)

男娘i 2022-05-28 13:05 193阅读 0赞

--------------------

> 利用工作之外的时间终于看完了xutils3的所有模块的源码，以此博客来记录自己的分析过程，在此约定半年之后重新分析xUtils3源码对比该系列博客看看自己有没有新的突破。

[1. xUtils3源码解析之—–image][1. xUtils3_image]  
[2. xUtils3源码解析之—–Http(s)][2. xUtils3_Http_s]  
[3. xUtils3源码分析之—–DB(ORM)][3. xUtils3_DB_ORM]  
[4. xUtils3源码分析之—–view注解][4. xUtils3_view]

# 前言 #

> 下面进行xUtils3的网络请求模块的源码分析。

# 基本使用方法 #

> 通过x.http()得到HttpManagerImpl实例进行get.post等请求，请求参数RequestParams封装了请求的一些信息，还有个接口回调请求响应。[详细的Demo看作者的。][Demo]

BaiduParams params = new BaiduParams();
    x.http().get(params, new Callback.CommonCallback<List<BaiduResponse>>() {
                    @Override
                    public void onSuccess(List<BaiduResponse> result) {
    
                    }
    
                    @Override
                    public void onError(Throwable ex, boolean isOnCallback) {
    
                    }
    
                    @Override
                    public void onCancelled(CancelledException cex) {
    
                    }
    
                    @Override
                    public void onFinished() {
    
                    }
                });
    
        // cancelable.cancel(); // 取消请求
    }

# 源码分析 #

## 异步get请求 ##

> 首先看下异步get请求，我们直接从源码开始看下去。首先通过x.http()得到HttpManagerImpl实例，接着调用该实例的get方法，get方法接着调用requeset方法。request方法首先params保存请求方法，接着创建通过请求参数和回调的接口来HttpTask对象，最后通过得到的httpTask实例传入x.task().start(httpTask)方法；

x.http().get(params, Callback.CommonCallback<T> callback);
    
    @Override
    public <T> Callback.Cancelable get(RequestParams entity, Callback.CommonCallback<T> callback) {
        return request(HttpMethod.GET, entity, callback);
    }
    
     @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);
    }

> 由上 x.task().start(task); x.task()得到TaskControllerImpl实例是xUtils3初始化的时候创建的，我们直接看taskControllerImpl.start(AbsTask task)方法（我们传入的是HttpTask（该类继承AbsTask类)）。该方法首先创建个(通过传入HttpTask实例)TaskProxy代理类该代理类也是继承AbsTask类，接着调用taskProxy.doBackground()方法。doBackground方法首先通过this.onWaiting()设置代理task和真实的Task的状态再通过handler发送消息使真实task(httpTask)相应的接口执行waiting方法。接着创建个优先级线程PriorityRunnable放入线程池中，我们直接看线程的run方法，首先通过TaskProxy.this.onStarted()类似上面的this.onWaiting(）来更新task的状态；接着通过真实task(HttpTask)执行doBackground()方法。

**org.xutils.common.task.TaskControllerImpl;类**

public <T> AbsTask<T> start(AbsTask<T> task) {
        TaskProxy<T> proxy = null;
        if (task instanceof TaskProxy) {
            proxy = (TaskProxy<T>) task;
        } else {
            proxy = new TaskProxy<T>(task);
        }
        try {
            proxy.doBackground();
        } catch (Throwable ex) {
            LogUtil.e(ex.getMessage(), ex);
        }
        return proxy;
    }
    
    **org.xutils.common.task.TaskProxy;类**
    protected final ResultType doBackground() throws Throwable {
        this.onWaiting();
        PriorityRunnable runnable = new PriorityRunnable(
                task.getPriority(),
                new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 等待过程中取消
                            if (callOnCanceled || TaskProxy.this.isCancelled()) {
                                throw new Callback.CancelledException("");
                            }
    
                            // start running
                            TaskProxy.this.onStarted();
    
                            if (TaskProxy.this.isCancelled()) { // 开始时取消
                                throw new Callback.CancelledException("");
                            }
    
                            // 执行task, 得到结果.
                            task.setResult(task.doBackground());
                            TaskProxy.this.setResult(task.getResult());
    
                            // 未在doBackground过程中取消成功
                            if (TaskProxy.this.isCancelled()) {
                                throw new Callback.CancelledException("");
                            }
    
                            // 执行成功
                            TaskProxy.this.onSuccess(task.getResult());
                        } catch (Callback.CancelledException cex) {
                            TaskProxy.this.onCancelled(cex);
                        } catch (Throwable ex) {
                            TaskProxy.this.onError(ex, false);
                        } finally {
                            TaskProxy.this.onFinished();
                        }
                    }
                });
        this.executor.execute(runnable);
        return null;
    }

> 由上面我们走到了HttpTask.doBackground()方法，首先通过resolveLoadType()得到请求参数的类型，接着通过createNewRequest得到UriRequest实例，createNewRequest方法通过请求参数的uri的scheme得到HttpRequest实例(该类继承UriRequest类)该实例创建的过程生产queryUrl属性(uri和请求参数的拼接)。创建完UriRequest之后通过checkDownloadTask方法检测文件下载冲突，接着初始化一些重试的变量，然后是一些缓存的逻辑，我们这边没有配置缓存所以先跳过。接着创建内部类RequestWorker, 调用该内部类实例的request()方法。该request方法首先如果是下载操作能进行一些判断拦截，记着执行request.loadResult()方法，我们从上面的分析过程中知道request是HttpRequest实例，httpRequest.loadResult()方法首先更新isLoading变量，接着调用父类的loadResult()方法，接着调用(该loader(ObjectLoader)是创建HttpRequest实例的时候通过反射得到实例的范型类型然后创建相应的loader实例)loader.load(this);我们接着看ObjectLoader.load(request)方法，该方法首先执行request.sendRequest()方法，request.sendRequest方法也是网络请求的总入口，通过HttpURLConnection(如果配置了SSLSocketFactory则是HttpsURLConnection)配置一些信息(请求头，请求体，cookie等）进行最终的网络请求。ObjectLoader.load(request)方法接着会通过 load(request.getInputStream())方法解析响应的结果，该方法会调用传入范型类的里面的解析类通过parse把响应流解析成用户传入的范型。

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);
                    synchronized (cacheLock) {
                        while (trustCache == null) {
                            try {
                                cacheLock.wait();
                            } catch (InterruptedException iex) {
                                throw new Callback.CancelledException("cancelled before request");
                            } catch (Throwable ignored) {
                            }
                        }
                    }
    
                    // 处理完成
                    if (trustCache) {
                        return null;
                    }
                }
            }
        }
    
        if (trustCache == null) {
            trustCache = false;
        }
    
        if (cacheResult == null) {
            this.request.clearCacheHeader();
        }
    
        // 判断请求的缓存策略
        if (callback instanceof Callback.ProxyCacheCallback) {
            if (((Callback.ProxyCacheCallback) callback).onlyCache()) {
                return null;
            }
        }
    
        // 发起请求
        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();
                    requestWorker.request();
                    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) {
                switch (this.request.getResponseCode()) {
                    case 204: // empty content
                    case 205: // empty content
                    case 304: // disk cache is valid.
                        return null;
                    default: {
                        exception = ex;
                        if (this.isCancelled() && !(exception instanceof Callback.CancelledException)) {
                            exception = new Callback.CancelledException("canceled by user");
                        }
                        retry = retryHandler.canRetry(this.request, exception, ++retryCount);
                    }
                }
            }
    
        }
    
        if (exception != null && result == null && !trustCache) {
            hasException = true;
            throw exception;
        }
    
        return result;
    }

> 我们从下往上整理，由上步骤，ObjectLoader.load(request)方法得到result，那么UriRequest.loadResult()方法得到result，进而HttpRequest.loadResult()方法得到result，进而RequestWorker.request()方法得到result,进而HttpTask.doBackground()方法得到result,进而TaskProxy.doBackground()方法得到result，taskProxy得到result后，通过handler发送成功消息，进而HttpTask.onSuccess(result)执行用户接口方法回调。最终用户得到响应结果～

case MSG_WHAT_ON_SUCCESS: {
                        taskProxy.task.onSuccess(taskProxy.getResult());
                        break;

[1. xUtils3_image]: https://blog.csdn.net/yang_yang1994/article/details/79834439
[2. xUtils3_Http_s]: https://blog.csdn.net/yang_yang1994/article/details/79832655
[3. xUtils3_DB_ORM]: https://blog.csdn.net/yang_yang1994/article/details/79764372
[4. xUtils3_view]: https://blog.csdn.net/yang_yang1994/article/details/79705454
[Demo]: https://github.com/wyouflf/xUtils3/tree/master/sample