MybatisPlus快速入门-阿里云开发者社区

开发者社区> 【阿里云】云大使推广计划> 正文
登录阅读全文

MybatisPlus快速入门

简介: 本文主要内容:MybatisPlus的使用

MybatisPlus快速入门


一、MybatisPlus简介

MybatisPlus是一个MyBatis的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生

二、快速开始

1、创建数据库 mybatis_plus

2、创建User表

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

3、添加数据

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

4、打开IDEA在pom.xml添加相关依赖

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

    <!--mysql运行时依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!--lombok用来简化实体类-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

5、编写连接数据库的properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

# MybatisPlus日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

6、创建包entity编写User实体类

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

7、创建mapper编写UserMapper文件(MybatisPlus核心持久层接口)

@Repository
public interface UserMapper extends BaseMapper<User> {
    
}

8、在主启动类上添加扫面mapper文件夹(稍后我们会统一放入MybatisPlusConfig文件内)

@SpringBootApplication
@MapperScan("xxx.xxxx.mapper")
public class MybatisPlusApplication {
    ......
}

9、在测试类中完成测试

@SpringBootTest
class MybatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    void testMybatis_QuickStart() {
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

10、在控制台查看输出效果

-

三、插入数据和主键策略

插入数据

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert(){
        User user = new User();
        user.setName("张三");
        user.setAge(18);
        user.setEmail("1746344046@qq.com");

        int result = userMapper.insert(user);
        System.out.println("成功添加的行数:" + result);
        System.out.println("添加用户的id为:" + user.getId());  //id:1272668550292856834 MybatisPlus默认主键策略为雪花算法
    }

主键策略

1、ASSIGN_ID

MyBatis-Plus默认的主键策略是:ASSIGN_ID(使用了雪花算法)

@TableId(type = IdType.ASSIGN_ID)
private Long id;

2、AUTO自增策略

需要在数据库的id字段设置主键自增

@TableId(type = IdType.AUTO)
private Long id;

3、要想影响所有实体的配置,可以设置全局主键配置(properties或yml文件)

# 全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=auto

四、更新数据、自动填充和乐观锁

更新数据

    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(1L);
        user.setName("李四");

        int result = userMapper.updateById(user);
        System.out.println("成功更新的行数:" + result);
    }

自动填充

1、需求:项目中经常会遇到一些数据,每次都使用相同的方式填充,例如记录的创建时间,更新时间等。

2、数据库修改

在User表中添加datetime类型的新的字段 create_time、update_time

3、实体类修改

@Data
public class User {
    ......
        
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    //@TableField(fill = FieldFill.UPDATE)
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

4、实现元对象处理器接口

创建handler包编写MyMetaObjectHandler文件

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("开始填充insertFill.......");
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("开始填充updateFill.......");
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

5、测试

    @Test
    public void testAutoInsertFill(){
        User user = new User();
        user.setName("王五");
        user.setAge(20);
        user.setEmail("1746344046@qq.com");

        int result = userMapper.insert(user);
        System.out.println("成功添加的行数:" + result);  //2020-06-16 07:32:57.821(Timestamp), 2020-06-16 07:32:57.821(Timestamp)
    }

乐观锁

1、场景:

一件商品,成本价是80元,售价是100元。老板先是通知小李,说你去把商品价格增加50元。小李正在玩游戏,耽搁了一个小时。正好一个小时后,老板觉得商品价格增加到150元,价格太高,可能会影响销量。又通知小王,你把商品价格降低30元

此时,小李和小王同时操作商品后台系统。小李操作的时候,系统先取出商品价格100元;小王也在操作,取出的商品价格也是100元。小李将价格加了50元,并将100+50=150元存入了数据库;小王将商品减了30元,并将100-30=70元存入了数据库。是的,如果没有锁,小李的操作就完全被小王的覆盖了

现在商品价格是70元,比成本价低10元。几分钟后,这个商品很快出售了1千多件商品,老板亏1万多

2、乐观锁与悲观锁

