如何在自定义序列化器中复刻serde(with)的行为？

问题背景 #

我编写了一个针对chrono::DateTime<Utc>的自定义序列化模块：

pub mod datetime {
    pub fn serialize<S: Serializer>(
        date: &DateTime<Utc>,
        serializer: S,
    ) -> Result<S::Ok, S::Error> {
        // ...
    }

    // 反序列化代码省略
}

需要为结构体Foo手动实现自定义序列化逻辑，复刻字段上#[serde(with = "datetime")]属性的效果，预期的自动派生代码如下：

#[derive(Serialize, Deserialize)]
struct Foo {
    #[serde(with = "datetime")]
    pub timestamp: DateTime<Utc>,
}

我的尝试代码如下：

impl Serialize for Foo {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut m = serializer.serialize_map(None)?;
        m.serialize_entry(
            "timestamp",
            &datetime::serialize(&self.timestamp, serializer)?,
        )?;
        m.end()
    }
}

运行后触发编译错误：

error[E0277]: the trait bound `<S as foo::_::_serde::Serializer>::Ok: Serialize` is not satisfied
    --> <...>/foo.rs:95:13
     |
93   |         m.serialize_entry(
     |           --------------- required by a bound introduced by this call
94   |             "timestamp",
95   |             &datetime::serialize(&self.sent_timestamp, serializer)?,
     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Serialize` is not implemented for `<S as foo::_::_serde::Serializer>::Ok`
     |
note: required by a bound in `serialize_entry`
    --> ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/serde-1.0.193/src/ser/mod.rs:1808:12
     |
1801 |     fn serialize_entry<K: ?Sized, V: ?Sized>(
     |        --------------- required by a bound in this associated function
...
1808 |         V: Serialize,
     |            ^^^^^^^^^ required by this bound in `SerializeMap::serialize_entry`
help: consider further restricting the associated type
     |
86   |     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> where <S as foo::_::_serde::Serializer>::Ok: Serialize {
     |

我是否误解了Serializer的用法？不确定问题出在哪里。

问题分析与解决 #

你的错误核心是对Serde序列化流程的理解偏差：

1. datetime::serialize的作用：这个函数会直接消耗传入的Serializer，完成序列化后返回该Serializer的最终输出类型S::Ok——它不是生成一个可被再次序列化的中间值，而是直接完成序列化操作。
2. 错误的调用方式：你把原本用于创建map的serializer传给了datetime::serialize，导致后续无法再用这个Serializer处理map的收尾；同时serialize_entry要求第二个参数是实现Serialize的类型，你传入的S::Ok显然不满足这个约束。

正确的实现方式是，先为map写入key，再获取字段对应的子序列化器，传给自定义序列化函数：

impl Serialize for Foo {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serializer.serialize_map(None)?;
        // 先写入字段名
        map.serialize_key("timestamp")?;
        // 获取字段对应的子序列化器，传给自定义序列化函数
        datetime::serialize(&self.timestamp, map.serialize_value()?)?;
        // 完成map序列化
        map.end()
    }
}

或者，也可以借助serde::Serialize的serialize_with方法来简化逻辑，但本质和上面的代码一致：都是让自定义序列化函数直接操作字段对应的子序列化器，而不是尝试复用顶层Serializer或序列化已完成的结果。

简单来说，你之前的错误是把“序列化函数的输出结果”当成了“需要被序列化的值”，而正确逻辑是让自定义序列化函数直接参与到map字段的序列化流程中。

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