在运用了Mybatis Plus框架进行项目重构之后,关于如何更好的利用Mybatis plus。在此做一些总结供大家参考。
主要总结了以下这几个方面的实践。

  • 根底规划
    • BaseEntity
    • 逻辑删去
    • 主动填充字段
  • 代码生成类
  • 查询操作
    • Query基类(复用+PageQuery)
    • 普通Query
    • Lambda Query
    • 杂乱多表查询
    • 报表型查询
  • 保存操作
    • 模型利用JPA保存
    • 批量保存数据
    • 按条件更新数据
  • 扩展
    • 阻挠全表操作
    • 动态数据源
    • 多租户

具体代码完成在开源项目Agileboot中:github.com/valarchie/A…
关于Mybatis Plus的实践,如有不足或许主张欢迎大家谈论纠正。
废话不多说进入正题。

根底规划

BaseEntity

关于数据库中表中的公共字段咱们能够抽取出来做成基类承继。防止表映射的数据库实体类字段过分繁杂。
例如常用的创立时刻、创立者、更新时刻、更新者、逻辑删去字段。

/**
 * Entity基类
 *
 * @author valarchie
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class BaseEntity<T extends Model<?>> extends Model<T> {
    @ApiModelProperty("创立者ID")
    @TableField(value = "creator_id", fill = FieldFill.INSERT)
    private Long creatorId;
    @ApiModelProperty("创立时刻")
    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Date createTime;
    @ApiModelProperty("更新者ID")
    @TableField(value = "updater_id", fill = FieldFill.UPDATE, updateStrategy = FieldStrategy.NOT_NULL)
    private Long updaterId;
    @ApiModelProperty("更新时刻")
    @TableField(value = "update_time", fill = FieldFill.UPDATE)
    private Date updateTime;
    /**
     * deleted字段请在数据库中 设置为tinyInt   而且非null   默许值为0
     */
    @ApiModelProperty("删去标志(0代表存在 1代表删去)")
    @TableField("deleted")
    @TableLogic
    private Boolean deleted;
}

通过承继了基类,实体类看起来就简洁了许多。

/**
 * <p>
 * 告诉公告表
 * </p>
 *
 * @author valarchie
 * @since 2022-10-02
 */
@Getter
@Setter
@TableName("sys_notice")
@ApiModel(value = "SysNoticeEntity目标", description = "告诉公告表")
public class SysNoticeEntity extends BaseEntity<SysNoticeEntity> {
    private static final long serialVersionUID = 1L;
    @ApiModelProperty("公告ID")
    @TableId(value = "notice_id", type = IdType.AUTO)
    private Integer noticeId;
    @ApiModelProperty("公告标题")
    @TableField("notice_title")
    private String noticeTitle;
    @ApiModelProperty("公告类型(1告诉 2公告)")
    @TableField("notice_type")
    private Integer noticeType;
    @ApiModelProperty("公告内容")
    @TableField("notice_content")
    private String noticeContent;
    @ApiModelProperty("公告状况(1正常 0关闭)")
    @TableField("`status`")
    private Integer status;
    @ApiModelProperty("补白")
    @TableField("remark")
    private String remark;
    @Override
    public Serializable pkVal() {
        return this.noticeId;
    }
}

既然抽取出了公共字段,咱们能够更进一步将这些公共字段进行主动填值处理。
Mybatis Plus供给了字段主动填充的插件。

主动填充字段

/**
 * Mybatis Plus允许在插入或许更新的时分
 * 自定义设定值
 * @author valarchie
 */
@Component
@Slf4j
public class CustomMetaObjectHandler implements MetaObjectHandler {
    public static final String CREATE_TIME_FIELD = "createTime";
    public static final String CREATOR_ID_FIELD = "creatorId";
    public static final String UPDATE_TIME_FIELD = "updateTime";
    public static final String UPDATER_ID_FIELD = "updaterId";
    @Override
    public void insertFill(MetaObject metaObject) {
        if (metaObject.hasSetter(CREATE_TIME_FIELD)) {
            this.setFieldValByName(CREATE_TIME_FIELD, new Date(), metaObject);
        }
        if (metaObject.hasSetter(CREATOR_ID_FIELD)) {
            this.strictInsertFill(metaObject, CREATOR_ID_FIELD, Long.class, getUserIdSafely());
        }
    }
    @Override
    public void updateFill(MetaObject metaObject) {
        if (metaObject.hasSetter(UPDATE_TIME_FIELD)) {
            this.setFieldValByName(UPDATE_TIME_FIELD, new Date(), metaObject);
        }
        if (metaObject.hasSetter(UPDATER_ID_FIELD)) {
            this.strictUpdateFill(metaObject, UPDATER_ID_FIELD, Long.class, getUserIdSafely());
        }
    }
    public Long getUserIdSafely() {
        Long userId = null;
        try {
            LoginUser loginUser = AuthenticationUtils.getLoginUser();
            userId = loginUser.getUserId();
        } catch (Exception e) {
            log.info("can not find user in current thread.");
        }
        return userId;
    }
}

