springboot整合mybatisplus

application.yml

这里以TDengine时序数据库为例

spring:
  datasource:
    driver-class-name: com.taosdata.jdbc.TSDBDriver
#    driver-class-name: com.taosdata.jdbc.rs.RestfulDriver
#    url: jdbc:TAOS-RS://um.tdengine.com:6041/test?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
    url: jdbc:TAOS://um.tdengine.com:6030/test?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
    username: root
    password: taosdata

    hikari:
      pool-name: HikariPool
      # 最小空闲链接数
      minimum-idle: 32
      # 空闲连接存活最大时间 默认 600000（10分钟）
      idle-timeout: 0
      # 连接池最大连接数，默认 10
      maximum-pool-size: 128
      # 如果池无法成功初始化连接，则此属性控制池是否将fail fast
      initialization-fail-timeout: -1
      # 数据库连接超时时间，默认30s
      connection-timeout: 60000
      # 此属性控制池中连接的最大生命周期，值0表示无限生命周期，默认1800000即30分钟
      max-lifetime: 0
      # 连接检查 。 mysql 使用的 为 select 1  tdengine 特有语句 select server_status()
      connection-test-query: select server_status()

mybatis-plus:
  configuration:
    # 控制台打印sql
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 数据库下划线字段 与 实体中的驼峰属性映射（false，手动设置映射，推荐用 resultMap）
    # mybatis的驼峰法映射并不是严格限制的驼峰法语法，具体来说，对应“aa_bb”字段，其既可以匹配上“aaBb”属性，也可以匹配上“Aabb”属性。这一点在日常写代码时需要注意下。
    map-underscore-to-camel-case: false
  # mapper.xml所在目录
  mapper-locations: classpath:/mapper/**/*.xml

logging:
  level:
    com.taosdata.example.mybatisplusdemo.mapper: debug

maven依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <!--3.1.2 -->
    <version>3.5.1</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

配置分页插件

MybatisPlusInterceptor

package com.yomahub.liteflow.example.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加自动分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        // 自定义配置
        return configuration -> {

        };
    }
}

配置字段自动填充

针对 createTime、updateTime、createBy、updateBy

这里指定时间为 13位时间戳 Long类型， 时区 +8

package com.yomahub.liteflow.example.config;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.ZoneOffset;

/**
 * @description 配置 字段自动填充，针对 createTime、updateTime
 * @author peizhao.ma
 * @date 2022-07-13
 */
@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.strictInsertFill(metaObject, "createTime", () -> LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli(), Long.class); // 起始版本 3.3.3(推荐)
//        // 或者
//        this.strictInsertFill(metaObject, "createTime", Long.class, LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli()); // 起始版本 3.3.0(推荐使用)

//        // 或者
//        this.fillStrategy(metaObject, "createTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug)
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.strictUpdateFill(metaObject, "updateTime", () -> LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli(), Long.class); // 起始版本 3.3.3(推荐)

        // 或者
//        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)

        // 或者
//        this.fillStrategy(metaObject, "updateTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug)
    }
}

自动填充注解

标注什么时候自动填充。 如 INSERT 、 UPDATE 时填充对应字段

package com.yomahub.liteflow.example.pojo.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;

public class BaseEntity {

    @TableField(value = "create_by", fill = FieldFill.INSERT)
    private String createBy;

    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Long createTime;

    @TableField(value = "update_by", fill = FieldFill.INSERT_UPDATE)
    private String updateBy;

    @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
    private Long updateTime;

}

配置实体

标注表对应的实体

复合组件无法使用@TableId标注。 主键id默认使用雪花id

package com.yomahub.liteflow.example.pojo.entity;


import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

@EqualsAndHashCode(callSuper = true)
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@TableName("rule_node")
public class RuleNode extends BaseEntity{

    @TableId
    private Long id;

    @TableField("node_uid")
    private String nodeUid;

    @TableField("node_name")
    private String nodeName;

    @TableField("node_type")
    private Byte nodeType;

    @TableField("script")
    private String script;

