Java_代码生成_crud代码生成器

前言

对于单个表的增删改查都是很固定的，总是手写没有太多意义，而且浪费时间，研究了一下mybatis-plus的代码生成器，可以直接使用他的代码生成器去生成

代码生成前置条件

依赖

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <dependencies>
    <!-- mybatis-plus-generator -->
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-generator</artifactId>
      <version>3.4.1</version>
    </dependency>
    <!-- 模板引擎, 用于邮件、代码生成等 -->
    <dependency>
      <groupId>com.ibeetl</groupId>
      <artifactId>beetl</artifactId>
      <version>3.6.1.RELEASE</version>
    </dependency>
    <!-- swagger -->
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-boot-starter</artifactId>
      <version>3.0.0</version>
    </dependency>

    <!-- spring-boot-web -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <!-- hutool -->
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-core</artifactId>
      <version>5.7.11</version>
    </dependency>
    <!-- sqlServer -->
    <dependency>
      <groupId>com.microsoft.sqlserver</groupId>
      <artifactId>mssql-jdbc</artifactId>
      <version>8.2.2.jre8</version>
    </dependency>
  </dependencies>

生成代码基础类

• 这中间封装了一些东西，需要引入进来才可以正常进行代码生成
  

web包下:

ApiResult

package com.yf.system.base.web;

import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModelProperty;

import java.io.Serializable;

/**
 * 返回结果
 *
 * @author EleAdmin
 * @since 2017-06-10 10:10:50
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ApiResult<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "状态码")
    private Integer code;

    @ApiModelProperty(value = "状态信息")
    private String message;

    @ApiModelProperty(value = "返回数据")
    private T data;

    @ApiModelProperty(value = "错误信息")
    private String error;

    public ApiResult() {
    }

    public ApiResult(Integer code) {
        this(code, null);
    }

    public ApiResult(Integer code, String message) {
        this(code, message, null);
    }

    public ApiResult(Integer code, String message, T data) {
        this(code, message, data, null);
    }

    public ApiResult(Integer code, String message, T data, String error) {
        setCode(code);
        setMessage(message);
        setData(data);
        setError(error);
    }

    public Integer getCode() {
        return this.code;
    }

    public ApiResult<T> setCode(Integer code) {
        this.code = code;
        return this;
    }

    public String getMessage() {
        return this.message;
    }

    public ApiResult<T> setMessage(String message) {
        this.message = message;
        return this;
    }

    public T getData() {
        return this.data;
    }

    public ApiResult<T> setData(T data) {
        this.data = data;
        return this;
    }

    public String getError() {
        return this.error;
    }

    public ApiResult<T> setError(String error) {
        this.error = error;
        return this;
    }

}

BaseController

package com.yf.system.base.web;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yf.system.base.Constants;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;

import java.util.List;

/**
 * Controller基类
 *
 * @author EleAdmin
 * @since 2017-06-10 10:10:19
 */
public class BaseController {

    /**
     * 获取当前登录的user
     *
     * @return User
     */
//    public User getLoginUser() {
//        try {
//            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
//            if (authentication != null) {
//                Object object = authentication.getPrincipal();
//                if (object instanceof User) {
//                    return (User) object;
//                }
//            }
//        } catch (Exception e) {
//            System.out.println(e.getMessage());
//        }
//        return null;
//    }

//    /**
//     * 获取当前登录的userId
//     *
//     * @return userId
//     */
//    public Integer getLoginUserId() {
//        User loginUser = getLoginUser();
//        return loginUser == null ? null : loginUser.getUserId();
//    }

    /**
     * 返回成功
     *
     * @return ApiResult
     */
    public ApiResult<?> success() {
        return new ApiResult<>(Constants.RESULT_OK_CODE, Constants.RESULT_OK_MSG);
    }

    /**
     * 返回成功
     *
     * @param message 状态信息
     * @return ApiResult
     */
    public ApiResult<?> success(String message) {
        return success().setMessage(message);
    }

    /**
     * 返回成功
     *
     * @param data 返回数据
     * @return ApiResult
     */
    public <T> ApiResult<T> success(T data) {
        return new ApiResult<>(Constants.RESULT_OK_CODE, Constants.RESULT_OK_MSG, data);
    }

