从基础到高级详解Python临时文件与目录创建完全指南

def demonstrate_tempfile_needs():
    """
    演示临时文件的常见应用场景
    """
    scenarios = [
        {
            'name': '数据处理中间存储',
            'description': '大型数据集处理过程中的临时存储',
            'example': '排序、转换或聚合大量数据时的中间文件'
        },
        {
            'name': '缓存系统',
            'description': '存储计算密集型操作的缓存结果',
            'example': '网页缓存、api响应缓存或渲染结果缓存'
        },
        {
            'name': '文件下载和处理',
            'description': '下载文件后的临时处理空间',
            'example': '下载压缩包后的解压和内容提取'
        },
        {
            'name': '测试和调试',
            'description': '单元测试和调试时创建临时测试数据',
            'example': '自动化测试中的临时数据库或配置文件'
        },
        {
            'name': '进程间通信',
            'description': '不同进程之间的数据交换',
            'example': '多进程应用中的共享临时数据存储'
        }
    ]
    
    print("=== 临时文件的应用场景 ===")
    for scenario in scenarios:
        print(f"\n{scenario['name']}:")
        print(f"  描述: {scenario['description']}")
        print(f"  示例: {scenario['example']}")

demonstrate_tempfile_needs()

def demonstrate_tempfile_challenges():
    """
    演示临时文件处理中的挑战
    """
    challenges = [
        {
            'issue': '安全风险',
            'description': '临时文件可能包含敏感数据， improper handling can lead to data leaks',
            'solution': '使用安全权限和加密存储'
        },
        {
            'issue': '资源泄漏',
            'description': '未正确清理临时文件会导致磁盘空间耗尽',
            'solution': '自动清理机制和资源管理'
        },
        {
            'issue': '并发访问',
            'description': '多进程/线程同时访问临时文件可能导致冲突',
            'solution': '使用文件锁和唯一命名'
        },
        {
            'issue': '跨平台兼容性',
            'description': '不同操作系统的文件系统特性差异',
            'solution': '使用跨平台api和路径处理'
        },
        {
            'issue': '性能考虑',
            'description': '频繁的文件io操作可能影响性能',
            'solution': '适当的缓冲和内存映射策略'
        }
    ]
    
    print("=== 临时文件处理的挑战与解决方案 ===")
    for challenge in challenges:
        print(f"\n{challenge['issue']}:")
        print(f"  问题: {challenge['description']}")
        print(f"  解决方案: {challenge['solution']}")

demonstrate_tempfile_challenges()

import tempfile
import os

def demonstrate_basic_tempfiles():
    """
    演示基本的临时文件创建方法
    """
    print("=== 基本临时文件创建 ===")
    
    # 方法1: 使用temporaryfile - 自动清理
    with tempfile.temporaryfile(mode='w+', encoding='utf-8') as temp_file:
        temp_file.write("这是临时文件内容\n第二行内容")
        temp_file.seek(0)
        content = temp_file.read()
        print(f"temporaryfile 内容: {content!r}")
        print(f"文件描述符: {temp_file.fileno()}")
    
    # 文件在此处已自动删除
    print("文件已自动删除")
    
    # 方法2: 使用namedtemporaryfile - 有名称的临时文件
    with tempfile.namedtemporaryfile(mode='w+', delete=true, encoding='utf-8') as named_temp:
        named_temp.write("命名临时文件内容")
        print(f"临时文件路径: {named_temp.name}")
        
        # 验证文件存在
        if os.path.exists(named_temp.name):
            print("文件存在，可被其他进程访问")
        else:
            print("文件不存在")
    
    # 方法3: 使用mkstemp - 低级api
    fd, temp_path = tempfile.mkstemp(suffix='.txt', prefix='python_')
    print(f"mkstemp 文件描述符: {fd}, 路径: {temp_path}")
    
    # 需要手动管理资源
    try:
        with os.fdopen(fd, 'w') as f:
            f.write("mkstemp 创建的内容")
        
        # 读取内容验证
        with open(temp_path, 'r') as f:
            content = f.read()
            print(f"mkstemp 文件内容: {content!r}")
    finally:
        # 手动清理
        os.unlink(temp_path)
        print("mkstemp 文件已手动删除")

demonstrate_basic_tempfiles()