    @TableField("script_type")
    private Byte scriptType;

    @TableField("clazz")
    private String clazz;

    @TableField("script_file_address")
    private String scriptFileAddress;

    @TableField("service_uid")
    private String serviceUid;
}

配置mapper

继承BaseMapper

package com.yomahub.liteflow.example.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yomahub.liteflow.example.pojo.entity.RuleNode;

public interface RuleNodeMapper extends BaseMapper<RuleNode> {
}

配置service

继承IService接口

package com.yomahub.liteflow.example.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yomahub.liteflow.example.pojo.dto.NodeAddDTO;
import com.yomahub.liteflow.example.pojo.dto.NodeQueryDTO;
import com.yomahub.liteflow.example.pojo.dto.NodeUpdateDTO;
import com.yomahub.liteflow.example.pojo.entity.RuleNode;
import com.yomahub.liteflow.example.pojo.vo.PageVO;

import java.util.List;

public interface RuleNodeService extends IService<RuleNode>{


    boolean save(NodeAddDTO dto);

    PageVO<RuleNode> pageNode(NodeQueryDTO dto);

    boolean update(NodeUpdateDTO dto);

    boolean deleteById(Long nodeId);

    boolean deleteBatchByIds(List<Long> ids);
}

继承IService实现类 ServiceImpl<RuleNodeMapper, RuleNode>