    /**
     * 返回成功
     *
     * @param message 状态信息
     * @return ApiResult
     */
    public <T> ApiResult<T> success(String message, T data) {
        return success(data).setMessage(message);
    }

    /**
     * 返回分页查询数据
     *
     * @param list  当前页数据
     * @param count 总数量
     * @return ApiResult
     */
    public <T> ApiResult<PageResult<T>> success(List<T> list, Long count) {
        return success(new PageResult<>(list, count));
    }

    /**
     * 返回分页查询数据
     *
     * @param iPage IPage
     * @return ApiResult
     */
    public <T> ApiResult<PageResult<T>> success(IPage<T> iPage) {
        return success(iPage.getRecords(), iPage.getTotal());
    }

    /**
     * 返回失败
     *
     * @return ApiResult
     */
    public ApiResult<?> fail() {
        return new ApiResult<>(Constants.RESULT_ERROR_CODE, Constants.RESULT_ERROR_MSG);
    }

    /**
     * 返回失败
     *
     * @param message 状态信息
     * @return ApiResult
     */
    public ApiResult<?> fail(String message) {
        return fail().setMessage(message);
    }

    /**
     * 返回失败
     *
     * @param data 返回数据
     * @return ApiResult
     */
    public <T> ApiResult<T> fail(T data) {
        return fail(Constants.RESULT_ERROR_MSG, data);
    }

    /**
     * 返回失败
     *
     * @param message 状态信息
     * @param data    返回数据
     * @return ApiResult
     */
    public <T> ApiResult<T> fail(String message, T data) {
        return new ApiResult<>(Constants.RESULT_ERROR_CODE, message, data);
    }

    /**
     * 请求参数的空字符串转为null
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
    }

}

BaseParam

package com.yf.system.base.web;

import com.baomidou.mybatisplus.annotation.TableField;
import com.yf.system.base.annotation.QueryField;
import com.yf.system.base.annotation.QueryType;
import com.yf.system.base.utils.CommonUtil;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * 查询参数基本字段
 *
 * @author EleAdmin
 * @since 2021-08-26 22:14:43
 */
@Data
public class BaseParam implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableField(exist = false)
    @ApiModelProperty("分页查询页码")
    private Long page;

    @TableField(exist = false)
    @ApiModelProperty("分页查询每页数量")
    private Long limit = Long.MAX_VALUE;

    @TableField(exist = false)
    @ApiModelProperty(value = "排序字段", notes = "排序字段或sql, 如果是sql则order字段无用, 如: `id asc, name desc`")
    private String sort;

    @TableField(exist = false)
    @ApiModelProperty(value = "排序方式", notes = "sort是字段名称时对应的排序方式, asc升序, desc降序")
    private String order;

    @QueryField(value = "create_time", type = QueryType.GE)
    @TableField(exist = false)
    @ApiModelProperty("创建时间起始值")
    private String createTimeStart;

    @QueryField(value = "create_time", type = QueryType.LE)
    @TableField(exist = false)
    @ApiModelProperty("创建时间结束值")
    private String createTimeEnd;

    /**
     * 获取集合中的第一条数据
     *
     * @param records 集合
     * @return 第一条数据
     */
    public <T> T getOne(List<T> records) {
        return CommonUtil.listGetOne(records);
    }

}

BatchParam

package com.yf.system.base.web;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.service.IService;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * 批量修改通用参数
 *
 * @author EleAdmin
 * @since 2020-03-13 00:11:06
 */
@Data
public class BatchParam<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "需要修改的数据id集合")
    private List<Serializable> ids;

    @ApiModelProperty(value = "需要修改的字段和值")
    private T data;

    /**
     * 通用批量修改方法
     *
     * @param service IService
     * @param idField id字段名称
     * @return boolean
     */
    public boolean update(IService<T> service, String idField) {
        if (this.data == null) {
            return false;
        }
        return service.update(this.data, new UpdateWrapper<T>().in(idField, this.ids));
    }

    /**
     * 通用批量修改方法
     *
     * @param service IService
     * @param idField id字段名称
     * @return boolean
     */
    public boolean update(IService<T> service, SFunction<T, ?> idField) {
        if (this.data == null) {
            return false;
        }
        return service.update(this.data, new LambdaUpdateWrapper<T>().in(idField, this.ids));
    }

}