运用自定义填充值时,需求在生成实体的时分加上装备。FieldFill.INSERTFieldFill.INSERT_UPDATE

private void entityConfig(StrategyConfig.Builder builder) {
    Entity.Builder entityBuilder = builder.entityBuilder();
    entityBuilder
        .enableLombok()
        .addTableFills(new Column("create_time", FieldFill.INSERT))
        .addTableFills(new Column("creator_id", FieldFill.INSERT))
        .addTableFills(new Property("updateTime", FieldFill.INSERT_UPDATE))
        .addTableFills(new Property("updaterId", FieldFill.INSERT_UPDATE))
        // ID strategy AUTO, NONE, INPUT, ASSIGN_ID, ASSIGN_UUID;
        .idType(IdType.AUTO)
        .formatFileName("%sEntity");
    if (isExtendsFromBaseEntity) {
        entityBuilder
            .superClass(BaseEntity.class)
            .addSuperEntityColumns("creator_id", "create_time", "creator_name", "updater_id", "update_time",
                "updater_name", "deleted");
    }
    entityBuilder.build();
}

逻辑删去

数据库一般不进行实在删去操作。但是假如让咱们手工处理这些逻辑删去的话,也对错常麻烦。Mybatis Plus有供给这样的插件。仅需求在EntityConfig中设置逻辑删去的字段是哪个即可。


entityBuilder
    // deleted的字段设置成tinyint  长度为1
    .logicDeleteColumnName("deleted")
    .formatFileName("%sEntity");

代码生成类

Mybatis plus支撑生成entity,mapper,service,controller这四层类。 但是笔者以为生成类的时分还是不要直接掩盖本来的类比较好。
我将生成的类,固定放在一个目录让运用者自己copy类到指定的目录。
以下是我自己封装的CodeGenerator的代码片段。
需求填入的字段主要是:

  • 作者名
  • 包名
  • 表名
  • 是否需求承继基类(由于不是一切表都需求承继基类)
public static void main(String[] args) {
    // 默许读取application-dev yml中的master数据库装备
    JSON ymlJson = JSONUtil.parse(new Yaml().load(ResourceUtil.getStream("application-dev.yml")));
    CodeGenerator generator = CodeGenerator.builder()
        .databaseUrl(JSONUtil.getByPath(ymlJson, URL_PATH).toString())
        .username(JSONUtil.getByPath(ymlJson, USERNAME_PATH).toString())
        .password(JSONUtil.getByPath(ymlJson, PASSWORD_PATH).toString())
        .author("valarchie")
        //生成的类 放在orm子模块下的/target/generated-code目录底下
        .module("/agileboot-orm/target/generated-code")
        .parentPackage("com.agileboot")
        .tableName("sys_config")
        // 决议是否承继基类
        .isExtendsFromBaseEntity(true)
        .build();
    generator.generateCode();
}

查询操作

Query基类

体系内的查询大部分有共用的逻辑。比方时刻范围的查询、排序。咱们能够抽取这部分逻辑放在基类。 然后把具体查询条件的结构,放到子类去完成。

AbstractQuery

/**
 * @author valarchie
 */
@Data
public abstract class AbstractQuery<T> {
    protected String orderByColumn;
    protected String isAsc;
    @JsonFormat(shape = Shape.STRING, pattern = "yyyy-MM-dd")
    private Date beginTime;
    @JsonFormat(shape = Shape.STRING, pattern = "yyyy-MM-dd")
    private Date endTime;
    private static final String ASC = "ascending";
    private static final String DESC = "descending";
    /**
     * 生成query conditions
     * @return
     */
    public abstract QueryWrapper<T> toQueryWrapper();
    public void addSortCondition(QueryWrapper<T> queryWrapper) {
        if(queryWrapper != null) {
            boolean sortDirection = convertSortDirection();
            queryWrapper.orderBy(StrUtil.isNotBlank(orderByColumn), sortDirection,
                StrUtil.toUnderlineCase(orderByColumn));
        }
    }
    public void addTimeCondition(QueryWrapper<T> queryWrapper, String fieldName) {
        if (queryWrapper != null) {
            queryWrapper
                .ge(beginTime != null, fieldName, DatePickUtil.getBeginOfTheDay(beginTime))
                .le(endTime != null, fieldName, DatePickUtil.getEndOfTheDay(endTime));
        }
    }
    public boolean convertSortDirection() {
        boolean orderDirection = true;
        if (StrUtil.isNotEmpty(isAsc)) {
            if (ASC.equals(isAsc)) {
                orderDirection = true;
            } else if (DESC.equals(isAsc)) {
                orderDirection = false;
            }
        }
        return orderDirection;
    }
}

