dto.setId("data" + IdUtil.getSnowflakeNextId());

// result: data1762308343244185600

// 所属 jar 
// cn.hutool.core.util
// public class IdUtil
// Maven: cn.hutool:hutool-all:5.8.22 (hutool-all-5.8.22.jar)

// 后面是时间戳
versionControl.setVersion(version + "-" + LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());

// result: GCXS20231126-1709002025792

/**
* 字符串判空
* org.springframework.util
* public abstract class StringUtils
* Maven: org.springframework:spring-core:5.3.31 (spring-core-5.3.31.jar)
*/
String str = "xxx";
if (StringUtils.hasLength(verifyInfo)) {}


/**
* List<String> 集合判空
* org.springframework.util
* public abstract class CollectionUtils
* Maven: org.springframework:spring-core:5.3.31 (spring-core-5.3.31.jar)
*/
List<String> list = new ArrayList<>();
if (!CollectionUtils.isEmpty(list)) {}

/**
* com.alibaba.fastjson

public class JSONArray
extends com.alibaba.fastjson.JSON
implements java.util.List<Object>, java.io.Serializable, Cloneable

public class JSONObject extends com.alibaba.fastjson.JSON
implements java.util.Map<String, Object>,
           Cloneable,
           java.io.Serializable,
           java.lang.reflect.InvocationHandler,
           com.alibaba.fastjson2.util.Wrapper

* Maven: com.alibaba:fastjson:2.0.42 (fastjson-2.0.42.jar)
*/
JSONArray array = new JSONArray();
JSONObject obj = new JSONObject();
obj.put("type", "NotComplatedVariable");
obj.put("variables", "a, b, c");
array.add(obj);

return array.isEmpty() ? null : array.toJSONString();

@Slf4j
public class MyClass {
    public void test() {
        log.info("当前记录 id -> {}", id);
    }
}

String xmlContent = "        <w:r><w:t>${contract_</w:t></w:r>
        <w:r><w:t>number</w:t></w:r>
        <w:r><w:t>}</w:t></w:r>";
xmlContent = xmlContent.replaceAll(">\\s+<", "><");

/**
 * 验证 xml 变量是否完整
 * @param xmlFilePath
 * @return
 * @throws IOException
 */
public static List<String> verifyXMLVariable(String xmlFilePath) throws IOException {
    String xmlContent = Files.readString(Paths.get(xmlFilePath));

    // 所有完整的 ${name}
    List<String> completedVariableList = XmlUtil.extractCompletedVariable(xmlContent);

    // 去掉格式化产生的空格，移除 xml 标签，提取变量
    xmlContent = xmlContent.replaceAll(">\\s+<", "><");
    String removeXmlTagsResult = XmlUtil.removeXmlTags(xmlContent);
    List<String> variableList = XmlUtil.extractVariable(removeXmlTagsResult);

    // 不正确的变量
    List<String> differenceList = variableList
            .stream()
            .filter(e -> !completedVariableList.contains(e))
            .collect(Collectors.toList());

    return differenceList;
}

// XmlUtil.java
public static String removeXmlTags(String xmlContent) {
    // 正则表达式用于匹配XML标签
    String regex = "<[^>]*>";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(xmlContent);

    // 用空串替换所有匹配到的XML标签
    String result = matcher.replaceAll("");
    return result;
}
    
public static List<String> extractVariable(String xmlContent) {
    // 使用正则表达式提取 ${name} 变量
    String regex = "\\$(\\{?)([a-zA-Z_][a-zA-Z0-9_]*)(}?|^$)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(xmlContent);

    List<String> variableList = new ArrayList<>();

    // 遍历匹配到的变量
    while (matcher.find()) {
        variableList.add(matcher.group(2));
    }
    return variableList;
}
    
public static List<String> extractCompletedVariable(String xmlContent) {
    // 定义正则表达式匹配规则
    // 返回所有的 ${name} → 只返回完整的
    String regex = "\\$\\{([a-zA-Z_][a-zA-Z0-9_]*)\\}";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(xmlContent);

    List<String> completedVariableList = new ArrayList<>();

    // 查找匹配的内容
    while (matcher.find()) {
        completedVariableList.add(matcher.group(1));
    }
    return completedVariableList;
}

List<String> AList = new ArrayList<>();
AList.add("a");
AList.add("b");

List<String> BList = new ArrayList<>();
BList.add("a");
BList.add("b");
BList.add("c");

/**
* 求异：AList 有，BList 没有的值
* result: differentList = ["c"]
*/
List<String> differenceList = AList
            .stream()
            .filter(e -> !BList.contains(e))
            .collect(Collectors.toList());