一、Redis核心设计原则

1. 内存高效：优化数据结构，减少内存占用
2. 低延迟访问：单次操作≤0.1ms响应时间
3. 数据完整性：完整存储所有L2字段
4. 实时订阅：支持多客户端实时数据推送
5. 持久化策略：RDB+AOF保障数据安全

二、数据结构设计与键规范

2.1 键命名规范

三、详细数据存储方案

3.1 盘口数据（OrderBook）

# 存储结构
HSET orderbook:600000.SH \
    "update_time" "1629123456789" \
    "bid1_px" "12.34" \
    "bid1_vol" "5000" \
    "bid1_ord" "3" \
    "ask1_px" "12.35" \
    "ask1_vol" "6000" \
    "ask1_ord" "2" \
    ... # bid2~bid5, ask2~ask5 \
    "total_bid" "25000" \
    "total_ask" "30000"

# 字段说明表
| 字段名         | 数据类型 | 示例值     | 对应L2字段                |
|----------------|----------|------------|--------------------------|
| update_time    | String   | 1629123456789 | OrderBook.update_time    |
| bid{1-5}_px    | Double   | 12.34      | OrderBook.BidLevels[i].price |
| bid{1-5}_vol   | Integer  | 5000       | OrderBook.BidLevels[i].volume|
| bid{1-5}_ord   | Integer  | 3          | OrderBook.BidLevels[i].orders|
| total_bid      | Integer  | 25000      | OrderBook.total_bid_vol  |

设计理由：

• Hash结构：单次HSET原子更新全部档位
• 扁平化存储：避免嵌套结构，直接映射L2原始数据
• 快速访问：通过HGETALL一次获取完整盘口

3.2 逐笔委托（OrderDetail）

# 时间序列存储（纳秒级精度）
TS.CREATE ts:order:600000.SH 
  RETENTION 86400000  # 保留24小时数据
  LABELS symbol 600000.SH type order

# 写入数据（时间戳单位：毫秒）
TS.ADD ts:order:600000.SH 1629123456789 
  "order_id:1234567890|price:12.34|vol:5000|dir:B|type:A"

# 独立存储订单详情
HSET order:1234567890 
    "symbol" "600000.SH" 
    "time" "1629123456789" 
    "price" "12.34" 
    "vol" "5000" 
    "dir" "B" 
    "type" "A" 
    "related" "0"

字段编码规则：

value格式：field1:value1|field2:value2...
示例：order_id:123456|price:12.34|vol:5000|dir:B|type:A

设计理由：

• TimeSeries模块：
• 自动按时间排序，支持范围查询（TS.RANGE）
• 内置降采样（TS.DOWNAMPLE），快速生成分钟级统计
• Hash存储：独立存储订单详情，避免重复数据

3.3 逐笔成交（Transaction）

# 成交流（Stream结构）
XADD stream:trade:600000.SH * 
    time 1629123456789000 
    bid_order 1234567890 
    ask_order 1234567891 
    price 12.35 
    vol 100 
    type N

# 时间序列存储
TS.CREATE ts:trade:600000.SH 
  DUPLICATE_POLICY LAST 
  RETENTION 604800000  # 保留7天

Stream消息体结构：

{
  "time": "1629123456789000",  // 纳秒时间戳
  "bid_order": "1234567890",   // 买方订单号
  "ask_order": "1234567891",   // 卖方订单号
  "price": "12.35",            // 成交价格
  "vol": "100",                // 成交量
  "type": "N"                  // 成交类型(N/C)
}

设计理由：

• Stream结构：
• 消息持久化，支持消费者组（Consumer Group）
• 严格有序，保证成交顺序
• TimeSeries冗余存储：支持时间范围快速统计

四、数据关系与访问模式

4.1 数据关联逻辑

4.2 典型访问场景

1. 实时盘口查询

HGETALL orderbook:600000.SH

2. 历史委托分析

TS.RANGE ts:order:600000.SH 1629123000000 1629123600000

3. 成交回放

XREAD STREAMS stream:trade:600000.SH 0-0

4. 订单溯源

HGETALL order:1234567890

五、C++接入实现

5.1 盘口更新示例

#include <hiredis/hiredis.h>
#include <string>

