QNetworkAccessManager使用的简单封装

最新推荐文章于 2023-05-23 17:03:44 发布
最新推荐文章于 2023-05-23 17:03:44 发布
阅读量471 收藏 3
点赞数
文章标签： json
原文链接：http://www.cnblogs.com/kohlrabi/p/7095238.html
版权

实现对QNetworkAccessManager使用方式的简单封装类：HttpServer

增加：

1. 使用QEventLoop实现同步请求
2. 异步请求可以传一个QVariant参数
3. 可以设置超时时间

限制：

1.只能简单的使用put/post方法
2.post 固定参数 ContentTypeHeader == application/json
3.put 固定参数 ContentTypeHeader == application/x-www-form-urlencoded
4.除上述参数外，其他参数都是默认设置
4.没有考虑https协议

使用方式：

  1. 使用factory函数获取类指针，异步调用可以设置自定义参数，会传给slot函数
  2. 如果异步调用，需连接signal和slot函数，使用setConnectTo可以方便连接参数最多的signal，slot函数
  3. 调用put/post相关函数

例子：
异步：

// 调用
QString url = "http://192.168.1.1:8080/XXX";
QString data = "{}";
QVariant param = 100;
HttpServer *http = HttpServer::factory(this, param);
http->setConnectTo(this);
http->postRequest(url, data);

.................................

// slot函数
void XXX::finished(QNetworkReply *reply, QVariant param, bool timeout)
{
    int myParam = param.toInt();
    int httpCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    QString json = QTextCodec::codecForName("UTF-8")->toUnicode(reply->readAll());
    reply->deleteLater();
}

同步：

HttpServer *http = HttpServer::factory(this);
bool timeout;
auto *reply = http->postRequestSyn(url, data, &timeout);

if(!timeout) {
    int httpCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    QString json = QTextCodec::codecForName("UTF-8")->toUnicode(reply->readAll());
}
reply->deleteLater();
http->deleteLater();

头文件：

#ifndef HTTPSERVER_H
#define HTTPSERVER_H

#include <QObject>
#include <QScopedPointer>
#include <QtNetwork/QNetworkAccessManager>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkRequest>
#include <QTimer>

class HttpServer : public QObject
{
    Q_OBJECT
public:
    static HttpServer *factory(QObject *parent = 0, QVariant parameter = QVariant());
    static HttpServer *factory(QVariant parameter = QVariant());

    // 异步 get 请求
    // \param timeout 设置超时，结果作为槽函数实参
    void getRequest(const QString& url, bool timeout = false, long time = WAIT_TIME);

    // 同步 get 请求
    // \param timeout 指针不为0时进行超时设置，并且，接收是否超时结果
    QNetworkReply *getRequestSyn(const QString& url, bool *timeout = 0, long time = WAIT_TIME);

    // 异步 post 请求，data 为 json
    // \param timeout 设置超时，结果作为槽函数实参
    void postRequest(const QString& url, const QString &data, bool timeout = false, long time = WAIT_TIME);

    // 同步 post 请求，data 为 json
    // \param timeout 指针不为0时进行超时设置，并且，接收是否超时结果
    QNetworkReply *postRequestSyn(const QString& url, const QString &data, bool *timeout = 0, long time = WAIT_TIME);

    // 异步请求时设置信号接收对象，三参数信号
    // 也可用QObject::connect自定义接收对象和其他slot函数
    void setConnectTo(QObject *receiver);
    
signals:
    // 可以通过setConnectTo连接
    void finished(QNetworkReply *reply, QVariant param, bool isTimeout);
    // 自己连接
    void finished(QNetworkReply *reply, QVariant param);
    void finished(QNetworkReply *reply, bool isTimeout);
    void finished(QNetworkReply *reply);

private slots:
    void finished();
    void timeOut();

private:
    HttpServer(QObject *parent = 0,  QVariant parameter = QVariant());

    void get(const QString& url);
    void get_timeout(const QString& url, QTimer *timer, long time);
    QNetworkReply *get_syn(const QString& url);
    QNetworkReply *get_syn_timeout(const QString& url, bool *timeout, long time);

    void post(const QString& url, const QString &data);
    void post_timeout(const QString& url, const QString &data, QTimer *timer, long time);
    QNetworkReply *post_syn(const QString& url, const QString &data);
    QNetworkReply *post_syn_timeout(const QString& url, const QString &data, bool *timeout, long time);

