MyBatisPlus 学习笔记
作者:故事我忘了￠
个人微信公众号:程序猿的月光宝盒

https://mybatis.plus/guide/

本篇基于springboot,mybatis Plus的版本为3.4.2

本篇对应的github地址

https://github.com/monkeyKinn/StudyMyBatisPlus

觉得有用给个Star哦~~~~

Star

Star

Star

  1. #创建用户表
  2. CREATE TABLE user (
  3.     id BIGINT(20) PRIMARY KEY NOT NULL COMMENT '主键',
  4.     name VARCHAR(30) DEFAULT NULL COMMENT '姓名',
  5.     age INT(11) DEFAULT NULL COMMENT '年龄',
  6.     email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
  7.     manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',
  8.     create_time DATETIME DEFAULT NULL COMMENT '创建时间',
  9.     CONSTRAINT manager_fk FOREIGN KEY (manager_id)
  10.         REFERENCES user (id)
  11. )  ENGINE=INNODB CHARSET=UTF8;
  13. #初始化数据：
  14. INSERT INTO user (id, name, age, email, manager_id
  15. 	, create_time)
  16. VALUES (1087982257332887553, '大boss', 40, 'boss@baomidou.com', NULL
  17. 		, '2019-01-11 14:20:20'),
  18. 	(1088248166370832385, '王天风', 25, 'wtf@baomidou.com', 1087982257332887553
  19. 		, '2019-02-05 11:12:22'),
  20. 	(1088250446457389058, '李艺伟', 28, 'lyw@baomidou.com', 1088248166370832385
  21. 		, '2019-02-14 08:31:16'),
  22. 	(1094590409767661570, '张雨琪', 31, 'zjq@baomidou.com', 1088248166370832385
  23. 		, '2019-01-14 09:15:15'),
  24. 	(1094592041087729666, '刘红雨', 32, 'lhm@baomidou.com', 1088248166370832385
  25. 		, '2019-01-14 09:48:16');
  1.     <dependency>
  2.       <groupId>org.springframework.boot</groupId>
  3.       <artifactId>spring-boot-starter</artifactId>
  4.     </dependency>
  6.     <dependency>
  7.       <groupId>mysql</groupId>
  8.       <artifactId>mysql-connector-java</artifactId>
  9.       <scope>runtime</scope>
  10.     </dependency>
  12.     <dependency>
  13.       <groupId>org.projectlombok</groupId>
  14.       <artifactId>lombok</artifactId>
  15.       <optional>true</optional>
  16.     </dependency>
  18.     <dependency>
  19.       <groupId>org.springframework.boot</groupId>
  20.       <artifactId>spring-boot-starter-test</artifactId>
  21.       <scope>test</scope>
  22.       <exclusions>
  23.         <exclusion>
  24.           <groupId>org.junit.vintage</groupId>
  25.           <artifactId>junit-vintage-engine</artifactId>
  26.         </exclusion>
  27.       </exclusions>
  28.     </dependency>
  30.     <dependency>
  31.       <groupId>com.baomidou</groupId>
  32.       <artifactId>mybatis-plus-boot-starter</artifactId>
  33.       <version>3.4.2</version>
  34.     </dependency>
  36.     <dependency>
  37.       <groupId>junit</groupId>
  38.       <artifactId>junit</artifactId>
  39.       <version>4.13</version>
  40.       <scope>test</scope>
  41.     </dependency>
  1. spring.application.name=MyBatisPlus
  2. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  3. spring.datasource.url=jdbc:mysql://localhost:3306/mp?useSSL=false&serverTimezone=GMT%2B8
  4. spring.datasource.username=root
  5. spring.datasource.password=admin
  1. @Data
  2. public class User{
  3.     /** 主键 */
  4.     private Long id;
  5.     /** 姓名 */
  6.     private String name;
  7.     /** 年龄 */
  8.     private Integer age;
  9.     /** 邮件 */
  10.     private String email;
  11.     /** 直属上级id */
  12.     private Long managerId;
  13.     /** 创建时间 */
  14.     private LocalDateTime createTime;
  15. }
  1. public interface UserMapper extends BaseMapper<User> {
  2. }
  1. @SpringBootApplication
  2. // 注意这里的包扫描路径 要写到mapper所在的包名上
  3. @MapperScan("com.jsc.mybatisplus.mapper")
  4. public class MyBatisPlusApplication {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(MyBatisPlusApplication.class, args);
  8.     }
  10. }
  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. class MyBatisPlusApplicationTests {
  4. 	// 后面会用到,此为创建条件构造器
  5.     private QueryWrapper<User> query = Wrappers.query();
  6.     @Autowired
  7.     private UserMapper userMapper;
  8.      @Test
  9.     void selectAllTest() {
  10.         List<User> users = userMapper.selectList(null);
  11.         Assertions.assertEquals(5,users.size());
  12.         users.forEach(System.out::println);
  13.     }
  15. }
  1. spring.application.name=MyBatisPlus
  2. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  3. spring.datasource.url=jdbc:mysql://localhost:3306/mp?useSSL=false&serverTimezone=GMT%2B8
  4. spring.datasource.username=root
  5. spring.datasource.password=admin
  8. #日志输出配置
  9. logging.level.root=warn
  10. #只想看这个包里的sql日志 trace是最低级别
  11. logging.level.com.jsc.mybatisplus.mapper=trace
  1. 	@Test
  2.     void insertTest() {
  3.         User user = new User();
  4.         user.setName("老金");
  5.         user.setAge(18);
  6.         // 没有email 默认不给插入 没有id 是因为默认雪花id
  7.         user.setManagerId(1087982257332887553L);
  8.         user.setCreateTime(LocalDateTime.now());
  10.         int rows = userMapper.insert(user);
  11.         System.out.println("影响行数: " + rows);
  12.     }
  1. @TableName("表名") //在实体类上,用来当db中表和实体类名不一致时候,指定表
  2. @TableId //在字段上,用来指定对应的主键,当数据库中的主键不是id命名时,实体类也不是id时用
  3. @TableField("字段名") //在实体类上,用来指定对应的字段名
  1. transient //关键字 无法被序列化(存到磁盘)
  1. static //关键字  只有一份 属于类
  1. @TableField(exit=false) //默认是true,数据库中存在
  1. 	@Test
  2.     void selectByIdTest() {
  3.         // 根据id查询
  4.         User user = userMapper.selectById(1382699085670719489L);
  5.         // User(id=1382699085670719489, name=老金, age=18, email=null, managerId=1087982257332887553, createTime=2021-04-15T22:15:26)
  6.         System.out.println(user);
  7.     }
  8. 	@Test
  9.     void selectBatchIdsTest() {
  10.         // 根据id批量查询
  11.         List<Long> ids = Arrays.asList(1382699085670719489L, 1094592041087729666L, 1094590409767661570L);
  12.         List<User> users = userMapper.selectBatchIds(ids);
  13.         users.forEach(System.out::println);
  14.     }
  16.     @Test
  17.     void selectByMapTest() {
  18.         Map<String, Object> map = new HashMap<>();
  19.         // map.put("name", "老金");
  20.         // map的key是数据库中的字段
  21.         map.put("age", 27);
  22.         // WHERE name = ? AND age = ?
  23.         // WHERE age = ?
  24.         List<User> users = userMapper.selectByMap(map);
  25.         System.out.println(users);
  26.     }
  1. 	@Test
  2.     void selectByWrapper0() {
  3.         /*
  4.          * 1、名字中包含雨并且年龄小于40
  5.          * name like '%雨%' and age<40
  6.          * 条件构造器
  7.          */
  9.         query.like("name", "雨").lt("age", 40);
  10.         List<User> users = userMapper.selectList(query);
  11.         users.forEach(System.out::println);
  12.     }
  14.     @Test
  15.     void selectByWrapper1() {
  16.         /*
  17.          * 名字中包含雨年并且龄大于等于20且小于等于40并且email不为空
  18.          * name like '%雨%' and age between 20 and 40 and email is not null
  19.          */
  20.         query.like("name", "雨").between("age", 20, 40).isNotNull("email");
  21.         List<User> users = userMapper.selectList(query);
  22.         users.forEach(System.out::println);
  23.     }
  25.     @Test
  26.     void selectByWrapper2() {
  27.         /*
  28.          * 名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
  29.          *  name like '王%' or age>=25 order by age desc,id asc
  30.          */
  31.         query.like("name", "王").or().ge("age", 18).orderByDesc("age").orderByAsc("id");
  32.         List<User> users = userMapper.selectList(query);
  33.         users.forEach(System.out::println);
  34.     }
  36. 	@Test
  37.     void selectByWrapper3() {
  38.         /*
  39.          * 创建日期为2019年2月14日并且直属上级为名字为王姓 --函数开头用apple拼接sql
  40.          * date_format(create_time,'%Y-%m-%d')='2019-02-14' and manager_id in (select id from user where name like '王%')
  41.          */
  42.         query.apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14")
  43.                 .inSql("manager_id", "select id from user where name like '王%'");
  45.         List<User> users = userMapper.selectList(query);
  46.         users.forEach(System.out::println);
  47.     }
  49. 	@Test
  50.     void selectByWrapper4() {
  51.         /*
  52.          * 名字为王姓并且（年龄小于40或邮箱不为空）
  53.          * name like '王%' and (age<40 or email is not null)
  54.          */
  55.         query.likeRight("name","王").and(qw->qw.lt("age",40 ).or().isNotNull("email"));
  57.         List<User> users = userMapper.selectList(query);
  58.         users.forEach(System.out::println);
  59.     }
  61. 	@Test
  62.     void selectByWrapper5() {
  63.         /*
  64.          * 名字为王姓或者（年龄小于40并且年龄大于20并且邮箱不为空）
  65.          * name like '王%' or (age<40 and age>20 and email is not null)
  66.          */
  67.         query.likeRight("name","王").or(qw->
  68.                 qw.lt("age",40 )
  69.                         .gt("age",20).isNotNull("email"));
  70.         List<User> users = userMapper.selectList(query);
  71.         users.forEach(System.out::println);
  72.     }
  74. 	@Test
  75.     void selectByWrapper6() {
  76.         /*
  77.          * （年龄小于40或邮箱不为空）并且名字为王姓,nested 正常嵌套 不带 AND 或者 OR
  78.          * (age<40 or email is not null) and name like '王%'
  79.          */
  80.         query.nested(qw->
  81.                 qw.lt("age",40).or().isNotNull("email")).likeRight("name","王");
  82.         List<User> users = userMapper.selectList(query);
  83.         users.forEach(System.out::println);
  84.     }
  86. 	@Test
  87.     void selectByWrapper7() {
  88.         /*
  89.          * 年龄为30、31、34、35
  90.          *   age in (30、31、34、35)
  91.          */
  92.         query.in("age",18,30,31,34,35);
  93.         List<User> users = userMapper.selectList(query);
  94.         users.forEach(System.out::println);
  95.     }
  97.     
  1. 	@Test
  2.     void selectByWrapper8() {
  3.         /*
  4.          * 10、名字中包含雨并且年龄小于40(需求1加强版)
  5.                     第一种情况：  select id,name -- 就用select("")
  6. 	                            from user
  7. 	                            where name like '%雨%' and age<40
  8.                     第二种情况：  select id,name,age,email
  9. 	                            from user
  10. 	                            where name like '%雨%' and age<40
  11.          */
  13.         query.like("name","雨").lt("age",40).select("name","age");
  14.         List<User> users = userMapper.selectList(query);
  15.         users.forEach(System.out::println);
  16.     }
  18.  	@Test
  19.     void selectByWrapper9() {
  20.         /*
  21.          * 10、名字中包含雨并且年龄小于40(需求1加强版)
  22.                     第一种情况：  select id,name -- 就用select("")
  23. 	                            from user
  24. 	                            where name like '%雨%' and age<40
  25.                     第二种情况：  select id,name,age,email -- 就用select("")
  26. 	                            from user
  27. 	                            where name like '%雨%' and age<40
  28.          */
  30.         query.like("name","雨").lt("age",40).select(User.class,info ->
  31.                 !info.getColumn().equals("create_time")
  32.                         &&!info.getColumn().equals("manager_id"));
  33.         List<User> users = userMapper.selectList(query);
  34.         users.forEach(System.out::println);
  35.     }
  1. @Test
  2.     void selectByCondition() {
  3.         // 根据参数条件查询
  4.         // String name = "金";
  5.         String name = "玉";
  6.         String age = "18";
  7.         // 如果不为空,就有后面的条件加入到sql中
  8.         query.like(StringUtils.isNotBlank(name),"name",name)
  9.                 .eq(StringUtils.isNotBlank(age),"age",age);
  10.         List<User> users = userMapper.selectList(query);
  11.         users.forEach(System.out::println);
  12.     }
  1.  	@Test
  2.     void selectByWrapperEntity() {
  3.         /*
  4.          * 使用场景:
  5.          *  1、通过实体传过来数据
  6.          *  2.不想永理科这样的构造器,默认是等值的
  7.          *          如果不想等值,在实体类中加上注解
  8.          *          @TableField(condition=SqlCondition.like)
  9.          *                     小于的话就是="%s&lt;#{%s}"
  10.          *                                 列名<列值
  11.          */
  12.         User whereUser = new User();
  13.         whereUser.setName("老金");
  14.         whereUser.setAge(18);
  15.         query = Wrappers.query(whereUser);
  16.         // query.like("name", "雨").lt("age", 40);
  17.         List<User> users = userMapper.selectList(query);
  18.         users.forEach(System.out::println);
  19.     }
  1. @Test
  2.     void selectByWrapperAllEq() {
  3.         HashMap<String, Object> params = new HashMap<>();
  4.         params.put("name", "王天风");
  5.         params.put("age", null);
  6. 		
  7.         // 后面的false,是忽略null值的列
  8.         // query.allEq(params,false);
  9.         // 前面一个函数是过滤用的  比如这里就是不包含age列
  10.         query.allEq((k,v)->!"age".equals(k),params);
  11.         List<User> users = userMapper.selectList(query);
  12.         users.forEach(System.out::println);
  13.     }
  1.     @Test
  2.     void selectByWrapperMaps() {
  3.         /*
  4.         * 使用场景:
  5.         *  1.当表特别的多色时候只要查少数 几列,返回一个map,而不是属性大部分都为空的实体
  6.         *  2.返回的是统计结果
  7.         *       按照直属上级分组，查询每组的 平均年龄、最小龄、最大年龄。
  8.         *           并且只取年龄总和小于500的组。
  9.         *               select
  10.         *                   avg(age) avg_age,
  11.         *                   min(age) min_age,
  12.         *                   max(age) max_age
  13.         *               from user
  14.         *               group by manager_id --上级id分组
  15.         *               having sum(age) <500 --只有总和小于500
  16.         * */
  17.         // 第一种情况
  18.         // query.like("name","雨").lt("age",40).select("id","name");
  20.         // 第二种情况
  21.         query.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
  22.                 .groupBy("manager_id")
  23.                 .having("sum(age) < {0}",500);
  24.         List<Map<String, Object>> users = userMapper.selectMaps(query);
  25.         users.forEach(System.out::println);
  26.     }
  28.     @Test
  29.     void selectByWrapperObjs() {
  30.         query.select("id","name").like("name","雨").lt("age",40);
  31.         // 返回第一列的值 只返回一列的时候用
  32.         List<Object> users = userMapper.selectObjs(query);
  33.         users.forEach(System.out::println);
  34.     }
  36. 	@Test
  37.     void selectByWrapperCounts() {
  38.         // 不能设置查询的列名了
  39.         query.like("name","雨").lt("age",40);
  40.         // 查总记录数
  41.         Integer count = userMapper.selectCount(query);
  42.         System.out.println(count);
  43.     }
  45.     @Test
  46.     void selectByWrapperOne() {
  47.         // 不能设置查询的列名了
  48.         query.like("name","老金").lt("age",40);
  49.         // 只返回一条数据
  50.         User user = userMapper.selectOne(query);
  51.         System.out.println(user);
  52.     }
  1.     @Test
  2.     void selectLambda() {
  3.         // 创建方式
  4.         // QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
  5.         // LambdaQueryWrapper<User> userLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
  6.         LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
  8.         // 好处: 防止误写字段名
  9.         
  10.         // where name like '%雨%' and age<40
  11.         // 前面是类名 后面是get方法,表示属性
  12.         lambdaQueryWrapper.like(User::getName, "雨").lt(User::getAge, 40);
  14.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
  15.         users.forEach(System.out::println);
  16.     }
  18.     @Test
  19.     void selectLambda1() {
  20.         /*
  21.          * 名字为王姓并且（年龄小于40或邮箱不为空）
  22.          * name like '王%' and (age<40 or email is not null)
  23.          */
  24.         LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
  25.         // 好处: 防止误写字段名
  26.         // 前面是类名 后面是get方法,表示属性
  27.         lambdaQueryWrapper.likeRight(User::getName,"王").and(lqw->lqw.lt(User::getAge,40).or().isNotNull(User::getEmail));
  29.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
  30.         users.forEach(System.out::println);
  31.     }
  33. 	@Test
  34.     void selectLambda2() {
  35.         /*
  36.          * 名字为王姓并且（年龄小于40或邮箱不为空）
  37.          * name like '王%' and (age<40 or email is not null)
  38.          */
  39.         // 3.0.7新增创建方式
  40.         List<User> users = new LambdaQueryChainWrapper<>(userMapper)
  41.                 .like(User::getName, "雨").ge(User::getAge, 20).list();
  43.         users.forEach(System.out::println);
  44.     }
  1. public interface UserMapper extends BaseMapper<User> {
  2.     // 参数的注解是固定的 ew 就是WRAPPER的值
  3.     @Select("select * from user ${ew.customSqlSegment}")
  4.     List<User> selectAll(@Param(Constants.WRAPPER) Wrapper<User> wrapper);
  5. }
  1.  	@Test
  2.     void selectAllCustomize() {
  3.         // 自定义的方法
  5.         LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
  6.         lambdaQueryWrapper.likeRight(User::getName,"王").and(lqw->lqw.lt(User::getAge,40).or().isNotNull(User::getEmail));
  7.         List<User> users = userMapper.selectAll(lambdaQueryWrapper);
  8.         users.forEach(System.out::println);
  9.     }