struct OrderBook {
    std::string symbol;
    int64_t update_time;
    struct {
        double price;
        int volume;
        int orders;
    } bid[5], ask[5];
    int total_bid, total_ask;
};

void update_orderbook(redisContext* c, const OrderBook& book) {
    std::string key = "orderbook:" + book.symbol;
    
    redisReply* reply = (redisReply*)redisCommand(c, "MULTI");
    freeReplyObject(reply);
    
    // 删除旧数据
    reply = redisCommand(c, "DEL %s", key.c_str());
    freeReplyObject(reply);
    
    // 构造HSET命令
    std::vector<const char*> args = {"HSET", key.c_str(), 
        "update_time", std::to_string(book.update_time).c_str()};
    
    for (int i = 0; i < 5; ++i) {
        std::string bid_px = "bid" + std::to_string(i+1) + "_px";
        std::string bid_vol = "bid" + std::to_string(i+1) + "_vol";
        args.insert(args.end(), {
            bid_px.c_str(), std::to_string(book.bid[i].price).c_str(),
            bid_vol.c_str(), std::to_string(book.bid[i].volume).c_str()
        });
    }
    
    // 添加其他字段...
    
    reply = redisCommandArgv(c, args.size(), args.data(), NULL);
    if (reply->type == REDIS_REPLY_ERROR) {
        // 错误处理
    }
    freeReplyObject(reply);
    
    reply = redisCommand(c, "EXEC");
    freeReplyObject(reply);
}

5.2 逐笔数据写入

#include <chrono>

void insert_order(redisContext* c, const OrderDetail& order) {
    // 时间戳生成（C++11）
    auto now = std::chrono::system_clock::now();
    auto ts = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count();
    
    // TimeSeries写入
    redisReply* reply = (redisReply*)redisCommand(c,
        "TS.ADD ts:order:%s %lld *", 
        order.symbol.c_str(), 
        ts);
    
    // 构造value
    std::string value = 
        "order_id:" + std::to_string(order.order_id) + "|" +
        "price:" + std::to_string(order.price) + "|" +
        "vol:" + std::to_string(order.volume) + "|" +
        "dir:" + std::string(1, order.direction) + "|" +
        "type:" + std::string(1, order.order_type);
    
    if (reply->type == REDIS_REPLY_ERROR) {
        // 错误处理
    }
    freeReplyObject(reply);
    
    // 独立存储订单详情
    reply = redisCommand(c, 
        "HSET order:%lld "
        "symbol %s "
        "time %lld "
        "price %f "
        "vol %d "
        "dir %c "
        "type %c "
        "related %lld",
        order.order_id,
        order.symbol.c_str(),
        ts,
        order.price,
        order.volume,
        order.direction,
        order.order_type,
        order.related_order_id);
    
    freeReplyObject(reply);
}

六、性能优化策略

6.1 内存管理

# 设置最大内存（根据服务器配置调整）
CONFIG SET maxmemory 64gb

# 内存淘汰策略
CONFIG SET maxmemory-policy volatile-lru

# 压缩Hash字段
CONFIG SET hash-max-ziplist-entries 512
CONFIG SET hash-max-ziplist-value 64

6.2 持久化配置

# RDB快照（每5分钟保存）
CONFIG SET save "300 1"

# AOF追加（每秒同步）
CONFIG SET appendfsync everysec

6.3 集群扩展

# 创建集群（3主3从）
redis-cli --cluster create \
    192.168.1.101:6379 \
    192.168.1.102:6379 \
    192.168.1.103:6379 \
    192.168.1.104:6379 \
    192.168.1.105:6379 \
    192.168.1.106:6379 \
    --cluster-replicas 1

七、监控指标与容灾

7.1 关键监控项

7.2 容灾方案

1. 主从复制：实时同步数据到备用节点
2. 哨兵模式：自动故障转移
3. 跨机房同步：使用redis-replicator工具

八、架构总结

8.1 方案优势

8.2 适用场景

• 算法交易：实时获取盘口数据计算最优下单路径
• 风控引擎：监控异常委托/成交模式
• 行情分发：通过Pub/Sub向多个客户端广播
• 快速回测：从Stream回放历史数据