一、前言

Qt 使用 QNetworkAccessManager 访问网络，这里对其进行了简单的封装，访问网络的代码可以简化为: 
  1. // [[1]] GET 请求无参数
  2. HttpClient("http://localhost:8080/device").success([](const QString &response) {
  3.     qDebug() << response;
  4. }).get();

二、main.cpp

main() 函数里展示了 HttpClient 的使用示例。 
  1. #include <QApplication>
  2. #include <QNetworkAccessManager>
  3. #include <QDebug>
  4. #include <QFile>
  5. #include "HttpClient.h"
  7. int main(int argc, char *argv[]) {
  8. QApplication a(argc, argv);
  10. // 在代码块里执行网络访问，是为了测试 HttpClient 对象在被析构后，网络访问的回调函数仍然能正常执行
  11. {
  13.     // [[1]] GET 请求无参数
  14.     HttpClient("http://localhost:8080/device").success([](const QString &response) {
  15.         qDebug() << response;
  16.     }).get();
  18.     // [[2]] GET 请求有参数，有自定义 header
  19.     HttpClient("http://localhost:8080/device").success([](const QString &response) {
  20.         qDebug() << response;
  21.     }).param("id", "1").param("name", "诸葛亮").header("token", "123AS#D").get();
  24.     // [[3]] POST 请求有参数，有自定义 header
  25.     HttpClient("http://localhost:8080/device").success([](const QString &response) {
  26.         qDebug() << response;
  27.     }).param("id", "2").param("name", "卧龙").header("token", "DER#2J7")
  28.     .header("content-type", "application/x-www-form-urlencoded").post();
  30.     // [[4]] 每创建一个 QNetworkAccessManager 对象都会创建一个线程，当频繁的访问网络时，为了节省线程资源，调用 useManager()
  31.     // 使用共享的 QNetworkAccessManager，它不会被 HttpClient 删除。
  32.     // 如果下面的代码不传入 QNetworkAccessManager，从任务管理器里可以看到创建了几千个线程。
  33.     QNetworkAccessManager *manager = new QNetworkAccessManager();
  34.     for (int i = 0; i < 5000; ++i) {
  35.         HttpClient("http://localhost:8080/device").success([=](const QString &response) {
  36.             qDebug() << response << ", " << i;
  37.         }).manager(manager).get();
  38.     }
  39. }
  41.     return a.exec();
  42. }