def demonstrate_temp_directories():
    """
    演示临时目录的创建和使用
    """
    print("=== 临时目录创建与使用 ===")
    
    # 使用temporarydirectory
    with tempfile.temporarydirectory(prefix='python_temp_', suffix='_dir') as temp_dir:
        print(f"临时目录路径: {temp_dir}")
        
        # 在临时目录中创建多个文件
        files_to_create = ['config.ini', 'data.json', 'log.txt']
        
        for filename in files_to_create:
            file_path = os.path.join(temp_dir, filename)
            with open(file_path, 'w') as f:
                f.write(f"{filename} 的内容")
            
            print(f"创建文件: {file_path}")
        
        # 验证文件存在
        created_files = os.listdir(temp_dir)
        print(f"目录中的文件: {created_files}")
        
        # 演示目录自动清理
        print("退出with块后目录将自动删除")
    
    # 使用mkdtemp - 手动管理
    temp_dir_path = tempfile.mkdtemp(prefix='manual_')
    print(f"手动管理临时目录: {temp_dir_path}")
    
    try:
        # 在目录中工作
        test_file = os.path.join(temp_dir_path, 'test.txt')
        with open(test_file, 'w') as f:
            f.write("测试内容")
        
        print(f"创建测试文件: {test_file}")
        
    finally:
        # 手动清理 - 需要递归删除
        import shutil
        shutil.rmtree(temp_dir_path)
        print("手动临时目录已删除")

demonstrate_temp_directories()

def demonstrate_secure_tempfiles():
    """
    演示安全临时文件处理
    """
    print("=== 安全临时文件处理 ===")
    
    # 1. 安全权限设置
    with tempfile.namedtemporaryfile(mode='w', delete=false) as secure_temp:
        # 设置安全文件权限 (仅当前用户可读写)
        os.chmod(secure_temp.name, 0o600)
        secure_temp.write("敏感数据: 密码、密钥等")
        print(f"安全文件创建: {secure_temp.name}")
        
        # 验证权限
        stat_info = os.stat(secure_temp.name)
        print(f"文件权限: {oct(stat_info.st_mode)[-3:]}")
    
    # 手动清理
    os.unlink(secure_temp.name)
    
    # 2. 安全目录位置
    secure_dir = tempfile.mkdtemp()
    try:
        # 在安全目录中创建文件
        secure_file_path = os.path.join(secure_dir, 'secure_data.bin')
        
        # 使用安全模式创建文件
        with open(secure_file_path, 'wb') as f:
            f.write(b'加密的敏感数据')
            os.chmod(secure_file_path, 0o600)
        
        print(f"安全目录中的文件: {secure_file_path}")
        
    finally:
        shutil.rmtree(secure_dir)
    
    # 3. 使用加密的临时文件
    from cryptography.fernet import fernet
    
    # 生成加密密钥
    key = fernet.generate_key()
    cipher = fernet(key)
    
    with tempfile.namedtemporaryfile(mode='wb', delete=false) as encrypted_temp:
        sensitive_data = "超级机密信息".encode('utf-8')
        encrypted_data = cipher.encrypt(sensitive_data)
        encrypted_temp.write(encrypted_data)
        
        print(f"加密文件创建: {encrypted_temp.name}")
        print(f"原始数据长度: {len(sensitive_data)}")
        print(f"加密数据长度: {len(encrypted_data)}")
    
    # 清理
    os.unlink(encrypted_temp.name)

demonstrate_secure_tempfiles()

def demonstrate_advanced_tempfile_modes():
    """
    演示高级临时文件模式和使用技巧
    """
    print("=== 高级临时文件模式 ===")
    
    # 1. 使用不同的模式组合
    modes = [
        ('w+b', "二进制读写"),
        ('w+', "文本读写"),
        ('xb', "独占创建二进制"),
        ('x', "独占创建文本")
    ]
    
    for mode, description in modes:
        try:
            with tempfile.namedtemporaryfile(mode=mode, delete=false) as temp_file:
                print(f"模式 {mode} ({description}): {temp_file.name}")
                
                if 'b' in mode:
                    # 二进制操作
                    temp_file.write(b'binary data\x00\x01\x02')
                    temp_file.seek(0)
                    data = temp_file.read()
                    print(f"  写入/读取: {data!r}")
                else:
                    # 文本操作
                    temp_file.write("文本数据\n多行内容")
                    temp_file.seek(0)
                    content = temp_file.read()
                    print(f"  写入/读取: {content!r}")
                
            os.unlink(temp_file.name)
            
        except exception as e:
            print(f"模式 {mode} 错误: {e}")
    
    # 2. 自定义前缀和后缀
    custom_temp = tempfile.namedtemporaryfile(
        prefix='custom_',
        suffix='.json',
        delete=false
    )
    print(f"\n自定义临时文件: {custom_temp.name}")
    custom_temp.close()
    os.unlink(custom_temp.name)
    
    # 3. 指定目录和忽略清理
    specific_dir = '/tmp' if os.name != 'nt' else tempfile.gettempdir()
    with tempfile.namedtemporaryfile(
        dir=specific_dir,
        delete=false  # 不自动删除，用于演示
    ) as specific_temp:
        print(f"指定目录临时文件: {specific_temp.name}")
    
    # 手动清理
    os.unlink(specific_temp.name)

