DdStone/QTradeProgram

Fork 0

Files

unknown 80518309a7 Update 更新文档

2026-02-25 23:01:42 +08:00

13 KiB

Raw Blame History

QTradeProgram - 大单检测程序源代码文档

一、程序概述

1.1 程序结构

QTradeProgram/
├── QMainwindow/          # 主窗口UI模块
├── Sqbase/              # 核心业务逻辑模块
├── FTAPI/               # 富途API接口封装
├── include/             # 头文件和协议定义
├── config/              # 配置文件目录
└── lib/                 # 库文件目录

1.2 技术栈

开发语言: C++
界面框架: Qt 5.9
开发环境: Visual Studio 2015
数据接口: Futu API
数据格式: Protobuf

二、核心模块源代码

2.1 主窗口模块 (QMainwindow/)

2.1.1 QMainwindow.h

#pragma once
/*
	主窗口 提供 UI 交互界面
	- 显示、操作订阅列表，添加、删除
	- 断开连、连接OpenD
	- 大单监控使能
*/
#include <QSet>
#include <QtWidgets/QMainWindow>
#include <QTimer>
#include "ui_QMainwindow.h"

#include "QDataAcquisition.h"
#include "QBreathingLight.h"

#include "..\Sqbase\qlogmanager.h"
#include "..\Sqbase\qlogviewer.h"
#include "..\Sqbase\qorderprocessor.h"
#include "..\Sqbase\qbigordermanager.h"
#include "..\Sqbase\qbigorderviewer.h"

class QMainwindow : public QMainWindow
{
    Q_OBJECT

public:
    QMainwindow(QWidget *parent = Q_NULLPTR);
    ~QMainwindow();

private:
    QSet<QString> m_setReplayCode;
    int m_nReplyCount; // 订阅数量
    QMap<QString, float> m_replyCodeQuantity;
    QDataAcquisition* m_dataAcquisition;
    QTimer* m_netCheckTimer;

    QBreathingLight *m_lightWidget;

public:
    void initWidget();
    void initReplyManage();
    void updateCodeTable();

    QLogViewer* logViewer;

    QList<QSharedPointer<ReplyCodeItem>> m_replyCodes;
    QStandardItemModel *m_model;
    QSortFilterProxyModel *m_proxyModel;

private:
    QString toFixedDigitNumber(const QString& input);
    void readReplyCodefile(QList<QSharedPointer<ReplyCodeItem>>& replyList);
    void saveReplyCodefile();
    QString escapeCsv(const QString &field);

private:
    Ui::QMainwindowClass ui;
};

2.2 订单处理核心模块 (Sqbase/)

2.2.1 qorderprocessor.h

/*
	订单处理类
	- 维护一个线程池，用于处理接收到的订单数据
	- 检测大单
		单笔订单股票数量大于指定阈值，会被认定为大单
*/
#ifndef QORDERPROCESSOR_H
#define QORDERPROCESSOR_H

#include <QObject>
#include <QVector>
#include <QThreadPool>
#include <QMutex>
#include <QCache>
#include <QtConcurrent\QtConcurrent>
#include <algorithm>
#include <functional>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include "BZStruct.h"
#include "qeventbus.h"
#include "ObjectPool.h"

#include "tool.h"
#include "..\Sqbase\OrderBookParser.h"

class QOrderProcessor : public QObject
{
    Q_OBJECT
public:
    explicit QOrderProcessor(QObject *parent = nullptr);
    ~QOrderProcessor();

    void setProcessingEnabled(bool enabled);
    void processOrderBook(const Qot_UpdateOrderBook::Response &stRsp);

    // JSON保存线程开关
    void setJsonSaveEnabled(bool enabled);
    bool isJsonSaveEnabled() const { return m_jsonSaveEnabled; }

    void setreplyCodeQuantity(QMap<QString, float> CodeQuantity)
    {
        m_replyCodeQuantity = CodeQuantity;
    }

