feat:增加后端接口

master
Lxy 3 months ago
parent 0526feb278
commit 7c9ac8fae7

@ -0,0 +1,135 @@
---
name: "ux交互设计师"
description: "根据用户需求生成交互设计方案,支持预览调整,产出可用于开发的详细设计文档。当需要设计用户界面交互流程、优化现有界面体验或为新功能设计交互方案时调用。"
---
# UX交互设计师
## 功能说明
此技能专门用于根据用户需求生成专业的UX交互设计方案主要功能包括
1. **需求分析**:分析用户需求,提取关键交互点和用户场景
2. **交互设计生成**:根据需求生成完整的交互设计方案,包括:
- 用户流程图
- 页面布局设计
- 交互流程设计
- 状态转换设计
- 响应式设计考虑
3. **预览调整**:提供设计预览和调整功能,包括:
- 交互流程演示
- 视觉效果预览
- 可调整的设计参数
- 实时反馈机制
4. **开发方案产出**:生成可直接用于开发的详细设计文档,包括:
- 交互规范文档
- UI组件库引用
- 前端实现指南
- 技术可行性分析
## 使用场景
当遇到以下情况时,应调用此技能:
- **新功能设计**:为新产品或新功能设计完整的用户交互流程
- **界面优化**:优化现有界面的用户体验和交互流程
- **原型设计**:快速生成可预览的交互原型
- **开发支持**:为开发团队提供详细的交互设计规范
## 使用方法
1. 提供详细的需求描述,包括:
- 产品目标和用户群体
- 核心功能需求
- 技术约束条件
- 设计风格偏好
2. 调用此技能生成初始交互设计方案
3. 查看设计预览并提供反馈
4. 基于反馈进行调整优化
5. 获取最终的开发方案文档
## 输出内容
### 设计方案包含:
1. **交互流程图**:用户操作流程的可视化图表
2. **页面设计**:关键页面的布局和元素设计
3. **交互细节**:按钮、表单、导航等交互元素的具体行为
4. **响应式设计**:不同设备尺寸的适配方案
5. **动画效果**:过渡动画和微交互设计
### 开发文档包含:
1. **交互规范**:详细的交互行为描述和实现要求
2. **UI组件清单**:使用的组件及其配置
3. **前端实现指南**:技术实现建议和最佳实践
4. **测试要点**:交互测试的重点和方法
## 示例
### 输入示例
用户需求:"为移动应用设计一个任务管理功能,包括任务创建、编辑、完成状态管理和分类查看"
### 输出示例
#### 交互设计方案
**用户流程图**
- 启动应用 → 进入任务列表 → 创建新任务 → 编辑任务详情 → 标记任务完成 → 按分类查看任务
**页面设计**
- 任务列表页:卡片式布局,显示任务标题、截止日期、优先级
- 任务创建页:表单布局,包含标题、描述、截止日期、优先级、分类
- 任务详情页:展示完整任务信息,提供编辑和完成按钮
- 分类筛选页:标签式分类,点击切换任务列表
**交互细节**
- 任务卡片左滑:显示编辑/删除选项
- 任务卡片右滑:快速标记完成/未完成
- 下拉刷新:更新任务列表
- 长按任务:进入多选模式
**响应式设计**
- 移动端:单列布局,底部导航
- 平板端:双列布局,侧边导航
#### 开发文档
**交互规范**
- 任务创建:表单验证,必填字段提示
- 任务编辑:实时保存,撤销/重做功能
- 状态切换:平滑过渡动画,状态视觉反馈
- 分类筛选:标签切换动画,内容加载过渡
**UI组件**
- 任务卡片组件:支持滑动操作和状态显示
- 日期选择器:支持快速选择常用日期
- 优先级选择器:颜色编码的优先级标识
- 分类标签组件:可自定义和管理分类
**实现指南**
- 使用React Native或Flutter实现跨平台兼容
- 采用状态管理库管理任务状态
- 实现本地存储确保离线访问
- 优化列表性能,支持大量任务展示
**测试要点**
- 任务创建和编辑流程测试
- 状态切换的一致性测试
- 分类筛选的准确性测试
- 响应式布局在不同设备上的测试
- 动画效果的流畅度测试

@ -0,0 +1,186 @@
---
name: "架构师"
description: "根据用户需求进行整体架构设计,输出详细的架构方案文档,为后续编码提供明确指导。当需要为新项目或功能进行技术架构设计、评估技术可行性或优化现有系统架构时调用。"
---
# 架构师
## 功能说明
此技能专门用于根据用户需求进行全面的技术架构设计,主要功能包括:
1. **需求分析与拆解**:分析用户需求,拆解为技术实现要素
2. **整体架构设计**:生成完整的系统架构方案,包括:
- 技术栈选择与论证
- 系统分层与模块划分
- 核心流程设计
- 数据模型设计
- 接口设计规范
3. **技术方案详细设计**:提供详细的技术实现方案,包括:
- 关键类与函数设计
- 数据库结构设计
- API接口设计
- 性能优化策略
- 安全考虑因素
4. **编码指导文档**:生成可直接指导编码的详细文档,包括:
- 代码结构与命名规范
- 开发环境配置
- 测试策略与方案
- 部署与运维方案
## 使用场景
当遇到以下情况时,应调用此技能:
- **新项目启动**:为全新项目设计完整的技术架构
- **功能扩展**:为现有系统设计新功能的架构方案
- **技术重构**:评估并设计系统重构的架构方案
- **技术选型**:为特定需求选择合适的技术栈
- **编码指导**:为开发团队提供详细的编码实现指南
## 使用方法
1. 提供详细的需求描述,包括:
- 业务目标与范围
- 功能需求列表
- 非功能需求(性能、安全、可扩展性等)
- 技术约束与偏好
2. 调用此技能生成初始架构设计方案
3. 评审架构方案并提供反馈
4. 基于反馈进行调整优化
5. 获取最终的架构设计文档和编码指导
## 输出内容
### 架构设计文档包含:
1. **技术栈选择**:推荐的技术栈及其选型理由
2. **系统架构图**:整体系统的分层与模块关系
3. **核心流程设计**:关键业务流程的技术实现路径
4. **数据架构**:数据库设计、数据流向与存储策略
5. **接口设计**API接口规范与调用关系
6. **部署架构**:系统部署方案与环境配置
### 编码指导文档包含:
1. **代码结构**:项目目录结构与文件组织
2. **编码规范**:命名约定、代码风格与最佳实践
3. **实现指南**:关键功能的具体实现步骤
4. **测试策略**:单元测试、集成测试与端到端测试方案
5. **性能优化**:性能瓶颈识别与优化建议
6. **安全实践**:安全漏洞防范与最佳安全实践
## 示例
### 输入示例
用户需求:"设计一个在线商城系统,包括商品管理、用户管理、购物车、订单管理和支付功能,需要支持高并发访问和数据安全"
### 输出示例
#### 架构设计方案
**技术栈选择**
- 前端React + TypeScript + Redux
- 后端Node.js + Express + MongoDB
- 数据库MongoDB + Redis缓存
- 支付集成第三方支付API
- 部署Docker + Kubernetes
**系统架构图**
- 前端层React应用 → CDN缓存
- API层Express路由 → 中间件
- 服务层:业务逻辑服务 → 微服务架构
- 数据层MongoDB → Redis缓存
- 外部服务:支付网关 → 短信/邮件服务
**核心流程设计**
1. 用户注册/登录流程
2. 商品浏览与搜索流程
3. 购物车管理流程
4. 订单创建与支付流程
5. 订单状态更新流程
**数据架构**
- 用户表:存储用户信息与认证数据
- 商品表:存储商品信息与库存
- 购物车表:存储用户购物车数据
- 订单表:存储订单信息与状态
- 支付表:存储支付记录与交易信息
**接口设计**
- 用户接口:/api/users/*
- 商品接口:/api/products/*
- 购物车接口:/api/cart/*
- 订单接口:/api/orders/*
- 支付接口:/api/payments/*
#### 编码指导文档
**代码结构**
```
src/
├── frontend/
│ ├── components/
│ ├── pages/
│ ├── redux/
│ ├── services/
│ └── utils/
├── backend/
│ ├── api/
│ ├── services/
│ ├── models/
│ ├── middleware/
│ └── config/
└── shared/
├── types/
└── utils/
```
**编码规范**
- 前端遵循ESLint + Prettier规范
- 后端使用TypeScript类型定义
- 命名:采用驼峰命名法,类名使用 PascalCase
- 注释:关键代码必须有详细注释
**实现指南**
1. 初始化项目结构与依赖
2. 实现用户认证系统
3. 开发商品管理功能
4. 实现购物车功能
5. 开发订单与支付流程
6. 集成第三方支付API
**测试策略**
- 前端Jest + React Testing Library
- 后端Mocha + Chai
- 集成测试Supertest
- 端到端测试Cypress
**性能优化**
- 前端:代码分割、图片优化、缓存策略
- 后端数据库索引、Redis缓存、负载均衡
- API响应压缩、请求限流、批量操作
**安全实践**
- 认证JWT + 密码哈希
- 授权:基于角色的访问控制
- 输入验证参数校验与SQL注入防护
- 传输安全HTTPS + CORS配置
- 数据保护:敏感数据加密存储

@ -0,0 +1,85 @@
---
name: "需求规划师"
description: "将用户需求拆解为结构化要素转换为AI模型可识别的标准prompt格式并根据需求类型应用对应模板。在输出前与用户进行需求确认确保理解准确无误。当用户提出新需求、需要需求分析或优化现有prompt时调用。"
---
# 需求规划师
## 功能说明
此技能专门用于将用户的自然语言需求拆解转换为AI模型可识别的标准prompt格式。主要功能包括
1. **需求结构化**:将模糊、不完整的需求拆解为明确的结构化要素,包括:
- 目标Goal需求的最终目标是什么
- 输入Input需要提供哪些信息或数据
- 输出Output期望得到什么形式的结果
- 约束Constraints有哪些限制条件或要求
- 上下文Context相关的背景信息
2. **Prompt格式化**将结构化后的需求转换为标准的AI提示词格式包括
- 清晰的指令结构
- 适当的任务描述
- 明确的输出要求
- 必要的约束条件
3. **模板生成**根据需求类型自动应用对应的prompt模板包括
- 代码生成类模板
- 内容创作类模板
- 数据分析类模板
- 问题解决类模板
4. **需求确认**在生成最终prompt前与用户进行需求确认确保
- 需求理解准确无误
- 关键要素无遗漏
- 输出格式符合预期
- 可根据用户反馈进行调整
## 使用场景
当遇到以下情况时,应调用此技能:
- **用户提出新需求**用户描述了一个新的功能需求或任务需要将其转换为AI可处理的prompt
- **需求分析**需要深入分析和拆解复杂的需求确保AI能够准确理解
- **Prompt优化**现有prompt效果不佳需要重新组织和优化结构
## 使用方法
1. 接收用户的原始需求描述
2. 调用此技能进行需求拆解和结构化分析
3. 生成初始的prompt方案
4. 与用户进行需求确认,包括:
- 验证需求理解是否准确
- 确认关键要素是否完整
- 检查输出格式是否符合预期
- 收集用户的反馈和调整建议
5. 根据用户确认的结果优化和完善prompt
6. 提供最终确认后的prompt给AI模型使用
## 示例
### 输入示例
用户需求:"帮我写一个Python脚本爬取网站数据并保存到Excel文件"
### 输出示例
```
请帮我创建一个Python脚本实现以下功能
目标爬取指定网站的数据并将结果保存到Excel文件
输入:
- 网站URL[待提供]
- 需要爬取的数据字段:[待指定]
- 爬取深度:[待指定]
输出:
- 生成一个Python脚本文件
- 脚本应包含完整的代码和注释
- 生成的Excel文件应包含所有爬取的数据
约束:
- 使用合法的爬取方式遵守网站robots.txt规则
- 脚本应具有错误处理能力
- 爬取过程应考虑速率限制,避免对目标网站造成压力
请提供完整的实现代码,并确保代码可直接运行。
```

File diff suppressed because it is too large Load Diff

@ -0,0 +1,42 @@
{
"name": "alpha-futures-backend",
"version": "1.0.0",
"description": "AI期货分析系统后端API服务",
"main": "dist/app.js",
"scripts": {
"dev": "ts-node-dev --respawn --transpile-only src/app.ts",
"build": "tsc",
"start": "node dist/app.js",
"lint": "eslint .",
"test": "mocha --require ts-node/register test/**/*.ts"
},
"dependencies": {
"express": "^4.18.2",
"cors": "^2.8.5",
"helmet": "^7.1.0",
"morgan": "^1.10.0",
"express-rate-limit": "^7.1.5",
"jsonwebtoken": "^9.0.2",
"dotenv": "^16.3.1",
"mongoose": "^8.0.3",
"pg": "^8.11.3",
"redis": "^4.6.12",
"socket.io": "^4.7.4"
},
"devDependencies": {
"@types/express": "^4.17.21",
"@types/cors": "^2.8.17",
"@types/morgan": "^1.9.9",
"@types/jsonwebtoken": "^9.0.5",
"@types/pg": "^8.10.9",
"@types/node": "^20.10.4",
"@typescript-eslint/eslint-plugin": "^6.15.0",
"@typescript-eslint/parser": "^6.15.0",
"eslint": "^8.56.0",
"ts-node-dev": "^2.0.0",
"typescript": "^5.3.3",
"mocha": "^10.2.0",
"chai": "^4.3.10",
"supertest": "^6.3.3"
}
}

