spring boot备忘录-MyBatis Plus

最新推荐文章于 2023-04-26 14:22:04 发布

韩zj

最新推荐文章于 2023-04-26 14:22:04 发布

阅读量289

点赞数

本文链接：https://blog.csdn.net/jifashihan/article/details/108241124

版权

spring boot 专栏收录该内容

27 篇文章 4 订阅

订阅专栏

简介

spring boot持久性框架，目前有mybatis，mybatis-plus，jpa，mybatis比较接近原生sql，需要较强的sql功底，jpa是对hibernate的封装，满足比较常用的增删改查。mybatis-plus是mybatis的增强，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。如果业务较强的项目，即逻辑繁琐，数据操作较多的项目，建议使用mybatis或mybatis-plus，因为jpa对于复杂查询不友好，不复杂的业务比如登陆权限控制这些可以用jpa的，项目中可以没有一句sql。
官网
 参考教程

入门

引入依赖。可以在中引入Lombok，减少很多重复代码的书写。比如说getter/setter/toString等方法的编写
Lombok使用

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </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>

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

    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

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

配置数据库
在application.properties配置，mysql5和mysql8以上写法有些不同
mysql5

#mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus
spring.datasource.username=root
spring.datasource.password=123456

mysql8以上

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

编码
启动Application上添加@MapperScan 注解，扫描 Mapper 文件夹

@SpringBootApplication
@MapperScan("com.mybatisplus.mapper")
public class MybatisPlusApplication {
	......
}

创建entity ，使用Lombok简化代码

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

编写Mapper接口

public interface UserMapper extends BaseMapper<User> {
    
}

使用：

  @Autowired
    private UserMapper userMapper;
    ...
     //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
		 List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);

配置日志

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

CRUD

insert

User user = new User();
        user.setName("Helen");
        user.setAge(18);
        user.setEmail("11111111@qq.com");

        int result = userMapper.insert(user);
        System.out.println(result); //影响的行数

主键策略
MyBatis-Plus默认的主键策略是：ID_WORKER 全局唯一ID
另外还有
自增策略：需要在创建数据表的时候设置主键自增，实体字段中配置 @TableId(type = IdType.AUTO)

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

可以全局配置，影响所有实体

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

分布式系统唯一ID生成方案汇总
update

 User user = new User();
        user.setId(1L);
        user.setAge(28);

        int result = userMapper.updateById(user);
        System.out.println(result);

自动填充
对创建时间和更新时间，设定自动填充，不需要手动设置

@TableField(fill = FieldFill.INSERT)
    private Date createTime;

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

实现元对象处理器接口

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);

    @Override
    public void insertFill(MetaObject metaObject) {
        LOGGER.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        LOGGER.info("start update fill ....");
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

乐观锁
当要更新一条记录的时候，希望这条记录没有被别人更新，这时候可以使用一个字段来标记，如果有人修改了记录，修改这个字段，其他人在修改之前，判断是否和刚开始获取到的值一致，如果不一致，就说明已经被修改，不再进行修改
取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败
Entity增加一个version

@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;

元对象处理器接口添加version的insert默认值

@Override
public void insertFill(MetaObject metaObject) {
    ......
    this.setFieldValByName("version", 1, metaObject);
}

支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime
整数类型下 newVersion = oldVersion + 1
newVersion 会回写到 entity 中
仅支持 updateById(id) 与 update(entity, wrapper) 方法
在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

创建配置类MybatisPlusConfig

@EnableTransactionManagement
@Configuration
@MapperScan("com.mybatis_plus.mapper")
public class MybatisPlusConfig {

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

select

单个查询

User user = userMapper.selectById(1L);

批量查询

 List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));

简单的条件查询

 HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Helen");
    map.put("age", 18);
    List<User> users = userMapper.selectByMap(map);

map中的key对应的是数据库中的列名。例如数据库user_id，实体类是userId，这时map的key需要填写user_id
分页
在配置类MybatisPlusConfig 中添加

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

