cn.benma666.sjsj.web.DefaultLjq Maven / Gradle / Ivy

Go to download
/**
 * Project Name:myutils
 * Date:2018年12月16日
 * Copyright (c) 2018, jingma All Rights Reserved.
 */

package cn.benma666.sjsj.web;

import cn.benma666.constants.SysAuth;
import cn.benma666.crypt.MD5Util;
import cn.benma666.dict.*;
import cn.benma666.domain.*;
import cn.benma666.excel.ImageConverter;
import cn.benma666.excel.ImageConverterKey;
import cn.benma666.excel.MyLongestMatchColumnWidthStyleStrategy;
import cn.benma666.exception.DictException;
import cn.benma666.exception.MyException;
import cn.benma666.exception.QxException;
import cn.benma666.exception.VerifyRuleException;
import cn.benma666.json.JsonUtil;
import cn.benma666.iframe.*;
import cn.benma666.myutils.DateUtil;
import cn.benma666.myutils.*;
import cn.benma666.params.other.Dcsjycl;
import cn.benma666.sjsj.myutils.Msg;
import cn.benma666.sjsj.myutils.MyTransactional;
import cn.benma666.sjsj.myutils.ThreadPool;
import cn.benma666.sjsj.znjh.MyZnjh;
import cn.benma666.sjzt.*;
import cn.benma666.sjzt.bdwj.BdwjFile;
import cn.benma666.vo.WebSocketKhdxxVo;
import com.alibaba.druid.util.Utils;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.converters.ConverterKeyBuild;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.alibaba.excel.write.builder.ExcelWriterSheetBuilder;
import com.alibaba.excel.write.handler.CellWriteHandler;
import com.alibaba.excel.write.handler.SheetWriteHandler;
import com.alibaba.excel.write.handler.context.CellWriteHandlerContext;
import com.alibaba.excel.write.handler.context.SheetWriteHandlerContext;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteWorkbookHolder;
import com.alibaba.excel.write.metadata.style.WriteCellStyle;
import com.alibaba.excel.write.style.column.AbstractColumnWidthStyleStrategy;
import com.alibaba.excel.write.style.row.SimpleRowHeightStyleStrategy;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.util.TypeUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.beetl.sql.clazz.SQLType;
import org.beetl.sql.core.*;
import org.beetl.sql.core.mapping.BeanProcessor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.context.annotation.Scope;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.nio.charset.StandardCharsets;
import java.sql.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 默认拦截器 

 * date: 2018年12月16日 

 *
 * @author jingma
 */
@Component("MyDefaultLjq")
@Scope("prototype")
public class DefaultLjq extends BasicObject implements LjqInterface {
    /**
     * 去重字段列表缓存后缀
     */
    public static final String QCZD_LIST = "_qczdList";
    /**
     * 数据对象Map<对象key，对象>
     */
    protected static final JSONObject sjdxMap = CacheFactory.use(KEY_SJDX);
    /**
     * 字段信息缓存
     */
    protected static JSONObject fieldsCache = CacheFactory.use(KEY_FIELDS, CacheFactory.TYPE_MEMORY);
    /**
     * 允许的文件类型
     */
    protected static Collection yxdwjlx = Arrays.asList(
            valByDef(Conf.getUtilConfig().getService().getYxscwjlx(),
            "xls,xlsx,txt,csv,zip,rar,7z,png,jpg,json,xml").split(","));

    public DefaultLjq(){
    }
    /**
     * 获取处理类型
     *
     * @param myParams 参数对象
     * @return 处理类型
     */
    public static String getCllx(MyParams myParams) {
        return myParams.sys().getCllx();
    }

