应用配置文件加载逻辑调试完成

bash/start_winboll_in_termux_alllog.sh

@@ -53,4 +53,5 @@ echo -e "🚀 服务启动中，输入help查指令，输入exit优雅停机"
 echo -e "📝 Java日志输出路径：$MAIN_LOG\n"
 
 # 启动核心命令
+cd $BASE_DIR
 java -cp "$CLASSPATH" "$MAIN_CLASS" -v -log:ALL

src/Main.java

@@ -1,129 +1,42 @@
-import java.io.IOException;
-import java.io.PrintStream;
 import java.util.Date;
 import cc.winboll.LogUtils;
 import cc.winboll.test.ConsoleCmdAutoTest;
+import cc.winboll.util.IniConfigUtils;
 
 public class Main {
-    // 保存原始标准流，保证恢复准确性
-    private static final PrintStream ORIGIN_OUT = System.out;
-    private static final PrintStream ORIGIN_ERR = System.err;
-    // 标记流是否已接管，避免重复操作
-    private static boolean isStreamTakenOver = false;
-
     public static void main(String[] args) {
         System.out.println("==== 程序启动 ====");
         System.out.println("启动时间：" + new Date());
         System.out.println("程序开始运行...");
+		try {
+			//if (!IniConfigUtils.loadConfig("/sdcard/WinBoLLStudio/Sources/AuthCenterConsoleApp/config/config.ini")) {
+			if (!IniConfigUtils.loadConfig(null)) {
+				System.out.println("INI配置文件加载失败，程序无法启动，强制退出");
+				System.exit(1);
+			}
 
-        try {
-            // 步骤1：先提示进入日志初始化流程，等待日志路径初始化完成
-            System.out.println("\n【日志初始化】开始初始化日志工具，未完成前暂不接管输出流...");
-            // 触发LogUtils静态初始化（日志路径交互+创建，会输出路径）
-            LogUtils.i("Main", "日志工具初始化完成！");
+			try {
+				// 初始化日志工具，输出路径
+				System.out.println("\n【日志初始化】开始初始化日志工具...");
 
-            // 步骤2：日志初始化完成后，接管所有输出流
-            takeOverAllStreams();
-            System.out.println("【流接管】所有输出流已由LogUtils接管，后续输出将写入日志");
+				// 设置日志级别与日志输出目录
+				LogUtils.setGlobalLogLevel(java.util.logging.Level.ALL);
+				LogUtils.initLogDir("/sdcard/WinBoLLStudio/AuthCenterConsoleApp/logs");
+				LogUtils.i("Main", "日志工具初始化完成！");
 
-            // 核心新增：接管流后立即执行自动化测试
-            LogUtils.i("Main", "开始执行ConsoleCmdAutoTest自动化测试套件");
-            ConsoleCmdAutoTest.main(args); // 传递启动参数，兼容配置文件指定
+				// 执行自动化测试，传递启动参数
+				LogUtils.i("Main", "开始执行ConsoleCmdAutoTest自动化测试套件");
+				//ConsoleCmdAutoTest.main(args);
 
-        } finally {
-            // 必恢复所有流，杜绝资源泄露
-            restoreAllStreams();
-            LogUtils.i("Main", "所有输出流已恢复原始状态");
-        }
+			} finally {
+				LogUtils.i("Main", "测试执行完毕");
+			}
+		} catch (Exception e) {
+			System.out.println(String.format("%s", e));
+		}
 
         System.out.println("\n==== 程序结束 ====");
         System.out.println("结束时间：" + new Date());
     }
-
-    /** 全量接管：System.out/err 所有输出场景（覆盖字节、字符串、print/println/printf全场景） */
-    private static void takeOverAllStreams() {
-        if (isStreamTakenOver) return;
-
-        // 接管System.out 所有输出（覆盖字节、字符串、print/println/printf全场景）
-        System.setOut(new PrintStream(ORIGIN_OUT) {
-				// 基础字符串输出（最常用）
-				@Override
-				public void println(String msg) {
-					LogUtils.i("STDOUT", msg);
-				}
-				@Override
-				public void print(String msg) {
-					LogUtils.i("STDOUT", msg);
-				}
-				// 无参换行
-				@Override
-				public void println() {
-					LogUtils.i("STDOUT", "");
-				}
-				// 所有基本类型输出（int/long等）
-				@Override
-				public void println(int x) {
-					LogUtils.i("STDOUT", String.valueOf(x));
-				}
-				@Override
-				public void println(long x) {
-					LogUtils.i("STDOUT", String.valueOf(x));
-				}
-				@Override
-				public void println(boolean x) {
-					LogUtils.i("STDOUT", String.valueOf(x));
-				}
-				// 底层字节输出（兜底，防止漏接）
-				@Override
-				public void write(byte[] buf, int off, int len) {
-					String msg = new String(buf, off, len).trim();
-					if (!msg.isEmpty()) LogUtils.i("STDOUT", msg);
-				}
-			});
-
-        // 接管System.err 所有输出（同out逻辑，用error级别）
-        System.setErr(new PrintStream(ORIGIN_ERR) {
-				@Override
-				public void println(String msg) {
-					LogUtils.e("STDERR", msg);
-				}
-				@Override
-				public void print(String msg) {
-					LogUtils.e("STDERR", msg);
-				}
-				@Override
-				public void println() {
-					LogUtils.e("STDERR", "");
-				}
-				@Override
-				public void println(int x) {
-					LogUtils.e("STDERR", String.valueOf(x));
-				}
-				@Override
-				public void println(long x) {
-					LogUtils.e("STDERR", String.valueOf(x));
-				}
-				@Override
-				public void println(boolean x) {
-					LogUtils.e("STDERR", String.valueOf(x));
-				}
-				@Override
-				public void write(byte[] buf, int off, int len) {
-					String msg = new String(buf, off, len).trim();
-					if (!msg.isEmpty()) LogUtils.e("STDERR", msg);
-				}
-			});
-
-        isStreamTakenOver = true;
-    }
-
-    /** 恢复所有原始输出流 */
-    private static void restoreAllStreams() {
-        if (!isStreamTakenOver) return;
-
-        System.setOut(ORIGIN_OUT);
-        System.setErr(ORIGIN_ERR);
-        isStreamTakenOver = false;
-    }
 }
 

