Rust Trait系统设计模式:实现灵活的多态和代码复用

电机FOC控制实战:STM32 CubeMX配置六路互补PWM与死区优化 本文详细介绍了如何使用STM32 CubeMX配置六路互补PWM与死区优化,实现电机FOC控制。通过实战经验分享,包括时钟配置、定时器设置、死区时间计算及优化技巧,帮助开发者避免常见问题,提升电机控制性能。特别适用于STM32G4系列的无刷电机驱动应用。 阅读详情

引言

作为从Python转向Rust的开发者,我发现Rust的Trait系统是实现代码复用和多态的核心机制。与Python的鸭子类型不同,Rust的Trait提供了编译时的类型安全保证。本文将深入探讨Rust Trait系统的设计模式,帮助你掌握如何利用Trait构建灵活、可扩展的代码。

一、Trait基础

1.1 定义Trait

trait Drawable {
    fn draw(&self);
    
    fn default_draw(&self) {
        println!("Default drawing behavior");
    }
}

struct Circle {
    radius: f64,
}

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius {}", self.radius);
    }
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Drawable for Rectangle {
    fn draw(&self) {
        println!("Drawing a rectangle {}x{}", self.width, self.height);
    }
}

1.2 Trait约束

fn draw_all<T: Drawable>(shapes: &[T]) {
    for shape in shapes {
        shape.draw();
    }
}

fn main() {
    let circle = Circle { radius: 5.0 };
    let rectangle = Rectangle { width: 3.0, height: 4.0 };
    
    draw_all(&[circle, rectangle]);
}

1.3 多个Trait约束

use std::fmt::Display;

trait Printable: Display {
    fn print(&self) {
        println!("{}", self);
    }
}

struct Point {
    x: i32,
    y: i32,
}

impl Display for Point {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl Printable for Point {}

二、Trait对象

2.1 使用Trait对象实现多态

trait Shape {
    fn area(&self) -> f64;
}

struct Square {
    side: f64,
}

impl Shape for Square {
    fn area(&self) -> f64 {
        self.side * self.side
    }
}

struct Triangle {
    base: f64,
    height: f64,
}

impl Shape for Triangle {
    fn area(&self) -> f64 {
        0.5 * self.base * self.height
    }
}

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Square { side: 5.0 }),
        Box::new(Triangle { base: 4.0, height: 6.0 }),
    ];
    
    for shape in shapes {
        println!("Area: {}", shape.area());
    }
}

2.2 Trait对象的限制

trait CloneableShape: Shape + Clone {
    fn clone_box(&self) -> Box<dyn CloneableShape>;
}

impl<T: Shape + Clone + 'static> CloneableShape for T {
    fn clone_box(&self) -> Box<dyn CloneableShape> {
        Box::new(self.clone())
    }
}

2.3 动态分发 vs 静态分发

// 静态分发(编译时确定)
fn process_static<T: Shape>(shape: T) -> f64 {
    shape.area()
}

// 动态分发(运行时确定)
fn process_dynamic(shape: &dyn Shape) -> f64 {
    shape.area()
}

三、Trait设计模式

3.1 Adapter模式

struct LegacyPrinter {
    output: String,
}

impl LegacyPrinter {
    fn print_line(&mut self, text: &str) {
        self.output.push_str(text);
        self.output.push('\n');
    }
}

trait NewPrinter {
    fn print(&mut self, content: &str);
}

struct PrinterAdapter {
    legacy: LegacyPrinter,
}

impl NewPrinter for PrinterAdapter {
    fn print(&mut self, content: &str) {
        for line in content.lines() {
            self.legacy.print_line(line);
        }
    }
}

3.2 Strategy模式

trait PaymentStrategy {
    fn pay(&self, amount: f64) -> bool;
}

struct CreditCardPayment {
    card_number: String,
}

impl PaymentStrategy for CreditCardPayment {
    fn pay(&self, amount: f64) -> bool {
        println!("Paying {} with credit card {}", amount, self.card_number);
        true
    }
}

struct PayPalPayment {
    email: String,
}