    public Result initSjdx(MyParams myParams) throws MyException{
        if (StringUtil.isBlank(getCllx(myParams))) {
            throw new MyException(Msg.msg("interceptor.bxsscllx", "sys.cllx"));
        }
        //记录请求开始时间
        myParams.sys().setQqkssj(System.currentTimeMillis());
        //获取用户信息
        @Nullable SysQxYhxx user = LjqManager.getUser(myParams);
        myParams.put(KEY_USER, user);
        //穿透场景不进行对象处理
        if(isCt(myParams)){
            //记录操作日志
            initCzrz(myParams, user);
            return success("获取基础信息成功",myParams);
        }
        SysSjglSjdx sjdx;
        //读取缓存
        String cacheKey = StringUtil.fastNotNull(myParams.sys().getDlsjdxid(),
                myParams.sys().getDlsjdxdm(),myParams.sys().getAuthCode(),
                myParams.sjdx().getId(),myParams.sjdx().getDxdm());
        if(!isBlank(cacheKey)){
            synchronized (sjdxMap){
                //进行同步操作，不免重复查询，缓存加载完成后这里应该耗时很少，应该不会成为瓶颈
                Object obj = sjdxMap.get(cacheKey);
                if (obj != null && !valByDef(myParams.sys().getClearCache(),false)) {
                    sjdx = (SysSjglSjdx) obj;
                } else {
                    JSONObject jsonObj = Db.use().findFirst(SqlId.of("sjsj", "findSjdx"), myParams);
                    if (jsonObj == null) {
                        throw new MyException(Msg.msg("interceptor.sjdxbwy", cacheKey), myParams);
                    }
                    sjdx = jsonObj.toJavaObject(SysSjglSjdx.class);
                    //设置缓存
                    sjdxMap.put(cacheKey,sjdx);
                }
            }
        }else {
            throw new MyException("该请求没有设置数据对象信息");
        }
        JSONObject defParams = JSONObject.parseObject(Conf.getVal("sjdx.jcxx1"), Feature.OrderedField);
        //合并新配置与默认配置
        myParams.putAll(JsonUtil.mergeJSONObjects(defParams,myParams));
        if(!myParams.sys().getNbdy()&&!UserManager.hasAuth(user, SysAuth.QTQX_SYS.name())){
            //非内部调用且没有最高权限
            defParams= JSONObject.parseObject(Conf.getVal("sjdx.jcxx2"), Feature.OrderedField);
            //合并优先级高于用户传参的默认配置2（核心关键配置），对前端传参进行控制，避免前端传参权力太大，入侵系统
            JsonUtil.mergeJSONObjects(myParams,defParams);
        }
        //合并数据对象的扩展信息到系统参数中
        if(sjdx!=null){
            if(valByDef(Conf.getUtilConfig().getZnjh().getZdctdy(), true)){
                log.trace("开始进行自动补充穿透调用:{},{},{}",sjdx,sjdx.getSjztObj(),myParams.sys().getCtapp());
                if(!isBlank(sjdx.getSjztObj().getSsyy())&&isBlank(myParams.sys().getCtapp())){
                    //数据载体设置了所属应用且外部没有设置穿透app时自动补充
                    myParams.sys().setCtapp(sjdx.getSjztObj().getSsyy());
                }
                if(!isBlank(myParams.sys().getCtapp())){
                    //自动设置穿透调用，有穿透app时，查看是否需要进行穿透调用
                    SysZnjhCtdy ctdy = MyZnjh.getCtdyByMbjd(myParams.sys().getCtapp());
                    if (!isBlank(ctdy.getDm())) {
                        myParams.sys().setCtdy(ctdy.getDm());
                    }
                }
            }
            //设置从数据库中读取的数据对象
            myParams.put(KEY_SJDX, sjdx);
            //通过大字典扩展对象，对象本地的扩展信息字段大小限制4000可能存不下，较少使用
            String kzxx = Conf.getVal(sjdx.getDxdm() + ".kzxx");
            if(!isBlank(kzxx)){
                JsonUtil.mergeJSONObjects(myParams, JSONObject.parseObject(kzxx, Feature.OrderedField));
            }
            JsonUtil.mergeJSONObjects(myParams, sjdx.getKzxxObj());
            //对rest接口的支持（支持路径参数传递一个关键参数）：SEARCHKEY处理，非查询场景，设置了该参数时,且原始参数没有设置主键，自动设置为对象主键
            if(!Cllx.select.name().equals(myParams.sys().getCllx())
                    &&StringUtil.isNotBlank(myParams.sys().getSearchKey())
                    &&isBlank(myParams.get("$.yobj."+sjdx.getZddmZjzd()))){
                myParams.set("$.yobj."+sjdx.getZddmZjzd(),myParams.sys().getSearchKey());
            }
        }
        //穿透场景不获字段等信息
        if(isCt(myParams)){
            //记录操作日志
            initCzrz(myParams, user);
            return success("获取基础信息成功",myParams);
        }
        //获取基础信息
        return success("获取基础信息成功",LjqManager.jcxx(myParams));
    }

