专利上传功能 数据填充部分开发

PAS/src/main/java/cn/cslg/pas/common/model/vo/ImportDataVo.java

@@ -1,24 +0,0 @@
-package cn.cslg.pas.common.model.vo;
-
-import lombok.Data;
-import lombok.experimental.Accessors;
-
-import java.util.List;
-
-@Data
-@Accessors(chain = true)
-public class ImportDataVo {
-    private String sourceId;
-    private String sourceName;
-    private List<Column> column;
-
-    @Data
-    public static class Column {
-        private String setName;
-        private String column;
-        private String type;
-        private String splitSymbol;
-        private String handler;
-    }
-
-}

PAS/src/main/java/cn/cslg/pas/common/model/vo/UploadParamsVO.java

@@ -15,10 +15,10 @@ import java.util.List;
 public class UploadParamsVO {
 //    private String patentNo;
 //    private Integer applicationDate;
-    /**
-     * 专利
-     */
-    private List<Patent> patentList;
+//    /**
+//     * 专利
+//     */
+//    private List<Patent> patentList;
 
     /**
      * 权利要求
@@ -30,25 +30,25 @@ public class UploadParamsVO {
      */
     private PatentInstructionText patentInstructionText;
 
-    /**
-     * 专利信息代理人
-     */
-    private List<PatentAgent> patentAgentList;
-
-    /**
-     * 专利信息质押职权人
-     */
-    private List<PatentPledge> patentPledgeList;
-
-    /**
-     * 专利信息许可人
-     */
-    private List<PatentLicensor> patentLicensorList;
-
-    /**
-     * 专利信息事务信息
-     */
-    private List<PatentAffair> patentAffairList;
+//    /**
+//     * 专利信息代理人
+//     */
+//    private List<PatentAgent> patentAgentList;
+//
+//    /**
+//     * 专利信息质押职权人
+//     */
+//    private List<PatentPledge> patentPledgeList;
+//
+//    /**
+//     * 专利信息许可人
+//     */
+//    private List<PatentLicensor> patentLicensorList;
+//
+//    /**
+//     * 专利信息事务信息
+//     */
+//    private List<PatentAffair> patentAffairList;
 
 
 }

PAS/src/main/java/cn/cslg/pas/common/model/vo/UploadSettingVO.java

@@ -0,0 +1,62 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+/**
+ * @author 沈永艺
+ * @date 2022/7/1
+ * @description 用于存储从配置文件(Json类型)中解析出来的配置参数
+ */
+
+@Data
+@Accessors(chain = true)
+public class UploadSettingVO {
+    /**
+     * 数据来源 ID
+     */
+    private String sourceId;
+
+    /**
+     * 数据来源名称
+     */
+    private String sourceName;
+
+    /**
+     * 可配置属性 包含与数据来源文件(Excel文件)中的字段相对应的属性字段 是一个数组
+     */
+    private List<Column> column;
+
+    @Data
+    @Accessors(chain = true)
+    public static class Column {
+        /**
+         * 上传Excel栏位名称
+         */
+        private String setName;
+
+        /**
+         * 在代码中创建的数据库类里面的字段
+         */
+        private String column;
+
+        /**
+         * 该字段数据的存储类型 (目前在代码里面只有两种 Integer String   Date类型的数据在数据库里存储的类型为 int 型)
+         * 目前有三种类型 Integer String Date <- 这个date类型特别设置出来 会对这个时间类型的数据做一次处理
+         */
+        private String type;
+
+        /**
+         * 分隔符
+         */
+        private String splitSymbol;
+
+        /**
+         * 处理方法
+         */
+        private String handler;
+    }
+
+}

PAS/src/main/java/cn/cslg/pas/controller/ProjectImportController.java

@@ -2,7 +2,6 @@ package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.annotation.Permission;
 import cn.cslg.pas.common.core.base.Constants;
-import cn.cslg.pas.common.model.vo.ImportDataVo;
 import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.ProjectImportVO;
 import cn.cslg.pas.common.model.vo.TaskParams;
@@ -10,7 +9,7 @@ import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.service.ProjectImportService;
 import cn.cslg.pas.service.ProjectImportStatusService;
 import cn.cslg.pas.service.ProjectService;
