SpringBoot 后端接收参数优化（统一处理前端参数）

在使用 SpringBoot+ MyBatisPlus 框架的项目，写了个后端统一处理前端post提交的json格式的查询参数类，赖得手工一个一个参数处理（把要查询的参数交给前端）。

使用示例代码：

    @PostMapping("/list")
    public String list1(@RequestBody PageParam pageParam) {
        IPage<ChargeRule> page = new Page<>(pageParam.getCurrent(), pageParam.getSize());
        QueryWrapper<ChargeRule> queryWrapper = pageParam.getQueryWrap(ChargeRule.class);
        return RespUtil.respSucc( chargeRuleService.page(page, queryWrapper));
    }

统一处理前端参数，代码如下：

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author zhenhua
 * @Description 针对前端的分页与查询参数封装
 * @date 2024/06/24
 */
public class PageParam {

    /**
     * 第几页码
     */
    Long current;

    /**
     * 每页条数
     */
    Long size;

    /**
     * 查询条件内容
     */
    JSONObject query;

    /**
     * 排序字段
     */
    String order;

    public Long getCurrent() {
        return current;
    }

    public void setCurrent(Long current) {
        this.current = current;
    }

    public Long getSize() {
        return size;
    }

    public void setSize(Long size) {
        this.size = size;
    }

    public JSONObject getQuery() {
        return query;
    }

    public void setQuery(JSONObject query) {
        this.query = query;
    }

    public String getOrder() {
        return order;
    }

    public void setOrder(String order) {
        this.order = order;
    }


    /**
     * 查询条件 限定生成在clazz 类中的字段
     * @return
     */
    public QueryWrapper getQueryWrap(Class clazz) {
        QueryWrapper qw = new QueryWrapper();

        if (this.query != null) {
            Set<String> fieldNames = new HashSet<>();
            if(clazz!=null){
                for (Field field : clazz.getDeclaredFields()) {
                    fieldNames.add(field.getName());
                }
            }

            for (Map.Entry<?, ?> entry : query.entrySet()) {
                Object key = entry.getKey();
                Object valueObj = entry.getValue();
                if (valueObj != null) {
                    String value = valueObj.toString().trim();
                    if (StringUtils.isNotEmpty(value)) {
                        if (key != null) {
                            String keyStr = (String) key;
                            // 检查 clazz 类中是否有该字段
                            if (fieldNames.contains(keyStr)) {
                                String fieldName = camelToSnakeCase(keyStr);
                                if (fieldName.contains("time") || fieldName.contains("date")) {
                                    // 时间相关的外层处理
                                } else if (keyStr.contains("type") && valueObj instanceof Integer) {
                                    qw.eq(fieldName, value);
                                } else {
                                    qw.like(fieldName, value);
                                }
                            }
                        }
                    }
                }
            }
        }

        return qw;
    }


    /**
     * 查询条件 前端所有字段都会封装，如果后端不需要该字段，会报错
     * @return
     */
    @Deprecated
    public QueryWrapper getQueryWrap() {
        return getQueryWrap(null);
    }

    /**
     * 把驼峰命名转换为下划线命名
     * @param camelCaseStr
     * @return
     */
    public static String camelToSnakeCase(String camelCaseStr) {
        return camelCaseStr.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
    }

    /**
     * 获取前端参数
     * @param key
     * @return
     */
    public <T>T getParam(String key){
        if(this.query==null){
            return null;
        }
        return (T) this.query.get(key);
    }

    /**
     * 获取对象
     * @param
     * @return
     */
    public <T>T getJavaBean(Class<T> clazz) {
        if(this.query==null){
            return null;
        }
        return JSONObject.parseObject(JSONObject.toJSONString(this.query),clazz);
    }
}

注意，springboot要配置可以接收任意参数。