在功能开发中，动态创建或获取某个对象的情况很多。在前端JS开发中，可以使用工厂函数，通过给定的类型标识创建不同的对象实例；还可以通过对象映射来实现动态创建对象。

在Rust中，我们也可以使用这两种方式去创建对象实例，但实现书写的方式可能略有不同；rust还可以通过序列化JSON数据时进行枚举类型匹配。

我们定义好需要测试的数据结构体、方法。小狗、小猫有自己的字段、方法,它们有相同的字段name,也有相同的方法say。

use serde_derive::{Deserialize, Serialize};#[derive(Deserialize, Serialize, Debug)]
struct Dog {name: String,work: String,
}
impl Dog {fn new(name: String, work: String) -> Dog {Dog { name, work }}fn say(&self) {println!("{} say wangwang", self.name);}
}#[derive(Deserialize, Serialize, Debug)]
struct Cat {name: String,age: i32,
}impl Cat {fn new(name: String) -> Cat {Cat { name: name, age: 0 }}fn say(&self) {println!("{} say miamiamia", self.name);}
}

序列化serde

我们在拿到JSON格式数据进行序列化时，在rust中是需要确定具体数据类型的，但是我们并不知道具体类型，因为现在有两种类型，要合为一种类型，就需要归集，使用枚举enum来定义可能的类型：

#[derive(Deserialize, Serialize, Debug)]
#[serde(untagged)]
enum Animal {Dog(Dog),Cat(Cat),
}

对于JSON格式和rust 结构体的互相转换，可以使用serde库。也正好利用JSON转结构体这一过程，利用转换机制来实现动态创建对象。

安装相关的库:

cargo add serde serde_derive serde_json

我们定义一个JSON格式数据，使用serde库进行反序列化，并使用match进行匹配：

fn main() {let data = r#"{"name":"admin","age":2}"#;let animal = serde_json::from_str(data).unwrap();match animal {Animal::Dog(dog) => {dog.say();}Animal::Cat(cat) => {cat.say();}};
}

测试运行，正常输出了cat say wangwang。我们修改JSON格式数据

let data = r#"
{"name":"admin","work":"play"
}
"#;

测试运行，正常输出了dog say wangwang，说明没有逻辑没有问题。

待优化的地方在于我们使用了match,如果我们需要在多个地方使用animal,那么这段匹配逻辑就无处不在了。当有很多方法时，无法控制具体调用哪个方法，就需要不停的去匹配。

我们可以将它们需要调用公共方法在枚举类型Animal定义一下，内部逻辑根据不同类型在调用各自的方法。

impl Animal {fn say(&self) {match self {Animal::Cat(cat) => cat.say(),Animal::Dog(dog) => dog.say(),}}
}

为Animal定义公共方法say，然后在序列化JSON数据格式时，我们必须要指定数据类型：

fn main() {let data = r#"{"name":"admin","age":2,"work":"play"}"#;let animal: Animal = serde_json::from_str(data).unwrap();animal.say();
}

明确指定了animal: Animal，因为没有其他逻辑帮助rust推断出具体的类型是什么。也可以这么写let animal = serde_json::from_str::<Animal>(data).unwrap();

注意

需要注意的是：匹配的不同对象结构体的字段不能一致，否则会匹配到枚举的第一个；如果出现包含的情况，我们需要把被包含的结构体放在前面。

比如小猫也有work字段了：

#[derive(Deserialize, Serialize, Debug)]
struct Cat {name: String,age: i32,work: String,
}

这是我们再去匹配JSON格式数据,因为数据里有age，我们希望的是匹配小猫Cat,但是它里面完全包含了小狗的字段Dog,而且枚举Animal种小狗在前，所以会直接匹配小狗：

let data = r#"
{"name":"admin","age":2,"work":"play"
}
"#;

这样达不到我们想要的结果，所以需要注意调整枚举值的顺序，可以将复杂数据结构放到前面。将Cat放到前面就可以正常工作了。

#[derive(Deserialize, Serialize, Debug)]
#[serde(untagged)]
enum Animal {Cat(Cat)Dog(Dog),
}

动态类型匹配

上一个方式是我们拿到了具体对象的JSON数据，然后通过序列化，获取到对应的对象实例。如果我们只知道某个类型，需要根据类型初始化具体实例对象。

我们枚举实例对象的类型，定义字符串转枚举类型的方法：

#[derive(Deserialize, Serialize, Debug)]
#[serde(untagged)]
enum AnimalType {Dog,Cat
}
impl AnimalType {fn str_to_animal_type(str: &str) -> AnimalType {match str {"dog" => AnimalType::Dog,"cat" => AnimalType::Cat,_ => panic!("unknown type"),}}
}

调用AnimalType获取到枚举类型，然后通过匹配类型来实例化对象，这跟上面的序列化JSON格式后续处理方式一致。

fn main() {let names = "dog";match AnimalType::str_to_animal_type(names) {AnimalType::Dog => {let dog = Dog {name: "admin".to_string(),work: "play".to_string(),};dog.say();}AnimalType::Cat => {let cat = Cat {name: "admin".to_string(),age: 2,work: "play".to_string(),};cat.say();}}
}