@ -0,0 +1,61 @@
import express from 'express';
import { fetchAIAnalysis, fetchMultiDimensionAnalysis, fetchTrendPrediction, fetchWinRateAssessment, fetchTechnicalIndicators } from '../services/analysisService';
const router = express.Router();
// 获取AI分析
router.get('/ai/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchAIAnalysis(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取AI分析失败' });
}
});
// 获取多维度分析
router.get('/multi/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchMultiDimensionAnalysis(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取多维度分析失败' });
}
});
// 获取趋势预测
router.get('/trend/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchTrendPrediction(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取趋势预测失败' });
}
});
// 获取胜率评估
router.get('/winrate/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchWinRateAssessment(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取胜率评估失败' });
}
});
// 获取技术指标
router.get('/indicators/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchTechnicalIndicators(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取技术指标失败' });
}
});
export default router;

@ -0,0 +1,98 @@
import express from 'express';
import { fetchDataSources, saveDataSource, fetchAIModels, saveAIModel, fetchSystemSettings, saveSystemSettings } from '../services/configService';
const router = express.Router();
// 获取数据源列表
router.get('/datasources', async (req, res) => {
try {
const data = await fetchDataSources();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取数据源列表失败' });
}
});
// 保存数据源配置
router.post('/datasources', async (req, res) => {
try {
const data = await saveDataSource(req.body);
res.status(200).json({ success: true, message: '配置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存数据源配置失败' });
}
});
// 获取AI模型列表
router.get('/ai-models', async (req, res) => {
try {
const data = await fetchAIModels();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取AI模型列表失败' });
}
});
// 保存AI模型配置
router.post('/ai-models', async (req, res) => {
try {
const data = await saveAIModel(req.body);
res.status(200).json({ success: true, message: '配置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存AI模型配置失败' });
}
});
// 获取系统设置
router.get('/system', async (req, res) => {
try {
const data = await fetchSystemSettings();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取系统设置失败' });
}
});
// 保存系统设置
router.post('/system', async (req, res) => {
try {
const data = await saveSystemSettings(req.body);
res.status(200).json({ success: true, message: '设置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存系统设置失败' });
}
});
// 获取用户设置
router.get('/user', async (req, res) => {
try {
const data = {
preferences: {
theme: 'light',
language: 'zh-CN',
timezone: 'Asia/Shanghai'
},
notifications: {
email: true,
sms: false,
wechat: true
}
};
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取用户设置失败' });
}
});
// 保存用户设置
router.post('/user', async (req, res) => {
try {
// 模拟保存操作
await new Promise(resolve => setTimeout(resolve, 200));
res.status(200).json({ success: true, message: '设置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存用户设置失败' });
}
});
export default router;

@ -0,0 +1,59 @@
import express from 'express';
import { fetchMarketOverview, fetchMarketDetail, fetchKlineData, fetchMarketHotspots, fetchRiskAlerts } from '../services/marketService';
const router = express.Router();
// 获取市场概览
router.get('/overview', async (req, res) => {
try {
const data = await fetchMarketOverview();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取市场概览失败' });
}
});
// 获取品种详情
router.get('/detail/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchMarketDetail(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取品种详情失败' });
}
});
// 获取K线数据
router.get('/klines/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const { period = '1H' } = req.query;
const data = await fetchKlineData(symbol, period as string);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取K线数据失败' });
}
});
// 获取市场热点
router.get('/hotspots', async (req, res) => {
try {
const data = await fetchMarketHotspots();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取市场热点失败' });
}
});
// 获取风险预警
router.get('/alerts', async (req, res) => {
try {
const data = await fetchRiskAlerts();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取风险预警失败' });
}
});
export default router;

@ -0,0 +1,49 @@
import express from 'express';
import { fetchPushSettings, savePushSettings, testPush, fetchPushHistory } from '../services/pushService';
const router = express.Router();
// 获取推送设置
router.get('/settings/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchPushSettings(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取推送设置失败' });
}
});
// 保存推送设置
router.post('/settings/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await savePushSettings(symbol, req.body);
res.status(200).json({ success: true, message: '设置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存推送设置失败' });
}
});
// 测试推送
router.post('/test', async (req, res) => {
try {
const { method, content } = req.body;
const data = await testPush(method, content);
res.status(200).json({ success: true, message: '测试推送成功' });
} catch (error) {
res.status(500).json({ success: false, message: '测试推送失败' });
}
});
// 获取推送历史
router.get('/history', async (req, res) => {
try {
const data = await fetchPushHistory();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取推送历史失败' });
}
});
export default router;

@ -0,0 +1,61 @@
import express from 'express';
import { fetchStopLossAdvice, fetchPositionAdvice, fetchRolloverAlerts, fetchRiskAssessment } from '../services/riskService';
const router = express.Router();
// 获取止损建议
router.get('/stoploss/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchStopLossAdvice(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取止损建议失败' });
}
});
// 获取仓位建议
router.post('/position', async (req, res) => {
try {
const { capital, risk_tolerance, symbols } = req.body;
const data = await fetchPositionAdvice(capital, risk_tolerance, symbols);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取仓位建议失败' });
}
});
// 获取换月预警
router.get('/rollover', async (req, res) => {
try {
const data = await fetchRolloverAlerts();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取换月预警失败' });
}
});
// 获取风险评估
router.get('/assessment/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await fetchRiskAssessment(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取风险评估失败' });
}
});
// 保存风控设置
router.post('/settings', async (req, res) => {
try {
const { stop_loss_strategy, risk_tolerance, max_position } = req.body;
// 模拟保存操作
await new Promise(resolve => setTimeout(resolve, 200));
res.status(200).json({ success: true, message: '设置保存成功' });
} catch (error) {
res.status(500).json({ success: false, message: '保存风控设置失败' });
}
});
export default router;

@ -0,0 +1,49 @@
import express from 'express';
import { fetchWatchlist, addToWatchlist, removeFromWatchlist, checkWatchlistStatus } from '../services/watchlistService';
const router = express.Router();
// 获取自选列表
router.get('/', async (req, res) => {
try {
const data = await fetchWatchlist();
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '获取自选列表失败' });
}
});
// 添加自选
router.post('/', async (req, res) => {
try {
const { symbol, name } = req.body;
const data = await addToWatchlist(symbol, name);
res.status(200).json({ success: true, message: '添加成功' });
} catch (error) {
res.status(500).json({ success: false, message: '添加自选失败' });
}
});
// 删除自选
router.delete('/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await removeFromWatchlist(symbol);
res.status(200).json({ success: true, message: '删除成功' });
} catch (error) {
res.status(500).json({ success: false, message: '删除自选失败' });
}
});
// 检查自选状态
router.get('/status/:symbol', async (req, res) => {
try {
const { symbol } = req.params;
const data = await checkWatchlistStatus(symbol);
res.status(200).json({ success: true, data });
} catch (error) {
res.status(500).json({ success: false, message: '检查自选状态失败' });
}
});
export default router;

