添加未清选择改成动态引导语

qianbao
1 parent 48dd0522
Showing 6 changed files with 300 additions and 107 deletions
pom.xml
src/main/java/com/xly/service/QuoService.java
src/main/java/com/xly/tool/DynamicToolProvider.java
src/main/java/com/xly/util/DeepCopyUtils.java
src/main/java/com/xly/util/PinyinUtil.java
src/main/java/com/xly/util/Validator.java
@@ -102,6 +102,12 @@
 			<artifactId>pagehelper-spring-boot-starter</artifactId>
 			<version>${pagehelper.version}</version>
 		</dependency>
+		<!-- 方案A：使用 pinyin4j（推荐） -->
+		<dependency>
+			<groupId>com.belerweb</groupId>
+			<artifactId>pinyin4j</artifactId>
+			<version>2.5.1</version>
+		</dependency>
  
 		<!-- 工具类 -->
 		<dependency>
@@ -2,6 +2,7 @@ package com.xly.service;
  
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.pinyin.PinyinUtil;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson2.JSONObject;
 import com.xly.entity.ParamRule;
@@ -41,7 +42,7 @@ public class QuoService {
             }
             List<ParamRule> dataAll = session.getCurrentTool().getParamRuleListAll();
             //获取产品的参数
-            List<ParamRule> dataProduct = dataAll.stream().filter(one-> "产品".equals(one.getSGroup()) && !one.getBDynamicParam() ).collect(Collectors.toUnmodifiableList());
+            List<ParamRule> dataProduct = dataAll.stream().filter(one-> "产品".equals(one.getSGroup()) && !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
             List<ParamRule> dataPart = dataAll.stream().filter(one-> "部件".equals(one.getSGroup()) && !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
             List<ParamRule> datasDynamicPart = dataAll.stream().filter(one-> "sDynamicPart".equals(one.getSParamValue()) && !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
             List<Map<String,Object>> sAll = new ArrayList<>();
@@ -67,7 +68,11 @@ public class QuoService {
                     product.put("sParamConfigValue",p.getSParamConfigValue()==null?StrUtil.EMPTY:p.getSParamConfigValue());
                     //获取动态参数
                     adddynamicData( sValue, dataAll, p,  finalArgsOld, sAll,  product);
-                    productList.add(product);
+                    if(  !"sDynamicPart".equals(p.getSParamValue())
+                            &&!"sDynamicPartDel".equals(p.getSParamValue())
+                    ){
+                        productList.add(product);
+                    }
                 }
             });
             List<Map<String,Object>> partList = new ArrayList<>();
@@ -109,7 +114,7 @@ public class QuoService {
                     datasDynamicPartArray.forEach(one->{
                         List<ParamRule> dataPartDynamic = dataAll.stream().filter(d ->
                                 one.equals(d.getSDynamicParam())
-                                        && "新增部件".equals(d.getSDynamicParamName()
+                                        && "sDynamicPart".equals(d.getSDynamicParamName()
                                 )&&d.getBDynamicParam()
                         ).collect(Collectors.toUnmodifiableList());
                         if(ObjectUtil.isNotEmpty(dataPartDynamic)){
@@ -34,12 +34,14 @@ import lombok.RequiredArgsConstructor;
  
 import lombok.extern.slf4j.Slf4j;
  
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
  
 import java.util.*;
  
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -188,6 +190,13 @@ public class DynamicToolProvider implements ToolProvider {
                     finalArgs.put(k,v);
                 }
             });
+            if(argsNew.containsKey("删除动态部件")){
+                argsNew.put("sDynamicPartDel",argsNew.get("删除动态部件"));
+            }
+            if(!argsNew.containsKey("sDynamicPartDel")){
+                finalArgs.remove("sDynamicPartDel");
+                finalArgs.remove("删除动态部件");
+            }
             // 2 【补全动态参数】动态参数补全
             try{
                 args = applyValues(args, meta.getParamRuleListCheck());
@@ -223,6 +232,7 @@ public class DynamicToolProvider implements ToolProvider {
                 }
                 //判断是否首次进入给提示 如果没有产品名称 产品长 宽
                 if(!Validator.isValid(args.get("dProductWidth"))
+                        && !Validator.isValid(args.get("sCustomerName"))
                         && !Validator.isValid(args.get("dProductLength"))
                         && !Validator.isValid(args.get("sProductName"))){
                     String sTsMemo = session.getCurrentTool().getSTsMemo();
@@ -256,110 +266,246 @@ public class DynamicToolProvider implements ToolProvider {
      * @return void
      * @Description 获取动态参数
      **/
-    private List<ParamRule> doSetParamgetArgsAfter(Map<String,Object> argsNew,UserSceneSession session){
-        //获取当前方法
-        //根据新参数获取需要填写参数
+    private List<ParamRule> doSetParamgetArgsAfter(Map<String, Object> argsNew, UserSceneSession session) {
         List<ParamRule> dynamicParamRule = new ArrayList<>();
-        try{
+        try {
             ToolMeta tool = session.getCurrentTool();
             Map<String, Object> argsOld = session.getArgs();
             Map<String, Object> args = DeepCopyUtils.deepCopy(argsNew);
-            if(ObjectUtil.isEmpty(argsOld)){
+
+            if (ObjectUtil.isEmpty(argsOld)) {
                 argsOld = new HashMap<>();
             }
-            //根据新录入的参数获取规则
+
             List<ParamRule> paramRuleDataAll = tool.getParamRuleListAll();
-            //动态参数
-            List<ParamRule> paramRuleData = paramRuleDataAll.stream().filter(one->
-                    ( ObjectUtil.isNotEmpty(args.get(one.getSParam()))  || ObjectUtil.isNotEmpty(args.get(one.getSParamValue())))
+
+            // 1. 获取动态参数规则
+            List<ParamRule> paramRuleData = paramRuleDataAll.stream()
+                    .filter(one -> (ObjectUtil.isNotEmpty(args.get(one.getSParam()))
+                            || ObjectUtil.isNotEmpty(args.get(one.getSParamValue())))
                             && ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())
-            ).collect(Collectors.toUnmodifiableList());
-            //为空的时候需要重新插入不为空 表示之前已经放过了
-            AtomicReference<List<ParamRule>> paramRuleDataAllNew = new AtomicReference<>(paramRuleDataAll);
-            if(ObjectUtil.isNotEmpty(paramRuleData)){
+                            && !"sDynamicPart".equals(one.getSParamValue())
+                            && !"sDynamicPartDel".equals(one.getSParamValue())
+                    )
+                    .collect(Collectors.toList());
+            List<ParamRule> paramRuleDataAllNew = new ArrayList<>(paramRuleDataAll);
+            // 2. 处理非动态参数
+            if (ObjectUtil.isNotEmpty(paramRuleData)) {
                 Map<String, Object> finalArgsOld = argsOld;
-                paramRuleData.forEach(one->{
-                    Map<String,Object> searMap = new HashMap<>();
-                    searMap.putAll(args);
-                    //新参数如果值变了移除掉之前插入的
-                    paramRuleDataAllNew.set(paramRuleDataAll.stream().filter(d ->
-                            !one.getSParam().equals(d.getSDynamicParam())
-                                    || (one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
-                    ).collect(Collectors.toUnmodifiableList()));
+
+                for (ParamRule one : paramRuleData) {
+                    Map<String, Object> searMap = new HashMap<>(args);
+                    paramRuleDataAllNew.removeIf(d ->
+                            one.getSParam().equals(d.getSDynamicParam())
+                                    && one.getSParamValue().equals(d.getSParamValue())
+                    );
  
                     String sValue = searMap.get(one.getSParam()).toString();
                     List<String> addValue = new ArrayList<>();
-                    if(JSONUtil.isTypeJSONArray(sValue)){
-                        addValue = JSONUtil.toList(sValue,String.class);
-                    }else{
+
+                    if (JSONUtil.isTypeJSONArray(sValue)) {
+                        addValue = JSONUtil.toList(sValue, String.class);
+                    } else {
                         addValue.add(sValue);
                     }
-                    for(String sVaule:addValue){
-                        //根据值获取动态部件
-                        List<ParamRule> paramRuleDataD = paramRuleDataAllNew.get().stream().filter(d ->
-                                d.getBDynamicParam()
-                                        && sValue.equals(d.getSDynamicParam())
-                                        && one.getSParam().equals(d.getSDynamicParamName())
-                        ).collect(Collectors.toUnmodifiableList());
-
-                        //如果不存在的加入方法参数中
-                        if(ObjectUtil.isEmpty(paramRuleDataD)){
-                            searMap.put("sRuleId",one.getSId());
-                            searMap.put("sTooId",one.getSParentId());
-                            searMap.put("sParam",one.getSParam());
-                            searMap.put("sParamValue",sVaule);
-//                        searMap.put("sParamValue",one.getSParamValue());
-                            searMap.put("sParamName",one.getSParam());
+
+                    for (String sVaule : addValue) {
+                        List<ParamRule> paramRuleDataD = paramRuleDataAllNew.stream()
+                                .filter(d -> d.getBDynamicParam()
+                                        && sVaule.equals(d.getSDynamicParam())
+                                        && one.getSParam().equals(d.getSDynamicParamName()))
+                                .collect(Collectors.toList());
+
+                        // 如果不存在，则添加
+                        if (ObjectUtil.isEmpty(paramRuleDataD)) {
+                            searMap.put("sRuleId", one.getSId());
+                            searMap.put("sTooId", one.getSParentId());
+                            searMap.put("sParam", one.getSParam());
+                            searMap.put("sParamValue", sVaule);
+                            searMap.put("sParamName", one.getSParam());
+                            searMap.put("argsNew", JSONObject.toJSONString(args));
+                            searMap.put("argsAll", JSONObject.toJSONString(finalArgsOld));
+
                             String sSql = one.getSDynamicParamRuleSql();
-                            searMap.put("argsNew",JSONObject.toJSONString(args));
-                            searMap.put("argsAll",JSONObject.toJSONString(finalArgsOld));
-                            //如果不是SELECT 开头
-                            List<Map<String,Object>> selectData = new ArrayList<>();
-                            List<Map<String,Object>> dynamicParamRuleOne = new ArrayList<>();
-                            if(sSql.replaceAll(" ","").toLowerCase().startsWith("select")
-                                    || sSql.replaceAll(" ","").toLowerCase().startsWith("call")){
-                                try{
-                                    selectData = this.dynamicExeDbService.findSql(searMap, sSql);
-                                    if(ObjectUtil.isNotEmpty(selectData)){
+                            List<Map<String, Object>> dynamicParamRuleOne = new ArrayList<>();
+
+                            if (sSql.replaceAll(" ", "").toLowerCase().startsWith("select")
+                                    || sSql.replaceAll(" ", "").toLowerCase().startsWith("call")) {
+                                try {
+                                    List<Map<String, Object>> selectData =
+                                            this.dynamicExeDbService.findSql(searMap, sSql);
+                                    if (ObjectUtil.isNotEmpty(selectData)) {
                                         String sData = (ObjectUtil.isNotEmpty(selectData)
-                                                && ObjectUtil.isNotEmpty(selectData.get(0).get("sData")))?selectData.get(0).get("sData").toString():StrUtil.EMPTY;
-                                        if(ObjectUtil.isNotEmpty(sData)){
-                                            dynamicParamRuleOne = JsonUtils.toList(sData,Map.class);
+                                                && ObjectUtil.isNotEmpty(selectData.get(0).get("sData")))
+                                                ? selectData.get(0).get("sData").toString()
+                                                : StrUtil.EMPTY;
+                                        if (ObjectUtil.isNotEmpty(sData)) {
+                                            dynamicParamRuleOne = JsonUtils.toList(sData, Map.class);
                                         }
                                     }
-                                }catch (Exception e){}
-                            }else{
-                                //表示过程走自定义参数
+                                } catch (Exception e) {
+                                    log.error("执行动态参数SQL失败", e);
+                                }
                             }
-                            if(ObjectUtil.isNotEmpty(dynamicParamRuleOne)){
-                                dynamicParamRuleOne.forEach(dynamicParamRuleData->{
-                                    ParamRule paramRule =  BeanUtil.toBean(dynamicParamRuleData,ParamRule.class);
-                                    if(!RuleCode.CONST.getCode().equals(paramRule.getSRule())
+
+                            if (ObjectUtil.isNotEmpty(dynamicParamRuleOne)) {
+                                for (Map<String, Object> dynamicParamRuleData : dynamicParamRuleOne) {
+                                    ParamRule paramRule = BeanUtil.toBean(dynamicParamRuleData, ParamRule.class);
+                                    if (!RuleCode.CONST.getCode().equals(paramRule.getSRule())
                                             && ObjectUtil.isNotEmpty(paramRule.getSParamConfig())
-                                            && JSONUtil.isTypeJSON(paramRule.getSParamConfig())
-                                    ){
-                                        try{getConstMeg(paramRule);}catch (Exception e){  e.printStackTrace();}
+                                            && JSONUtil.isTypeJSON(paramRule.getSParamConfig())) {
+                                        try {
+                                            getConstMeg(paramRule);
+                                        } catch (Exception e) {
+                                            log.error("获取常量配置失败", e);
+                                        }
                                     }
                                     dynamicParamRule.add(paramRule);
-                                });
+                                }
                             }
                         }
                     }
-                });
+                }
+            }
+
+            // 3. 处理动态部件
+            List<ParamRule> sDynamicPart = paramRuleDataAll.stream()
+                    .filter(one -> "sDynamicPart".equals(one.getSParamValue()))
+                    .collect(Collectors.toList());
+            // 3. 处理动态部件
+            List<ParamRule> sDynamicPartDel = paramRuleDataAll.stream()
+                    .filter(one -> "sDynamicPartDel".equals(one.getSParamValue()))
+                    .collect(Collectors.toList());
+            //移除的动态部件
+            List<String> sDynamicPartDelValue = new ArrayList<>();
+            if(ObjectUtil.isNotEmpty(sDynamicPartDel)){
+                ParamRule sDynamicPartOneDel = sDynamicPartDel.get(0);
+                String sValueDel = ObjectUtil.isNotEmpty(args.get(sDynamicPartOneDel.getSParam()))
+                        ? args.get(sDynamicPartOneDel.getSParam()).toString()
+                        : StrUtil.EMPTY;
+                if (ObjectUtil.isNotEmpty(sValueDel)) {
+                    if (JSONUtil.isTypeJSONArray(sValueDel)) {
+                        sDynamicPartDelValue = JSONUtil.toList(sValueDel, String.class);
+                    } else {
+                        sDynamicPartDelValue.add(sValueDel);
+                    }
+                }
             }
-            List<ParamRule> dataAll = new ArrayList<>(paramRuleDataAllNew.get());
+            //新增部件
+            if (ObjectUtil.isNotEmpty(sDynamicPart)
+                    && ObjectUtil.isNotEmpty(sDynamicPart.get(0))
+                    && ObjectUtil.isNotEmpty(sDynamicPart.get(0).getSParam())) {
+
+                ParamRule sDynamicPartOne = sDynamicPart.get(0);
+                String sValue = ObjectUtil.isNotEmpty(args.get(sDynamicPartOne.getSParam()))
+                        ? args.get(sDynamicPartOne.getSParam()).toString()
+                        : StrUtil.EMPTY;
+
+                if (ObjectUtil.isNotEmpty(sValue)) {
+                    List<String> addValueOld = new ArrayList<>();
+
+                    if (JSONUtil.isTypeJSONArray(sValue)) {
+                        addValueOld = JSONUtil.toList(sValue, String.class);
+                    } else {
+                        addValueOld.add(sValue);
+                    }
+                    //新增部件不在删除部件中的
+                    List<String> finalSDynamicPartDelValue = sDynamicPartDelValue;
+                    List<String> addValue = addValueOld.stream().filter(one-> !finalSDynamicPartDelValue.contains(one)).collect(Collectors.toList());
+                    //反写值取SESSION
+                    session.getArgs().put(sDynamicPart.get(0).getSParam(),JSONUtil.toJsonStr(addValue));
+                    session.getArgs().put(sDynamicPart.get(0).getSParamValue(),JSONUtil.toJsonStr(addValue));
+                    //收集当前有效的动态部件值
+                    List<String> validDynamicPartValues = new ArrayList<>();
+                    for (String sVal : addValue) {
+                        if(!finalSDynamicPartDelValue.contains(sVal)){
+                            validDynamicPartValues.add(sVal);
+                        }
+                        boolean exists = paramRuleDataAllNew.stream()
+                                .anyMatch(d -> sVal.equals(d.getSDynamicParam()));
+                        if (!exists) {
+                            // 获取部件标准参数
+                            List<ParamRule> sDynamicPartCheckAddCopy = paramRuleDataAll.stream()
+                                    .filter(d -> ObjectUtil.isNotEmpty(d.getSGroup())
+                                            && !d.getBDynamicParam()
+                                            && d.getSGroup().equals("部件")
+                                            && d.getBStandardParam())
+                                    .map(d -> {
+                                        ParamRule copy = new ParamRule();
+                                        BeanUtils.copyProperties(d, copy);
+
+                                        // 设置动态参数
+                                        String paramName = d.getSParam().split("-").length > 1
+                                                ? d.getSParam().split("-")[1]
+                                                : d.getSParam().split("-")[0];
+                                        copy.setSParam(sVal + "-" + paramName);
+
+                                        // 拼音转换
+                                        String firstLetters = "";
+                                        try {
+                                            firstLetters = PinyinUtil.convertToPinyin(sVal);
+                                        } catch (Exception e) {
+                                            log.warn("拼音转换失败: {}", sVal);
+                                            firstLetters = sVal.substring(0, 1).toUpperCase();
+                                        }
+                                        copy.setSParamValue(firstLetters + d.getSParamValue());
+                                        copy.setIOrder(d.getIOrder() + 100000);
+                                        copy.setBDynamicParam(true);
+                                        copy.setSDynamicParam(sVal);
+                                        copy.setSDynamicParamName("sDynamicPart");
+                                        return copy;
+                                    })
+                                    .collect(Collectors.toList());
+
+                            if (ObjectUtil.isNotEmpty(sDynamicPartCheckAddCopy)) {
+                                paramRuleDataAllNew.addAll(sDynamicPartCheckAddCopy);
+                                log.info("添加了 {} 个动态部件参数，sVal={}",
+                                        sDynamicPartCheckAddCopy.size(), sVal);
+                            }
+                        } else {
+                            log.info("动态部件已存在，跳过: {}", sVal);
+                        }
+                    }
+                    // 移除不在 addValue 中的动态部件
+                    paramRuleDataAllNew = paramRuleDataAllNew.stream()
+                        .filter(p -> {
+                            // 如果不是动态部件参数，保留
+                            if (!p.getBDynamicParam() || !"sDynamicPart".equals(p.getSDynamicParamName())) {
+                                return true;
+                            }
+                            // 如果是动态部件参数，检查是否在有效值列表中
+                            return validDynamicPartValues.contains(p.getSDynamicParam());
+                        })
+                        .collect(Collectors.toList());
+                    log.info("移除无效动态部件后，列表大小: {}", paramRuleDataAllNew.size());
+                }else{
+                    //移除不是动态部件的
+                    paramRuleDataAllNew = paramRuleDataAllNew.stream()
+                            .filter(p -> !p.getBDynamicParam() || !"sDynamicPart".equals(p.getSDynamicParamName()))
+                            .collect(Collectors.toList());
+                    log.info("sValue为空，移除所有动态部件");
+                }
+            }
+            // 4. 合并所有参数
+            List<ParamRule> dataAll = new ArrayList<>(paramRuleDataAllNew);
             dataAll.addAll(dynamicParamRule);
-            paramRuleDataAllNew.set(dataAll);
-            List<ParamRule> newList = new ArrayList<>(paramRuleDataAllNew.get());
-            List<ParamRule> dynamicParamRuleAll = Validator.deduplicateByParamValue(newList);
-            List<ParamRule> paramRuleList = dynamicParamRuleAll.stream().filter(one-> one.getBTipModel()).collect(Collectors.toUnmodifiableList());
-            List<ParamRule> paramRuleListCheck = dynamicParamRuleAll.stream().filter(one->one.getBEmpty()).collect(Collectors.toUnmodifiableList());
+
+            // 5. 去重并设置
+            List<ParamRule> dynamicParamRuleAll = Validator.deduplicateByParamValue(dataAll);
+            List<ParamRule> paramRuleList = dynamicParamRuleAll.stream()
+                    .filter(one -> one.getBTipModel())
+                    .collect(Collectors.toList());
+            List<ParamRule> paramRuleListCheck = dynamicParamRuleAll.stream()
+                    .filter(one -> one.getBEmpty())
+                    .collect(Collectors.toList());
+
             session.getCurrentTool().setParamRuleListAll(dynamicParamRuleAll);
             session.getCurrentTool().setParamRuleListCheck(paramRuleListCheck);
             session.getCurrentTool().setParamRuleList(paramRuleList);
-        }catch (Exception e){
+
+        } catch (Exception e) {
             e.printStackTrace();
-            log.error(e.getMessage());
+            log.error("获取动态参数失败: {}", e.getMessage(), e);
         }
  
         return dynamicParamRule;
@@ -645,12 +791,18 @@ public class DynamicToolProvider implements ToolProvider {
             Map<String,Object> data = quoService.getQuoData(args, session);
             List<Map<String,Object>> sAll = (List<Map<String, Object>>) data.get("sAll");
             List<Map<String,Object>> sEmptyData = sAll.stream().filter(one-> BooleanUtil.toBoolean(one.get("bEmpty").toString())
-                    && (!Validator.isValid(one.get("sValue"))) && !"sDynamicPart".equals(one.get("sName"))).collect(Collectors.toUnmodifiableList());
+                    && (!Validator.isValid(one.get("sValue")))
+                    && !"sDynamicPart".equals(one.get("sName"))
+                    && !"sDynamicPartDel".equals(one.get("sName"))
+            ).collect(Collectors.toUnmodifiableList());
             data.remove("sAll");
             if(ObjectUtil.isNotEmpty(sEmptyData)){
                 List<ParamRule> missData = session.getCurrentTool().getParamRuleListAll().stream().filter(d ->
                         d.getBEmpty()
-                        && (!Validator.isValid(args.get(d.getSParam()))) && !"sDynamicPart".equals(d.getSParamValue())).collect(Collectors.toUnmodifiableList());
+                        && (!Validator.isValid(args.get(d.getSParam())))
+                                && !"sDynamicPart".equals(d.getSParamValue())
+                                && !"sDynamicPartDel".equals(d.getSParamValue())
+                ).collect(Collectors.toUnmodifiableList());
                 data.put("bTs",true);
                 String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,missData);
                 session.setSSystemPrompt(sSystemPrompt);
@@ -911,7 +1063,10 @@ public class DynamicToolProvider implements ToolProvider {
     private List<String> checkRequiredParams(Map<String, Object> args, List<ParamRule> paramDefs) {
         Map<String,Object> returnMap = transformationArgs( args, paramDefs);
         List<ParamRule> paramDefsCheck = paramDefs.stream()
-                .filter(pd -> !"sDynamicPart".equals(pd.getSParamValue())).collect(Collectors.toUnmodifiableList());
+                .filter(pd ->
+                        !"sDynamicPart".equals(pd.getSParamValue())
+                   &&   !"sDynamicPartDel".equals(pd.getSParamValue())
+                ).collect(Collectors.toUnmodifiableList());
         paramDefsCheck = paramDefsCheck.stream()
                 .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel()).collect(Collectors.toUnmodifiableList());
         paramDefsCheck = paramDefsCheck.stream()
@@ -61,10 +61,10 @@ public class DeepCopyUtils {
         }
     }
  
-    private static <T> T cloneArray(T array) {
+    public static <T> T cloneArray(T array) {
         Class<?> componentType = array.getClass().getComponentType();
  
-        if (componentType.isPrimitive()) {
+        if (componentType !=null &&  componentType.isPrimitive()) {
             // 基本类型数组
             int length = java.lang.reflect.Array.getLength(array);
             Object copy = java.lang.reflect.Array.newInstance(componentType, length);
+package com.xly.util;
+
+import net.sourceforge.pinyin4j.PinyinHelper;
+import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
+import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
+import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
+import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
+
+public class PinyinUtil {
+
+    private static final HanyuPinyinOutputFormat FORMAT = new HanyuPinyinOutputFormat();
+
+    static {
+        FORMAT.setCaseType(HanyuPinyinCaseType.LOWERCASE);  // 小写
+        FORMAT.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  // 不带声调
+    }
+
+    public static String convertToPinyin(Object input) {
+        if (input == null) {
+            return "";
+        }
+
+        String sVal = input.toString().trim();
+        if (sVal.isEmpty()) {
+            return "";
+        }
+
+        try {
+            StringBuilder result = new StringBuilder();
+            char[] chars = sVal.toCharArray();
+
+            for (char ch : chars) {
+                // 判断是否为汉字
+                if (String.valueOf(ch).matches("[\\u4E00-\\u9FA5]+")) {
+                    String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(ch, FORMAT);
+                    if (pinyinArray != null && pinyinArray.length > 0) {
+                        // 多音字取第一个
+                        result.append(pinyinArray[0]);
+                    } else {
+                        result.append(ch);  // 无法转换保留原字符
+                    }
+                } else {
+                    result.append(ch);  // 非汉字直接保留
+                }
+            }
+
+            return result.toString() + "_";
+        } catch (BadHanyuPinyinOutputFormatCombination e) {
+            System.err.println("拼音转换异常: " + sVal + ", " + e.getMessage());
+            return sVal + "_";
+        }
+    }
+}
 \ No newline at end of file
@@ -36,32 +36,6 @@ public class Validator {
         }
         return ObjectUtil.isNotEmpty(obj);
     }
-
-    /**
-     * 根据指定 key 对 List<Map<String, Object>> 去重
-     *
-     * @param list 原始列表
-     * @param key  去重依据的 key
-     * @return 去重后的列表（保留首次出现的顺序）
-     */
-    public static List<Map<String, Object>> distinctByKey(
-            List<Map<String, Object>> list, String key) {
-
-        if (list == null || list.isEmpty()) {
-            return new ArrayList<>();
-        }
-
-        return list.stream()
-                .filter(item -> item != null && item.get(key) != null)
-                .collect(Collectors.toMap(
-                        item -> item.get(key),
-                        Function.identity(),
-                        (existing, replacement) -> existing
-                ))
-                .values()
-                .stream()
-                .collect(Collectors.toList());
-    }
     /***
      * @Author 钱豹
      * @Date 0:58 2026/7/2