ExistenceParam

package com.yf.system.base.web;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.service.IService;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;

/**
 * 检查是否存在通用参数
 *
 * @author EleAdmin
 * @since 2021-09-07 22:24:39
 */
@Data
public class ExistenceParam<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "检查的字段")
    private String field;

    @ApiModelProperty(value = "字段的值")
    private String value;

    @ApiModelProperty(value = "修改时的主键")
    private String id;

    /**
     * 检查是否存在
     *
     * @param service IService
     * @param idField 修改时的主键字段
     * @return boolean
     */
    public boolean isExistence(IService<T> service, String idField) {
        return isExistence(service, idField, true);
    }

    /**
     * 检查是否存在
     *
     * @param service           IService
     * @param idField           修改时的主键字段
     * @param isToUnderlineCase 是否需要把field转为下划线格式
     * @return boolean
     */
    public boolean isExistence(IService<T> service, String idField, boolean isToUnderlineCase) {
        if (StrUtil.hasBlank(this.field, this.value)) {
            return false;
        }
        String fieldName = isToUnderlineCase ? StrUtil.toUnderlineCase(field) : field;
        QueryWrapper<T> wrapper = new QueryWrapper<>();
        wrapper.eq(fieldName, value);
        if (id != null) {
            wrapper.ne(idField, id);
        }
        return service.count(wrapper) > 0;
    }

    /**
     * 检查是否存在
     *
     * @param service IService
     * @param idField 修改时的主键字段
     * @return boolean
     */
    public boolean isExistence(IService<T> service, SFunction<T, ?> idField) {
        return isExistence(service, idField, true);
    }

    /**
     * 检查是否存在
     *
     * @param service           IService
     * @param idField           修改时的主键字段
     * @param isToUnderlineCase 是否需要把field转为下划线格式
     * @return boolean
     */
    public boolean isExistence(IService<T> service, SFunction<T, ?> idField, boolean isToUnderlineCase) {
        if (StrUtil.hasBlank(this.field, this.value)) {
            return false;
        }
        String fieldName = isToUnderlineCase ? StrUtil.toUnderlineCase(field) : field;
        LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
        wrapper.apply(fieldName + " = {0}", value);
        if (id != null) {
            wrapper.ne(idField, id);
        }
        return service.count(wrapper) > 0;
    }

}

PageParam

package com.yf.system.base.web;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yf.system.base.Constants;
import com.yf.system.base.annotation.QueryField;
import com.yf.system.base.annotation.QueryType;
import com.yf.system.base.utils.CommonUtil;

import java.lang.reflect.Field;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 分页、排序、搜索参数封装
 *
 * @author EleAdmin
 * @since 2019-04-26 10:34:35
 */
public class PageParam<T, U extends BaseParam> extends Page<T> {
    private static final long serialVersionUID = 1L;

    /**
     * 租户id字段名称
     */
    private static final String TENANT_ID_FIELD = "tenantId";

    /**
     * 查询条件
     */
    private final U where;

    /**
     * 是否把字段名称驼峰转下划线
     */
    private final boolean isToUnderlineCase;

    public PageParam() {
        this(null);
    }

    public PageParam(U where) {
        this(where, true);
    }

    public PageParam(U where, boolean isToUnderlineCase) {
        super();
        this.where = where;
        this.isToUnderlineCase = isToUnderlineCase;
        if (where != null) {
            // 获取分页页码
            if (where.getPage() != null) {
                setCurrent(where.getPage());
            }
            // 获取分页每页数量
            if (where.getLimit() != null) {
                setSize(where.getLimit());
            }
            // 获取排序方式
            if (where.getSort() != null) {
                if (sortIsSQL(where.getSort())) {
                    setOrders(parseOrderSQL(where.getSort()));
                } else {
                    List<OrderItem> orderItems = new ArrayList<>();
                    String column = this.isToUnderlineCase ? StrUtil.toUnderlineCase(where.getSort()) : where.getSort();
                    boolean asc = !Constants.ORDER_DESC_VALUE.equals(where.getOrder());
                    orderItems.add(new OrderItem(column, asc));
                    setOrders(orderItems);
                }
            }
        }
    }