src/cc/winboll/LogUtils.java

@@ -19,11 +19,11 @@ import java.util.logging.Logger;
  * 适配Java7语法，兼容Android API30，支持异常堆栈打印
  * 支持通过启动参数动态控制全局日志级别、-v参数控制终端同步输出
  * 功能：单文件输出+10MB大小限制+满额时间戳备份+新日志沿用authcenter.log+退出自动清lck锁文件
- * 新增：默认日志目录=运行目录/logs，目录不存在则读取用户输入路径（空字符/回车默认用logs）
+ * 新增：默认日志目录=指定路径，目录不存在支持用户输入，静态变量存日志路径，空路径不初始化日志处理器
  * 内部日志全部使用系统流输出，避免初始化依赖冲突
  * @Author 豆包&ZhanGSKen<zhangsken@qq.com>
  * @Date 2026-01-14 00:00:00
- * @LastEditTime 2026-01-24 内部日志改用系统流输出
+ * @LastEditTime 2026-01-24 移除无参initLogDir，完善带参初始化逻辑
  */
 public class LogUtils {
     // ========== 静态常量（常量优先，public对外暴露，private私有） ==========
@@ -32,49 +32,72 @@ public class LogUtils {
     public static final String LOG_FILE_SUFFIX = ".log";
     private static final int MAX_LOG_SIZE = 10 * 1024 * 1024;
     private static final SimpleDateFormat BACKUP_SDF = new SimpleDateFormat("yyyyMMddHHmmss");
-    private static final String DEFAULT_LOG_DIR = "/sdcard/WinBoLLStudio/Sources/AuthCenterConsoleApp/logs"; // 默认运行目录下logs文件夹
 
     // ========== 静态成员变量 ==========
     private static ConsoleHandler consoleHandler;
     private static FileHandler fileHandler;
+    private static String DEFAULT_LOG_DIR = "/sdcard/WinBoLLStudio/AuthCenterConsoleApp/logs"; // 默认日志记录
+    private static String CURRENT_LOG_DIR; // 静态变量保存当前日志目录路径
 
     // ========== 静态初始化块（全局仅执行一次） ==========
     static {
-        LOGGER.setUseParentHandlers(false);
-        consoleHandler = new ConsoleHandler();
-        consoleHandler.setFormatter(new CustomLogFormatter());
-        setGlobalLogLevel(Level.ALL);
-        // 初始化日志目录：默认logs，不存在则读用户输入（空输入用logs）
-        initLogDir();
-        System.out.printf("[LogUtils][DEBUG] 静态初始化完成，默认日志级别ALL，单文件10MB限制+时间戳备份+lck自动清理%n");
+		if (CURRENT_LOG_DIR != null && !CURRENT_LOG_DIR.trim().endsWith("")) {
+			LOGGER.setUseParentHandlers(false);
+			consoleHandler = new ConsoleHandler();
+			consoleHandler.setFormatter(new CustomLogFormatter());
+			setGlobalLogLevel(Level.ALL);
+			// 调用带参initLogDir，传入默认路径，已删除无参方法
+			initLogDir(CURRENT_LOG_DIR);
+			System.out.printf("[LogUtils][DEBUG] 静态初始化完成，默认日志级别ALL，单文件10MB限制+时间戳备份+lck自动清理%n");
+		} else {
+			System.out.printf("LOG_DIR 路径为空，LogUtils 日志类未启用。%n");
+		}
+
     }
 
     // ========== 私有化构造器，禁止外部实例化 ==========
     private LogUtils() {}
 
-    // ========== 核心：日志目录初始化（空输入默认logs+打印路径） ==========
-    private static void initLogDir() {
-        File defaultDir = new File(DEFAULT_LOG_DIR);
-        // 默认目录存在，直接初始化并打印路径
-        if (defaultDir.exists()) {
-            System.out.printf("[LogUtils][INFO] 默认日志目录存在，路径：%s%n", defaultDir.getAbsolutePath());
-            setLogDir(DEFAULT_LOG_DIR);
+    // ========== 核心：日志目录初始化（仅保留带参方法，空路径不初始化处理器） ==========
+    public static void initLogDir(String logDirParam) {
+        // 核心逻辑：日志目录路径为空，直接返回，不初始化日志处理器
+        if (logDirParam == null || logDirParam.trim().isEmpty()) {
+            System.err.printf("[LogUtils][WARN] 日志目录路径为空，不初始化日志文件处理器%n");
+            CURRENT_LOG_DIR = null;
             return;
         }
 
-        // 默认目录不存在，提示输入（空字符/回车用默认logs）
-        System.err.printf("[LogUtils][WARN] 默认日志目录[%s]不存在%n", defaultDir.getAbsolutePath());
-        System.out.print("请输入日志目录路径（直接回车/空输入默认使用logs目录）：");
+        // 赋值静态变量，保存当前日志目录
+        CURRENT_LOG_DIR = logDirParam.trim();
+        File logDir = new File(CURRENT_LOG_DIR);
+
+        // 目录存在，直接初始化日志处理器
+        if (logDir.exists()) {
+            System.out.printf("[LogUtils][INFO] 日志目录存在，路径：%s%n", logDir.getAbsolutePath());
+            setLogDir(CURRENT_LOG_DIR);
+            return;
+        }
+
+        // 目录不存在，提示用户输入，空回车沿用传入路径尝试创建
+        System.err.printf("[LogUtils][WARN] 传入的日志目录[%s]不存在%n", logDir.getAbsolutePath());
+        System.out.print("请输入日志目录路径(输入空行使用默认值)：");
         Scanner scanner = new Scanner(System.in);
         String inputPath = scanner.nextLine().trim();
 
-        // 空输入则用默认logs，否则用用户输入路径
-        String finalLogDir = inputPath.isEmpty() ? DEFAULT_LOG_DIR : inputPath;
-        File finalDir = new File(finalLogDir);
+        // 更新最终目录&静态变量，空输入沿用原传入路径
+        String finalLogDir = inputPath.isEmpty() ? CURRENT_LOG_DIR : inputPath;
+        CURRENT_LOG_DIR = finalLogDir;
+        File finalDir = new File(CURRENT_LOG_DIR);
         System.out.printf("[LogUtils][INFO] 最终确认日志目录：%s%n", finalDir.getAbsolutePath());
 
         scanner.close();
-        setLogDir(finalLogDir);
+		
+		// 日志路径有效，初始化日志处理器
+        if (logDir.exists()) {
+            System.out.printf("[LogUtils][INFO] 日志目录存在，路径：%s%n", logDir.getAbsolutePath());
+            setLogDir(CURRENT_LOG_DIR);
+            return;
+        }
     }
 
     // ========== 私有工具方法（内部调用，按功能归类） ==========
@@ -108,7 +131,7 @@ public class LogUtils {
     }
 
     // ========== 公共核心方法（对外提供功能，核心方法优先） ==========
-    public static void setLogDir(String logDir) {
+    static void setLogDir(String logDir) {
         System.out.printf("[LogUtils][DEBUG] 【函数调用】setLogDir，入参logDir=%s%n", logDir);
         if (logDir == null || logDir.trim().isEmpty()) {
             System.err.printf("[LogUtils][WARN] 日志目录为空，跳过文件处理器初始化%n");
@@ -137,7 +160,7 @@ public class LogUtils {
                 System.out.printf("[LogUtils][INFO] 日志处理器初始化成功，当前日志文件：%s，最大10MB%n", logFile.getAbsolutePath());
                 System.out.println("[LogUtils][INFO] 满额自动备份为authcenter_时间戳.log，新日志沿用authcenter.log");
             }
-            // JVM关闭钩子，退出强制清理lck锁文件
+            // JVM关闭钩子，清理lck锁文件
             Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
 														 @Override
 														 public void run() {

src/cc/winboll/WinBoLL.java

@@ -40,10 +40,7 @@ public class WinBoLL {
         // 解析启动参数 + 加载INI根配置
         MainUtils.parseArgs(args);
         LogUtils.d(TAG, "【参数信息】main()，传入启动参数：" + MainUtils.arrayToString(args));
-        if (!IniConfigUtils.loadRootConfig()) {
-            LogUtils.e(TAG, "INI配置文件加载失败，程序无法启动，强制退出");
-            System.exit(1);
-        }
+        
 
         // 读取项目根目录 初始化日志目录
         String projectRootDir = "./";

src/cc/winboll/test/ConsoleCmdAutoTest.java

@@ -187,10 +187,6 @@ public class ConsoleCmdAutoTest {
             MainUtils.parseArgs(mockArgs);
             LogUtils.d(TAG, "【参数信息】模拟启动参数：" + MainUtils.arrayToString(mockArgs));
 
-            // 4. 设置日志级别与日志输出目录
-            LogUtils.setGlobalLogLevel(Level.INFO);
-            LogUtils.setLogDir(LOG_DIR_PATH);
-
             // 5. 初始化核心工具类
             EnvInfoUtils.printEnvReport(true);
             ServerUtils.initServerUrl(MainUtils.getFinalServerUrl());

src/cc/winboll/util/IniConfigUtils.java

@@ -1,6 +1,5 @@
 package cc.winboll.util;
 
-import cc.winboll.LogUtils;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
@@ -14,110 +13,106 @@ import java.util.Map;
  * INI配置文件读取工具类
  * 适配Android/assets目录与标准JVM文件路径，兼容Java7语法及Android API30
  * 提供INI配置加载、配置项获取核心能力，支持注释忽略与小节分组解析
- * 调整：读取运行目录下config/config.ini，配置加载失败直接写日志退出程序，无兜底逻辑
+ * 调整：1.路径加载优先级 CONFIG_PATH(运行目录config/config.ini)→DEFAULT_CONFIG_PATH兜底，均失败则退出
+ *      2.日志改为系统流(System.out/err)输出，移除LogUtils依赖
+ *      3.配置加载失败无兜底，最终路径不存在直接退出程序
  * 升级：新增带默认值的配置获取方法，解决小节/键缺失导致的功能异常
- * 修复：移除冗余System.err输出，避免日志冲突；新增文件预校验，提升加载稳定性
+ * 修复：新增文件预校验，提升加载稳定性；移除冗余输出，日志更清晰
  * @Author 豆包&ZhanGSKen<zhangsken@qq.com>
  * @Date 2026-01-15 00:00:00
- * @LastEditTime 2026-01-27 15:42:00
+ * @LastEditTime 2026-01-27 17:05:00
  */
 public class IniConfigUtils {
     // ========== 静态常量（不可变） ==========
     private static final String TAG = "IniConfigUtils";
     private static final Map<String, Map<String, String>> iniConfigMap = new HashMap<String, Map<String, String>>();
-    // 核心调整：运行目录(当前工作目录)下的config/config.ini
+    // 优先加载：运行目录下config/config.ini
     private static final String CONFIG_PATH = "./config/config.ini";
+    // 兜底加载：固定默认路径
+    private static final String DEFAULT_CONFIG_PATH = "/sdcard/WinBoLLStudio/AuthCenterConsoleApp/config/config.ini";
 
     // ========== 工具方法：文件预校验 ==========
     private static boolean checkFileValid(String filePath) {
         File configFile = new File(filePath);
         if (!configFile.exists()) {
-            LogUtils.e(TAG, "【文件校验】配置文件不存在：" + filePath);
+            System.err.println("[" + TAG + "] 【文件校验】配置文件不存在：" + filePath);
             return false;
         }
         if (!configFile.isFile()) {
-            LogUtils.e(TAG, "【文件校验】指定路径不是文件：" + filePath);
+            System.err.println("[" + TAG + "] 【文件校验】指定路径不是文件：" + filePath);
             return false;
         }
         if (!configFile.canRead()) {
-            LogUtils.e(TAG, "【文件校验】配置文件无读取权限：" + filePath);
+            System.err.println("[" + TAG + "] 【文件校验】配置文件无读取权限：" + filePath);
             return false;
         }
         return true;
     }
 
-    // ========== 配置加载方法 ==========
-    public static boolean loadRootConfig() {
-        LogUtils.d(TAG, "【函数调用】loadRootConfig()，加载运行目录配置：" + CONFIG_PATH);
-        // 校验失败直接退出，无兜底
-        if (!checkFileValid(CONFIG_PATH)) {
-            LogUtils.e(TAG, "【配置加载失败】文件校验不通过，程序退出");
-            System.exit(1);
-        }
-
-        FileInputStream fis = null;
-        try {
-            fis = new FileInputStream(CONFIG_PATH);
-            boolean loadSuccess = loadIniConfig(fis);
-            if (!loadSuccess) {
-                LogUtils.e(TAG, "【配置加载失败】INI解析失败，程序退出");
-                System.exit(1);
+    // ========== 核心修改：loadConfig 优先级逻辑 ==========
+    public static boolean loadConfig(String configFilePath) {
+        String finalLoadPath = null;
+        // 1. 先判断传入路径是否为空/无效，无效则用CONFIG_PATH
+        if (configFilePath == null || configFilePath.trim().isEmpty() || !checkFileValid(configFilePath)) {
+            if (configFilePath != null && !configFilePath.trim().isEmpty()) {
+                System.out.println("[" + TAG + "] 【路径无效】传入路径不可用，尝试优先路径：" + CONFIG_PATH);
+            } else {
+                System.out.println("[" + TAG + "] 【路径为空】传入路径为空，尝试优先路径：" + CONFIG_PATH);
             }
-            return true;
-        } catch (IOException e) {
-            LogUtils.e(TAG, "【函数异常】loadRootConfig()，加载配置文件IO异常", e);
-            LogUtils.e(TAG, "【配置加载失败】IO异常，程序退出");
-            System.exit(1);
-            return false; // 逻辑兜底，实际不会执行
-        } finally {
-            if (fis != null) {
-                try {
-                    fis.close();
-                } catch (IOException e) {
-                    LogUtils.e(TAG, "【流关闭异常】loadRootConfig()，关闭文件流失败", e);
+            // 2. 尝试优先路径 CONFIG_PATH
+            if (checkFileValid(CONFIG_PATH)) {
+                finalLoadPath = CONFIG_PATH;
+                System.out.println("[" + TAG + "] 【路径选择】优先路径可用，使用：" + CONFIG_PATH);
+            } else {
+                // 3. 优先路径失效，尝试最终兜底 DEFAULT_CONFIG_PATH
+                System.out.println("[" + TAG + "] 【路径选择】优先路径不可用，尝试兜底路径：" + DEFAULT_CONFIG_PATH);
+                if (checkFileValid(DEFAULT_CONFIG_PATH)) {
+                    finalLoadPath = DEFAULT_CONFIG_PATH;
+                    System.out.println("[" + TAG + "] 【路径选择】兜底路径可用，使用：" + DEFAULT_CONFIG_PATH);
+                } else {
+                    // 4. 所有路径都失效，返回false
+                    System.err.println("[" + TAG + "] 【配置加载失败】优先路径+兜底路径均不可用");
+                    return false;
                 }
             }
-        }
-    }
-
-    public static boolean loadConfig(String configFilePath) {
-        LogUtils.d(TAG, "【函数调用】loadConfig()，加载指定路径：" + configFilePath);
-        // 校验失败直接退出，无兜底
-        if (!checkFileValid(configFilePath)) {
-            LogUtils.e(TAG, "【配置加载失败】指定文件校验不通过，程序退出");
-            System.exit(1);
+        } else {
+            // 传入路径有效，直接使用
+            finalLoadPath = configFilePath;
+            System.out.println("[" + TAG + "] 【函数调用】loadConfig()，加载指定有效路径：" + configFilePath);
         }
 
+        // 加载最终选定的配置文件
         FileInputStream fis = null;
         try {
             iniConfigMap.clear();
-            fis = new FileInputStream(configFilePath);
+            fis = new FileInputStream(finalLoadPath);
             boolean loadSuccess = loadIniConfig(fis);
             if (!loadSuccess) {
-                LogUtils.e(TAG, "【配置加载失败】指定INI解析失败，程序退出");
-                System.exit(1);
+                System.err.println("[" + TAG + "] 【配置加载失败】INI文件解析失败");
+                return false;
             }
+            System.out.println("[" + TAG + "] 【配置加载成功】最终加载路径：" + finalLoadPath);
             return true;
         } catch (IOException e) {
-            LogUtils.e(TAG, "【函数异常】loadConfig()，加载指定路径配置IO异常", e);
-            LogUtils.e(TAG, "【配置加载失败】IO异常，程序退出");
-            System.exit(1);
-            return false; // 逻辑兜底，实际不会执行
+            System.err.println("[" + TAG + "] 【函数异常】loadConfig()，加载配置文件IO异常");
+            e.printStackTrace();
+            return false;
         } finally {
             if (fis != null) {
                 try {
                     fis.close();
                 } catch (IOException e) {
-                    LogUtils.e(TAG, "【流关闭异常】loadConfig()，关闭文件流失败", e);
+                    System.err.println("[" + TAG + "] 【流关闭异常】loadConfig()，关闭文件流失败");
+                    e.printStackTrace();
                 }
             }
         }
     }
 
     public static boolean loadIniConfig(InputStream inputStream) {
-        LogUtils.d(TAG, "【函数调用】loadIniConfig()，输入流：" + (inputStream == null ? "null" : inputStream.getClass().getName()));
+        System.out.println("[" + TAG + "] 【函数调用】loadIniConfig()，输入流：" + (inputStream == null ? "null" : inputStream.getClass().getName()));
         if (inputStream == null) {
-            LogUtils.e(TAG, "【函数异常】loadIniConfig()，输入流为null");
+            System.err.println("[" + TAG + "] 【函数异常】loadIniConfig()，输入流为null");
             return false;
         }
 
@@ -134,7 +129,7 @@ public class IniConfigUtils {
                 if (line.startsWith("[") && line.endsWith("]")) {
                     currentSection = line.substring(1, line.length() - 1).trim();
                     iniConfigMap.put(currentSection, new HashMap<String, String>());
-                    LogUtils.d(TAG, "【解析小节】当前小节：" + currentSection);
+                    System.out.println("[" + TAG + "] 【解析小节】当前小节：" + currentSection);
                     continue;
                 }
                 if (line.contains("=") && !currentSection.isEmpty()) {
@@ -143,22 +138,24 @@ public class IniConfigUtils {
                         String key = keyValue[0].trim();
                         String value = keyValue[1].trim();
                         iniConfigMap.get(currentSection).put(key, value);
-                        LogUtils.d(TAG, "【解析配置】[" + currentSection + "] " + key + "=" + value);
+                        System.out.println("[" + TAG + "] 【解析配置】[" + currentSection + "] " + key + "=" + value);
                     }
                 }
             }
-            LogUtils.i(TAG, "【函数结束】loadIniConfig()，配置加载完成，小节数：" + iniConfigMap.size());
+            System.out.println("[" + TAG + "] 【函数结束】loadIniConfig()，配置加载完成，小节数：" + iniConfigMap.size());
             return true;
         } catch (IOException e) {
-            LogUtils.e(TAG, "【函数异常】loadIniConfig()，IO异常", e);
+            System.err.println("[" + TAG + "] 【函数异常】loadIniConfig()，IO异常");
+            e.printStackTrace();
             return false;
         } finally {
             if (br != null) {
                 try {
                     br.close();
-                    LogUtils.d(TAG, "【流关闭成功】loadIniConfig()，输入流已关闭");
+                    System.out.println("[" + TAG + "] 【流关闭成功】loadIniConfig()，输入流已关闭");
                 } catch (IOException e) {
-                    LogUtils.e(TAG, "【流关闭异常】loadIniConfig()，关闭输入流失败", e);
+                    System.err.println("[" + TAG + "] 【流关闭异常】loadIniConfig()，关闭输入流失败");
+                    e.printStackTrace();
                 }
             }
         }
@@ -166,33 +163,33 @@ public class IniConfigUtils {
 
     // ========== 配置获取方法 ==========
     public static String getConfigValue(String section, String key) {
-        LogUtils.d(TAG, "【函数调用】getConfigValue()，小节：" + section + " 键：" + key);
+        System.out.println("[" + TAG + "] 【函数调用】getConfigValue()，小节：" + section + " 键：" + key);
         if (section == null || key == null) {
-            LogUtils.w(TAG, "【参数异常】getConfigValue()，小节或键为null");
+            System.err.println("[" + TAG + "] 【参数异常】getConfigValue()，小节或键为null");
             return null;
         }
         if (!iniConfigMap.containsKey(section)) {
-            LogUtils.w(TAG, "【获取失败】getConfigValue()，不存在小节[" + section + "]");
+            System.err.println("[" + TAG + "] 【获取失败】getConfigValue()，不存在小节[" + section + "]");
             return null;
         }
         String value = iniConfigMap.get(section).get(key);
-        LogUtils.d(TAG, "【获取结果】getConfigValue()，值：" + value);
+        System.out.println("[" + TAG + "] 【获取结果】getConfigValue()，值：" + value);
         return value;
     }
 
     public static String getConfigValue(String section, String key, String defaultValue) {
-        LogUtils.d(TAG, "【函数调用】getConfigValue()，小节：" + section + " 键：" + key + " 默认值：" + defaultValue);
+        System.out.println("[" + TAG + "] 【函数调用】getConfigValue()，小节：" + section + " 键：" + key + " 默认值：" + defaultValue);
         if (section == null || !iniConfigMap.containsKey(section)) {
-            LogUtils.w(TAG, "【降级处理】getConfigValue()，小节[" + section + "]不存在，使用默认值");
+            System.err.println("[" + TAG + "] 【降级处理】getConfigValue()，小节[" + section + "]不存在，使用默认值");
             return defaultValue;
         }
         Map<String, String> sectionMap = iniConfigMap.get(section);
         if (key == null || !sectionMap.containsKey(key)) {
-            LogUtils.w(TAG, "【降级处理】getConfigValue()，键[" + key + "]不存在，使用默认值");
+            System.err.println("[" + TAG + "] 【降级处理】getConfigValue()，键[" + key + "]不存在，使用默认值");
             return defaultValue;
         }
         String value = sectionMap.get(key);
-        LogUtils.d(TAG, "【获取结果】getConfigValue()，值：" + value);
+        System.out.println("[" + TAG + "] 【获取结果】getConfigValue()，值：" + value);
         return value;
     }