@ -0,0 +1,62 @@
import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import morgan from 'morgan';
import rateLimit from 'express-rate-limit';
import { config } from './config';
import marketRoutes from './api/market';
import analysisRoutes from './api/analysis';
import riskRoutes from './api/risk';
import configRoutes from './api/config';
import watchlistRoutes from './api/watchlist';
import pushRoutes from './api/push';
const app = express();
// 中间件配置
app.use(helmet());
app.use(cors(config.cors));
app.use(morgan('combined'));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
// 速率限制
app.use(rateLimit({
windowMs: config.rateLimit.windowMs,
max: config.rateLimit.max,
message: {
success: false,
message: '请求过于频繁,请稍后再试'
}
}));
// 健康检查
app.get('/health', (req, res) => {
res.status(200).json({ success: true, message: '服务运行正常' });
});
// API路由注册
app.use('/api/market', marketRoutes);
app.use('/api/analysis', analysisRoutes);
app.use('/api/risk', riskRoutes);
app.use('/api/config', configRoutes);
app.use('/api/watchlist', watchlistRoutes);
app.use('/api/push', pushRoutes);
// 404处理
app.use((req, res) => {
res.status(404).json({ success: false, message: '接口不存在' });
});
// 错误处理
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
console.error(err.stack);
res.status(500).json({ success: false, message: '服务器内部错误' });
});
// 启动服务器
app.listen(config.port, () => {
console.log(`服务器运行在 http://localhost:${config.port}`);
});
export default app;

@ -0,0 +1,32 @@
import dotenv from 'dotenv';
dotenv.config();
export const config = {
port: process.env.PORT || 3005,
jwtSecret: process.env.JWT_SECRET || 'your-secret-key',
database: {
mongo: {
url: process.env.MONGO_URL || 'mongodb://localhost:27017/alpha-futures'
},
postgres: {
host: process.env.PG_HOST || 'localhost',
port: parseInt(process.env.PG_PORT || '5432'),
user: process.env.PG_USER || 'postgres',
password: process.env.PG_PASSWORD || 'password',
database: process.env.PG_DATABASE || 'alpha-futures'
}
},
redis: {
url: process.env.REDIS_URL || 'redis://localhost:6379'
},
rateLimit: {
windowMs: 60 * 1000, // 1分钟
max: 120 // 每分钟120次请求
},
cors: {
origin: '*', // 在生产环境中应该设置具体的域名
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
allowedHeaders: ['Content-Type', 'Authorization']
}
};

@ -0,0 +1,142 @@
// 分析服务
import { generateFutureData, futuresList } from '../utils/mockData';
// 获取AI分析
export const fetchAIAnalysis = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 500));
const future = futuresList.find(item => item.code === symbol);
if (!future) {
throw new Error('品种不存在');
}
const data = generateFutureData(symbol, future.name);
return {
symbol,
technical: {
trend: data.overallView,
indicators: data.indicators,
strength: data.adx > 40 ? '强' : data.adx > 20 ? '弱' : '无'
},
fundamental: {
industry: future.type,
supplyDemand: ['平衡', '供过于求', '供不应求'][Math.floor(Math.random() * 3)],
policyImpact: ['中性', '利好', '利空'][Math.floor(Math.random() * 3)]
},
sentiment: {
marketSentiment: ['中性', '乐观', '悲观'][Math.floor(Math.random() * 3)],
positioning: ['多头', '空头', '平衡'][Math.floor(Math.random() * 3)],
volumeAnalysis: '正常'
},
prediction: {
trend: ['上涨', '下跌', '震荡'][Math.floor(Math.random() * 3)],
winRate: data.winRate,
expectedReturn: +(Math.random() * 10 - 2).toFixed(2),
timeHorizon: '1-3天'
}
};
};
// 获取多维度分析
export const fetchMultiDimensionAnalysis = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 400));
return {
technical: {
trend: ['多头', '空头', '震荡'][Math.floor(Math.random() * 3)],
support: +(Math.random() * 500 + 1500).toFixed(2),
resistance: +(Math.random() * 500 + 2500).toFixed(2),
indicators: {
macd: ['金叉', '死叉', '走平'][Math.floor(Math.random() * 3)],
rsi: Math.floor(Math.random() * 40) + 30,
kdj: ['金叉', '死叉', '走平'][Math.floor(Math.random() * 3)]
}
},
capital: {
fundFlow: ['流入', '流出', '平衡'][Math.floor(Math.random() * 3)],
openInterest: Math.floor(Math.random() * 100000) + 50000,
volume: Math.floor(Math.random() * 1000000) + 100000,
largePositions: Math.floor(Math.random() * 50) + 20
},
policy: {
industryPolicy: ['中性', '利好', '利空'][Math.floor(Math.random() * 3)],
macroEconomy: ['稳定', '向好', '向坏'][Math.floor(Math.random() * 3)],
internationalFactors: ['稳定', '有利', '不利'][Math.floor(Math.random() * 3)]
}
};
};
// 获取趋势预测
export const fetchTrendPrediction = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
return {
short_term: {
trend: ['上涨', '下跌', '震荡'][Math.floor(Math.random() * 3)],
confidence: Math.floor(Math.random() * 30) + 60,
timeHorizon: '1-3天'
},
medium_term: {
trend: ['上涨', '下跌', '震荡'][Math.floor(Math.random() * 3)],
confidence: Math.floor(Math.random() * 25) + 55,
timeHorizon: '1-2周'
},
long_term: {
trend: ['上涨', '下跌', '震荡'][Math.floor(Math.random() * 3)],
confidence: Math.floor(Math.random() * 20) + 50,
timeHorizon: '1-3月'
}
};
};
// 获取胜率评估
export const fetchWinRateAssessment = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
const winRate = Math.floor(Math.random() * 30) + 40;
return {
win_rate: winRate,
risk_reward: +(Math.random() * 2 + 0.5).toFixed(2),
backtest_results: {
period: '过去3个月',
total_trades: Math.floor(Math.random() * 50) + 50,
win_trades: Math.floor(winRate / 100 * 100),
loss_trades: Math.floor((100 - winRate) / 100 * 100),
profit_factor: +(Math.random() * 2 + 0.5).toFixed(2)
}
};
};
// 获取技术指标
export const fetchTechnicalIndicators = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return {
macd: {
value: +(Math.random() * 2 - 1).toFixed(2),
signal: +(Math.random() * 2 - 1).toFixed(2),
histogram: +(Math.random() * 1 - 0.5).toFixed(2),
status: ['金叉', '死叉', '走平'][Math.floor(Math.random() * 3)]
},
rsi: {
value: Math.floor(Math.random() * 40) + 30,
status: ['超买', '超卖', '正常'][Math.floor(Math.random() * 3)]
},
kdj: {
k: +(Math.random() * 100).toFixed(2),
d: +(Math.random() * 100).toFixed(2),
j: +(Math.random() * 100).toFixed(2),
status: ['金叉', '死叉', '走平'][Math.floor(Math.random() * 3)]
},
bollinger: {
upper: +(Math.random() * 500 + 2500).toFixed(2),
middle: +(Math.random() * 500 + 2000).toFixed(2),
lower: +(Math.random() * 500 + 1500).toFixed(2),
status: ['突破上轨', '突破下轨', '通道内'][Math.floor(Math.random() * 3)]
}
};
};

@ -0,0 +1,65 @@
// 配置服务
// 获取数据源列表
export const fetchDataSources = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return [
{ id: 1, name: 'Wind', status: 'online', priority: 1, enabled: true },
{ id: 2, name: '同花顺', status: 'online', priority: 2, enabled: true },
{ id: 3, name: '东方财富', status: 'online', priority: 3, enabled: true },
{ id: 4, name: '新浪财经', status: 'offline', priority: 4, enabled: false },
{ id: 5, name: 'TQSDK', status: 'online', priority: 5, enabled: true },
{ id: 6, name: 'RQData', status: 'online', priority: 6, enabled: true }
];
};
// 保存数据源配置
export const saveDataSource = async (data: any) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
console.log('保存数据源配置:', data);
return data;
};
// 获取AI模型列表
export const fetchAIModels = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return [
{ id: 1, name: 'DeepSeek', accuracy: '85%', responseTime: '250ms', enabled: true },
{ id: 2, name: 'GPT-4', accuracy: '88%', responseTime: '350ms', enabled: false },
{ id: 3, name: 'Claude', accuracy: '82%', responseTime: '200ms', enabled: false },
{ id: 4, name: '自定义模型', accuracy: '78%', responseTime: '150ms', enabled: false }
];
};
// 保存AI模型配置
export const saveAIModel = async (data: any) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
console.log('保存AI模型配置:', data);
return data;
};
// 获取系统设置
export const fetchSystemSettings = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 100));
return {
refresh_interval: 30,
alert_threshold: 70,
backtest_days: 90
};
};
// 保存系统设置
export const saveSystemSettings = async (data: any) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
console.log('保存系统设置:', data);
return data;
};

@ -0,0 +1,51 @@
// 市场数据服务
import { futuresList, generateFuturesOverview, generateFutureData, generateKlineData, riskAlerts } from '../utils/mockData';
// 获取市场概览
export const fetchMarketOverview = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
return generateFuturesOverview();
};
// 获取品种详情
export const fetchMarketDetail = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
const future = futuresList.find(item => item.code === symbol);
if (!future) {
throw new Error('品种不存在');
}
return generateFutureData(symbol, future.name);
};
// 获取K线数据
export const fetchKlineData = async (symbol: string, period: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return generateKlineData(30);
};
// 获取市场热点
export const fetchMarketHotspots = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
const overview = generateFuturesOverview();
// 按涨跌幅排序返回前10个
return overview
.sort((a, b) => Math.abs(b.changePercent) - Math.abs(a.changePercent))
.slice(0, 10)
.map(item => ({
symbol: item.code,
name: item.name,
change: item.changePercent,
volume: Math.floor(Math.random() * 1000000) + 100000
}));
};
// 获取风险预警
export const fetchRiskAlerts = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 100));
return riskAlerts;
};