  • 上面的故事,如果是乐观锁,小王保存价格前,会检查下价格是否被人修改过了。如果被修改过了,则重新取出的被修改后的价格,150元,这样他会将120元存入数据库
  • 如果是悲观锁,小李取出数据后,小王只能等小李操作完之后,才能对价格进行操作,也会保证最终的价格是120元

3、模拟上述场景

  • 数据库中增加商品表

    CREATE TABLE product
    (
        id BIGINT(20) NOT NULL COMMENT '主键ID',
        name VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
        price INT(11) DEFAULT 0 COMMENT '价格',
        version INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
        PRIMARY KEY (id)
    );
  • 添加数据

    INSERT INTO product (id, NAME, price) VALUES (1, 'RTX3080', 100);
  • 编写实体类

    @Data
    public class Product {
        private Long id;
        private String name;
        private Integer price;
        private Integer version;
    }
  • 编写ProductMapper

    @Repository
    public interface ProductMapper extends BaseMapper<Product> {
        
    }
  • 测试

        @Autowired
        private ProductMapper productMapper;
    
        @Test
        public void testNoLockCurrentUpdate(){
            //1、小李
            Product p1 = productMapper.selectById(1L);
            System.out.println("小李取出的价格:" + p1.getPrice());
    
            //2、小王
            Product p2 = productMapper.selectById(1L);
            System.out.println("小王取出的价格:" + p2.getPrice());
    
            //3、小李将价格加了50元,存入了数据库
            p1.setPrice(p1.getPrice() + 50);
            productMapper.updateById(p1);
    
            //4、小王将商品减了30元,存入了数据库
            p2.setPrice(p2.getPrice() - 30);
            int result = productMapper.updateById(p2);
            if(result == 0){//更新失败,重试
                //重新获取数据
                p2 = productMapper.selectById(1L);
                //更新
                p2.setPrice(p2.getPrice() - 30);
                productMapper.updateById(p2);
            }
    
            //5、最后的结果
            Product p3 = productMapper.selectById(1L);
            System.out.println("最后的结果:" + p3.getPrice());  //最后的结果:70
        }

4、使用MybatisPlus的乐观苏解决问题

  • 数据库中添加version字段
  • 修改实体类

    @Version
    private Integer version;
  • 创建配置文件

    • 创建config包,创建文件MybatisPlusConfig.java
    • 此时可以删除主启动类中的@MapperScan扫描注解
    @EnableTransactionManagement
    @Configuration
    @MapperScan("xxxx.xxxx.mapper")
    public class MybatisPlusConfig {
        
    }
  • 编写乐观锁插件

        /**
         * 乐观锁插件
         */
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() {
            return new OptimisticLockerInterceptor();
        }
  • 测试

        @Autowired
        private ProductMapper productMapper;
    
        @Test
        public void testNoLockCurrentUpdate(){
            //1、小李
            Product p1 = productMapper.selectById(1L);
            System.out.println("小李取出的价格:" + p1.getPrice());
    
            //2、小王
            Product p2 = productMapper.selectById(1L);
            System.out.println("小王取出的价格:" + p2.getPrice());
    
            //3、小李将价格加了50元,存入了数据库
            p1.setPrice(p1.getPrice() + 50);
            productMapper.updateById(p1);
    
            //4、小王将商品减了30元,存入了数据库
            p2.setPrice(p2.getPrice() - 30);
            int result = productMapper.updateById(p2);
            if(result == 0){//更新失败,重试
                //重新获取数据
                p2 = productMapper.selectById(1L);
                //更新
                p2.setPrice(p2.getPrice() - 30);
                productMapper.updateById(p2);
            }
    
            //5、最后的结果
            Product p3 = productMapper.selectById(1L);
            System.out.println("最后的结果:" + p3.getPrice());  //最后的结果:120
        }
  • 总结:当我们使用了乐观锁后,如果出现了多个人同时修改同一数据的情况,那么所有人在拿到数据的同时也获取了乐观锁的版本号,当第一个人修改完毕后,乐观锁就会版本号+1,那么当其他人提交数据时由于版本号不对应的关系,所以数据就会提交失败

五、查询数据和分页插件

查询数据

1、通过多个id批量查询