impl PaymentStrategy for PayPalPayment {
    fn pay(&self, amount: f64) -> bool {
        println!("Paying {} via PayPal {}", amount, self.email);
        true
    }
}

struct ShoppingCart {
    items: Vec<f64>,
    payment_method: Box<dyn PaymentStrategy>,
}

impl ShoppingCart {
    fn checkout(&self) -> bool {
        let total: f64 = self.items.iter().sum();
        self.payment_method.pay(total)
    }
}

3.3 Factory模式

trait Vehicle {
    fn drive(&self);
}

struct Car;
struct Bike;

impl Vehicle for Car {
    fn drive(&self) {
        println!("Driving a car");
    }
}

impl Vehicle for Bike {
    fn drive(&self) {
        println!("Riding a bike");
    }
}

enum VehicleType {
    Car,
    Bike,
}

struct VehicleFactory;

impl VehicleFactory {
    fn create(vehicle_type: VehicleType) -> Box<dyn Vehicle> {
        match vehicle_type {
            VehicleType::Car => Box::new(Car),
            VehicleType::Bike => Box::new(Bike),
        }
    }
}

3.4 Decorator模式

trait Coffee {
    fn cost(&self) -> f64;
    fn description(&self) -> String;
}

struct SimpleCoffee;

impl Coffee for SimpleCoffee {
    fn cost(&self) -> f64 {
        2.0
    }
    
    fn description(&self) -> String {
        "Simple coffee".to_string()
    }
}

struct MilkDecorator {
    coffee: Box<dyn Coffee>,
}

impl Coffee for MilkDecorator {
    fn cost(&self) -> f64 {
        self.coffee.cost() + 0.5
    }
    
    fn description(&self) -> String {
        format!("{} with milk", self.coffee.description())
    }
}

struct SugarDecorator {
    coffee: Box<dyn Coffee>,
}

impl Coffee for SugarDecorator {
    fn cost(&self) -> f64 {
        self.coffee.cost() + 0.2
    }
    
    fn description(&self) -> String {
        format!("{} with sugar", self.coffee.description())
    }
}

四、Trait边界和关联类型

4.1 关联类型

trait Iterator {
    type Item;
    
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter {
    count: i32,
}

impl Iterator for Counter {
    type Item = i32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

4.2 泛型Trait

trait Convert<T> {
    fn convert(self) -> T;
}

impl Convert<String> for i32 {
    fn convert(self) -> String {
        self.to_string()
    }
}

impl Convert<i32> for String {
    fn convert(self) -> i32 {
        self.parse().unwrap_or(0)
    }
}

4.3 where子句

fn process<T, U>(a: T, b: U) -> String
where
    T: Display + Clone,
    U: Display,
{
    format!("{} and {}", a, b)
}

五、标准库中的Trait

5.1 Debug和Display

use std::fmt::{self, Debug, Display};

struct Person {
    name: String,
    age: i32,
}

impl Debug for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Person {{ name: {:?}, age: {} }}", self.name, self.age)
    }
}

impl Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} is {} years old", self.name, self.age)
    }
}

5.2 Iterator和IntoIterator

struct VecWrapper(Vec<i32>);

impl IntoIterator for VecWrapper {
    type Item = i32;
    type IntoIter = std::vec::IntoIter<i32>;
    
    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

fn main() {
    let wrapper = VecWrapper(vec![1, 2, 3]);
    for num in wrapper {
        println!("{}", num);
    }
}

5.3 From和Into

struct MyString(String);

impl From<String> for MyString {
    fn from(s: String) -> Self {
        MyString(s)
    }
}

impl From<&str> for MyString {
    fn from(s: &str) -> Self {
        MyString(s.to_string())
    }
}

fn main() {
    let s1: MyString = "hello".into();
    let s2: MyString = String::from("world").into();
}

六、实战:构建可扩展的日志系统

use std::fmt::Display;

trait Logger {
    fn log(&self, message: &str);
    fn log_error(&self, error: &str) {
        self.log(&format!("[ERROR] {}", error));
    }
}

struct ConsoleLogger;
struct FileLogger {
    filename: String,
}
struct NetworkLogger {
    endpoint: String,
}

impl Logger for ConsoleLogger {
    fn log(&self, message: &str) {
        println!("Console: {}", message);
    }
}

impl Logger for FileLogger {
    fn log(&self, message: &str) {
        println!("Writing to {}: {}", self.filename, message);
    }
}

impl Logger for NetworkLogger {
    fn log(&self, message: &str) {
        println!("Sending to {}: {}", self.endpoint, message);
    }
}

struct Application {
    loggers: Vec<Box<dyn Logger>>,
}

impl Application {
    fn new() -> Self {
        Application {
            loggers: vec![
                Box::new(ConsoleLogger),
                Box::new(FileLogger { filename: "app.log".to_string() }),
                Box::new(NetworkLogger { endpoint: "http://log.example.com".to_string() }),
            ],
        }
    }
    
