MyBatis-Plus快速入门篇

ゝ一纸荒年。 2024-03-26 09:49 195阅读 0赞

入门篇

  • 1.快速入门
    • 1.1数据库准备
    • 1.2创建SpringBoot工程，引入MyBatis-Plus和MySQL依赖，可以使用 Spring Initializer快速初始化一个 Spring Boot 工程
    • 1.3编写DataSource相关配置（配置MySQL数据库连接）
    • 1.4编码
    • 1.5测试
  • 2.使用MybatisPlus完成增删改
    • 2.1Mapper添加
    • 2.2Mapper删除
    • 2.3Mapper修改
  • 3.使用MybatisPlus完成查询
  • 4.Service封装
  • 5.逆向工程-代码生成器

1.快速入门

1.1数据库准备

现有一张tb_user表，其表结构如下:
在这里插入图片描述
对应的数据库脚本如下:

  1. DROP TABLE IF EXISTS `tb_user`;
  2. CREATE TABLE `tb_user`  (
  3.   `id` int(11) NOT NULL AUTO_INCREMENT,
  4.   `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  5.   `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  6.   `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  7.   `age` int(11) NULL DEFAULT NULL,
  8.   `email` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  9.   PRIMARY KEY (`id`) USING BTREE
  10. ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

1.2创建SpringBoot工程，引入MyBatis-Plus和MySQL依赖，可以使用 Spring Initializer快速初始化一个 Spring Boot 工程

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.        <version>2.1.1.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.example</groupId>
  12.     <artifactId>mybatisplus</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>mybatisplus</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>8</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter</artifactId>
  23.         </dependency>
  25.         <dependency>
  26.             <groupId>mysql</groupId>
  27.             <artifactId>mysql-connector-java</artifactId>
  28.             <version>5.1.26</version>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.projectlombok</groupId>
  32.             <artifactId>lombok</artifactId>
  33.             <optional>true</optional>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-test</artifactId>
  38.             <scope>test</scope>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>com.baomidou</groupId>
  42.             <artifactId>mybatis-plus-boot-starter</artifactId>
  43.             <version>3.5.2</version>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>junit</groupId>
  47.             <artifactId>junit</artifactId>
  48.             <version>4.13</version>
  49.             <scope>test</scope>
  50.         </dependency>
  51.     </dependencies>
  53.     <build>
  54.         <plugins>
  55.             <plugin>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-maven-plugin</artifactId>
  58.                 <configuration>
  59.                     <excludes>
  60.                         <exclude>
  61.                             <groupId>org.projectlombok</groupId>
  62.                             <artifactId>lombok</artifactId>
  63.                         </exclude>
  64.                     </excludes>
  65.                 </configuration>
  66.             </plugin>
  67.         </plugins>
  68.     </build>
  70. </project>

1.3编写DataSource相关配置（配置MySQL数据库连接）

  1. server:
  2.   port: 8080
  3. spring:
  4.   datasource:
  5.     driver-class-name: com.mysql.jdbc.Driver
  6.     username: root
  7.     password: 123456
  8.     url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8

1.4编码

实体类

  1. import com.baomidou.mybatisplus.annotation.TableName;
  2. import lombok.Data;
  4. @TableName("tb_user")
  5. @Data
  6. public class User {
  8.     private Integer id;
  9.     private String username;
  10.     private String password;
  11.     private String name;
  12.     private Integer age;
  13.     private String email;
  14. }

其中@TableName是MybatisPlus注解，内容对应MySQL表名称，@Data是Lombok的注解，该注解的主要功能是省去了getter/setter方法。

编写mapper

  1. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  2. import com.example.mybatisplus.domain.User;
  4. public interface UserMapper extends BaseMapper<User> {
  6. }

启动类增加@MapperScan注解

  1. import org.mybatis.spring.annotation.MapperScan;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. @SpringBootApplication
  6. @MapperScan("com.example.mybatisplus")
  7. public class MybatisplusApplication {
  10.     public static void main(String[] args) {
  12.         SpringApplication.run(MybatisplusApplication.class, args);
  13.     }
  15. }

1.5测试

  1. import com.example.mybatisplus.domain.User;
  2. import com.example.mybatisplus.mapper.UserMapper;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7. import org.springframework.test.context.junit4.SpringRunner;
  9. @SpringBootTest(classes = MybatisplusApplication.class)
  10. @RunWith(SpringRunner.class)
  11. public class UserMapperTest {
  14.     @Autowired
  15.     private UserMapper userMapper;
  17.     @Test
  18.     public void test01(){
  20.         User user = userMapper.selectById(1);
  21.         System.out.println(user);
  22.     }
  23. }

在这里插入图片描述

@Test需引入Junit依赖包，可以从https://mvnrepository.com/下载

2.使用MybatisPlus完成增删改

2.1Mapper添加

方法：

  1. //添加一条记录 参数:T 实体对象
  2.     int insert(T entity);

测试:

  1. @Test
  2.     public void testInsert(){
  4.         User user=new User();
  5.         user.setUsername("xy");
  6.         user.setPassword("123456");
  7.         user.setName("专精装项羽");
  8.         user.setAge(180);
  9.         int count = userMapper.insert(user);
  10.         System.out.println(count);
  11.     }

2.2Mapper删除

方法：

  1. //根据ID删除
  2.     int deleteById(Serializable id);
  3.     //根据实体类删除
  4.     int deleteById(T entity);
  5.     //根据columnMap条件删除
  6.     int deleteByMap(@Param("cm") Map<String, Object> columnMap);
  7.     //根据entiy条件，删除记录
  8.     int delete(@Param("ew") Wrapper<T> queryWrapper);
  9.     //根据ID批量删除
  10.     int deleteBatchIds(@Param("coll") Collection<?> idList);

测试：

根据id删除

  1. @Test
  2.     public void testDelete01(){
  4.         int count=userMapper.deleteById(1883332609);
  5.     }

根据id批量删除

  1. @Test
  2.     public void testDelete02(){
  4.         List list=new ArrayList();
  5.         list.add(3);
  6.         list.add(4);
  7.         int count = userMapper.deleteBatchIds(list);
  8.     }

根据map构造条件，删除

  1. @Test
  2.     public void testDelete03(){
  4.         Map<String,Object> map=new HashMap<>();
  5.         map.put("username","dg");
  6.         map.put("name","呆瓜");
  7.         int count = userMapper.deleteByMap(map);
  8.     }

2.3Mapper修改

方法：

  1. //根据ID修改
  2.     int updateById(@Param("et") T entity);
  3.     //根据whereEntiy条件修改
  4.     int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

测试：

  1. @Test
  2.     public void testUpdate01(){
  4.         User user=new User();
  5.         user.setId(3);
  6.         user.setName("杨杨杨");
  7.         int count = userMapper.updateById(user);
  8.     }
  10. @Test
  11.     public void testUpdate02(){
  13.         User user=new User();
  14.         user.setName("旺旺旺");
  15.         QueryWrapper<User> qw=new QueryWrapper<>();
  16.         qw.eq("id",1);
  17.         int count = userMapper.update(user,qw);
  18.     }

3.使用MybatisPlus完成查询

查询的方法比较多，所以单独总结一起

  1. //根据ID查询，查询出一条记录
  2.     T selectById(Serializable id);
  3.     //根据ID批量查询，查询出多条记录
  4.     List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
  5.     //根据entity条件，查询出多条记录
  6.     List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
  7.     //根据columnMap条件，查询出多条记录
  8.     List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
  9.     //根据queryWrapper条件，查询出多条记录
  10.     List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
  11.     //根据queryWrapper条件，查询出多条记录（注意：只返回第一个字段的值）
  12.     List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);
  13.      //根据entiy条件，查询出多条记录并分页
  14.     <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);
  15.     //根据Wrapper条件，查询出多条记录并分页
  16.     <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param("ew") Wrapper<T> queryWrapper);

分页查询
配置拦截器

  1. @Configuration
  2. public class PageConfig {
  5.     /**
  6.      * 3.4.0之前的版本用这个
  7.      * @return
  8.      */
  9.    /* @Bean
  10.     public PaginationInterceptor paginationInterceptor(){
  11.         return  new PaginationInterceptor();
  12.     }*/
  14.     /**
  15.      * 3.4.0之后提供的拦截器的配置方式
  16.      * @return
  17.      */
  18.    @Bean
  19.    public MybatisPlusInterceptor mybatisPlusInterceptor(){
  21.        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
  22.        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
  23.        return mybatisPlusInterceptor;
  24.    }
  25. }

查询

  1. @Test
  2.     public void testSelectPage(){
  4.         int current=1;//当前页码
  5.         int size=5;//每页显示条数
  6.         IPage<User> page=new Page(current,size);
  7.         userMapper.selectPage(page,null);
  8.         List<User> records = page.getRecords();//当前页的数据
  9.         long pages = page.getPages();//总页数
  10.         long total = page.getTotal();//总记录数
  11.         System.out.println(records);
  12.         System.out.println(pages);
  13.         System.out.println(total);
  14.     }

条件构造器查询

  1. Wrapper:
  2.     1.QueryWrapper 查询
  3.         LambdaQueryWrapper (支持Lambda表达式)
  4.     2.UpdateWrapper 更新
  5.         LamdbaUpdateWrapper(支持Lamdba表达式)

基础查询
通过QueryWrapper指定查询条件

  1. sql:select * from tb_user where password='123456' and age>18
  3. eq():等于=
  4. ne():不等于=
  5. gt():大于>
  6. ge():大于等于>=
  7. lt():小于<
  8. le():小于等于<=
  9. between(): BETWEEN 值1 AND 值2
  10. in():in
  11. notIn():not in
  13. @Test
  14.     public void testWrapper1(){
  16.         //创建查询条件构造器
  17.         QueryWrapper<User> wrapper=new QueryWrapper<>();
  18.         //设置条件
  19.         wrapper.eq("username","bq")
  20.                 .lt("age",23)
  21.                 .in("name","白起","旺旺旺");
  22.         List<User> users = userMapper.selectList(wrapper);
  23.         System.out.println(users);
  24.      }

以上sql等同于 select * from tb_user where username=“bq” and age<23 and name in(“白起”,“旺旺旺”)

逻辑查询or
or():让紧接着下一个方法用or连接

  1. @Test
  2.     public void testWrapper2(){
  4.         //创建查询条件构造器
  5.         QueryWrapper<User> wrapper=new QueryWrapper<>();
  6.         //设置条件
  7.         wrapper.eq("username","bq")
  8.                 .or()
  9.                 .lt("age",23)
  10.                 .in("name","王昭君","旺旺旺");
  11.         List<User> users = userMapper.selectList(wrapper);
  12.         System.out.println(users);
  13.     }

模糊查询like

  1. like      //模糊查询匹配值‘%值%’
  2. notLike   //模糊查询不匹配值‘%值%’
  3. likeLeft  //模糊查询匹配最后一位值‘%值’
  4. likeRight  //模糊查询匹配第一位值‘值%’
  6. @Test
  7.     public void testWrapper3(){
  9.         //创建查询条件构造器
  10.         QueryWrapper<User> wrapper=new QueryWrapper<>();
  11.         //设置条件
  12.         wrapper.likeLeft("name","君");
  13.         List<User> users = userMapper.selectList(wrapper);
  14.         System.out.println(users);
  15.     }

排序查询

  1. orderBy
  2. orderByAsc
  3. orderByDESC

select：指定需要查询的字段

  1. @Test
  2.     public void testWrapper4(){
  4.         //创建查询条件构造器
  5.         QueryWrapper<User> wrapper=new QueryWrapper<>();
  6.         //设置条件
  7.         wrapper.lt("age",22).select("age");
  8.         List<User> users = userMapper.selectList(wrapper);
  9.         System.out.println(users);
  10.     }

4.Service封装

MVC架构
controller——>service（impl）———->dao(mapper)

Mybatis-Plus 为了开发更加快捷，对业务层也进行了封装，直接提供了相关的接口和实现类。我们在进行业务层开发时，可以继承它提供的接口和实现类，使得编码更加高效

    1. 定义接口继承IService
    1. 定义实现类继承ServiceImpl 实现定义的接口

接口

  1. public interface _UserService extends IService<User> {
  3. }

实现类实现接口

  1. @Service
  2. public class _UserServiceImpl extends ServiceImpl<UserMapper, User> implements _UserService {
  3.     }

测试

  1. import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
  2. import com.example.mybatisplustest.MybatisPlusTestApplication;
  3. import com.example.mybatisplustest.pojo.User;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.test.context.junit4.SpringRunner;
  10. @SpringBootTest(classes = MybatisPlusTestApplication.class)
  11. @RunWith(SpringRunner.class)
  12. public class UserServiceTest {
  15.     @Autowired
  16.     private UserService userService;
  18.     @Test
  19.     public void testFind(){
  21.         UpdateWrapper<User> wrapper = new UpdateWrapper<>();
  22.         wrapper.eq("id",1);
  23.         User one = userService.getOne(wrapper);
  24.         System.out.println(one);
  25.     }
  26. }

5.逆向工程-代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
安装
引入坐标依赖

  1. <dependency>
  2.             <groupId>com.baomidou</groupId>
  3.             <artifactId>mybatis-plus-generator</artifactId>
  4.             <version>3.5.2</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.freemarker</groupId>
  8.             <artifactId>freemarker</artifactId>
  9.             <version>2.3.28</version>
  10.         </dependency>
  12. package com.example.mybatisplus;
  14. import com.baomidou.mybatisplus.generator.FastAutoGenerator;
  15. import com.baomidou.mybatisplus.generator.config.OutputFile;
  16. import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
  18. import java.util.Collections;
  20. public class Generator {
  22.     public static void main(String[] args) {
  24.         FastAutoGenerator.create("jdbc:mysql://localhost:3306/test?characterEncoding=utf-8", "root", "123456")
  25.                 .globalConfig(builder -> {
  27.                     builder.author("test") // 设置作者
  28.                             .enableSwagger() // 开启 swagger 模式
  29.                             .fileOverride() // 覆盖已生成文件
  30.                             .outputDir("D://"); // 指定输出目录
  31.                 })
  32.                 .packageConfig(builder -> {
  34.                     builder.parent("com.baomidou.mybatisplus.samples.generator") // 设置父包名
  35.                             .moduleName("system") // 设置父包模块名
  36.                             .pathInfo(Collections.singletonMap(OutputFile.xml, "D://")); // 设置mapperXml生成路径
  37.                 })
  38.                 .strategyConfig(builder -> {
  40.                     builder.addInclude("tb_user") // 设置需要生成的表名
  41.                             .addTablePrefix("t_", "c_"); // 设置过滤表前缀
  42.                 })
  43.                 .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
  44.                 .execute();
  45.     }
  46. }

生成结果
在这里插入图片描述
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，195人围观）

还没有评论，来说两句吧...

相关阅读