    QNetworkRequest get_request(const QString& url);
    QNetworkRequest post_request(const QString& url);
    QByteArray post_data(const QString &data);

    QNetworkReply *HttpServer::syn_timeout(QNetworkReply *reply, bool *isTimeout, long time);
    QNetworkReply *HttpServer::syn(QNetworkReply *reply);

    void emitSignals(QNetworkReply *reply, QVariant param, bool isTimeout);

    QScopedPointer<QNetworkAccessManager> mManager;
    QScopedPointer<QTimer> mTimer;
    QNetworkReply *mReply;
    QVariant mParam;

    enum {
        WAIT_TIME = 10000
    };
};

#endif // HTTPSERVER_H

实现文件：

#include <QEventLoop>
#include <QTextCodec>

#include "httpserver.h"

 HttpServer *HttpServer::factory(QObject *parent,  QVariant parameter)
{
    return new HttpServer(parent, parameter);
}

HttpServer *HttpServer::factory( QVariant parameter)
{
    return new HttpServer(0, parameter);
}

HttpServer::HttpServer(QObject *parent,  QVariant parameter)
    :QObject(parent)
    ,mParam(parameter)
    ,mReply(nullptr)
{
    mManager.reset(new QNetworkAccessManager);
    mTimer.reset(new QTimer);

    connect(mTimer.data(), SIGNAL(timeout()), this, SLOT(timeOut()));
}

void HttpServer::setConnectTo(QObject *receiver)
{
    connect(this, SIGNAL(finished(QNetworkReply *, QVariant, bool)), receiver, SLOT(finished(QNetworkReply *, QVariant, bool)));
}

void HttpServer::getRequest(const QString& url, bool timeout, long time)
{
    if(timeout)
        get_timeout(url, mTimer.data(), time);
    else
        get(url);
}

QNetworkReply *HttpServer::getRequestSyn(const QString& url, bool *timeout, long time)
{
    if(timeout)
        return get_syn_timeout(url, timeout, time);
    else
        return get_syn(url);
}

void HttpServer::postRequest(const QString& url, const QString &data, bool timeout, long time)
{
    if(timeout)
        post_timeout(url, data, mTimer.data(), time);
    else
        post(url, data);
}

QNetworkReply *HttpServer::postRequestSyn(const QString& url, const QString &data, bool *timeout, long time)
{
    if(timeout)
        return post_syn_timeout(url ,data, timeout, time);
    else
        return post_syn(url, data);
}

void HttpServer::finished()
{
    mTimer->stop();

    emitSignals(mReply, mParam, false);

    this->deleteLater();
}

void HttpServer::timeOut()
{
    mTimer->stop();

    emitSignals(mReply, mParam, true);
    disconnect(mReply, SIGNAL(finished()), this, SLOT(finished()));

    this->deleteLater();
}

void HttpServer::get(const QString& url)
{
    mReply = mManager->get(get_request(url));
    connect(mReply, SIGNAL(finished()), this, SLOT(finished()));
}

void HttpServer::get_timeout(const QString& url, QTimer *timer, long time)
{
    get(url);
    timer->start(time);
}

QNetworkReply *HttpServer::get_syn_timeout(const QString& url, bool *isTimeout, long time)
{
    QNetworkReply *reply = mManager->get(get_request(url));
    return syn_timeout(reply, isTimeout, time);
}

QNetworkReply *HttpServer::get_syn(const QString& url)
{
    QNetworkReply *reply = mManager->get(get_request(url));
    return syn(reply);
}

void HttpServer::post(const QString& url, const QString &data)
{
    mReply = mManager->post(post_request(url), post_data(data));
    connect(mReply, SIGNAL(finished()), this, SLOT(finished()));
}

void HttpServer::post_timeout(const QString& url, const QString &data, QTimer *timer, long time)
{
    post(url, data);
    timer->start(time);
}

QNetworkReply *HttpServer::post_syn(const QString& url, const QString &data)
{
    QNetworkReply *reply = mManager->post(post_request(url), post_data(data));
    return syn(reply);
}

