调用自定义函数

src/main/java/com/example/demo/draft/demo043/ApplicationTest__01.java

@@ -44,8 +44,11 @@ public class ApplicationTest__01 {
         }
 
         // Step.2
-        String targetContent = Files.readString(Path.of(processJSONFile), StandardCharsets.UTF_8);
+//        String targetContent = Files.readString(Path.of(processJSONFile), StandardCharsets.UTF_8);
-        List<Object> list = JSON.parseArray(targetContent);
+//        List<Object> list = JSON.parseArray(targetContent);
+
+        // 通过 ｛｛key｝｝ 限制变量范围
+        List<Object> list = FormatUtil.loadJSON(processJSONFile);
 
         String templateContent = Files.readString(Path.of(inputTemplateData), StandardCharsets.UTF_8);
         ConfigDocument document = JSON.parseObject(templateContent, ConfigDocument.class);
@@ -54,7 +57,7 @@ public class ApplicationTest__01 {
         System.out.println(result);
         for(Object obj: list) {
             Map<String, String> map = JSON.parseObject(JSON.toJSONString(obj), Map.class);
-            result = FormatUtil.stealBeamsAndReplacePillars(result, map);
+            result = FormatUtil.stealBeamsAndReplacePillars(result, map, true, false, false);
         }
 
         // Step.3

src/main/java/com/example/demo/draft/demo043/ApplicationTest__03.java

@@ -44,8 +44,11 @@ public class ApplicationTest__03 {
         }
 
         // Step.2
-        String targetContent = Files.readString(Path.of(processJSONFile), StandardCharsets.UTF_8);
+//        String targetContent = Files.readString(Path.of(processJSONFile), StandardCharsets.UTF_8);
-        List<Object> list = JSON.parseArray(targetContent);
+//        List<Object> list = JSON.parseArray(targetContent);
+
+        // 通过 ｛｛key｝｝ 限制变量范围
+        List<Object> list = FormatUtil.loadJSON(processJSONFile);
 
         String templateContent = Files.readString(Path.of(inputTemplateData), StandardCharsets.UTF_8);
         ConfigDocument document = JSON.parseObject(templateContent, ConfigDocument.class);

src/main/java/com/example/demo/draft/demo043/core/EnhancedConfigProcessor.java

@@ -271,6 +271,10 @@ public class EnhancedConfigProcessor {
             params.put("context", context);
             params.put("loopIndex", loopIndex);
 
+            // 参数
+            value = params.get("params").toString();
+            params.remove("params");
+            
             // 调用工具函数
             result = callFormatUtilFunction(functionName, value, params);
             

src/main/java/com/example/demo/draft/demo043/core/TemplateFileLoader.java

@@ -12,39 +12,97 @@ import java.util.Map;
 
 /**
  * 模板文件工具类
- * 负责从文件系统或类路径加载模板文件
+ * 负责从文件系统或类路径加载模板文件，支持缓存机制提高性能
+ *
+ * <p>该类提供了以下功能：</p>
+ * <ul>
+ *   <li>从类路径加载模板文件</li>
+ *   <li>从文件系统加载模板文件</li>
+ *   <li>智能识别路径前缀自动选择加载方式</li>
+ *   <li>模板内容缓存，避免重复读取文件</li>
+ *   <li>缓存管理功能</li>
+ * </ul>
+ *
+ * <p>使用示例：</p>
+ * <pre>
+ * // 从类路径加载
+ * String template1 = TemplateFileLoader.loadTemplate("classpath:templates/default.html");
+ * // 从文件系统加载
+ * String template2 = TemplateFileLoader.loadTemplate("file:/opt/templates/default.html");
+ * // 默认从类路径加载
+ * String template3 = TemplateFileLoader.loadTemplate("templates/default.html");
+ * </pre>
+ *
+ * @author 岳佳君
+ * @version 1.0
  */
 @Slf4j
 public class TemplateFileLoader {
 
+    /**
+     * 默认模板目录路径
+     */
     private static final String DEFAULT_TEMPLATE_DIR = "templates/";
+
+    /**
+     * 类路径前缀标识符
+     */
     private static final String CLASS_PATH_PREFIX = "classpath:";
+
+    /**
+     * 文件系统路径前缀标识符
+     */
     private static final String FILE_PATH_PREFIX = "file:";
 
-    // 模板缓存
+    /**
+     * 模板缓存，使用HashMap存储已加载的模板内容
+     * Key: 缓存键（包含路径前缀和模板路径）
+     * Value: 模板文件内容
+     */
     private static final Map<String, String> TEMPLATE_CACHE = new HashMap<>();
 
     /**
      * 从类路径加载模板文件
+     *
+     * <p>该方法会首先检查缓存中是否已存在该模板，如果存在则直接返回缓存内容，
+     * 否则从类路径读取文件内容并存入缓存。</p>
+     *
+     * @param templatePath 模板文件路径，可以是相对路径或绝对路径
+     *                     （相对路径相对于类路径根目录）
+     * @return 模板文件的内容字符串
+     * @throws IOException 当模板文件未找到或读取失败时抛出
+     * @throws IllegalArgumentException 当templatePath为null或空字符串时抛出
      */
     public static String loadTemplateFromClasspath(String templatePath) throws IOException {
+        // 参数校验
+        if (templatePath == null || templatePath.trim().isEmpty()) {
+            throw new IllegalArgumentException("模板路径不能为空");
+        }
+
         String cacheKey = CLASS_PATH_PREFIX + templatePath;
+
+        // 检查缓存中是否已存在该模板
         if (TEMPLATE_CACHE.containsKey(cacheKey)) {
+            log.debug("从缓存加载类路径模板: {}", templatePath);
             return TEMPLATE_CACHE.get(cacheKey);
         }
 
         try {
-            // 从类路径加载
+            // 处理路径格式，确保以"/"开头
             String fullPath = templatePath.startsWith("/") ? templatePath : "/" + templatePath;
             java.io.InputStream inputStream = TemplateFileLoader.class.getResourceAsStream(fullPath);
 
+            // 检查文件是否存在
             if (inputStream == null) {
                 throw new IOException("模板文件未找到: " + templatePath);
             }
 
+            // 读取文件内容并转换为字符串
             String content = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+
+            // 存入缓存
             TEMPLATE_CACHE.put(cacheKey, content);
-            log.info("从类路径加载模板: {}", templatePath);
+            log.info("从类路径加载模板成功: {}", templatePath);
             return content;
 
         } catch (IOException e) {
@@ -55,22 +113,43 @@ public class TemplateFileLoader {
 
     /**
      * 从文件系统加载模板文件
+     *
+     * <p>该方法会首先检查缓存中是否已存在该模板，如果存在则直接返回缓存内容，
+     * 否则从文件系统读取文件内容并存入缓存。</p>
+     *
+     * @param filePath 模板文件的绝对路径或相对路径（相对于当前工作目录）
+     * @return 模板文件的内容字符串
+     * @throws IOException 当模板文件不存在或读取失败时抛出
+     * @throws IllegalArgumentException 当filePath为null或空字符串时抛出
      */
     public static String loadTemplateFromFileSystem(String filePath) throws IOException {
+        // 参数校验
+        if (filePath == null || filePath.trim().isEmpty()) {
+            throw new IllegalArgumentException("文件路径不能为空");
+        }
+
         String cacheKey = FILE_PATH_PREFIX + filePath;
+
+        // 检查缓存中是否已存在该模板
         if (TEMPLATE_CACHE.containsKey(cacheKey)) {
+            log.debug("从缓存加载文件系统模板: {}", filePath);
             return TEMPLATE_CACHE.get(cacheKey);
         }
 
         try {
             Path path = Paths.get(filePath);
+
+            // 检查文件是否存在
             if (!Files.exists(path)) {
                 throw new IOException("模板文件不存在: " + filePath);
             }
 
+            // 读取文件内容
             String content = Files.readString(path, StandardCharsets.UTF_8);
+
+            // 存入缓存
             TEMPLATE_CACHE.put(cacheKey, content);
-            log.info("从文件系统加载模板: {}", filePath);
+            log.info("从文件系统加载模板成功: {}", filePath);
             return content;
 
         } catch (IOException e) {
@@ -80,12 +159,31 @@ public class TemplateFileLoader {
     }
 
     /**
-     * 智能加载模板（自动判断路径类型）
+     * 智能加载模板文件（自动判断路径类型）
+     *
+     * <p>根据路径前缀自动选择加载方式：</p>
+     * <ul>
+     *   <li>以"classpath:"开头：从类路径加载</li>
+     *   <li>以"file:"开头：从文件系统加载</li>
+     *   <li>无前缀：默认从类路径加载</li>
+     * </ul>
+     *
+     * @param templatePath 模板路径，支持带前缀的完整路径或不带前缀的相对路径
+     * @return 模板文件的内容字符串
+     * @throws IOException 当模板文件加载失败时抛出
+     * @throws IllegalArgumentException 当templatePath为null或空字符串时抛出
      */
     public static String loadTemplate(String templatePath) throws IOException {
+        // 参数校验
+        if (templatePath == null || templatePath.trim().isEmpty()) {
+            throw new IllegalArgumentException("模板路径不能为空");
+        }
+
         if (templatePath.startsWith(CLASS_PATH_PREFIX)) {
+            // 从类路径加载，去掉前缀
             return loadTemplateFromClasspath(templatePath.substring(CLASS_PATH_PREFIX.length()));
         } else if (templatePath.startsWith(FILE_PATH_PREFIX)) {
+            // 从文件系统加载，去掉前缀
             return loadTemplateFromFileSystem(templatePath.substring(FILE_PATH_PREFIX.length()));
         } else {
             // 默认从类路径加载
@@ -94,17 +192,33 @@ public class TemplateFileLoader {
     }
 
     /**
-     * 清除模板缓存
+     * 清除所有模板缓存
+     *
+     * <p>该方法会清空当前内存中所有的模板缓存，适用于需要强制重新加载模板的场景，
+     * 比如模板文件内容已更新但缓存还未过期的情况。</p>
      */
     public static void clearCache() {
+        int cacheSize = TEMPLATE_CACHE.size();
         TEMPLATE_CACHE.clear();
-        log.info("模板缓存已清除");
+        log.info("模板缓存已清除，原缓存大小: {}", cacheSize);
     }
 
     /**
-     * 获取缓存中的模板数量
+     * 获取当前缓存中的模板数量
+     *
+     * @return 缓存中模板的数量
      */
     public static int getCacheSize() {
         return TEMPLATE_CACHE.size();
     }
+
+    /**
+     * 检查指定路径的模板是否已缓存
+     *
+     * @param templatePath 模板路径（需要包含完整的前缀）
+     * @return 如果模板已缓存返回true，否则返回false
+     */
+    public static boolean isCached(String templatePath) {
+        return TEMPLATE_CACHE.containsKey(templatePath);
+    }
 }

src/main/java/com/example/demo/draft/demo043/core/Xml2AFSIMTransformation.java

@@ -13,34 +13,87 @@ import java.util.Map;
 import java.util.Stack;
 import java.util.regex.Pattern;
 
+/**
+ * XML转AFSIM格式转换器
+ *
+ * <p>该类提供将XML文件转换为JSON格式并应用正则表达式规则进行键名转换的功能。
+ * 采用流式处理方式，适用于处理大型XML文件，避免内存溢出。</p>
+ *
+ * <p>主要功能：</p>
+ * <ul>
+ *   <li>流式解析XML文件，降低内存占用</li>
+ *   <li>支持正则表达式规则对JSON键名进行转换</li>
+ *   <li>自动处理XML属性和元素内容</li>
+ *   <li>生成标准JSON数组格式输出</li>
+ * </ul>
+ *
+ * @author 岳佳君
+ * @version 1.0
+ */
 @Slf4j
 public class Xml2AFSIMTransformation {
 
+    /**
+     * 正则表达式规则映射
+     * Key: 编译后的正则表达式模式
+     * Value: 替换字符串
+     */
     private final Map<Pattern, String> regexRules;
 
+    /**
+     * 构造函数，初始化转换规则
+     *
+     * @param rules 转换规则映射，Key为匹配的正则表达式，Value为替换字符串
+     *              如果为null，则使用空规则集
+     */
     public Xml2AFSIMTransformation(Map<String, String> rules) {
-        log.info("初始化转换器，规则数量: {}", rules != null ? rules.size() : 0);
+        log.info("初始化XML转AFSIM转换器，规则数量: {}", rules != null ? rules.size() : 0);
         // 编译正则表达式规则
         regexRules = new HashMap<>();
         if (rules != null) {
             for (Map.Entry<String, String> entry : rules.entrySet()) {
+                // 预编译正则表达式以提高性能
                 regexRules.put(Pattern.compile(entry.getKey()), entry.getValue());
             }
         }
+        log.debug("正则表达式规则编译完成");
     }
 
     /**
-     * 流式XML转JSON并应用转换规则
+     * 将XML文件转换为JSON格式并应用转换规则
+     *
+     * <p>该方法使用StAX流式API解析XML，适用于处理大型文件。
+     * 转换后的JSON格式为对象数组，每个XML根元素对应一个JSON对象。</p>
+     *
+     * @param xmlFile     输入的XML文件，不能为null
+     * @param jsonFile    输出的JSON文件，不能为null
+     * @param rootElement 根元素名称，用于标识每个JSON对象的开始和结束
+     * @throws Exception 当文件读写失败、XML解析错误或转换过程中出现异常时抛出
+     * @throws IllegalArgumentException 当参数为null或空字符串时抛出
      */
     public void convertXmlToJson(File xmlFile, File jsonFile, String rootElement) throws Exception {
+        // 参数校验
+        if (xmlFile == null || !xmlFile.exists()) {
+            throw new IllegalArgumentException("XML文件不存在或为null: " + xmlFile);
+        }
+        if (jsonFile == null) {
+            throw new IllegalArgumentException("JSON文件路径不能为null");
+        }
+        if (rootElement == null || rootElement.trim().isEmpty()) {
+            throw new IllegalArgumentException("根元素名称不能为空");
+        }
+
         log.info("开始XML转JSON转换并应用规则");
+        log.debug("输入文件: {}, 输出文件: {}, 根元素: {}", xmlFile.getPath(), jsonFile.getPath(), rootElement);
 
         try (FileInputStream xmlInputStream = new FileInputStream(xmlFile);
              FileWriter jsonWriter = new FileWriter(jsonFile)) {
 
+            // 创建XML流读取器
             XMLInputFactory factory = XMLInputFactory.newInstance();
             XMLStreamReader reader = factory.createXMLStreamReader(xmlInputStream);
 
+            // 写入JSON数组开始标记
             jsonWriter.write("[\n");
 
             boolean firstObject = true;
@@ -52,6 +105,7 @@ public class Xml2AFSIMTransformation {
             StringBuilder currentText = new StringBuilder();
             String currentElement = null;
 
+            // 流式解析XML
             while (reader.hasNext()) {
                 int event = reader.next();
 
@@ -80,7 +134,7 @@ public class Xml2AFSIMTransformation {
                             String text = reader.getText().trim();
                             if (!text.isEmpty()) {
                                 currentText.append(text);
-                                log.debug("文本内容: {}", text);
+                                log.trace("文本内容: {}", text);
                             }
                         }
                         break;
@@ -112,6 +166,7 @@ public class Xml2AFSIMTransformation {
                                 jsonWriter.write(json);
                                 objectCount++;
 
+                                // 每处理100个对象刷新一次缓冲区并记录日志
                                 if (objectCount % 100 == 0) {
                                     log.info("已处理 {} 个对象", objectCount);
                                     jsonWriter.flush();
@@ -125,48 +180,68 @@ public class Xml2AFSIMTransformation {
                 }
             }
 
+            // 写入JSON数组结束标记
             jsonWriter.write("\n]");
             log.info("转换完成，共处理 {} 个对象", objectCount);
 
         } catch (Exception e) {
-            log.error("转换失败", e);
+            log.error("XML转JSON转换失败，文件: {}", xmlFile.getPath(), e);
             throw e;
         }
     }
 
     /**
-     * 处理元素的属性
+     * 处理XML元素的属性
+     *
+     * <p>将元素的属性添加到当前对象中，属性键名为"元素名@属性名"格式</p>
+     *
+     * @param reader XML流读取器
+     * @param elementStack 元素栈，用于跟踪当前解析路径
+     * @param currentObject 当前正在构建的对象
      */
     private void processAttributesForElement(XMLStreamReader reader, Stack<String> elementStack,
                                              Map<String, Object> currentObject) {
-        if (reader.getAttributeCount() > 0) {
+        int attributeCount = reader.getAttributeCount();
-            for (int i = 0; i < reader.getAttributeCount(); i++) {
+        if (attributeCount > 0) {
+            log.debug("处理元素 {} 的属性，属性数量: {}", elementStack.peek(), attributeCount);
+            for (int i = 0; i < attributeCount; i++) {
                 String attrName = reader.getAttributeLocalName(i);
                 String attrValue = reader.getAttributeValue(i);
-                // 默认处理：将属性添加到对象中
+                // 将属性添加到对象中，格式为：元素名@属性名
                 String attrKey = elementStack.peek() + "@" + attrName;
                 currentObject.put(attrKey, attrValue);
+                log.trace("添加属性: {} = {}", attrKey, attrValue);
             }
         }
     }
 
     /**
-     * 处理元素文本内容
+     * 处理XML元素的文本内容
+     *
+     * <p>将元素的文本内容添加到当前对象中，键名为完整的元素路径</p>
+     *
+     * @param elementName 元素名称
+     * @param content 元素文本内容
+     * @param elementStack 元素栈，用于构建完整路径
+     * @param currentObject 当前正在构建的对象
      */
     private void processElementContent(String elementName, String content,
                                        Stack<String> elementStack, Map<String, Object> currentObject) {
-        // 默认处理：将元素内容添加到对象中
+        // 构建完整的元素路径作为key：父元素.当前元素
-        // 构建完整的元素路径作为key
         String elementKey = String.join(".", elementStack) + "." + elementName;
         currentObject.put(elementKey, content);
+        log.debug("添加元素内容: {} = {}", elementKey, content);
     }
 
     /**
-     * 将对象转换为JSON字符串
+     * 将Map对象转换为JSON字符串
+     *
+     * @param object 要转换的对象映射
+     * @return JSON格式的字符串，如果对象为空则返回null
      */
     private String convertObjectToJson(Map<String, Object> object) {
-        if (object.isEmpty()) {
+        if (object == null || object.isEmpty()) {
-            log.warn("空对象，跳过输出");
+            log.warn("空对象，跳过JSON转换");
             return null;
         }
 
@@ -174,12 +249,15 @@ public class Xml2AFSIMTransformation {
             return mapToJson(object);
         } catch (Exception e) {
             log.error("对象转JSON失败", e);
-            return "{}";
+            return "{}"; // 返回空对象作为容错处理
         }
     }
 
     /**
-     * Map转JSON字符串
+     * 递归将Map转换为JSON字符串
+     *
+     * @param map 要转换的映射
+     * @return JSON对象字符串
      */
     private String mapToJson(Map<String, Object> map) {
         if (map.isEmpty()) {
@@ -204,7 +282,10 @@ public class Xml2AFSIMTransformation {
     }
 
     /**
-     * 值转JSON
+     * 将值转换为JSON格式
+     *
+     * @param value 要转换的值，支持String、Number、Boolean、Map、List等类型
+     * @return JSON格式的值表示
      */
     private String valueToJson(Object value) {
         if (value == null) {
@@ -239,14 +320,21 @@ public class Xml2AFSIMTransformation {
             return json.toString();
         }
 
+        // 默认处理：转换为字符串
         return "\"" + escapeJson(value.toString()) + "\"";
     }
 
     /**
-     * JSON特殊字符转义
+     * JSON字符串转义处理
+     *
+     * <p>转义JSON中的特殊字符，包括引号、反斜杠、控制字符等</p>
+     *
+     * @param text 要转义的文本
+     * @return 转义后的安全JSON字符串
      */
     private String escapeJson(String text) {
         if (text == null) return "";
+
         return text.replace("\\", "\\\\")
                 .replace("\"", "\\\"")
                 .replace("\b", "\\b")
@@ -258,6 +346,11 @@ public class Xml2AFSIMTransformation {
 
     /**
      * 应用正则表达式转换规则到单个对象
+     *
+     * <p>遍历对象的所有键，对每个键应用正则表达式规则进行转换</p>
+     *
+     * @param originalMap 原始对象映射
+     * @return 应用规则转换后的新对象映射
      */
     private Map<String, Object> applyRules(Map<String, Object> originalMap) {
         Map<String, Object> transformedMap = new HashMap<>();
@@ -270,25 +363,32 @@ public class Xml2AFSIMTransformation {
             // 如果找到匹配的规则则使用新key，否则保留原key
             if (newKey != null) {
                 transformedMap.put(newKey, value);
-                log.debug("转换键: {} -> {}", originalKey, newKey);
+                log.debug("键名转换: {} -> {}", originalKey, newKey);
             } else {
                 transformedMap.put(originalKey, value);
             }
         }
 
+        log.debug("规则应用完成，原始键数: {}, 转换后键数: {}", originalMap.size(), transformedMap.size());
         return transformedMap;
     }
 
     /**
      * 查找并替换匹配的正则规则
+     *
+     * <p>遍历所有正则规则，找到第一个匹配的规则并进行替换</p>
+     *
+     * @param originalKey 原始键名
+     * @return 替换后的新键名，如果没有匹配规则则返回null
      */
     private String findAndReplace(String originalKey) {
         for (Map.Entry<Pattern, String> rule : regexRules.entrySet()) {
             if (rule.getKey().matcher(originalKey).matches()) {
-                return rule.getKey().matcher(originalKey).replaceAll(rule.getValue());
+                String newKey = rule.getKey().matcher(originalKey).replaceAll(rule.getValue());
+                log.trace("正则匹配: {} -> {} (规则: {})", originalKey, newKey, rule.getKey().pattern());
+                return newKey;
             }
         }
         return null;
     }
-
 }

src/main/resources/data/01-作战部队武器装备/20250923_6b399e.xml

@@ -2,6 +2,6 @@
 <作战部队武器装备>
     <装备类型>武装直升机</装备类型>
     <武器装备型号>Z-10</武器装备型号>
-    <武器装备名称>直-10攻击直升机</武器装备名称>
+    <武器装备型号名称>直-10攻击直升机</武器装备型号名称>
     <武器装备数量>18</武器装备数量>
 </作战部队武器装备>

src/main/resources/data/01-作战部队武器装备/20250923_6ba0d8.xml

@@ -2,6 +2,6 @@
 <作战部队武器装备>
     <装备类型>自行火炮</装备类型>
     <武器装备型号>PLZ-05</武器装备型号>
-    <武器装备名称>05式自行榴弹炮</武器装备名称>
+    <武器装备型号名称>05式自行榴弹炮</武器装备型号名称>
     <武器装备数量>36</武器装备数量>
 </作战部队武器装备>

src/main/resources/data/01-作战部队武器装备/20250923_9efa34.xml

@@ -2,6 +2,6 @@
 <作战部队武器装备>
     <装备类型>战斗机</装备类型>
     <武器装备型号>J-20</武器装备型号>
-    <武器装备名称>歼-20隐形战斗机</武器装备名称>
+    <武器装备型号名称>歼-20隐形战斗机</武器装备型号名称>
     <武器装备数量>24</武器装备数量>
 </作战部队武器装备>

src/main/resources/data/01-作战部队武器装备/20250923_b345dd.xml

@@ -2,6 +2,6 @@
 <作战部队武器装备>
     <装备类型>主战坦克</装备类型>
     <武器装备型号>99A</武器装备型号>
-    <武器装备名称>99A式主战坦克</武器装备名称>
+    <武器装备型号名称>99A式主战坦克</武器装备型号名称>
     <武器装备数量>50</武器装备数量>
 </作战部队武器装备>

src/main/resources/data/01-作战部队武器装备/20250923_e9dd05.xml

@@ -2,6 +2,6 @@
 <作战部队武器装备>
     <装备类型>驱逐舰</装备类型>
     <武器装备型号>055</武器装备型号>
-    <武器装备名称>055型导弹驱逐舰</武器装备名称>
+    <武器装备型号名称>055型导弹驱逐舰</武器装备型号名称>
     <武器装备数量>2</武器装备数量>
 </作战部队武器装备>

src/main/resources/data/01-作战部队武器装备/default.json

@@ -13,7 +13,7 @@
               "values": [
                 {
                   "combined": false,
-                  "value": "string batchnumber = \"作战部队武器装备.武器装备数量\""
+                  "value": "string batchnumber = \"{{作战部队武器装备.武器装备数量}}\""
                 }
               ]
             }
@@ -70,8 +70,8 @@
         }
       ],
       "values": [
-        "作战部队武器装备.武器装备名称",
+        "{{作战部队武器装备.武器装备型号名称}}",
-        "作战部队武器装备.武器装备型号"
+        "{{作战部队武器装备.武器装备型号}}"
       ]
     }
   ]

src/main/resources/data/03-任务航线/20250923_422dc2.xml

@@ -2,7 +2,7 @@
 <任务航线>
     <航线点型号>WP003</航线点型号>
     <航线点名称>目标区域</航线点名称>
-    <航线点坐标>40.0042,116.6074</航线点坐标>
+    <航线点坐标>120.3826,36.0673</航线点坐标> <!-- 青岛 -->
     <航线点类型>目标点</航线点类型>
     <准时到达时间>08:45:00</准时到达时间>
     <转弯方式>盘旋</转弯方式>

src/main/resources/data/03-任务航线/20250923_4c32c8.xml

@@ -2,7 +2,7 @@
 <任务航线>
     <航线点型号>WP002</航线点型号>
     <航线点名称>导航点A</航线点名称>
-    <航线点坐标>39.9242,116.5074</航线点坐标>
+    <航线点坐标>121.61,38.92</航线点坐标> <!-- 大连 -->
     <航线点类型>航路点</航线点类型>
     <准时到达时间>08:15:30</准时到达时间>
     <转弯方式>飞越转弯</转弯方式>

src/main/resources/data/03-任务航线/20250923_82c579.xml

@@ -2,7 +2,7 @@
 <任务航线>
     <航线点型号>WP005</航线点型号>
     <航线点名称>降落点</航线点名称>
-    <航线点坐标>39.9042,116.4074</航线点坐标>
+    <航线点坐标>119.31,39.95</航线点坐标> <!-- 秦皇岛 -->
     <航线点类型>降落点</航线点类型>
     <准时到达时间>09:45:00</准时到达时间>
     <转弯方式>直接进近</转弯方式>

src/main/resources/data/03-任务航线/20250923_b43a26.xml

@@ -2,7 +2,7 @@
 <任务航线>
     <航线点型号>WP001</航线点型号>
     <航线点名称>起飞点</航线点名称>
-    <航线点坐标>39.9042,116.4074</航线点坐标>
+    <航线点坐标>118.04,24.27</航线点坐标> <!-- 厦门 -->
     <航线点类型>起飞点</航线点类型>
     <准时到达时间>08:00:00</准时到达时间>
     <转弯方式>直接转弯</转弯方式>

src/main/resources/data/03-任务航线/20250923_c87aa1.xml

@@ -2,7 +2,7 @@
 <任务航线>
     <航线点型号>WP004</航线点型号>
     <航线点名称>返航点</航线点名称>
-    <航线点坐标>39.9542,116.4574</航线点坐标>
+    <航线点坐标>110.37,21.27</航线点坐标> <!-- 湛江 -->
     <航线点类型>返航点</航线点类型>
     <准时到达时间>09:30:00</准时到达时间>
     <转弯方式>标准转弯</转弯方式>

src/main/resources/data/03-任务航线/default.json

@@ -18,11 +18,27 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "39.9242N"
+                      "value": "{{任务航线.北纬}}",
+                      "utilFunction": {
+                        "regexReplace": {
+                          "params": "{{任务航线.航线点坐标}}",
+                          "description": "通过正则表达式获取经纬度",
+                          "pattern": "([0-9]+[\\.]{0,}[0-9]{0,}),([0-9]+[\\.]{0,}[0-9]{0,})",
+                          "replacement": "$2N"
+                        }
+                      }
                     },
                     {
                       "combined": false,
-                      "value": "116.5074E"
+                      "value": "{{任务航线.东经}}",
+                      "utilFunction": {
+                        "regexReplace": {
+                          "params": "{{任务航线.航线点坐标}}",
+                          "description": "通过正则表达式获取经纬度",
+                          "pattern": "([0-9]+[\\.]{0,}[0-9]{0,}),([0-9]+[\\.]{0,}[0-9]{0,})",
+                          "replacement": "$1E"
+                        }
+                      }
                     }
                   ]
                 },
@@ -32,7 +48,7 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "任务航线.航线点类型"
+                      "value": "{{任务航线.航线点类型}}"
                     }
                   ]
                 },
@@ -42,7 +58,7 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "任务航线.准时到达时间"
+                      "value": "{{任务航线.准时到达时间}}"
                     }
                   ]
                 },
@@ -52,7 +68,7 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "任务航线.转弯方式"
+                      "value": "{{任务航线.转弯方式}}"
                     }
                   ]
                 },
@@ -62,7 +78,7 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "任务航线.转向方式"
+                      "value": "{{任务航线.转向方式}}"
                     }
                   ]
                 },
