def export_redis_hash_to_log(redis_key, log_file_path):
    # 配置日志
    logging.basicConfig(filename=log_file_path, ...)
    # 導(dǎo)出邏輯...

# 多次調(diào)用
export_redis_hash_to_log(key1, "file1.log")
export_redis_hash_to_log(key2, "file2.log")

import logging

# 第一次調(diào)用 - 生效
logging.basicConfig(filename='file1.log')

# 第二次調(diào)用 - 被忽略
logging.basicConfig(filename='file2.log')  # 這個(gè)配置不會(huì)生效

import logging
from logging.handlers import RotatingFileHandler

def setup_logger(log_file_path, max_size_mb=10, backup_count=5):
    """
    創(chuàng)建獨(dú)立的日志記錄器
    
    參數(shù):
        log_file_path: 日志文件路徑
        max_size_mb: 單個(gè)文件最大大小(MB)
        backup_count: 備份文件數(shù)量
    """
    # 使用文件路徑作為記錄器名稱，確保唯一性
    logger = logging.getLogger(log_file_path)
    
    # 避免重復(fù)添加處理器
    if logger.handlers:
        return logger
    
    logger.setLevel(logging.INFO)
    
    # 創(chuàng)建帶輪轉(zhuǎn)的文件處理器
    max_bytes = max_size_mb * 1024 * 1024
    file_handler = RotatingFileHandler(
        log_file_path, 
        encoding='utf-8',
        maxBytes=max_bytes,
        backupCount=backup_count
    )
    
    # 設(shè)置日志格式
    formatter = logging.Formatter(
        '%(asctime)s - %(levelname)s - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    file_handler.setFormatter(formatter)
    
    logger.addHandler(file_handler)
    logger.propagate = False  # 防止向上傳播到根記錄器
    
    return logger

import org.apache.log4j.Logger;
import org.apache.log4j.RollingFileAppender;
import org.apache.log4j.PatternLayout;
import java.nio.charset.StandardCharsets;

public class RedisExporterLogger {
    
    public static Logger setupLogger(String logFilePath, int maxFileSizeMB, int backupCount) {
        // 獲取或創(chuàng)建Logger實(shí)例
        Logger logger = Logger.getLogger(logFilePath);
        
        // 避免重復(fù)配置
        if (logger.getAllAppenders().hasMoreElements()) {
            return logger;
        }
        
        // 創(chuàng)建滾動(dòng)文件Appender
        RollingFileAppender appender = new RollingFileAppender();
        appender.setFile(logFilePath);
        appender.setEncoding(StandardCharsets.UTF_8.name());
        appender.setMaxFileSize(maxFileSizeMB + "MB");
        appender.setMaxBackupIndex(backupCount);
        
        // 設(shè)置日志格式
        PatternLayout layout = new PatternLayout();
        layout.setConversionPattern("%d{yyyy-MM-dd HH:mm:ss} - %p - %m%n");
        appender.setLayout(layout);
        
        logger.addAppender(appender);
        logger.setAdditivity(false); // 避免重復(fù)輸出
        
        return logger;
    }
}

def safe_string_processing(text):
    """
    安全處理字符串，避免編碼問(wèn)題
    
    參數(shù):
        text: 待處理的文本
    返回:
        處理后的安全文本
    """
    if not isinstance(text, str):
        text = str(text)
    
    # 方法1: 替換無(wú)法編碼的字符
    cleaned_text = text.encode('utf-8', errors='replace').decode('utf-8')
    
    # 方法2: 移除非ASCII字符（如果需要）
    # cleaned_text = ''.join(char for char in text if ord(char) < 128)
    
    # 清理?yè)Q行符
    cleaned_text = cleaned_text.replace('\n', ' ').replace('\r', '')
    
    return cleaned_text

def export_redis_hash_to_log(redis_host, redis_port, redis_password, 
                           redis_key, log_file_path, db=0):
    """
    增強(qiáng)版的Redis哈希導(dǎo)出函數(shù)
    """
    logger = setup_logger(log_file_path)
    
    try:
        # Redis連接配置
        r = redis.Redis(
            host=redis_host,
            port=redis_port,
            password=redis_password,
            db=db,
            decode_responses=True,
            socket_connect_timeout=10,
            socket_timeout=30,  # 增加超時(shí)時(shí)間
            retry_on_timeout=True  # 超時(shí)重試
        )
        
        # 檢查連接和鍵類型
        if not check_redis_key(r, redis_key, logger):
            return
        
        # 批量獲取數(shù)據(jù)（避免內(nèi)存溢出）
        export_hash_data(r, redis_key, logger)
        
    except Exception as e:
        handle_export_error(e, logger)

def check_redis_key(redis_conn, key, logger):
    """檢查Redis鍵是否存在且為哈希類型"""
    if not redis_conn.exists(key):
        logger.warning(f"Key不存在: {key}")
        return False
    
    if redis_conn.type(key) != 'hash':
        logger.warning(f"Key不是哈希類型: {key}")
        return False
    
    return True

def export_hash_data(redis_conn, key, logger, batch_size=1000):
    """分批導(dǎo)出哈希數(shù)據(jù)"""
    cursor = 0
    total_count = 0
    
    logger.info(f"開始導(dǎo)出哈希鍵: {key}")
    
    while True:
        cursor, data = redis_conn.hscan(key, cursor, count=batch_size)
        
        if not data:
            break
            
        for field, value in data.items():
            safe_field = safe_string_processing(field)
            safe_value = safe_string_processing(value)
            
            logger.info(f"媒體請(qǐng)求: {safe_field}\n渠道響應(yīng): {safe_value}")
            total_count += 1
        
        if cursor == 0:  # 迭代結(jié)束
            break
    
    logger.info(f"導(dǎo)出完成，總計(jì){total_count}條記錄")

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import java.util.Map;
import java.nio.charset.StandardCharsets;

public class RedisHashExporter {
    
    private static final Logger logger = Logger.getLogger(RedisHashExporter.class);
    
    public void exportHashToFile(String host, int port, String password, 
                               String redisKey, String filePath, int db) {
        
        try (Jedis jedis = new Jedis(host, port)) {
            // 認(rèn)證
            if (password != null && !password.isEmpty()) {
                jedis.auth(password);
            }
            
            // 選擇數(shù)據(jù)庫(kù)
            jedis.select(db);
            
            // 檢查鍵是否存在
            if (!jedis.exists(redisKey)) {
                logger.warn("Key does not exist: " + redisKey);
                return;
            }
            
            // 檢查鍵類型
            if (!"hash".equals(jedis.type(redisKey))) {
                logger.warn("Key is not hash type: " + redisKey);
                return;
            }
            
            // 分批掃描哈希
            exportHashData(jedis, redisKey, filePath);
            
        } catch (Exception e) {
            logger.error("Export failed: " + e.getMessage(), e);
        }
    }
    
    private void exportHashData(Jedis jedis, String key, String filePath) {
        ScanParams scanParams = new ScanParams().count(1000);
        String cursor = ScanParams.SCAN_POINTER_START;
        int totalCount = 0;
        
        do {
            ScanResult<Map.Entry<String, String>> scanResult = 
                jedis.hscan(key, cursor, scanParams);
            
            for (Map.Entry<String, String> entry : scanResult.getResult()) {
                String safeField = safeString(entry.getKey());
                String safeValue = safeString(entry.getValue());
                
                String logMessage = String.format(
                    "媒體請(qǐng)求: %s\n渠道響應(yīng): %s", safeField, safeValue);
                
                writeToFile(filePath, logMessage);
                totalCount++;
            }
            
            cursor = scanResult.getCursor();
        } while (!cursor.equals("0"));
        
        logger.info("Export completed. Total records: " + totalCount);
    }
    
    private String safeString(String text) {
        if (text == null) {
            return "";
        }
        
        // 使用UTF-8編碼處理
        byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
        return new String(bytes, StandardCharsets.UTF_8)
               .replace("\n", " ")
               .replace("\r", "");
    }
    
    private synchronized void writeToFile(String filePath, String content) {
        try (FileWriter writer = new FileWriter(filePath, StandardCharsets.UTF_8, true)) {
            writer.write(content + "\n");
        } catch (IOException e) {
            logger.error("File write error: " + e.getMessage(), e);
        }
    }
}

def memory_efficient_export(redis_conn, key, logger):
    """
    內(nèi)存友好的導(dǎo)出方式，使用HSCAN迭代
    """
    cursor = '0'
    total_processed = 0
    
    while cursor != 0:
        cursor, data = redis_conn.hscan(key, cursor=cursor, count=500)
        
        for field, value in data.items():
            # 處理并立即寫入，不保存大量數(shù)據(jù)在內(nèi)存中
            process_and_log(field, value, logger)
            total_processed += 1
            
            # 每處理1000條記錄提交一次
            if total_processed % 1000 == 0:
                logger.handlers[0].flush()
    
    return total_processed

import tenacity

@tenacity.retry(
    stop=tenacity.stop_after_attempt(3),
    wait=tenacity.wait_exponential(multiplier=1, min=4, max=10),
    retry=tenacity.retry_if_exception_type((redis.ConnectionError, redis.TimeoutError))
)
def robust_redis_operation(redis_conn, operation, *args):
    """
    帶重試機(jī)制的Redis操作
    """
    return operation(redis_conn, *args)

from concurrent.futures import ThreadPoolExecutor, as_completed

def concurrent_export(export_tasks, max_workers=3):
    """
    并發(fā)執(zhí)行多個(gè)導(dǎo)出任務(wù)
    """
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_task = {
            executor.submit(
                export_redis_hash_to_log, 
                task['host'], task['port'], task['password'],
                task['key'], task['log_file'], task.get('db', 0)
            ): task for task in export_tasks
        }
        
        for future in as_completed(future_to_task):
            task = future_to_task[future]
            try:
                future.result()
                print(f"成功完成: {task['key']}")
            except Exception as e:
                print(f"任務(wù)失敗 {task['key']}: {str(e)}")

import yaml
import json

def load_export_config(config_file):
    """
    從配置文件加載導(dǎo)出任務(wù)
    """
    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
        with open(config_file, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f)
    elif config_file.endswith('.json'):
        with open(config_file, 'r', encoding='utf-8') as f:
            return json.load(f)
    else:
        raise ValueError("不支持的配置文件格式")

# config.yaml 示例
"""
redis:
  host: "redis.example.com"
  port: 6379
  password: "your_password"
  db: 1

export_tasks:
  - key: "1188888:test:log2:1766666666-a3d555555555537"
    log_file: "test_1766666666_a3d555555555537.log"
  - key: "1188888:test:log2:1788888888-a3d555555555537"
    log_file: "test_1788888888_a3d555555555537.log"
"""

import argparse
import sys

def main():
    parser = argparse.ArgumentParser(description='Redis哈希數(shù)據(jù)導(dǎo)出工具')
    parser.add_argument('--config', required=True, help='配置文件路徑')
    parser.add_argument('--concurrent', type=int, default=1, help='并發(fā)任務(wù)數(shù)')
    parser.add_argument('--verbose', action='store_true', help='詳細(xì)輸出模式')
    
    args = parser.parse_args()
    
    try:
        config = load_export_config(args.config)
        export_tasks = prepare_export_tasks(config)
        
        if args.concurrent > 1:
            concurrent_export(export_tasks, args.concurrent)
        else:
            for task in export_tasks:
                export_redis_hash_to_log(**task)
                
        print("所有導(dǎo)出任務(wù)完成")
        
    except Exception as e:
        print(f"程序執(zhí)行失敗: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()