QNetworkReply *HttpServer::post_syn_timeout(const QString& url, const QString &data, bool *isTimeout, long time)
{

    QNetworkReply *reply = mManager->post(post_request(url), post_data(data));
    return syn_timeout(reply, isTimeout, time);
}

QNetworkReply *HttpServer::syn(QNetworkReply *reply)
{
    QEventLoop loop;
    connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));

    loop.exec();

    return reply;
}

QNetworkReply *HttpServer::syn_timeout(QNetworkReply *reply, bool *isTimeout, long time)
{
    QEventLoop loop;
    connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));

    QTimer timer;
    timer.setInterval(time);
    timer.setSingleShot(true);
    connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

    timer.start();
    loop.exec();

    if (timer.isActive()) {
        timer.stop();
        *isTimeout = false;
        return reply;
    } else {
        disconnect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
        *isTimeout = true;
        return reply;
    }
}

QNetworkRequest HttpServer::get_request(const QString& url)
{
    QNetworkRequest request;
    request.setUrl(QUrl(url));
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
    return request;
}

QNetworkRequest HttpServer::post_request(const QString& url)
{
    QNetworkRequest request;
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    request.setUrl(QUrl(url));
    return request;
}

QByteArray HttpServer::post_data(const QString &data)
{
    QByteArray postData;
    postData.append(QTextCodec::codecForName("UTF-8")->fromUnicode(data));
    return postData;
}

void HttpServer::emitSignals(QNetworkReply *reply, QVariant param, bool isTimeout)
{
    emit finished(reply, param, isTimeout);
    emit finished(reply, param);
    emit finished(reply, isTimeout);
    emit finished(reply);
}

转载于:https://www.cnblogs.com/kohlrabi/p/7095238.html