使用

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

对应sql实现：
SELECT id,name,age,email,create_time,update_time FROM user LIMIT 0,5

Page<User> page = new Page<>(1, 5);

    IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);

    //注意：使用 mapIPage 获取记录列表，否则会有数据类型转换错误
    mapIPage.getRecords().forEach(System.out::println);

delete

 int result = userMapper.deleteById(8L);

批量删除

 int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));

条件删除

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

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

逻辑删除
逻辑删除是通过定义一个字段，作为是否启用的标识，删除的时候，设置成1，查询的时候，查询该字段为0的记录，相当于删除了，并不是真正从数据库删除掉
Entity加入字段

@TableLogic
@TableField(fill = FieldFill.INSERT)
private Integer deleted;

元对象处理器接口添加deleted的insert默认值

@Override
public void insertFill(MetaObject metaObject) {
    ......
    this.setFieldValByName("deleted", 0, metaObject);
}

application.properties 配置

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

配置类MybatisPlusConfig 中配置

@Bean
public ISqlInjector sqlInjector() {
    return new LogicSqlInjector();
}

MyBatis Plus中查询操作也会自动添加逻辑删除字段的判断，

/**
 * 测试 逻辑删除后的查询：
 * 不包括被逻辑删除的记录
 */
@Test
public void testLogicDeleteSelect() {
    User user = new User();
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}

相当于
SELECT id,name,age,email,create_time,update_time,deleted FROM user WHERE deleted=0

性能分析

性能分析拦截器，用于输出每条 SQL 语句及其执行时间
SQL 性能执行分析,开发环境使用，超过指定时间，停止运行。有助于发现问题
配置
在MybatisPlusConfig 配置

//maxTime 指的是 sql 最大执行时长
@Bean
@Profile({"dev","test"})// 设置 dev test 环境开启
public PerformanceInterceptor performanceInterceptor() {
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
    performanceInterceptor.setFormat(true);
    return performanceInterceptor;
}

spring boot配置环境

#环境设置：dev、test、prod
spring.profiles.active=dev

wapper

Wrapper ：条件构造抽象类，用于构造条件，有一些子类
在这里插入图片描述

AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
    UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
    LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
    LambdaUpdateWrapper ： Lambda 更新封装Wrapper

条件构造器
使用例子

 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .isNull("name")
        .ge("age", 12)
        .isNotNull("email");
    int result = userMapper.delete(queryWrapper);

 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "Tom");

    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);

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

    Integer count = userMapper.selectCount(queryWrapper);
    System.out.println(count);

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    Map<String, Object> map = new HashMap<>();
    map.put("id", 2);
    map.put("name", "Jack");
    map.put("age", 20);

    queryWrapper.allEq(map);
    List<User> users = userMapper.selectList(queryWrapper);

    users.forEach(System.out::println);

 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .notLike("name", "e")
        .likeRight("email", "t");

    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
    maps.forEach(System.out::println);

in、notIn：
notIn("age",{1,2,3})--->age not in (1,2,3)
notIn("age", 1, 2, 3)--->age not in (1,2,3)
inSql、notinSql：可以实现子查询
例: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)

  QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //queryWrapper.in("id", 1, 2, 3);
    queryWrapper.inSql("id", "select id from user where id < 3");

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

 //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");

    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or()
        .between("age", 20, 30);

    int result = userMapper.update(user, userUpdateWrapper);

 //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");

    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or(i -> i.eq("name", "李白").ne("age", 20));

    int result = userMapper.update(user, userUpdateWrapper);

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

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

last：直接拼接到 sql 的最后，只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.last("limit 1");

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

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

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

 //修改值
    User user = new User();
    user.setAge(99);

    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .set("name", "老李")//除了可以查询还可以使用set设置修改的字段
        .setSql(" email = '123@qq.com'");//可以有子查询

    int result = userMapper.update(user, userUpdateWrapper);