在配置文件中配置接口对应的mapper文件

  1. #设置扫描路径
  2. mybatis-plus.mapper-locations=mapper/*.xml

省略图

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper
  3. 	PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <mapper namespace="com.jsc.mybatisplus.mapper.UserMapper">
  5.   <select id="selectAll" resultType="com.jsc.mybatisplus.entity.User">
  6. <!--     参数的注解是固定的 ew 就是WRAPPER的值-->
  7.     select * from user ${ew.customSqlSegment}
  8.   </select>
  9. </mapper>

接口中的sql注解就不用了

首先明确一点,mybatis分页rowbounds确实实现了分页,但是是逻辑分页/内存分页,他先把数据全查出来,load到memory中,然后给你你想要的,换句话说,是海选…你懂我意思吧…可想而知,数据爆炸的时代,你得给多大的内存,内存不要钱吗,海选可贵,选择又多,多了换一批时间就 慢 ,一个道理~

Mp就提供了物理分页的插件,解决上述问题

既然是插件,肯定要配置

省略

  1. package com.jsc.mybatisplus.config;
  3. import com.baomidou.mybatisplus.annotation.DbType;
  4. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
  5. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  9. /**
  10.  * mybatis的分页配置
  11.  *
  12.  * @author 金聖聰
  13.  * @version v1.0
  14.  * @email jinshengcong@163.com
  15.  * @date Created in 2021/04/16 15:48
  16.  */
  17. @Configuration
  18. public class MyBatisPlusConfig {
  19.     // 新版废弃
  20.     // @Bean
  21.     // public PaginationInterceptor paginationInterceptor() {
  22.     //     return new PaginationInterceptor();
  23.     // }
  24.     //-------------------------------------------------
  25.     /*
  26.       未测试
  27.       新的分页插件,一缓和二缓遵循mybatis的规则,
  28.       需要设置 MybatisConfiguration#useDeprecatedExecutor = false
  29.       避免缓存出现问题(该属性会在旧插件移除后一同移除)
  30.      */
  31.     /* @Bean
  32.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
  33.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  34.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
  35.         return interceptor;
  36.     }
  38.     @Bean
  39.     public ConfigurationCustomizer configurationCustomizer() {
  40.         return configuration -> configuration.setUseDeprecatedExecutor(false);
  41.     }*/
  42.     //***************************************************
  43.     /**
  44.      * 注册插件
  45.      *  依赖以下版本+
  46.      *      <dependency>
  47.      *         <groupId>com.baomidou</groupId>
  48.      *         <artifactId>mybatis-plus-boot-starter</artifactId>
  49.      *         <version>3.4.1</version>
  50.      *     </dependency>
  51.      * @return com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor 拦截器
  52.      * @author 金聖聰
  53.      * @email jinshengcong@163.com
  54.      * Modification History:
  55.      * Date         Author        Description        version
  56.      *--------------------------------------------------------*
  57.      * 2021/04/16 15:56    金聖聰     修改原因            1.0
  58.      */
  59.     @Bean
  60.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
  61.         // 0.创建一个拦截器
  62.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  64.         // 1. 添加分页插件
  65.         PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor();
  66.         // 2. 设置请求的页面大于最大页后操作，true调回到首页，false继续请求。默认false
  67.         pageInterceptor.setOverflow(false);
  68.         // 3. 单页分页条数限制，默认无限制
  69.         pageInterceptor.setMaxLimit(500L);
  70.         // 4. 设置数据库类型
  71.         pageInterceptor.setDbType(DbType.MYSQL);
  72.         // 5.添加内部拦截器
  73.         interceptor.addInnerInterceptor(pageInterceptor);
  75.         return interceptor;
  76.     }
  77. }
  1. 	@Test
  2.     void selectPage() {
  3.         //分页查询
  4.         /*
  5.          * 1、名字中包含雨并且年龄小于40
  6.          * name like '%雨%' and age<40
  7.          * 条件构造器
  8.          */
  9.         LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
  10.         lambdaQueryWrapper.ge(User::getAge,18);
  12.         // 泛型是实体类 , 当前页数 默认是1，从1开始，不是0。每页最多多少条
  14.         // 第一种用selectPage方法,返回的是 Page<User> userPage
  15.         /*Page<User> page = new Page<>(1, 2);
  16.         Page<User> userPage = userMapper.selectPage(page, lambdaQueryWrapper);
  18.         System.out.println("总页数: "+userPage.getPages());
  19.         System.out.println("总记录数: "+userPage.getTotal());
  20.         userPage.getRecords().forEach(System.out::println);*/
  22.         // 第二种用 selectMapsPage方法,返回的是 IPage<Map<String, Object>>
  23.         // 如果第一个参数还是用的上面的page,此时page胡报错
  24.         // 解决方案:
  25.         //      把page 转成对应的类型IPage<Map<String, Object>>
  26.         //          因为新版后(3.4.1+), 更改了源码 给他设定了具体类型
  27.         IPage<Map<String, Object>> page1 = new Page<>(4, 2);
  28.         IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page1, lambdaQueryWrapper);
  30.         System.out.println("总页数: "+mapIPage.getPages());
  31.         System.out.println("总记录数: "+mapIPage.getTotal());
  32.         List<Map<String, Object>> records = mapIPage.getRecords();
  33.         records.forEach(System.out::println);
  34.     }