三、HttpClient.h

  1. #ifndef HTTPCLIENT_H
  2. #define HTTPCLIENT_H
  4. #include <functional>
  5. #include <QMap>
  6. #include <QVariant>
  7. #include <QStringList>
  8. #include <QNetworkReply>
  9. #include <QNetworkRequest>
  10. #include <QNetworkAccessManager>
  12. class HttpClientPrivate;
  14. /**
  15. * 对 QNetworkAccessManager 简单封装的 HTTP 访问客户端，简化 GET、POST、PUT、DELETE、上传、下载等操作。
  16. * 在执行请求前设置需要的参数和回调函数:
  17. *     1. 调用 header() 设置请求头
  18. *     2. 调用 param() 设置参数，使用 Form 表单的方式提交请求，GET 请求的 query parameters 也可以用它设置
  19. *     3. 调用 json() 设置 JSON 字符串的 request body，Content-Type 为 application/json，
  20. *        当然也可以不是 JSON 格式，因使用 request body 的情况多数是使用 JSON 格式传递复杂对象，故命名为 json
  21. *     4. 调用 success() 注册请求成功的回调函数
  22. *     5. 调用 fail() 注册请求失败的回调函数
  23. *     6. 调用 complete() 注册请求结束的回调函数
  24. *        success(), fail(), complete() 的回调函数是可选的，根据需要注册对应的回调函数，也可以一个都不注册
  25. * 然后根据请求的类型调用 get(), post(), put(), remove(), download(), upload() 执行 HTTP 请求
  26. *
  27. * 默认 HttpClient 会创建一个 QNetworkAccessManager，如果不想使用默认的，调用 manager() 传入即可。
  28. * 调用 debug(true) 设置为调试模式，输出调试信息如 URL、参数等。
  29. */
  30. class HttpClient {
  31. public:
  32.     HttpClient(const QString &url);
  33.     ~HttpClient();
  34.     void stop2();
  36.     /**
  37.     * @brief 每创建一个 QNetworkAccessManager 对象都会创建一个线程，当频繁的访问网络时，为了节省线程资源，
  38.     *     可以传入 QNetworkAccessManager 给多个请求共享 (它不会被 HttpClient 删除，用户需要自己手动删除)。
  39.     *     如果没有使用 manager() 传入一个 QNetworkAccessManager，则 HttpClient 会自动的创建一个，并且在网络访问完成后自动删除它。
  40.     *
  41.     * @param  manager 执行 HTTP 请求的 QNetworkAccessManager 对象
  42.     * @return 返回 HttpClient 的引用，可以用于链式调用
  43.     */
  44.     HttpClient& manager(QNetworkAccessManager *manager);
  46.     /**
  47.     * @brief  参数 debug 为 true 则使用 debug 模式，请求执行时输出请求的 URL 和参数等
  48.     *
  49.     * @param  debug 是否启用调试模式
  50.     * @return 返回 HttpClient 的引用，可以用于链式调用
  51.     */
  52.     HttpClient& debug(bool debug);
  54.     /**
  55.     * @brief 添加一个请求的参数，可以多次调用添加多个参数
  56.     *
  57.     * @param name  参数的名字
  58.     * @param value 参数的值
  59.     * @return 返回 HttpClient 的引用，可以用于链式调用
  60.     */
  61.     HttpClient& param(const QString &name, const QVariant &value);
  63.     /**
  64.     * @brief 添加多个请求的参数
  65.     *
  66.     * @param ps QMap 类型的参数，key 为参数名，value 为参数值
  67.     *           可以使用 {{"name", 1}, {"box", 2}} 的方式创建 QMap 对象
  68.     * @return 返回 HttpClient 的引用，可以用于链式调用
  69.     */
  70.     HttpClient& params(const QMap<QString, QVariant> &ps);
  72.     /**
  73.     * @brief 添加请求的参数 (请求体)，使用 Json 格式，例如 "{\"name\": \"Alice\"}"
  74.     *
  75.     * @param json 请求体 (request body) 为 Json 格式的参数字符串
  76.     * @return 返回 HttpClient 的引用，可以用于链式调用
  77.     */
  78.     HttpClient& json(const QString &json);
  80.     /**
  81.     * @brief 添加请求头
  82.     *
  83.     * @param name  请求头的名字
  84.     * @param value 请求头的值
  85.     * @return 返回 HttpClient 的引用，可以用于链式调用
  86.     */
  87.     HttpClient& header(const QString &name, const QString &value);
  89.     /**
  90.     * @brief 添加多个请求头
  91.     *
  92.     * @param nameValues 请求头的名字和值对
  93.     *                   可以使用 {{"name", 1}, {"box", 2}} 的方式创建 QMap 对象
  94.     * @return 返回 HttpClient 的引用，可以用于链式调用
  95.     */
  96.     HttpClient& headers(const QMap<QString, QString> nameValues);
  98.     /**
  99.     * @brief 注册请求成功的回调函数
  100.     *
  101.     * @param successHandler 成功的回调函数，参数为响应的字符串
  102.     * @return 返回 HttpClient 的引用，可以用于链式调用
  103.     */
  104.     HttpClient& success(std::function<void(const QString &)> successHandler);
  106.     /**
  107.     * @brief 注册请求失败的回调函数
  108.     *
  109.     * @param failHandler 失败的回调函数，参数为失败原因和 HTTP 状态码
  110.     * @return 返回 HttpClient 的引用，可以用于链式调用
  111.     */
  112.     HttpClient& fail(std::function<void(const QString &, int)> failHandler);
  114.     /**
  115.     * @brief 注册请求结束的回调函数，不管成功还是失败请求结束后都会执行
  116.     *
  117.     * @param completeHandler 完成的回调函数，无参数
  118.     * @return 返回 HttpClient 的引用，可以用于链式调用
  119.     */
  120.     HttpClient& complete(std::function<void()> completeHandler);
  122.     /**
  123.     * @brief 设置请求响应的字符集，默认使用 UTF-8
  124.     *
  125.     * @param cs 字符集
  126.     * @return 返回 HttpClient 的引用，可以用于链式调用
  127.     */
  128.     HttpClient& charset(const QString &cs);
  130.     /**
  131.     * @brief 执行 GET 请求
  132.     */
  133.     void get();
  135.     /**
  136.     * @brief 执行 POST 请求
  137.     */
  138.     void post();
  140.     /**
  141.     * @brief 执行 PUT 请求
  142.     */
  143.     void put();
  145.     /**
  146.     * @brief 执行 DELETE 请求，由于 delete 是 C++ 的运算符，所以用同义词 remove
  147.     *        注意: Qt 提供的 DELETE 请求是不支持传递参数的，
  148.     *        请参考 QNetworkAccessManager::deleteResource(const QNetworkRequest &request)
  149.     */
  150.     void remove();
  152.     /**
  153.     * @brief 使用 GET 进行下载，下载的文件保存到 savePath
  154.     *
  155.     * @param savePath 下载的文件保存路径
  156.     */
  157.     void download(const QString &savePath);
  159.     /**
  160.     * @brief 上传单个文件
  161.     *        使用 POST 上传，服务器端获取文件的参数名为 file
  162.     *
  163.     * @param path 要上传的文件的路径
  164.     */
  165.     void upload(const QString &path);
  167.     /**
  168.     * @brief 上传文件，文件的内容已经读取到 data 中
  169.     *        使用 POST 上传，服务器端获取文件的参数名为 file
  170.     *
  171.     * @param path 要上传的文件的路径
  172.     */
  173.     void upload(const QByteArray &data);
  175.     /**
  176.     * @brief 上传多个文件
  177.     *        使用 POST 上传，服务器端获取文件的参数名为 files
  178.     *
  179.     * @param paths 要上传的文件的路径
  180.     */
  181.     void upload(const QStringList &paths);
  183. private:
  184.     HttpClientPrivate *d;
  185. };
  187. #endif // HTTPCLIENT_H