@@ -73,7 +89,7 @@
                     {
                       "combined": false,
                       "unit": "deg",
-                      "value": "任务航线.坡度"
+                      "value": "{{任务航线.坡度}}"
                     }
                   ]
                 },
@@ -84,7 +100,7 @@
                     {
                       "combined": false,
                       "unit": "km/h",
-                      "value": "任务航线.速度"
+                      "value": "{{任务航线.速度}}"
                     }
                   ]
                 },
@@ -95,7 +111,7 @@
                     {
                       "combined": false,
                       "unit": "m",
-                      "value": "任务航线.高度"
+                      "value": "{{任务航线.高度}}"
                     }
                   ]
                 },
@@ -105,7 +121,7 @@
                   "values": [
                     {
                       "combined": false,
-                      "value": "任务航线.高度属性"
+                      "value": "{{任务航线.高度属性}}"
                     }
                   ]
                 },
@@ -116,14 +132,14 @@
                     {
                       "combined": false,
                       "unit": "m/s",
-                      "value": "任务航线.升降率"
+                      "value": "{{任务航线.升降率}}"
                     }
                   ]
                 }
               ],
               "values": [
-                "任务航线.航线点型号",
+                "{{任务航线.航线点型号}}",
-                "任务航线.航线点名称"
+                "{{任务航线.航线点名称}}"
               ]
             }
           ],