@ -0,0 +1,66 @@
// 推送服务
// 模拟推送设置存储
const pushSettings: Record<string, any> = {
'AU': {
methods: ['email', 'wechat'],
timing: 'realTime',
content: ['price', 'trend', 'risk'],
price_level: 300
},
'AG': {
methods: ['email'],
timing: 'realTime',
content: ['price', 'trend'],
price_level: 50
}
};
// 模拟推送历史存储
const pushHistory: any[] = [
{ id: 1, timestamp: new Date().toISOString(), method: 'email', content: 'AU价格突破3000', status: 'success' },
{ id: 2, timestamp: new Date().toISOString(), method: 'wechat', content: 'AG趋势改变', status: 'success' },
{ id: 3, timestamp: new Date().toISOString(), method: 'email', content: 'CU风险预警', status: 'failed' }
];
// 获取推送设置
export const fetchPushSettings = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return pushSettings[symbol] || {
methods: ['email'],
timing: 'realTime',
content: ['price']
};
};
// 保存推送设置
export const savePushSettings = async (symbol: string, settings: any) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
pushSettings[symbol] = settings;
console.log('保存推送设置:', symbol, settings);
return settings;
};
// 测试推送
export const testPush = async (method: string, content: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 500));
console.log('测试推送:', method, content);
// 模拟推送成功
return { success: true, message: '测试推送成功' };
};
// 获取推送历史
export const fetchPushHistory = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
return pushHistory;
};

@ -0,0 +1,81 @@
// 风控服务
import { generateFutureData, futuresList } from '../utils/mockData';
// 获取止损建议
export const fetchStopLossAdvice = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
const future = futuresList.find(item => item.code === symbol);
if (!future) {
throw new Error('品种不存在');
}
const data = generateFutureData(symbol, future.name);
return {
stop_loss_price: data.tradingAdvice.stopLoss,
strategy: ['固定止损', '移动止损', '波动率止损'][Math.floor(Math.random() * 3)],
reasoning: `基于${data.volatility}波动率和${data.riskLevel}风险等级,建议设置止损位在${data.tradingAdvice.stopLoss.toFixed(2)}`
};
};
// 获取仓位建议
export const fetchPositionAdvice = async (capital: number, risk_tolerance: string, symbols: string[]) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 400));
// 根据风险承受能力计算仓位比例
const riskMultiplier = risk_tolerance === 'high' ? 0.05 : risk_tolerance === 'medium' ? 0.03 : 0.01;
const positions = symbols.map(symbol => {
const future = futuresList.find(item => item.code === symbol);
if (!future) return null;
const positionPercentage = +(Math.random() * 20 + 5).toFixed(2);
const positionAmount = capital * positionPercentage / 100;
return {
symbol,
percentage: positionPercentage,
amount: positionAmount,
reasoning: `基于${risk_tolerance}风险承受能力,建议配置${positionPercentage}%的仓位`
};
}).filter(Boolean);
return { positions };
};
// 获取换月预警
export const fetchRolloverAlerts = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
const alerts = [
{ symbol: 'RB', expiration_date: '2026-05-15', days_left: 15, recommendation: '建议开始移仓' },
{ symbol: 'SC', expiration_date: '2026-06-20', days_left: 30, recommendation: '关注换月' },
{ symbol: 'CU', expiration_date: '2026-04-20', days_left: 5, recommendation: '紧急移仓' },
{ symbol: 'MA', expiration_date: '2026-05-10', days_left: 10, recommendation: '建议移仓' }
];
return alerts;
};
// 获取风险评估
export const fetchRiskAssessment = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
const future = futuresList.find(item => item.code === symbol);
if (!future) {
throw new Error('品种不存在');
}
const riskLevel = ['低', '中等', '高'][Math.floor(Math.random() * 3)];
const volatility = +(Math.random() * 10 + 5).toFixed(2);
const liquidity = +(Math.random() * 50 + 50).toFixed(2);
return {
risk_level: riskLevel,
volatility: volatility,
liquidity: liquidity,
reasoning: `该品种风险等级为${riskLevel},波动率为${volatility}%,流动性良好,适合${riskLevel === '高' ? '激进' : riskLevel === '中等' ? '稳健' : '保守'}型投资者`
};
};

@ -0,0 +1,57 @@
// 自选服务
import { generateFutureData, futuresList } from '../utils/mockData';
// 模拟自选列表存储
let watchlist: string[] = ['AU', 'AG', 'CU'];
// 获取自选列表
export const fetchWatchlist = async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
const watchlistData = watchlist.map(symbol => {
const future = futuresList.find(item => item.code === symbol);
if (!future) return null;
const data = generateFutureData(symbol, future.name);
return {
symbol: data.code,
name: data.name,
price: data.currentPrice,
change: data.changePercent
};
}).filter(Boolean);
return watchlistData;
};
// 添加自选
export const addToWatchlist = async (symbol: string, name: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
if (!watchlist.includes(symbol)) {
watchlist.push(symbol);
}
return { symbol, name };
};
// 删除自选
export const removeFromWatchlist = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 200));
watchlist = watchlist.filter(item => item !== symbol);
return { symbol };
};
// 检查自选状态
export const checkWatchlistStatus = async (symbol: string) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 100));
return {
is_in_watchlist: watchlist.includes(symbol)
};
};

@ -0,0 +1,223 @@
// 模拟数据
// 期货品种列表
export const futuresList = [
// 金属类
{ code: 'AU', name: '金', type: '金属' },
{ code: 'AG', name: '银', type: '金属' },
{ code: 'CU', name: '铜', type: '金属' },
{ code: 'NI', name: '镍', type: '金属' },
{ code: 'SN', name: '锡', type: '金属' },
{ code: 'AL', name: '铝', type: '金属' },
{ code: 'ZN', name: '锌', type: '金属' },
// 建材类
{ code: 'FG', name: '玻璃', type: '建材' },
{ code: 'SJS', name: '烧碱', type: '建材' },
{ code: 'SCA', name: '纯碱', type: '建材' },
{ code: 'JM', name: '焦煤', type: '建材' },
{ code: 'RB', name: '螺纹钢', type: '建材' },
{ code: 'ALO', name: '氧化铝', type: '建材' },
// 能源化工类
{ code: 'MA', name: '甲醇', type: '能源化工' },
{ code: 'PVC', name: 'PVC', type: '能源化工' },
{ code: 'FU', name: '燃油', type: '能源化工' },
{ code: 'SC', name: '原油', type: '能源化工' },
{ code: 'L', name: '橡胶', type: '能源化工' },
{ code: 'NR', name: '20号胶', type: '能源化工' },
{ code: 'BU', name: '沥青', type: '能源化工' },
{ code: 'LU', name: '低硫燃油', type: '能源化工' },
// 农产品类
{ code: 'P', name: '棕榈油', type: '农产品' },
// 新能源类
{ code: 'LC', name: '碳酸锂', type: '新能源' },
{ code: 'SI', name: '工业硅', type: '新能源' },
{ code: 'PGS', name: '多晶硅', type: '新能源' },
// 金融类
{ code: 'IC', name: '中证500', type: '金融' },
{ code: 'IM', name: '中证1000', type: '金融' },
{ code: 'IH', name: '上证50', type: '金融' }
];
// 生成随机数据的工具函数
const generateRandomPrice = (base: number, volatility: number) => {
return +(base + (Math.random() - 0.5) * 2 * volatility).toFixed(2);
};
const generateRandomChange = () => {
return +(Math.random() * 10 - 5).toFixed(2);
};
const generateRandomWinRate = () => {
return Math.floor(Math.random() * 50) + 30;
};
const generateRandomATR = () => {
return +(Math.random() * 5 + 0.5).toFixed(2);
};
const generateRandomADX = () => {
return Math.floor(Math.random() * 60) + 10;
};
const getADXStatus = (adx: number) => {
if (adx < 20) return '无趋势/震荡';
if (adx < 40) return '弱趋势';
return '强趋势';
};
const getTrendDirection = () => {
const directions = ['看多', '看空', '观望'];
return directions[Math.floor(Math.random() * directions.length)];
};
const getTrendStatus = (direction: string) => {
if (direction === '看多') return '多头趋势';
if (direction === '看空') return '空头趋势';
return '震荡';
};
const generateRandomRSI = () => {
return Math.floor(Math.random() * 80) + 10;
};
// 生成品种详细数据
export const generateFutureData = (code: string, name: string) => {
const currentPrice = generateRandomPrice(2000, 500);
const changePercent = generateRandomChange();
const atr = generateRandomATR();
const adx = generateRandomADX();
const winRate = generateRandomWinRate();
const trends = {
'5MIN': {
direction: getTrendDirection(),
status: getTrendStatus(getTrendDirection()),
rsi: generateRandomRSI()
},
'30MIN': {
direction: getTrendDirection(),
status: getTrendStatus(getTrendDirection()),
rsi: generateRandomRSI()
},
'1HOUR': {
direction: getTrendDirection(),
status: getTrendStatus(getTrendDirection()),
rsi: generateRandomRSI()
},
'1DAY': {
direction: getTrendDirection(),
status: getTrendStatus(getTrendDirection()),
rsi: generateRandomRSI()
}
};
const indicators = {
macd: ['金叉向上', '死叉向下', '走平'][Math.floor(Math.random() * 3)],
rsi: `${generateRandomRSI()}(中性)`,
bollinger: ['触及上轨', '触及下轨', '中轨附近'][Math.floor(Math.random() * 3)],
kdj: ['金叉向上', '死叉向下', '走平'][Math.floor(Math.random() * 3)]
};
const entry = currentPrice;
const stopLoss = entry * (1 - 0.02 * (Math.random() + 0.5));
const target = entry * (1 + 0.03 * (Math.random() + 0.5));
const resistance = entry * (1 + 0.05 * (Math.random() + 0.5));
const support = entry * (1 - 0.05 * (Math.random() + 0.5));
const overallViews = ['观望', '中线', '多头排列', '空头排列', '震荡'];
const overallView = overallViews[Math.floor(Math.random() * overallViews.length)];
return {
code,
name,
fullName: `${name}-${code}605`,
currentPrice,
changePercent,
winRate,
atr,
adx,
adxStatus: getADXStatus(adx),
trends,
indicators,
tradingAdvice: {
entry: +entry.toFixed(2),
stopLoss: +stopLoss.toFixed(2),
target: +target.toFixed(2),
resistance: +resistance.toFixed(2),
support: +support.toFixed(2)
},
riskLevel: ['低', '中等', '高'][Math.floor(Math.random() * 3)],
volatility: ['低', '中等', '高'][Math.floor(Math.random() * 3)],
overallView,
aiAnalysis: `MACD:${indicators.macd} | RSI:${indicators.rsi} | 布林带:${indicators.bollinger}`
};
};
// 生成多个品种的概览数据
export const generateFuturesOverview = () => {
return futuresList.map(item => {
const data = generateFutureData(item.code, item.name);
return {
code: data.code,
name: data.name,
currentPrice: data.currentPrice,
changePercent: data.changePercent,
winRate: data.winRate,
atr: data.atr,
adx: data.adx,
adxStatus: data.adxStatus,
trends: data.trends,
tradingAdvice: data.tradingAdvice,
overallView: data.overallView,
aiAnalysis: data.aiAnalysis
};
});
};
// 风险预警数据
export const riskAlerts = [
{ id: 1, title: '原油波动加剧', level: '高', message: '原油价格近期波动较大,建议控制仓位' },
{ id: 2, title: '螺纹钢换月提醒', level: '中等', message: '螺纹钢主力合约即将换月,请注意移仓' },
{ id: 3, title: '市场情绪偏空', level: '中等', message: '多数品种技术指标显示空头信号,建议谨慎操作' },
{ id: 4, title: '铜库存下降', level: '低', message: '铜库存持续下降,可能影响价格走势' }
];
// K线图模拟数据
export const generateKlineData = (days: number) => {
const data = [];
let price = 2000;
for (let i = 0; i < days; i++) {
const open = price;
const high = open + Math.random() * 50;
const low = open - Math.random() * 50;
const close = low + Math.random() * (high - low);
const volume = Math.floor(Math.random() * 100000) + 10000;
data.push({
time: new Date(Date.now() - (days - i) * 24 * 60 * 60 * 1000).getTime() / 1000,
open: +open.toFixed(2),
high: +high.toFixed(2),
low: +low.toFixed(2),
close: +close.toFixed(2),
volume
});
price = close;
}
return data;
};
// AI市场研判
export const aiMarketAnalysis = {
overallTrend: '震荡偏弱',
keyFactors: ['原油价格波动', '宏观经济数据', '政策面变化'],
recommendations: ['控制仓位', '关注原油走势', '做好止损'],
confidence: 75
};