demonstrate_advanced_tempfile_modes()

class dataprocessingpipeline:
    """
    使用临时文件的数据处理管道
    """
    
    def __init__(self):
        self.temp_files = []
        self.temp_dirs = []
    
    def process_large_dataset(self, data_generator, process_func, chunk_size=1000):
        """
        处理大型数据集
        """
        print("=== 大型数据处理管道 ===")
        
        # 创建临时工作目录
        work_dir = tempfile.mkdtemp(prefix='data_pipeline_')
        self.temp_dirs.append(work_dir)
        print(f"创建工作目录: {work_dir}")
        
        processed_chunks = []
        chunk_count = 0
        
        try:
            # 分块处理数据
            current_chunk = []
            for item in data_generator:
                current_chunk.append(item)
                
                if len(current_chunk) >= chunk_size:
                    # 处理当前块
                    processed_chunk = self._process_chunk(current_chunk, process_func, work_dir, chunk_count)
                    processed_chunks.append(processed_chunk)
                    current_chunk = []
                    chunk_count += 1
            
            # 处理最后一块
            if current_chunk:
                processed_chunk = self._process_chunk(current_chunk, process_func, work_dir, chunk_count)
                processed_chunks.append(processed_chunk)
            
            # 合并结果
            final_result = self._merge_results(processed_chunks, work_dir)
            print(f"处理完成: {chunk_count + 1} 个数据块")
            
            return final_result
            
        except exception as e:
            print(f"数据处理错误: {e}")
            self.cleanup()
            raise
    
    def _process_chunk(self, chunk_data, process_func, work_dir, chunk_index):
        """
        处理单个数据块
        """
        # 创建临时文件存储块数据
        chunk_file = tempfile.namedtemporaryfile(
            mode='w+',
            dir=work_dir,
            suffix=f'_chunk_{chunk_index}.json',
            delete=false,
            encoding='utf-8'
        )
        self.temp_files.append(chunk_file.name)
        
        try:
            # 处理数据
            processed_data = process_func(chunk_data)
            
            # 写入临时文件
            import json
            json.dump(processed_data, chunk_file, ensure_ascii=false)
            chunk_file.close()
            
            return chunk_file.name
            
        except exception as e:
            chunk_file.close()
            os.unlink(chunk_file.name)
            raise
    
    def _merge_results(self, chunk_files, work_dir):
        """
        合并处理结果
        """
        merged_data = []
        
        for chunk_file in chunk_files:
            try:
                with open(chunk_file, 'r', encoding='utf-8') as f:
                    import json
                    chunk_data = json.load(f)
                    merged_data.extend(chunk_data)
            except exception as e:
                print(f"合并块 {chunk_file} 错误: {e}")
        
        # 创建最终结果文件
        result_file = tempfile.namedtemporaryfile(
            mode='w+',
            dir=work_dir,
            suffix='_final_result.json',
            delete=false,
            encoding='utf-8'
        )
        self.temp_files.append(result_file.name)
        
        import json
        json.dump(merged_data, result_file, ensure_ascii=false, indent=2)
        result_file.close()
        
        return result_file.name
    
    def cleanup(self):
        """清理所有临时资源"""
        for file_path in self.temp_files:
            try:
                if os.path.exists(file_path):
                    os.unlink(file_path)
            except oserror:
                pass
        
        for dir_path in self.temp_dirs:
            try:
                if os.path.exists(dir_path):
                    shutil.rmtree(dir_path)
            except oserror:
                pass
        
        self.temp_files.clear()
        self.temp_dirs.clear()
        print("所有临时资源已清理")
    
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.cleanup()