实际开发中有的查询是多表联查的,这样就不能用上面的两个方法了,但是不甘心使用传统的写法,,那怎么办?

用xml自定义查询方法

  1. // 自定义分页
  2. IPage<User> selectUserPage(Page<User> page,@Param(Constants.WRAPPER) Wrapper<User> wrapper);
  1. <select id="selectUserPage" resultType="com.jsc.mybatisplus.entity.User">
  2.     <!--     参数的注解是固定的 ew 就是WRAPPER的值-->
  3.     <!--    没有什么改变,但是可以自己多表联查-->
  4.     select *
  5.     from user ${ew.customSqlSegment}
  6.   </select>
  1.     @Test
  2.     void selectPageCustomize() {
  3.         //分页查询
  4.         /*
  5.          * 1、名字中包含雨并且年龄小于40
  6.          * name like '%雨%' and age<40
  7.          * 条件构造器
  8.          */
  9.         LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
  10.         lambdaQueryWrapper.ge(User::getAge,18);
  12.         // 泛型是实体类 , 当前页数 默认是1，从1开始，不是0。每页最多多少条
  14.         // 第一种用selectPage方法,返回的是 Page<User> userPage
  15.         Page<User> page = new Page<>(1, 2);
  16.         IPage<User> userIPage = userMapper.selectUserPage(page, lambdaQueryWrapper);
  18.         System.out.println("总页数: "+userIPage.getPages());
  19.         System.out.println("总记录数: "+userIPage.getTotal());
  20.         userIPage.getRecords().forEach(System.out::println);
  21.     }
  1. 	@Test
  2.     void UpdateById() {
  3.         User user = new User();
  4.         user.setId(1382713714941648898L);
  5.         user.setName("小陈");
  6.         int i = userMapper.updateById(user);
  7.         System.out.println("影响记录数: "+i);
  8.     }
  1. 	private UpdateWrapper<User> update = Wrappers.update();
  3. 	@Test
  4.     void UpdateByWrapper() {
  5.         User user = new User();
  6.         // user.setId(1382713714941648898L);
  7.         user.setName("小金");
  9.         update.eq("name","老金");
  10.         int i = userMapper.update(user,update);
  11.         System.out.println("影响记录数: "+i);
  12.     }
  14.  	@Test
  15.     void UpdateByWrapper1() {
  16.         User whereUser = new User();
  17.         // user.setId(1382713714941648898L);
  18.         whereUser.setName("小金");
  19.         // 可以直接把实体传进去
  20.         update = new UpdateWrapper<>(whereUser);
  21.         update.eq("age",18);
  23.         User user = new User();
  24.         user.setAge(21);
  25.         int i = userMapper.update(user,update);
  26.         System.out.println("影响记录数: "+i);
  27.     }
  1. 	@Test
  2.     void UpdateByWrapper2() {
  3.         // 不创建实体传入,直接在条件中set
  4.         update.eq("name","小金").set("name","老金");
  6.         int i = userMapper.update(null,update);
  7.         System.out.println("影响记录数: "+i);
  8.     }
  1. 	@Test
  2.     void UpdateByLambda() {
  3.         LambdaUpdateWrapper<User> updateLambda = Wrappers.lambdaUpdate();
  4.         updateLambda.eq(User::getName,"老金").set(User::getName,"小金");
  5.         int i = userMapper.update(null,updateLambda);
  6.         System.out.println("影响记录数: "+i);
  7.     }
  8. 	
  9. 	@Test
  10.     void UpdateByLambdaChain() {
  11.         // 链式调用
  12.         boolean update = new LambdaUpdateChainWrapper<User>(userMapper).eq(User::getName, "小金").set(User::getName, "老金").update();
  13.         System.out.println(update?"成功":"失败");
  14.     }
  1.     @Test
  2.     void deleteById() {
  3.         int i = userMapper.deleteById(1382699085670719489L);
  4.         System.out.println("影响行数: "+ i);
  5.     }
  1.     @Test
  2.     void deleteByMap() {
  3.         Map<String, Object> columnMap = new HashMap<>();
  4.         columnMap.put("name","小金");
  5.         columnMap.put("age","18");
  6.         // WHERE name = ? AND age = ?
  7.         int i = userMapper.deleteByMap(columnMap);
  9.         System.out.println("影响行数: "+ i);
  10.     }
  12.     @Test
  13.     void deleteByBatchIds() {
  14.         List<Long> longs = Arrays.asList(1383035889074692097L, 1383035840634646530L);
  15.         int i = userMapper.deleteBatchIds(longs);
  16.         // WHERE id IN ( ? , ? )
  17.         // 根据id批量删除
  18.         System.out.println("影响行数: " + i);
  19.     }
  1.    @Test
  2.     void deleteByWrapper() {
  3.         LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
  4.         lambdaQuery.eq(User::getId, "1383037094597267457");
  5.         int delete = userMapper.delete(lambdaQuery);
  6.         System.out.println("影响行数: " + delete);
  7.     }