    @Test
    public void testSelectByBatchIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

2、通过map封装完成简单条件查询

    @Test
    public void testSelectByMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("age", 18);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

分页插件

1、在MybatisPlusConfig添加组件

/**
 * 分页插件
 */
@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}

2、测试

    @Test
    public void testSelectPage() {

        Page<User> page = new Page<>(1,5);
        Page<User> pageParam = userMapper.selectPage(page, null);

        pageParam.getRecords().forEach(System.out::println);
        System.out.println(pageParam.getCurrent());  // 获取当前是第几页
        System.out.println(pageParam.getPages());    // 获取一共的页数
        System.out.println(pageParam.getSize());     // 获取每一页的个数
        System.out.println(pageParam.getTotal());    // 获取总记录条数
        System.out.println(pageParam.hasNext());     // 判断是否还有下一页
        System.out.println(pageParam.hasPrevious()); // 判断是否还有前一页
    }

3、通过QueryWrapper完成条件查询

    @Test
    public void testSelectMapsPage() {
        Page<Map<String, Object>> page = new Page<>(1, 5);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name", "age");   // 表示查询结果只显示name和age列
        Page<Map<String, Object>> pageParam = userMapper.selectMapsPage(page, queryWrapper);

        List<Map<String, Object>> records = pageParam.getRecords();
        records.forEach(System.out::println);
    }

六、删除数据与逻辑删除

删除数据

1、根据id删除数据

@Test
public void testDeleteById(){

    int result = userMapper.deleteById(5L);
    System.out.println(result);
}

2、批量删除数据

@Test
public void testDeleteBatchIds() {

    int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
    System.out.println(result);
}

3、根据map封装完成删除

@Test
public void testDeleteByMap() {

    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "张三");
    map.put("age", 18);

    int result = userMapper.deleteByMap(map);
    System.out.println(result);
}

逻辑删除

1、修改数据库字段

ALTER TABLE `user` ADD COLUMN `deleted` tinyint DEFAULT false

2、修改实体类

@TableLogic
private Integer deleted;

3、测试

    @Test
    public void testLogicDelete(){
        int result = userMapper.deleteById(1L);  //此时的删除只是把deleted字段变成1
        System.out.println(result);
    }

七、条件构造器和常用接口

案例一:

    @Test
    public void testDelete() { //删除名字为空年龄大于12且邮箱不为空的用户(这里SQL为UPODATE因为逻辑删除原因)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("name").ge("age", 12).isNotNull("email");
        int result = userMapper.delete(queryWrapper); // UPDATE user SET deleted=1 WHERE deleted=0 AND (name IS NULL AND age >= ? AND email IS NOT NULL)
        System.out.println("delete return count = " + result);
    }

案例二:

    @Test
    public void testSelectObjs() { // 查询id in (select id from user where id <= 3)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("id", "select id from user where id <= 3");

        List<Object> objects = userMapper.selectObjs(queryWrapper);  //返回值是Object列表
        objects.forEach(System.out::println);
    }

案例三:

@Test
public void testSelectCount() { // 查询age在20-30之间的数量(包含20与30)

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age", 20, 30);

    Integer count = userMapper.selectCount(queryWrapper);  //返回数据数量
    System.out.println(count);
}

案例四:

@Test
public void testSelectListOrderBy() { // 先按照age降序排列,如果age相同按照id降序排列

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("age", "id");

    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

Wrapper的常见查询关键字:

-

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:

阿里云推广返现计划,0门槛、高返佣、技术变现轻松返利,加入我们成为阿里云官方推广大使!

官方博客
官网链接