Struct TranslationConfig 

pub struct TranslationConfig {

    pub source_language: String,
    pub target_language: String,
    pub api_url: String,
    pub enable_cache: bool,
    pub cache_ttl: Duration,
    pub max_cache_entries: usize,
    pub batch_size: usize,
    pub max_retries: usize,
    pub retry_delay_ms: u64,
    pub timeout_seconds: u64,
    pub use_indexing: bool,
    pub min_text_length: usize,
    pub skip_links: bool,
    pub skip_code_blocks: bool,
    pub custom_filters: Vec<String>,
    pub api_key: Option<String>,
    pub user_agent: String,
}

翻译配置结构体

Fields

source_language: String

源语言代码 (ISO 639-1)

target_language: String

目标语言代码 (ISO 639-1)

api_url: String

翻译API的URL地址

enable_cache: bool

是否启用缓存

cache_ttl: Duration

缓存TTL (生存时间)

max_cache_entries: usize

缓存最大条目数

batch_size: usize

批处理大小

max_retries: usize

最大重试次数

retry_delay_ms: u64

重试延迟 (毫秒)

timeout_seconds: u64

请求超时时间 (秒)

use_indexing: bool

是否启用索引标记

min_text_length: usize

最小翻译文本长度

skip_links: bool

是否跳过链接文本

skip_code_blocks: bool

是否跳过代码块

custom_filters: Vec<String>

自定义过滤规则 (正则表达式)

api_key: Option<String>

API认证密钥

user_agent: String

用户代理字符串

Implementations

impl TranslationConfig

pub fn new() -> Self

创建新的配置实例

Examples found in repository

examples/performance_test.rs (line 112)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 HTML翻译库性能测试\n");
    
    let large_html = generate_large_html();
    let dom = parse_html(&large_html);
    
    println!("📊 测试数据:");
    println!("  - HTML大小: {} KB", large_html.len() / 1024);
    println!("  - 包含 ~5000 个文本元素\n");
    
    // 1. DOM遍历性能测试
    println!("🔍 DOM遍历性能对比:");
    
    // 原始递归收集器
    let start = Instant::now();
    let original_collector = TextCollector::new();
    let original_items = original_collector.collect_from_dom(&dom)?;
    let original_time = start.elapsed();
    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
             original_time.as_millis(), original_items.len());
    
    // 优化的迭代收集器
    let start = Instant::now();
    let mut optimized_collector = OptimizedTextCollector::new();
    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
    let optimized_time = start.elapsed();
    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
             optimized_time.as_millis(), optimized_items.len());
    
    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
    
    // 2. 内存管理测试
    println!("💾 内存管理优化:");
    let memory_manager = Arc::new(GlobalMemoryManager::new());
    
    // 测试字符串池效率
    let start = Instant::now();
    let mut test_strings = Vec::new();
    for i in 0..1000 {
        let s = memory_manager.acquire_string(50);
        test_strings.push(format!("Test string {}", i));
    }
    
    for s in test_strings {
        memory_manager.release_string(s);
    }
    let pool_time = start.elapsed();
    
    // 获取内存统计
    let (pool_stats, _) = memory_manager.get_pool_stats();
    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
             pool_stats.small_pool_size,
             pool_stats.large_pool_size, 
             pool_stats.total_capacity / 1024);
    
    // 3. 智能缓存测试
    println!("\n🧠 智能缓存性能:");
    use html_translation_lib::config::TranslationConfig;
    
    let config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://example.com/translate");
    
    let mut cache_manager = SmartCacheManager::new(&config).await?;
    
    let start = Instant::now();
    
    // 模拟缓存操作
    for i in 0..500 {
        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
        let value = format!("translation_{}", i);
        cache_manager.set(&key, value).await?;
    }
    
    // 测试缓存命中
    let mut hits = 0;
    for i in 0..100 {
        let key = format!("text_{}", i);
        if cache_manager.get(&key).await?.is_some() {
            hits += 1;
        }
    }
    
    let cache_time = start.elapsed();
    let cache_stats = cache_manager.stats();
    
    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
    println!("  - 缓存命中数: {} / 100", hits);
    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
    
    // 4. 并发批处理测试
    println!("\n⚡ 并发批处理性能:");
    let batch_config = BatchConfig {
        batch_size: 20,
        max_concurrency: 4,
        timeout_duration: std::time::Duration::from_secs(10),
        ..Default::default()
    };
    
    let batch_processor = ConcurrentBatchProcessor::new(
        batch_config, 
        Arc::clone(&memory_manager)
    );
    
    // 准备测试文本
    let test_texts: Vec<String> = (0..200)
        .map(|i| format!("Test text number {}", i))
        .collect();
    
    let start = Instant::now();
    
    // 提交批处理任务
    let mut task_ids = Vec::new();
    for chunk in test_texts.chunks(50) {
        let task_id = batch_processor.submit_batch(
            chunk.to_vec(), 
            Priority::Normal
        ).await?;
        task_ids.push(task_id);
    }
    
    // 模拟翻译函数
    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
    }
    
    // 处理队列
    let _results = batch_processor.process_queue(mock_translate).await?;
    let batch_time = start.elapsed();
    
    let batch_stats = batch_processor.get_stats().await;
    let queue_status = batch_processor.get_queue_status();
    
    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
    
    // 5. 总结
    println!("\n📈 性能优化总结:");
    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
    println!("  ✅ 内存池管理: 减少 GC 压力");
    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
    println!("\n🎉 所有性能优化测试完成!");
    
    Ok(())
}