@ -0,0 +1,26 @@
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"lib": ["ES2020"],
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"moduleResolution": "node",
"declaration": true,
"declarationMap": true,
"sourceMap": true
},
"include": [
"src/**/*"
],
"exclude": [
"node_modules",
"dist",
"test"
]
}

@ -0,0 +1,688 @@
# AI期货分析系统架构设计方案
## 1. 技术栈选择
### 1.1 前端技术栈
| 技术 | 版本 | 用途 | 选型理由 |
|------|------|------|----------|
| React | 18.x | 前端框架 | 组件化开发,性能优异,生态成熟 |
| TypeScript | 5.x | 类型系统 | 提供类型安全,减少运行时错误 |
| Ant Design | 5.x | UI组件库 | 专业金融界面,组件丰富,响应式设计 |
| Redux Toolkit | 2.x | 状态管理 | 简化Redux使用提供更好的开发体验 |
| ECharts | 5.x | 数据可视化 | 强大的图表能力,适合金融数据展示 |
| TradingView Lightweight Charts | 4.x | K线图表 | 专业级K线图表性能优异功能丰富 |
| Vite | 5.x | 构建工具 | 快速的开发服务器和构建速度 |
| React Router | 6.x | 路由管理 | 声明式路由,支持嵌套路由和路由守卫 |
### 1.2 后端技术栈
| 技术 | 版本 | 用途 | 选型理由 |
|------|------|------|----------|
| Node.js | 18.x | 运行环境 | 高性能适合I/O密集型应用 |
| Express | 4.x | Web框架 | 轻量级API设计简洁中间件丰富 |
| TypeScript | 5.x | 类型系统 | 提供类型安全,提高代码可维护性 |
| MongoDB | 6.x | 文档数据库 | 灵活的数据模型,适合存储结构化和半结构化数据 |
| Redis | 7.x | 缓存 | 高性能缓存,适合存储热点数据和会话信息 |
| PostgreSQL | 15.x | 关系型数据库 | 强大的查询能力,适合存储结构化金融数据 |
| MQTT | 4.x | 消息队列 | 适合实时数据传输,支持物联网设备通信 |
| Socket.IO | 4.x | 实时通信 | 支持WebSocket适合实时数据推送 |
| JWT | - | 认证 | 无状态认证,便于水平扩展 |
### 1.3 AI技术栈
| 技术 | 版本 | 用途 | 选型理由 |
|------|------|------|----------|
| Python | 3.10+ | AI开发语言 | 数据科学和机器学习的标准语言 |
| TensorFlow/PyTorch | 2.x | 深度学习框架 | 支持复杂模型训练和推理 |
| DeepSeek | - | 大语言模型 | 高性能中文大模型,适合金融分析 |
| scikit-learn | 1.3+ | 机器学习库 | 提供丰富的机器学习算法 |
| NumPy/Pandas | 1.24+/2.0+ | 数据处理 | 高效的数值计算和数据处理 |
| FastAPI | 0.100+ | AI服务框架 | 高性能API框架支持异步处理 |
## 2. 系统架构图
```mermaid
flowchart TD
subgraph 前端层
WebApp["Web应用\nReact + Ant Design"]
MobileApp["移动App\nReact Native"]
WebApp -->|API调用| APIGateway
MobileApp -->|API调用| APIGateway
end
subgraph 接口层
APIGateway["API网关\nExpress + Nginx"]
RateLimiter["速率限制"]
AuthService["认证服务\nJWT"]
APIGateway --> RateLimiter
RateLimiter --> AuthService
AuthService -->|验证通过| BackendServices
end
subgraph 后端服务层
BackendServices["后端服务"]
MarketService["市场数据服务"]
AnalysisService["分析服务"]
RiskService["风控服务"]
ConfigService["配置服务"]
WatchlistService["自选服务"]
PushService["推送服务"]
BackendServices --> MarketService
BackendServices --> AnalysisService
BackendServices --> RiskService
BackendServices --> ConfigService
BackendServices --> WatchlistService
BackendServices --> PushService
end
subgraph AI层
AIServices["AI服务"]
LLMService["大语言模型服务\nDeepSeek"]
QuantService["量化分析服务"]
PredictionService["预测服务"]
AIServices --> LLMService
AIServices --> QuantService
AIServices --> PredictionService
AnalysisService --> AIServices
end
subgraph 数据层
DataLayer["数据存储"]
RealTimeDB["实时行情数据库\nInfluxDB"]
HistoricalDB["历史数据库\nPostgreSQL"]
AnalysisDB["分析结果库\nMongoDB"]
CacheDB["缓存\nRedis"]
ConfigDB["配置数据库\nMongoDB"]
DataLayer --> RealTimeDB
DataLayer --> HistoricalDB
DataLayer --> AnalysisDB
DataLayer --> CacheDB
DataLayer --> ConfigDB
MarketService --> DataLayer
AnalysisService --> DataLayer
RiskService --> DataLayer
ConfigService --> ConfigDB
WatchlistService --> AnalysisDB
end
subgraph 外部服务层
ExternalServices["外部服务"]
MarketDataAPI["行情数据API"]
NewsAPI["新闻/政策API"]
SMSAPI["短信服务"]
EmailAPI["邮件服务"]
WeChatAPI["微信服务"]
DingTalkAPI["钉钉服务"]
ExternalServices --> MarketDataAPI
ExternalServices --> NewsAPI
ExternalServices --> SMSAPI
ExternalServices --> EmailAPI
ExternalServices --> WeChatAPI
ExternalServices --> DingTalkAPI
MarketService --> MarketDataAPI
AnalysisService --> NewsAPI
PushService --> SMSAPI
PushService --> EmailAPI
PushService --> WeChatAPI
PushService --> DingTalkAPI
end
```
## 3. 核心流程设计
### 3.1 市场数据获取与处理流程
```mermaid
sequenceDiagram
participant Client as 前端
participant API as API网关
participant MarketService as 市场数据服务
participant Cache as Redis缓存
participant RealTimeDB as 实时数据库
participant ExternalAPI as 外部行情API
Client->>API: 请求市场数据
API->>MarketService: 转发请求
MarketService->>Cache: 检查缓存
alt 缓存命中
Cache-->>MarketService: 返回缓存数据
else 缓存未命中
MarketService->>RealTimeDB: 查询实时数据库
alt 数据库有数据
RealTimeDB-->>MarketService: 返回数据
MarketService->>Cache: 更新缓存
else 数据库无数据
MarketService->>ExternalAPI: 请求外部API
ExternalAPI-->>MarketService: 返回行情数据
MarketService->>RealTimeDB: 存储实时数据
MarketService->>Cache: 更新缓存
end
end
MarketService-->>API: 返回数据
API-->>Client: 响应数据
```
### 3.2 AI分析流程
```mermaid
sequenceDiagram
participant Client as 前端
participant API as API网关
participant AnalysisService as 分析服务
participant AIService as AI服务
participant MarketService as 市场数据服务
participant AnalysisDB as 分析结果库
Client->>API: 请求AI分析
API->>AnalysisService: 转发请求
AnalysisService->>MarketService: 获取市场数据
MarketService-->>AnalysisService: 返回数据
AnalysisService->>AIService: 调用AI分析
AIService->>AIService: 执行技术分析
AIService->>AIService: 执行资金面分析
AIService->>AIService: 执行政策面分析
AIService->>AIService: 执行AI预测
AIService-->>AnalysisService: 返回分析结果
AnalysisService->>AnalysisDB: 存储分析结果
AnalysisService-->>API: 返回分析结果
API-->>Client: 响应分析结果
```
### 3.3 风控管理流程
```mermaid
sequenceDiagram
participant Client as 前端
participant API as API网关
participant RiskService as 风控服务
participant MarketService as 市场数据服务
participant AnalysisService as 分析服务
participant AnalysisDB as 分析结果库
Client->>API: 请求风控建议
API->>RiskService: 转发请求
RiskService->>MarketService: 获取最新市场数据
MarketService-->>RiskService: 返回数据
RiskService->>AnalysisService: 获取AI分析结果
AnalysisService-->>RiskService: 返回分析结果
RiskService->>RiskService: 计算止损点位
RiskService->>RiskService: 计算仓位建议
RiskService->>RiskService: 分析换月风险
RiskService->>RiskService: 评估整体风险
RiskService->>AnalysisDB: 存储风控结果
RiskService-->>API: 返回风控建议
API-->>Client: 响应风控建议
```
### 3.4 消息推送流程
```mermaid
sequenceDiagram
participant Client as 前端
participant API as API网关
participant PushService as 推送服务
participant ExternalServices as 外部服务
participant MarketService as 市场数据服务
participant AnalysisService as 分析服务
Client->>API: 配置推送设置
API->>PushService: 存储推送配置
loop 定时检查
PushService->>MarketService: 获取最新市场数据
MarketService-->>PushService: 返回数据
PushService->>AnalysisService: 获取AI分析结果
AnalysisService-->>PushService: 返回分析结果
PushService->>PushService: 检查推送条件
alt 满足推送条件
PushService->>ExternalServices: 发送推送通知
ExternalServices-->>Client: 推送通知
end
end
```
## 4. 数据架构
### 4.1 数据库设计
#### 4.1.1 实时行情数据库 (InfluxDB)
| 测量值 | 字段 | 标签 | 说明 |
|--------|------|------|------|
| futures_price | open, high, low, close, volume, open_interest | symbol, exchange, interval | 存储K线数据 |
| market_tick | price, volume, open_interest | symbol, exchange, timestamp | 存储逐笔成交数据 |
#### 4.1.2 历史数据库 (PostgreSQL)
| 表名 | 字段 | 类型 | 说明 |
|------|------|------|------|
| futures_contracts | id, symbol, name, exchange, type, size, price_tick, margin_rate, created_at, updated_at | SERIAL, VARCHAR, VARCHAR, VARCHAR, VARCHAR, DECIMAL, DECIMAL, DECIMAL, TIMESTAMP, TIMESTAMP | 合约基本信息 |
| historical_prices | id, contract_id, timestamp, open, high, low, close, volume, open_interest | SERIAL, INTEGER, TIMESTAMP, DECIMAL, DECIMAL, DECIMAL, DECIMAL, INTEGER, INTEGER | 历史K线数据 |
| market_events | id, event_type, event_date, title, content, impact_level, created_at | SERIAL, VARCHAR, DATE, VARCHAR, TEXT, INTEGER, TIMESTAMP | 市场事件记录 |
#### 4.1.3 分析结果库 (MongoDB)
| 集合 | 字段 | 类型 | 说明 |
|------|------|------|------|
| analysis_results | _id, symbol, timestamp, technical_analysis, fundamental_analysis, sentiment_analysis, ai_prediction, risk_assessment | ObjectId, String, Date, Object, Object, Object, Object, Object | 分析结果 |
| user_watchlists | _id, user_id, symbols, created_at, updated_at | ObjectId, String, Array, Date, Date | 用户自选合约 |
| trading_signals | _id, symbol, signal_type, direction, strength, timestamp, confidence, expiration | ObjectId, String, String, String, Number, Date, Number, Date | 交易信号 |
#### 4.1.4 配置数据库 (MongoDB)
| 集合 | 字段 | 类型 | 说明 |
|------|------|------|------|
| data_sources | _id, name, type, url, api_key, priority, enabled, status, response_time | ObjectId, String, String, String, String, Number, Boolean, String, Number | 数据源配置 |
| ai_models | _id, name, type, api_key, url, parameters, accuracy, response_time, enabled | ObjectId, String, String, String, String, Object, Number, Number, Boolean | AI模型配置 |
| system_settings | _id, key, value, description, updated_at | ObjectId, String, Mixed, String, Date | 系统配置 |
| user_settings | _id, user_id, preferences, notifications, created_at, updated_at | ObjectId, String, Object, Object, Date, Date | 用户配置 |
### 4.2 数据流向
1. **数据采集**从外部行情API获取实时数据存入实时行情数据库
2. **数据处理**:实时数据经过清洗和标准化后,定期存入历史数据库
3. **数据分析**分析服务从实时和历史数据库获取数据进行技术分析和AI分析
4. **结果存储**:分析结果存入分析结果库,供前端查询和后续分析使用
5. **数据缓存**热点数据存入Redis缓存提高查询性能
6. **配置管理**:系统配置和用户配置存入配置数据库,支持动态调整
## 5. 接口设计
### 5.1 API接口规范
| 接口类型 | 路径前缀 | 认证方式 | 速率限制 |
|----------|----------|----------|----------|
| 公共接口 | /api/public | 无需认证 | 60次/分钟 |
| 用户接口 | /api/user | JWT认证 | 120次/分钟 |
| 市场接口 | /api/market | JWT认证 | 120次/分钟 |
| 分析接口 | /api/analysis | JWT认证 | 60次/分钟 |
| 风控接口 | /api/risk | JWT认证 | 60次/分钟 |
| 配置接口 | /api/config | JWT认证 | 30次/分钟 |
| 推送接口 | /api/push | JWT认证 | 30次/分钟 |
### 5.2 核心API接口
#### 5.2.1 市场数据接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取市场概览 | GET | /api/market/overview | 获取所有品种概览 | N/A | `{data: [{symbol, name, price, change, atr, adx, win_rate}]}` |
| 获取品种详情 | GET | /api/market/detail/{symbol} | 获取单个品种详细数据 | N/A | `{data: {symbol, name, price, indicators, trends, trading_advice}}` |
| 获取K线数据 | GET | /api/market/klines/{symbol} | 获取K线数据 | N/A | `{data: [{timestamp, open, high, low, close, volume}]}` |
| 获取市场热点 | GET | /api/market/hotspots | 获取市场热点 | N/A | `{data: [{symbol, name, change, volume}]}` |
| 获取风险预警 | GET | /api/market/alerts | 获取市场风险预警 | N/A | `{data: [{id, title, message, level, symbol}]}` |
#### 5.2.2 分析接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取AI分析 | GET | /api/analysis/ai/{symbol} | 获取AI分析结果 | N/A | `{data: {symbol, technical, fundamental, sentiment, prediction}}` |
| 获取多维度分析 | GET | /api/analysis/multi/{symbol} | 获取多维度分析 | N/A | `{data: {technical, capital, policy}}` |
| 获取趋势预测 | GET | /api/analysis/trend/{symbol} | 获取趋势预测 | N/A | `{data: {short_term, medium_term, long_term}}` |
| 获取胜率评估 | GET | /api/analysis/winrate/{symbol} | 获取胜率评估 | N/A | `{data: {win_rate, risk_reward, backtest_results}}` |
| 获取技术指标 | GET | /api/analysis/indicators/{symbol} | 获取技术指标 | N/A | `{data: {macd, rsi, kdj, bollinger}}` |
#### 5.2.3 风控接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取止损建议 | GET | /api/risk/stoploss/{symbol} | 获取止损建议 | N/A | `{data: {stop_loss_price, strategy, reasoning}}` |
| 获取仓位建议 | POST | /api/risk/position | 获取仓位建议 | `{capital, risk_tolerance, symbols: []}` | `{data: {positions: [{symbol, percentage, reasoning}]}}` |
| 获取换月预警 | GET | /api/risk/rollover | 获取换月预警 | N/A | `{data: [{symbol, expiration_date, days_left, recommendation}]}` |
| 获取风险评估 | GET | /api/risk/assessment/{symbol} | 获取风险评估 | N/A | `{data: {risk_level, volatility, liquidity, reasoning}}` |
| 保存风控设置 | POST | /api/risk/settings | 保存风控设置 | `{stop_loss_strategy, risk_tolerance, max_position}` | `{success: true, message: "设置保存成功"}` |
#### 5.2.4 配置接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取数据源 | GET | /api/config/datasources | 获取数据源列表 | N/A | `{data: [{id, name, status, priority, enabled}]}` |
| 保存数据源 | POST | /api/config/datasources | 保存数据源配置 | `{id, name, url, api_key, priority, enabled}` | `{success: true, message: "配置保存成功"}` |
| 获取AI模型 | GET | /api/config/ai-models | 获取AI模型列表 | N/A | `{data: [{id, name, accuracy, response_time, enabled}]}` |
| 保存AI模型 | POST | /api/config/ai-models | 保存AI模型配置 | `{id, name, url, api_key, parameters, enabled}` | `{success: true, message: "配置保存成功"}` |
| 获取系统设置 | GET | /api/config/system | 获取系统设置 | N/A | `{data: {refresh_interval, alert_threshold, backtest_days}}` |
| 保存系统设置 | POST | /api/config/system | 保存系统设置 | `{refresh_interval, alert_threshold, backtest_days}` | `{success: true, message: "设置保存成功"}` |
| 获取用户设置 | GET | /api/config/user | 获取用户设置 | N/A | `{data: {preferences, notifications}}` |
| 保存用户设置 | POST | /api/config/user | 保存用户设置 | `{preferences, notifications}` | `{success: true, message: "设置保存成功"}` |
#### 5.2.5 自选接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取自选列表 | GET | /api/watchlist | 获取用户自选列表 | N/A | `{data: [{symbol, name, price, change}]}` |
| 添加自选 | POST | /api/watchlist | 添加合约到自选 | `{symbol, name}` | `{success: true, message: "添加成功"}` |
| 删除自选 | DELETE | /api/watchlist/{symbol} | 从自选中删除合约 | N/A | `{success: true, message: "删除成功"}` |
| 检查自选状态 | GET | /api/watchlist/status/{symbol} | 检查合约是否在自选 | N/A | `{data: {is_in_watchlist: true}}` |
#### 5.2.6 推送接口
| 接口 | 方法 | 路径 | 描述 | 请求体 | 响应体 |
|------|------|------|------|--------|--------|
| 获取推送设置 | GET | /api/push/settings/{symbol} | 获取推送设置 | N/A | `{data: {methods, timing, content}}` |
| 保存推送设置 | POST | /api/push/settings/{symbol} | 保存推送设置 | `{methods, timing, content, price_level}` | `{success: true, message: "设置保存成功"}` |
| 测试推送 | POST | /api/push/test | 测试推送 | `{method, content}` | `{success: true, message: "测试推送成功"}` |
| 获取推送历史 | GET | /api/push/history | 获取推送历史 | N/A | `{data: [{id, timestamp, method, content, status}]}` |
## 6. 部署架构
### 6.1 开发环境
| 服务 | 版本 | 端口 | 配置 |
|------|------|------|------|
| Node.js | 18.x | 3000 | 开发服务器 |
| MongoDB | 6.x | 27017 | 分析结果和配置存储 |
| PostgreSQL | 15.x | 5432 | 历史数据存储 |
| Redis | 7.x | 6379 | 缓存 |
| InfluxDB | 2.x | 8086 | 实时行情数据 |
| Python | 3.10+ | 8000 | AI服务 |
### 6.2 生产环境
| 服务 | 版本 | 配置 | 部署方式 |
|------|------|------|----------|
| API网关 | Nginx | 负载均衡 | Kubernetes |
| 后端服务 | Node.js | 多实例 | Kubernetes |
| AI服务 | Python | GPU支持 | Kubernetes |
| 数据库 | MongoDB/PostgreSQL/Redis/InfluxDB | 高可用集群 | Kubernetes |
| 监控 | Prometheus/Grafana | 实时监控 | Kubernetes |
| 日志 | ELK Stack | 集中式日志 | Kubernetes |
### 6.3 CI/CD流程
| 阶段 | 工具 | 操作 |
|------|------|------|
| 代码提交 | Git | 代码提交到仓库 |
| 代码检查 | ESLint/Prettier | 代码风格检查 |
| 测试 | Jest/Mocha | 单元测试和集成测试 |
| 构建 | Docker | 构建容器镜像 |
| 部署 | Kubernetes | 部署到测试环境 |
| 验证 | Cypress | 端到端测试 |
| 发布 | Kubernetes | 部署到生产环境 |
## 7. 编码指导文档
### 7.1 项目结构
```
/
├── frontend/ # 前端代码
│ ├── public/ # 静态资源
│ ├── src/ # 源代码
│ │ ├── components/ # 通用组件
│ │ │ ├── layout/ # 布局组件
│ │ │ ├── charts/ # 图表组件
│ │ │ ├── forms/ # 表单组件
│ │ │ └── common/ # 通用UI组件
│ │ ├── pages/ # 页面组件
│ │ │ ├── dashboard/ # 主页
│ │ │ ├── detail/ # 详情分析页
│ │ │ ├── risk/ # 风控管理页
│ │ │ ├── config/ # 配置管理页
│ │ │ └── watchlist/ # 自选页面
│ │ ├── services/ # API服务
│ │ ├── store/ # Redux状态管理
│ │ ├── utils/ # 工具函数
│ │ ├── constants/ # 常量定义
│ │ ├── hooks/ # 自定义Hooks
│ │ ├── types/ # TypeScript类型定义
│ │ ├── App.tsx # 应用根组件
│ │ └── main.tsx # 应用入口
│ ├── package.json # 依赖配置
│ ├── tsconfig.json # TypeScript配置
│ └── vite.config.ts # Vite配置
├── backend/ # 后端代码
│ ├── src/ # 源代码
│ │ ├── api/ # API路由
│ │ ├── services/ # 业务逻辑服务
│ │ ├── models/ # 数据模型
│ │ ├── middleware/ # 中间件
│ │ ├── config/ # 配置
│ │ ├── utils/ # 工具函数
│ │ ├── types/ # TypeScript类型定义
│ │ └── app.ts # 应用入口
│ ├── package.json # 依赖配置
│ ├── tsconfig.json # TypeScript配置
│ └── nodemon.json # 开发服务器配置
├── ai/ # AI服务代码
│ ├── src/ # 源代码
│ ├── requirements.txt # Python依赖
│ └── Dockerfile # Docker配置
├── shared/ # 共享代码
│ ├── types/ # 共享类型定义
│ └── utils/ # 共享工具函数
├── config/ # 配置文件
├── docs/ # 文档
├── scripts/ # 脚本文件
└── docker-compose.yml # Docker Compose配置
```
### 7.2 编码规范
#### 7.2.1 前端编码规范
- **代码风格**使用ESLint + Prettier保持代码风格一致
- **命名规范**
- 组件名大驼峰命名法PascalCase
- 变量名小驼峰命名法camelCase
- 常量名全大写SNAKE_CASE
- 文件名:组件文件使用大驼峰,其他文件使用小驼峰
- **注释规范**
- 组件JSDoc注释包含参数和返回值
- 函数:关键函数添加注释
- 复杂逻辑:添加 inline 注释
- **组件设计**
- 单一职责原则
- 可复用组件提取
- 状态管理合理使用
- 性能优化考虑
#### 7.2.2 后端编码规范
- **代码风格**使用ESLint + Prettier保持代码风格一致
- **命名规范**
- 类名大驼峰命名法PascalCase
- 方法名小驼峰命名法camelCase
- 变量名小驼峰命名法camelCase
- 常量名全大写SNAKE_CASE
- 文件名:小驼峰命名法
- **注释规范**
- 类JSDoc注释包含类的用途
- 方法JSDoc注释包含参数、返回值和异常
- 复杂逻辑:添加 inline 注释
- **API设计**
- RESTful API设计规范
- 统一的错误处理
- 合理的状态码使用
- 详细的API文档
### 7.3 实现指南
#### 7.3.1 前端实现步骤
1. **项目初始化**
- 使用Vite创建React项目
- 配置TypeScript
- 安装Ant Design和其他依赖
2. **核心组件开发**
- 实现布局组件Header, Sider, Content
- 开发图表组件K线图, 热力图, 趋势图)
- 实现表单组件(配置表单, 风控设置表单)
- 开发通用UI组件品种卡片, 风险预警, 数据表格)
3. **页面开发**
- 实现Dashboard主页
- 开发详情分析页
- 实现风控管理页
- 开发配置管理页
- 实现自选页面
4. **状态管理**
- 配置Redux Toolkit
- 创建数据切片market, analysis, risk, config, watchlist
- 实现异步ThunkAPI调用
- 配置中间件logger, error handling
5. **API服务**
- 实现API客户端
- 配置请求拦截器(认证, 错误处理)
- 实现数据缓存策略
- 开发实时数据订阅
6. **性能优化**
- 组件懒加载
- 数据缓存
- 图表性能优化
- 代码分割
#### 7.3.2 后端实现步骤
1. **项目初始化**
- 初始化Node.js项目
- 配置TypeScript
- 安装Express和其他依赖
2. **核心服务开发**
- 实现市场数据服务
- 开发分析服务
- 实现风控服务
- 开发配置服务
- 实现自选服务
- 开发推送服务
3. **API路由**
- 配置Express路由
- 实现API网关
- 配置中间件(认证, 速率限制, 错误处理)
- 开发API文档
4. **数据库集成**
- 配置MongoDB连接
- 实现PostgreSQL集成
- 配置Redis缓存
- 实现InfluxDB连接
5. **AI服务集成**
- 开发AI服务客户端
- 实现模型调用
- 配置模型参数
- 开发分析算法
6. **外部服务集成**
- 实现行情API调用
- 开发新闻API集成
- 配置推送服务
- 实现数据采集
### 7.4 测试策略
#### 7.4.1 前端测试
- **单元测试**
- 工具Jest + React Testing Library
- 测试范围:组件功能, 状态管理, 工具函数
- **集成测试**
- 工具React Testing Library + MSW
- 测试范围:组件交互, API调用, 状态流转
- **端到端测试**
- 工具Cypress
- 测试范围:完整用户流程, 页面导航, 表单提交
#### 7.4.2 后端测试
- **单元测试**
- 工具Mocha + Chai
- 测试范围:服务逻辑, 工具函数, 数据处理
- **集成测试**
- 工具Supertest
- 测试范围API接口, 数据库操作, 服务集成
- **性能测试**
- 工具Artillery
- 测试范围API响应时间, 并发处理能力
### 7.5 性能优化
#### 7.5.1 前端性能优化
- **代码优化**
- 代码分割和懒加载
- 减少不必要的重渲染
- 使用React.memo和useMemo
- 优化状态管理
- **资源优化**
- 图片优化和懒加载
- 字体优化
- 第三方库按需加载
- 代码压缩和tree shaking
- **数据优化**
- 数据缓存策略
- 分页和虚拟滚动
- 批量API请求
- 实时数据订阅优化
- **图表优化**
- 大数据量图表使用虚拟滚动
- 图表按需渲染
- 减少图表重绘
- 使用WebWorker处理复杂计算
#### 7.5.2 后端性能优化
- **API优化**
- 响应压缩
- 请求限流
- 批量操作
- 缓存策略
- **数据库优化**
- 索引优化
- 查询优化
- 连接池配置
- 读写分离
- **服务优化**
- 异步处理
- 负载均衡
- 微服务拆分
- 缓存策略
- **AI服务优化**
- 模型缓存
- 批处理请求
- GPU加速
- 模型量化
### 7.6 安全实践
#### 7.6.1 前端安全
- **认证与授权**
- 使用JWT认证
- 实现路由守卫
- 权限控制
- **输入验证**
- 客户端表单验证
- 防止XSS攻击
- 防止CSRF攻击
- **数据保护**
- 敏感数据加密
- 安全的本地存储
- 防止数据泄露
- **网络安全**
- HTTPS使用
- CORS配置
- 安全的API调用
#### 7.6.2 后端安全
- **认证与授权**
- JWT认证
- 基于角色的访问控制
- 密码哈希存储
- **输入验证**
- 服务端参数校验
- 防止SQL注入
- 防止NoSQL注入
- **数据保护**
- 敏感数据加密
- 安全的数据库操作
- 防止数据泄露
- **网络安全**
- HTTPS使用
- CORS配置
- 安全的API设计
- 速率限制和防DDoS
## 8. 结论
本架构设计方案提供了AI期货分析系统的完整技术架构包括前端、后端、AI服务和数据架构的详细设计。方案基于现代技术栈采用微服务架构支持高并发、实时数据处理和AI分析满足系统的性能和可扩展性要求。
前端采用React + Ant Design技术栈实现专业的金融界面和丰富的数据可视化功能。后端采用Node.js + Express + MongoDB/PostgreSQL/Redis技术栈提供高性能的API服务和数据处理能力。AI服务采用Python + DeepSeek技术栈实现智能分析和预测功能。
方案详细设计了数据库结构、API接口、核心流程和部署架构为开发团队提供了明确的技术实现指南。同时方案还包含了详细的编码规范、实现步骤、测试策略和性能优化建议确保系统的质量和可维护性。
通过本架构设计方案开发团队可以快速启动AI期货分析系统的开发实现一个功能完整、性能优异、安全可靠的智能期货分析系统为期货投资者提供专业的决策辅助工具。