四、HttpClient.cpp

  1. #include "HttpClient.h"
  3. #include <QDebug>
  4. #include <QFile>
  5. #include <QHash>
  6. #include <QUrlQuery>
  7. #include <QHttpPart>
  8. #include <QHttpMultiPart>
  10. /*-----------------------------------------------------------------------------|
  11. |                              HttpClientPrivate                              |
  12. |----------------------------------------------------------------------------*/
  13. /**
  14. * @brief 请求的类型
  15. *
  16. * 注: UPLOAD 不是 HTTP Method，只是为了上传时对请求进行特殊处理而定义的
  17. */
  18. enum class HttpClientRequestMethod {
  19.     GET, POST, PUT, DELETE, UPLOAD
  20. };
  22. /**
  23. * @brief 缓存 HttpClientPrivate 的数据成员，方便在异步 lambda 中使用 = 以值的方式访问。
  24. */
  25. class HttpClientPrivateCache {
  26. public:
  27.     std::function<void(const QString &)>      successHandler = nullptr;
  28.     std::function<void(const QString &, int)>    failHandler = nullptr;
  29.     std::function<void()>                    completeHandler = nullptr;
  30.     bool debug = false;
  31.     bool internal = false;
  32.     QString charset;
  33.     QNetworkAccessManager* manager = nullptr;
  34. };
  36. /**
  37. * @brief HttpClient 的辅助类，封装不希望暴露给客户端的数据和方法，使得 HttpClient 只暴露必要的 API 给客户端。
  38. */
  39. class HttpClientPrivate {
  40.     friend class HttpClient;
  42.     HttpClientPrivate(const QString &url);
  43.     ~HttpClientPrivate();
  44.     void stop1();
  46.     /**
  47.     * @brief 缓存 HttpClientPrivate 的数据成员
  48.     *
  49.     * @return 返回 HttpClientPrivateCache 缓存对象
  50.     */
  51.     HttpClientPrivateCache cache();
  53.     /**
  54.     * @brief 获取 Manager，如果传入了 manager 则返回此 manager，否则新创建一个 manager，默认会自动创建一个 manager，
  55.     *        使用传入的 manager 则 interval 被设置为 false，自动创建的 manager 则设置 interval 为 true
  56.     *
  57.     * @return 返回 QNetworkAccessManager 对象
  58.     */
  59.     QNetworkAccessManager* getManager();
  61.     /**
  62.     * @brief 使用用户设定的 URL、请求头、参数等创建 Request
  63.     *
  64.     * @param d      HttpClientPrivate 的对象
  65.     * @param method 请求的类型
  66.     * @return 返回可用于执行请求的 QNetworkRequest
  67.     */
  68.     static QNetworkRequest createRequest(HttpClientPrivate *d, HttpClientRequestMethod method);
  70.     /**
  71.     * @brief 执行请求的辅助函数
  72.     *
  73.     * @param d      HttpClientPrivate 的对象
  74.     * @param method 请求的类型
  75.     */
  76.     static void executeQuery(HttpClientPrivate *d, HttpClientRequestMethod method);
  78.     /**
  79.     * @brief 上传文件或者数据
  80.     *
  81.     * @param d     HttpClientPrivate 的对象
  82.     * @param paths 要上传的文件的路径(path 和 data 不能同时使用)
  83.     * @param data  要上传的文件的数据
  84.     */
  85.     static void upload(HttpClientPrivate *d, const QStringList &paths, const QByteArray &data);
  87.     /**
  88.     * @brief 使用 GET 进行下载，下载的文件保存到 savePath
  89.     *
  90.     * @param d        HttpClientPrivate 的对象
  91.     * @param savePath 下载的文件保存路径
  92.     */
  93.     static void download(HttpClientPrivate *d, const QString &savePath);
  95.     /**
  96.     * @brief 使用 GET 进行下载，当有数据可读取时回调 readyRead(), 大多数情况下应该在 readyRead() 里把数据保存到文件
  97.     *
  98.     * @param readyRead 有数据可读取时的回调 lambda 函数
  99.     */
  100.     static void download(HttpClientPrivate *d, std::function<void(const QByteArray &)> readyRead);
  102.     /**
  103.     * @brief 读取服务器响应的数据
  104.     *
  105.     * @param reply   请求的 QNetworkReply 对象
  106.     * @param charset 请求响应的字符集，默认使用 UTF-8
  107.     * @return 返回服务器端响应的字符串
  108.     */
  109.     static QString readReply(QNetworkReply *reply, const QString &charset = "UTF-8");
  111.     /**
  112.     * @brief 请求结束的处理函数
  113.     *
  114.     * @param cache          HttpClientPrivateCache 缓存对象
  115.     * @param reply          QNetworkReply 对象，不能为 NULL
  116.     * @param successMessage 请求成功的消息
  117.     * @param failMessage    请求失败的消息
  118.     */
  119.     static void handleFinish(HttpClientPrivateCache cache, QNetworkReply *reply, const QString &successMessage, const QString &failMessage);
  121.     /////////////////////////////////////////////////// 成员变量 //////////////////////////////////////////////
  122.     QString   url;                            // 请求的 URL
  123.     QString   json;                           // 请求的参数使用 Json 格式
  124.     QUrlQuery params;                         // 请求的参数使用 Form 格式
  125.     QString   charset = "UTF-8";              // 请求响应的字符集
  126.     QHash<QString, QString> headers;          // 请求头
  127.     QNetworkAccessManager *manager = nullptr; // 执行 HTTP 请求的 QNetworkAccessManager 对象
  128.     bool useJson = false;                    // 为 true 时请求使用 Json 格式传递参数，否则使用 Form 格式传递参数
  129.     bool debug = false;                    // 为 true 时输出请求的 URL 和参数
  130.     bool internal = true;                     // 是否使用自动创建的 manager
  132.     std::function<void(const QString &)>   successHandler = nullptr; // 成功的回调函数，参数为响应的字符串
  133.     std::function<void(const QString &, int)> failHandler = nullptr; // 失败的回调函数，参数为失败原因和 HTTP status code
  134.     std::function<void()>                 completeHandler = nullptr; // 结束的回调函数，无参数
  135. };
  137. HttpClientPrivate::HttpClientPrivate(const QString &url) : url(url) { }
  139. HttpClientPrivate::~HttpClientPrivate() {
  140.     manager = nullptr;
  141.     successHandler = nullptr;
  142.     failHandler = nullptr;
  143.     completeHandler = nullptr;
  144. }
  146. void HttpClientPrivate::stop1()
  147. {
  148.     manager->deleteLater();
  149. }
  151. // 缓存 HttpClientPrivate 的数据成员
  152. HttpClientPrivateCache HttpClientPrivate::cache() {
  153.     HttpClientPrivateCache cache;
  155.     cache.successHandler = successHandler;
  156.     cache.failHandler = failHandler;
  157.     cache.completeHandler = completeHandler;
  158.     cache.debug = debug;
  159.     cache.internal = internal;
  160.     cache.charset = charset;
  161.     cache.manager = getManager();
  163.     return cache;
  164. }
  166. // 执行请求的辅助函数
  167. void HttpClientPrivate::executeQuery(HttpClientPrivate *d, HttpClientRequestMethod method) {
  168.     // 1. 缓存需要的变量，在 lambda 中使用 = 捕获进行值传递 (不能使用引用 &，因为 d 已经被析构)
  169.     // 2. 创建请求需要的变量
  170.     // 3. 根据 method 执行不同的请求
  171.     // 4. 请求结束时获取响应数据，在 handleFinish 中执行回调函数
  173.     // [1] 缓存需要的变量，在 lambda 中使用 = 捕获进行值传递 (不能使用引用 &，因为 d 已经被析构)
  174.     HttpClientPrivateCache cache = d->cache();
  176.     // [2] 创建请求需要的变量
  177.     QNetworkRequest request = HttpClientPrivate::createRequest(d, method);
  178.     QNetworkReply    *reply = nullptr;
  180.     // [3] 根据 method 执行不同的请求
  181.     switch (method) {
  182.     case HttpClientRequestMethod::GET:
  183.         reply = cache.manager->get(request);
  184.         break;
  185.     case HttpClientRequestMethod::POST:
  186.         reply = cache.manager->post(request, d->useJson ? d->json.toUtf8() : d->params.toString(QUrl::FullyEncoded).toUtf8());
  187.         break;
  188.     case HttpClientRequestMethod::PUT:
  189.         reply = cache.manager->put(request, d->useJson ? d->json.toUtf8() : d->params.toString(QUrl::FullyEncoded).toUtf8());
  190.         break;
  191.     case HttpClientRequestMethod::DELETE:
  192.         reply = cache.manager->deleteResource(request);
  193.         break;
  194.     default:
  195.         break;
  196.     }
  198.     // [4] 请求结束时获取响应数据，在 handleFinish 中执行回调函数
  199.     // 请求结束时一次性读取所有响应数据
  200.     QObject::connect(reply, &QNetworkReply::finished, [=] {
  201.         QString successMessage = HttpClientPrivate::readReply(reply, cache.charset.toUtf8());
  202.         QString failMessage = reply->errorString();
  203.         HttpClientPrivate::handleFinish(cache, reply, successMessage, failMessage);
  204.     });
  205. }
  207. // 使用 GET 进行下载，下载的文件保存到 savePath
  208. void HttpClientPrivate::download(HttpClientPrivate *d, const QString &savePath) {
  209.     // 1. 打开下载文件，如果打开文件出错，不进行下载
  210.     // 2. 给请求结束的回调函数注入关闭释放文件的行为
  211.     // 3. 调用下载的重载函数开始下载
  212.     QFile *file = new QFile(savePath);
  214.     // [1] 打开下载文件，如果打开文件出错，不进行下载
  215.     if (!file->open(QIODevice::WriteOnly | QIODevice::Truncate)) {
  216.         file->close();
  217.         file->deleteLater();
  219.         if (d->debug) {
  220.             qDebug().noquote() << QString("[错误] 打开文件出错: %1").arg(savePath);
  221.         }
  223.         if (nullptr != d->failHandler) {
  224.             d->failHandler(QString("[错误] 打开文件出错: %1").arg(savePath), -1);
  225.         }
  227.         return;
  228.     }
  230.     // [2] 给请求结束的回调函数注入关闭释放文件的行为
  231.     std::function<void()> userCompleteHandler = d->completeHandler;
  232.     std::function<void()> injectedCompleteHandler = [=]() {
  233.         // 请求结束后释放文件对象
  234.         file->flush();
  235.         file->close();
  236.         file->deleteLater();
  238.         // 执行用户指定的结束回调函数
  239.         if (nullptr != userCompleteHandler) {
  240.             userCompleteHandler();
  241.         }
  242.     };
  243.     d->completeHandler = injectedCompleteHandler;
  245.     // [3] 调用下载的重载函数开始下载
  246.     HttpClientPrivate::download(d, [=](const QByteArray &data) {
  247.         file->write(data);
  248.     });
  249. }
  251. // 使用 GET 进行下载，当有数据可读取时回调 readyRead(), 大多数情况下应该在 readyRead() 里把数据保存到文件
  252. void HttpClientPrivate::download(HttpClientPrivate *d, std::function<void(const QByteArray &)> readyRead) {
  253.     // 1. 缓存需要的变量，在 lambda 中使用 = 捕获进行值传递 (不能使用引用 &，因为 d 已经被析构)
  254.     // 2. 创建请求需要的变量，执行请求
  255.     // 3. 有数据可读取时回调 readyRead()
  256.     // 4. 请求结束时获取响应数据，在 handleFinish 中执行回调函数
  258.     // [1] 缓存需要的变量，在 lambda 中使用 = 捕捉使用 (不能使用引用 &，因为 d 已经被析构)
  259.     HttpClientPrivateCache cache = d->cache();
  261.     // [2] 创建请求需要的变量，执行请求
  262.     QNetworkRequest request = HttpClientPrivate::createRequest(d, HttpClientRequestMethod::GET);
  263.     QNetworkReply    *reply = cache.manager->get(request);
  265.     // [3] 有数据可读取时回调 readyRead()
  266.     QObject::connect(reply, &QNetworkReply::readyRead, [=] {
  267.         readyRead(reply->readAll());
  268.     });
  270.     // [4] 请求结束时获取响应数据，在 handleFinish 中执行回调函数
  271.     QObject::connect(reply, &QNetworkReply::finished, [=] {
  272.         QString successMessage = "下载完成"; // 请求结束时一次性读取所有响应数据
  273.         QString failMessage = reply->errorString();
  274.         HttpClientPrivate::handleFinish(cache, reply, successMessage, failMessage);
  275.     });
  276. }
  278. // 上传文件或者数据的实现
  279. void HttpClientPrivate::upload(HttpClientPrivate *d, const QStringList &paths, const QByteArray &data) {
  280.     // 1. 缓存需要的变量，在 lambda 中使用 = 捕获进行值传递 (不能使用引用 &，因为 d 已经被析构)
  281.     // 2. 创建 Form 表单的参数 Text Part
  282.     // 3. 创建上传的 File Part
  283.     //    3.1 使用文件创建 File Part
  284.     //    3.2 使用数据创建 File Part
  285.     // 4. 创建请求需要的变量，执行请求
  286.     // 5. 请求结束时释放 multiPart 和打开的文件，获取响应数据，在 handleFinish 中执行回调函数
  288.     // [1] 缓存需要的变量，在 lambda 中使用 = 捕捉使用 (不能使用引用 &，因为 d 已经被析构)
  289.     HttpClientPrivateCache cache = d->cache();
  291.     // [2] 创建 Form 表单的参数 Text Part
  292.     QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
  293.     QList<QPair<QString, QString> > paramItems = d->params.queryItems();
  294.     for (int i = 0; i < paramItems.size(); ++i) {
  295.         QString name = paramItems.at(i).first;
  296.         QString value = paramItems.at(i).second;
  298.         QHttpPart textPart;
  299.         textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QString("form-data; name=\"%1\"").arg(name));
  300.         textPart.setBody(value.toUtf8());
  301.         multiPart->append(textPart);
  302.     }
  304.     if (paths.size() > 0) {
  305.         // [3.1] 使用文件创建 File Part
  306.         QString inputName = paths.size() == 1 ? "file" : "files"; // 一个文件时为 file，多个文件时为 files
  308.         for (const QString &path : paths) {
  309.             // path 为空时，不上传文件
  310.             if (path.isEmpty()) {
  311.                 continue;
  312.             }
  314.             // We cannot delete the file now, so delete it with the multiPart
  315.             QFile *file = new QFile(path, multiPart);
  317.             // 如果文件打开失败，则释放资源返回，终止上传
  318.             if (!file->open(QIODevice::ReadOnly)) {
  319.                 QString failMessage = QString("打开文件失败[%2]: %1").arg(path).arg(file->errorString());
  321.                 if (cache.debug) {
  322.                     qDebug().noquote() << failMessage;
  323.                 }
  325.                 if (nullptr != cache.failHandler) {
  326.                     cache.failHandler(failMessage, -1);
  327.                 }
  329.                 multiPart->deleteLater();
  330.                 return;
  331.             }
  333.             // 单个文件时，name 为服务器端获取文件的参数名，为 file
  334.             // 多个文件时，name 为服务器端获取文件的参数名，为 files
  335.             // 注意: 服务器是 Java 的则用 form-data
  336.             // 注意: 服务器是 PHP  的则用 multipart/form-data
  337.             QString disposition = QString("form-data; name=\"%1\"; filename=\"%2\"").arg(inputName).arg(file->fileName());
  338.             QHttpPart filePart;
  339.             filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(disposition));
  340.             filePart.setBodyDevice(file);
  341.             multiPart->append(filePart);
  342.         }
  343.     }
  344.     else {
  345.         // [3.2] 使用数据创建 File Part
  346.         QString   disposition = QString("form-data; name=\"file\"; filename=\"no-name\"");
  347.         QHttpPart dataPart;
  348.         dataPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(disposition));
  349.         dataPart.setBody(data);
  350.         multiPart->append(dataPart);
  351.     }
  353.     // [4] 创建请求需要的变量，执行请求
  354.     QNetworkRequest request = HttpClientPrivate::createRequest(d, HttpClientRequestMethod::UPLOAD);
  355.     QNetworkReply    *reply = cache.manager->post(request, multiPart);
  357.     // [5] 请求结束时释放 multiPart 和文件，获取响应数据，在 handleFinish 中执行回调函数
  358.     QObject::connect(reply, &QNetworkReply::finished, [=] {
  359.         multiPart->deleteLater(); // 释放资源: multiPart + file
  361.         QString successMessage = HttpClientPrivate::readReply(reply, cache.charset); // 请求结束时一次性读取所有响应数据
  362.         QString failMessage = reply->errorString();
  363.         HttpClientPrivate::handleFinish(cache, reply, successMessage, failMessage);
  364.     });
  365. }
  367. // 获取 Manager，如果传入了 manager 则返回此 manager，否则新创建一个 manager，默认会自动创建一个 manager
  368. QNetworkAccessManager* HttpClientPrivate::getManager() {
  369.     return internal ? new QNetworkAccessManager() : manager;
  370. }
  372. // 使用用户设定的 URL、请求头、参数等创建 Request
  373. QNetworkRequest HttpClientPrivate::createRequest(HttpClientPrivate *d, HttpClientRequestMethod method) {
  374.     // 1. 如果是 GET 请求，并且参数不为空，则编码请求的参数，放到 URL 后面
  375.     // 2. 调试时输出网址和参数
  376.     // 3. 设置 Content-Type
  377.     // 4. 添加请求头到 request 中
  379.     bool get = method == HttpClientRequestMethod::GET;
  380.     bool upload = method == HttpClientRequestMethod::UPLOAD;
  381.     bool withForm = !get && !upload && !d->useJson; // PUT、POST 或者 DELETE 请求，且 useJson 为 false
  382.     bool withJson = !get && !upload &&  d->useJson; // PUT、POST 或者 DELETE 请求，且 useJson 为 true
  384.                                                     // [1] 如果是 GET 请求，并且参数不为空，则编码请求的参数，放到 URL 后面
  385.     if (get && !d->params.isEmpty()) {
  386.         d->url += "?" + d->params.toString(QUrl::FullyEncoded);
  387.     }
  389.     // [2] 调试时输出网址和参数
  390.     if (d->debug) {
  391.         qDebug().noquote() << "[网址]" << d->url;
  393.         if (withJson) {
  394.             qDebug().noquote() << "[参数]" << d->json;
  395.         }
  396.         else if (withForm || upload) {
  397.             QList<QPair<QString, QString> > paramItems = d->params.queryItems();
  398.             QString buffer; // 避免多次调用 qDebug() 输入调试信息，每次 qDebug() 都有可能输出行号等
  400.                             // 按键值对的方式输出参数
  401.             for (int i = 0; i < paramItems.size(); ++i) {
  402.                 QString name = paramItems.at(i).first;
  403.                 QString value = paramItems.at(i).second;
  405.                 if (0 == i) {
  406.                     buffer += QString("[参数] %1=%2\n").arg(name).arg(value);
  407.                 }
  408.                 else {
  409.                     buffer += QString("       %1=%2\n").arg(name).arg(value);
  410.                 }
  411.             }
  413.             if (!buffer.isEmpty()) {
  414.                 qDebug().noquote() << buffer;
  415.             }
  416.         }
  417.     }
  419.     // [3] 设置 Content-Type
  420.     // 如果是 POST 请求，useJson 为 true 时添加 Json 的请求头，useJson 为 false 时添加 Form 的请求头
  421.     if (withForm) {
  422.         d->headers["Content-Type"] = "application/x-www-form-urlencoded";
  423.     }
  424.     else if (withJson) {
  425.         d->headers["Content-Type"] = "application/json; charset=utf-8";
  426.     }
  428.     // [4] 添加请求头到 request 中
  429.     QNetworkRequest request(QUrl(d->url));
  430.     for (auto i = d->headers.cbegin(); i != d->headers.cend(); ++i) {
  431.         request.setRawHeader(i.key().toUtf8(), i.value().toUtf8());
  432.     }
  434.     return request;
  435. }
  437. // 读取服务器响应的数据
  438. QString HttpClientPrivate::readReply(QNetworkReply *reply, const QString &charset) {
  439.     QTextStream in(reply);
  440.     QString result;
  441.     in.setCodec(charset.toUtf8());
  443.     while (!in.atEnd()) {
  444.         result += in.readLine();
  445.     }
  447.     return result;
  448. }
  450. // 请求结束的处理函数
  451. void HttpClientPrivate::handleFinish(HttpClientPrivateCache cache, QNetworkReply *reply, const QString &successMessage, const QString &failMessage) {
  452.     // 1. 执行请求成功的回调函数
  453.     // 2. 执行请求失败的回调函数
  454.     // 3. 执行请求结束的回调函数
  455.     // 4. 释放 reply 和 manager 对象
  457.     if (reply->error() == QNetworkReply::NoError) {
  458.         if (cache.debug) {
  459.             qDebug().noquote() << QString("[结束] 成功: %1").arg(successMessage);
  460.         }
  462.         // [1] 执行请求成功的回调函数
  463.         if (nullptr != cache.successHandler) {
  464.             cache.successHandler(successMessage);
  465.         }
  466.     }
  467.     else {
  468.         if (cache.debug) {
  469.             qDebug().noquote() << QString("[结束] 失败: %1").arg(failMessage);
  470.         }
  472.         // [2] 执行请求失败的回调函数
  473.         if (nullptr != cache.failHandler) {
  474.             cache.failHandler(failMessage, reply->error());
  475.         }
  476.     }
  478.     // [3] 执行请求结束的回调函数
  479.     if (nullptr != cache.completeHandler) {
  480.         cache.completeHandler();
  481.     }
  483.     // [4] 释放 reply 和 manager 对象
  484.     if (nullptr != reply) {
  485.         reply->deleteLater();
  486.     }
  488.     if (cache.internal && nullptr != cache.manager) {
  489.         cache.manager->deleteLater();
  490.     }
  491. }
  493. /*-----------------------------------------------------------------------------|
  494. |                                 HttpClient                                  |
  495. |----------------------------------------------------------------------------*/
  497. // 注意: 在异步请求中 HttpClient 的 HttpClientPrivate 成员变量 d 已经被析构，所以需要先缓存相关变量为栈对象，使用 = 以值的方式访问
  498. HttpClient::HttpClient(const QString &url) : d(new HttpClientPrivate(url)) { }
  500. HttpClient::~HttpClient() {
  501.     delete d;
  502. }
  504. void HttpClient::stop2()
  505. {
  506.     d->stop1();
  507. }
  509. // 传入 QNetworkAccessManager 给多个请求共享
  510. HttpClient& HttpClient::manager(QNetworkAccessManager *manager) {
  511.     d->manager = manager;
  512.     d->internal = (nullptr == manager);
  514.     return *this;
  515. }
  517. // 传入 debug 为 true 则使用 debug 模式，请求执行时输出请求的 URL 和参数等
  518. HttpClient& HttpClient::debug(bool debug) {
  519.     d->debug = debug;
  521.     return *this;
  522. }
  524. // 添加一个请求的参数，可以多次调用添加多个参数
  525. HttpClient& HttpClient::param(const QString &name, const QVariant &value) {
  526.     d->params.addQueryItem(name, value.toString());
  528.     return *this;
  529. }
  531. // 添加多个请求的参数
  532. HttpClient& HttpClient::params(const QMap<QString, QVariant> &ps) {
  533.     for (auto iter = ps.cbegin(); iter != ps.cend(); ++iter) {
  534.         d->params.addQueryItem(iter.key(), iter.value().toString());
  535.     }
  537.     return *this;
  538. }
  540. // 添加请求的参数 (请求体)，使用 Json 格式，例如 "{\"name\": \"Alice\"}"
  541. HttpClient& HttpClient::json(const QString &json) {
  542.     d->json = json;
  543.     d->useJson = true;
  545.     return *this;
  546. }
  548. // 添加请求头
  549. HttpClient& HttpClient::header(const QString &name, const QString &value) {
  550.     d->headers[name] = value;
  552.     return *this;
  553. }
  555. // 添加多个请求头
  556. HttpClient& HttpClient::headers(const QMap<QString, QString> nameValues) {
  557.     for (auto i = nameValues.cbegin(); i != nameValues.cend(); ++i) {
  558.         d->headers[i.key()] = i.value();
  559.     }
  561.     return *this;
  562. }
  564. // 注册请求成功的回调函数
  565. HttpClient& HttpClient::success(std::function<void(const QString &)> successHandler) {
  566.     d->successHandler = successHandler;
  568.     return *this;
  569. }
  571. // 注册请求失败的回调函数
  572. HttpClient& HttpClient::fail(std::function<void(const QString &, int)> failHandler) {
  573.     d->failHandler = failHandler;
  575.     return *this;
  576. }
  578. // 注册请求结束的回调函数，不管成功还是失败都会执行
  579. HttpClient& HttpClient::complete(std::function<void()> completeHandler) {
  580.     d->completeHandler = completeHandler;
  582.     return *this;
  583. }
  585. // 设置请求响应的编码
  586. HttpClient& HttpClient::charset(const QString &cs) {
  587.     d->charset = cs;
  589.     return *this;
  590. }
  592. // 执行 GET 请求
  593. void HttpClient::get() {
  594.     HttpClientPrivate::executeQuery(d, HttpClientRequestMethod::GET);
  595. }
  597. // 执行 POST 请求
  598. void HttpClient::post() {
  599.     HttpClientPrivate::executeQuery(d, HttpClientRequestMethod::POST);
  600. }
  602. // 执行 PUT 请求
  603. void HttpClient::put() {
  604.     HttpClientPrivate::executeQuery(d, HttpClientRequestMethod::PUT);
  605. }
  607. // 执行 DELETE 请求
  608. void HttpClient::remove() {
  609.     HttpClientPrivate::executeQuery(d, HttpClientRequestMethod::DELETE);
  610. }
  612. // 使用 GET 进行下载，下载的文件保存到 savePath
  613. void HttpClient::download(const QString &savePath) {
  614.     HttpClientPrivate::download(d, savePath);
  615. }
  617. // 上传文件
  618. void HttpClient::upload(const QString &path) {
  619.     QStringList paths = { path };
  620.     HttpClientPrivate::upload(d, paths, QByteArray());
  621. }
  623. // 上传文件，文件的内容以及读取到 data 中
  624. void HttpClient::upload(const QByteArray &data) {
  625.     HttpClientPrivate::upload(d, QStringList(), data);
  626. }
  628. // 上传多个文件
  629. void HttpClient::upload(const QStringList &paths) {
  630.     HttpClientPrivate::upload(d, paths, QByteArray());
  631. }