-import cn.cslg.pas.service.UploadSettingTest;
+import cn.cslg.pas.service.UploadBatchService;
 import cn.dev33.satoken.stp.StpUtil;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,14 +21,6 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.multipart.MultipartFile;
 
-import java.io.BufferedReader;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.Objects;
-
 /**
  * <p>
  * 专题库导入 前端控制器
@@ -49,7 +40,7 @@ public class ProjectImportController {
     private final ProjectImportService projectImportService;
     private final ProjectImportStatusService projectImportStatusService;
 
-    private final UploadSettingTest uploadSettingTest;
+    private final UploadBatchService uploadBatchService;
     private final FileUtils fileUtils;
 
     @Permission(roles = {2})
@@ -63,12 +54,11 @@ public class ProjectImportController {
         TaskParams taskParams = projectService.getImportPatentTaskParams(file, params.getProjectId());
         projectService.importPatent(taskParams, params);
 
-        // TODO: 2022/7/1 专利处理开始入口处
         //专利导入新方法入口
         //先解析Json文件 获得配置文件的Json串
         String getSettingJson = fileUtils.analysisJsonFile();
         //进入处理方法
-        uploadSettingTest.processData(taskParams, params, getSettingJson);
+        uploadBatchService.parsingConfigurationFiles(taskParams, params, getSettingJson);
 
         return Response.success(true);
     }

PAS/src/main/java/cn/cslg/pas/service/UploadBatchService.java

@@ -0,0 +1,248 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.model.vo.UploadSettingVO;
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import cn.cslg.pas.common.model.vo.TaskParams;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.utils.DateUtils;
+import cn.cslg.pas.common.utils.JsonUtils;
+import cn.cslg.pas.common.utils.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+@Service
+public class UploadBatchService {
+    //定义的一个工具参数 用于在装配数据的方法里 (fillDataToUploadParamsVO) 做存储数据的用途
+    private static Object classObj;
+    private static List<Object> lstObj = new ArrayList<>();
+
+    public void parsingConfigurationFiles(TaskParams taskParams, ProjectImportPatentVO projectImportPatentVO, String getSettingJson) {
+        //将 Json 转换为 对象数组
+        List<UploadSettingVO> test = JsonUtils.jsonToList(getSettingJson, UploadSettingVO.class);
+
+        //创建一个存放单一数据源的对象
+        //这个对象存放的是 我们需要使用哪一个数据源的配置数据 所以只存一个
+        //正常在Json文件里面会有多个数据源 也就是多条数据
+        List<UploadSettingVO.Column> jsonData = new ArrayList<>();
+
+        //开始将前端传入的数据源参数与 Json 中解析出来的 sourceId(数据来源ID) 进行比对
+        //并将比对中的那一条数据放入上方定义的 jsonData 中 用于后续使用
+
+        for (int i = 0; i < Objects.requireNonNull(test).size(); i++) {
+            //提取一个常量
+            UploadSettingVO constant = Objects.requireNonNull(test).get(i);
+            //判断 如果说 Json 解析出来的 List<T> 中的 sourceId 和传入参数的 sourceId 匹配成功 则开始装配数据
+            if (constant.getSourceId().equals(projectImportPatentVO.getSourceId())) {
+                //填充数据
+                jsonData = constant.getColumn();
+            }
+        }
+        //调用处理数据方法
+        processData(taskParams, jsonData);
+    }
+
+    private UploadParamsVO processData(TaskParams taskParams, List<UploadSettingVO.Column> jsonData) {
+        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+
+        try {
+            for (int i = 0; i < taskParams.getRowList().size(); i++) {
+                Map<Object, Object> row = taskParams.getRowList().get(i);
+                for (Object object : row.keySet()) {
+                    String key = object.toString();
+                    Object value = row.get(key);
+                    for (UploadSettingVO.Column jsonDatum : jsonData) {
+                        if (jsonDatum.getSetName().equals(key)) {
+                            switch (jsonDatum.getType()) {
+                                case "Date":
+                                    //将数据填充到最大类 UploadParamsVO 中
+                                    fillDataToUploadParamsVO(uploadParamsVO, DateUtils.getDateTime(value.toString()), jsonDatum.getColumn());
+                                    break;
+                                case "String":
+                                    if (!jsonDatum.getSplitSymbol().equals("")) {
+                                        List<String> splitList = StringUtils.changeStringToString(value.toString().replaceAll(" ", ""), jsonDatum.getSplitSymbol());
+
+                                        System.out.println("此处为进行数据拆分部分 开发中");
+                                    } else {
+                                        fillDataToUploadParamsVO(uploadParamsVO, row.toString(), jsonDatum.getColumn());
+                                    }
+                                    break;
+                                case "Integer":
+                                    fillDataToUploadParamsVO(uploadParamsVO, Integer.parseInt(value.toString()), jsonDatum.getColumn());
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return uploadParamsVO;
+    }
+
+    /**
+     * @param uploadParamsVO 最大的属性类
+     * @param object         需要存储的数据
+     * @param column         数据存储的字段
+     * @return uploadParamsVO 数据装填完毕的类 用于后续进行数据库操作
+     * @author 沈永艺
+     * @date 2022/7/4
+     * @description 通过反射将 UploadParamsVO 的属性进行解析 并将从Excel中获得到的数据填充到对应的字段中去
+     */
+
+    private static UploadParamsVO fillDataToUploadParamsVO(UploadParamsVO uploadParamsVO, Object object, String column) {
+        //通过反射获取 UploadParamsVO 的所有属性
+        Field[] field = uploadParamsVO.getClass().getDeclaredFields();
+
+        try {
+            //开始进行 UploadParamsVO 的属性级别的循环
+            for (Field item : field) {
+                item.setAccessible(true);
+                //System.out.println(item.get(uploadParamsVO));
+                //获取每一个属性的名称 例: patentAgent 或者 patentRightList 均为属性参数字段
+                String name = item.getName();
+                //将获取到的名称的首字母进行大写 用于后续获取 get set 方法的时候用 例 patent -> Patent
+                name = name.substring(0, 1).toUpperCase() + name.substring(1);
+                //获取这个属性的类型 目前在UploadParamsVO中只有 对象类型 和 数组类型(List)
+                String type = item.getGenericType().toString();
+                //进行属性类型的判断
+                //type的样式为:
+                //    对象类型: class com/cn.*.*.*.domain/model.自定义类名 (主要是对象类型会有一个 class 加空格)
+                //    List类型: java.util.List<com/cn.*.*.*.domain/model.自定义类名>
+                //如果类型中包含 class 说明该字段类型为对象类型
+                if (type.contains("class")) {
+                    if (object instanceof String || object instanceof Integer) {
+                        //从类型中获取对象类型的完整类型名称 (这里的方法是从后向前找到空格第一次出现的位置 做截取 然后再把空格替换没) 完整名称为 com/cn.*.*.*.domain/model.自定义类名
+                        String fullTypeName = type.substring(type.lastIndexOf(" ")).replace(" ", "");
+                        //用提取出的完整类型名称创建一个 新的 -> 该类型的 -> 类 这里可以说这个类叫 UploadParamsVO属性的类 简称属性类
+                        Object classModel = Class.forName(fullTypeName).newInstance();
+                        Object testModel = item.get(uploadParamsVO);
+                        System.out.println(testModel);
+                        if (classObj == null) {
+                            classObj = classModel;
+                        }
+                        //通过反射获取 属性类 的所有属性 (本质上是获取这个对象的所有字段)
+                        Field[] modelField = classObj.getClass().getDeclaredFields();
+                        //开始进行 属性类 级别的循环
+                        for (Field element : modelField) {
+                            //获取每一个属性的名称
+                            String modelName = element.getName();
+                            //因为需要向属性字段里面插入数据 所以判断一下 这个属性的名称和我们这一次调用这个方法时所传入的属性字段是否一致 如果一致 说明我们找到了这个字段 可以插入
+                            if (column.equals(modelName)) {
+                                //将获取到的名称的首字母进行大写 用于后续获取 get set 方法的时候用 例 manual -> Manual
+                                modelName = modelName.substring(0, 1).toUpperCase() + modelName.substring(1);
+                                //获取这个属性类的get方法 m 现在的样子就是 getXxx()
+                                Method m = classObj.getClass().getMethod("get" + modelName);
+                                //开始判断
+                                //如果这个属性类里面的字段的类型中包含 String 则说明 这个字段的类型为 java.lang.String 字符串型
+                                //如果这个属性类里面的字段的类型中包含 Integer 则说明 这个字段的类型为 java.lang.Integer 整型
+                                if (element.getGenericType().toString().contains("String")) {
+                                    //因为上面我们已经获取了 get 方法 所以现在直接就 get 这个字段的值
+                                    String value = (String) m.invoke(classModel);
+                                    //如果没有得到值 value 为 null 的话 我们就为他添加数据
+                                    if (value == null) {
+                                        //与获取 get 方法一致 现在我们要获取 set 方法 m 现在的样子就是 setXxx()
+                                        m = classObj.getClass().getMethod("set" + modelName, String.class);
+                                        //调用 set 方法 将数据填充进这个属性类里面
+                                        m.invoke(classObj, object.toString());
+                                    }
+                                } else if (element.getGenericType().toString().contains("Integer")) {
+                                    //直接 get 值
+                                    Integer value = (Integer) m.invoke(classObj);
+                                    //value 为 null 加数据
+                                    if (value == null) {
+                                        //获取 set 方法
+                                        m = classObj.getClass().getMethod("set" + modelName, Integer.class);
+                                        //set 值
+                                        m.invoke(classObj, Integer.parseInt(object.toString()));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    //这一步 是将我们填充好的属性类 填充进 UploadParamsVO 里所对应的这个属性参数中
+                    if (classObj != null) {
+                        //先获取 set 方法
+                        Method m = uploadParamsVO.getClass().getMethod("set" + name, classObj.getClass());
+                        //填充数据
+                        m.invoke(uploadParamsVO, classObj);
+                    }
+                } else if (type.contains("List") && type.contains("<") && type.contains(">")) {
+                    if (object instanceof List) {
+                        List<Object> list = new ArrayList<>();
+                        String path = type.substring(type.lastIndexOf("<")).replace("<", "").replace(">", "");
+                        Object listModel = Class.forName(path).newInstance();
+                        Field[] fieldName = listModel.getClass().getDeclaredFields();
+                        for (Field element : fieldName) {
+                            List<String> dataList = (List<String>) object;
+                            for (String s : dataList) {
+                                Object toStoreData = Class.forName(path).newInstance();
+                                String fieldNames = element.getName();
+                                if (column.equals(fieldNames)) {
+
+                                    Object testModelA = item.get(uploadParamsVO);
+                                    System.out.println(testModelA + "+++++++++++");
+                                    System.out.println(item);
+
+                                    fieldNames = fieldNames.substring(0, 1).toUpperCase() + fieldNames.substring(1);
+                                    String types = element.getGenericType().toString();
+                                    if (types.equals("class java.lang.String")) {
+                                        Method method = toStoreData.getClass().getMethod("set" + fieldNames, String.class);
+                                        method.invoke(toStoreData, s);
+                                    }
+
+                                    list.add(toStoreData);
+                                } else {
+                                    break;
+                                }
+                            }
+
+                        }
+                        Method m = uploadParamsVO.getClass().getMethod("set" + name, List.class);
+                        m.invoke(uploadParamsVO, list);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return uploadParamsVO;
+    }
+
+    public static void main(String[] args) {
+        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+
+        List<String> patentRightList = new ArrayList<>();
+        patentRightList.add("A");
+        patentRightList.add("B");
+        patentRightList.add("C");
+        patentRightList.add("D");
+
+        List<String> testList = new ArrayList<>();
+        testList.add("1");
+        testList.add("2");
+        testList.add("3");
+        testList.add("4");
+        testList.add("5");
+
+//        fillDataToUploadParamsVO(uploadParamsVO, patentRightList, "content");
+        fillDataToUploadParamsVO(uploadParamsVO, testList, "contentOut");
+//        fillDataToUploadParamsVO(uploadParamsVO, 1, "sort");
+
+        fillDataToUploadParamsVO(uploadParamsVO, "SYY", "manual");
+        fillDataToUploadParamsVO(uploadParamsVO, "SUU", "manualOut");
+        fillDataToUploadParamsVO(uploadParamsVO, 1, "patentId");
+
+        System.out.println(uploadParamsVO);
+    }
+}
+

PAS/src/main/java/cn/cslg/pas/service/UploadSettingTest.java

@@ -1,181 +0,0 @@
-package cn.cslg.pas.service;
-
-import cn.cslg.pas.common.model.vo.ImportDataVo;
-import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
-import cn.cslg.pas.common.model.vo.TaskParams;
-import cn.cslg.pas.common.model.vo.UploadParamsVO;
-import cn.cslg.pas.common.utils.DateUtils;
-import cn.cslg.pas.common.utils.JsonUtils;
-import cn.cslg.pas.domain.PatentInstructionText;
-import org.springframework.stereotype.Service;
-import org.springframework.util.ReflectionUtils;
-
-import java.lang.reflect.*;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-@Service
-public class UploadSettingTest {
-
-    public void processData(TaskParams taskParams, ProjectImportPatentVO projectImportPatentVO, String getSettingJson) {
-        //将 Json 转换为 对象数组
-        List<ImportDataVo> test = JsonUtils.jsonToList(getSettingJson, ImportDataVo.class);
-        /*
-         *  创建一个存放单一数据源的对象
-         *  这个对象存放的是 我们需要使用哪一个数据源的配置数据 所以只存一个
-         *  正常在Json文件里面会有多个数据源 也就是多条数据
-         * */
-        List<ImportDataVo.Column> jsonData = new ArrayList<>();
-        /*
-         *   开始将前端传入的数据源参数与 Json 中解析出来的 sourceId(数据来源ID) 进行比对
-         *   并将比对中的那一条数据放入上方定义的 jsonData 中 用于后续使用
-         * */
-        for (int i = 0; i < Objects.requireNonNull(test).size(); i++) {
-            //提取一个常量
-            ImportDataVo constant = Objects.requireNonNull(test).get(i);
-            //判断 如果说 Json 解析出来的 List<T> 中的 sourceId 和传入参数的 sourceId 匹配成功 则开始装配数据
-            if (constant.getSourceId().equals(projectImportPatentVO.getSourceId())) {
-                //填充数据
-                jsonData = constant.getColumn();
-            }
-        }
-        // TODO: 2022/7/1 从解析出来的配置文件Json里面和Excel解析出来的栏位进行匹配 FOR循环 能不能在减少一层？
-        // TODO: 2022/7/1 接入分割处理方法 处理Excel解析数据 然后作为参数装配进 UploadParamsVO里面 如何实现？
-
-        try {
-            for (int i = 0; i < taskParams.getRowList().size(); i++) {
-                Map<Object, Object> row = taskParams.getRowList().get(i);
-                Class<UploadParamsVO> clazz = UploadParamsVO.class;
-                UploadParamsVO uploadParamsVO = clazz.newInstance();
-                for (Object object : row.keySet()) {
-                    String key = object.toString();
-                    Object value = row.get(key);
-                    for (ImportDataVo.Column jsonDatum : jsonData) {
-                        if (jsonDatum.getSetName().equals(key)) {
-                            Field propertyList = clazz.getDeclaredField(jsonDatum.getColumn());
-                            ReflectionUtils.makeAccessible(propertyList);
-                            switch (jsonDatum.getType()) {
-                                case "Date":
-                                    ReflectionUtils.setField(propertyList, uploadParamsVO, DateUtils.getDateTime(value.toString()));
-                                    break;
-                                case "String":
-                                    if (!jsonDatum.getSplitSymbol().equals("")) {
-                                        // TODO: 2022/7/1 进入到数据拆分流程 新建方法将分隔符以参数的形式传入拆分公用方法内
-                                        System.out.println("此处为进行数据拆分部分 待开发");
-                                    } else {
-
-                                        PatentInstructionText patentInstructionText = new PatentInstructionText();
-                                        patentInstructionText.setManual(value.toString());
-                                    }
-                                    ReflectionUtils.setField(propertyList, uploadParamsVO, value.toString());
-                                    break;
-                                case "Integer":
-                                    ReflectionUtils.setField(propertyList, uploadParamsVO, Integer.parseInt(value.toString()));
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    }
-                }
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static void fillDataToUploadParamsVO(UploadParamsVO uploadParamsVO) {
-        //通过反射获取所有属性
-        Field[] field = uploadParamsVO.getClass().getDeclaredFields();
-        try {
-            //开始进行 属性级别的循环
-            for (Field item : field) {
-                //获取每一个属性的名称 例: patentAgent 或者 patentRightList 均为属性参数字段
-                String name = item.getName();
-                //将获取到的名称的首字母进行大写 用于后续获取 get set 方法的时候用
-                name = name.substring(0, 1).toUpperCase() + name.substring(1);
-                //获取这个属性的类型 目前在UploadParamsVO中只有 对象类型 和 数组类型(List)
-                String type = item.getGenericType().toString();
-
-                //进行属性类型的判断
-                //type的样式为:
-                //    对象类型: class com/cn.*.*.*.domain/model.自定义类名 (主要是对象类型会有一个 class 加空格)
-                //    List类型: java.util.List<com/cn.*.*.*.domain/model.自定义类名>
-                //如果类型中包含 class 说明该字段类型为对象类型
-                if (type.contains("class")) {
-                    //从类型中获取对象类型的完整名称 (这里的方法是从后向前找到空格第一次出现的位置 做截取 然后再把空格替换没) 完整名称为 com/cn.*.*.*.domain/model.自定义类名
-                    String path = type.substring(type.lastIndexOf(" ")).replace(" ", "");
-                    //将
-                    Object model = Class.forName(path).newInstance();
-                    //
-                    Field[] modelField = model.getClass().getDeclaredFields();
-                    for (Field element : modelField) {
-                        String modelName = element.getName();
-
-                        modelName = modelName.substring(0, 1).toUpperCase() + modelName.substring(1);
-
-                        Method m = model.getClass().getMethod("get" + modelName);
-                        if (element.getGenericType().toString().contains("String")) {
-                            String value = (String) m.invoke(model);
-                            if (value == null) {
-                                m = model.getClass().getMethod("set" + modelName, String.class);
-                                m.invoke(model, "对象类型测试数据");
-                            }
-                        } else if (element.getGenericType().toString().contains("Integer")) {
-                            Integer value = (Integer) m.invoke(model);
-                            if (value == null) {
-                                m = model.getClass().getMethod("set" + modelName, Integer.class);
-                                m.invoke(model, 2);
-                            }
-                        }
-                    }
-                    Method m = uploadParamsVO.getClass().getMethod("set" + name, model.getClass());
-                    m.invoke(uploadParamsVO, model);
-                } else if (type.contains("List") && type.contains("<") && type.contains(">")) {
-                    List<Object> list = new ArrayList<>();
-                    String path = type.substring(type.lastIndexOf("<")).replace("<", "").replace(">", "");
-                    Object model = Class.forName(path).newInstance();
-                    Field[] fieldName = model.getClass().getDeclaredFields();
-                    for (Field element : fieldName) {
-                        String fieldNames = element.getName();
-                        fieldNames = fieldNames.substring(0, 1).toUpperCase() + fieldNames.substring(1);
-                        String types = element.getGenericType().toString();
-                        if (types.equals("class java.lang.String")) {
-                            Method method = model.getClass().getMethod("get" + fieldNames);
-                            String value = (String) method.invoke(model);
-                            if (value == null) {
-                                method = model.getClass().getMethod("set" + fieldNames, String.class);
-                                method.invoke(model, "列表类型测试数据");
-                            }
-                        } else if (types.equals("class java.lang.Integer")) {
-                            Method method = model.getClass().getMethod("get" + fieldNames);
-                            Integer value = (Integer) method.invoke(model);
-                            if (value == null) {
-                                method = model.getClass().getMethod("set" + fieldNames, Integer.class);
-                                method.invoke(model, 1);
-                            }
-                        }
-                    }
-                    Method m = uploadParamsVO.getClass().getMethod("get" + name);
-                    list.add(model);
-                    List value = (List) m.invoke(uploadParamsVO);
-                    if (value == null) {
-                        m = uploadParamsVO.getClass().getMethod("set" + name, List.class);
-                        m.invoke(uploadParamsVO, list);
-                    }
-                }
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void main(String[] args) {
-        UploadParamsVO uploadParamsVO = new UploadParamsVO();
-        fillDataToUploadParamsVO(uploadParamsVO);
-        System.out.println(uploadParamsVO);
-    }
-}
-

PAS/src/main/resources/application.yml

@@ -20,7 +20,7 @@ spring:
       max-file-size: 1000MB
       max-request-size: 1000MB
   profiles:
-    active: test
+    active: dev
   jackson:
     default-property-inclusion: non_null
     serialization: