SpringBoot整合Mybatis-Plus

系统管理员 2022-09-14 14:22 62阅读 0赞

### SpringBoot整合Mybatis-Plus ###

*  一、配置文件
 *  二、实体类
 *  三、业务代码
 *  四、执行结果
 *   *  4.1增删改查
     *  4.2查询条件：名字中包含'王大锤888'
     *  4.3分页查询
 *  五、项目结构
 *  六、BaseMapper接口

Mybatis-Plus 是一款 Mybatis 动态 SQL 自动注入 Mybatis 增删改查 CRUD 操作中间件， 减少你的开发周期优化动态维护 XML 实体字段。

# 一、配置文件 #

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>springboot</groupId>
        <artifactId>springboot</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot</name>
    
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.3.RELEASE</version>
        </parent>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
    	    <dependency>
    	    	<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    	
    		
    		<dependency>
    			<groupId>com.baomidou</groupId>
    			<artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.3.4</version>
    		</dependency>
    
            
            <dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-jdbc</artifactId>
    		</dependency>
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid</artifactId>
    			<version>1.1.9</version>
    		</dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-extension</artifactId>
                <version>3.3.1</version>
            </dependency>
    		
    		<dependency>
    			<groupId>org.projectlombok</groupId>
    			<artifactId>lombok</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-amqp</artifactId>
            </dependency>
             <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
        </dependencies>
    </project>

application.yml

spring:
      profiles:
        active: dev

application-dev.yml

server:
      port: 8086
     
    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
        driver-class-name: com.mysql.cj.jdbc.Driver
     
    mybatis:
      mapper-locations: classpath:mapping/*Mapper.xml
      type-aliases-package: org.spring.springboot.entity
     
    
    #showSql
    logging:
      level:
        com:
          example:
            mapper : debug

# 二、实体类 #

Person

package org.spring.springboot.entity;
    
    import lombok.Data;
    
    @Data
    public class Person { 
        private Integer id;
        private String userName;
        private String passWord;
    
        public Person() { 
        }
    
        public Person(Integer id, String userName, String passWord) { 
            this.id = id;
            this.userName = userName;
            this.passWord = passWord;
        }
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public String getUserName() { 
            return userName;
        }
    
        public void setUserName(String userName) { 
            this.userName = userName;
        }
    
        public String getPassWord() { 
            return passWord;
        }
    
        public void setPassWord(String passWord) { 
            this.passWord = passWord;
        }
    }

对应数据表Person  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]

# 三、业务代码 #

HelloController

package org.spring.springboot.controller;
    
    import org.spring.springboot.entity.Person;
    import org.spring.springboot.mapper.PersonMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.List;
    
    @RestController
    public class HelloController { 
        /*Autowired默认的装配方式：byType; Qualifier意思是合格者，一般跟Autowired配合使用，需要指定一个bean的名称，通过bean名称就能找到需要装配的bean。 @Autowired @Qualifier("personMapper") 原理： 其实在启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器， 当容器扫描到@Autowied、@Resource(是CommonAnnotationBeanPostProcessor后置处理器处理的)或@Inject时， 就会在IoC容器自动查找需要的bean，并装配给该对象的属性 */
        @Autowired
        PersonMapper personMapper;
        @RequestMapping("/test")
        public void test(){ 
            // 新增数据
            Person person1  = new Person();
            person1.setId(1);
            person1.setPassWord("123456");
            person1.setUserName("zhangsanfeng");
            int i1 = personMapper.insert(person1);
            System.out.println("插入一条数据>>>" + i1);
    
            // 新增数据
            Person person11  = new Person();
            person11.setId(2);
            person11.setPassWord("8888");
            person11.setUserName("zhangsanfeng888");
            int i11 = personMapper.insert(person11);
            System.out.println("插入一条数据>>>" + i11);
    
            // 修改数据
            Person person2  = new Person();
            person2.setId(1);
            person2.setPassWord("789789");
            int i2 = personMapper.updateById(person2);
            System.out.println("更新一条数据>>>" + i2);
            // 删除数据
            int i3 = personMapper.deleteById(3);
            System.out.println("删除一条数据>>>" + i3);
            // 查询单条数据
            Person person3  = personMapper.selectById(1);
            System.out.println("查询1条数据>>>" + person3.toString());
            // 查询多条数据
            List<Person> person = personMapper.selectList(null);
            System.out.println("查询多条数据>>>" + person);
        }
        
        //不同查询方式总结
        @RequestMapping("/select")
        public void test2(){ 
            // 查询条件：名字中包含'王大锤888'
    
            // 使用查询构造器，查询一条记录
            QueryWrapper<Person> queryWrapper = new QueryWrapper<>();
            queryWrapper.like("user_name","王大锤888");
            Person person = personMapper.selectOne(queryWrapper);
            System.out.println(person);
    
            // 使用lambda 条件构造器，查询一条记录
            LambdaQueryWrapper<Person> queryWrappers = new QueryWrapper<Person>().lambda();
            queryWrappers.like(Person::getUserName,"王大锤888");
            Person person2 = personMapper.selectOne(queryWrappers);
            System.out.println(person2);
    
            //函数式编程方式，查询一条记录
            Person person3 = new LambdaQueryChainWrapper<Person>(personMapper).like(Person::getUserName,"王大锤888").one();
            System.out.println(person3);
    
            //将对象直接以构造参数的形式传递给 QueryWrapper,MyBatisPlus 会自动根据实体对象中的属性自动构建相应查询的 SQL 语句
            Person person4  = new Person();
            person4.setUserName("王大锤888");
            QueryWrapper<Person> queryWrapper4 = new QueryWrapper<>(person4);
            // 开始查询
            Person user = personMapper.selectOne(queryWrapper4);
            System.out.println(user);
    
            //通过 Map 封装的条件查询，返回一个 List
            Map<String,Object> columnMap = new HashMap<>();
            columnMap.put("user_name", "王大锤888");
            List<Person> users = personMapper.selectByMap(columnMap);
            System.out.println(users);
    
            // 使用查询构造器，返回一个 List
            QueryWrapper<Person> queryWrapper5 = new QueryWrapper<>();
            queryWrapper5.like("user_name","王大锤888");
            // 开始查询
            List<Person> person5 = personMapper.selectList(queryWrapper5);
            System.out.println(person5);
        }
    
        @RequestMapping("/selectByPage")
        public IPage<Person> test3(){ 
            // 查询条件：名字中包含'王大锤8'
    
            LambdaQueryWrapper<Person> queryWrappers = new QueryWrapper<Person>().lambda();
            queryWrappers.like(Person::getUserName,"王大锤8");
            IPage<Person> page = personMapper.selectPage(new Page<>(1,2),queryWrappers);
            return page;
        }
    
        @RequestMapping("/testByMap")
        public IPage<Map<String, Object>> test4(){ 
            // 查询条件：名字中包含'王大锤8'
            LambdaQueryWrapper<Person> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.like(Person::getUserName,"王大锤8");
            // 开始查询
            IPage<Map<String, Object>> page = personMapper.selectMapsPage(new Page<>(1,2),
                    queryWrapper);
            return page;
        }
    }

