二十一、Rust 反射 获取类型

不同于 java 中的反射，Rust 没有提供以往意义上的运行时反射，取而代之的是 "编译期反射"，如 类型分析、类型转换、类型签名。但即便如此，也已经能对 Rust元编程 提供很多助力了。

这种操作，主要通过 Any 来实现，Rust 中提供了 Any Trait，所有类型（含自定义类型）都自动实现了该特征；因此，通过它我们可以进行一些类似反射的功能；

实际上，在 Rust 早期版本中是提供了 Reflection 的，但是在 14年移除了相关代码，原因是：

1. 反射打破了原有的封装原则，能任意访问结构体内容，不安全；
2. 反射的存在使得代码过于臃肿，移除后编译器可以简化很多；
3. 反射功能设计的比较弱，开发者对于是否在未来的版本中还拥有反射功能存疑；

另一篇 关于Rust为何不引入 Runtime Reflection ，大致信息如下：

1. 不一定非要使用反射来实现， Rust中可以有更好的实现：
2. 派生宏和Trait之间的配合，可以将实现从运行时转移到编译时；
   例如，利用过程宏实现编译时反射，以实现依赖注入等功能 - https://github.com/dtolnay/reflect

至于保留 Any 的原因：

1. 在调试范型类型相关代码时，有TypeId会更方便，更容易给出正确的错误提示；
2. 有利于编译器作出代码的优化；

Any源码简读

参看Any源码文档：

作为 &dyn Any (借用的 trait 对象)，具有 is 和 downcast_ref 方法，可测试值是否为给定类型，并对类型的内部值进行引用；作为 &mut dyn Any，还有 downcast_mut 方法，用于获取内部值的 "可变引用" ；

Box<dyn Any> 具有 downcast 方法，该方法尝试转换为 Box<T>；也有称 "类型具象化"。但需注意，&dyn Any 仅限于测试值是否为具体的类型，而不能用于测试类型是否实现了 Trait；

总结就是 std::any 起到的作用有4个：

1. 获得变量的类型 a.type_id()；
2. 判断变量是否是指定的具体类型 a.is::<String>() 或 TypeId::of::<String>() == a.type_id()；
3. 把any转换成指定类型 a.downcast_ref::<String>()；
4. 获取类型的名字 (_: &T) -> String { std::any::type_name::<T>().to_string() }；

下面看一段 Any Trait 部分核心源码，可帮助更好理解 Any：

pub trait Any: 'static {
    fn type_id(&self) -> TypeId;
}

// 获得变量的类型TypeId
// 为所有的T实现了Any
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: 'static + ?Sized> Any for T {
    fn type_id(&self) -> TypeId { TypeId::of::<T>() }
}

// 判断变量是否是指定类型
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is<T: Any>(&self) -> bool {
    // Get `TypeId` of the type this function is instantiated with.
    let t = TypeId::of::<T>();

    // Get `TypeId` of the type in the trait object.
    let concrete = self.type_id();

    // Compare both `TypeId`s on equality.
    t == concrete
}


// 把any转换成指定类型
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
    if self.is::<T>() {
        // SAFETY: just checked whether we are pointing to the correct type
        unsafe {
            Some(&*(self as *const dyn Any as *const T))
        }
    } else {
        None
    }
}

// 获取类型名字
pub const fn type_name<T: ?Sized>() -> &'static str {
    intrinsics::type_name::<T>()
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct TypeId {
    t: u64,
}

补充说明：

1. Rust 中，所有拥有静态生命周期的类型都会实现Any，未来可能会考虑加入生命周期是非'static的情况；

2. Rust 中，所有类型都有一个全局唯一的标识 TypeId（A TypeId represents a globally unique identifier for a type）；

3. 这些 TypeId 都是通过调用 intrinsic 模块中定义的函数创建的，即 TypeId 的生成是由编译器的实现来决定的！

关于intrinsic 模块：

intrinsic 库函数是指：由编译器内置实现的函数，一般是具有如下特点的函数：