    fn log(&self, message: &str) {
        for logger in &self.loggers {
            logger.log(message);
        }
    }
}

七、从Python视角看Trait

7.1 Python的鸭子类型 vs Rust的Trait

Python版本(鸭子类型):

class Circle:
    def draw(self):
        print("Drawing a circle")

class Rectangle:
    def draw(self):
        print("Drawing a rectangle")

def draw_all(shapes):
    for shape in shapes:
        shape.draw()  # 运行时检查

Rust版本(Trait):

trait Drawable {
    fn draw(&self);
}

struct Circle;
struct Rectangle;

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
}

impl Drawable for Rectangle {
    fn draw(&self) {
        println!("Drawing a rectangle");
    }
}

fn draw_all(shapes: &[Box<dyn Drawable>]) {
    for shape in shapes {
        shape.draw();  // 编译时检查
    }
}

7.2 优势对比

特性Python鸭子类型Rust Trait
类型检查运行时编译时
错误检测运行时编译时
性能有虚函数开销静态分发时零开销
灵活性高中等
安全性低高

八、常见陷阱与解决方案

8.1 Sized问题

// 问题:Trait对象需要知道大小
fn bad_function<T: Drawable>(shape: T) {
    // OK:T是Sized
}

fn bad_function2(shape: dyn Drawable) {
    // 错误:dyn Drawable不是Sized
}

// 解决方案:使用引用或Box
fn good_function(shape: &dyn Drawable) {
    shape.draw();
}

8.2 Trait对象的生命周期

// 问题:生命周期不匹配
struct Container<'a> {
    shape: &'a dyn Drawable,
}

// 解决方案:显式标注生命周期
impl<'a> Container<'a> {
    fn new(shape: &'a dyn Drawable) -> Self {
        Container { shape }
    }
}

8.3 实现冲突

// 问题:孤儿规则
struct StringWrapper(String);

// 错误:不能为外部类型实现外部Trait
// impl Display for StringWrapper { }

// 解决方案:使用newtype模式
struct MyDisplay(String);

impl std::fmt::Display for MyDisplay {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "MyDisplay({})", self.0)
    }
}

九、总结

Rust的Trait系统是实现代码复用和多态的强大工具。通过合理使用Trait,可以构建出灵活、可扩展且类型安全的代码。关键要点包括:

  1. Trait定义:定义方法签名和默认实现
  2. Trait实现:为具体类型实现Trait方法
  3. Trait对象:实现运行时多态
  4. 设计模式:Adapter、Strategy、Factory、Decorator等
  5. 关联类型:增强Trait的表达能力
  6. 标准库Trait:利用Rust标准库提供的通用Trait

通过掌握Trait系统,你可以编写出更加优雅和可维护的Rust代码。


参考资料:

408 | 408常用计算公式与方法 —— 计组篇 汇总 408常用计算公式与方法 —— 计算机组成原理篇 汇总 阅读详情

相关推荐

千兆以太网PHY设计:PCB原理图完整示例

深入解析千兆以太网PHY电路设计要点,提供完整的PCB原理图设计实例,帮助工程师掌握高速信号布局与电源去耦等关键技术,提升设计稳定性与信号完整性。

weixin_30633869的博客 635