活动记录,是一个领域模型模式,

​ 一个模型类对应数据库中的一个表

​ 模型类的一个实例对应表中的一个记录

简单来说就是通过实体类对象对表进行增删改查操作,方便开发人员的开发

用lombok的@Data后,继承别的类后会有个警告,用注解@EqualsAndHashCode(callSuper=false)可以消除警告,再添加一个系列化id

““@EqualsAndHashCode(callSuper=false)“就是不调用父类,

但是,别的时候 大部分需要父类的一些属性作为等值比较的

  1. @Data
  2. @EqualsAndHashCode(callSuper = false)
  3. public class User extends Model<User> {
  4.     private static final long serialVersionUID = 7589930312778081895L;
  5.     /** 主键 */
  6.     private Long id;
  7.     /** 姓名 */
  8.     private String name;
  9.     /** 年龄 */
  10.     private Integer age;
  11.     /** 邮件 */
  12.     private String email;
  13.     /** 直属上级id */
  14.     private Long managerId;
  15.     /** 创建时间 */
  16.     private LocalDateTime createTime;
  17. }
  1.     @Test
  2.     void ARInsertTest() {
  3.         User user = new User();
  4.         user.setName("xx");
  5.         user.setAge(0);
  6.         user.setManagerId(1088248166370832385L);
  7.         user.setCreateTime(LocalDateTime.now());
  9.         // 直接insert,自己插自己可还行
  10.         boolean insert = user.insert();
  11.         System.out.println(insert?"成功":"失败");
  12.     }
  14.     @Test
  15.     void ARSelectByIdTest1() {
  16.         // 不需要参数,直接实体上设置
  17.         // 直接查,自己查自己可还行
  18.         User user = new User();
  19.         user.setId(1383044106274050049L);
  21.         User user1 = user.selectById();
  22.         System.out.println(user1);
  23.     }
  24. // 查出来的都是新的对象,并没有把值设置到原来的对象上
  26.     @Test
  27.     void ARUpdateTest() {
  28.         User user = new User();
  29.         user.setId(1383044106274050049L);
  30.         user.setName("xxoo");
  31.         user.setAge(16);
  32.         user.setManagerId(1383035808669888513L);
  33.         user.setCreateTime(LocalDateTime.now());
  35.         // 自己操作
  36.         boolean b = user.updateById();
  37.         System.out.println(b?"success":"fail");
  39.     }
  41.     @Test
  42.     void ARDeleteTest() {
  43.         User user = new User();
  44.         user.setId(1383044106274050049L);
  46.         // 自己操作
  47.         boolean b = user.deleteById();
  48.         System.out.println(b?"success":"fail");
  50.     }