PersonMapper

package org.spring.springboot.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.apache.ibatis.annotations.Mapper;
    import org.spring.springboot.entity.Person;
    import org.springframework.stereotype.Repository;
    
    @Mapper
    @Repository
    public interface PersonMapper extends BaseMapper<Person> { 
      //Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
    }

主启动类ApplicationApp

package org.spring.springboot;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    // Spring Boot 应用的标识
    /* UserMapper.java 如果不添加Mapper注解，则此处需要添加MapperScan @MapperScan("com.example.mapper") */
    @SpringBootApplication
    public class ApplicationApp { 
    
        public static void main(String[] args) { 
            // 程序启动入口
            // 启动嵌入式的 Tomcat 并初始化 Spring 环境及其各 Spring 组件
            SpringApplication.run(ApplicationApp.class,args);
        }
    }

MybatisPlusConfig

package org.spring.springboot.config;
    
    import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    @EnableTransactionManagement
    @Configuration
    public class MybatisPlusConfig { 
        /** * mybatis-plus分页插件 */
        @Bean
        public PaginationInterceptor paginationInterceptor() { 
            PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
            // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false
            // paginationInterceptor.setOverflow(false);
            // 设置最大单页限制数量，默认 500 条，-1 不受限制
            // paginationInterceptor.setLimit(500);
            // 开启 count 的 join 优化,只针对部分 left join
            paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
            return paginationInterceptor;
        }
    }

# 四、执行结果 #

## 4.1增删改查 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][4d930c85b2b94468b8e491f0d8b98ad5.png]

## 4.2查询条件：名字中包含’王大锤888’ ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
![在这里插入图片描述][81c13ef1442245e4a9a475b48c518539.png]

## 4.3分页查询 ##

查询条件：名字中包含’王大锤8’，查询第1页，每页显示2条  
不添加MybatisPlusConfig类，查询结果没有分页  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
添加MybatisPlusConfig类，正常显示分页  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 6]

# 五、项目结构 #

[项目下载][Link 1]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_14_color_FFFFFF_t_70_g_se_x_16]