# 使用示例
def demo_data_pipeline():
    """数据处理管道演示"""
    
    # 模拟数据生成器
    def data_generator():
        for i in range(10000):
            yield {'id': i, 'data': f'item_{i}', 'value': i * 2}
    
    # 模拟处理函数
    def process_function(chunk):
        return [{'processed': item, 'timestamp': time.time()} for item in chunk]
    
    # 使用管道
    with dataprocessingpipeline() as pipeline:
        result_file = pipeline.process_large_dataset(data_generator(), process_function, chunk_size=500)
        
        # 读取部分结果
        with open(result_file, 'r', encoding='utf-8') as f:
            import json
            result_data = json.load(f)
            print(f"处理结果: {len(result_data)} 条记录")
            print(f"示例记录: {result_data[0] if result_data else '无数据'}")

demo_data_pipeline()

class testtempfilemanager:
    """
    测试用的临时文件管理器
    """
    
    def __init__(self):
        self.test_files = []
        self.test_dirs = []
    
    def create_test_config(self, config_data):
        """创建测试配置文件"""
        config_file = tempfile.namedtemporaryfile(
            mode='w+',
            suffix='.json',
            delete=false,
            encoding='utf-8'
        )
        self.test_files.append(config_file.name)
        
        import json
        json.dump(config_data, config_file, indent=2)
        config_file.close()
        
        return config_file.name
    
    def create_test_database(self, db_data):
        """创建测试数据库文件"""
        db_file = tempfile.namedtemporaryfile(
            mode='wb',
            suffix='.db',
            delete=false
        )
        self.test_files.append(db_file.name)
        
        # 模拟数据库文件创建
        db_file.write(b'sqlite format 3\x00')  # sqlite文件头
        # 这里可以添加更多的模拟数据库内容
        db_file.close()
        
        return db_file.name
    
    def create_test_directory_structure(self, structure):
        """创建测试目录结构"""
        base_dir = tempfile.mkdtemp(prefix='test_structure_')
        self.test_dirs.append(base_dir)
        
        def create_structure(current_path, current_structure):
            for name, content in current_structure.items():
                item_path = os.path.join(current_path, name)
                
                if isinstance(content, dict):
                    # 创建子目录
                    os.makedirs(item_path, exist_ok=true)
                    create_structure(item_path, content)
                else:
                    # 创建文件
                    with open(item_path, 'w', encoding='utf-8') as f:
                        f.write(content if isinstance(content, str) else str(content))
        
        create_structure(base_dir, structure)
        return base_dir
    
    def cleanup(self):
        """清理测试文件"""
        for file_path in self.test_files:
            try:
                os.unlink(file_path)
            except oserror:
                pass
        
        for dir_path in self.test_dirs:
            try:
                shutil.rmtree(dir_path)
            except oserror:
                pass
        
        self.test_files.clear()
        self.test_dirs.clear()

# 使用示例
def demo_test_framework():
    """测试框架演示"""
    test_manager = testtempfilemanager()
    
    try:
        # 创建测试配置
        config_data = {
            'database': {
                'host': 'localhost',
                'port': 5432,
                'name': 'test_db'
            },
            'settings': {
                'debug': true,
                'timeout': 30
            }
        }
        config_file = test_manager.create_test_config(config_data)
        print(f"测试配置文件: {config_file}")
        
        # 创建测试数据库
        db_file = test_manager.create_test_database({'test': 'data'})
        print(f"测试数据库文件: {db_file}")
        
        # 创建目录结构
        dir_structure = {
            'config': {
                'app.ini': '[main]\nversion=1.0',
                'secrets': {
                    'key.txt': 'secret-key-12345'
                }
            },
            'data': {
                'input.csv': 'id,name,value\n1,test,100',
                'output': {}
            },
            'logs': {
                'app.log': 'log start\n'
            }
        }
        test_dir = test_manager.create_test_directory_structure(dir_structure)
        print(f"测试目录结构: {test_dir}")
        
        # 显示创建的内容
        for root, dirs, files in os.walk(test_dir):
            level = root.replace(test_dir, '').count(os.sep)
            indent = ' ' * 2 * level
            print(f"{indent}{os.path.basename(root)}/")
            sub_indent = ' ' * 2 * (level + 1)
            for file in files:
                print(f"{sub_indent}{file}")
        
    finally:
        test_manager.cleanup()
        print("测试资源已清理")

demo_test_framework()