    // 性能监控接口
    size_t getCacheHitRate() const { return m_cacheHits; }
    size_t getCacheMissRate() const { return m_cacheMisses; }
    double getCacheHitRatio() const { 
        return (m_cacheHits + m_cacheMisses) > 0 ? 
            static_cast<double>(m_cacheHits) / (m_cacheHits + m_cacheMisses) : 0.0; 
    }

public:
    OrderBookParser parser;

signals:
    // 基础信号
    void maxOrderReady(BigOrderInfo bigOrderInfo);
    
    // 状态信号
    void processingStarted(const QString& code);
    void processingFinished(const QString& code);
    void errorOccurred(const QString& code, const QString& error);

private:
    QVector<BigOrderInfo> findExtremeOrders(const OrderBookData& data) const;
    OrderBookEntry findMaxVolumeItemEx(const QVector<OrderBookEntry>& items, double volumeRatio) const;
    QVector<BigOrderInfo>  findMaxVolumeItem(const OrderBookData& data) const;
    OrderBookEntry findMinPriceItem(const QVector<OrderBookEntry>& items) const;

    // 缓存相关方法
    bool getCachedResult(const QString& cacheKey, QVector<BigOrderInfo>& result) const;
    void cacheResult(const QString& cacheKey, const QVector<BigOrderInfo>& result) const;

    double sumQuantity(const QVector<OrderBookEntry>& items) const;

    void internalProcess(const OrderBookData& orderData);
    
    // JSON保存相关方法
    void saveOrderDataAsJson(const OrderBookData& orderData);
    QJsonObject orderBookDataToJson(const OrderBookData& data) const;
    
    QThreadPool m_threadPool;
    mutable QMutex m_dataMutex;
    bool m_enabled = true;
    bool m_jsonSaveEnabled = false; // JSON保存开关
    QSet<QString> m_processingCodes;

    QMap<QString, float> m_replyCodeQuantity;

    // JSON保存线程池
    QThreadPool m_jsonSaveThreadPool;

    // 性能优化成员 - 手动缓存实现
    mutable QMap<QString, QVector<BigOrderInfo>> m_orderCache;
    mutable QList<QString> m_cacheKeys;
    mutable size_t m_cacheHits = 0;
    mutable size_t m_cacheMisses = 0;
    mutable QMutex m_cacheMutex;
    size_t m_cacheMaxSize = 200;
};

#endif // QORDERPROCESSOR_H

2.2.2 qorderprocessor.cpp (核心算法部分)

// 大单检测核心算法
QVector<BigOrderInfo> QOrderProcessor::findExtremeOrders(const OrderBookData& data) const
{
    QVector<BigOrderInfo> result;
    
    // 检查阈值设置
    if (!m_replyCodeQuantity.contains(data.code)) {
        return result;
    }
    
    float threshold = m_replyCodeQuantity[data.code];
    
    // 检查买盘大单
    for (const OrderBookEntry& entry : data.bids) {
        if (entry.volume >= threshold) {
            BigOrderInfo bigOrder;
            bigOrder.price = entry.price;
            bigOrder.volume = entry.volume;
            bigOrder.code = data.code;
            bigOrder.name = data.name;
            bigOrder.isBigOrder = true;
            bigOrder.nBigOrderType = 1; // 买盘大单
            result.append(bigOrder);
        }
    }
    
    // 检查卖盘大单
    for (const OrderBookEntry& entry : data.asks) {
        if (entry.volume >= threshold) {
            BigOrderInfo bigOrder;
            bigOrder.price = entry.price;
            bigOrder.volume = entry.volume;
            bigOrder.code = data.code;
            bigOrder.name = data.name;
            bigOrder.isBigOrder = true;
            bigOrder.nBigOrderType = 0; // 卖盘大单
            result.append(bigOrder);
        }
    }
    
    return result;
}

