Qt5网络绘图与多线程并发编程实战：构建高性能数据监控桌面应用

// NetworkManager.h
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QSslConfiguration>

class NetworkManager : public QObject {
    Q_OBJECT
public:
    static NetworkManager* instance();
    void fetchData(const QUrl &url);

signals:
    void dataReceived(const QByteArray &data);
    void errorOccurred(const QString &error);

private slots:
    void onReplyFinished(QNetworkReply *reply);
    void onSslErrors(QNetworkReply *reply, const QList<QSslError> &errors);

private:
    NetworkManager();
    QNetworkAccessManager *m_nam;
};

// NetworkManager.cpp
NetworkManager::NetworkManager() {
    m_nam = new QNetworkAccessManager(this);
    connect(m_nam, &QNetworkAccessManager::finished, this, &NetworkManager::onReplyFinished);
}

void NetworkManager::fetchData(const QUrl &url) {
    QNetworkRequest request(url);
    // 设置超时（需借助 QTimer 或使用 QNetworkReply::ignoreSslErrors）
    QSslConfiguration sslConf = QSslConfiguration::defaultConfiguration();
    sslConf.setPeerVerifyMode(QSslSocket::VerifyNone); // 仅测试用
    request.setSslConfiguration(sslConf);
    m_nam->get(request);
}

void NetworkManager::onReplyFinished(QNetworkReply *reply) {
    if (reply->error() == QNetworkReply::NoError) {
        QByteArray data = reply->readAll();
        emit dataReceived(data);
    } else {
        emit errorOccurred(reply->errorString());
    }
    reply->deleteLater();
}

void DataProcessor::handleRawData(const QByteArray &raw) {
    QJsonDocument doc = QJsonDocument::fromJson(raw);
    if (!doc.isArray()) return;
    QList<QPointF> points;
    for (auto item : doc.array()) {
        QJsonObject obj = item.toObject();
        qreal x = obj["timestamp"].toDouble();
        qreal y = obj["value"].toDouble();
        points.append(QPointF(x, y));
    }
    emit pointsReady(points);
}

class DataPointItem : public QGraphicsEllipseItem {
public:
    DataPointItem(const QPointF &pos, qreal radius = 3.0) 
        : QGraphicsEllipseItem(-radius, -radius, 2*radius, 2*radius) {
        setPos(pos);
        setBrush(Qt::blue);
        setPen(Qt::NoPen);
    }
};

class CurveItem : public QGraphicsItem {
public:
    void setPoints(const QList<QPointF> &points) {
        m_points = points;
        update();  // 触发重绘
    }
    QRectF boundingRect() const override {
        if (m_points.isEmpty()) return QRectF();
        // 计算边界
        qreal minX, maxX, minY, maxY;
        // ... 遍历得到边界
        return QRectF(minX, minY, maxX - minX, maxY - minY);
    }
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override {
        if (m_points.size() < 2) return;
        QPainterPath path;
        path.moveTo(m_points.first());
        for (int i = 1; i < m_points.size(); ++i) {
            path.lineTo(m_points.at(i));
        }
        painter->setPen(QPen(Qt::red, 2));
        painter->drawPath(path);
    }
private:
    QList<QPointF> m_points;
};

view->setRenderHint(QPainter::Antialiasing);
view->setViewportUpdateMode(QGraphicsView::FullViewportUpdate); // 避免残影

// 在 view 中重写 wheelEvent 和 mousePressEvent
void ChartView::wheelEvent(QWheelEvent *event) {
    qreal factor = (event->angleDelta().y() > 0) ? 1.1 : 0.9;
    scale(factor, factor);
}

#include <QtConcurrent/QtConcurrent>

void DataController::processPoints(const QList<QPointF> &raw) {
    // 在后台线程计算指标
    QFuture<QList<QPointF>> future = QtConcurrent::run(this, &DataController::computeMA, raw);
    // 通过 QFutureWatcher 获取结果
    QFutureWatcher<QList<QPointF>> *watcher = new QFutureWatcher<QList<QPointF>>(this);
    connect(watcher, &QFutureWatcher<QList<QPointF>>::finished, [=]() {
        QList<QPointF> ma = watcher->result();
        emit maReady(ma);
        watcher->deleteLater();
    });
    watcher->setFuture(future);
}

// 计算移动平均（纯 CPU 运算）
QList<QPointF> DataController::computeMA(const QList<QPointF> &points) {
    const int window = 20;
    QList<QPointF> maPoints;
    if (points.size() < window) return maPoints;
    qreal sum = 0;
    for (int i = 0; i < points.size(); ++i) {
        sum += points[i].y();
        if (i >= window) sum -= points[i - window].y();
        if (i >= window - 1) {
            qreal avg = sum / window;
            maPoints.append(QPointF(points[i].x(), avg));
        }
    }
    return maPoints;
}

class IndicatorTask : public QRunnable {
public:
    IndicatorTask(const QList<QPointF> &data, int type, QObject *receiver)
        : m_data(data), m_type(type), m_receiver(receiver) { }

    void run() override {
        // 执行计算
        QList<QPointF> result;
        // ... 根据 m_type 计算不同指标
        // 通过信号发送结果（注意：需使用 QMetaObject::invokeMethod 或信号槽跨线程）
        QMetaObject::invokeMethod(m_receiver, "onIndicatorReady", 
                                  Qt::QueuedConnection,
                                  Q_ARG(QList<QPointF>, result));
    }
private:
    QList<QPointF> m_data;
    int m_type;
    QObject *m_receiver;
};

// 使用
IndicatorTask *task = new IndicatorTask(points, 1, this);
QThreadPool::globalInstance()->start(task);

// 注册自定义类型
qRegisterMetaType<QList<QPointF>>("QList<QPointF>");

// 在 main 或主窗口构造函数中
NetworkManager *net = NetworkManager::instance();
DataProcessor *processor = new DataProcessor(this);
ChartController *controller = new ChartController(view, this);

connect(net, &NetworkManager::dataReceived, processor, &DataProcessor::handleRawData);
connect(processor, &DataProcessor::pointsReady, controller, &ChartController::onNewData);
connect(controller, &ChartController::needComputeIndicator, this, &MainWindow::startComputation);
// 计算结果返回时，controller 直接更新图元

void ChartController::onNewData(const QList<QPointF> &points) {
    m_rawCurve->setPoints(points);
    emit needComputeIndicator(points);  // 交给主窗口启动线程池任务
}

// 主窗口接收计算结果
void MainWindow::onIndicatorResult(const QList<QPointF> &ma) {
    m_maCurve->setPoints(ma);
}