代码生成子表高级查询

在代码生成后，子表的高级查询需要我们写代码自行处理，详情请参考此章节

效果展示

后台代码

步骤一：在对应的请求接口中，代码生成的接口为/list的请求路径

/**
 * 分页列表查询
 *
 * @param wsMian
 * @param pageNo
 * @param pageSize
 * @param req
 * @return
 */
@GetMapping(value = "/list")
public Result<IPage<WsMian>> queryPageList(WsMian wsMian,
                                           @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                           @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                           HttpServletRequest req) {
       //高级查询参数
       String superQueryParams = req.getParameter("superQueryParams");
       //类型 and 并且 or 或者 根据不同的类型拼接不同的sql
       String superQueryMatchType = req.getParameter("superQueryMatchType");
       //子表对应的主表外键id集合，根据自己的逻辑动态处理
       List<String> mainIds = new ArrayList<>();
       //最新组合的查询条件集合，将子表的查询条件删除
       List<QueryCondition> newConditions = new ArrayList<>();
       //自定义请求类，详情参考步骤二的代码
       CustomRequest customRequest = new CustomRequest(req);
       if(StringUtils.isNotEmpty(superQueryParams)){
           try {
               superQueryParams = URLDecoder.decode(superQueryParams, "UTF-8");
               //获取参数
               List<QueryCondition> conditions = JSON.parseArray(superQueryParams, QueryCondition.class);
               //子表查询条件封装,如本示例ws_main_sub,如有多个子表写多个查询条件
               QueryWrapper<WsMainSub> wsMainSubQuery = new QueryWrapper<>();
               //循环查询参数
               for(QueryCondition condition : conditions){
                   //判断当前的查询构造器的字段是否包含逗号，包含代表为子表的查询条件
                   if(condition.getField().contains(",")){
                       String[] split = condition.getField().split(",");
                       // TODO 多个子表可以根据实体类名称做判断
                       String entityName = split[0];
                       //对应的实体类属性
                       String entityFieldName = split[1];
                       //值
                       Object queryValue = condition.getVal();
                       //数据类型
                       String type = condition.getType();
                       //根据不同的类型获取不同的值
                       if("date".equals(type)){
                           queryValue = DateUtils.str2Date(condition.getVal(),DateUtils.date_sdf.get());
                       }else if("datetime".equals(type)){
                           queryValue = DateUtils.str2Date(condition.getVal(), DateUtils.datetimeFormat.get());
                       }
                       String dbType = condition.getDbType();
                       if (oConvertUtils.isNotEmpty(dbType)) {
                           try {
                               String valueStr = String.valueOf(queryValue);
                               switch (dbType.toLowerCase().trim()) {
                                   case "int":
                                       queryValue = Integer.parseInt(valueStr);
                                       break;
                                   case "bigdecimal":
                                       queryValue = new BigDecimal(valueStr);
                                       break;
                                   case "short":
                                       queryValue = Short.parseShort(valueStr);
                                       break;
                                   case "long":
                                       queryValue = Long.parseLong(valueStr);
                                       break;
                                   case "float":
                                       queryValue = Float.parseFloat(valueStr);
                                       break;
                                   case "double":
                                       queryValue = Double.parseDouble(valueStr);
                                       break;
                                   case "boolean":
                                       queryValue = Boolean.parseBoolean(valueStr);
                                       break;
                                   default:
                               }
                              /*拼接查询规则,注意entityFieldName为数据库的字段名称，如果数据库的名称和实体类的属性不匹配，需要自行转换；
                                如实体类为orderNo，而数据库为order_no，则此处传的是order_no*/
                               QueryGenerator.addEasyQuery(wsMainSubQuery, entityFieldName, QueryRuleEnum.getByValue(condition.getRule()), queryValue);
                           } catch (Exception e) {
                               log.error("高级查询值转换失败：", e);
                           }
                       }
                   }else{
                       newConditions.add(condition);
                   }
               }
               List<WsMainSub> list = wsMainSubService.list(wsMainSubQuery);
               mainIds = list.stream().map(WsMainSub::getWsMianId).collect(Collectors.toList());
           } catch (UnsupportedEncodingException e) {
               throw new RuntimeException(e);
           }
       }
       try {
           if (!newConditions.isEmpty()) {
               CustomRequest.SUPER_QUERY_PARAMS = URLEncoder.encode(JSON.toJSONString(newConditions),"UTF-8");
           }
       } catch (UnsupportedEncodingException e) {
           throw new RuntimeException(e);
       }
       QueryWrapper<WsMian> queryWrapper = QueryGenerator.initQueryWrapper(wsMian, customRequest.getParameterMap());
       Page<WsMian> page = new Page<WsMian>(pageNo, pageSize);
       //拼接子表查询条件，子表为空代表没有查询到数据 直接返回空数据即可
       if (!mainIds.isEmpty()) {
           if(StringUtils.isNotEmpty(superQueryMatchType) || "and".equals(superQueryMatchType)){
               queryWrapper.in("id", mainIds);
           }else{
               queryWrapper.or().in("id", mainIds);
           }
           IPage<WsMian> pageList = wsMianService.page(page, queryWrapper);
           return Result.OK(pageList);
       }else{
           return Result.OK(new Page<WsMian>());
       }
     
}

步骤二：自定义CustomRequest请求类

public class CustomRequest extends HttpServletRequestWrapper {
    
    public static String SUPER_QUERY_PARAMS = "";
    
    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request The request to wrap
     * @throws IllegalArgumentException if the request is null
     */
    public CustomRequest(HttpServletRequest request) {
        super(request);
    }
    
    @Override
    public Map<String,String[]> getParameterMap() {
        Map<String, String[]> modifiableMap = new HashMap<>();
        modifiableMap.putAll(super.getParameterMap());
        modifiableMap.put("superQueryParams", new String[]{SUPER_QUERY_PARAMS});
        return modifiableMap;
    }
}