// 查找最大成交量订单
OrderBookEntry QOrderProcessor::findMaxVolumeItemEx(const QVector<OrderBookEntry>& items, double volumeRatio) const
{
    if (items.isEmpty()) {
        return OrderBookEntry();
    }
    
    OrderBookEntry maxItem = items.first();
    for (const OrderBookEntry& item : items) {
        if (item.volume > maxItem.volume) {
            maxItem = item;
        }
    }
    
    return maxItem;
}

// 查找大单的核心方法
QVector<BigOrderInfo> QOrderProcessor::findMaxVolumeItem(const OrderBookData& data) const
{
    QVector<BigOrderInfo> bigOrders;
    
    // 使用缓存机制提高性能
    QString cacheKey = data.code + "_" + QDateTime::currentDateTime().toString("yyyyMMddhhmm");
    QVector<BigOrderInfo> cachedResult;
    
    if (getCachedResult(cacheKey, cachedResult)) {
        return cachedResult;
    }
    
    // 执行大单检测算法
    bigOrders = findExtremeOrders(data);
    
    // 缓存结果
    cacheResult(cacheKey, bigOrders);
    
    return bigOrders;
}

2.3 大单管理模块

2.3.1 qbigordermanager.h

/*
	大单管理器
	- 管理所有检测到的大单数据
	- 单例模式确保全局唯一实例
	- 提供大单数据的增删改查接口
*/
#ifndef QBIGORDERMANAGER_H
#define QBIGORDERMANAGER_H

#include <QObject>
#include <QList>
#include <QSharedPointer>
#include <QMutex>
#include "BZStruct.h"

class QBigOrderManager : public QObject
{
    Q_OBJECT
public:
    static QBigOrderManager* instance();
    
    void addBigOrder(const BigOrderInfo& order);
    void removeBigOrder(const QString& code);
    QList<QSharedPointer<BigOrderInfo>> getBigOrders() const;
    void clearAll();
    
    // 统计功能
    int getBigOrderCount() const;
    int getBigOrderCountByType(int type) const;

signals:
    void bigOrderAdded(QSharedPointer<BigOrderInfo> order);
    void bigOrderRemoved(const QString& code);
    void markBigOrderSignal();

private:
    explicit QBigOrderManager(QObject *parent = nullptr);
    ~QBigOrderManager();
    
    static QBigOrderManager* m_instance;
    QList<QSharedPointer<BigOrderInfo>> m_bigOrders;
    mutable QMutex m_orderMutex;
};

#endif // QBIGORDERMANAGER_H

2.4 数据结构定义

2.4.1 BZStruct.h (核心数据结构)

/*
	核心数据结构定义
	- 订单簿条目
	- 大单信息
	- 配置项
*/
#ifndef BZSTRUCT_H
#define BZSTRUCT_H

#include <QString>
#include <QVector>
#include <QDateTime>

// 订单详情
struct OrderDetail {
    long long orderId;
    double volume;
    double price;
};

// 订单簿条目
struct OrderBookEntry {
    double price;
    double volume;
    int orderCount;
    QString code;
    QVector<OrderDetail> details;
};

// 订单簿数据
struct OrderBookData {
    QString name;
    QString code;
    QString askTime;
    QString bidTime;
    QVector<OrderBookEntry> bids;
    QVector<OrderBookEntry> asks;
};

// 大单信息
struct BigOrderInfo {
    double price;
    double volume;
    long long orderId;
    int nBigOrderType;      // 大单类型 (0:空/1:多)
    int level;
    bool isBigOrder;
    QString name;
    QString code;
    QString svrRecvTime;
};

// 订阅项
struct ReplyCodeItem {
    QString code;
    float quantity;
    QString name;
};

#endif // BZSTRUCT_H

三、关键技术实现

3.1 多线程处理机制

