SpringBoot 整合mybatis plus

Mybatis Plus 简介

Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。封装了简单的crud方法，简单的crud只需调用方法即可，无需再写xml。

springboot整合 mybatis plus

核心依赖：

	 <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
     </dependency>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>

     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.38</version>
         <scope>runtime</scope>
     </dependency>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
             <exclusion>
                 <groupId>org.junit.vintage</groupId>
                 <artifactId>junit-vintage-engine</artifactId>
             </exclusion>
         </exclusions>
     </dependency>
     <dependency>
         <groupId>com.baomidou</groupId>
         <artifactId>mybatis-plus-boot-starter</artifactId>
         <version>3.0.1</version>
     </dependency>

Jdbc配置文件

spring:
  datasource:
    url: jdbc:mysql://XXX.XXX.XXX.XXX
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  <!-- 定时框架线程池配置--!>  
  quartz:
    properties:
      org:
        quartz:
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 50
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true
mybatis-plus:
  type-aliases-package: cn.XXX.ict.entity
  mapper-locations: classpath:/mapper/*Mapper.xml
server:
  port: 8082

定义个空的mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

MybatisPlusConfig

@Configuration
public class MybatisPlusConfig {
    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
// 开启 count 的 join 优化,只针对 left join !!!
        return new PaginationInterceptor();
    }


    /**
     * 两个分页插件都配置,不会冲突
     * pagehelper的分页插件
     */
    @Bean
    public PageInterceptor pageInterceptor() {
        return new PageInterceptor();
    }
}

实体类

@Data
//对应数据库该表
@TableName("parameters")
@ApiModel("接口参数表")
public class Parameters {
	//对应数据库主键列
    @TableId(value = "parameter_id")
    private String parameterId;
    
	//对应数据库该列
    @ApiModelProperty("接口版本规则id")
    @TableField("interface_id")
    private String interfaceId;

    @ApiModelProperty("接口名")
    @TableField("name")
    private String name;

    @TableField("location")
    @ApiModelProperty("参数位置")
    private String location;

    @TableField("description")
    @ApiModelProperty("接口描述")
    private String description;

    @TableField("required")
    private String required;
}

service

• 继承 IService

public interface ParametersService extends IService<Parameters> {

}

IService中已有的方法

public interface IService<T> {
    boolean save(T var1);

    boolean saveBatch(Collection<T> var1);

    boolean saveBatch(Collection<T> var1, int var2);

    boolean saveOrUpdateBatch(Collection<T> var1);

    boolean saveOrUpdateBatch(Collection<T> var1, int var2);

    boolean removeById(Serializable var1);

    boolean removeByMap(Map<String, Object> var1);

    boolean remove(Wrapper<T> var1);

    boolean removeByIds(Collection<? extends Serializable> var1);

    boolean updateById(T var1);

    boolean update(T var1, Wrapper<T> var2);

    boolean updateBatchById(Collection<T> var1);

    boolean updateBatchById(Collection<T> var1, int var2);

    boolean saveOrUpdate(T var1);

    T getById(Serializable var1);

    Collection<T> listByIds(Collection<? extends Serializable> var1);

    Collection<T> listByMap(Map<String, Object> var1);

    T getOne(Wrapper<T> var1);

    Map<String, Object> getMap(Wrapper<T> var1);

    Object getObj(Wrapper<T> var1);

    int count(Wrapper<T> var1);

    List<T> list(Wrapper<T> var1);

    IPage<T> page(IPage<T> var1, Wrapper<T> var2);

    List<Map<String, Object>> listMaps(Wrapper<T> var1);

    List<Object> listObjs(Wrapper<T> var1);

    IPage<Map<String, Object>> pageMaps(IPage<T> var1, Wrapper<T> var2);
}

serviceImpl

• 继承ServiceImpl

@Service
public class ParametersServiceImpl extends ServiceImpl<ParametersMapper, Parameters> implements ParametersService {

}

mapper

• 继承BaseMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface ParametersMapper extends BaseMapper<Parameters> {

}

BaseMapper接口

public interface BaseMapper<T> {
 
    /**
     * <p>
     * 插入一条记录
     * </p>
     *
     * @param entity 实体对象
     */
    Integer insert(T entity);
 
    /**
     * <p>
     * 根据 ID 删除
     * </p>
     *
     * @param id 主键ID
     */
    Integer deleteById(Serializable id);
 
    /**
     * <p>
     * 根据 columnMap 条件，删除记录
     * </p>
     *
     * @param columnMap 表字段 map 对象
     */
    Integer deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
 
    /**
     * <p>
     * 根据 entity 条件，删除记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Integer delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 删除（根据ID 批量删除）
     * </p>
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    Integer deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
 
    /**
     * <p>
     * 根据 ID 修改
     * </p>
     *
     * @param entity 实体对象
     */
    Integer updateById(@Param(Constants.ENTITY) T entity);
 
    /**
     * <p>
     * 根据 whereEntity 条件，更新记录
     * </p>
     *
     * @param entity        实体对象 (set 条件值,不能为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    Integer update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
 
    /**
     * <p>
     * 根据 ID 查询
     * </p>
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);
 
    /**
     * <p>
     * 查询（根据ID 批量查询）
     * </p>
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
 
    /**
     * <p>
     * 查询（根据 columnMap 条件）
     * </p>
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
 
    /**
     * <p>
     * 根据 entity 条件，查询一条记录
     * </p>
     *
     * @param queryWrapper 实体对象
     */
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询总记录数
     * </p>
     *
     * @param queryWrapper 实体对象
     */
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 entity 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * 注意： 只返回第一个字段的值
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 entity 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

• 以上就完成springboot 对mybatis-plus的整合

应用举例

Controller层通过IService自带的方法调用BaseMapper方法查询数据库，并将数据保存到数据库

compare1 = compareService.getOne(new QueryWrapper<Compare>().select().eq("project_id", project.getProjectId()).eq("compare_flag", compareFlag));
    if (compare1 == null) {
        Compare compare = new Compare();

        compare.setCompareFlag(compareFlag);
        compare.setProjectId(project.getProjectId());
        compare.setCompareTime(DateUtil.parse(compareTime, DateUtil.YCHAR_06));
        compare.setUpdateTime(DateUtil.parse(compareTime, DateUtil.YCHAR_06));
        compare.setSrcVersion(srcVersion);
        compare.setTargetVersion(targetVersion);
        compareService.save(compare);
     }

getOne()源码