@ -62,3 +62,13 @@ h2 {
margin-bottom: 16px;
}
}
/* 加载容器样式 */
.loading-container {
display: flex;
justify-content: center;
align-items: center;
height: 400px;
font-size: 18px;
color: #1890ff;
}

@ -1,13 +1,14 @@
import React from 'react';
import React, { Suspense, lazy } from 'react';
import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
import { Provider } from 'react-redux';
import store from './store';
import MainLayout from './components/layout/MainLayout';
import Dashboard from './pages/dashboard/Dashboard';
import Detail from './pages/detail/Detail';
import RiskControl from './pages/risk-control/RiskControl';
import Config from './pages/config/Config';
import Watchlist from './pages/watchlist/Watchlist';
// 使
const Dashboard = lazy(() => import('./pages/dashboard/Dashboard'));
const Detail = lazy(() => import('./pages/detail/Detail'));
const RiskControl = lazy(() => import('./pages/risk-control/RiskControl'));
const Config = lazy(() => import('./pages/config/Config'));
const Watchlist = lazy(() => import('./pages/watchlist/Watchlist'));
import './App.css';
function App() {
@ -15,13 +16,15 @@ function App() {
<Provider store={store}>
<Router>
<MainLayout>
<Routes>
<Route path="/" element={<Dashboard />} />
<Route path="/watchlist" element={<Watchlist />} />
<Route path="/detail/:code" element={<Detail />} />
<Route path="/risk-control" element={<RiskControl />} />
<Route path="/config" element={<Config />} />
</Routes>
<Suspense fallback={<div className="loading-container">加载中...</div>}>
<Routes>
<Route path="/" element={<Dashboard />} />
<Route path="/watchlist" element={<Watchlist />} />
<Route path="/detail/:code" element={<Detail />} />
<Route path="/risk-control" element={<RiskControl />} />
<Route path="/config" element={<Config />} />
</Routes>
</Suspense>
</MainLayout>
</Router>
</Provider>

@ -42,11 +42,12 @@
.kline-chart {
width: 100%;
height: 400px;
background-color: #fafafa;
border-radius: 4px;
display: flex;
justify-content: center;
align-items: center;
}
.chart-container {
width: 100%;
height: 100%;
}
.chart-placeholder {

@ -1,8 +1,9 @@
import React, { useState, useEffect } from 'react';
import React, { useState, useEffect, useRef } from 'react';
import { Card, Button, Row, Col, Select, Tabs, Tag, Statistic, Alert, Spin } from 'antd';
import { useParams, useNavigate } from 'react-router-dom';
import { LineChartOutlined, BarChartOutlined, AreaChartOutlined, ArrowUpOutlined, AlertOutlined, RobotOutlined, SafetyOutlined } from '@ant-design/icons';
import { generateFutureData } from '../../utils/mockData';
import { generateFutureData, generateKlineData } from '../../utils/mockData';
import { createChart } from 'lightweight-charts';
import './Detail.css';
const { Option } = Select;
@ -15,6 +16,8 @@ const Detail = () => {
const [loading, setLoading] = useState(true);
const [currentPeriod, setCurrentPeriod] = useState('1H');
const [currentIndicator, setCurrentIndicator] = useState('MA');
const chartRef = useRef(null);
const chartInstance = useRef(null);
console.log('Detail page loaded with code:', code);
@ -27,6 +30,125 @@ const Detail = () => {
}, 500);
}, [code]);
// K线
useEffect(() => {
if (!data || !chartRef.current) return;
//
if (chartInstance.current) {
chartInstance.current.destroy();
}
// APIK线
const fetchKlineData = async () => {
try {
const response = await fetch(`http://localhost:3002/api/market/klines/${code}?period=${currentPeriod}`);
if (!response.ok) {
throw new Error('获取K线数据失败');
}
const result = await response.json();
return result.data;
} catch (error) {
console.error('获取K线数据失败:', error);
// 使
return generateKlineData(30);
}
};
fetchKlineData().then(klineData => {
//
const chart = createChart(chartRef.current, {
width: chartRef.current.clientWidth,
height: 400,
timeScale: {
timeVisible: true,
secondsVisible: false,
},
grid: {
vertLines: {
color: 'rgba(42, 46, 57, 0.1)',
},
horzLines: {
color: 'rgba(42, 46, 57, 0.1)',
},
},
});
// K线
const candlestickSeries = chart.addCandlestickSeries({
upColor: '#52c41a',
downColor: '#ff4d4f',
borderVisible: false,
wickUpColor: '#52c41a',
wickDownColor: '#ff4d4f',
});
// K线
candlestickSeries.setData(klineData.map(item => ({
time: new Date(item.time * 1000).toISOString().split('T')[0],
open: item.open,
high: item.high,
low: item.low,
close: item.close,
})));
//
if (currentIndicator === 'MA') {
// MA5
const ma5Series = chart.addLineSeries({
color: '#1890ff',
lineWidth: 1,
});
// MA5
const ma5Data = [];
for (let i = 4; i < klineData.length; i++) {
const sum = klineData.slice(i - 4, i + 1).reduce((acc, item) => acc + item.close, 0);
ma5Data.push({
time: new Date(klineData[i].time * 1000).toISOString().split('T')[0],
value: sum / 5,
});
}
ma5Series.setData(ma5Data);
// MA10
const ma10Series = chart.addLineSeries({
color: '#faad14',
lineWidth: 1,
});
// MA10
const ma10Data = [];
for (let i = 9; i < klineData.length; i++) {
const sum = klineData.slice(i - 9, i + 1).reduce((acc, item) => acc + item.close, 0);
ma10Data.push({
time: new Date(klineData[i].time * 1000).toISOString().split('T')[0],
value: sum / 10,
});
}
ma10Series.setData(ma10Data);
}
//
chartInstance.current = chart;
//
const handleResize = () => {
if (chartInstance.current) {
chartInstance.current.resize(chartRef.current.clientWidth, 400);
}
};
window.addEventListener('resize', handleResize);
//
return () => {
window.removeEventListener('resize', handleResize);
if (chartInstance.current) {
chartInstance.current.destroy();
}
};
});
}, [data, currentPeriod, currentIndicator, code]);
const handleBack = () => {
navigate('/');
};
@ -124,12 +246,8 @@ const Detail = () => {
</div>
</div>
<div className="kline-chart">
{/* 这里将集成TradingView Lightweight Charts */}
<div className="chart-placeholder">
<LineChartOutlined style={{ fontSize: 48, color: '#1890ff', marginBottom: 16 }} />
<p>K线图表区域</p>
<p>周期: {currentPeriod} | 指标: {currentIndicator}</p>
</div>
{/* TradingView Lightweight Charts */}
<div ref={chartRef} className="chart-container"></div>
</div>
</Card>

@ -1,43 +1,58 @@
import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
import { generateFuturesOverview, generateFutureData, riskAlerts, aiMarketAnalysis } from '../utils/mockData';
// 模拟异步获取期货概览数据
// 后端API基础URL
const API_BASE_URL = 'http://localhost:3005/api';
// 异步获取期货概览数据
export const fetchFuturesOverview = createAsyncThunk(
'futures/fetchOverview',
async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 500));
return generateFuturesOverview();
const response = await fetch(`${API_BASE_URL}/market/overview`);
if (!response.ok) {
throw new Error('获取市场概览失败');
}
const data = await response.json();
return data.data;
}
);
// 模拟异步获取单个期货详情
// 异步获取单个期货详情
export const fetchFutureDetail = createAsyncThunk(
'futures/fetchDetail',
async ({ code, name }) => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 500));
return generateFutureData(code, name);
const response = await fetch(`${API_BASE_URL}/market/detail/${code}`);
if (!response.ok) {
throw new Error('获取品种详情失败');
}
const data = await response.json();
return data.data;
}
);
// 模拟异步获取风险预警
// 异步获取风险预警
export const fetchRiskAlerts = createAsyncThunk(
'futures/fetchRiskAlerts',
async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 300));
return riskAlerts;
const response = await fetch(`${API_BASE_URL}/market/alerts`);
if (!response.ok) {
throw new Error('获取风险预警失败');
}
const data = await response.json();
return data.data;
}
);
// 模拟异步获取AI市场分析
// 异步获取AI市场分析
export const fetchAIMarketAnalysis = createAsyncThunk(
'futures/fetchAIMarketAnalysis',
async () => {
// 模拟API请求延迟
await new Promise(resolve => setTimeout(resolve, 400));
return aiMarketAnalysis;
// 由于后端没有专门的市场分析接口,我们使用模拟数据
return {
overallTrend: '震荡偏弱',
keyFactors: ['原油价格波动', '宏观经济数据', '政策面变化'],
recommendations: ['控制仓位', '关注原油走势', '做好止损'],
confidence: 75
};
}
);

Loading…
Cancel
Save