    /**
     * 是否穿透
     */
    public boolean isCt(MyParams myParams){
        //穿透场景不获字段等信息
        if(!isBlank(myParams.sys().getCtqapp())&&!Conf.getAppdm()
                .equals(myParams.sys().getCtqapp())){
            //穿透前app调用
            return true;
        }else if(!isBlank(myParams.sys().getCtdy())){
            return true;
        }else if(!isBlank(myParams.sys().getCtapp())&&!Conf.getAppdm()
                .equals(myParams.sys().getCtapp())){
            return true;
        }
        return false;
    }
    public Result jcxx(MyParams myParams) {
        SysQxYhxx user = myParams.user();
        //处理权限码
        if(isBlank(myParams.sys().getAuthCode())){
            //若前端没有传入权限码
            if(user!=null&&getSjdx()!=null&&user.getDxqxys().get(getSjdx().getDxdm())!=null){
                //优先取当前用户获得授权的权限码
                myParams.sys().setAuthCode(user.getDxqxys().get(getSjdx().getDxdm()).getString("qxm"));
            }else if(getSjdx()!=null){
                //若都没有授权则随机取，其实取哪个已经没意义了，反正都一样没权限
                myParams.sys().setAuthCode(getSjdx().getAuthCode());
            }else if(isBlank(myParams.sys().getController())&&user!=null
                &&user.getDxqxys().get(myParams.sys().getController())!=null){
                //定制场景
                myParams.sys().setAuthCode(user.getDxqxys().get(myParams.sys()
                        .getController()).getString("qxm"));
            }
        }
        //获取字段信息
        if(getSjdx()!=null){
            //没有数据对象不获取字段
            try{
                getFields(myParams, user);
            }catch (MyException e){
                //权限鉴定
                auth(myParams);
                throw e;
            }
        }
        //记录操作日志
        initCzrz(myParams, user);
        //权限鉴定
        auth(myParams);
        //非定制场景
        if(getSjdx()!=null){
            if (myParams.getBooleanValue("$.cllxkz."+getCllx(myParams)+".putobj")) {
                //设置需要处理的对象
                putObj(myParams,false);
            }
            //转换规则
            zhgz(myParams);
            //参数预处理
            csycl(myParams);
            //验证规则
            yzgz(myParams);
        }
        log.trace("基础信息获取完成");
        return success("获取基础信息成功",myParams);
    }