 public T getOne(Wrapper<T> queryWrapper) {
        return SqlHelper.getObject(this.baseMapper.selectList(queryWrapper));    
}

• getOne()，这个是方法返回结果不止一条则会抛出异常，如果想默认取第一条结果，可以给这方法传第二个参数为false。

save()源码

public boolean save(T entity) {
        return retBool(this.baseMapper.insert(entity));   
}

eq()

• 相当于where

分页查询举例

@ApiOperation(value = "查看项目列表", notes = "查看项目列表")
@PostMapping(value = "/list")
public Result list(int pageNumber, int pageSize) {
    List<Object> list = new ArrayList<>();
    List<ProjectManagerVO> projectManagerVOList;
    //传入分页参数
    IPage<Project> page = new Page<>(pageNumber, pageSize);
    IPage<Project> pageList = projectService.page(page, new QueryWrapper<Project>());
    //查询到的总条数
    long totalNum = pageList.getTotal();
    //当前页数据
    List<Project> list1 = pageList.getRecords();
	//处理数据
    projectManagerVOList = searchList(list1);
    list.add(projectManagerVOList);
    list.add(totalNum);
    return Result.success(list);
}

按条件查询列表

List<Regular> list1 = regularService.list(new QueryWrapper<Regular>().select().eq("project_id", project.getProjectId()).orderByDesc("create_time"));

多表查询

当遇到多表查询或者较复杂逻辑查询时，不要拘泥于硬用mp自带的方法，不然会发现查询逻辑越复杂代码会越臃肿，还不如老老实实写sql。

举例说明
@Mapper

• 代替mapper映射文件

@Select

• 简便、快速去操作sql
• 只需要在mapper中方法上加入@Select()，然后在括号中写入需要实现的sql语句即可

@Results

• MyBatis中使用@Results注解来映射查询结果集到实体类属性。

@Mapper
public interface InterfaceMapper extends BaseMapper<Interface> {

    @Select({"<script>" +
            "select p.project_id,p.project_name,c.src_version,c.target_version,c.compare_flag,D.interface_flag,D.interface_name,D.interface_path,D.request_method,D.create_time from project  as p\n" +
            "LEFT JOIN compare as c\n" +
            "on p.project_id = c.project_id\n" +
            "left join comDetail as D\n" +
            "on c.compare_id = D.compare_id\n" +
            "where p.project_name = #{projectName} " +
            "<if test=\"interfaceFlag !='' \">" +
            "\t and D.interface_flag = #{interfaceFlag}" +
            "</if>" +
            "<if test=\"compareFlag !='' \">" +
            "\t and c.compare_flag = #{compareFlag}" +
            "</if>" +
            "ORDER BY p.project_id,D.create_time\n" +
            "limit #{pageNumber},#{pageSize} " +
            "</script>"
    })
    @Results({
            @Result(column = "project_id", property = "projectId", jdbcType = JdbcType.INTEGER),
            @Result(column = "project_name", property = "projectName", jdbcType = JdbcType.VARCHAR),
            @Result(column = "create_time", property = "createTime"),
            @Result(column = "interface_name", property = "interfaceName", jdbcType = JdbcType.VARCHAR),
            @Result(column = "src_version", property = "srcVersion", jdbcType = JdbcType.VARCHAR),
            @Result(column = "target_version", property = "tarVersion", jdbcType = JdbcType.VARCHAR),
            @Result(column = "request_method", property = "interfaceType", jdbcType = JdbcType.VARCHAR),
            @Result(column = "interface_flag", property = "interfaceFlag", jdbcType = JdbcType.VARCHAR),
            @Result(column = "interface_path", property = "interfacePath", jdbcType = JdbcType.VARCHAR),
            @Result(column = "compare_flag", property = "compareFlag", jdbcType = JdbcType.VARCHAR),
    })
    public List<InterfaceManagerVO> searchInterface(String projectName, String interfaceFlag, String compareFlag, int pageNumber, int pageSize);
    
}

controller调用

@ApiOperation(value = "查询接口", notes = "查询接口")
@PostMapping(value = "/search")
public Result<List<InterfaceManagerVO>> search(String projectName, String interfaceFlag, String compareFlag, int pageNumber, int pageSize) {

    List<InterfaceManagerVO> interfaceManagerVOList;
    int totalNum;
    if (projectName == null) {
        interfaceManagerVOList = interfaceMapper.searchList((pageNumber - 1) * pageSize, pageSize);
        totalNum = interfaceMapper.listTotalNum();
    } else {
        interfaceManagerVOList = interfaceMapper.searchInterface(projectName, interfaceFlag, compareFlag, (pageNumber - 1) * pageSize, pageSize);
        totalNum = interfaceMapper.searchTotalNum(projectName, interfaceFlag, compareFlag);
    }
    List<Object> list = new ArrayList<>();
    if (interfaceManagerVOList == null) {
        return Result.error(101, "数据为空");
    }
    list.add(interfaceManagerVOList);
    list.add(totalNum);
    return Result.success(list);
}