# 六、BaseMapper接口 #

public interface BaseMapper<T> { 
        //插入一条记录 参数：实体 返回：int
        Integer insert(T entity);
     
        //根据 ID 删除 参数：主键ID 返回：int
        Integer deleteById(Serializable id);
        
         //根据 columnMap 条件，删除记录 参数：表字段 map 对象 返回：int
        Integer deleteByMap(@Param("cm") Map<String, Object> columnMap);
     
         //根据 entity 条件，删除记录 参数：实体对象封装操作类（可以为 null） 返回：int
        Integer delete(@Param("ew") Wrapper<T> wrapper);
     
         //删除（根据ID 批量删除） 参数：主键ID列表 返回：int
        Integer deleteBatchIds(List<? extends Serializable> idList);
     
         //根据 ID 修改 参数：实体对象 返回：int
        Integer updateById(T entity);
     
         //根据 whereEntity 条件，更新记录 参数：实体对象,实体对象封装操作类（可以为 null） 返回：int
        Integer update(@Param("et") T entity, @Param("ew") Wrapper<T> wrapper);
     
         //根据 ID 查询 参数：主键ID 返回：T
        T selectById(Serializable id);
     
         //查询（根据ID 批量查询） 参数：主键ID列表 返回：List<T>
        List<T> selectBatchIds(List<? extends Serializable> idList);
     
         //查询（根据 columnMap 条件） 参数：表字段 map 对象 返回：List<T>
        List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
     
         //根据 entity 条件，查询一条记录 参数：实体对象 返回：T
        T selectOne(@Param("ew") T entity);
    
         //根据 Wrapper 条件，查询总记录数 参数：实体对象 返回：int
        Integer selectCount(@Param("ew") Wrapper<T> wrapper);
     
         //根据 entity 条件，查询全部记录 参数：实体对象封装操作类（可以为 null） 返回：List<T>
        List<T> selectList(@Param("ew") Wrapper<T> wrapper);
     
         //根据 Wrapper 条件，查询全部记录 参数：实体对象封装操作类（可以为 null） 返回：List<T>
        List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> wrapper);
     
         //根据 Wrapper 条件，查询全部记录 参数：实体对象封装操作类（可以为 null） 返回：List<Object>
        List<Object> selectObjs(@Param("ew") Wrapper<T> wrapper);
     
        /** * 用法：(new RowBounds(offset, limit), ew); * 根据 entity 条件，查询全部记录（并翻页） * @param rowBounds * 分页查询条件（可以为 RowBounds.DEFAULT） * @param wrapper * 实体对象封装操作类（可以为 null） * @return List<T> */
         //根据 ID 删除 参数：主键ID 返回：int
        List<T> selectPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
     
        /** -- 不常用, * 根据 Wrapper 条件，查询全部记录（并翻页） * @param rowBounds * 分页查询条件（可以为 RowBounds.DEFAULT） * @param wrapper * 实体对象封装操作类 * @return List<Map<String, Object>> */
         //根据 ID 删除 参数：主键ID 返回：int
        List<Map<String, Object>> selectMapsPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
    }

**参考文章**  
[SpringBoot - MyBatis-Plus使用详解][SpringBoot - MyBatis-Plus]  
[Mybatis-Plus 的BaseMapper用法][Mybatis-Plus _BaseMapper]  
[Mybatis-Plus的BaseMapper的使用][Mybatis-Plus_BaseMapper]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/198a6f6d59494a69aa833ba8a951b3cb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/982a5d9eeb154e1c823cd0d540b6734a.png
[4d930c85b2b94468b8e491f0d8b98ad5.png]: /images/20220828/28fd62d9b62740428cb3b492b1d32ddf.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/93bb1c37b7444cb386b385cc0b58a1c4.png
[81c13ef1442245e4a9a475b48c518539.png]: /images/20220828/b54f41f2d728468baeab4ef7ba6a8a68.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/3d3688037eac46f784393492316eb886.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/e0e7fecebca64dbab1bbb669d17a8e9f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/a36f4cb5d58e47cc96e1d5fff8ed9a2d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/d4a6037a7cf242cb85b9fd668f0b7c00.png
[Link 1]: https://gitee.com/jike11231/springboot-mybatis-plus.git
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/4299d5b109e54f7e83bd02ef00b3de39.png
[SpringBoot - MyBatis-Plus]: https://www.hangge.com/blog/cache/detail_2901.html
[Mybatis-Plus _BaseMapper]: https://blog.csdn.net/weixin_44839439/article/details/116302498
[Mybatis-Plus_BaseMapper]: https://www.cnblogs.com/JoeyWong/p/9489701.html