如何在Rust中通过Trait实现符合预定义API的对象组合？

我想实现让符合预定义API的不同对象可以组合，尝试用Trait嵌套的方式但没成功。请问这种实现方式在Rust中是否可行？

我的Rust尝试代码（编译报错） #

pub trait XAPI {
    fn new(y: YAPI) -> Self;
}

pub trait YAPI {
    fn new() -> Self;
}

pub struct X {
}

pub struct Y {
}

impl YAPI for Y{
    fn new() -> Self {
        Y {}
    }
}
impl XAPI for X{
    fn new(y: YAPI) -> Self {
        X {}
    }
}

Java中的实现示例（可正常运行） #

/* Online Java Compiler and Editor */
interface PocketAPI {}

class Pocket implements PocketAPI {}

interface JacketAPI {}

class Jacket implements JacketAPI {

  public Jacket(PocketAPI labelStore) {}
}

public class Main {
  public static void main(String[] args) {
    System.out.println("!!!");

    PocketAPI pocket = new Pocket();

    JacketAPI jacket = new Jacket(pocket);
  }
}

在Rust里，直接把Trait作为函数参数的写法（比如fn new(y: YAPI)）是行不通的——因为Trait本身属于动态大小类型(DST)，无法直接作为参数传递。要实现类似Java接口的组合效果，有两种常用方案：

方案一：泛型约束（静态分发） #

通过泛型参数限定传入类型必须实现目标Trait，这种方式是编译时静态分发，无运行时开销，适合不需要动态切换类型的场景：

pub trait XAPI {
    // 用泛型Y约束为YAPI的实现者
    fn new<Y: YAPI>(y: Y) -> Self;
}

pub trait YAPI {
    fn new() -> Self;
}

pub struct X {}
pub struct Y {}

impl YAPI for Y {
    fn new() -> Self {
        Y {}
    }
}

impl XAPI for X {
    fn new<Y: YAPI>(_y: Y) -> Self {
        X {}
    }
}

// 使用示例
fn main() {
    let y = Y::new();
    let x = X::new(y);
}

方案二：Trait Object（动态分发） #

如果需要运行时多态（比如要存储不同YAPI实现者的实例），可以用Box<dyn YAPI>或&dyn YAPI包裹Trait对象，对应Java里的接口多态逻辑：

pub trait XAPI {
    // 使用Box包裹Trait Object
    fn new(y: Box<dyn YAPI>) -> Self;
}

pub trait YAPI {
    fn new() -> Self;
}

pub struct X {}
pub struct Y {}

impl YAPI for Y {
    fn new() -> Self {
        Y {}
    }
}

impl XAPI for X {
    fn new(_y: Box<dyn YAPI>) -> Self {
        X {}
    }
}

// 使用示例
fn main() {
    let y = Box::new(Y::new());
    let x = X::new(y);
}

方案对比 #

• 泛型约束：编译期确定具体类型，性能最优，但无法在运行时动态替换不同的Trait实现。
• Trait Object：支持运行时动态切换实现类型，有轻微的虚表调用开销，灵活性更高，但要求Trait满足对象安全（比如不能有返回Self的方法，除非调整设计）。

内容的提问来源于stack exchange，提问作者cpchung