class optimizedtempfilesystem:
    """
    优化的临时文件系统
    """
    
    def __init__(self, max_memory_size=100 * 1024 * 1024):  # 100mb
        self.max_memory_size = max_memory_size
        self.memory_buffer = bytearray()
        self.temp_files = []
        self.total_size = 0
    
    def write_data(self, data):
        """
        智能写入数据，根据大小选择内存或磁盘存储
        """
        data_size = len(data) if isinstance(data, bytes) else len(data.encode('utf-8'))
        
        if self.total_size + data_size <= self.max_memory_size:
            # 使用内存存储
            if isinstance(data, bytes):
                self.memory_buffer.extend(data)
            else:
                self.memory_buffer.extend(data.encode('utf-8'))
            self.total_size += data_size
            return none  # 返回none表示数据在内存中
        else:
            # 使用临时文件存储
            temp_file = self._create_temp_file()
            if isinstance(data, bytes):
                temp_file.write(data)
            else:
                temp_file.write(data.encode('utf-8'))
            self.total_size += data_size
            return temp_file.name
    
    def _create_temp_file(self):
        """创建临时文件"""
        temp_file = tempfile.namedtemporaryfile(mode='wb', delete=false)
        self.temp_files.append(temp_file.name)
        return temp_file
    
    def read_all_data(self):
        """读取所有数据"""
        # 读取内存数据
        all_data = bytes(self.memory_buffer)
        
        # 读取文件数据
        for file_path in self.temp_files:
            try:
                with open(file_path, 'rb') as f:
                    file_data = f.read()
                    all_data += file_data
            except oserror:
                continue
        
        return all_data
    
    def clear(self):
        """清理所有资源"""
        self.memory_buffer.clear()
        self.total_size = 0
        
        for file_path in self.temp_files:
            try:
                os.unlink(file_path)
            except oserror:
                pass
        
        self.temp_files.clear()
    
    def get_stats(self):
        """获取统计信息"""
        return {
            'total_size': self.total_size,
            'memory_usage': len(self.memory_buffer),
            'file_count': len(self.temp_files),
            'using_disk': len(self.temp_files) > 0
        }

# 使用示例
def demo_optimized_storage():
    """优化存储演示"""
    print("=== 优化临时存储系统 ===")
    
    storage = optimizedtempfilesystem(max_memory_size=50)  # 小尺寸用于演示
    
    test_data = [
        "小数据块1",
        "小数据块2",
        "这个数据块比较大，应该会触发文件存储" * 10,
        "另一个小数据块"
    ]
    
    for i, data in enumerate(test_data):
        storage_location = storage.write_data(data)
        stats = storage.get_stats()
        
        if storage_location:
            print(f"数据 {i}: 存储在文件 {storage_location}")
        else:
            print(f"数据 {i}: 存储在内存中")
        
        print(f"  统计: 总大小={stats['total_size']}, 文件数={stats['file_count']}")
    
    # 读取所有数据
    all_data = storage.read_all_data()
    print(f"\n总共存储数据: {len(all_data)} 字节")
    
    storage.clear()
    print("存储系统已清理")

demo_optimized_storage()

def cross_platform_tempfile_considerations():
    """
    跨平台临时文件处理注意事项
    """
    print("=== 跨平台兼容性考虑 ===")
    
    considerations = {
        'windows': [
            '文件路径使用反斜杠，需要特殊处理',
            '文件锁定机制不同',
            '权限系统基于acl而非unix权限',
            '临时目录通常为c:\\users\\username\\appdata\\local\\temp'
        ],
        'linux/macos': [
            '文件路径使用正斜杠',
            '基于unix权限系统',
            '支持符号链接和硬链接',
            '临时目录通常为/tmp或/var/tmp'
        ],
        '通用最佳实践': [
            '始终使用os.path.join()构建路径',
            '使用tempfile.gettempdir()获取系统临时目录',
            '处理文件权限差异',
            '考虑文件名长度限制',
            '处理路径字符编码差异'
        ]
    }
    
    for platform, notes in considerations.items():
        print(f"\n{platform}:")
        for note in notes:
            print(f"  • {note}")
    
    # 演示跨平台临时目录获取
    print(f"\n当前系统临时目录: {tempfile.gettempdir()}")
    
    # 演示跨平台路径处理
    test_paths = [
        ('config', 'subdir', 'file.txt'),
        ('data', '2023', '12', '31', 'log.json')
    ]
    
    for path_parts in test_paths:
        constructed_path = os.path.join(*path_parts)
        print(f"构建的路径: {constructed_path}")

cross_platform_tempfile_considerations()