weixin_30408165
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt 之处理 QNetworkAccessManager 网络连接超时
青春不老，奋斗不止！
11-17 2万+
在网络操作中，经常会由于各种原因引起网络连接超时，究竟何为网络连接超时？
QNetWork网络请求模块封装
02-19
对Qt网络请求功能的封装，使用了QNetworkReply、QNetworkRequest和QNetworkAccessManager类，将网络请求与业务逻辑模块拆分开来，同时增加了日志保存功能。 1、CLog.h/cpp：日志保存功能； 2、NetworkHelper.h/cpp：使用Qt类封装网络请求； 3、TextStreamHelper.h/cpp：使用NetworkHelper与服务器进行字符流类请求 4、PicDownHelper.h/cpp：使用NetworkHelper，进行图片下载 5、NetworkModule.h/cpp/ui：为用户界面类，使用3和4的功能进行上层业务逻辑简单实现。
封装QNetworkAccessManager实现Ftp的上传
moonlight的博客
12-15 3022
封装QNetworkAccessManager实现Ftp的上传,对进度条显示等进行设置
通过QT QNetworkAccessManager类实现HTTP下载文件的小工具
01-23
通过QT QNetworkAccessManager 实现HTTP下载文件的小例子，仅供初学者参考。通过vs搭建QT4.8.6环境下编译且正常运行的小例子
QT的qnetworkservice，QNetworkAccessManager网络请求，异步和同步阻塞封装，加入lambda和信号槽封装请求响应
You never know your luck
09-27 1483
QT的qnetworkservice，QNetworkAccessManager网络请求，异步和同步阻塞封装，加入lambda和信号槽封装请求和相应。 【封装源码下载】 1：示例 (1) 简单示例 /* 使用lambda特性 */ static HttpService http; http.get("https://www.qt.io") .onResopnse([](QByte...
QT学习_QNetworkAccessManager
LittleBoyZou的博客
11-28 700
bool HttpClient::get(QNetworkRequest request) { QNetworkReply *reply; bool success = false; request.setPriority(QNetworkRequest::HighPriority); //向networkRequest里面添加公用的头 for (QMa...
使用QNetworkAccessManager进行同步下载
04-11
下面是一个简单的示例，展示如何使用QNetworkAccessManager进行同步文件下载： ```cpp #include <QNetworkAccessManager> #include #include void downloadFile(const QString &urlString) { ...
Qt使用QNetworkAccessManager实现Http操作
coologic
12-20 3029
介绍 QtNetwork是Qt网络操作模块，提供了基于TCP/IP的各种API，除了之前介绍过的最基础的TCP及UDP通讯：QTcpSocket-Qt使用Tcp通讯实现服务端和客户端、QUdpSocket-Qt使用Udp通讯实现服务端和客户端，还提供了HTTP、HTTPS、FTP等高级API，并统一使用QNetworkAccessManager进行操作。Ftp使用请见：Qt使用QNetw...
C++ QT框架QNetworkAccessManager,Request HTTP请求模块
草木疏博客
11-07 794
C++ QT框架QNetworkRequest HTTP请求模块
通过QEventLoop实现网络请求QNetworkAccesssManager阻塞
qingfenglu的专栏
05-12 2275
在有网络请求时将界面锁死，不允许用户进行更多的操作（更好的方法是仅仅锁住某些按钮，而不是整个界面。不过这里我们以锁住整个界面为例）。我们的解决方案很简单：当QNetworkAccessManager发出请求之后，我们进入一个新的事件循环，将操作进行阻塞。我们的代码示例如下： void fetchWeather(const QString &cityName) { QEventLoop
Qt 使用QNetworkAccessManager实现Http操作
m0_73443478的博客
01-06 1358
Qt 使用QNetworkAccessManager实现Http操作
QNetworkAccessManager 同步异步请求问题
huangmindong的专栏
02-16 449
QNetworkAccessManager 同步异步请求问题
Qt网络传输之QNetworkAccessManager的使用
热门推荐
梦之旅的专栏
03-16 1万+
把 QNetworkAccessManager 的 get/post 请求封装成函数，此方法可以避免使用槽函数响应网络请求；#include &lt;QtNetwork/QNetworkAccessManager&gt; #include &lt;QtNetwork/QNetworkRequest&gt; #include &lt;QtNetwork/QNetworkReply&gt; #incl...
Qt HTTP和HttpServer
Liuqz2009的专栏
02-03 1213
Qt网络访问 API 是围绕 QNetworkAccessManager 对象构建的，该对象保存它发送的请求的通用配置和设置。由于 QNetworkAccessManager 是基于 QObject 的，所以只能在它所属的线程中使用。它提供了一组标准函数，它们接受一个请求和可选数据，每个函数都返回一个 QNetworkReply 对象。当上面的 replyFinished 槽函数被调用时，它采用的参数是 QNetworkReply 对象，包含下载的数据以及元数据（标题等）。并行执行的请求数量取决于协议。
Qt组件QEventLoop之图片下载举例
L_yangliu的专栏
05-17 1334
下面这段代码是我从自己的项目里复制过来的，着重是QEventLoop的用法和使用场景“ //下载网络图片 void shopsubmit::setNetworkPic(QString szUrl) {     QUrl url(szUrl);     QNetworkAccessManager manager;     QEventLoop loop;     //qDebu
Qt Http 服务器 客户端使用
coco_wei的博客
12-23 1183
Qt Http 服务器 客户端使用
QNetworkAccessManager 详细介绍
Mountain_tai_li的博客
05-23 1077
QNetworkAccessManager 是 Qt 网络模块中的一个类，用于管理网络请求和响应。它提供了一种简单的方式来发送 HTTP 请求并处理响应。下面是 QNetworkAccessManager 类的一些常用函数：
Qt扫盲-QNetworkAccessManager理论总结
洪源兄
01-26 1956
QNetworkAccessManager 其实就是一个访问网络接口的管理工具类，该对象保存了它发送的请求的公共配置和设置（其实就是 QNetworkRequest 里的配置数据）。它包含代理和缓存配置，以及与此类问题相关的信号，以及可用于监视网络操作进展的应答信号，也就是下载进度、上传进度等信号。一个QNetworkAccessManager实例对整个Qt应用程序来说就足够了。由于QNetworkAccessManager是基于QObject的，它只能从它所属的线程使用。
QNetworkAccessManager 的使用
weixin_30360497的博客
09-24 456
非阻塞式的： // client.h class Client : public QObject { Q_OBJECT public: explicit Client(const QString &url); void sendData(const QString &data); p...
qt 封装http请求
最新发布
06-23
但使用Qt自带的QNetworkAccessManager类是更加轻量和简单的方式，可以避免额外依赖，并且具有更好的可移植性和跨平台性。 ### 回答3： Qt是一种跨平台的C++应用程序框架，提供了许多丰富的库，其中包括Qt网络库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值