量化平台中的 DSL 设计与实现：从规则树到可执行策略
量化平台的核心挑战之一是如何让非程序员也能创建和修改交易策略。DSL（Domain Specific Language，领域特定语言）是解决这个问题的关键技术。
结论先行：EasyQuant 采用 JSON 格式的 DSL 来描述交易策略，通过规则树（Rule Tree）的方式组织策略逻辑，最终编译成 ta4j 的可执行策略对象，实现了可视化编辑、版本管理、可解释性和高性能的平衡。
一、为什么需要 DSL？
1）传统代码方式的痛点
// 传统 Java 代码策略
public class MyStrategy {
public Strategy buildStrategy() {
SMAIndicator sma20 = new SMAIndicator(closePrice, 20);
SMAIndicator sma5 = new SMAIndicator(closePrice, 5);
Rule entryRule = new CrossedUpRule(sma5, sma20);
Rule exitRule = new CrossedDownRule(sma5, sma20);
return new BaseStrategy(entryRule, exitRule);
}
}
痛点：
- 需要编程知识，门槛高
- 难以可视化展示
- 难以版本管理和回溯
- 难以解释和调试
2）可视化 DSL 的优势
{
"entry": {
"type": "CROSS_UP",
"left": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 5 }
},
"right": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 20 }
}
},
"exit": {
"type": "CROSS_DOWN",
"left": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 5 }
},
"right": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 20 }
}
}
}
优势：
- 可视化编辑，降低门槛
- JSON 格式，易于存储和传输
- 版本管理，支持回溯
- 结构化，易于解释和调试
二、DSL 规则树设计
1）基本节点类型
// types/dsl.ts
// 规则节点基类
export interface RuleNode {
type: string
children?: RuleNode[]
params?: Record<string, unknown>
}
// 逻辑组合节点
export interface AndNode extends RuleNode {
type: 'AND'
children: RuleNode[]
}
export interface OrNode extends RuleNode {
type: 'OR'
children: RuleNode[]
}
export interface NotNode extends RuleNode {
type: 'NOT'
child: RuleNode
}
// 比较节点
export interface GtNode extends RuleNode {
type: 'GT'
left: ValueNode
right: ValueNode
}
export interface LtNode extends RuleNode {
type: 'LT'
left: ValueNode
right: ValueNode
}
export interface EqNode extends RuleNode {
type: 'EQ'
left: ValueNode
right: ValueNode
}
// 交叉节点
export interface CrossUpNode extends RuleNode {
type: 'CROSS_UP'
left: ValueNode
right: ValueNode
}
export interface CrossDownNode extends RuleNode {
type: 'CROSS_DOWN'
left: ValueNode
right: ValueNode
}
// 值节点
export interface IndicatorNode extends RuleNode {
type: 'IND'
indicator: string
params: Record<string, number | string>
}
export interface ConstantNode extends RuleNode {
type: 'CONST'
value: number
}
export interface RefNode extends RuleNode {
type: 'REF'
param: string
}
export type ValueNode = IndicatorNode | ConstantNode | RefNode
export type LogicNode = AndNode | OrNode | NotNode
export type CompareNode = GtNode | LtNode | EqNode
export type CrossNode = CrossUpNode | CrossDownNode
export type RuleNodeType = LogicNode | CompareNode | CrossNode
2）策略 DSL 结构
// types/strategy.ts
export interface StrategyDSL {
name: string
description: string
symbols: string[]
timeframe: string
// 入场规则
entry: RuleNode
// 出场规则
exit: RuleNode
// 止损规则（可选）
stopLoss?: RuleNode
// 止盈规则（可选）
takeProfit?: RuleNode
// 参数定义
params: Record<string, unknown>
// 指标定义
indicators: IndicatorConfig[]
}
export interface IndicatorConfig {
name: string
type: string
params: Record<string, number | string>
}
3）示例：均线金叉策略
{
"name": "均线金叉策略",
"description": "5日均线金叉20日均线买入，死叉卖出",
"symbols": ["AAPL", "MSFT", "GOOGL"],
"timeframe": "1m",
"entry": {
"type": "CROSS_UP",
"left": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 5 }
},
"right": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 20 }
}
},
"exit": {
"type": "CROSS_DOWN",
"left": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 5 }
},
"right": {
"type": "IND",
"indicator": "SMA",
"params": { "period": 20 }
}
},
"params": {
"fastPeriod": 5,
"slowPeriod": 20
},
"indicators": [
{
"name": "SMA5",
"type": "SMA",
"params": { "period": 5 }
},
{
"name": "SMA20",
"type": "SMA",
"params": { "period": 20 }
}
]
}
三、DSL 编译器实现
1）编译器架构
// compiler/StrategyCompiler.java
@Component
public class StrategyCompiler {
private final IndicatorFactory indicatorFactory;
private final RuleFactory ruleFactory;
/**
* 编译 DSL 到 ta4j Strategy
*/
public Strategy compile(StrategyDSL dsl, BarSeries series) {
// 1. 构建指标图
Map<String, Indicator<Num>> indicators = buildIndicators(dsl, series);
// 2. 编译入场规则
Rule entryRule = compileRule(dsl.getEntry(), indicators);
// 3. 编译出场规则
Rule exitRule = compileRule(dsl.getExit(), indicators);
// 4. 构建策略
return new BaseStrategy(entryRule, exitRule);
}
/**
* 构建指标图
*/
private Map<String, Indicator<Num>> buildIndicators(
StrategyDSL dsl,
BarSeries series
) {
Map<String, Indicator<Num>> indicators = new HashMap<>();
// 构建预定义指标
for (IndicatorConfig config : dsl.getIndicators()) {
Indicator<Num> indicator = indicatorFactory.create(
config.getType(),
series,
config.getParams()
);
indicators.put(config.getName(), indicator);
}
// 构建规则中引用的指标
buildRuleIndicators(dsl.getEntry(), indicators, series);
buildRuleIndicators(dsl.getExit(), indicators, series);
return indicators;
}
/**
* 编译规则
*/
private Rule compileRule(
RuleNode node,
Map<String, Indicator<Num>> indicators
) {
return switch (node.getType()) {
case "AND" -> compileAndRule((AndNode) node, indicators);
case "OR" -> compileOrRule((OrNode) node, indicators);
case "NOT" -> compileNotRule((NotNode) node, indicators);
case "GT" -> compileGtRule((GtNode) node, indicators);
case "LT" -> compileLtRule((LtNode) node, indicators);
case "EQ" -> compileEqRule((EqNode) node, indicators);
case "CROSS_UP" -> compileCrossUpRule((CrossUpNode) node, indicators);
case "CROSS_DOWN" -> compileCrossDownRule((CrossDownNode) node, indicators);
default -> throw new IllegalArgumentException("Unknown rule type: " + node.getType());
};
}
private Rule compileAndRule(AndNode node, Map<String, Indicator<Num>> indicators) {
List<Rule> rules = node.getChildren().stream()
.map(child -> compileRule(child, indicators))
.toList();
return new AndRule(rules.toArray(new Rule[0]));
}
private Rule compileOrRule(OrNode node, Map<String, Indicator<Num>> indicators) {
List<Rule> rules = node.getChildren().stream()
.map(child -> compileRule(child, indicators))
.toList();
return new OrRule(rules.toArray(new Rule[0]));
}
private Rule compileNotRule(NotNode node, Map<String, Indicator<Num>> indicators) {
Rule rule = compileRule(node.getChild(), indicators);
return new NotRule(rule);
}
private Rule compileCrossUpRule(CrossUpNode node, Map<String, Indicator<Num>> indicators) {
Indicator<Num> left = compileValue(node.getLeft(), indicators);
Indicator<Num> right = compileValue(node.getRight(), indicators);
return new CrossedUpRule(left, right);
}
private Indicator<Num> compileValue(ValueNode node, Map<String, Indicator<Num>> indicators) {
return switch (node.getType()) {
case "IND" -> compileIndicator((IndicatorNode) node, indicators);
case "CONST" -> compileConstant((ConstantNode) node);
case "REF" -> compileRef((RefNode) node, indicators);
default -> throw new IllegalArgumentException("Unknown value type: " + node.getType());
};
}
private Indicator<Num> compileIndicator(IndicatorNode node, Map<String, Indicator<Num>> indicators) {
String indicatorName = node.getIndicator();
Map<String, Object> params = node.getParams();
return indicatorFactory.create(indicatorName, params);
}
private Indicator<Num> compileConstant(ConstantNode node) {
return new ConstantIndicator(node.getValue());
}
private Indicator<Num> compileRef(RefNode node, Map<String, Indicator<Num>> indicators) {
String paramName = node.getParam();
return indicators.get(paramName);
}
}
2）指标工厂
// factory/IndicatorFactory.java
@Component
public class IndicatorFactory {
private final BarSeries series;
public Indicator<Num> create(String type, Map<String, Object> params) {
return switch (type) {
case "SMA" -> createSMA(params);
case "EMA" -> createEMA(params);
case "RSI" -> createRSI(params);
case "MACD" -> createMACD(params);
case "BOLL" -> createBOLL(params);
case "ATR" -> createATR(params);
case "CCI" -> createCCI(params);
case "STOCH" -> createSTOCH(params);
default -> throw new IllegalArgumentException("Unknown indicator type: " + type);
};
}
private Indicator<Num> createSMA(Map<String, Object> params) {
int period = (int) params.get("period");
ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
return new SMAIndicator(closePrice, period);
}
private Indicator<Num> createEMA(Map<String, Object> params) {
int period = (int) params.get("period");
ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
return new EMAIndicator(closePrice, period);
}
private Indicator<Num> createRSI(Map<String, Object> params) {
int period = (int) params.get("period");
ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
return new RSIIndicator(closePrice, period);
}
private Indicator<Num> createMACD(Map<String, Object> params) {
int shortPeriod = (int) params.getOrDefault("shortPeriod", 12);
int longPeriod = (int) params.getOrDefault("longPeriod", 26);
int signalPeriod = (int) params.getOrDefault("signalPeriod", 9);
ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
return new MACDIndicator(closePrice, shortPeriod, longPeriod, signalPeriod);
}
private Indicator<Num> createBOLL(Map<String, Object> params) {
int period = (int) params.get("period");
double multiplier = (double) params.getOrDefault("multiplier", 2.0);
ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
SMAIndicator sma = new SMAIndicator(closePrice, period);
StandardDeviationIndicator stdDev = new StandardDeviationIndicator(closePrice, period);
return new BollingerBandsMiddleIndicator(sma, stdDev, multiplier);
}
private Indicator<Num> createATR(Map<String, Object> params) {
int period = (int) params.get("period");
return new ATRIndicator(series, period);
}
private Indicator<Num> createCCI(Map<String, Object> params) {
int period = (int) params.get("period");
return new CCIIndicator(series, period);
}
private Indicator<Num> createSTOCH(Map<String, Object> params) {
int kPeriod = (int) params.getOrDefault("kPeriod", 14);
int dPeriod = (int) params.getOrDefault("dPeriod", 3);
return new StochasticOscillatorKIndicator(series, kPeriod);
}
}
四、DSL 可视化编辑器
1）前端组件设计
<template>
<div class="strategy-editor">
<div class="editor-header">
<el-input v-model="strategy.name" placeholder="策略名称" />
<el-input v-model="strategy.description" placeholder="策略描述" />
</div>
<div class="editor-body">
<div class="rule-section">
<h3>入场规则</h3>
<RuleTreeEditor
v-model="strategy.entry"
:indicators="strategy.indicators"
/>
</div>
<div class="rule-section">
<h3>出场规则</h3>
<RuleTreeEditor
v-model="strategy.exit"
:indicators="strategy.indicators"
/>
</div>
<div class="indicator-section">
<h3>指标配置</h3>
<IndicatorConfig
v-model="strategy.indicators"
/>
</div>
</div>
<div class="editor-footer">
<el-button @click="saveStrategy">保存策略</el-button>
<el-button @click="testStrategy">测试策略</el-button>
</div>
</div>
</template>
<script setup lang="ts">
import { ref } from 'vue'
import type { StrategyDSL } from '@/types/strategy'
const strategy = ref<StrategyDSL>({
name: '',
description: '',
symbols: [],
timeframe: '1m',
entry: {
type: 'AND',
children: []
},
exit: {
type: 'AND',
children: []
},
params: {},
indicators: []
})
const saveStrategy = async () => {
await http.post('/api/strategies', strategy.value)
}
const testStrategy = async () => {
await http.post('/api/strategies/test', strategy.value)
}
</script>
2）规则树编辑器组件
<template>
<div class="rule-tree-editor">
<div class="rule-node" :class="node.type">
<div class="node-header">
<el-select v-model="node.type" @change="onTypeChange">
<el-option label="AND" value="AND" />
<el-option label="OR" value="OR" />
<el-option label="NOT" value="NOT" />
<el-option label="GT" value="GT" />
<el-option label="LT" value="LT" />
<el-option label="CROSS_UP" value="CROSS_UP" />
<el-option label="CROSS_DOWN" value="CROSS_DOWN" />
</el-select>
<el-button @click="removeNode" type="danger" size="small">删除</el-button>
</div>
<div class="node-body">
<template v-if="isLogicNode">
<RuleTreeEditor
v-for="(child, index) in node.children"
:key="index"
v-model="node.children[index]"
:indicators="indicators"
/>
<el-button @click="addChild" type="primary" size="small">添加子节点</el-button>
</template>
<template v-else-if="isCompareNode || isCrossNode">
<div class="value-editor">
<ValueEditor
v-model="node.left"
:indicators="indicators"
/>
<span>{{ operatorSymbol }}</span>
<ValueEditor
v-model="node.right"
:indicators="indicators"
/>
</div>
</template>
</div>
</div>
</div>
</template>
<script setup lang="ts">
import { computed } from 'vue'
import type { RuleNode, LogicNode, CompareNode, CrossNode } from '@/types/dsl'
const props = defineProps<{
modelValue: RuleNode
indicators: IndicatorConfig[]
}>()
const emit = defineEmits<{
'update:modelValue': [value: RuleNode]
}>()
const node = computed({
get: () => props.modelValue,
set: (value) => emit('update:modelValue', value)
})
const isLogicNode = computed(() =>
['AND', 'OR', 'NOT'].includes(node.value.type)
)
const isCompareNode = computed(() =>
['GT', 'LT', 'EQ'].includes(node.value.type)
)
const isCrossNode = computed(() =>
['CROSS_UP', 'CROSS_DOWN'].includes(node.value.type)
)
const operatorSymbol = computed(() => {
const symbols: Record<string, string> = {
GT: '>',
LT: '<',
EQ: '=',
CROSS_UP: '↑',
CROSS_DOWN: '↓'
}
return symbols[node.value.type] || ''
})
const onTypeChange = () => {
// 根据类型初始化节点结构
if (isLogicNode.value) {
node.value.children = node.value.children || []
} else if (isCompareNode.value || isCrossNode.value) {
node.value.left = { type: 'IND', indicator: 'SMA', params: { period: 5 } }
node.value.right = { type: 'IND', indicator: 'SMA', params: { period: 20 } }
}
}
const addChild = () => {
if (!node.value.children) {
node.value.children = []
}
node.value.children.push({
type: 'GT',
left: { type: 'IND', indicator: 'SMA', params: { period: 5 } },
right: { type: 'IND', indicator: 'SMA', params: { period: 20 } }
})
}
const removeNode = () => {
emit('update:modelValue', null)
}
</script>
五、DSL 可解释性实现
1）规则评估追踪
// engine/RuleEvaluator.java
@Component
public class RuleEvaluator {
private final RuleCompiler compiler;
private final EventPublisher eventPublisher;
/**
* 评估规则并记录评估结果
*/
public EvaluationResult evaluate(
RuleNode node,
Map<String, Indicator<Num>> indicators,
int index
) {
EvaluationResult result = new EvaluationResult();
result.setNodeType(node.getType());
result.setIndex(index);
try {
Rule rule = compiler.compileRule(node, indicators);
boolean satisfied = rule.isSatisfied(index);
result.setSatisfied(satisfied);
result.setSuccess(true);
// 发布评估事件
eventPublisher.publishEvent(new RuleEvaluatedEvent(
node.getType(),
index,
satisfied
));
} catch (Exception e) {
result.setSuccess(false);
result.setError(e.getMessage());
// 发布错误事件
eventPublisher.publishEvent(new RuleEvaluatedErrorEvent(
node.getType(),
index,
e.getMessage()
));
}
return result;
}
/**
* 评估整个策略并生成解释
*/
public StrategyExplanation explain(
StrategyDSL dsl,
BarSeries series,
int index
) {
StrategyExplanation explanation = new StrategyExplanation();
// 构建指标
Map<String, Indicator<Num>> indicators = compiler.buildIndicators(dsl, series);
// 评估入场规则
EvaluationResult entryResult = evaluate(dsl.getEntry(), indicators, index);
explanation.setEntryResult(entryResult);
// 评估出场规则
EvaluationResult exitResult = evaluate(dsl.getExit(), indicators, index);
explanation.setExitResult(exitResult);
// 生成解释文本
explanation.setExplanation(generateExplanation(dsl, entryResult, exitResult));
return explanation;
}
private String generateExplanation(
StrategyDSL dsl,
EvaluationResult entryResult,
EvaluationResult exitResult
) {
StringBuilder sb = new StringBuilder();
sb.append("策略: ").append(dsl.getName()).append("\n");
sb.append("入场规则: ").append(entryResult.isSatisfied() ? "满足" : "不满足").append("\n");
sb.append("出场规则: ").append(exitResult.isSatisfied() ? "满足" : "不满足").append("\n");
if (!entryResult.isSuccess()) {
sb.append("入场规则错误: ").append(entryResult.getError()).append("\n");
}
if (!exitResult.isSuccess()) {
sb.append("出场规则错误: ").append(exitResult.getError()).append("\n");
}
return sb.toString();
}
}
2）阻塞原因分类
// domain/BlockingReasonCode.java
public enum BlockingReasonCode {
// 数据相关
NO_SYMBOLS("无交易标的"),
NO_BARS("无K线数据"),
BARS_NOT_FRESH("K线数据不新鲜"),
// 策略相关
STRATEGY_NOT_ACTIVE("策略未激活"),
SIGNAL_NONE("无交易信号"),
ENGINE_ERROR("引擎错误"),
// 风控相关
RISK_REJECTED("风控拒绝"),
VOLUME_TOO_LARGE("交易量过大"),
INSUFFICIENT_FUNDS("资金不足"),
// 执行相关
BROKER_REJECTED("通道拒绝"),
NETWORK_ERROR("网络错误"),
TIMEOUT("超时");
private final String description;
BlockingReasonCode(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
}
六、DSL 扩展机制
1）自定义指标扩展
// extension/CustomIndicatorExtension.java
public interface CustomIndicatorExtension {
String getName();
Indicator<Num> create(BarSeries series, Map<String, Object> params);
Map<String, Object> getParamSchema();
}
// 示例：自定义指标
@Component
public class CustomRSIExtension implements CustomIndicatorExtension {
@Override
public String getName() {
return "CUSTOM_RSI";
}
@Override
public Indicator<Num> create(BarSeries series, Map<String, Object> params) {
int period = (int) params.get("period");
double overbought = (double) params.getOrDefault("overbought", 70.0);
double oversold = (double) params.getOrDefault("oversold", 30.0);
RSIIndicator rsi = new RSIIndicator(series, period);
return new Indicator<Num>() {
@Override
public Num getValue(int index) {
return rsi.getValue(index);
}
public boolean isOverbought(int index) {
return rsi.getValue(index).doubleValue() > overbought;
}
public boolean isOversold(int index) {
return rsi.getValue(index).doubleValue() < oversold;
}
};
}
@Override
public Map<String, Object> getParamSchema() {
return Map.of(
"period", Map.of(
"type", "integer",
"min", 1,
"max", 100,
"default", 14
),
"overbought", Map.of(
"type", "number",
"min", 0,
"max", 100,
"default", 70
),
"oversold", Map.of(
"type", "number",
"min", 0,
"max", 100,
"default", 30
)
);
}
}
2）自定义规则扩展
// extension/CustomRuleExtension.java
public interface CustomRuleExtension {
String getName();
Rule create(Map<String, Object> params, Map<String, Indicator<Num>> indicators);
Map<String, Object> getParamSchema();
}
// 示例：自定义规则
@Component
public class NDayBreakoutExtension implements CustomRuleExtension {
@Override
public String getName() {
return "N_DAY_BREAKOUT";
}
@Override
public Rule create(
Map<String, Object> params,
Map<String, Indicator<Num>> indicators
) {
int n = (int) params.get("n");
Indicator<Num> high = (Indicator<Num>) indicators.get("HIGH");
Indicator<Num> low = (Indicator<Num>) indicators.get("LOW");
Indicator<Num> close = (Indicator<Num>) indicators.get("CLOSE");
return new AbstractRule() {
@Override
public boolean isSatisfied(int index) {
// 计算 N 日最高价
Num nHigh = high.getValue(index);
for (int i = 1; i < n; i++) {
Num h = high.getValue(index - i);
if (h.isGreaterThan(nHigh)) {
nHigh = h;
}
}
// 当前收盘价突破 N 日最高价
return close.getValue(index).isGreaterThan(nHigh);
}
};
}
@Override
public Map<String, Object> getParamSchema() {
return Map.of(
"n", Map.of(
"type", "integer",
"min", 1,
"max", 100,
"default", 20
)
);
}
}
七、最佳实践总结
1）DSL 设计原则
- 简洁性：DSL 应该简洁易懂，降低学习成本
- 表达能力：DSL 应该能够表达常见的策略逻辑
- 可扩展性：DSL 应该支持自定义扩展
- 可解释性：DSL 应该能够生成清晰的解释
2）编译器设计原则
- 性能优化：编译结果应该能够缓存和复用
- 错误处理：编译错误应该清晰易懂
- 类型安全：编译过程应该进行类型检查
- 可测试性：编译器应该易于测试
3）可视化编辑器设计原则
- 用户体验：编辑器应该直观易用
- 实时反馈：编辑器应该提供实时反馈
- 验证机制：编辑器应该进行实时验证
- 版本管理：编辑器应该支持版本管理
结语：DSL 是量化平台的核心竞争力
DSL 是量化平台的核心竞争力，它让非程序员也能创建和修改交易策略，降低了量化交易的门槛，提高了策略开发的效率。
关键优势总结：
- 降低门槛：可视化编辑，无需编程知识
- 提高效率：快速创建和修改策略
- 版本管理：支持策略版本管理和回溯
- 可解释性：生成清晰的策略解释
- 可扩展性：支持自定义指标和规则
对于正在构建量化平台的团队，DSL 是一个值得深入投入的核心功能。