src/test/java/com/example/demo/FormatUtilTest.java

@@ -1,5 +1,6 @@
 package com.example.demo;
 
+import com.alibaba.fastjson2.JSON;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.BeforeEach;
@@ -9,6 +10,7 @@ import static org.junit.jupiter.api.Assertions.*;
 import com.example.demo.draft.demo043.util.FormatUtil;
 
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
 import lombok.extern.slf4j.Slf4j;
@@ -72,7 +74,7 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>转换后的时间格式正确</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 正常格式转换")
+    @DisplayName("formatTime - 时间，正常格式转换 - 【已验证】")
     void testFormatTime_NormalConversion() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 正常格式转换 ==========");
@@ -81,24 +83,18 @@ public class FormatUtilTest {
         String inputTime = "2024-01-15 14:30:25";
         params.put("fromFormat", "yyyy-MM-dd HH:mm:ss");
         params.put("toFormat", "yyyy/MM/dd");
-        
         log.info("输入参数:");
         log.info("  - 时间字符串: {}", inputTime);
         log.info("  - 源格式: {}", params.get("fromFormat"));
         log.info("  - 目标格式: {}", params.get("toFormat"));
-        
-        // 预期结果
-        String expectedResult = "2024/01/15";
-        log.info("预期结果: {}", expectedResult);
-        
         // 执行测试
         Object result = FormatUtil.formatTime(inputTime, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
+        String expectedResult = "2024/01/15";
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
         assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 格式转换结果正确");
     }
     
@@ -107,10 +103,10 @@ public class FormatUtilTest {
      * 
      * <p><b>测试目的：</b>验证formatTime方法对空值的容错处理</p>
      * <p><b>测试场景：</b>输入时间为空字符串</p>
-     * <p><b>预期结果：</b>返回空字符串或默认值</p>
+     * <p><b>预期结果：</b>返回空字符串</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 空值处理")
+    @DisplayName("formatTime - 需要格式化时间的获取到空串 - 【已验证】")
     void testFormatTime_EmptyInput() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 空值处理 ==========");
@@ -119,23 +115,19 @@ public class FormatUtilTest {
         String inputTime = "";
         params.put("fromFormat", "yyyy-MM-dd");
         params.put("toFormat", "yyyy/MM/dd");
-        
         log.info("输入参数:");
         log.info("  - 时间字符串: '{}' (空字符串)", inputTime);
         log.info("  - 源格式: {}", params.get("fromFormat"));
         log.info("  - 目标格式: {}", params.get("toFormat"));
-        
-        // 预期结果
-        log.info("预期结果: 非空结果（空字符串或默认值）");
-        
         // 执行测试
         Object result = FormatUtil.formatTime(inputTime, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
+        String expectedResult = "";
+        log.info("预期结果: ''，（空字符串）");
+        log.info("实际结果: '{}'", result);
         assertNotNull(result);
+        assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 空值处理正确");
     }
     
@@ -147,7 +139,7 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>输出原值</p>
      */
     @Test
-    @DisplayName("formatTime方法测试 - 格式不匹配")
+    @DisplayName("formatTime - 格式不匹配")
     void testFormatTime_FormatMismatch() {
         System.out.println();
         log.info("========== 时间格式化模块测试 - 格式不匹配 ==========");
@@ -185,31 +177,39 @@ public class FormatUtilTest {
      * <p><b>预期结果：</b>正确提取开始时间</p>
      */
     @Test
-    @DisplayName("extractTimeRange方法测试 - 正常提取开始时间")
+    @DisplayName("extractTimeRange - 时间范围内(t1 ~ t2)，正常提取开始时间 - 【已验证】")
     void testExtractTimeRange_ExtractStartTime() {
         System.out.println();
         log.info("========== 时间范围提取模块测试 - 正常提取开始时间 ==========");
         
         // 输入参数
-        String inputTimeRange = "2024-01-15 14:30:25 - 2024-01-15 16:45:30";
+        String inputTimeRange1 = "2024-01-15 14:30:25 ~ 2024-01-15 16:45:30";
         params.put("type", "start");
-        
         log.info("输入参数:");
-        log.info("  - 时间范围字符串: {}", inputTimeRange);
+        log.info("  - 时间范围字符串: {}", inputTimeRange1);
         log.info("  - 提取类型: {}", params.get("type"));
-        
-        // 预期结果
-        String expectedResult = "2024-01-15 14:30:25";
-        log.info("预期结果: {}", expectedResult);
-        
         // 执行测试
-        Object result = FormatUtil.extractTimeRange(inputTimeRange, params);
+        Object result1 = FormatUtil.extractTimeRange(inputTimeRange1, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
-        assertEquals(expectedResult, result);
+        String expectedResult1 = "2024-01-15 14:30:25";
+        log.info("预期结果：'{}'", expectedResult1);
+        log.info("实际结果：'{}'", result1);
+        assertEquals(expectedResult1, result1);
+
+        // 输入参数
+        String inputTimeRange2 = "2024-01-15 ~ 2024-01-15 ";
+        params.put("type", "start");
+        log.info("输入参数:");
+        log.info("  - 时间范围字符串: {}", inputTimeRange2);
+        log.info("  - 提取类型: {}", params.get("type"));
+        // 执行测试
+        Object result2 = FormatUtil.extractTimeRange(inputTimeRange2, params);
+        // 断言验证
+        String expectedResult2 = "2024-01-15";
+        log.info("预期结果：'{}'", expectedResult2);
+        log.info("实际结果：'{}'", result2);
+        assertEquals(expectedResult2, result2);
+
         log.info("✓ 测试通过 - 开始时间提取正确");
     }
     
@@ -218,10 +218,10 @@ public class FormatUtilTest {
      * 
      * <p><b>测试目的：</b>验证extractTimeRange方法对无分隔符情况的处理</p>
      * <p><b>测试场景：</b>时间范围字符串中无分隔符</p>
-     * <p><b>预期结果：</b>返回原始字符串或错误信息</p>
+     * <p><b>预期结果：</b>返回原始字符串</p>
      */
     @Test
-    @DisplayName("extractTimeRange方法测试 - 无分隔符处理")
+    @DisplayName("extractTimeRange - 无分隔符情况下，获取开始时间 - 【已验证】")
     void testExtractTimeRange_NoSeparator() {
         System.out.println();
         log.info("========== 时间范围提取模块测试 - 无分隔符处理 ==========");
@@ -241,11 +241,13 @@ public class FormatUtilTest {
         // 执行测试
         Object result = FormatUtil.extractTimeRange(inputTimeRange, params);
 
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
+        String expectedResult = "2024-01-15 14:30:25";
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
         assertNotNull(result);
+        assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 无分隔符处理正确");
     }
     
@@ -257,7 +259,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
      */
     @Test
-    @DisplayName("dynamicTimeFormat方法测试 - 标准格式识别")
+    @DisplayName("dynamicTimeFormat - 标准格式识别")
     void testDynamicTimeFormat_StandardFormat() {
         System.out.println();
         log.info("========== 动态时间格式化模块测试 - 标准格式识别 ==========");
@@ -293,7 +295,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>正确识别并转换为目标格式</p>
      */
     @Test
-    @DisplayName("dynamicTimeFormat方法测试 - 中文格式识别")
+    @DisplayName("dynamicTimeFormat - 中文格式识别")
     void testDynamicTimeFormat_ChineseFormat() {
         System.out.println();
         log.info("========== 动态时间格式化模块测试 - 中文格式识别 ==========");
@@ -329,7 +331,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回true</p>
      */
     @Test
-    @DisplayName("validateTimeFormat方法测试 - 格式验证通过")
+    @DisplayName("validateTimeFormat - 格式验证通过")
     void testValidateTimeFormat_ValidFormat() {
         System.out.println();
         log.info("========== 时间格式验证模块测试 - 格式验证通过 ==========");
@@ -366,7 +368,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回false</p>
      */
     @Test
-    @DisplayName("validateTimeFormat方法测试 - 格式验证失败")
+    @DisplayName("validateTimeFormat - 格式验证失败")
     void testValidateTimeFormat_InvalidFormat() {
         System.out.println();
         log.info("========== 时间格式验证模块测试 - 格式验证失败 ==========");
@@ -406,7 +408,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>截取结果正确</p>
      */
     @Test
-    @DisplayName("substring方法测试 - 正常截取")
+    @DisplayName("substring - 正常截取")
     void testSubstring_NormalCase() {
         System.out.println();
         log.info("========== 字符串截取模块测试 - 正常截取 ==========");
@@ -446,7 +448,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回空字符串或错误信息</p>
      */
     @Test
-    @DisplayName("substring方法测试 - 起始位置超界")
+    @DisplayName("substring - 起始位置超界 - 【验证中】")
     void testSubstring_StartOutOfBounds() {
         System.out.println();
         log.info("========== 字符串截取模块测试 - 起始位置超界 ==========");
@@ -486,7 +488,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>替换结果正确</p>
      */
     @Test
-    @DisplayName("regexReplace方法测试 - 正则替换")
+    @DisplayName("regexReplace - 正则替换 - 【已验证】")
     void testRegexReplace_NormalCase() {
         System.out.println();
         log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
@@ -495,7 +497,7 @@ public class FormatUtilTest {
         String inputString = "abc123def456";
         String regex = "\\d+";
         String replacement = "*";
-        params.put("regex", regex);
+        params.put("pattern", regex);
         params.put("replacement", replacement);
         
         log.info("输入参数:");
@@ -503,21 +505,94 @@ public class FormatUtilTest {
         log.info("  - 正则表达式: {}", regex);
         log.info("  - 替换字符串: {}", replacement);
 
-        // 预期结果
-        String expectedResult = "abc*def*";
-        log.info("预期结果: {}", expectedResult);
-        
         // 执行测试
         Object result = FormatUtil.regexReplace(inputString, params);
 
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
+        String expectedResult = "abc*def*";
+        log.info("预期结果: {}", expectedResult);
+        log.info("实际结果: {}", result);
         assertEquals(expectedResult, result);
         log.info("✓ 测试通过 - 正则替换正确");
     }
 
+    /**
+     * 测试regexReplace方法 - 正则表达式替换
+     *
+     * <p><b>测试目的：</b>验证regexReplace方法能够正确进行正则替换</p>
+     * <p><b>测试场景：</b>替换字符串中的数字</p>
+     * <p><b>预计结果：</b>替换结果正确</p>
+     */
+    @Test
+    @DisplayName("regexReplace - 正则替换、分组替换、大小写敏感替换 - 【已验证】")
+    void testRegexReplace_NormalCase4() {
+        System.out.println();
+        log.info("========== 正则表达式替换模块测试 - 正则替换 ==========");
+
+        // 输入参数
+        String inputString = "abc123def456";
+        String regex = "\\d+";
+        String replacement = "*";
+        params.put("pattern", regex);
+        params.put("replacement", replacement);
+
+
+        // 测试用例1：数字替换
+        String inputString1 = "abc123def456";
+        Map<String, Object> params1 = new HashMap<>();
+        params1.put("pattern", "\\d+");
+        params1.put("replacement", "*");
+        String result1 = FormatUtil.regexReplace(inputString1, params1);
+        log.info("实际结果 (1): " + result1);
+        // 断言验证
+        String expectedResult1 = "abc*def*";
+        log.info("预期结果：'{}'", expectedResult1);
+        log.info("实际结果：'{}'", result1);
+        assertEquals(expectedResult1, result1);
+
+        // 测试用例2：分组引用替换
+        String inputString2 = "电话: 123-456";
+        Map<String, Object> params2 = new HashMap<>();
+        params2.put("pattern", "(\\d+)-(\\d+)");
+        params2.put("replacement", "$2到$1");
+        String result2 = FormatUtil.regexReplace(inputString2, params2);
+        log.info("实际结果 (2): " + result2);
+        // 断言验证
+        String expectedResult2 = "电话: 456到123";
+        log.info("预期结果：'{}'", expectedResult2);
+        log.info("实际结果：'{}'", result2);
+        assertEquals(expectedResult2, result2);
+
+        // 测试用例3：大小写不敏感
+        String inputString3 = "Hello World";
+        Map<String, Object> params3 = new HashMap<>();
+        params3.put("pattern", "hello");
+        params3.put("replacement", "HI");
+        params3.put("flags", "CASE_INSENSITIVE");
+        String result3 = FormatUtil.regexReplace(inputString3, params3);
+        log.info("实际结果 (3): " + result3);
+        // 断言验证
+        String expectedResult3 = "HI World";
+        log.info("预期结果：'{}'", expectedResult3);
+        log.info("实际结果：'{}'", result3);
+        assertEquals(expectedResult3, result3);
+
+        // 测试用例4：大小写不敏感
+        String inputString4 = "Hello World";
+        Map<String, Object> params4 = new HashMap<>();
+        params4.put("pattern", "hello");
+        params4.put("replacement", "HI");
+        String result4 = FormatUtil.regexReplace(inputString4, params4);
+        log.info("实际结果 (4): " + result4);
+        // 断言验证
+        String expectedResult4 = "Hello World";
+        log.info("预期结果：'{}'", expectedResult4);
+        log.info("实际结果：'{}'", result4);
+        assertEquals(expectedResult4, result4);
+
+        log.info("✓ 测试通过 - 正则替换正确");
+    }
+    
     /**
      * 测试toUpperCase方法 - 大小写转换
      * 
@@ -526,7 +601,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("toUpperCase方法测试 - 大小写转换")
+    @DisplayName("toUpperCase - 大小写转换")
     void testToUpperCase_NormalCase() {
         System.out.println();
         log.info("========== 字符串大小写转换模块测试 - 大小写转换 ==========");
@@ -560,30 +635,24 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>去除空格后结果正确</p>
      */
     @Test
-    @DisplayName("trim方法测试 - 去除空格")
+    @DisplayName("trim - 字符串，去除空格 - 【已验证】")
     void testTrim_NormalCase() {
         System.out.println();
         log.info("========== 字符串空格处理模块测试 - 去除空格 ==========");
         
         // 输入参数
         String inputString = "  hello world  ";
-        
         log.info("输入参数:");
         log.info("  - 输入字符串: '{}'", inputString);
         log.info("  - 注意: 字符串前后有空格");
-        
-        // 预期结果
-        String expectedResult = "hello world";
-        log.info("预期结果: '{}'", expectedResult);
-        
         // 执行测试
         Object result = FormatUtil.trim(inputString, params);
-        
-        // 实际结果
-        log.info("实际结果: '{}'", result);
-        
         // 断言验证
+        String expectedResult = "hello world";
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
         assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 空格去除正确");
     }
     
@@ -595,7 +664,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 基础替换")
+    @DisplayName("stealBeamsAndReplacePillars - 基础替换")
     void testStealBeamsAndReplacePillars_BasicReplacement() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 基础替换 ==========");
@@ -633,7 +702,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>大小写敏感替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 大小写敏感")
+    @DisplayName("stealBeamsAndReplacePillars - 批量Map替换，大小写敏感 - 【已验证】")
     void testStealBeamsAndReplacePillars_CaseSensitive() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 大小写敏感替换 ==========");
@@ -644,24 +713,17 @@ public class FormatUtilTest {
         replacementMap.put("Hello", "Hi");
         replacementMap.put("world", "universe");
         boolean caseSensitive = true;
-        
         log.info("输入参数:");
         log.info("  - 输入字符串: {}", inputString);
-        log.info("  - 替换映射: {}", replacementMap);
+        log.info("  - 替换映射: {}", JSON.toJSONString(replacementMap));
         log.info("  - 大小写敏感: {}", caseSensitive);
         log.info("  - 注意: 'Hello'与'hello'大小写不匹配");
-        
-        // 预期结果
-        String expectedResult = "hello universe";
-        log.info("预期结果: {}", expectedResult);
-        
         // 执行测试
         String result = FormatUtil.stealBeamsAndReplacePillars(inputString, replacementMap, caseSensitive);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
+        String expectedResult = "hello universe";
+        log.info("预期结果：'{}'", expectedResult);
+        log.info("实际结果：'{}'", result);
         assertEquals(expectedResult, result);
         log.info("✓ 测试通过 - 大小写敏感替换正确");
     }
@@ -674,7 +736,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>整词匹配替换结果正确</p>
      */
     @Test
-    @DisplayName("stealBeamsAndReplacePillars方法测试 - 整词匹配")
+    @DisplayName("stealBeamsAndReplacePillars - 整词匹配")
     void testStealBeamsAndReplacePillars_WholeWord() {
         System.out.println();
         log.info("========== 字符串替换模块测试 - 整词匹配替换 ==========");
@@ -718,7 +780,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("coordinateConvert方法测试 - 度分秒转十进制")
+    @DisplayName("coordinateConvert - 度分秒转十进制")
     void testCoordinateConvert_DmsToDecimal() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 度分秒转十进制 ==========");
@@ -727,24 +789,19 @@ public class FormatUtilTest {
         String coordinate = "116°23'45.67\"";
         params.put("fromType", "dms");
         params.put("toType", "decimal");
-        
         log.info("输入参数:");
         log.info("  - 坐标值: {}", coordinate);
         log.info("  - 源格式: {}", params.get("fromType"));
         log.info("  - 目标格式: {}", params.get("toType"));
         log.info("  - 注意: 116°23'45.67\" ≈ 116.396019");
-        
-        // 预期结果
-        log.info("预期结果: 非空转换结果");
-        
         // 执行测试
         Object result = FormatUtil.coordinateConvert(coordinate, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
-        assertNotNull(result);
+        String expectedResult = "116.396019";
+        log.info("预期结果：'{}'", expectedResult);
+        log.info("实际结果：'{}'", result);
+        assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 度分秒转十进制转换正确");
     }
     
@@ -756,33 +813,29 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("coordinateConvert方法测试 - 十进制转度分秒")
+    @DisplayName("coordinateConvert - 十进制转度分秒 - 【已验证】")
     void testCoordinateConvert_DecimalToDms() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 十进制转度分秒 ==========");
         
         // 输入参数
         String coordinate = "116.396019";
-        params.put("fromType", "decimal");
+        params.put("fromFormat", "decimal"); // 十进制
-        params.put("toType", "dms");
+        params.put("toFormat", "dms"); // 度分秒
-        
+        params.put("precision", "2"); // 保留2位小数
         log.info("输入参数:");
         log.info("  - 坐标值: {}", coordinate);
-        log.info("  - 源格式: {}", params.get("fromType"));
+        log.info("  - 源格式: {}", params.get("fromFormat"));
-        log.info("  - 目标格式: {}", params.get("toType"));
+        log.info("  - 目标格式: {}", params.get("toFormat"));
         log.info("  - 注意: 116.396019 ≈ 116°23'45.67\"");
-        
-        // 预期结果
-        log.info("预期结果: 非空转换结果");
-        
         // 执行测试
         Object result = FormatUtil.coordinateConvert(coordinate, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
-        assertNotNull(result);
+        String expectedResult = "116°23'45.67\"";
+        log.info("预期结果：'{}'", expectedResult);
+        log.info("实际结果：'{}'", result);
+        assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 十进制转度分秒转换正确");
     }
     
@@ -794,7 +847,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("cartesianConvert方法测试 - 直角坐标转极坐标")
+    @DisplayName("cartesianConvert - 直角坐标转极坐标")
     void testCartesianConvert_RectangularToPolar() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 直角坐标转极坐标 ==========");
@@ -836,7 +889,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>标准化结果正确</p>
      */
     @Test
-    @DisplayName("normalizeCoordinate方法测试 - 坐标标准化")
+    @DisplayName("normalizeCoordinate - 坐标标准化")
     void testNormalizeCoordinate_NormalCase() {
         System.out.println();
         log.info("========== 坐标系转换模块测试 - 坐标格式标准化 ==========");
@@ -873,7 +926,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回原始值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 正常范围检查")
+    @DisplayName("boundaryCheck - 正常范围检查")
     void testBoundaryCheck_WithinRange() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 正常范围检查 ==========");
@@ -913,7 +966,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回最大值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 超出上限截断")
+    @DisplayName("boundaryCheck - 超出上限截断 - 【验证中】")
     void testBoundaryCheck_AboveMaxTruncate() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 超出上限截断处理 ==========");
@@ -954,7 +1007,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回默认值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 超出下限默认值")
+    @DisplayName("boundaryCheck - 超出下限默认值")
     void testBoundaryCheck_BelowMinDefault() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 超出下限默认值处理 ==========");
@@ -997,7 +1050,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>返回错误信息或默认值</p>
      */
     @Test
-    @DisplayName("boundaryCheck方法测试 - 异常值检测")
+    @DisplayName("boundaryCheck - 异常值检测")
     void testBoundaryCheck_NaNValue() {
         System.out.println();
         log.info("========== 极值检查模块测试 - 异常值检测 ==========");
@@ -1039,33 +1092,129 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>转换结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 键名格式转换")
+    @DisplayName("kvMapping - 键名格式转换 - 【已验证】")
     void testKvMapping_KeyFormatConversion() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 键名格式转换 ==========");
         
         // 输入参数
         Map<String, Object> inputMap = new HashMap<>();
-        inputMap.put("user_name", "张三");
-        inputMap.put("user_age", 25);
-        params.put("keyFormat", "snake_to_camel");
 
+        // =================== 全大写命名 ===================
+        inputMap.put("USER_ID", 1001);
+        inputMap.put("STATUS", "ACTIVE");
+        // =================== 全小写命名 ===================
+        inputMap.put("name", "李四");
+        inputMap.put("address", "北京市朝阳区");
+        inputMap.put("phone", "13800138000");
+        // =================== 小驼峰命名 (lowerCamelCase) ===================
+        inputMap.put("userName", "王五");
+        // =================== 大驼峰命名 (UpperCamelCase/PascalCase) ===================
+        inputMap.put("UserRole", "ADMIN");
+        // =================== 蛇形命名 (snake_case) ===================
+        inputMap.put("user_password", "encrypted123");
+        // =================== 短横线命名 (kebab-case) ===================
+        inputMap.put("user-address", "上海市浦东新区");
+
+        // 1. 转成全大写
+        System.out.println();
+        log.info("========== 转成全大写 ==========");
+        params.put("keyFormat", "uppercase");
         log.info("输入参数:");
         log.info("  - 输入Map: {}", inputMap);
         log.info("  - 键名格式转换: {}", params.get("keyFormat"));
-        log.info("  - 注意: 蛇形命名(user_name)转驼峰命名(userName)");
+        log.info("  - 注意: 短横杠在全大写中，不做处理");
-        
-        // 预期结果
-        log.info("预期结果: 非空转换结果");
-        
         // 执行测试
         Object result = FormatUtil.kvMapping(inputMap, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
-        assertNotNull(result);
+        String expectedResultString = """
+                {"USERROLE":"ADMIN","STATUS":"ACTIVE","USER-ADDRESS":"上海市浦东新区","USER_PASSWORD":"encrypted123","ADDRESS":"北京市朝阳区","PHONE":"13800138000","USER_ID":1001,"USERNAME":"王五","NAME":"李四"}
+                """.trim();
+        String resultString = JSON.toJSONString(result);
+        log.info("预期结果: {}", expectedResultString);
+        log.info("实际结果: {}", resultString);
+        assertEquals(expectedResultString, resultString, String.format("转换为全大写%s失败", params.get("keyFormat")));
+
+        // 2. 转成全小写
+        System.out.println();
+        log.info("========== 转成全小写 ==========");
+        params.put("keyFormat", "lowercase");
+        log.info("输入参数:");
+        log.info("  - 输入Map: {}", inputMap);
+        log.info("  - 键名格式转换: {}", params.get("keyFormat"));
+        log.info("  - 注意: 短横杠在全小写中，不做处理");
+        // 执行测试
+        Object result2 = FormatUtil.kvMapping(inputMap, params);
+        // 断言验证
+        String expectedResultString2 = """
+                {"user_password":"encrypted123","address":"北京市朝阳区","phone":"13800138000","user_id":1001,"name":"李四","userrole":"ADMIN","user-address":"上海市浦东新区","status":"ACTIVE","username":"王五"}
+                """.trim();
+        String resultString2 = JSON.toJSONString(result2);
+        log.info("预期结果: {}", expectedResultString2);
+        log.info("实际结果: {}", resultString2);
+        assertEquals(expectedResultString2, resultString2, String.format("转换为全小写%s失败", params.get("keyFormat")));
+
+
+        // 3. 转换为小驼峰命名
+        System.out.println();
+        log.info("========== 转换为小驼峰命名 ==========");
+        params.put("keyFormat", "camelcase");
+        log.info("输入参数:");
+        log.info("  - 输入Map: {}", inputMap);
+        log.info("  - 键名格式转换: {}", params.get("keyFormat"));
+        log.info("  - 注意: 所有值都被转为驼峰，不区分当前是否大小写，只判断 [ _ | - | ' '] 下划线、短横杠、空串三种。");
+        // 执行测试
+        Object result3 = FormatUtil.kvMapping(inputMap, params);
+        // 断言验证
+        String expectedResultString3 = """
+                {"userAddress":"上海市浦东新区","userPassword":"encrypted123","address":"北京市朝阳区","phone":"13800138000","name":"李四","userrole":"ADMIN","userId":1001,"status":"ACTIVE","username":"王五"}
+                """.trim();
+        String resultString3 = JSON.toJSONString(result3);
+        log.info("预期结果: {}", expectedResultString3);
+        log.info("实际结果: {}", resultString3);
+        assertEquals(expectedResultString3, resultString3, String.format("转换为小驼峰命名%s失败", params.get("keyFormat")));
+
+
+        // 4. 转换为蛇形命名
+        System.out.println();
+        log.info("========== 转换为蛇形命名 ==========");
+        params.put("keyFormat", "snakecase");
+        log.info("输入参数:");
+        log.info("  - 输入Map: {}", inputMap);
+        log.info("  - 键名格式转换: {}", params.get("keyFormat"));
+        log.info("  - 注意: 短横杠在蛇形命名中，不做处理");
+        // 执行测试
+        Object result4 = FormatUtil.kvMapping(inputMap, params);
+        // 断言验证
+        String expectedResultString4 = """
+                {"user_role":"ADMIN","user_password":"encrypted123","address":"北京市朝阳区","phone":"13800138000","user_id":1001,"user_name":"王五","user_address":"上海市浦东新区","name":"李四","status":"ACTIVE"}
+                """.trim();
+        String resultString4 = JSON.toJSONString(result4);
+        log.info("预期结果: {}", expectedResultString4);
+        log.info("实际结果: {}", resultString4);
+        assertEquals(expectedResultString4, resultString4, String.format("转换为蛇形命名%s失败", params.get("keyFormat")));
+
+
+        // 5. 转换为短横线命名
+        System.out.println();
+        log.info("========== 转换为短横线命名 ==========");
+        params.put("keyFormat", "kebabcase");
+        log.info("输入参数:");
+        log.info("  - 输入Map: {}", inputMap);
+        log.info("  - 键名格式转换: {}", params.get("keyFormat"));
+        log.info("  - 注意: 短横杠在全大写中，不做处理");
+        // 执行测试
+        Object result5 = FormatUtil.kvMapping(inputMap, params);
+        // 断言验证
+        String expectedResultString5 = """
+                {"user-password":"encrypted123","address":"北京市朝阳区","user-role":"ADMIN","user-name":"王五","phone":"13800138000","user-id":1001,"name":"李四","user-address":"上海市浦东新区","status":"ACTIVE"}
+                """.trim();
+        String resultString5 = JSON.toJSONString(result5);
+        log.info("预期结果: {}", expectedResultString5);
+        log.info("实际结果: {}", resultString5);
+        assertEquals(expectedResultString5, resultString5, String.format("转换为短横线命名%s失败", params.get("keyFormat")));
+
+
         log.info("✓ 测试通过 - 键名格式转换正确");
     }
     
@@ -1077,13 +1226,13 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>过滤结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 数据过滤")
+    @DisplayName("kvMapping - 数据过滤")
     void testKvMapping_DataFiltering() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 数据过滤 ==========");
         
         // 输入参数
-        Map<String, Object> inputMap = new HashMap<>();
+        Map<String, Object> inputMap = new LinkedHashMap<>();
         inputMap.put("name", "张三");
         inputMap.put("age", 25);
         inputMap.put("address", null);
@@ -1104,7 +1253,10 @@ public class FormatUtilTest {
         log.info("实际结果: {}", result);
         
         // 断言验证
-        assertNotNull(result);
+        assertNotNull(result instanceof Map);
+        if(result instanceof Map) {
+            boolean flag = false;
+        }
         log.info("✓ 测试通过 - 数据过滤正确");
     }
     
@@ -1116,13 +1268,13 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>排序结果正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 分组排序")
+    @DisplayName("kvMapping - 对 Map 对象进行分组排序 - 【已验证】")
     void testKvMapping_GroupingSorting() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 分组排序 ==========");
         
         // 输入参数
-        Map<String, Object> inputMap = new HashMap<>();
+        Map<String, Object> inputMap = new LinkedHashMap<>();
         inputMap.put("z_key", "value3");
         inputMap.put("a_key", "value1");
         inputMap.put("m_key", "value2");
@@ -1143,7 +1295,16 @@ public class FormatUtilTest {
         log.info("实际结果: {}", result);
         
         // 断言验证
-        assertNotNull(result);
+        Map<String, Object> expectedResult = new LinkedHashMap<>() {{
+            put("a_key", "value1");
+            put("m_key", "value2");
+            put("z_key", "value3");
+        }};
+        String expectedResultString = JSON.toJSONString(expectedResult);
+        String resultString = JSON.toJSONString(result);
+        log.info("预期结果：'{}'", expectedResult);
+        log.info("实际结果：'{}'", result);
+        assertEquals(expectedResultString, resultString, "排序失败");
         log.info("✓ 测试通过 - 分组排序正确");
     }
     
@@ -1155,7 +1316,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>JSON格式正确</p>
      */
     @Test
-    @DisplayName("kvMapping方法测试 - 输出格式转换")
+    @DisplayName("kvMapping - 输出格式转换")
     void testKvMapping_OutputFormat() {
         System.out.println();
         log.info("========== 数据KV映射模块测试 - 输出格式转换 ==========");
@@ -1196,7 +1357,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>组合处理结果正确</p>
      */
     @Test
-    @DisplayName("综合测试 - 多方法组合使用")
+    @DisplayName("boundaryCheck - 综合测试 - 多方法组合使用 - 【验证中】")
     void testMultipleMethods_CombinedUsage() {
         System.out.println();
         log.info("========== 综合测试 - 多方法组合使用 ==========");
@@ -1259,7 +1420,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>所有转换正确完成</p>
      */
     @Test
-    @DisplayName("性能测试 - 大量数据处理")
+    @DisplayName("coordinateConvert - 性能测试 - 大量数据处理 - 【验证中】")
     void testPerformance_LargeDataProcessing() {
         System.out.println();
         log.info("========== 性能测试 - 大量数据处理 ==========");
@@ -1272,11 +1433,9 @@ public class FormatUtilTest {
         log.info("  - 目标格式: decimal");
         log.info("  - 坐标模式: 116.0°23'45.67\" ~ 116.999°23'45.67\"");
         log.info("  - 性能要求: 处理时间 < 5000 ms");
-        
         // 开始性能测试
         long startTime = System.currentTimeMillis();
         log.info("开始性能测试...");
-        
         for (int i = 0; i < testCount; i++) {
             Map<String, Object> coordParams = new HashMap<>();
             coordParams.put("fromType", "dms");
@@ -1285,60 +1444,52 @@ public class FormatUtilTest {
             Object result = FormatUtil.coordinateConvert("116." + i + "°23'45.67\"", coordParams);
             assertNotNull(result);
         }
-        
         long endTime = System.currentTimeMillis();
         long duration = endTime - startTime;
-        
         // 实际结果
         log.info("性能测试结果:");
         log.info("  - 开始时间: {} ms", startTime);
         log.info("  - 结束时间: {} ms", endTime);
         log.info("  - 总耗时: {} ms", duration);
         log.info("  - 平均每个转换耗时: {} ms", (double)duration / testCount);
-        
         // 预期结果
-        log.info("预期结果: 处理时间 < 5000 ms");
+        log.info("预期结果: 处理时间 < 100 ms");
-        
         // 断言验证
-        assertTrue(duration < 5000, "性能测试应在5秒内完成");
+        assertTrue(duration < 100, "性能测试应在0.1秒内完成");
+
         log.info("✓ 测试通过 - 性能表现符合要求");
     }
     
     /**
-     * 异常处理测试 - 无效参数组合
+     * 默认参数值
      * 
      * <p><b>测试目的：</b>验证方法对无效参数组合的容错能力</p>
      * <p><b>测试场景：</b>提供相互冲突的参数</p>
-     * <p><b>预计结果：</b>返回合理的错误信息或默认值</p>
+     * <p><b>预计结果：</b>返回合理的默认值</p>
      */
     @Test
-    @DisplayName("异常处理测试 - 无效参数组合")
+    @DisplayName("formatTime - 默认参数值 - 【已验证】")
     void testErrorHandling_InvalidParameterCombination() {
         System.out.println();
-        log.info("========== 异常处理测试 - 无效参数组合 ==========");
+        log.info("========== 默认参数值 ==========");
         
         // 输入参数
         String inputTime = "2024-01-15";
         params.put("fromFormat", "yyyy-MM-dd");
         params.put("toFormat", "HH:mm:ss");
-        
         log.info("输入参数:");
         log.info("  - 输入时间: {}", inputTime);
         log.info("  - 源格式: {}", params.get("fromFormat"));
         log.info("  - 目标格式: {}", params.get("toFormat"));
         log.info("  - 注意: 日期格式到时间格式的无效转换");
-        
-        // 预期结果
-        log.info("预期结果: 返回合理的错误信息或默认值");
-        
         // 执行测试
         Object result = FormatUtil.formatTime(inputTime, params);
-        
-        // 实际结果
-        log.info("实际结果: {}", result);
-        
         // 断言验证
-        assertNotNull(result);
+        String expectedResult = "00:00:00";
+        log.info("预期结果: '{}'", expectedResult);
+        log.info("实际结果: '{}'", result);
+        assertEquals(expectedResult, result);
+
         log.info("✓ 测试通过 - 异常处理正确");
     }
     
@@ -1350,7 +1501,7 @@ public class FormatUtilTest {
      * <p><b>预计结果：</b>正确处理或返回错误信息</p>
      */
     @Test
-    @DisplayName("边界值测试 - 极值输入")
+    @DisplayName("boundaryCheck - 边界值测试 - 极值输入 - 【验证中】")
     void testBoundaryValues_ExtremeInputs() {
         System.out.println();
         log.info("========== 边界值测试 - 极值输入 ==========");