    /**
     * 排序字段是否是sql
     */
    private boolean sortIsSQL(String sort) {
        return sort != null && (sort.contains(",") || sort.trim().contains(" "));
    }

    /**
     * 解析排序sql
     */
    private List<OrderItem> parseOrderSQL(String orderSQL) {
        List<OrderItem> orders = new ArrayList<>();
        if (StrUtil.isNotBlank(orderSQL)) {
            for (String item : orderSQL.split(",")) {
                String[] temp = item.trim().split(" ");
                if (!temp[0].isEmpty()) {
                    String column = this.isToUnderlineCase ? StrUtil.toUnderlineCase(temp[0]) : temp[0];
                    boolean asc = temp.length == 1 || !temp[temp.length - 1].equals(Constants.ORDER_DESC_VALUE);
                    orders.add(new OrderItem(column, asc));
                }
            }
        }
        return orders;
    }

    /**
     * 设置默认排序方式
     *
     * @param orderItems 排序方式
     * @return PageParam
     */
    public PageParam<T, U> setDefaultOrder(List<OrderItem> orderItems) {
        if (orders() == null || orders().size() == 0) {
            setOrders(orderItems);
        }
        return this;
    }

    /**
     * 设置默认排序方式
     *
     * @param orderSQL 排序方式
     * @return PageParam
     */
    public PageParam<T, U> setDefaultOrder(String orderSQL) {
        setDefaultOrder(parseOrderSQL(orderSQL));
        return this;
    }

    /**
     * 获取查询条件
     *
     * @param excludes 不包含的字段
     * @return QueryWrapper
     */
    public QueryWrapper<T> getWrapper(String... excludes) {
        return buildWrapper(null, Arrays.asList(excludes));
    }

    /**
     * 获取查询条件
     *
     * @param columns 只包含的字段
     * @return QueryWrapper
     */
    public QueryWrapper<T> getWrapperWith(String... columns) {
        return buildWrapper(Arrays.asList(columns), null);
    }

    /**
     * 构建QueryWrapper
     *
     * @param columns  包含的字段
     * @param excludes 排除的字段
     * @return QueryWrapper
     */
    private QueryWrapper<T> buildWrapper(List<String> columns, List<String> excludes) {
        QueryWrapper<T> queryWrapper = new QueryWrapper<>();
        Map<String, Object> map = BeanUtil.beanToMap(where, false, true);
        for (String fieldName : map.keySet()) {
            Object fieldValue = map.get(fieldName);
            Field field = ReflectUtil.getField(where.getClass(), fieldName);

            // 过滤不包含的字段
            if (columns != null && !columns.contains(fieldName)) {
                continue;
            }

            // 过滤排除的字段
            if (excludes != null && excludes.contains(fieldName)) {
                continue;
            }

            // 过滤逻辑删除字段
            if (field.getAnnotation(TableLogic.class) != null) {
                continue;
            }

            // 过滤租户id字段
            if (fieldName.equals(TENANT_ID_FIELD)) {
                continue;
            }

            // 获取注解指定的查询字段及查询方式
            QueryType queryType = QueryType.LIKE;
            QueryField queryField = field.getAnnotation(QueryField.class);
            if (queryField != null) {
                if (StrUtil.isNotEmpty(queryField.value())) {
                    fieldName = queryField.value();
                }
                if (queryField.type() != null) {
                    queryType = queryField.type();
                }
            } else {
                // 过滤非本表的字段
                TableField tableField = field.getAnnotation(TableField.class);
                if (tableField != null && !tableField.exist()) {
                    continue;
                }
            }

            // 字段名驼峰转下划线
            if (this.isToUnderlineCase) {
                fieldName = StrUtil.toUnderlineCase(fieldName);
            }

            //
            switch (queryType) {
                case EQ:
                    queryWrapper.eq(fieldName, fieldValue);
                    break;
                case NE:
                    queryWrapper.ne(fieldName, fieldValue);
                    break;
                case GT:
                    queryWrapper.gt(fieldName, fieldValue);
                    break;
                case GE:
                    queryWrapper.ge(fieldName, fieldValue);
                    break;
                case LT:
                    queryWrapper.lt(fieldName, fieldValue);
                    break;
                case LE:
                    queryWrapper.le(fieldName, fieldValue);
                    break;
                case LIKE:
                    queryWrapper.like(fieldName, fieldValue);
                    break;
                case NOT_LIKE:
                    queryWrapper.notLike(fieldName, fieldValue);
                    break;
                case LIKE_LEFT:
                    queryWrapper.likeLeft(fieldName, fieldValue);
                    break;
                case LIKE_RIGHT:
                    queryWrapper.likeRight(fieldName, fieldValue);
                    break;
                case IS_NULL:
                    queryWrapper.isNull(fieldName);
                    break;
                case IS_NOT_NULL:
                    queryWrapper.isNotNull(fieldName);
                    break;
                case IN:
                    queryWrapper.in(fieldName, fieldValue);
                    break;
                case NOT_IN:
                    queryWrapper.notIn(fieldName, fieldValue);
                    break;
                case IN_STR:
                    if (fieldValue instanceof String) {
                        queryWrapper.in(fieldName, Arrays.asList(((String) fieldValue).split(",")));
                    }
                    break;
                case NOT_IN_STR:
                    if (fieldValue instanceof String) {
                        queryWrapper.notIn(fieldName, Arrays.asList(((String) fieldValue).split(",")));
                    }
                    break;
            }
        }
        return queryWrapper;
    }

