![]()
引言
在构建复杂的 Rust 系统时，设计模式是提升代码质量的重要工具。本文将通过一个算法交易系统的实例，深入讲解三个经典设计模式：策略模式、观察者模式和装饰器模式。这些模式不仅能帮助我们写出更优雅的代码，还能显著提高系统的可维护性和扩展性。
一、策略模式：动态切换交易策略
策略模式让我们能在运行时动态切换算法行为。在算法交易系统中，我们经常需要根据市场情况切换不同的执行策略，比如 TWAP、VWAP 或 POV 策略。
1.1 代码实现
// 定义执行策略特征
trait ExecutionStrategy {
fn execute_order(&self, order_id: u32, quantity: u32);
}
// 实现 TWAP 策略
struct TwapStrategy;
impl ExecutionStrategy for TwapStrategy {
fn execute_order(&self, order_id: u32, quantity: u32) {
println!("使用 TWAP 策略执行订单 {}，数量：{}", order_id, quantity);
// 这里实现 TWAP 具体逻辑
}
}
// 实现 VWAP 策略
struct VwapStrategy;
impl ExecutionStrategy for VwapStrategy {
fn execute_order(&self, order_id: u32, quantity: u32) {
println!("使用 VWAP 策略执行订单 {}，数量：{}", order_id, quantity);
// 这里实现 VWAP 具体逻辑
}
}
// 实现 POV 策略
struct PovStrategy {
participation_rate: f64,
}
impl ExecutionStrategy for PovStrategy {
fn execute_order(&self, order_id: u32, quantity: u32) {
println!(
"使用 POV 策略执行订单 {}，参与率 {}%，数量：{}",
order_id,
self.participation_rate * 100.0,
quantity
);
// 这里实现 POV 具体逻辑
}
}
// 订单执行器
struct OrderExecutor {
strategy: Box<dyn ExecutionStrategy>,
}
impl OrderExecutor {
fn new(strategy: Box<dyn ExecutionStrategy>) -> Self {
OrderExecutor { strategy }
}
fn set_strategy(&mut self, strategy: Box<dyn ExecutionStrategy>) {
self.strategy = strategy;
}
fn execute(&self, order_id: u32, quantity: u32) {
self.strategy.execute_order(order_id, quantity);
}
}
接下来可以通过 main 函数部分运行：
fn main() {
let order_id = 101;
let quantity = 1000;
// Using TWAP Strategy
let twap_strategy = Box::new(TwapStrategy);
let mut executor = OrderExecutor::new(twap_strategy);
executor.execute(order_id, quantity);
// Switching to VWAP Strategy
let vwap_strategy = Box::new(VwapStrategy);
executor.set_strategy(vwap_strategy);
executor.execute(order_id+1, quantity);
// Switching to POV Strategy
let pov_strategy = Box::new(PovStrategy {
participation_rate: 0.1,
});
executor.set_strategy(pov_strategy);
executor.execute(order_id+2, quantity);
}
结果显示：
使用 TWAP 策略执行订单 101，数量：1000
使用 VWAP 策略执行订单 102，数量：1000
使用 POV 策略执行订单 103，参与率 10%，数量：1000
二、观察者模式：实时市场数据推送
观察者模式非常适合处理市场数据推送场景，让多个交易策略能够订阅并响应市场数据的变化。
2.1 代码实现
use std::rc::Rc;
use std::cell::RefCell;
// 观察者特征
trait Observer {
fn update(&self, instrument_id: &str, price: f64);
}
// 主题特征
trait Subject {
fn attach(&mut self, observer: Rc<dyn Observer>);
fn detach(&mut self, observer: &Rc<dyn Observer>);
fn notify(&self);
}
// 动量策略
struct MomentumStrategy {
name: String,
threshold: f64,
}
impl Observer for MomentumStrategy {
fn update(&self, instrument_id: &str, price: f64) {
if price > self.threshold {
println!(
"{}: [{}] 价格突破阈值！当前价格：{}",
self.name, instrument_id, price
);
// 实现买入逻辑
}
}
}
// 均值回归策略
struct MeanReversionStrategy {
name: String,
average_price: RefCell<f64>,
}
impl Observer for MeanReversionStrategy {
fn update(&self, instrument_id: &str, price: f64) {
let mut avg = self.average_price.borrow_mut();
*avg = (*avg * 0.9) + (price * 0.1);
if price < *avg {
println!(
"{}: [{}] 价格低于均值！价格：{}，均值：{:.2}",
self.name, instrument_id, price, *avg
);
// 实现买入逻辑
}
}
}
// 市场数据源
struct MarketDataFeed {
instrument_id: String,
observers: RefCell<Vec<Rc<dyn Observer>>>,
price: RefCell<f64>,
}
impl MarketDataFeed {
fn new(instrument_id: &str) -> Self {
MarketDataFeed {
instrument_id: instrument_id.to_string(),
observers: RefCell::new(Vec::new()),
price: RefCell::new(0.0),
}
}
fn set_price(&self, new_price: f64) {
*self.price.borrow_mut() = new_price;
self.notify();
}
}
impl Subject for MarketDataFeed {
fn attach(&mut self, observer: Rc<dyn Observer>) {
self.observers.borrow_mut().push(observer);
}
fn detach(&mut self, observer: &Rc<dyn Observer>) {
let mut observers = self.observers.borrow_mut();
if let Some(pos) = observers.iter().position(|x| Rc::ptr_eq(x, observer)) {
observers.remove(pos);
}
}
fn notify(&self) {
let price = *self.price.borrow();
for observer in self.observers.borrow().iter() {
observer.update(&self.instrument_id, price);
}
}
}
接下来可以通过 main 函数部分运行：
fn main() {
// Create market data feed for AAPL
let mut market_data_feed = MarketDataFeed::new("AAPL");
// Create observers
let momentum_strategy: Rc<dyn Observer> = Rc::new(MomentumStrategy {
name: String::from("MomentumStrategy"),
threshold: 150.0,
});
let mean_reversion_strategy: Rc<dyn Observer> = Rc::new(MeanReversionStrategy {
name: String::from("MeanReversionStrategy"),
average_price: RefCell::new(145.0),
});
// Attach observers
market_data_feed.attach(momentum_strategy.clone());
market_data_feed.attach(mean_reversion_strategy.clone());
// Simulate market data updates
let price_updates = vec![148.0, 151.0, 149.5, 152.5, 147.0];
for price in price_updates {
println!("\nMarketDataFeed [{}]: New price is {}", "AAPL", price);
market_data_feed.set_price(price);
}
// Detach momentum strategy
market_data_feed.detach(&momentum_strategy);
// More updates
let more_price_updates = vec![153.0, 146.5];
for price in more_price_updates {
println!("\nMarketDataFeed [{}]: New price is {}", "AAPL", price);
market_data_feed.set_price(price);
}
}
结果显示：
MarketDataFeed [AAPL]: New price is 148
MarketDataFeed [AAPL]: New price is 151
MomentumStrategy: [AAPL] 价格突破阈值！当前价格：151
MarketDataFeed [AAPL]: New price is 149.5
MarketDataFeed [AAPL]: New price is 152.5
MomentumStrategy: [AAPL] 价格突破阈值！当前价格：152.5
MarketDataFeed [AAPL]: New price is 147
MarketDataFeed [AAPL]: New price is 153
MarketDataFeed [AAPL]: New price is 146.5
MeanReversionStrategy: [AAPL] 价格低于均值！价格：146.5，均值：147.39
三、装饰器模式：增强订单执行功能
装饰器模式允许我们动态地给对象添加新的行为。在交易系统中，我们可以用它来为订单执行添加额外的功能，如日志记录、风控检查等。
3.1 代码实现
// 定义订单组件特征
trait OrderComponent {
fn execute(&self, order_id: u32, quantity: u32) -> bool;
}
// 基础订单执行器
struct BasicOrderExecutor;
impl OrderComponent for BasicOrderExecutor {
fn execute(&self, order_id: u32, quantity: u32) -> bool {
println!("执行基础订单：ID = {}，数量 = {}", order_id, quantity);
true
}
}
// 装饰器基础特征
struct OrderDecorator {
wrapped: Box<dyn OrderComponent>,
}
// 风控检查装饰器
struct RiskCheckDecorator {
component: Box<dyn OrderComponent>,
risk_limit: u32,
}
impl OrderComponent for RiskCheckDecorator {
fn execute(&self, order_id: u32, quantity: u32) -> bool {
if quantity > self.risk_limit {
println!("风控检查失败：订单数量 {} 超过限制 {}", quantity, self.risk_limit);
return false;
}
self.component.execute(order_id, quantity)
}
}
// 日志记录装饰器
struct LoggingDecorator {
component: Box<dyn OrderComponent>,
}
impl OrderComponent for LoggingDecorator {
fn execute(&self, order_id: u32, quantity: u32) -> bool {
println!("开始执行订单：ID = {}，数量 = {}", order_id, quantity);
let result = self.component.execute(order_id, quantity);
println!("订单执行完成：ID = {}，结果 = {}", order_id, result);
result
}
}
接下来可以通过 main 函数部分运行：
fn main() {
let order_id = 1001;
let quantity = 500;
// 创建基础执行器
let basic_executor = Box::new(BasicOrderExecutor);
// 添加风控检查
let risk_checker = Box::new(RiskCheckDecorator {
component: basic_executor,
risk_limit: 1000,
});
// 添加日志记录
let logger = Box::new(LoggingDecorator {
component: risk_checker,
});
// 执行订单
logger.execute(order_id, quantity);
}
结果显示：
开始执行订单：ID = 1001，数量 = 500
执行基础订单：ID = 1001，数量 = 500
订单执行完成：ID = 1001，结果 = true
总结
通过这个算法交易系统的例子，我们详细介绍了三个重要的设计模式在 Rust 中的应用：
策略模式让我们能够灵活切换不同的交易执行策略 观察者模式帮助我们构建响应式的市场数据处理系统 装饰器模式使我们能够动态地为订单执行添加新的功能
这些设计模式各有特色：
策略模式适合处理算法的动态切换 观察者模式适合处理事件驱动的场景 装饰器模式适合动态扩展对象功能
在实际项目中，合理运用这些设计模式可以帮助我们构建出更加健壮、灵活和可维护的系统。
参考文章
Rust Design Patterns in Algorithmic Trading：https://siddharthqs.com/design-patterns-in-rust Head First Design Patterns Rust 设计模式
书籍推荐
各位 Rust 爱好者，今天为大家介绍一本《Programming Rust: Fast, Safe Systems Development》(第二版) 是由 Jim Blandy、Jason Orendorff 和 Leonora Tindall 合著的 Rust 编程指南。本书深入探讨了 Rust 语言在系统编程中的应用，着重介绍如何利用 Rust 的独特特性来平衡性能和安全性。书中涵盖了 Rust 的基础数据类型、所有权和借用概念、特征和泛型、并发编程、闭包、迭代器以及异步编程等核心内容。这本更新版基于 Rust 2021 版本，为系统程序员提供了全面而实用的 Rust 编程指导。