通过在实体类上id的注解@TableId(type=IdType.XXX)设置

值 值
AUTO 数据库ID自增
NONE 无状态,该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
INPUT insert前自行set主键值
ASSIGN_ID 分配ID(主键类型为Number(Long和Integer)或String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为
DefaultIdentifierGenerator雪花算法)
ASSIGN_UUID 分配UUID,主键类型为String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认default方法)
ID_WORKER 分布式全局唯一ID 长整型类型 (please use ASSIGN_ID)
UUID 32位UUID字符串 (please use ASSIGN_UUID)
ID_WORKER_STR 分布式全局唯一ID 字符串类型 (please use ASSIGN_ID)

在配置文件中设置

  1. mybatis-plus.global-config.db-config.id-type=uuid

如果局部策略和全局策略都设置了 ,就近原则

基本的在官网,这里不做过多记录

https://mybatis.plus/config/#基本配置

https://mybatis.plus/config/#configuration

mapUnderscoreToCamelCase这个配置不能和configLocation一起出现,会报错

字段验证策略可以看一下~

不过一般都是默认的NOT_NULL

not_empty (字段为””)也是忽略

ignored 就是空的也插入 但是有风险 在更新的时候

但是在实体类中,

个别的,可以在字段上配置@TableField(stragegy=FieldStrategy.NOT_EMPTY),就是字段为””的时候也忽略