    /**
     * 获取包含排序的查询条件
     *
     * @return 包含排序的QueryWrapper
     */
    public QueryWrapper<T> getOrderWrapper() {
        return getOrderWrapper(getWrapper());
    }

    /**
     * 获取包含排序的查询条件
     *
     * @param queryWrapper 不含排序的QueryWrapper
     * @return 包含排序的QueryWrapper
     */
    public QueryWrapper<T> getOrderWrapper(QueryWrapper<T> queryWrapper) {
        if (queryWrapper == null) {
            queryWrapper = new QueryWrapper<>();
        }
        for (OrderItem orderItem : orders()) {
            if (orderItem.isAsc()) {
                queryWrapper.orderByAsc(orderItem.getColumn());
            } else {
                queryWrapper.orderByDesc(orderItem.getColumn());
            }
        }
        return queryWrapper;
    }

    /**
     * 获取集合中的第一条数据
     *
     * @param records 集合
     * @return 第一条数据
     */
    public T getOne(List<T> records) {
        return CommonUtil.listGetOne(records);
    }

    /**
     * 代码排序集合
     *
     * @param records 集合
     * @return 排序后的集合
     */
    public List<T> sortRecords(List<T> records) {
        List<OrderItem> orderItems = orders();
        if (records == null || records.size() < 2 || orderItems == null || orderItems.size() == 0) {
            return records;
        }
        Comparator<T> comparator = null;
        for (OrderItem item : orderItems) {
            if (item.getColumn() == null) {
                continue;
            }
            String field = this.isToUnderlineCase ? StrUtil.toCamelCase(item.getColumn()) : item.getColumn();
            Function keyExtractor = t -> ReflectUtil.getFieldValue(t, field);
            if (comparator == null) {
                if (item.isAsc()) {
                    comparator = Comparator.comparing(keyExtractor);
                } else {
                    comparator = Comparator.comparing(keyExtractor, Comparator.reverseOrder());
                }
            } else {
                if (item.isAsc()) {
                    comparator.thenComparing(keyExtractor);
                } else {
                    comparator.thenComparing(keyExtractor, Comparator.reverseOrder());
                }
            }
        }
        if (comparator != null) {
            return records.stream().sorted(comparator).collect(Collectors.toList());
        }
        return records;
    }

}

PageResult

package com.yf.system.base.web;

import io.swagger.annotations.ApiModelProperty;

import java.io.Serializable;
import java.util.List;

/**
 * 分页查询返回结果
 *
 * @author EleAdmin
 * @since 2017-06-10 10:10:02
 */