Rust 中的 trait 定义与实现

trait 是 Rust 类型系统的核心抽象机制,它通过定义行为而非继承关系实现多态和代码复用。通过默认实现、trait 约束、关联类型等特性,trait 提供了强大而灵活的抽象能力。理解 trait 的设计哲学和实现机制,是掌握 Rust 泛型编程、理解标准库、设计优雅 API 的基础。

weixin_43752269的博客 1010

STM32 ADC+DMA实战:手把手教你驱动XGZP6847A压力传感器(附完整代码)

本文详细介绍了如何使用STM32的ADC和DMA外设驱动XGZP6847A压力传感器,包括硬件连接、ADC配置、DMA高效传输实现以及数据处理与校准方法。通过实战案例和完整代码,帮助开发者快速掌握高精度压力数据采集技术,适用于工业控制和医疗设备等领域。

weixin_42570484的博客 406

dyn-clone:让 Rust 动态 trait 对象实现克隆的终极解决方案

在 Rust 开发中,动态 trait 对象(trait object)的克隆一直是开发者面临的痛点。标准库的 `Clone` trait 由于其 Self 类型限制,无法直接用于 trait 对象。而 **dyn-clone** 库正是为解决这一问题而生,它提供了一种简单高效的方式,让你的 trait 对象也能轻松实现克隆功能。 ## 为什么需要 dyn-clone? Rust 的类型系统虽

gitblog_00220的博客 1021

Ribo测序翻译效率计算及可视化

本文介绍了一个计算翻译效率(TE)和分析转录-翻译相关性的生物信息学流程。首先通过Python脚本从标准化表达量矩阵(TPM/FPKM)计算TE值,该脚本自动匹配转录组(RNA)和翻译组(Ribo)样本进行比值运算。然后使用R语言进行相关性分析,通过ggplot2绘制样本间转录-翻译表达量的散点图,添加线性回归线和相关系数标注,支持PNG/PDF格式输出。整个流程实现了从原始数据处理到可视化分析的全过程。

Tiaoxiaobai的博客 556

移花接木,玩转CANoe的几种扩展接口应用(五)——串口设备

近期看到粉丝朋友在CANoe自动化测试方面的关注度很大,今天就围绕这个做一个专题,总结一下以往项目上用过的几种CANoe扩展接口,分享出来希望对相关领域的网友有所帮助。本文是该专题的第五篇文章,主要讲解了串口设备的功能配置、连接方法、配置方法、调用方法,最后分析了这种扩展借口应用的特点和适用场景。

Mr.Cssust的博客 2371

Rust Trait系统模式:实现多态与代码复用

Trait是Rust中定义共享行为的机制,类似于其他语言中的接口或抽象类。println!Rust的Trait系统是实现多态和代码复用的核心机制。Trait定义:定义共享行为的接口默认实现:提供默认方法实现Trait对象:实现动态多态Trait约束:约束泛型类型Trait继承:扩展现有Trait标准库Trait:Debug、Clone、PartialEq等设计模式:Adapter、Strategy模式实战案例:通用数据处理器。

no1coder的博客 4239

2026年GESP3月认证C++五级真题解析

因为要合并成升序数组,所以当A[i]小于等于B[j]时,取A[i],否则取B[j]。当a[i]>a[j]时,左边数组中从i到m的所有元素都大于a[j],因此逆序对数量增加m-i+1。给定一个包含n个互不相同的正整数的数组A与一个包含m个互不相同的正整数的数组B,请你帮忙计算有多少个数在数组A与数组B中均出现。下面代码实现两个整数除法,其中被除数为一个“大整数”,用字符串表示,除数是一个小整数,用int表示,则横线处应该填写()。且a[i] > a[j],则a[i]和a[j]是一个逆序对。

lan_in的博客 120

Rust Trait 敲黑板

Rust Trait 是构建类型安全、高可复用代码的核心工具,通过行为抽象实现多态,配合泛型、关联类型等特性,兼顾灵活性与性能

码刀攻城 1253

具身智能中的(VLA)算法与实践——第一讲 基础与概览