同样的就近原则

mybatis-plus.global-config.db-config.table-prefix=

  1. 新建service包

  2. 新建接口UserService

  3. 继承IService<T> 泛型写所对应的实体类

  4. 创建service的实现包impl

  5. 创建UserServiceImp

  6. 继承ServiceImpl<UserMapper, User> 第一个蚕食数索要操作的mapper接口,第二个参数是对应的实体类

  7. 实现刚才的接口UserService,并给上@Service的注解

    UserService.java

    1. public interface UserService extends IService<User> {
    2. }

    ServiceImpl.java

    1. @Service
    2. public class UserServiceImp extends ServiceImpl<UserMapper, User> implements UserService{
    3. }
  1.     @Autowired
  2.     private UserService userService;
  4.     @Test
  5.     public void testService() {
  6.         User one = userService.getOne(Wrappers.<User>lambdaQuery().gt(User::getAge,25),false);
  7.         System.out.println(one);
  8.     }
  1.     @Test
  2.     public void batchTest() {
  3.         // 批量
  4.         User user = new User();
  5.         user.setName("犀利");
  6.         user.setAge(12);
  8.         User user1 = new User();
  9.         user1.setName("犀利1");
  10.         user1.setAge(121);
  12.         List<User> users = Arrays.asList(user1, user);
  13.         userService.saveBatch(users);
  14.     }
  1. 	@Test
  2.     public void chainTest() {
  3.         // 查大于25的
  4.         List<User> list = userService.lambdaQuery().gt(User::getAge, 25).list();
  5.         list.forEach(System.out::println);
  6.     }
  8.     @Test
  9.     public void chainTest1() {
  10.         // 更新
  11.         boolean update = userService.lambdaUpdate().eq(User::getName, "小陈").set(User::getName, "小玉").update();
  12.         System.out.println(update?"success":"fail");
  13.     }
  15.     @Test
  16.     public void chainTest2() {
  17.         // 直接删除
  18.         boolean update = userService.lambdaUpdate().eq(User::getName, "xx").remove();
  19.         System.out.println(update?"success":"fail");
  20.     }

版权声明：本文为jsccc520原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jsccc520/p/14669347.html