examples/basic_translation.rs (line 16)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 104)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn target_language(self, lang: &str) -> Self

设置目标语言

Examples found in repository

examples/performance_test.rs (line 113)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 HTML翻译库性能测试\n");
    
    let large_html = generate_large_html();
    let dom = parse_html(&large_html);
    
    println!("📊 测试数据:");
    println!("  - HTML大小: {} KB", large_html.len() / 1024);
    println!("  - 包含 ~5000 个文本元素\n");
    
    // 1. DOM遍历性能测试
    println!("🔍 DOM遍历性能对比:");
    
    // 原始递归收集器
    let start = Instant::now();
    let original_collector = TextCollector::new();
    let original_items = original_collector.collect_from_dom(&dom)?;
    let original_time = start.elapsed();
    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
             original_time.as_millis(), original_items.len());
    
    // 优化的迭代收集器
    let start = Instant::now();
    let mut optimized_collector = OptimizedTextCollector::new();
    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
    let optimized_time = start.elapsed();
    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
             optimized_time.as_millis(), optimized_items.len());
    
    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
    
    // 2. 内存管理测试
    println!("💾 内存管理优化:");
    let memory_manager = Arc::new(GlobalMemoryManager::new());
    
    // 测试字符串池效率
    let start = Instant::now();
    let mut test_strings = Vec::new();
    for i in 0..1000 {
        let s = memory_manager.acquire_string(50);
        test_strings.push(format!("Test string {}", i));
    }
    
    for s in test_strings {
        memory_manager.release_string(s);
    }
    let pool_time = start.elapsed();
    
    // 获取内存统计
    let (pool_stats, _) = memory_manager.get_pool_stats();
    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
             pool_stats.small_pool_size,
             pool_stats.large_pool_size, 
             pool_stats.total_capacity / 1024);
    
    // 3. 智能缓存测试
    println!("\n🧠 智能缓存性能:");
    use html_translation_lib::config::TranslationConfig;
    
    let config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://example.com/translate");
    
    let mut cache_manager = SmartCacheManager::new(&config).await?;
    
    let start = Instant::now();
    
    // 模拟缓存操作
    for i in 0..500 {
        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
        let value = format!("translation_{}", i);
        cache_manager.set(&key, value).await?;
    }
    
    // 测试缓存命中
    let mut hits = 0;
    for i in 0..100 {
        let key = format!("text_{}", i);
        if cache_manager.get(&key).await?.is_some() {
            hits += 1;
        }
    }
    
    let cache_time = start.elapsed();
    let cache_stats = cache_manager.stats();
    
    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
    println!("  - 缓存命中数: {} / 100", hits);
    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
    
    // 4. 并发批处理测试
    println!("\n⚡ 并发批处理性能:");
    let batch_config = BatchConfig {
        batch_size: 20,
        max_concurrency: 4,
        timeout_duration: std::time::Duration::from_secs(10),
        ..Default::default()
    };
    
    let batch_processor = ConcurrentBatchProcessor::new(
        batch_config, 
        Arc::clone(&memory_manager)
    );
    
    // 准备测试文本
    let test_texts: Vec<String> = (0..200)
        .map(|i| format!("Test text number {}", i))
        .collect();
    
    let start = Instant::now();
    
    // 提交批处理任务
    let mut task_ids = Vec::new();
    for chunk in test_texts.chunks(50) {
        let task_id = batch_processor.submit_batch(
            chunk.to_vec(), 
            Priority::Normal
        ).await?;
        task_ids.push(task_id);
    }
    
    // 模拟翻译函数
    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
    }
    
    // 处理队列
    let _results = batch_processor.process_queue(mock_translate).await?;
    let batch_time = start.elapsed();
    
    let batch_stats = batch_processor.get_stats().await;
    let queue_status = batch_processor.get_queue_status();
    
    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
    
    // 5. 总结
    println!("\n📈 性能优化总结:");
    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
    println!("  ✅ 内存池管理: 减少 GC 压力");
    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
    println!("\n🎉 所有性能优化测试完成!");
    
    Ok(())
}