本文介绍了视觉-语言-动作(VLA)模型的基础概念及其在AI领域的重要性。VLA模型通过融合多模态数据实现具身智能,使AI系统能感知环境并执行物理动作。文章探讨了大型语言模型(LLMs)和视觉语言模型(VLMs)如何赋能具身智能,包括指令解析、场景理解和动作规划。同时提供了Python、PyTorch/TensorFlow开发环境的详细搭建指南,包含GPU配置建议和测试代码。VLA模型在机器人操作、导航、人机协作等领域具有广泛应用前景,是实现通用人工智能的关键技术。

u012133341的博客 1599

OPTEE v4.4.0 qemu_v8环境搭建(支持Hafnium)

一、前提条件 二、拉取代码 三、下载工具链 四、修改代码 五、编译 六、运行

AI-安全-功耗 893

Rust:Trait 抽象与 unsafe 底层掌控力的深度实践

Rust:Trait 抽象与 unsafe 底层掌控力的深度实践

啊Q老师 2214

SoC 内的 CPU、GPU、DSP、NPU 协同执行结构图解析:多异构协同的最新实战体系

随着移动端 AI 能力迅速演进,SoC(System on Chip)内部的多种异构计算单元(CPU、GPU、DSP、NPU)之间的协同执行能力成为衡量芯片智能算力的关键指标。本文基于截至 2025 年 5 月最新主流国产芯片(如海思昇腾、地平线旭日、联发科天玑、高通骁龙 8 Gen 系、寒武纪思元等)在实际落地应用中的公开结构与技术资料,深入解析 CPU-GPU-DSP-NPU 协同执行的体系结构、执行路径与调度逻辑。文章结合 Android NNAPI、Vulkan Compute、自定义调度器等工程实

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 8712

ncspot API封装:Rust trait设计模式解析

你是否在构建跨平台应用时,为不同数据类型的统一操作而烦恼?是否在设计API时,既想保证接口一致性,又要保留类型特异性而头疼?ncspot——这款用Rust编写的跨平台ncurses Spotify客户端,通过精妙的trait设计模式,为我们展示了如何优雅解决这些问题。本文将深入剖析ncspot的API封装架构,带你掌握Rust trait的高级应用技巧,学会构建既灵活又健壮的接口系统。 读完本文...

gitblog_00954的博客 632

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Rust Trait 定义与实现:类型系统的多态基石

摘要:本文深入探讨了Rust语言中Trait的核心机制与应用。Trait作为Rust类型系统的核心抽象,定义了类型行为契约,支持默认实现、关联类型等高级特性。文章详细分析了Trait的核心概念、边界约束与泛型应用,介绍了标准库中关键Trait的作用。特别探讨了Trait实现的一致性规则(孤儿规则)及其解决方案(新类型模式)。最后通过构建序列化框架的实践案例,展示了Trait在实现序列化/反序列化、上下文配置等复杂功能时的综合应用,体现了Rust零成本抽象的设计理念。

超哥的博客 708

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Rust trait定义与实现:类型系统的契约机制

摘要:Rust的trait机制是类型系统的核心,它通过契约式设计将静态安全与运行时多态有机结合。trait支持默认实现、关联类型和泛型约束,并通过孤儿规则确保实现唯一性。高级应用包括动态分发的trait对象、where子句约束和标记trait。工程实践中需要权衡trait粒度与性能考量,单态化可能带来二进制膨胀。trait不仅是接口抽象,更是编译器的类型指令系统,能帮助开发者构建更安全、高效的软件架构。

Superman_chaoge的博客 1615

Rust语言进阶之关键字:trait用法实例(三十三)

本篇目的:Rust语言进阶之关键字:trait用法实例在Rust语言中,trait是一个关键字,用于定义一组方法的集合,描述了某种行为的抽象。它类似于其他编程语言中的接口(如Java的接口或C++的抽象基类),用于约束类型必须实现的功能。trait是Rust语言类型系统的重要组成部分,通过它可以实现多态、代码复用以及抽象设计。以下是trait的关键概念和特性:定义与作用trait的核心功能是定义一组方法,这些方法可能有默认实现,也可以是没有实现的抽象方法。任何实现了该trait。