    /**
     * 参数预处理
     */
    protected void csycl(MyParams myParams) {
        JSONObject yobj = myParams.getJSONObject(KEY_YOBJ);
        if(isBlank(yobj)){
            return;
        }
        String cllx = getCllx(myParams);
        Map fields = (Map) myParams.get(KEY_FIELDS);
        for(Map.Entry e:fields.entrySet()){
            if (isBlank(yobj.get(e.getKey()))){
                //空值忽略
                continue;
            }
            SysSjglSjzd f = e.getValue();
            JSONArray list;
            if(f.getZdywlb().contains("plcz")){
                //混合保存支持
                list = yobj.getJSONArray(e.getKey());
                //参数重组
                yobj.remove(e.getKey());
                if("MyFile".equals(f.getKjlx())){
                    //文件控件，表示通过文件批量上传的数据
                    myParams.sys().setFiles(list);
                    //转为批量保存
                    if(Cllx.insert.name().equals(cllx)||Cllx.update.name().equals(cllx)
                            ||Cllx.save.name().equals(cllx)){
                        //一般保存转为数据批量上传
                        myParams.sys().setCllx(Cllx.sjplsc.name());
                    }
                }else {
                    List nList = new ArrayList<>();
                    JSONObject no;
                    for (JSONObject o:list.toJavaList(JSONObject.class)){
                        no = yobj.clone();
                        JsonUtil.mergeJSONObject(no,o);
                        nList.add(no);
                    }
                    myParams.sys().setEditTableData(nList);
                    myParams.remove(KEY_YOBJ);
                    //转为批量保存
                    if(Cllx.insert.name().equals(cllx)||Cllx.update.name().equals(cllx)
                            ||Cllx.save.name().equals(cllx)){
                        //一般保存转为批量保存
                        myParams.sys().setCllx(Cllx.plbc.name());
                    }
                }
            }else if(f.getZdywlb().contains("glcz")){
                //关联操作
                Object val = yobj.get(e.getKey());
                yobj.remove(e.getKey());
                MyParams glcs = new MyParams(f.getKzxxObj().getJSONObject("glcs"));
                if(isBlank(glcs)){
                    throw new MyException("关联操作参数不能为空："+e.getKey());
                }
                if(val instanceof List){
                    if("MyFile".equals(f.getKjlx())){
                        //文件控件，表示通过文件批量上传的数据
                        glcs.sys().setFiles((List) val);
                        cllx = getCllx(glcs);
                        //转为批量保存
                        if(Cllx.insert.name().equals(cllx)||Cllx.update.name().equals(cllx)
                                ||Cllx.save.name().equals(cllx)){
                            //一般保存转为数据批量上传
                            glcs.sys().setCllx(Cllx.sjplsc.name());
                        }
                    }else {
                        glcs.sys().setEditTableData((List) val);
                    }
                }else {
                    glcs.put(KEY_YOBJ,val);
                }
                myParams.sys().getCstcl().put(f.getZdmc(),glcs);
            }
        }
    }

    /**
     * 转换规则
     * @param myParams 相关参数
     */
    public void zhgz(MyParams myParams) {
        JSONObject zhgz = myParams.getJSONObject(KEY_ZHGZ);
        if (zhgz==null) {
            //没有配置转换信息
            return;
        }
        //取出验证规则
        String cllx = getCllx(myParams);
        for (String key : zhgz.keySet()) {
            JSONObject gzObj = zhgz.getJSONObject(key);
            Object val = myParams.get("$." + key);
            Object newVal = TransRule.ruleTrans(val,myParams, gzObj, cllx);
            if((isBlank(val)&&isBlank(newVal))){
                //原始值为空，转换后也为空则跳过
                continue;
            }
            //转换数据
            myParams.set("$." + key,newVal);
        }
    }

    /**
     * 验证规则
     * @param myParams 相关参数
     */
    public void yzgz(MyParams myParams) {
        //取出验证规则
        JSONObject yzgz = myParams.getJSONObject(KEY_YZGZ);
        if (myParams.get(KEY_USER) == null||yzgz==null) {
            //没有用户信息默认为系统内部调用，不进行验证，或没有配置验证信息
            return;
        }
        String cllx = getCllx(myParams);
        for (String key : yzgz.keySet()) {
            JSONObject gzObj = yzgz.getJSONObject(key);
            try {
                Object val = myParams.get("$." + key);
                Object newVal = VerifyRule.ruleVerify(myParams.get("$." + key),
                        myParams, gzObj, cllx);
                if((isBlank(val)&&isBlank(newVal))){
                    //原始值为空，转换后也为空则跳过
                    continue;
                }
                //转换数据
                myParams.set("$." + key,newVal);
            } catch (VerifyRuleException e) {
                throw new MyException(e.getMessage(), HttpStatus.PRECONDITION_FAILED.value(), key);
            }
        }
    }