• 与CPU架构相关性很大，必须利用汇编实现或者利用汇编才能具备最高性能的函数；
• 和编译器密切相关的函数，由编译器来实现最为合适；
• 具体实现 - https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs

Any基本使用

• examples/main.rs

use std::any::{Any, TypeId};

struct Person {
    pub name: String,
}

/// 判断是否为指定类型-1
fn is_string(s: &dyn Any) -> bool {
    TypeId::of::<String>() == s.type_id() // 获取TypeId
}

/// 判断是否为指定类型-2
fn check_string(s: &dyn Any) {
    if s.is::<String>() {
        println!("It's a string!");
    } else {
        println!("Not a string...");
    }
}

/// 转换Any为特定类型
fn print_if_string(s: &dyn Any) {
    if let Some(ss) = s.downcast_ref::<String>() {
        println!("It's a string({}): '{}'", ss.len(), ss);
    } else {
        println!("Not a string...");
    }
}

/// 获取类型的名字
/// 但需注意, 此方式获取的名字不唯一
///    如 type_name::<Option<String>> 可能返回 Option<String> 或 std::option::Option<std::string::String>
/// 同时, 编译器版本不同、可能返回值不同
fn get_type_name<T>(_: &T) -> String {
    std::any::type_name::<T>().to_string()
}

fn main() {
    let p = Person { name: "John".to_string() };
    assert!(!is_string(&p));
    assert!(is_string(&p.name));

    check_string(&p);
    check_string(&p.name);

    print_if_string(&p);
    print_if_string(&p.name);

    println!("Type name of p: {}", get_type_name(&p));
    println!("Type name of p.name: {}", get_type_name(&p.name));
}

• 输出如下

Not a string...
It's a string!
Not a string...
It's a string(4): 'John'
Type name of p: 0_any::Person
Type name of p.name: alloc::string::String

Any适用场景

Rust 中的 Any 类似于 Java 中的 Object，可以传入任何拥有静态生命周期的类型；因此，当入参类型复杂，但后续又没有更多功能性操作时，就可以简化入参。例如，打印任何类型的值。

• examples/1_print_any.rs

use std::any::Any;
use std::fmt::Debug;

#[derive(Debug)]
struct MyType {
    name: String,
    age: u32,
}

fn print_any<T: Any + Debug>(value: &T) {
    let value_any = value as &dyn Any;

    if let Some(string) = value_any.downcast_ref::<String>() {
        println!("String ({}): {}", string.len(), string);
    } else if let Some(MyType { name, age }) = value_any.downcast_ref::<MyType>() {
        println!("MyType ({}, {})", name, age)
    } else {
        println!("{:?}", value)
    }
}

fn main() {
    let ty = MyType {
        name: "Rust".to_string(),
        age: 30,
    };
    let name = String::from("Rust");

    print_any(&ty);
    print_any(&name);
    print_any(&30);
}

• 运行后输出

MyType (Rust, 30)
String (4): Rust
30

如上所示，不论 String、MyType 自定义类型、还是内置的 i32 类型，都可以被打印，只要他们实现了 Debug Trait；这也可以认为是Rust 中、一种函数重载的方式，在读取一些结构复杂的配置时，也可以直接使用 Any。

最后总结

Any Trait 并非常规意义上的 Reflection，而最多是编译期反射、且只启用了 "类型检查" 和 "类型转换"，并不检查结构的任意内容。

Any 符合零成本抽象，因为Rust只会针对调用该函数的相关类型生成代码，并且返回的是编译器内部的类型ID，没有额外开销；甚至可以直接使用 TypeId::of::<String>，从而没有了 dyn any 的动态绑定开销。

虽然 Rust 没有真正的 运行时 Reflection，但使用过程宏、仍可以实现大部分反射能够实现的功能，如上一节的 AOP 增强 ！！

就这样，bye bye ～

参考资料

• https://www.jianshu.com/p/c4ef17bb1ca3
• https://rust.ffactory.org/std/any/index.html
• https://jasonkayzk.github.io/2022/11/24/Rust反射之Any/