PageQuery

分页对错常常见的查询条件,咱们能够基于AbstractQuery再做一层封装。

/**
 * @author valarchie
 */
@Data
public abstract class AbstractPageQuery<T> extends AbstractQuery<T> {
    public static final int MAX_PAGE_NUM = 200;
    public static final int MAX_PAGE_SIZE = 500;
    @Max(MAX_PAGE_NUM)
    protected Integer pageNum = 1;
    @Max(MAX_PAGE_SIZE)
    protected Integer pageSize = 10;
    public Page<T> toPage() {
        return new Page<>(pageNum, pageSize);
    }
}

普通Query

比方咱们有个菜单查询列表,咱们能够新建一个MenuQuery承继AbstractQuery。然后完成 toQueryWrapper办法去结构查询条件。

/**
 * @author valarchie
 */
@Data
public class MenuQuery extends AbstractQuery<SysMenuEntity> {
    private String menuName;
    private Boolean isVisible;
    private Integer status;
    @Override
    public QueryWrapper<SysMenuEntity> toQueryWrapper() {
        QueryWrapper<SysMenuEntity> queryWrapper = new QueryWrapper<SysMenuEntity>()
            .like(StrUtil.isNotEmpty(menuName), "menu_name", menuName)
            .eq(isVisible != null, "is_visible", isVisible)
            .eq(status != null, "status", status);
        queryWrapper.orderBy(true, true, Arrays.asList("parent_id", "order_num"));
        return queryWrapper;
    }
}

假如有别的一个不同的菜单查询列表,查询的参数一样,但是查询条件的结构不一样。咱们能够新建一个DifferentMenuQuery类承继MenuQuery类,再覆写toQueryWrapper办法即可。

Lambda Query

假如在项目中的查询明确是单表操作的话,咱们能够运用LambdaQuery来结构查询。

LambdaQueryWrapper<SysMenuEntity> menuQuery = Wrappers.lambdaQuery();
menuQuery.select(SysMenuEntity::getMenuId);
List<SysMenuEntity> menuList = menuService.list(menuQuery);

杂乱多表查询

Mybatis Plus支撑@Select注解,遇到简略的多表join查询的话,咱们能够直接在代码中写SQL句子。

以下是Mapper中的完成。${ew.customSqlSegment} 会渲染出QueryWrapper类生成的查询条件。

/**
 * 依据条件分页查询用户列表
 * @param page 页码目标
 * @param queryWrapper 查询目标
 * @return 用户信息集合信息
 */
@Select("SELECT u.*, d.dept_name, d.leader_name "
    + "FROM sys_user u "
    + " LEFT JOIN sys_dept d ON u.dept_id = d.dept_id "
    + "${ew.customSqlSegment}")
Page<SearchUserDO> getUserList(Page<SearchUserDO> page,
    @Param(Constants.WRAPPER) Wrapper<SearchUserDO> queryWrapper);

Service层中的完成。

@Override
public Page<SearchUserDO> getUserList(AbstractPageQuery<SearchUserDO> query) {
    return baseMapper.getUserList(query.toPage(), query.toQueryWrapper());
}

报表型查询

假如遇到杂乱的报表型查询,利用@Select注解的话,或许SQL看起来还对错常的杂乱。此刻推荐运用XML的形式。

Mybatis Plus 框架项目落地实践总结

保存操作

模型利用JPA保存

Mybatis Plus支撑activeRecord特性,咱们能够直接在Entity上履行save\update\delete等操作。框架会主动帮咱们落库。 activeRecord需求在EntityConfig装备。

        entityBuilder
            // operate entity like JPA.
            .enableActiveRecord()
            // deleted的字段设置成tinyint  长度为1
            // ID strategy AUTO, NONE, INPUT, ASSIGN_ID, ASSIGN_UUID;
            .idType(IdType.AUTO)
            .formatFileName("%sEntity");

由于Entity都是生成的,咱们不方便将事务逻辑直接放在Entity中。这样会和数据库实体过于耦合。
推荐新建一个模型类承继XxxxEntity,然后将逻辑填充在模型类中。