    /**
     * 采用base64的方式上传
     */
    public Result upload(MyParams myParams) throws Exception {
        SysSjglFile file = myParams.yobj(SysSjglFile.class);
        if(StringUtil.isBlank(file.getWjnr())){
            throw new MyException("没有获取到上传文件内容");
        }
        if(!yxdwjlx.contains(file.getWjlx())){
            throw new MyException("上传的文件类型不支持："+file.getWjlx());
        }
        if(StringUtil.isEmpty(file.getYwdm())){
            file.setYwdm("dxsjsc");
        }
        if(StringUtil.isEmpty(file.getWjlb())){
            file.setWjlb(getSjdx().getDxdm());
        }
        byte[] byteArr = Base64.getDecoder().decode(file.getWjnr());
        //去重码ywdm+wjlb+MD5
        file.setQcm(file.getYwdm() + file.getWjlb() + FileUtil.getFileMD5(byteArr));
        //如果表中存在此去重码则把这个文件删除
        MyLambdaQuery fileMyLambdaQuery = db(DEFAULT).lambdaQuery(SysSjglFile.class,myParams.user());
        SysSjglFile f = fileMyLambdaQuery.andEq(SysSjglFile::getQcm,file.getQcm()).singleSimple();
        if (f!=null) {
            log.info(f.getWjm() + "文件已经存在"+f.getId());
            return success("该文件已经存在", f.toQd());
        }
        IFile ifile = file.toIFile();
        ifile.save(new ByteArrayInputStream(byteArr));
        //保存文件记录
        file.setWjdx(byteArr.length);
        file.setSclj(ifile.getAbsolutePath());
        fileMyLambdaQuery.insertSelective(file);
        //避免文件内容打印到日志和返回前端
        file.setWjnr(null);
        log.debug(file.getWjm() + "文件上传成功");
        return success("文件上传成功", file.toQd());
    }

    /**
     * 只取对外有用的,系统基础信息
     * @return 系统基础信息
     */
    public Result xtjcxx(MyParams myParams){
        MyParams jcxx = new MyParams();
        jcxx.put(KEY_USER,myParams.user().toQd());
        JsonUtil.copy(jcxx, myParams, $_SYS_TOKEN);
        JsonUtil.copy(jcxx, myParams, $_SYS_CLIENT_IP);
        //设置在线用户数
        jcxx.set("$.sys.zxyhs", XtxxWebSocket.getOnlineCount());
        return success("基础信息获取成功", jcxx);
    }
    /**
     * 只取对外有用的,对象基础信息
     * @return 对象基础信息
     */
    public Result dxjcxx(MyParams myParams){
        //只取对外有用的，对象基础信息
        JSONObject jcxx = new JSONObject();
        jcxx.put(KEY_SJDX, myParams.get(KEY_SJDX));
        jcxx.put(KEY_FIELDS, myParams.get(KEY_FIELDS));
        jcxx.put(KEY_OBJ, myParams.get(KEY_OBJ));
        JsonUtil.copy(jcxx, myParams, "$.cllxkz");
        JsonUtil.copy(jcxx, myParams, "$.sys.sjdxkz");
        JsonUtil.copy(jcxx, myParams, "$.sys.fields");
        JsonUtil.copy(jcxx, myParams, "$.sys.cdlj");
        JsonUtil.copy(jcxx, myParams, $_SYS_AUTHCODE);
        return success("对象基础信息获取成功", jcxx);
    }

    public Result getdata(MyParams myParams) {
        //创建个对象，用于在模板中可以设置一些数据作为结果传给前端
        JSONObject resultData = new JSONObject();
        myParams.sql().setResultData(resultData);

        //先调用一次查询语句，获取默认查询条件
        LjqManager.getSql(myParams,Cllx.select.name());
        String[] arr = (String[]) getSql(myParams).getData();
        resultData.put("list", db(arr[0]).find(arr[1], myParams));
        return success("操作成功", resultData);
    }


    public Result plcl(MyParams myParams) {
        //先调用一次查询语句，获取默认查询条件
        LjqManager.getSql(myParams,Cllx.select.name());
        String[] arr = LjqManager.getSql(myParams);
        final int update = db(arr[0]).update(arr[1], myParams);
        return success("操作成功："+update, update);
    }

    /**
     * 导出当前页数据
     */
    public Result dcdqysj(MyParams myParams) {
        return dcsj(myParams);
    }