examples/basic_translation.rs (line 17)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 105)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn source_language(self, lang: &str) -> Self

设置源语言

pub fn api_url(self, url: &str) -> Self

设置API URL

Examples found in repository

examples/performance_test.rs (line 114)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 HTML翻译库性能测试\n");
    
    let large_html = generate_large_html();
    let dom = parse_html(&large_html);
    
    println!("📊 测试数据:");
    println!("  - HTML大小: {} KB", large_html.len() / 1024);
    println!("  - 包含 ~5000 个文本元素\n");
    
    // 1. DOM遍历性能测试
    println!("🔍 DOM遍历性能对比:");
    
    // 原始递归收集器
    let start = Instant::now();
    let original_collector = TextCollector::new();
    let original_items = original_collector.collect_from_dom(&dom)?;
    let original_time = start.elapsed();
    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
             original_time.as_millis(), original_items.len());
    
    // 优化的迭代收集器
    let start = Instant::now();
    let mut optimized_collector = OptimizedTextCollector::new();
    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
    let optimized_time = start.elapsed();
    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
             optimized_time.as_millis(), optimized_items.len());
    
    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
    
    // 2. 内存管理测试
    println!("💾 内存管理优化:");
    let memory_manager = Arc::new(GlobalMemoryManager::new());
    
    // 测试字符串池效率
    let start = Instant::now();
    let mut test_strings = Vec::new();
    for i in 0..1000 {
        let s = memory_manager.acquire_string(50);
        test_strings.push(format!("Test string {}", i));
    }
    
    for s in test_strings {
        memory_manager.release_string(s);
    }
    let pool_time = start.elapsed();
    
    // 获取内存统计
    let (pool_stats, _) = memory_manager.get_pool_stats();
    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
             pool_stats.small_pool_size,
             pool_stats.large_pool_size, 
             pool_stats.total_capacity / 1024);
    
    // 3. 智能缓存测试
    println!("\n🧠 智能缓存性能:");
    use html_translation_lib::config::TranslationConfig;
    
    let config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://example.com/translate");
    
    let mut cache_manager = SmartCacheManager::new(&config).await?;
    
    let start = Instant::now();
    
    // 模拟缓存操作
    for i in 0..500 {
        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
        let value = format!("translation_{}", i);
        cache_manager.set(&key, value).await?;
    }
    
    // 测试缓存命中
    let mut hits = 0;
    for i in 0..100 {
        let key = format!("text_{}", i);
        if cache_manager.get(&key).await?.is_some() {
            hits += 1;
        }
    }
    
    let cache_time = start.elapsed();
    let cache_stats = cache_manager.stats();
    
    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
    println!("  - 缓存命中数: {} / 100", hits);
    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
    
    // 4. 并发批处理测试
    println!("\n⚡ 并发批处理性能:");
    let batch_config = BatchConfig {
        batch_size: 20,
        max_concurrency: 4,
        timeout_duration: std::time::Duration::from_secs(10),
        ..Default::default()
    };
    
    let batch_processor = ConcurrentBatchProcessor::new(
        batch_config, 
        Arc::clone(&memory_manager)
    );
    
    // 准备测试文本
    let test_texts: Vec<String> = (0..200)
        .map(|i| format!("Test text number {}", i))
        .collect();
    
    let start = Instant::now();
    
    // 提交批处理任务
    let mut task_ids = Vec::new();
    for chunk in test_texts.chunks(50) {
        let task_id = batch_processor.submit_batch(
            chunk.to_vec(), 
            Priority::Normal
        ).await?;
        task_ids.push(task_id);
    }
    
    // 模拟翻译函数
    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
    }
    
    // 处理队列
    let _results = batch_processor.process_queue(mock_translate).await?;
    let batch_time = start.elapsed();
    
    let batch_stats = batch_processor.get_stats().await;
    let queue_status = batch_processor.get_queue_status();
    
    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
    
    // 5. 总结
    println!("\n📈 性能优化总结:");
    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
    println!("  ✅ 内存池管理: 减少 GC 压力");
    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
    println!("\n🎉 所有性能优化测试完成!");
    
    Ok(())
}

