MQL5设计模式实战：EA开发中的经典设计模式应用指南
一、为什么EA开发者需要学设计模式
做EA开发超过一年的开发者，几乎都会遇到同样的困境：最初写的几百行代码，随着功能不断叠加，逐渐膨胀到几千行的"巨无霸"文件。新加一个出场策略要改三个地方，调整风控规则要同步修改五处代码，改一个Bug往往引出三个新Bug。到最后，连自己写的代码都不敢动——因为你不知道改了这一处，会在哪个地方崩掉。
这不是你能力的问题，这是缺乏架构设计方法论的必然结果。而设计模式，正是解决这类问题的利器。
很多EA开发者对设计模式有一个常见的误区：觉得那是Java、C++那些"大企业项目"才需要的东西，MQL5就是写写EA，用不上。但实际上，MQL5是一门完全面向对象的语言——它支持类、接口、继承、多态，具备使用设计模式的全部语言基础。而EA开发中的很多典型痛点，恰恰是设计模式的经典适用场景。
GoF的《设计模式》一书提出了23种经典设计模式，分为创建型、结构型、行为型三大类。对于EA开发来说，不需要全部掌握，其中有7个模式是最高频使用的，几乎能覆盖80%以上的EA架构问题。本文将逐一讲解这7个设计模式：单例模式、工厂模式、装饰器模式、适配器模式、策略模式、观察者模式、状态模式，每个模式都配有完整的MQL5代码实现和具体的EA应用场景。
在开始之前，先明确本文的立场：设计模式不是"高大上的炫技"，而是"经过行业验证的问题解决方案"。学设计模式的目的不是为了在简历上多写几个名词，而是为了写出更易维护、更易扩展、更少Bug的EA代码。
二、创建型模式——单例模式：全局风控管理器
2.1 模式定义与核心思想
在EA开发中，单例模式最经典的应用场景就是全局风控管理器。想象一下：你的EA里有开仓检查、加仓检查、平仓检查三个地方都需要做风控校验。如果每个地方都new一个风控管理器，那么每个管理器维护的是自己的计数——A管理器说今天已经开了3单，B管理器说今天只开了1单，C管理器说还没开过单。最终的结果就是风控完全失效，该限制的没有限制住。
而单例模式确保了整个EA中只有一个风控管理器实例，所有地方都访问同一个对象，所有计数都在同一个地方维护，从根本上避免了多实例导致的数据不一致问题。
2.2 MQL5完整实现
下面是一个完整的单例风控管理器实现，包含最大持仓手数控制、单日亏损上限控制、全局仓位统计等核心功能：
//| 全局风控管理器（单例模式） |
//| 功能：确保全EA只有一个风控实例，统一管理风险参数 |
//+------------------------------------------------------------------+
class CSingletonRiskManager
{
private:
static CSingletonRiskManager *m_instance; // 静态实例指针
double m_max_position_lots; // 最大持仓手数
double m_daily_loss_limit; // 单日亏损上限（金额）
double m_day_start_equity; // 当日起始净值
int m_day_start_bar; // 当日起始K线索引
// 私有构造函数，禁止外部直接new
CSingletonRiskManager();
// 私有析构函数
~CSingletonRiskManager();
public:
// 获取单例实例的全局访问点
static CSingletonRiskManager* GetInstance();
// 检查是否允许开新仓（综合风控检查）
bool CanOpenNew(double lots);
// 获取当前总持仓手数
double GetTotalPositionLots();
// 获取当日浮盈亏金额
double GetDailyFloatingPnL();
// 设置风控参数
void SetMaxPositionLots(double lots) { m_max_position_lots=lots; }
void SetDailyLossLimit(double amount) { m_daily_loss_limit=amount; }
};
// 静态成员初始化
CSingletonRiskManager* CSingletonRiskManager::m_instance = NULL;
//+------------------------------------------------------------------+
//| 构造函数（私有） |
//+------------------------------------------------------------------+
CSingletonRiskManager::CSingletonRiskManager()
{
m_max_position_lots = 1.0;
m_daily_loss_limit = 500.0;
m_day_start_equity = AccountInfoDouble(ACCOUNT_EQUITY);
m_day_start_bar = iBarShift(_Symbol, _Period, iTime(_Symbol, _Period, 0));
}
//+------------------------------------------------------------------+
//| 析构函数（私有） |
//+------------------------------------------------------------------+
CSingletonRiskManager::~CSingletonRiskManager()
{
// 清理工作（MQL5中注意手动释放）
}
//+------------------------------------------------------------------+
//| 获取单例实例 |
//+------------------------------------------------------------------+
CSingletonRiskManager* CSingletonRiskManager::GetInstance()
{
if(m_instance == NULL)
{
m_instance = new CSingletonRiskManager();
}
return m_instance;
}
//+------------------------------------------------------------------+
//| 综合风控检查：是否允许开新仓 |
//+------------------------------------------------------------------+
bool CSingletonRiskManager::CanOpenNew(double lots)
{
// 检查1：总持仓手数不超限
if(GetTotalPositionLots() + lots > m_max_position_lots)
return false;
// 检查2：当日亏损不超上限
if(GetDailyFloatingPnL() < -m_daily_loss_limit)
return false;
return true;
}
//+------------------------------------------------------------------+
//| 计算当前总持仓手数 |
//+------------------------------------------------------------------+
double CSingletonRiskManager::GetTotalPositionLots()
{
double total = 0.0;
for(int i=PositionsTotal()-1; i>=0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket > 0 && PositionSelectByTicket(ticket))
{
total += PositionGetDouble(POSITION_VOLUME);
}
}
return total;
}
//+------------------------------------------------------------------+
//| 计算当日浮盈亏 |
//+------------------------------------------------------------------+
double CSingletonRiskManager::GetDailyFloatingPnL()
{
return AccountInfoDouble(ACCOUNT_EQUITY) - m_day_start_equity;
}
// 使用示例：
// CSingletonRiskManager* rm = CSingletonRiskManager::GetInstance();
// rm.SetMaxPositionLots(2.0);
// if(rm.CanOpenNew(0.1)) { /* 执行开仓 */ }
2.3 EA应用场景
- 全局仓位统计：无论EA中哪个模块需要知道当前总持仓，都通过同一个单例获取，确保数据一致
- 单日亏损上限：统一记录当日起始净值和当前浮盈亏，任何模块想开仓前都先过单例的风控检查
- 最大持仓手数控制：全局维护最大手数限制，避免多策略同时开仓导致总敞口超标
- 交易日志统一管理：全EA共用一个日志管理器，日志格式和输出路径统一
2.4 注意事项
三、创建型模式——工厂模式：策略信号工厂
3.1 为什么需要工厂模式
在EA开发中，策略信号的来源往往不止一种。比如同一个EA可能同时支持均线交叉信号、布林带突破信号、RSI超买超卖信号等多种信号源。如果不用工厂模式，代码通常是这样的：用一个枚举变量表示信号类型，然后在OnTick里用switch或者if-else判断用哪种信号计算。
这种写法的问题在于：每新增一种信号源，就要修改好几处代码——要加枚举值、要加if分支、要加参数初始化。代码越来越臃肿，不符合开闭原则（对扩展开放，对修改关闭）。
工厂模式的核心思想是：定义一个创建对象的接口，让子类（或工厂方法）决定实例化哪个类。调用方只需要告诉工厂"我要什么类型的信号"，工厂就返回对应的信号对象，调用方不需要知道具体的实现类，只需要通过统一的接口来调用。
3.2 MQL5实现要点
工厂模式在MQL5中的实现需要三个层次：首先定义一个ISignal基接口，规定所有信号类必须实现的方法（比如GetSignalDirection()返回+1/-1/0）；然后编写具体的信号类（CMA_CrossSignal、CBollingerSignal、CRSI_Signal等），各自实现接口方法；最后创建CSignalFactory工厂类，根据传入的配置字符串创建并返回对应类型的信号对象。
3.3 EA应用场景
- 根据EA参数动态切换信号源：用户在EA输入参数中选择信号类型，工厂据此创建对应信号对象
- 多信号组合策略：工厂创建多个信号对象，再通过组合器（如加权投票）综合判断
- 策略回测对比：在Strategy Tester中通过参数优化，对比不同信号源的表现
- 订单执行器工厂：不同的订单执行方式（市价单、挂单、限价单）由工厂统一创建
四、结构型模式——装饰器模式：风控层层叠加
4.1 风控叠加的痛点
EA的风控规则往往不是单一的，而是多层叠加的。比如：最基础的是单笔止损止盈，然后要加最大回撤限制，还要加交易时间限制（某些时段不交易），还要加品种过滤（只交易指定品种），可能还要根据账户等级启用不同的风控层级。
如果用继承来实现，你会发现类爆炸了：基础风控类、基础+回撤类、基础+时间类、基础+品种类、基础+回撤+时间类……每多一种风控规则，子类的数量就指数级增长。这显然是不可维护的。
装饰器模式就是为了解决这个问题而生的。它的核心思想是：动态地给一个对象添加额外的职责，比继承更灵活。装饰器和被装饰对象实现同一个接口，装饰器内部持有一个被装饰对象的引用，在调用被装饰对象的方法前后添加自己的逻辑。这样，你可以像搭积木一样，一层一层地叠加功能。
4.2 MQL5完整实现
//| 风控装饰器体系（装饰器模式） |
//| 功能：灵活组合多层风控规则，像搭积木一样叠加 |
//+------------------------------------------------------------------+
// 风控检查基接口
class IRiskChecker
{
public:
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type) = 0;
virtual string GetRiskDesc() = 0;
};
// 基础风控类（被装饰对象）
class CBaseRiskChecker : public IRiskChecker
{
private:
double m_max_lots_per_trade;
public:
CBaseRiskChecker(double max_lots):m_max_lots_per_trade(max_lots) {}
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type)
{
return (lots > 0 && lots <= m_max_lots_per_trade);
}
virtual string GetRiskDesc() { return "基础风控(单笔手数限制)"; }
};
// 装饰器基类（所有装饰器的父类）
class CRiskDecorator : public IRiskChecker
{
protected:
IRiskChecker *m_inner; // 被装饰的内层对象
public:
CRiskDecorator(IRiskChecker *inner):m_inner(inner) {}
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type)
{
if(m_inner == NULL) return false;
return m_inner.CheckCanOpen(lots, type); // 委托给内层对象
}
virtual string GetRiskDesc()
{
if(m_inner == NULL) return "";
return m_inner.GetRiskDesc();
}
};
// 具体装饰器1：最大回撤限制
class CDrawdownRiskDecorator : public CRiskDecorator
{
private:
double m_max_drawdown_pct;
public:
CDrawdownRiskDecorator(IRiskChecker *inner, double max_dd)
: CRiskDecorator(inner), m_max_drawdown_pct(max_dd) {}
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type)
{
// 先让内层检查
if(!CRiskDecorator::CheckCanOpen(lots, type))
return false;
// 再加自己的检查：当前回撤是否超限
double current_dd = CalculateDrawdownPercent();
return (current_dd < m_max_drawdown_pct);
}
virtual string GetRiskDesc()
{
return CRiskDecorator::GetRiskDesc() + " + 最大回撤装饰器";
}
double CalculateDrawdownPercent()
{
// 从历史订单中计算最大回撤（简化实现）
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
if(balance <= 0) return 0.0;
double dd = (balance - equity) / balance * 100.0;
return (dd > 0) ? dd : 0.0;
}
};
// 具体装饰器2：交易时间限制
class CTradingTimeRiskDecorator : public CRiskDecorator
{
private:
int m_start_hour;
int m_end_hour;
public:
CTradingTimeRiskDecorator(IRiskChecker *inner, int start_h, int end_h)
: CRiskDecorator(inner), m_start_hour(start_h), m_end_hour(end_h) {}
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type)
{
if(!CRiskDecorator::CheckCanOpen(lots, type))
return false;
// 检查当前时间是否在交易时段内
MqlDateTime dt;
TimeToStruct(TimeCurrent(), dt);
return (dt.hour >= m_start_hour && dt.hour < m_end_hour);
}
virtual string GetRiskDesc()
{
return CRiskDecorator::GetRiskDesc() + " + 交易时间装饰器";
}
};
// 具体装饰器3：品种过滤
class CSymbolFilterRiskDecorator : public CRiskDecorator
{
private:
string m_allowed_symbols[];
public:
CSymbolFilterRiskDecorator(IRiskChecker *inner, string symbols[])
: CRiskDecorator(inner)
{
// 拷贝允许的品种列表
ArrayCopy(m_allowed_symbols, symbols);
}
virtual bool CheckCanOpen(double lots, ENUM_ORDER_TYPE type)
{
if(!CRiskDecorator::CheckCanOpen(lots, type))
return false;
// 检查当前品种是否在允许列表中
for(int i=0; i<ArraySize(m_allowed_symbols); i++)
{
if(_Symbol == m_allowed_symbols[i])
return true;
}
return false;
}
virtual string GetRiskDesc()
{
return CRiskDecorator::GetRiskDesc() + " + 品种过滤装饰器";
}
};
// 使用示例：
// IRiskChecker* risk = new CBaseRiskChecker(1.0);
// risk = new CDrawdownRiskDecorator(risk, 15.0); // 加回撤限制
// risk = new CTradingTimeRiskDecorator(risk, 8, 20); // 加时间限制
// risk = new CSymbolFilterRiskDecorator(risk, syms); // 加品种过滤
// bool can_open = risk.CheckCanOpen(0.1, ORDER_TYPE_BUY);
4.3 EA应用场景
- 灵活组合风控规则：根据不同客户的需求，自由组合风控层级，无需新增子类
- A/B测试不同风控组合：快速搭建不同的风控配置，对比回测效果
- 根据账户等级启用不同风控：VIP账户启用全部风控，体验账户启用基础风控
- 信号过滤叠加：趋势过滤 + 波动过滤 + 成交量过滤，层层筛选信号
五、结构型模式——适配器模式：MT4/MT5双平台兼容
5.1 双平台开发的痛点
很多EA开发者都面临一个现实问题：客户群体中既有MT4用户，也有MT5用户。同一个策略逻辑，需要同时维护MQL4和MQL5两个版本。而MT4和MT5在订单API、指标API、时间函数等方面存在大量差异——MQL4用OrderSend()下单，MQL5用trade类；MQL4用iMA()直接返回指标值，MQL5用CopyBuffer()拷贝缓冲区；MQL4的OrdersTotal()是历史+持仓总订单，MQL5要分开查PositionsTotal()和OrdersHistoryTotal()。
这些差异散落在代码的各个角落。每次发现一个Bug，要在两套代码里各改一遍，还容易改漏。新增一个功能，也要分别在两个版本中实现，工作量翻倍。
适配器模式可以很好地解决这个问题。它的核心思想是：将一个类的接口转换成客户希望的另一个接口，让原本不兼容的类可以一起工作。具体到EA双平台开发，就是定义一套统一的交易API接口，然后为MT4和MT5分别编写适配器，上层的策略逻辑只调用统一接口，完全不关心底层是MT4还是MT5。
5.2 EA应用场景
- 双平台EA开发：同一套策略逻辑同时支持MT4和MT5，代码复用率大幅提升
- 降低迁移成本：从MT4迁移到MT5时，只需替换适配器，策略逻辑无需改动
- 指标API统一：封装不同平台的指标调用方式，上层直接获取指标值
- 订单管理统一：开仓、平仓、改止损等操作统一接口，屏蔽平台差异
六、行为型模式——策略模式：可切换的入场/出场算法
6.1 模式定义与核心思想
在EA开发中，策略模式的应用场景非常广泛。出场算法就是一个典型例子：你可能有固定止盈止损、追踪止损、时间止盈、移动止盈等多种出场方式。如果把这些出场逻辑都写在OnTick里用if-else判断，代码会非常臃肿，新增一种出场方式要改好几个地方。
用策略模式的思路，把每种出场算法封装成一个独立的类，它们都实现同一个IExitStrategy接口。EA主程序中持有一个IExitStrategy指针，指向当前使用的出场策略对象。需要切换出场算法时，只需要更换这个指针指向的对象，其他代码完全不用改。
6.2 MQL5完整实现
//| 出场策略体系（策略模式） |
//| 功能：可切换的多种出场算法，运行时动态切换 |
//+------------------------------------------------------------------+
// 出场策略基接口
class IExitStrategy
{
public:
// 检查是否需要退出，返回退出原因（0=不退出, 1=止盈, 2=止损, 3=时间到）
virtual int CheckExit(ulong ticket) = 0;
virtual string GetStrategyName() = 0;
};
// 策略1：固定止盈止损
class CFixedSLTPExit : public IExitStrategy
{
private:
double m_tp_points; // 止盈点数
double m_sl_points; // 止损点数
public:
CFixedSLTPExit(double tp_pts, double sl_pts)
: m_tp_points(tp_pts), m_sl_points(sl_pts) {}
virtual int CheckExit(ulong ticket)
{
if(!PositionSelectByTicket(ticket)) return 0;
double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
double current_price = PositionGetDouble(POSITION_PRICE_CURRENT);
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
double profit_pts = 0;
if(type == POSITION_TYPE_BUY)
profit_pts = (current_price - open_price) / point;
else
profit_pts = (open_price - current_price) / point;
if(profit_pts >= m_tp_points) return 1; // 止盈
if(profit_pts <= -m_sl_points) return 2; // 止损
return 0;
}
virtual string GetStrategyName() { return "固定止盈止损"; }
};
// 策略2：追踪止损
class CTrailingStopExit : public IExitStrategy
{
private:
double m_trailing_stop_pts; // 追踪止损距离（点）
double m_trigger_pts; // 触发追踪的盈利点数
public:
CTrailingStopExit(double ts_pts, double trigger_pts)
: m_trailing_stop_pts(ts_pts), m_trigger_pts(trigger_pts) {}
virtual int CheckExit(ulong ticket)
{
if(!PositionSelectByTicket(ticket)) return 0;
double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
double current_price = PositionGetDouble(POSITION_PRICE_CURRENT);
double sl_price = PositionGetDouble(POSITION_SL);
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
double profit_pts = 0;
if(type == POSITION_TYPE_BUY)
profit_pts = (current_price - open_price) / point;
else
profit_pts = (open_price - current_price) / point;
// 达到触发条件后，调整止损位
if(profit_pts >= m_trigger_pts)
{
double new_sl = 0;
if(type == POSITION_TYPE_BUY)
new_sl = current_price - m_trailing_stop_pts * point;
else
new_sl = current_price + m_trailing_stop_pts * point;
// 如果新止损比当前止损更好，更新止损（通过trade对象修改）
// 此处省略trade操作代码，重点展示策略模式结构
}
return 0; // 追踪止损不主动平仓，只移动止损位
}
virtual string GetStrategyName() { return "追踪止损"; }
};
// 策略3：时间止盈
class CTimeExit : public IExitStrategy
{
private:
int m_max_bars_hold; // 最大持仓K线数
public:
CTimeExit(int max_bars):m_max_bars_hold(max_bars) {}
virtual int CheckExit(ulong ticket)
{
if(!PositionSelectByTicket(ticket)) return 0;
datetime open_time = (datetime)PositionGetInteger(POSITION_TIME);
int bars_held = iBarShift(_Symbol, _Period, open_time);
if(bars_held >= m_max_bars_hold)
return 3; // 时间到，退出
return 0;
}
virtual string GetStrategyName() { return "时间止盈"; }
};
// Context类：使用策略的上下文
class CExitManager
{
private:
IExitStrategy *m_strategy;
public:
CExitManager():m_strategy(NULL) {}
~CExitManager() { if(m_strategy) delete m_strategy; }
// 动态切换策略
void SetStrategy(IExitStrategy *strategy)
{
if(m_strategy) delete m_strategy;
m_strategy = strategy;
}
// 执行出场检查
int CheckPositionExit(ulong ticket)
{
if(m_strategy == NULL) return 0;
return m_strategy.CheckExit(ticket);
}
};
// 使用示例：
// CExitManager exit_mgr;
// exit_mgr.SetStrategy(new CFixedSLTPExit(500, 300));
// // 后来想换成追踪止损
// exit_mgr.SetStrategy(new CTrailingStopExit(200, 300));
6.3 EA应用场景
- 多策略回测对比：同一份EA，通过切换不同的入场/出场策略，对比回测结果
- 根据市场状态动态切换策略：趋势行情用趋势策略，震荡行情用震荡策略
- 策略组合优化：多个策略组合使用，如"固定止损 + 追踪止盈"
- 参数优化：在Strategy Tester中对不同策略及参数进行穷举优化
七、行为型模式——观察者模式：事件通知机制
7.1 模块耦合的问题
当EA的模块越来越多时，模块之间的通信就成了一个问题。比如，信号模块产生了一个入场信号，需要通知订单执行模块下单、通知风控模块检查、通知日志模块记录、通知通知模块发推送。如果信号模块直接调用这四个模块的方法，那么信号模块就和这四个模块紧密耦合了——任何一个模块的接口变化，都可能影响信号模块。
观察者模式就是为了解决这种"一对多"的依赖关系。它的核心思想是：定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并自动更新。在观察者模式中，被观察者（也叫主题或Subject）维护一个观察者列表，它只知道观察者实现了某个接口，不知道观察者的具体类型。新增或删除观察者时，被观察者的代码完全不需要修改。
7.2 EA应用场景
- 信号-交易解耦：信号模块只负责产生信号，订单模块订阅信号事件后自动执行
- 多模块事件通知：一次开仓动作同时触发日志记录、风控更新、统计更新等
- 日志与报警系统：关键事件发生时自动推送通知到手机或邮箱
- 多EA通信：通过全局变量或命名管道实现跨EA的观察者模式
八、行为型模式——状态模式：EA运行状态管理
8.1 模式定义与核心思想
EA运行过程中会经历多种状态：初始化中、正常交易、暂停交易、收盘时段、错误状态等。如果你用一堆bool变量（is_initialized、is_trading、is_paused、is_closed、is_error）来管理这些状态，很快就会陷入if-else的地狱——每次要执行一个操作，都要先判断N个标志变量，代码逻辑越来越复杂，很容易出现非法状态跳转（比如从错误状态直接跳到交易状态，跳过了重新初始化）。
状态模式把每个状态的行为封装到独立的类中，每个状态类只关心自己能做什么、能转到什么状态。状态之间的跳转逻辑清晰可见，杜绝了非法状态转移的可能性。
8.2 MQL5完整实现
//| EA运行状态机（状态模式） |
//| 功能：管理EA生命周期，状态转移自动校验 |
//+------------------------------------------------------------------+
// 状态枚举
enum EA_STATE
{
STATE_INIT = 0, // 初始化中
STATE_TRADING = 1, // 交易中
STATE_PAUSED = 2, // 暂停
STATE_CLOSED = 3, // 收盘/休市
STATE_ERROR = 4 // 错误状态
};
// 状态基接口
class IEAState
{
public:
virtual void OnEnter() = 0; // 进入状态时调用
virtual void OnExit() = 0; // 退出状态时调用
virtual void OnTick() = 0; // 每个tick调用
virtual EA_STATE GetStateId() = 0; // 获取状态ID
virtual bool CanTransitionTo(EA_STATE target) = 0; // 能否转到目标状态
};
// 状态机Context
class CEAStateMachine
{
private:
IEAState *m_current_state; // 当前状态
IEAState *m_states[5]; // 所有状态对象
public:
CEAStateMachine();
~CEAStateMachine();
// 切换状态
bool TransitionTo(EA_STATE new_state);
// 当前tick处理
void OnTick();
// 获取当前状态
EA_STATE GetCurrentState() { return m_current_state ? m_current_state.GetStateId() : STATE_INIT; }
};
//=== 具体状态类：初始化状态 ===
class CInitState : public IEAState
{
public:
virtual void OnEnter() { Print("进入初始化状态"); }
virtual void OnExit() { Print("退出初始化状态"); }
virtual void OnTick() { /* 初始化中不执行交易逻辑 */ }
virtual EA_STATE GetStateId() { return STATE_INIT; }
virtual bool CanTransitionTo(EA_STATE target)
{
// 初始化状态只能转到交易中或错误状态
return (target == STATE_TRADING || target == STATE_ERROR);
}
};
//=== 具体状态类：交易中状态 ===
class CTradingState : public IEAState
{
public:
virtual void OnEnter() { Print("进入交易状态，开始执行策略"); }
virtual void OnExit() { Print("退出交易状态"); }
virtual void OnTick()
{
// 正常执行交易逻辑：信号判断 → 风控检查 → 下单/平仓
// ...
}
virtual EA_STATE GetStateId() { return STATE_TRADING; }
virtual bool CanTransitionTo(EA_STATE target)
{
// 交易中可以转到暂停、收盘、错误状态
return (target == STATE_PAUSED || target == STATE_CLOSED || target == STATE_ERROR);
}
};
//=== 具体状态类：暂停状态 ===
class CPausedState : public IEAState
{
public:
virtual void OnEnter() { Print("进入暂停状态，停止开新仓"); }
virtual void OnExit() { Print("退出暂停状态"); }
virtual void OnTick()
{
// 暂停状态下不平仓，只管理已有持仓的止损止盈
// ...
}
virtual EA_STATE GetStateId() { return STATE_PAUSED; }
virtual bool CanTransitionTo(EA_STATE target)
{
// 暂停可以恢复交易、进入收盘或错误
return (target == STATE_TRADING || target == STATE_CLOSED || target == STATE_ERROR);
}
};
//=== 具体状态类：收盘状态 ===
class CClosedState : public IEAState
{
public:
virtual void OnEnter() { Print("进入收盘状态，市场休市"); }
virtual void OnExit() { Print("退出收盘状态，市场开市"); }
virtual void OnTick()
{
// 收盘状态下不执行交易，只做每日重置（如重置当日盈亏统计）
// ...
}
virtual EA_STATE GetStateId() { return STATE_CLOSED; }
virtual bool CanTransitionTo(EA_STATE target)
{
// 收盘后只能转到交易中或错误
return (target == STATE_TRADING || target == STATE_ERROR);
}
};
//=== 具体状态类：错误状态 ===
class CErrorState : public IEAState
{
public:
virtual void OnEnter() { Print("进入错误状态，停止所有交易"); }
virtual void OnExit() { Print("从错误状态恢复"); }
virtual void OnTick()
{
// 错误状态下不做任何交易操作
// 可以尝试自动恢复（如重新连接、重新初始化）
// ...
}
virtual EA_STATE GetStateId() { return STATE_ERROR; }
virtual bool CanTransitionTo(EA_STATE target)
{
// 错误状态只能先回到初始化，再重新开始
return (target == STATE_INIT);
}
};
//+------------------------------------------------------------------+
//| 状态机实现 |
//+------------------------------------------------------------------+
CEAStateMachine::CEAStateMachine()
{
// 创建所有状态对象
m_states[STATE_INIT] = new CInitState();
m_states[STATE_TRADING] = new CTradingState();
m_states[STATE_PAUSED] = new CPausedState();
m_states[STATE_CLOSED] = new CClosedState();
m_states[STATE_ERROR] = new CErrorState();
m_current_state = m_states[STATE_INIT];
m_current_state.OnEnter();
}
CEAStateMachine::~CEAStateMachine()
{
for(int i=0; i<5; i++)
{
if(m_states[i]) delete m_states[i];
}
}
bool CEAStateMachine::TransitionTo(EA_STATE new_state)
{
if(!m_current_state) return false;
if(!m_states[new_state]) return false;
// 检查状态转移是否合法
if(!m_current_state.CanTransitionTo(new_state))
{
Print("非法状态转移：", m_current_state.GetStateId(), " → ", new_state);
return false;
}
// 执行状态切换
m_current_state.OnExit();
m_current_state = m_states[new_state];
m_current_state.OnEnter();
return true;
}
void CEAStateMachine::OnTick()
{
if(m_current_state) m_current_state.OnTick();
}
8.3 EA应用场景
- EA生命周期管理：初始化→交易中→暂停→收盘→错误，各状态行为明确
- 交易时段控制：自动识别开盘/收盘时间，切换到对应状态
- 错误处理与恢复：出错时进入错误状态，尝试自动恢复或等待人工介入
- 交易策略状态：建仓→加仓→持有→减仓→平仓，用状态机管理持仓生命周期
九、实战案例：用设计模式重构一个真实EA
光说不练假把式。下面我们通过一个真实的案例来展示设计模式的落地效果。
假设我们有一个经典的"面条式"网格EA：单文件约800行，所有逻辑都堆在OnTick函数里——开仓判断、加仓判断、平仓判断、止损止盈、风控检查、日志输出全部混在一起。变量名随意（a、b、c一大堆），全局变量到处用，新增一个功能要在代码里翻半天找对地方。
9.1 重构路线图
我们用之前学到的设计模式，分五步来重构这个EA：
第1步：用单例模式统一风控管理。把散落在各处的风控检查（最大持仓手数、单日亏损限制、回撤控制）抽出来，做成一个全局单例的风控管理器。所有需要做风控检查的地方，都通过这个单例来调用。这样改风控规则只需要改一个类，而不是在代码里找N处。
第二步：用策略模式封装网格计算逻辑。把网格间距计算、加仓位置计算、止盈位置计算等抽出来，封装成独立的网格策略类。以后如果想换成马丁策略、对冲策略，只需要新增一个策略类，不需要动主EA的逻辑。
第三步：用装饰器叠加多层风控。把基础风控、回撤限制、交易时间限制、品种过滤等做成独立的装饰器，灵活组合。不同的客户需求对应不同的风控组合，不需要为每个客户维护一个分支版本。
第四步：用状态模式管理EA运行状态。把EA的运行状态（初始化、交易中、暂停、收盘、错误）封装成状态类，状态之间的跳转有明确的合法性检查。再也不用靠一堆bool标志变量来判断当前处于什么状态。
第五步：用观察者模式实现事件通知。信号产生、订单成交、风控触发等关键事件，通过观察者模式通知各个订阅模块。模块之间解耦，新增日志模块、报警模块都不需要修改现有代码。
9.2 重构前后对比
| 维度 | 重构前（面条式） | 重构后（设计模式） |
|---|---|---|
| 代码结构 | 单文件800行，所有逻辑混在一起 | 10+模块化文件，职责清晰 |
| 维护成本 | 改一个风控规则要改5处 | 改一个风控规则只改1处 |
| 扩展效率 | 加一个新出场策略要改3处以上 | 加一个新出场策略只加1个类 |
| Bug率 | 改一个Bug容易引出新Bug | 模块化隔离，Bug影响范围可控 |
| 新人上手时间 | 1-2周才能看懂全部代码 | 2-3天就能理解架构并上手修改 |
| 代码复用率 | 新项目基本要重写 | 风控/状态/信号模块可直接复用 |
如果你对重构的方法论感兴趣，想知道如何识别代码中的"坏味道"、如何分步骤安全地重构，可以阅读我们之前发布的《MQL5代码重构与技术债治理》深度文。那篇文章详细讲解了重构的原则、方法和常见的代码坏味道，和本文的设计模式落地形成"为什么改→改成什么样"的完整学习路径。
十、设计模式选择指南与常见误区
10.1 问题-模式选择指南
很多开发者学完设计模式后会有一个困惑：面对具体问题，我怎么知道该用哪个模式？下面这张表总结了EA开发中常见的问题场景，以及对应的推荐设计模式，帮你快速决策。
| 你遇到的问题 | 推荐模式 | 一句话说明 |
|---|---|---|
| 需要全局统一的风控管理器 | 单例模式 | 保证只有一个实例，避免风控计数错误 |
| 有多种信号源/策略需要切换 | 工厂模式 | 统一创建对象，调用方不用管具体实现 |
| 风控规则有很多种组合方式 | 装饰器模式 | 像搭积木一样灵活叠加风控规则 |
| 同一套策略要跑MT4和MT5 | 适配器模式 | 隔离平台差异，上层逻辑统一 |
| 出场算法有好几种想切换对比 | 策略模式 | 把算法封装成类，运行时动态切换 |
| 信号产生后要通知多个模块 | 观察者模式 | 一对多通知，模块解耦 |
| EA状态多，if-else写不过来 | 状态模式 | 每个状态一个类，转移逻辑清晰 |
10.2 常见误区
误区一：每个类都要套个模式。 有些人觉得不用设计模式就是"水平低"，于是给每个类都硬套一个模式。实际上，很多简单的逻辑用普通的类和函数就足够了，强行套模式只会增加不必要的抽象层级。
误区二：只学模式名称不学设计思想。 设计模式的价值不在于那些类结构图，而在于背后的设计原则——开闭原则、单一职责原则、依赖倒置原则、里氏替换原则等。模式是这些原则在特定场景下的具体体现。理解了设计原则，你甚至可以自己"发明"出适合当前问题的模式。
误区三：忽略MQL5的特殊性。 很多设计模式的教程都是基于Java或C++的，但MQL5有自己的特点：没有垃圾回收需要手动管理内存、没有反射机制工厂模式需要手动注册、OnTick调用频率很高对性能敏感。在MQL5中使用设计模式时，一定要考虑这些特殊性，不能照搬其他语言的写法。
10.3 实践建议
对于想系统提升EA架构能力的开发者，以下是一些实践建议：
- 从最常用的2-3个模式开始：先掌握策略模式、单例模式、装饰器模式这三个最高频的，其他的用到了再学
- 先写能用的代码，再考虑优化：不要一开始就想着套模式，先把功能做对，迭代时再引入模式
- 重构时引入模式：设计模式推荐的引入时机是重构的时候——你已经知道了代码的痛点在哪里，这时选择合适的模式来优化，效果更佳
- 多读优秀开源代码：MQL5 CodeBase上有很多高质量的EA代码，看看它们是怎么组织架构的，从中学习
- 结合重构一起学：设计模式和代码重构是一对黄金搭档，重构帮你发现问题，设计模式帮你解决问题
本文是EA工程化系列的第二篇，首篇《MQL5代码重构与技术债治理》于10月6日发布，建议两篇连读，形成完整的学习路径。后续我们还会推出工程化系列的更多内容，包括EA模块化架构设计、单元测试在MQL5中的应用、EA持续集成与自动化回测等。
如果你在EA开发中遇到了架构设计的难题，或者想为自己的EA引入设计模式但不知道从何入手，欢迎关注晓辉编程，我们专注于MT5 EA定制开发与技术服务，提供从策略实现到架构优化的全流程技术支持。
微信公众号
晓辉编程
视频号
晓辉说EA