public class PageResult<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "当前页数据")
    private List<T> list;

    @ApiModelProperty(value = "总数量")
    private Long count;

    public PageResult() {
    }

    public PageResult(List<T> list) {
        this(list, null);
    }

    public PageResult(List<T> list, Long count) {
        setList(list);
        setCount(count);
    }

    public List<T> getList() {
        return this.list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public Long getCount() {
        return this.count;
    }

    public void setCount(Long count) {
        this.count = count;
    }

}

annotation包下

QueryField

package com.yf.system.base.annotation;

import java.lang.annotation.*;

/**
 * 查询条件注解
 *
 * @author EleAdmin
 * @since 2021-09-01 20:48:16
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})
public @interface QueryField {

    // 字段名称
    String value() default "";

    // 查询方式
    QueryType type() default QueryType.LIKE;

}

QueryType

package com.yf.system.base.annotation;

/**
 * 查询方式
 *
 * @author EleAdmin
 * @since 2021-09-01 20:48:16
 */
public enum QueryType {
    // 等于
    EQ,
    // 不等于
    NE,
    // 大于
    GT,
    // 大于等于
    GE,
    // 小于
    LT,
    // 小于等于
    LE,
    // 包含
    LIKE,
    // 不包含
    NOT_LIKE,
    // 结尾等于
    LIKE_LEFT,
    // 开头等于
    LIKE_RIGHT,
    // 为NULL
    IS_NULL,
    // 不为空
    IS_NOT_NULL,
    // IN
    IN,
    // NOT IN
    NOT_IN,
    // IN条件解析逗号分割
    IN_STR,
    // NOT IN条件解析逗号分割
    NOT_IN_STR
}

utils包下

CommonUtil

package com.yf.system.base.utils;

import cn.hutool.core.util.ObjectUtil;
import com.yf.system.base.web.ApiResult;
import com.yf.system.base.Constants;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * 常用工具方法
 *
 * @author EleAdmin
 * @since 2017-06-10 10:10:22
 */
public class CommonUtil {
    // 生成uuid的字符
    private static final String[] chars = new String[]{
            "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
            "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
            "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
            "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
    };

    /**
     * 生成8位uuid
     *
     * @return String
     */
    public static String randomUUID8() {
        StringBuilder sb = new StringBuilder();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        for (int i = 0; i < 8; i++) {
            String str = uuid.substring(i * 4, i * 4 + 4);
            int x = Integer.parseInt(str, 16);
            sb.append(chars[x % 0x3E]);
        }
        return sb.toString();
    }

    /**
     * 生成16位uuid
     *
     * @return String
     */
    public static String randomUUID16() {
        StringBuilder sb = new StringBuilder();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        for (int i = 0; i < 16; i++) {
            String str = uuid.substring(i * 2, i * 2 + 2);
            int x = Integer.parseInt(str, 16);
            sb.append(chars[x % 0x3E]);
        }
        return sb.toString();
    }