package com.yomahub.liteflow.example.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yomahub.liteflow.example.config.LiteServiceConfig;
import com.yomahub.liteflow.example.exception.ServiceException;
import com.yomahub.liteflow.example.mapper.RuleNodeChainMapper;
import com.yomahub.liteflow.example.pojo.dto.NodeAddDTO;
import com.yomahub.liteflow.example.pojo.dto.NodeQueryDTO;
import com.yomahub.liteflow.example.pojo.dto.NodeUpdateDTO;
import com.yomahub.liteflow.example.pojo.entity.RuleNode;
import com.yomahub.liteflow.example.mapper.RuleNodeMapper;
import com.yomahub.liteflow.example.pojo.entity.RuleNodeChain;
import com.yomahub.liteflow.example.pojo.vo.PageVO;
import com.yomahub.liteflow.example.service.RuleNodeService;
import com.yomahub.liteflow.example.service.ScriptService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class RuleNodeServiceImpl extends ServiceImpl<RuleNodeMapper, RuleNode> implements RuleNodeService {

    @Resource
    private LiteServiceConfig LiteServiceConfig;

    @Resource
    private RuleNodeChainMapper ruleNodeChainMapper;

    @Resource
    private ScriptService scriptService;

    @Transactional
    @Override
    public boolean save(NodeAddDTO dto) {
        RuleNodeMapper ruleNodeMapper = this.getBaseMapper();

        // 检查是否存在该规则节点名称
        String nodeName = dto.getNodeName();
        LambdaQueryWrapper<RuleNode> wrapper = new QueryWrapper<RuleNode>().lambda()
                .eq(!ObjectUtils.isEmpty(dto.getNodeUid()), RuleNode::getNodeUid, dto.getNodeUid())
                .or()
                .eq(RuleNode::getNodeName, nodeName);
        RuleNode node = ruleNodeMapper.selectOne(wrapper);

        if(!ObjectUtils.isEmpty(node)){
            throw new ServiceException("node name 已经存在");
        }

        RuleNode saveNode = BeanUtil.copyProperties(dto, RuleNode.class);
        // node节点需要以字母开头，且名字中不能包含中划线-，因为-是EL中的减号，才能通过脚本编译，如 node13078cabb0ed4ff89729aeb12492fcf1
        saveNode.setNodeUid("node" + UUID.randomUUID().toString().replace("-", ""));
        saveNode.setServiceUid(LiteServiceConfig.getServiceUid());
        int rows = ruleNodeMapper.insert(saveNode);
        if(rows > 0){
            scriptService.loadNodesAndChains();
        }
        return rows > 0;
    }

    @Override
    public PageVO<RuleNode> pageNode(NodeQueryDTO dto) {

        RuleNodeMapper ruleNodeMapper = this.getBaseMapper();
        IPage<RuleNode> page = new PageDTO<>(dto.getPageNum(), dto.getPageSize());

        LambdaQueryWrapper<RuleNode> wrapper = new QueryWrapper<RuleNode>().lambda()
                .eq(!ObjectUtils.isEmpty(dto.getNodeName()), RuleNode::getNodeName, dto.getNodeName())
                .eq(!ObjectUtils.isEmpty(dto.getNodeType()), RuleNode::getNodeType, dto.getNodeType())
                .eq(!ObjectUtils.isEmpty(dto.getNodeUid()), RuleNode::getNodeUid, dto.getNodeUid());

        IPage<RuleNode> pageResult = ruleNodeMapper.selectPage(page, wrapper);

        return new PageVO<>(pageResult.getTotal(), pageResult.getRecords());
    }

    @Transactional
    @Override
    public boolean update(NodeUpdateDTO dto) {

        RuleNodeMapper ruleNodeMapper = this.getBaseMapper();

        // 更新前，先检查是否存在该node
        LambdaQueryWrapper<RuleNode> wrapper = new QueryWrapper<RuleNode>().lambda()
                        .eq(RuleNode::getId, dto.getId());
        RuleNode node = ruleNodeMapper.selectOne(wrapper);

        if(ObjectUtils.isEmpty(node)){
            throw new ServiceException("当前要修改的节点:<" + dto.getNodeName() + "> 不存在");
        }

        // 存在则进行修改
        RuleNode updateNode = BeanUtil.copyProperties(dto, RuleNode.class);
        int rows = ruleNodeMapper.updateById(updateNode);
        if(rows > 0){
            scriptService.loadNodesAndChains();
        }
        return rows > 0;
    }

    @Override
    public boolean deleteById(Long nodeId) {

        // 检查节点是否被关联
        LambdaQueryWrapper<RuleNodeChain> wrapper = new QueryWrapper<RuleNodeChain>().lambda()
                .eq(RuleNodeChain::getNodeId, nodeId);
        Long relatedRows = ruleNodeChainMapper.selectCount(wrapper);
        if(relatedRows > 0){
            throw new ServiceException("节点" + nodeId + "已关联规则链，无法删除");
        }

        // 没被关联，则直接删除
        RuleNodeMapper ruleNodeMapper = this.getBaseMapper();
        int rows = ruleNodeMapper.deleteById(nodeId);
        if(rows > 0){
            scriptService.loadNodesAndChains();
        }
        return rows > 0;
    }

    @Override
    public boolean deleteBatchByIds(List<Long> ids) {

        // 检查节点是否被关联
        LambdaQueryWrapper<RuleNodeChain> wrapper = new QueryWrapper<RuleNodeChain>().lambda()
                .in(RuleNodeChain::getNodeId, ids);
        List<RuleNodeChain> list = ruleNodeChainMapper.selectList(wrapper);
        if(!ObjectUtils.isEmpty(list)){
            List<Long> relatedNode = list.stream().map(RuleNodeChain::getNodeId).distinct().collect(Collectors.toList());
            throw new ServiceException("节点" + relatedNode.toString() + "已关联规则链，无法删除");
        }

        // 没被关联，则直接删除
        RuleNodeMapper ruleNodeMapper = this.getBaseMapper();
        int rows = ruleNodeMapper.deleteBatchIds(ids);
        if(rows > 0){
            scriptService.loadNodesAndChains();
        }
        return rows > 0;
    }
}

mapper接口扫描/注入

在 启动类 上加@MapperScan注解进行mapper接口扫描

或

在 mapper接口 上加 @Mapper注解

@SpringBootApplication
@MapperScan("com.yomahub.liteflow.example.mapper")
public class LiteflowExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(LiteflowExampleApplication.class, args);
    }

}

参考资料：

[1] 官网 https://baomidou.com/

[2] 尚硅谷2022 mybatisplus