Rust中避免同步trait及其异步版本重复代码的最佳实践

针对同步std::io、异步futures::io双trait实现重复的问题，最直接可行的方案是通过声明宏自动生成两套实现，仅在IO调用点按需添加async关键字和.await后缀，核心协议逻辑只需要编写一次。

核心实现复用 #

不需要依赖第三方库，用Rust原生声明宏就可以完成双版本代码生成，示例如下：

/// 统一生成同步/异步ProtoWrite实现的宏
macro_rules! impl_proto_write {
    // 异步版本分支
    (async, $trait:ident, $io_bound:path) => {
        #[async_trait]
        impl<W> $trait for W
        where
            W: $io_bound + Unpin + Send + Sync,
        {
            async fn proto_write<T>(&mut self, value: &T) -> Result<(), ProtocolError>
            where
                T: Serialize + Sync,
            {
                // --- 以下为协议核心逻辑，同步异步完全一致 ---
                let bytes = value.serialize_to_vec()?;
                // 仅IO调用点有差异
                self.write_all(&bytes).await?;
                self.flush().await?;
                // --- 核心逻辑结束 ---
                Ok(())
            }
        }
    };
    // 同步版本分支
    (sync, $trait:ident, $io_bound:path) => {
        impl<W> $trait for W
        where
            W: $io_bound,
        {
            fn proto_write<T>(&mut self, value: &T) -> Result<(), ProtocolError>
            where
                T: Serialize,
            {
                // --- 以下为协议核心逻辑，同步异步完全一致 ---
                let bytes = value.serialize_to_vec()?;
                // 仅IO调用点有差异
                self.write_all(&bytes)?;
                self.flush()?;
                // --- 核心逻辑结束 ---
                Ok(())
            }
        }
    };
}

// 两行代码生成两套实现，不需要重复写逻辑
impl_proto_write!(sync, ProtoWriteExt, std::io::Write);
impl_proto_write!(async, ProtoAsyncWriteExt, futures::io::AsyncWrite);

对应Read trait的实现可以用完全相同的宏模式生成，只需要替换write_all为read_exact等读方法即可。

测试代码复用 #

测试用例的重复逻辑同样可以用宏消除，还可以一次性生成同步、异步、跨版本互操作三类测试用例：

macro_rules! proto_roundtrip_test {
    // 同步测试分支
    (sync, $name:ident) => {
        #[test]
        fn $name() -> Result<(), ProtocolError> {
            let expected = 42;
            let mut buf = Vec::new();
            buf.proto_write(&expected)?;
            let mut read_cursor = std::io::Cursor::new(buf);
            let result: i32 = read_cursor.proto_read()?;
            assert_eq!(expected, result);
            Ok(())
        }
    };
    // 异步测试分支
    (async, $name:ident) => {
        #[tokio::test]
        async fn $name() -> Result<(), ProtocolError> {
            let expected = 42;
            let mut buf = Vec::new();
            let mut write_cursor = futures::io::Cursor::new(&mut buf);
            write_cursor.proto_write(&expected).await?;
            let mut read_cursor = futures::io::Cursor::new(buf);
            let result: i32 = read_cursor.proto_read().await?;
            assert_eq!(expected, result);
            Ok(())
        }
    };
    // 跨版本互操作测试分支：同步写、异步读
    (cross_sync_write_async_read, $name:ident) => {
        #[tokio::test]
        async fn $name() -> Result<(), ProtocolError> {
            let expected = 42;
            let mut buf = Vec::new();
            buf.proto_write(&expected)?;
            let mut read_cursor = futures::io::Cursor::new(buf);
            let result: i32 = read_cursor.proto_read().await?;
            assert_eq!(expected, result);
            Ok(())
        }
    };
}

// 批量生成所有测试用例
proto_roundtrip_test!(sync, transfers_primitive_correctly_sync);
proto_roundtrip_test!(async, transfers_primitive_correctly_async);
proto_roundtrip_test!(cross_sync_write_async_read, cross_sync_write_async_read_works);

方案注意事项 #

• 不要使用「异步实现套阻塞运行器生成同步版本」或者「同步实现套AsyncWrite包装生成异步版本」的方案，这两种方式都会引入额外运行时开销，还容易触发Unpin、线程安全相关的边界bug。
• 如果协议逻辑非常复杂，可以把和IO无关的序列化/反序列化逻辑拆成独立的内部函数，宏里只保留IO调用相关的差异部分，进一步减少重复代码。

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