    /**
     * 检查List是否有重复元素
     *
     * @param list   List
     * @param mapper 获取需要检查的字段的Function
     * @param <T>    数据的类型
     * @param <R>    需要检查的字段的类型
     * @return boolean
     */
    public static <T, R> boolean checkRepeat(List<T> list, Function<? super T, ? extends R> mapper) {
        for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < list.size(); j++) {
                if (i != j && mapper.apply(list.get(i)).equals(mapper.apply(list.get(j)))) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * List转为树形结构
     *
     * @param data           List
     * @param parentId       顶级的parentId
     * @param parentIdMapper 获取parentId的Function
     * @param idMapper       获取id的Function
     * @param consumer       赋值children的Consumer
     * @param <T>            数据的类型
     * @param <R>            parentId的类型
     * @return List<T>
     */
    public static <T, R> List<T> toTreeData(List<T> data, R parentId,
                                            Function<? super T, ? extends R> parentIdMapper,
                                            Function<? super T, ? extends R> idMapper,
                                            BiConsumer<T, List<T>> consumer) {
        List<T> result = new ArrayList<>();
        for (T d : data) {
            R dParentId = parentIdMapper.apply(d);
            if (ObjectUtil.equals(parentId, dParentId)) {
                R dId = idMapper.apply(d);
                List<T> children = toTreeData(data, dId, parentIdMapper, idMapper, consumer);
                consumer.accept(d, children);
                result.add(d);
            }
        }
        return result;
    }

    /**
     * 遍历树形结构数据
     *
     * @param data     List
     * @param consumer 回调
     * @param mapper   获取children的Function
     * @param <T>      数据的类型
     */
    public static <T> void eachTreeData(List<T> data, Consumer<T> consumer, Function<T, List<T>> mapper) {
        for (T d : data) {
            consumer.accept(d);
            List<T> children = mapper.apply(d);
            if (children != null && children.size() > 0) {
                eachTreeData(children, consumer, mapper);
            }
        }
    }

    /**
     * 获取集合中的第一条数据
     *
     * @param records 集合
     * @return 第一条数据
     */
    public static <T> T listGetOne(List<T> records) {
        return records == null || records.size() == 0 ? null : records.get(0);
    }

    /**
     * 支持跨域
     *
     * @param response HttpServletResponse
     */
    public static void addCrossHeaders(HttpServletResponse response) {
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "*");
        response.setHeader("Access-Control-Allow-Headers", "*");
        response.setHeader("Access-Control-Expose-Headers", Constants.TOKEN_HEADER_NAME);
    }

    /**
     * 输出错误信息
     *
     * @param response HttpServletResponse
     * @param code     错误码
     * @param message  提示信息
     * @param error    错误信息
     */
    public static void responseError(HttpServletResponse response, Integer code, String message, String error) {
        response.setContentType("application/json;charset=UTF-8");
        try {
            PrintWriter out = response.getWriter();
            out.write(JSONUtil.toJSONString(new ApiResult<>(code, message, null, error)));
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 当天日期开始
     *
     * @return
     */
    public static Date beginOfDate() {

        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(calendar1.get(Calendar.YEAR), calendar1.get(Calendar.MONTH), calendar1.get(Calendar.DAY_OF_MONTH),
                0, 0, 0);
        Date beginOfDate = calendar1.getTime();
        return beginOfDate;
    }

    /**
     * 当天日期结束
     *
     * @return
     */
    public static Date endOfDate() {

        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(calendar2.get(Calendar.YEAR), calendar2.get(Calendar.MONTH), calendar2.get(Calendar.DAY_OF_MONTH),
                23, 59, 59);
        Date endOfDate = calendar2.getTime();
        return endOfDate;
    }

}

JSONUtil

package com.yf.system.base.utils;

import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;

import java.util.HashMap;
import java.util.Map;

/**
 * JSON解析工具类
 *
 * @author EleAdmin
 * @since 2017-06-10 10:10:39
 */
public class JSONUtil {
    private static final ObjectMapper objectMapper = new ObjectMapper();
    private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();

    /**
     * 对象转json字符串
     *
     * @param value 对象
     * @return String
     */
    public static String toJSONString(Object value) {
        return toJSONString(value, false);
    }

    /**
     * 对象转json字符串
     *
     * @param value  对象
     * @param pretty 是否格式化输出
     * @return String
     */
    public static String toJSONString(Object value, boolean pretty) {
        if (value != null) {
            if (value instanceof String) {
                return (String) value;
            }
            try {
                if (pretty) {
                    return objectWriter.writeValueAsString(value);
                }
                return objectMapper.writeValueAsString(value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * json字符串转对象
     *
     * @param json  String
     * @param clazz Class
     * @return T
     */
    public static <T> T parseObject(String json, Class<T> clazz) {
        if (StrUtil.isNotBlank(json) && clazz != null) {
            try {
                return objectMapper.readValue(json, clazz);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * json字符串转Map
     *
     * @param json  String
     * @return Map
     */
    public static Map<String, String> parseObject(String json) {
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, String> map = new HashMap<>();
        try {
            // 将JSON字符串转换为Map
            map = objectMapper.readValue(json, new TypeReference<Map<String, String>>() {});

            // 遍历Map并输出键值对
            for (String key : map.keySet()) {
                System.out.println(key + ": " + map.get(key));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

}

代码生成包

代码生成包的地址：代码生成器