以下是基于您提供内容的完整示例demo，包含所有关键部分的实现：

// 完整示例demo展示prost-codec的完整使用流程

// 1. Cargo.toml依赖配置
/*
[dependencies]
prost = "0.11"
prost-codec = "0.3"
prost-derive = "0.11"
bytes = "1.0"
tokio-util = { version = "0.7", features = ["codec"] }
*/

// 2. 构建脚本 build.rs
/*
fn main() {
    prost_build::compile_protos(&["src/person.proto"], &["src/"]).unwrap();
}
*/

// 3. Protobuf定义 person.proto
/*
syntax = "proto3";

message Person {
    string name = 1;
    int32 id = 2;
    string email = 3;
}
*/

use prost_codec::{Codec, Config};
use prost::Message;
use bytes::{Bytes, BytesMut};
use tokio_util::codec::Decoder;

// 从protobuf生成的Person结构体(实际应由prost-build生成)
#[derive(Clone, PartialEq, Message)]
pub struct Person {
    #[prost(string, tag="1")]
    pub name: String,
    #[prost(int32, tag="2")]
    pub id: i32,
    #[prost(string, tag="3")]
    pub email: String,
}

fn main() {
    // 基本使用示例
    basic_usage();
    
    // 高级功能示例
    advanced_features();
    
    // 性能对比示例
    performance_comparison();
}

fn basic_usage() {
    println!("=== 基本使用示例 ===");
    
    // 创建Person实例
    let person = Person {
        name: "张三".to_string(),
        id: 1001,
        email: "zhangsan@example.com".to_string(),
    };
    
    // 初始化默认编解码器
    let codec = Codec::<Person>::default();
    
    // 序列化
    let mut buf = Vec::new();
    codec.encode(&person, &mut buf).unwrap();
    println!("序列化后的数据 ({} bytes): {:?}", buf.len(), buf);
    
    // 反序列化
    let decoded = codec.decode(&buf).unwrap();
    println!("反序列化结果: {:?}", decoded);
}

fn advanced_features() {
    println!("\n=== 高级功能示例 ===");
    
    // 1. 零拷贝反序列化
    let person = Person {
        name: "李四".to_string(),
        id: 1002,
        email: "lisi@example.com".to_string(),
    };
    
    let mut buf = Vec::new();
    let codec = Codec::<Person>::default();
    codec.encode(&person, &mut buf).unwrap();
    
    // 转换为Bytes实现零拷贝
    let bytes = Bytes::from(buf);
    let decoded = codec.decode(bytes).unwrap();
    println!("零拷贝反序列化结果: {:?}", decoded);
    
    // 2. 流式处理
    let mut stream_codec = Codec::<Person>::default();
    let mut buffer = BytesMut::new();
    
    // 模拟分块数据
    let data1 = vec![0x0a, 0x03, 0x41, 0x6c, 0x69]; // 部分数据
    let data2 = vec![0x63, 0x65, 0x10, 0xd2, 0x07]; // 剩余数据
    
    buffer.extend_from_slice(&data1);
    if let Ok(Some(p)) = stream_codec.decode_eof(&mut buffer) {
        println!("流式处理-部分数据: {:?}", p);
    }
    
    buffer.extend_from_slice(&data2);
    while let Ok(Some(p)) = stream_codec.decode_eof(&mut buffer) {
        println!("流式处理-完整数据: {:?}", p);
    }
    
    // 3. 自定义配置
    let config = Config::new()
        .set_max_message_size(1024 * 1024)  // 1MB最大消息
        .set_recursion_limit(100);          // 递归限制
    
    let custom_codec = Codec::<Person>::with_config(config);
    println!("自定义配置编解码器创建成功");
}

fn performance_comparison() {
    println!("\n=== 性能对比示例 ===");
    
    // 创建大对象
    let person = Person {
        name: "王".repeat(10000),
        id: 1003,
        email: "wang@example.com".repeat(100),
    };
    
    // prost标准实现
    use std::time::Instant;
    
    let start = Instant::now();
    let mut buf = Vec::new();
    person.encode(&mut buf).unwrap();
    let prost_time = start.elapsed();
    
    // prost-codec实现
    let start = Instant::now();
    let mut buf = Vec::new();
    let codec = Codec::<Person>::default();
    codec.encode(&person, &mut buf).unwrap();
    let prost_codec_time = start.elapsed();
    
    println!("prost 编码时间: {:?}", prost_time);
    println!("prost-codec 编码时间: {:?}", prost_codec_time);
    println!("性能提升: {:.2}%", 
        (prost_time.as_secs_f64() - prost_codec_time.as_secs_f64()) / 
        prost_time.as_secs_f64() * 100.0);
}

这个完整示例包含了以下关键部分：

1. 基本使用流程：从消息定义到编解码

2. 高级功能实现：

   • 零拷贝反序列化使用Bytes类型
   • 流式处理使用decode_eof方法
   • 自定义配置编解码器

3. 性能对比测试：展示prost和prost-codec的实际性能差异

4. 完整项目结构：包含Cargo.toml配置和build.rs构建脚本

5. 中文注释和输出：符合您要求的中文化处理

要运行这个示例，您需要：

1. 创建Rust项目
2. 添加所需的依赖项
3. 创建person.proto文件
4. 配置build.rs
5. 将示例代码复制到main.rs