Android系统攻城狮 1229

Rust Trait 系统的灵活应用

Rust语言以其安全性和高性能著称,而Trait系统则是其类型系统的核心之一。Trait不仅定义了类型的行为,还通过零成本抽象实现了高度的灵活性。无论是实现多态、代码复用,还是构建泛型系统,Trait都扮演着关键角色。本文将探讨Rust Trait系统的几种灵活应用场景,帮助开发者更好地利用这一强大工具。Rust通过Trait实现多态,既支持静态分发(编译期确定),也支持动态分发(运行期确定)。例如,使用`dyn Trait`可以实现运行时的动态分发,适用于需要灵活处理多种类型的场景。

glhyqq_960的博客 215

Golang 接口 vs Rust Trait:一场关于抽象的哲学对话

项目Golang 接口Rust Trait适用人群后端服务开发、云原生、DevOps系统编程、嵌入式、高性能计算抽象粒度方法级类型级控制权更灵活更严谨学习难度中等偏低中等偏高推荐场景快速构建服务、微服务架构高性能、高安全性要求的系统Go 的接口是组合文化的象征,鼓励程序员写出清晰、简单的代码;Rust 的 Trait 是抽象能力的极致体现,鼓励程序员写出安全、高效的代码。没有绝对的“更好”,只有“更合适”。选择哪种机制,取决于你的项目需求、团队背景以及长期维护目标。📌。

muyouking 1660

Rust Trait 泛型协作与多态实现

Rust的Trait本质是一组方法签名的集合,通过为不同类型实现相同Trait来达成多态。这种显式的接口约束比传统面向对象的继承更灵活,支持跨类型的行为共享,同时避免继承带来的耦合问题。编译器会严格检查Trait实现的完整性,确保类型系统安全。Rust语言以其独特的所有权系统和零成本抽象著称,而Trait与泛型的协作机制正是实现多态与代码复用的核心武器。本文将深入探讨这一设计如何通过编译期静态分发,在保证性能的同时实现灵活的类型抽象,为开发者提供兼具安全性与表现力的编程范式。Trait定义行为契约。

ztepqr_061的博客 227

Rust Trait机制解析:从基础概念到高级应用

Trait是编程语言中实现多态和代码复用的核心机制,它通过定义抽象行为接口实现了类型系统的扩展性。在Rust语言中,Trait系统采用零成本抽象设计,既支持静态分发的编译期多态,也提供动态分发的运行时灵活性。从原理上看,Traits通过方法签名集合定义契约,实现类型可以按需组合不同Traits的能力。这种设计在图形渲染、插件系统等场景展现强大优势,如标准库中的Iterator和Display Traits就是典型应用。通过关联类型、条件实现等高级特性,Traits还能构建复杂的泛型系统。掌握Trait设计原

weixin_30520015的博客 297

Rust Trait 泛型的高级实现模式

更进一步,通过nightly特性specialization,允许同一Trait针对不同泛型参数提供不同实现,解决重叠实例问题,但需注意稳定性限制。例如,在构建迭代器时,通过关联类型Item替代泛型参数,可避免重复声明类型,同时保留类型关联性。这种模式特别适合需要固定类型关系的场景,如自定义集合的迭代器实现,既能简化签名,又能保证类型安全。对于进阶开发者而言,掌握Trait泛型的高级模式能显著提升代码的复用性与表现力。本文将深入探讨三种典型的高级实现模式,帮助读者突破常规用法,解锁更强大的设计能力。

zmfmsi_414的博客 199

Rust开发之Trait作为参数与返回值使用

首先定义一个表示“可绘制对象”的Drawabledraw():用于在屏幕上绘制图形;area():计算并返回图形面积。在本案例中,我们系统地学习了如何将 Trait 用作函数参数与返回值,这是构建可扩展、模块化 Rust 系统的关键技能之一。

风中追风 478

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 159
上一篇: Rust异步编程实战:构建高性能并发应用
下一篇: Python asyncio深入解析:从事件循环到协程调度
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值