public class DeptModel extends SysDeptEntity {
    private ISysDeptService deptService;
    public DeptModel(ISysDeptService deptService) {
        this.deptService = deptService;
    }
    public DeptModel(SysDeptEntity entity, ISysDeptService deptService) {
        if (entity != null) {
            // 假如大数据量的话  能够用MapStruct优化
            BeanUtil.copyProperties(entity, this);
        }
        this.deptService = deptService;
    }
    public void loadAddCommand(AddDeptCommand addCommand) {
        this.setParentId(addCommand.getParentId());
        this.setAncestors(addCommand.getAncestors());
        this.setDeptName(addCommand.getDeptName());
        this.setOrderNum(addCommand.getOrderNum());
        this.setLeaderName(addCommand.getLeaderName());
        this.setPhone(addCommand.getPhone());
        this.setEmail(addCommand.getEmail());
    }
    public void checkDeptNameUnique() {
        if (deptService.isDeptNameDuplicated(getDeptName(), getDeptId(), getParentId())) {
            throw new ApiException(ErrorCode.Business.DEPT_NAME_IS_NOT_UNIQUE, getDeptName());
        }
    }
    public void generateAncestors() {
        if (getParentId() == 0) {
            setAncestors(getParentId().toString());
            return;
        }
        SysDeptEntity parentDept = deptService.getById(getParentId());
        if (parentDept == null || StatusEnum.DISABLE.equals(
            BasicEnumUtil.fromValue(StatusEnum.class, parentDept.getStatus()))) {
            throw new ApiException(ErrorCode.Business.DEPT_PARENT_DEPT_NO_EXIST_OR_DISABLED);
        }
        setAncestors(parentDept.getAncestors() + "," + getParentId());
    }
}

在应用层咱们就能够直接调用模型类来完成逻辑操作。整个代码的语义性十分强。

public void addDept(AddDeptCommand addCommand) {
    DeptModel deptModel = deptModelFactory.create();
    deptModel.loadAddCommand(addCommand);
    deptModel.checkDeptNameUnique();
    deptModel.generateAncestors();
    deptModel.insert();
}

批量保存数据

以上是单条数据的落库操作,那么多条数据循环去insert的话,显然不是一个明智之举。
Mybatis Plus供给了批量落库操作。

private boolean saveMenus() {
    List<SysRoleMenuEntity> list = new ArrayList<>();
    if (getMenuIds() != null) {
        for (Long menuId : getMenuIds()) {
            SysRoleMenuEntity rm = new SysRoleMenuEntity();
            rm.setRoleId(getRoleId());
            rm.setMenuId(menuId);
            list.add(rm);
        }
        return roleMenuService.saveBatch(list);
    }
    return false;
}

按条件更新数据

JPA的方法有一个弊端便是需求先拿到数据实体类,才能调用save等操作。
还有一种情况,咱们需求依照某些条件去更新数据,而不想先一条条获取数据再Save。
此刻能够运用LambdaUpdate类。

LambdaUpdateWrapper<SysUserEntity> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.set(SysUserEntity::getRoleId, null).eq(SysUserEntity::getUserId, userId);
userService.update(updateWrapper);

扩展

阻挠全表操作

Mybatis Plus供给了安全方面的插件,比方阻挠全标更新删去的插件。仅需求声明MybatisPlusInterceptor Bean,依次添加阻拦插件即可。

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
    return interceptor;
}

动态数据源

Mybatis Plus供给@DS注解去动态选择从库还是主库来履行SQL.

@DS("slave")
@PreAuthorize("@permission.has('system:notice:list')")
@GetMapping("/listFromSlave")
public ResponseDTO<PageDTO<NoticeDTO>> listFromSlave(NoticeQuery query) {
    PageDTO<NoticeDTO> pageDTO = noticeApplicationService.getNoticeList(query);
    return ResponseDTO.ok(pageDTO);
}

比方打上了@DS(“slave”)的接口,就会去找slave这个从库进行操作。

多租户

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {
            @Override
            public Expression getTenantId() {
                // 获取租户ID 实践应该从用户信息中获取
                return new LongValue(1);
            }
            // 这是 default 办法,默许回来 false 表明一切表都需求拼多租户条件
            @Override
            public boolean ignoreTable(String tableName) {
                return !"sys_user".equalsIgnoreCase(tableName);
            }
        }));
        // 假如用了分页插件注意先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor
        // 用了分页插件必须设置 MybatisConfiguration#useDeprecatedExecutor = false
//        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
欢迎加入全栈技术交流群:1398880