JAVA Map 返回与接受自定义格式

patsxy 2023-03-31 17:45:49

package com.igapm.generic.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.igapm.common.enums.InputTypeEnum;
import com.igapm.common.mybatis.core.page.PageQuery;
import com.igapm.common.mybatis.core.page.TableDataInfo;
import com.igapm.common.util.DictSelect;
import com.igapm.generic.domain.CommonConfig;
import com.igapm.generic.domain.CommonConfigPlan;
import com.igapm.generic.domain.dto.CommonConfigDTO;
import com.igapm.generic.domain.query.CommonConfigQuery;
import com.igapm.generic.domain.vo.CommonConfigVO;
import com.igapm.generic.enums.ConfigPlanStatusEnum;
import com.igapm.generic.mapper.CommonConfigMapper;
import com.igapm.generic.mapper.CommonConfigPlanMapper;
import com.igapm.generic.service.ICommonConfigService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**

通用查询字段配置Service业务层处理
@author igapm
@date 2023-03-16
/
@RequiredArgsConstructor
@Service
public class CommonConfigServiceImpl implements ICommonConfigService {

private final CommonConfigMapper baseMapper;

private final CommonConfigPlanMapper configPlanMapper;

/**
- 通用查询字段配置动态列分页列表
- /
  @Override
  public TableDataInfo<Map<String, Object>> getDyColPageList(CommonConfigQuery pageQuery) {
  //根据前端路由获取配置生效的方案
  LambdaQueryWrapper wrapper = Wrappers.lambdaQuery();
  wrapper.eq(CommonConfigPlan::getPageRoute, pageQuery.getPageRoute());
  wrapper.eq(CommonConfigPlan::getStatus, ConfigPlanStatusEnum.YES.getCode());
  CommonConfigPlan commonConfigPlan = configPlanMapper.selectOne(wrapper);
  if (commonConfigPlan == null) {
```
  return TableDataInfo.pageFail("该模块路由没有配置方案！");
```
  }
  //根据方案ID获取配置的字段集合
  LambdaQueryWrapper configWrapper = Wrappers.lambdaQuery();
  configWrapper.eq(CommonConfig::getCommonConfigPlanId, commonConfigPlan.getId());
  List commonConfigs = baseMapper.selectList(configWrapper);
  if (CollectionUtils.isEmpty(commonConfigs)) {
```
  return TableDataInfo.pageFail("该模块路由没有配置方案字段！");
```
  }
  //转换要返回的动态列的表头信息
  List
  titleList = commonConfigs.stream().map(commonConfig -> {
```
  Map<String, Object> beanToMap = BeanUtil.beanToMap(commonConfig, true, true);
  beanToMap.put("column" , StrUtil.toCamelCase(commonConfig.getColumnName(), '_'));
  beanToMap.put("name" , commonConfig.getColumnComment());
  beanToMap.put("type" , commonConfig.getInputType());
  return beanToMap;
```
  }).collect(Collectors.toList());
  //处理表头集合中存在的下拉字段，动态添加option下拉集合数据
  titleList = DictSelect.setFormOptionList(titleList, null);
  String inputTypeCode = String.valueOf(InputTypeEnum.SELECT.getCode());
  //过滤下拉的字段集合，用于区分普通字典下拉和人员下拉
  List
  filerStrList = titleList.stream().filter(f -> f.get("type").toString()
```
      .equals(inputTypeCode)).map(map -> {
          Map hashMap = new HashMap();
          hashMap.put("column",map.get("column"));
          hashMap.put("select_source",map.get("select_source"));
          return hashMap;
      }).collect(Collectors.toList());
```
  //转换动态列方案信息为SQL
  StringBuffer sb = new StringBuffer();
  sb.append("select ");
  commonConfigs.stream().forEach(commonConfig -> {
```
  sb.append(commonConfig.getTableName() + "." + commonConfig.getColumnName()
          + " AS `" + StrUtil.toCamelCase(commonConfig.getColumnName(), '_') + "` , ");
```
  });
  String subStr = sb.toString().substring(0, sb.toString().length() - 2);
  String sql = subStr + "from " + commonConfigs.get(0).getTableName();
  Page<List<Map<String, Object>>> result = baseMapper.getDynamicColumn(pageQuery.build(), sql);
  //处理数据集合中的下拉字段，动态转换，添加Text后缀
  List<List<Map<String, Object>>> lists = DictSelect.setValueListMap(result.getRecords(), filerStrList);
  result.setRecords(lists);
  TableDataInfo<Map<String, Object>> rspData = TableDataInfo.pageOk(titleList, result);
  return rspData;
  }
/**
- 通用查询字段配置(根据ID)
- /
  @Override
  public CommonConfigVO queryById(Long id) {
  return baseMapper.selectVoById(id);
  }
/**
- 通用查询字段配置列表
- /
  @Override
  public TableDataInfo queryPageList(CommonConfigDTO dto, PageQuery pageQuery) {
  LambdaQueryWrapper lqw = buildQueryWrapper(dto);
  Page result = baseMapper.selectVoPage(pageQuery.build(), lqw);
  return TableDataInfo.build(result);
  }
/**
- 查询通用查询字段配置列表
- /
  @Override
  public List queryList(CommonConfigDTO dto) {
  LambdaQueryWrapper lqw = buildQueryWrapper(dto);
  return baseMapper.selectVoList(lqw);
  }
private LambdaQueryWrapper buildQueryWrapper(CommonConfigDTO dto) {
```
  Map<String, Object> params = dto.getParams();
  LambdaQueryWrapper<CommonConfig> lqw = Wrappers.lambdaQuery();
  lqw.eq(dto.getCommonConfigPlanId() != null, CommonConfig::getCommonConfigPlanId, dto.getCommonConfigPlanId());
  lqw.like(StringUtils.isNotBlank(dto.getTableComment()), CommonConfig::getTableComment, dto.getTableComment());
  lqw.like(StringUtils.isNotBlank(dto.getTableName()), CommonConfig::getTableName, dto.getTableName());
  lqw.eq(StringUtils.isNotBlank(dto.getTableAlias()), CommonConfig::getTableAlias, dto.getTableAlias());
  lqw.like(StringUtils.isNotBlank(dto.getColumnName()), CommonConfig::getColumnName, dto.getColumnName());
  lqw.like(StringUtils.isNotBlank(dto.getColumnComment()), CommonConfig::getColumnComment, dto.getColumnComment());
  lqw.eq(StringUtils.isNotBlank(dto.getColumnType()), CommonConfig::getColumnType, dto.getColumnType());
  lqw.eq(StringUtils.isNotBlank(dto.getAdvanceOperatorCode()), CommonConfig::getAdvanceOperatorCode, dto.getNormalOperatorCode());
  lqw.eq(StringUtils.isNotBlank(dto.getNormalOperatorCode()), CommonConfig::getNormalOperatorCode, dto.getNormalOperatorCode());
  lqw.eq(StringUtils.isNotBlank(dto.getInputType()), CommonConfig::getInputType, dto.getInputType());
  lqw.eq(StringUtils.isNotBlank(dto.getDateFrom()), CommonConfig::getDateFrom, dto.getDateFrom());
  lqw.eq(StringUtils.isNotBlank(dto.getSelectSource()), CommonConfig::getSelectSource, dto.getSelectSource());
  lqw.eq(dto.getDispDefault() != null, CommonConfig::getDispDefault, dto.getDispDefault());
  lqw.eq(dto.getQueryDefault() != null, CommonConfig::getQueryDefault, dto.getQueryDefault());
  lqw.eq(StringUtils.isNotBlank(dto.getUserId()), CommonConfig::getUserId, dto.getUserId());
  lqw.eq(StringUtils.isNotBlank(dto.getTenantId()), CommonConfig::getTenantId, dto.getTenantId());
  return lqw;
```
}

/**
- 新增通用查询字段配置
- /
  @Override
  public Boolean insertByDTO(CommonConfigDTO dto) {
  CommonConfig add = BeanUtil.toBean(dto, CommonConfig.class);
  validEntityBeforeSave(add);
  boolean flag = baseMapper.insert(add) > 0;
  if (flag) {
```
  dto.setId(add.getId());
```
  }
  return flag;
  }
/**
- 修改通用查询字段配置
- /
  @Override
  public Boolean updateByDTO(CommonConfigDTO dto) {
  CommonConfig update = BeanUtil.toBean(dto, CommonConfig.class);
  validEntityBeforeSave(update);
  return baseMapper.updateById(update) > 0;
  }
  /**
- 修改通用批量添加字段配置
- /
  @Override
  public Boolean updateByDTOList(List dto) {
  for(CommonConfigDTO commonConfigDTO:dto) {
```
  CommonConfig update = BeanUtil.toBean(commonConfigDTO, CommonConfig.class);
  //validEntityBeforeSave(update);
  if(update.getId()==null){
      baseMapper.insert(update);
  }else {
      baseMapper.updateById(update);
  }
```
  }
  return true;
  }
/**
- 保存前的数据校验
- /
  private void validEntityBeforeSave(CommonConfig entity) {
  //做一些数据校验,如唯一约束
  }
/**
- 批量删除通用查询字段配置
- /
  @Override
  public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) {
  if (isValid) {
```
  //做一些业务上的校验,判断是否需要校验
```
  }
  return baseMapper.deleteBatchIds(ids) > 0;
  }
  }
  package com.igapm.common.core.domain;

/**

自定义Jackson反序列化日期类型时应用的类型转换器,一般用于@RequestBody接受参数时使用
- 次类是借用网上别的人的，增加了一个日期格式化的类型
@author: songyong
@date: 2023-03-29 15:53
/
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.io.IOException;
import java.text.ParseException;
import java.util.Date;

public class DateJacksonConverter extends JsonDeserializer {
//此处尤为重要，请查找自己控制台报错的日期格式化类型是啥样的
//我的是2020-04-29T16:23:44.999Z 所以我在下面的数组中添加了 "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'" 格式；如果下面数组中没有你要的格式化类型，其他的可自行根据自己的情况去添加即可
private static String[] pattern =
new String[]{"yyyy-MM-dd", "yyyy-MM-dd HH:mm", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm:ss.S",
"yyyy.MM.dd", "yyyy.MM.dd HH:mm", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm:ss.S",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm:ss.S", "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"};

@Override
public Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {

    Date targetDate = null;
    String originDate = p.getText();
    if (StringUtils.isNotEmpty(originDate)) {
        try {
            long longDate = Long.valueOf(originDate.trim());
            targetDate = new Date(longDate);
        } catch (NumberFormatException e) {
            try {
                targetDate = DateUtils.parseDate(originDate, DateJacksonConverter.pattern);
            } catch (ParseException pe) {
                throw new IOException(String.format(
                        "'%s' can not convert to type 'java.util.Date',just support timestamp(type of long) and following date format(%s)",
                        originDate,
                        StringUtils.join(pattern, ",")));
            }
        }
    }
    return targetDate;
}




@Override
public Class<?> handledType() {
    return Date.class;
}

// public static void main(String[] args) {
// String ll="2023-03-28 17:35:53";
// Date targetDate=null;
// try {
// targetDate= DateUtils.parseDate(ll, DateJacksonConverter.pattern);
// } catch (ParseException pe){
// System.out.println(pe);
// }
// System.out.println(targetDate);
// }

}

...全文