// 使用Qt线程池处理订单数据
void QOrderProcessor::processOrderBook(const Qot_UpdateOrderBook::Response &stRsp)
{
    if (!m_enabled) return;
    
    // 使用QtConcurrent在线程池中执行处理任务
    QtConcurrent::run(&m_threadPool, [this, stRsp]() {
        OrderBookData orderData = parser.parseOrderBook(stRsp);
        
        if (!m_processingCodes.contains(orderData.code)) {
            m_processingCodes.insert(orderData.code);
            emit processingStarted(orderData.code);
        }
        
        internalProcess(orderData);
        
        m_processingCodes.remove(orderData.code);
        emit processingFinished(orderData.code);
    });
}

3.2 缓存优化机制

// 缓存管理实现
bool QOrderProcessor::getCachedResult(const QString& cacheKey, QVector<BigOrderInfo>& result) const
{
    QMutexLocker locker(&m_cacheMutex);
    
    if (m_orderCache.contains(cacheKey)) {
        result = m_orderCache[cacheKey];
        m_cacheHits++;
        return true;
    }
    
    m_cacheMisses++;
    return false;
}

void QOrderProcessor::cacheResult(const QString& cacheKey, const QVector<BigOrderInfo>& result) const
{
    QMutexLocker locker(&m_cacheMutex);
    
    // 维护缓存大小
    if (m_cacheKeys.size() >= m_cacheMaxSize) {
        QString oldestKey = m_cacheKeys.takeFirst();
        m_orderCache.remove(oldestKey);
    }
    
    m_orderCache[cacheKey] = result;
    m_cacheKeys.append(cacheKey);
}

3.3 信号槽通信机制

// 主窗口中的信号槽连接
void QMainwindow::initWidget()
{
    // 大单检测信号连接
    connect(processor, &QOrderProcessor::maxOrderReady,
            this, [this](BigOrderInfo bigOrderInfo) {
        QBigOrderManager::instance()->addBigOrder(bigOrderInfo);
    });
    
    // 大单显示信号连接  
    connect(manager, &QBigOrderManager::bigOrderAdded,
            viewer, &QBigOrderViewer::onBigOrderAdded);
    
    // 视觉提示信号连接
    connect(manager, &QBigOrderManager::markBigOrderSignal,
            m_lightWidget, &QBreathingLight::triggerSignal);
}

四、程序入口

4.1 main.cpp

#include "QMainwindow.h"
#include <QtWidgets/QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMainwindow w;
    w.show();
    return a.exec();
}

五、技术特点总结

5.1 架构特点

模块化设计: 各功能模块职责清晰，耦合度低
事件驱动: 基于Qt信号槽机制的异步通信
多线程处理: 使用线程池提高数据处理能力
缓存优化: 手动实现缓存机制提升性能

5.2 算法特点

实时检测: 基于阈值的大单实时识别算法
高效处理: 优化的数据结构和算法实现
可配置性: 支持动态阈值调整和股票订阅

5.3 创新点

专业金融监控: 专门针对股票大单监控的解决方案
智能提示: 呼吸灯效果实时视觉反馈
性能优化: 多级缓存和线程池技术

六、代码统计

总代码行数: 约15,000行
头文件数量: 25个
源文件数量: 30个
类数量: 15个
函数数量: 约200个

声明: 本程序所有源代码均为原创开发，拥有完整的著作权。

13 KiB Raw Blame History

QTradeProgram - 大单检测程序 源代码文档

一、程序概述

1.1 程序结构

1.2 技术栈

二、核心模块源代码

2.1 主窗口模块 (QMainwindow/)

2.1.1 QMainwindow.h

2.2 订单处理核心模块 (Sqbase/)

2.2.1 qorderprocessor.h

2.2.2 qorderprocessor.cpp (核心算法部分)

2.3 大单管理模块

2.3.1 qbigordermanager.h

2.4 数据结构定义

2.4.1 BZStruct.h (核心数据结构)

三、关键技术实现

3.1 多线程处理机制

3.2 缓存优化机制

3.3 信号槽通信机制

四、程序入口

4.1 main.cpp

五、技术特点总结

5.1 架构特点

5.2 算法特点

5.3 创新点

六、代码统计

13 KiB

Raw Blame History

QTradeProgram - 大单检测程序源代码文档