class securetempfileserver:
    """
    安全临时文件服务器
    """
    
    def __init__(self, max_file_age=3600):  # 1小时
        self.base_dir = tempfile.mkdtemp(prefix='secure_server_')
        self.max_file_age = max_file_age
        self.file_registry = {}
        print(f"安全服务器启动在: {self.base_dir}")
    
    def upload_file(self, file_data, filename=none, metadata=none):
        """
        上传文件到安全临时存储
        """
        # 生成安全文件名
        if filename is none:
            import uuid
            filename = f"file_{uuid.uuid4().hex}"
        
        # 创建安全文件路径
        safe_filename = self._sanitize_filename(filename)
        file_path = os.path.join(self.base_dir, safe_filename)
        
        try:
            # 写入文件 with secure permissions
            with open(file_path, 'wb') as f:
                f.write(file_data if isinstance(file_data, bytes) else file_data.encode('utf-8'))
            
            # 设置安全权限
            os.chmod(file_path, 0o600)
            
            # 记录文件信息
            file_info = {
                'path': file_path,
                'filename': safe_filename,
                'upload_time': time.time(),
                'size': len(file_data),
                'metadata': metadata or {},
                'access_count': 0
            }
            
            self.file_registry[safe_filename] = file_info
            print(f"文件上传成功: {safe_filename} ({len(file_data)} 字节)")
            
            return safe_filename
            
        except exception as e:
            print(f"文件上传失败: {e}")
            # 清理部分上传的文件
            if os.path.exists(file_path):
                os.unlink(file_path)
            raise
    
    def download_file(self, file_id):
        """
        下载文件
        """
        if file_id not in self.file_registry:
            raise valueerror("文件不存在")
        
        file_info = self.file_registry[file_id]
        file_info['access_count'] += 1
        file_info['last_access'] = time.time()
        
        try:
            with open(file_info['path'], 'rb') as f:
                content = f.read()
            
            print(f"文件下载: {file_id} (第{file_info['access_count']}次访问)")
            return content
            
        except exception as e:
            print(f"文件下载失败: {e}")
            raise
    
    def cleanup_old_files(self):
        """
        清理过期文件
        """
        current_time = time.time()
        files_to_remove = []
        
        for file_id, file_info in self.file_registry.items():
            file_age = current_time - file_info['upload_time']
            if file_age > self.max_file_age:
                files_to_remove.append(file_id)
        
        for file_id in files_to_remove:
            self._remove_file(file_id)
            print(f"清理过期文件: {file_id}")
        
        return len(files_to_remove)
    
    def _remove_file(self, file_id):
        """移除单个文件"""
        if file_id in self.file_registry:
            file_info = self.file_registry[file_id]
            try:
                if os.path.exists(file_info['path']):
                    os.unlink(file_info['path'])
            except oserror:
                pass
            finally:
                del self.file_registry[file_id]
    
    def _sanitize_filename(self, filename):
        """消毒文件名"""
        import re
        # 移除危险字符
        safe_name = re.sub(r'[^\w\.-]', '_', filename)
        # 限制长度
        if len(safe_name) > 100:
            safe_name = safe_name[:100]
        return safe_name
    
    def shutdown(self):
        """关闭服务器并清理所有文件"""
        print("关闭安全服务器...")
        
        # 移除所有文件
        for file_id in list(self.file_registry.keys()):
            self._remove_file(file_id)
        
        # 移除基础目录
        try:
            shutil.rmtree(self.base_dir)
        except oserror:
            pass
        
        print("服务器已关闭，所有资源已清理")

# 使用示例
def demo_secure_server():
    """安全服务器演示"""
    server = securetempfileserver(max_file_age=300)  # 5分钟用于演示
    
    try:
        # 上传文件
        test_files = [
            b'binary file content',
            'text file content with special chars ñáéíóú',
            'x' * 1000  # 大文件
        ]
        
        file_ids = []
        for i, content in enumerate(test_files):
            file_id = server.upload_file(content, f'test_file_{i}.dat')
            file_ids.append(file_id)
        
        # 下载文件
        for file_id in file_ids:
            content = server.download_file(file_id)
            print(f"下载 {file_id}: {len(content)} 字节")
        
        # 等待并清理过期文件
        print("等待文件过期...")
        time.sleep(2)  # 实际应用中这里会是更长的时间
        
        cleaned = server.cleanup_old_files()
        print(f"清理了 {cleaned} 个过期文件")
        
    finally:
        server.shutdown()

demo_secure_server()