Trait 特质

trait是rust中特有的类型，它可以定义对象的行为，然后可以被其他对象实现。实现它的对象可以拥有相同的行为，但是可以拥有不同的内部逻辑。

这可以保证我们在动态获取到不同的对象实例，调用它们的方法时保证方法存在。在创建动态对象时，因为不知掉具体大小，需要使用Box<dyn Trait>定义动态对象。

trait AnimalTrait {fn say(&self);
}

然后在各个类型中实现AnimalTrait，并实现公共方法say。

impl AnimalTrait for Dog {fn say(&self) {println!("{} say wangwang", self.name);}
}impl AnimalTrait for Cat {fn say(&self) {println!("{} say miamiamia", self.name);}
}

定义类型都实现AnimalTrait的方法，就可以放心的使用Box<dyn AnimalTrait>提供的动态对象了。

impl AnimalType {fn str_to_animal(str: &str) -> Box<dyn AnimalTrait> {match str {"dog" => Box::new(Dog::new("admin".to_string(), "play".to_string())),"cat" => Box::new(Cat::new("test".to_string())),_ => panic!("unknown type"),}}
}

方法str_to_animal通过类型匹配获取到对应的实例对象，现在我们不需要再匹配里直接调用方法了。我们拿到动态对象，想调用那个方法就用哪个。

fn main() {let names = "dog";let animal = AnimalType::str_to_animal(names);animal.say();
}

这样就很方便的进行动态对象的传递，我们不需要关心该调用哪个方法，是否需要导入指定的方法。rust通过Box<dyn AnimalTrait>会自动调用合适的实现。

From/Into 类型强转

我们定义了AnimalTrait规范了动态对象的行为，它们在实现了AnimalTrait后，就可以根据动态对象调用它的公共方法了。

但在根据类型创建动态对象时，仍然定义了枚举AnimalType的方法str_to_animal并调用从而匹配到对应的动态对象。

我们还可以使用Fromtrait，通过让AnimalTrait实现Fromtrait，从而直接使用into方法让字符串类型转为动态对象。

impl From<&str> for Box<dyn AnimalTrait> {fn from(value: &str) -> Self {match value {"dog" => Box::new(Dog::new("admin".to_string(), "play".to_string())),"cat" => Box::new(Cat::new("test".to_string())),_ => panic!("unknown type"),}}
}

这样的实现可以减少在创建动态对象时的显示函数调用，我们在使用的时候直接调用into()方法即可：

fn main{let dog: Box<dyn AnimalTrait> = "dog".into();dog.say();
}

HashMap映射类型

以上实现方案难免都使用了match进行匹配，而我们在之前说的映射对象的实现，则可以避免match的匹配。

通过HashMap初始化类型映射结构体对象，在使用时通过自定义方法get传入指定的类型，得到动态类型。

struct AnimalFactory {map: HashMap<String, Box<dyn Fn() -> Box<dyn AnimalTrait>>>,
}

我们定义了一个结构体AnimalFactory，其中包含一个HashMap类型的字段map，用于存储类型与创建函数的映射关系。

注意到HashMap的值是一个闭包函数而不是直接动态类型，如果直接定义HashMap<String, Box<dyn AnimalTrait>>,我们在初始化时就必须实例化创建对象实例，这就导致具体对象的实例只有一个而避免不了处理所有权的问题。如果我们需要传递所有权，就必须使用Arc了。

定义了工厂结构体AnimalFactory,定义初始化函数new:

impl AnimalFactory {fn new() -> Self {map.insert("dog".to_string(),Box::new(|| {Box::new(Dog::new("admin".to_string(), "play".to_string())) as Box<dyn AnimalTrait>}) as Box<dyn Fn() -> Box<dyn AnimalTrait>>,);map.insert("cat".to_string(),Box::new(|| Box::new(Cat::new("test".to_string()))),);AnimalFactory { map }}
}

由于HashMap需要定义具体的类型，我们在插入类型Dog时无法匹配定义的Box<dyn Fn() -> Box<dyn AnimalTrait>>导致报错,这就需要我们手动强转类型。

为了简化类型书写，我们定义一个类型替代：

type AnimalDynType = Box<dyn Fn() -> Box<dyn AnimalTrait>>;

我们已经初始化了映射表，定义根据具体类型获取动态对象的方法：

impl AnimalFactory {fn get(&self, name: &str) -> Box<dyn AnimalTrait> {match self.map.get(name) {Some(create_fn) => create_fn(),None => panic!("not found"),}}
}

在使用时，首先创建一个AnimalFactory对象，然后调用get方法，传入具体的类型名称，即可获取对应的动态对象。

fn main() {let animal = AnimalFactory::new();let dog = animal.get_animal("dog");dog.say();
}

最后

这几种实现方式都有一定的使用场景，根据实际需求选择合适的方式。

往期关联文章：

rust 集合、错误处理、泛型、Trait、生命周期、包

并发线程间的数据共享