我要评论在功能开发中，动态创建或获取某个对象的情况很多。在前端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中实例化动态对象的示例详解的文章就介绍到这了,更多相关rust实例化动态对象内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论