    public Result dcsj(MyParams myParams) {
        //导出数据
        myParams.set("$.page.totalRequired", Boolean.FALSE);
        myParams.set("$.page.listRequired", Boolean.TRUE);
        PageInfo page = (PageInfo) LjqManager.select(myParams).getData();
        String fileName = getSjdx().getDxmc()+"-" + DateUtil.getGabDate();
        try {
            dcsjYcl(myParams,page.getList(),Cllx.dcsj.name());
            return resultExcelFile(myParams, myParams.other().getDcsjycl().getHeader(),
                    myParams.other().getDcsjycl().getData(), fileName);
        } catch (Exception e) {
            throw new MyException("导出数据失败，请查看系统日志分析原因",e);
        }
    }


    public Result getfile(MyParams myParams) {
        String[] arr;
        try {
            arr = (String[]) LjqManager.getSql(myParams);
            List rl = db(arr[0]).find(arr[1], myParams);
            if (rl.size() == 0) {
                throw new MyException("未找到文件数据");
            }
            JSONObject fo = rl.get(0);
            SysSjglFile file = fo.toJavaObject(SysSjglFile.class);
            String sjxs = fo.getString("sjxs");
            byte[] byteArr = null;
            if ("bdwjjl".equals(sjxs)) {
                byteArr = Utils.readByteArray(new FileInputStream(fo.getString("data")));
            } else if ("blob".equals(sjxs)) {
                byteArr = fo.getBytes("data");
            }
            if(myParams.containsKey("$.sys.xzms")){
                file.setXzms(myParams.getIntValue("$.sys.xzms"));
            }
            return resultFile(byteArr, file);
        } catch (Exception e) {
            log.error("获取文件失败:" + myParams, e);
            throw new MyException("获取文件失败，请查看系统日志分析原因:" + e.getMessage());
        }
    }

    /**
     * 下载文件
     * @param myParams 相关参数
     * @return 处理结果
     */
    public Result download(MyParams myParams) {
        MyParams fileJcxx = LjqManager.jcxxByDxdm("SYS_SJGL_FILE",myParams.user());
        fileJcxx.set("$.page.totalRequired", Boolean.FALSE);
        fileJcxx.put(KEY_YOBJ,myParams.get(KEY_YOBJ));
        fileJcxx.yobj(SysSjglFile.class).setYxx(Ljpd.TURE.getCode()+"");
        JsonUtil.copy(fileJcxx,myParams,$_SYS_IDS);
        PageInfo page = (PageInfo) LjqManager.select(fileJcxx).getData();
        if (page.getList().size() == 0) {
            throw new MyException("没有找到该文件");
        } else if (page.getList().size() > 1) {
            throw new MyException("不能找到唯一的文件记录");
        }
        SysSjglFile file = page.getList().get(0).toJavaObject(SysSjglFile.class);
        return resultFile(file.getFileBytes(), file);
    }



    public Result sjplsc(MyParams myParams) {
        JSONArray files = myParams.getJSONArray("$.sys.files");
        if(isBlank(files)){
            throw new MyException("没有获取到文件，请确认文件正确上传");
        }
        Result r = success("");
        int count = 0;
        int insert = 0;
        int update = 0;
        int ignore = 0;
        int repeat = 0;
        List succFiles = new ArrayList<>();
        SysSjglFile file = null;
        try {
            for(int i=0;i0){
            r.setMsg(StringUtil.join(succFiles,","));
            Result r1 = sjplcljg(count, insert, update, ignore, repeat);
            r.addMsg(r1.getMsg());
            r.setData(r1.getData());
        }
        return r;
    }

    /**
     * 批量数据转换验证
     * @param myParams 参数体
     * @return 验证转换结果
     */
    public Result plsjzhyz(MyParams myParams) {
        JSONArray editTableData = myParams.getJSONArray($_SYS_EDITTABLEDATA);
        if(isBlank(editTableData)){
            return success("没有提供批量转换验证的数据");
        }
        //重复数据量
        List list = editTableData.toJavaList(JSONObject.class);
        //处理后的数据列表，用于后续批量插入更新
        List dataList;
        if (Db.isSupported(getSjdx().getDxztlx()) || SjztLx.es.name().equals(getSjdx().getDxztlx())) {
            //数据库场景才进行查重操作
            dataList = new ArrayList<>();
            List