examples/basic_translation.rs (line 18)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 106)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn enable_cache(self, enabled: bool) -> Self

启用或禁用缓存

Examples found in repository

examples/basic_translation.rs (line 19)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 107)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn cache_ttl(self, ttl: Duration) -> Self

设置缓存TTL

pub fn batch_size(self, size: usize) -> Self

设置批处理大小

Examples found in repository

examples/basic_translation.rs (line 20)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 108)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn max_retries(self, retries: usize) -> Self

设置最大重试次数

Examples found in repository

examples/basic_translation.rs (line 21)

async fn main() -> TranslationResult<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - 基本使用示例");
    println!("{}", "=".repeat(50));
    
    // 创建翻译配置
    let config = TranslationConfig::new()
        .target_language("zh")  // 翻译为中文
        .api_url("http://localhost:1188/translate")  // DeepLX API地址
        .enable_cache(true)     // 启用缓存
        .batch_size(20)         // 批处理大小
        .max_retries(3);        // 最大重试次数
    
    println!("✓ 翻译配置创建完成");
    
    // 创建翻译器
    let mut translator = HtmlTranslator::new(config).await?;
    println!("✓ 翻译器初始化完成");
    
    // 示例HTML内容 - 使用字符串连接来避免标识符冲突
    let sample_html = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Welcome to Our Website</title>
        <meta name="description" content="This is a sample webpage for translation testing">
    </head>
    <body>
        <header>
            <h1>Welcome to Our Amazing Website</h1>
            <nav>
                <a href="{}home" title="Go to home page">Home</a>
                <a href="{}about" title="Learn about us">About</a>
                <a href="{}contact" title="Get in touch">Contact</a>
            </nav>
        </header>
        
        <main>
            <section id="hero">
                <h2>Discover Something New Today</h2>
                <p>We provide innovative solutions for your business needs. 
                   Our team of experts is dedicated to helping you succeed.</p>
                <button>Get Started Now</button>
            </section>
            
            <section id="features">
                <h3>Our Features</h3>
                <div class="feature">
                    <h4>Fast Performance</h4>
                    <p>Lightning-fast load times for better user experience.</p>
                </div>
                <div class="feature">
                    <h4>Secure & Reliable</h4>
                    <p>Your data is protected with enterprise-grade security.</p>
                </div>
                <div class="feature">
                    <h4>24/7 Support</h4>
                    <p>Round-the-clock customer support whenever you need help.</p>
                </div>
            </section>
            
            <section id="contact">
                <h3>Contact Us</h3>
                <form>
                    <label for="name">Your Name:</label>
                    <input type="text" id="name" name="name" placeholder="Enter your name" required>
                    
                    <label for="email">Email Address:</label>
                    <input type="email" id="email" name="email" placeholder="Enter your email" required>
                    
                    <label for="message">Message:</label>
                    <textarea id="message" name="message" placeholder="Tell us how we can help you" required></textarea>
                    
                    <button type="submit">Send Message</button>
                </form>
            </section>
        </main>
        
        <footer>
            <p>&copy; 2024 Our Company. All rights reserved.</p>
            <img src="logo.png" alt="Company Logo" title="Our company logo">
        </footer>
        
        <script>
            // This JavaScript code should not be translated
            console.log('Page loaded successfully');
        </script>
    </body>
    </html>
    "##, "#", "#", "#");
    
    println!("\n原始HTML内容长度: {} 字符", sample_html.len());
    
    // 执行翻译
    println!("\n🔄 开始翻译...");
    let start_time = std::time::Instant::now();
    
    let translated_html = translator.translate_html(&sample_html).await?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    // 显示翻译统计
    let stats = translator.get_stats();
    println!("\n📊 翻译统计:");
    println!("   - 收集文本数量: {}", stats.texts_collected);
    println!("   - 过滤后文本数量: {}", stats.texts_filtered);
    println!("   - 缓存命中: {}", stats.cache_hits);
    println!("   - 缓存未命中: {}", stats.cache_misses);
    println!("   - 缓存命中率: {:.1}%", stats.cache_hit_rate() * 100.0);
    println!("   - 创建批次数量: {}", stats.batches_created);
    println!("   - 处理时间: {:?}", stats.processing_time);
    
    // 保存翻译结果
    std::fs::write("translated_example.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: translated_example.html");
    
    // 显示部分翻译结果预览
    let preview_length = 500;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    // 对比原文和译文长度
    println!("\n📏 长度对比:");
    println!("   原文: {} 字符", sample_html.len());
    println!("   译文: {} 字符", translated_html.len());
    println!("   变化: {:.1}%", 
             (translated_html.len() as f32 / sample_html.len() as f32 - 1.0) * 100.0);
    
    // 演示文件翻译
    println!("\n🔄 演示文件翻译功能...");
    std::fs::write("sample_input.html", &sample_html)?;
    
    translator.translate_file("sample_input.html", "sample_output.html").await?;
    println!("✅ 文件翻译完成: sample_input.html → sample_output.html");
    
    println!("\n🎉 示例演示完成！");
    
    Ok(())
}

examples/monolith_integration.rs (line 109)

async fn main() -> TranslationResult<()> {
    tracing_subscriber::fmt::init();
    
    println!("HTML翻译库 - Monolith集成示例");
    println!("{}", "=".repeat(50));
    
    // 模拟从网络获取的HTML内容 - 避免前缀标识符冲突
    let html_content = format!(r##"
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Product Documentation</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <header>
            <h1>Product Documentation</h1>
            <p>Comprehensive guide for our product</p>
        </header>
        
        <nav>
            <ul>
                <li><a href="{}getting-started">Getting Started</a></li>
                <li><a href="{}features">Features</a></li>
                <li><a href="{}api-reference">API Reference</a></li>
                <li><a href="{}troubleshooting">Troubleshooting</a></li>
            </ul>
        </nav>
        
        <main>
            <section id="getting-started">
                <h2>Getting Started</h2>
                <p>Follow these simple steps to begin using our product:</p>
                <ol>
                    <li>Download the latest version from our website</li>
                    <li>Install the software on your system</li>
                    <li>Run the initial configuration wizard</li>
                    <li>Start exploring the features</li>
                </ol>
            </section>
            
            <section id="features">
                <h2>Key Features</h2>
                <div class="feature-grid">
                    <div class="feature-card">
                        <h3>Easy to Use</h3>
                        <p>Intuitive interface designed for users of all skill levels.</p>
                    </div>
                    <div class="feature-card">
                        <h3>High Performance</h3>
                        <p>Optimized algorithms ensure fast processing times.</p>
                    </div>
                    <div class="feature-card">
                        <h3>Extensible</h3>
                        <p>Plugin architecture allows for custom functionality.</p>
                    </div>
                </div>
            </section>
            
            <section id="api-reference">
                <h2>API Reference</h2>
                <p>Complete documentation of all available functions and methods.</p>
                <code>
                function processData(input) {{
                    // Example function
                    return input.map(item => item * 2);
                }}
                </code>
            </section>
        </main>
        
        <footer>
            <p>© 2024 Company Name. All rights reserved.</p>
        </footer>
        
        <script src="script.js"></script>
    </body>
    </html>
    "##, "#", "#", "#", "#");
    
    println!("📄 原始HTML内容长度: {} 字符", html_content.len());
    
    // 步骤1: 解析HTML为DOM
    println!("\n🔍 步骤1: 解析HTML为DOM...");
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut html_content.as_bytes())?;
    
    println!("✅ HTML解析完成");
    
    // 步骤2: 配置翻译参数
    println!("\n⚙️  步骤2: 配置翻译参数...");
    let translation_config = TranslationConfig::new()
        .target_language("zh")
        .api_url("http://localhost:1188/translate")
        .enable_cache(true)
        .batch_size(15)
        .max_retries(3);
    
    println!("✅ 翻译配置完成");
    
    // 步骤3: 在合并资源前翻译内容
    println!("\n🔄 步骤3: 翻译DOM内容...");
    let start_time = std::time::Instant::now();
    
    let translated_dom = translate_before_merge(dom, translation_config).await?;
    
    let translation_time = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", translation_time);
    
    // 步骤4: 将翻译后的DOM序列化为HTML
    println!("\n📝 步骤4: 序列化翻译后的DOM...");
    let translated_html = serialize_dom(&translated_dom)?;
    
    println!("✅ DOM序列化完成");
    
    // 步骤5: 保存翻译后的HTML（在实际使用中，这里会传给Monolith）
    println!("\n💾 步骤5: 保存翻译结果...");
    std::fs::write("translated_monolith_input.html", &translated_html)?;
    println!("✅ 翻译后的HTML已保存到: translated_monolith_input.html");
    
    // 现在这个文件可以作为Monolith的输入
    println!("\n🔧 集成说明:");
    println!("   1. 翻译后的HTML文件: translated_monolith_input.html");
    println!("   2. 现在可以使用Monolith处理此文件:");
    println!("      monolith translated_monolith_input.html > final_output.html");
    println!("   3. 最终输出将是翻译好的单文件HTML");
    
    // 显示处理统计
    println!("\n📊 处理统计:");
    println!("   - 原始内容长度: {} 字符", html_content.len());
    println!("   - 翻译后长度: {} 字符", translated_html.len());
    println!("   - 翻译用时: {:?}", translation_time);
    println!("   - 长度变化: {:.1}%", 
             (translated_html.len() as f32 / html_content.len() as f32 - 1.0) * 100.0);
    
    // 显示部分翻译结果预览
    let preview_length = 800;
    let preview = if translated_html.len() > preview_length {
        format!("{}...", &translated_html[..preview_length])
    } else {
        translated_html.clone()
    };
    
    println!("\n📝 翻译结果预览:");
    println!("{}", "=".repeat(60));
    println!("{}", preview);
    println!("{}", "=".repeat(60));
    
    println!("\n🎉 Monolith集成示例完成!");
    println!("   翻译后的文件现在可以用作Monolith的输入。");
    
    Ok(())
}

pub fn timeout(self, seconds: u64) -> Self

设置请求超时时间

pub fn api_key(self, key: Option<String>) -> Self

设置API密钥

pub fn use_indexing(self, enabled: bool) -> Self

启用或禁用索引标记

pub fn min_text_length(self, length: usize) -> Self

设置最小翻译文本长度

pub fn add_filter(self, pattern: &str) -> Self

添加自定义过滤规则

pub fn from_file<P: AsRef<Path>>(path: P) -> TranslationResult<Self>

从文件加载配置

pub fn save_to_file<P: AsRef<Path>>(&self, path: P) -> TranslationResult<()>

保存配置到文件

pub fn from_env() -> Self

从环境变量加载配置

pub fn validate(&self) -> TranslationResult<()>

验证配置的有效性

pub fn http_timeout(&self) -> Duration

获取HTTP客户端超时时间

pub fn retry_delay(&self) -> Duration

获取重试延迟时间

Trait Implementations

impl Clone for TranslationConfig

fn clone(&self) -> TranslationConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TranslationConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TranslationConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TranslationConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TranslationConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.