MyBatis_Plus(Spring版本笔记)

前言
一、MyBatis-Plus简介
- 1.1 简介
- 1.2 特性
- 1.3 支持数据库
- 1.4 框架结构
- 1.5 代码及文档地址
二、入门案例
- 2.1 开发环境
- 2.2 创建数据库和表
- - 2.2.1 创建表
  - 2.2.2 添加数据
- 2.3 创建maven工程
- - 2.3.1 打包方式 jar
  - 2.3.2 引入依赖
- 2.4 Spring整合MyBatis
- 2.5 加入MyBatis-Plus
- 2.6 总结
三、基本CRUD
- 3.1 BaseMapper
- 3.2 BaseMapper功能测试
- 3.3 通用Service
四、常用注解
- 4.1 @TableName
- 4.2 @TableId
- 4.3 @TableField
- 4.4 @TableLogic（逻辑删除）
- - 4.4.1 逻辑删除
  - 4.4.2 实现逻辑删除
五、条件构造器和常用接口
- 5.1 wapper介绍
- 5.2 QueryWrapper
- 5.3 UpdateWrapper
- 5.4 condition
- 5.5 LambdaQueryWrapper
- 5.6 LambdaUpdateWrapper
六、插件
- 6.1 分页插件
- - 6.1.1 添加配置
  - 6.1.2 测试
- 6.2 xml自定义分页
- 6.3 乐观锁
七、通用枚举
- 7.1 数据库添加字段sex
- 7.2 创建通用枚举
- 7.3 配置扫描通用枚举
- 7.4 测试
八、代码生成器
- 8.1 引入依赖
- 8.2 快速生成
九、MyBatisX插件
- 9.1 安装插件
- 9.2 功能
- - 9.2.1 XML跳转
  - 9.2.2 快速生成代码
十、总结

前言

本文主要参考哔站尚硅谷杨博超讲师课件整理而成，属于自己复习使用。

提示：以下是本篇文章正文内容，下面案例可供参考

一、MyBatis-Plus简介

1.1 简介

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

愿景
我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

在这里插入图片描述

1.2 特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

1.3 支持数据库

任何能使用MyBatis进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下

MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQLSQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb
达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库

1.4 框架结构

在这里插入图片描述

1.5 代码及文档地址

官方地址:http://mp.baomidou.com
代码发布地址:
Github: https://github.com/baomidou/mybatis-plus
Gitee: https://gitee.com/baomidou/mybatis-plus
文档发布地址:https://baomidou.com/pages/24112f

二、入门案例

2.1 开发环境

以maven工程为例，以ssm整合为技术框架。

工具	版本
IDE	idea 2021.3
JDK	JDK1.8
MAVEN	maven 3.8.4
MySQL	MySQL8.0.25
Spring	5.3.1
MyBatis-Plus	3.4.3.4

2.2 创建数据库和表

2.2.1 创建表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mybatis_plus`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL COMMENT '主键ID',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.2.2 添加数据

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');

2.3 创建maven工程

2.3.1 打包方式 jar

  <packaging>jar</packaging>

2.3.2 引入依赖

  <dependencies>
<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<!-- 连接池 -->

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

<version>1.2.8</version>

</dependency>

<!-- junit测试 -->

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.12</version>

<scope>test</scope>

</dependency>

<!-- MySQL驱动 -->

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>8.0.27</version>

</dependency>

<!-- 日志 -->

<dependency>

<groupId>org.slf4j</groupId>

<artifactId>slf4j-api</artifactId>

<version>1.7.30</version>

</dependency>

<dependency>

<groupId>ch.qos.logback</groupId>

<artifactId>logback-classic</artifactId>

<version>1.2.3</version>

</dependency>

<!-- lombok用来简化实体类 -->

<dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

<version>1.16.16</version>

</dependency>

<!--MyBatis-Plus的核心依赖-->

<dependency>

<groupId>com.baomidou</groupId>

<artifactId>mybatis-plus</artifactId>

<version>3.4.3.4</version>

</dependency>

<dependency>

<groupId>org.junit.jupiter</groupId>

<artifactId>junit-jupiter</artifactId>

<version>RELEASE</version>

<scope>test</scope>

</dependency>
<dependency>

<groupId>com.baomidou</groupId>

<artifactId>mybatis-plus-generator</artifactId>

<version>3.5.1</version>

</dependency>

<dependency>

<groupId>org.freemarker</groupId>

<artifactId>freemarker</artifactId>

<version>2.3.31</version>

</dependency>

</dependencies>
<properties>

<spring.version>5.3.1</spring.version>

</properties>

注意：
Spring整合MyBatis，需要MyBatis以及Spring整合MyBatis的依赖：

但是，在以上的依赖列表中，并没有MyBatis以及Spring整合MyBatis的依赖，因为当我们引入了
MyBatis-Plus的依赖时，就可以间接的引入这些依赖
在这里插入图片描述
并且依赖和依赖之间的版本必须兼容，所以我们不能随便引入其他版本的依赖，以免发生冲突
在官网上有明确提示：

2.4 Spring整合MyBatis

2.4.1 创建实体

public class User {
private Long id;

private String name;

private int age;

private String email;
public User(Long id, String name, int age, String email) {

this.id = id;

this.name = name;

this.age = age;

this.email = email;

}
public User() {

}
public Long getId() {

return this.id;

}
public String getName() {

return this.name;

}
public int getAge() {

return this.age;

}
public String getEmail() {

return this.email;

}
public SexEnum getSex() {

return this.sex;

}
public int getIsDeleted() {

return this.isDeleted;

}
public void setId(Long id) {

this.id = id;

}
public void setName(String name) {

this.name = name;

}
public void setAge(int age) {

this.age = age;

}
public void setEmail(String email) {

this.email = email;

}
public void setSex(SexEnum sex) {

this.sex = sex;

}
public void setIsDeleted(int isDeleted) {

this.isDeleted = isDeleted;

}
public String toString() {

return "User(id=" + this.getId() + ", name=" + this.getName() + ", age=" + this.getAge() + ", email=" + this.getEmail() + ", sex=" + this.getSex() + ", isDeleted=" + this.getIsDeleted() + ")";

}

}

2.4.2 创建MyBatis的核心配置文件

在resources下创建mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

2.4.3 创建mapper接口和映射文件

mapper接口：

public interface TestMapper {
/**
* 查询所有用户信息
* @return
*/
List<User> getAllUser();
}

mapper映射文件：
在resources下的com/atguigu/mp/mapper目录下创建TestMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatisplus.mapper.UserMapper">
<!--SQL片段，记录基础字段-->

<!--<sql id="BaseColumns">id,name,age,email</sql>-->

<!--第一种写法-->

<!--List<User> getAllUser();-->

<select id="getAllUser" resultType="User">

select <include refid="BaseColumns"></include> from user

</select>
<!--第二种写法-->

<!--List<User> getAllUser();-->

<select id="getAllUser" resultType="User">

<!--select <include refid="BaseColumns"></include> from user-->

select id,name,age,email from user

</select>

</mapper>

2.4.4 创建jdbc.properties

在resources下创建jdbc.properties

jdbc.username=root
jdbc.password=5864@WCY
jdbc.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.driver=com.mysql.cj.jdbc.Driver

2.4.5 创建Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 引入jdbc.properties -->

<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!-- 配置Druid数据源 -->

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>

<property name="url" value="${jdbc.url}"></property>

<property name="username" value="${jdbc.username}"></property>

<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置用于创建SqlSessionFactory的工厂bean -->

<bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<!-- 设置MyBatis配置文件的路径（可以不设置） -->

<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<!-- 设置数据源 -->

<property name="dataSource" ref="dataSource"></property>
<!-- 设置类型别名所对应的包 -->

<property name="typeAliasesPackage" value="com.atguigu.mybatisplus.pojo"></property>
<!--

设置映射文件的路径

若映射文件所在路径和mapper接口所在路径一致，则不需要设置

-->

<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>

</bean>
<!--

配置mapper接口的扫描配置

由mybatis-spring提供，可以将指定包下所有的mapper接口创建动态代理

并将这些动态代理作为IOC容器的bean管理

-->

<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">

<property name="basePackage" value="com.atguigu.mybatisplus.mapper"></property>

</bean>
<!--配置自动扫描的包-->

<context:component-scan base-package="com.atguigu.mybatisplus.service"></context:component-scan>

</beans>

2.4.6 添加日志功能

在resources下创建logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!--定义日志文件的存储地址 logs为当前项目的logs目录 还可以设置为../logs -->
    <property name="LOG_HOME" value="logs" />
<!--控制台日志， 控制台输出 -->

<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">

<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符

宽度,%msg：日志消息，%n是换行符-->

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}

- %msg%n</pattern>

</encoder>

</appender>
<!--myibatis log configure-->

<logger name="com.apache.ibatis" level="TRACE"/>

<logger name="java.sql.Connection" level="DEBUG"/>

<logger name="java.sql.Statement" level="DEBUG"/>

<logger name="java.sql.PreparedStatement" level="DEBUG"/>
<!-- 日志输出级别 -->

<root level="DEBUG">

<appender-ref ref="STDOUT" />

</root>
</configuration>

2.4.7 测试

方式一：通过IOC容器

public class MyBatisPlusTest {
	@Test
	public void testMyBatis(){
	ApplicationContext ac = new
	ClassPathXmlApplicationContext("applicationContext.xml");
	TestMapper mapper = ac.getBean(TestMapper.class);
	mapper.getAllUser().forEach(user -> System.out.println(user));
	}
}

方式二 Spring整合junit


//在Spring的环境中进行测试
@RunWith(SpringJUnit4ClassRunner.class)
//指定Spring的配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class MyBatisPlusTest {
	@Autowired
	private TestMapper testMapper;
	@Test
	public void testMyBatisBySpring(){
	testMapper.getAllUser().forEach(user -> System.out.println(user));
	}
}

在这里插入图片描述

2.5 加入MyBatis-Plus

Spring整合MyBatis
在这里插入图片描述
加入MyBatis-Plus之后

<!-- 此处使用的是MybatisSqlSessionFactoryBean -->
<!-- 配置用于创建SqlSessionFactory的工厂bean -->
    <bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<!-- 设置MyBatis配置文件的路径（可以不设置） -->

<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<!-- 设置数据源 -->

<property name="dataSource" ref="dataSource"></property>
<!-- 设置类型别名所对应的包 -->

<property name="typeAliasesPackage" value="com.atguigu.mybatisplus.pojo"></property>
<!--

设置映射文件的路径

若映射文件所在路径和mapper接口所在路径一致，则不需要设置

-->

<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>

</bean>

此处使用的是MybatisSqlSessionFactoryBean
经观察，目前bean中配置的属性和SqlSessionFactoryBean一致
MybatisSqlSessionFactoryBean是在SqlSessionFactoryBean的基础上进行了增强
即具有SqlSessionFactoryBean的基础功能，又具有MyBatis-Plus的扩展配置
具体配置信息地址(https://baomidou.com/pages/56bac0/#%E5%9F%BA%E6%9C%AC%E9%
85%8D%E7%BD%AE)

2.5.1 创建Mapper接口

public interface UserMapper extends BaseMapper<User> {
}

BaseMapper是MyBatis-Plus提供的基础mapper接口，泛型为所操作的实体类型，其中包含CRUD的各个方法，我们的mapper继承了BaseMapper之后，就可以直接使用BaseMapper所提供的各种方法，而不需要编写映射文件以及SQL语句，大大的提高了开发效率

2.5.2 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyBatisPlusTest {
/*

没有使用mybatis_plus

@Test

public void testMyBatis(){

ApplicationContext ac = new

ClassPathXmlApplicationContext("applicationContext.xml");

UserMapper mapper = ac.getBean(UserMapper.class);

mapper.getAllUser().forEach(user -> System.out.println(user));

}
*/

@Autowired

private UserMapper userMapper;
/---------------------------------使用MyBatisPlus之后-------------------------------------/

@Test

public void testMyBatisPlus(){

//查询所有用户信息

// SELECT id,name,age,email FROM user

System.out.println(userMapper.selectList(null));

}

2.5.3 结果

在这里插入图片描述

2.6 总结

在Spring整合MyBatis中加入了MyBatis-Plus后，我们就可以使用MyBatis-Plus所提供的BaseMapper实现CRUD，并不需要编写映射文件以及SQL语句
但是若要自定义SQL语句，仍然可以编写映射文件而不造成任何影响。因为MyBatis-Plus只做增强，而不做改变。

三、基本CRUD

3.1 BaseMapper

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如下：

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * <p>这个 Mapper 支持 id 泛型</p>
 *
 * @author hubin
 * @since 2016-01-23
 */
public interface BaseMapper<T> extends Mapper<T> {
/**

* 插入一条记录

*

* @param entity 实体对象

*/

int insert(T entity);
/**

* 根据 ID 删除

*

* @param id 主键ID

*/

int deleteById(Serializable id);
/**

* 根据实体(ID)删除

*

* @param entity 实体对象

* @since 3.4.4

*/

int deleteById(T entity);
/**

* 根据 columnMap 条件，删除记录

*

* @param columnMap 表字段 map 对象

*/

int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**

* 根据 entity 条件，删除记录

*

* @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

*/

int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 删除（根据ID 批量删除）

*

* @param idList 主键ID列表(不能为 null 以及 empty)

*/

int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**

* 根据 ID 修改

*

* @param entity 实体对象

*/

int updateById(@Param(Constants.ENTITY) T entity);
/**

* 根据 whereEntity 条件，更新记录

*

* @param entity        实体对象 (set 条件值,可以为 null)

* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

*/

int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**

* 根据 ID 查询

*

* @param id 主键ID

*/

T selectById(Serializable id);
/**

* 查询（根据ID 批量查询）

*

* @param idList 主键ID列表(不能为 null 以及 empty)

*/

List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**

* 查询（根据 columnMap 条件）

*

* @param columnMap 表字段 map 对象

*/

List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**

* 根据 entity 条件，查询一条记录

* <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>

*

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {

List<T> ts = this.selectList(queryWrapper);

if (CollectionUtils.isNotEmpty(ts)) {

if (ts.size() != 1) {

throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");

}

return ts.get(0);

}

return null;

}
/**

* 根据 Wrapper 条件，查询总记录数

*

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 根据 entity 条件，查询全部记录

*

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 根据 Wrapper 条件，查询全部记录

*

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 根据 Wrapper 条件，查询全部记录

* <p>注意： 只返回第一个字段的值</p>

*

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 根据 entity 条件，查询全部记录（并翻页）

*

* @param page         分页查询条件（可以为 RowBounds.DEFAULT）

* @param queryWrapper 实体对象封装操作类（可以为 null）

*/

<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**

* 根据 Wrapper 条件，查询全部记录（并翻页）

*

* @param page         分页查询条件

* @param queryWrapper 实体对象封装操作类

*/

<P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

}

3.2 BaseMapper功能测试


 	//插入
    @Test
    public void testInsert(){
	// INSERT INTO user  ( id, name, age, email )  VALUES  ( ?, ?, ?, ? )
        User user = new User(6,"张三",23,"zhangsan@126.com");
int result = userMapper.insert(user);
System.out.println("result="+result);
}
//删除

@Test

public void testDelete(){

//根据Id删除用户

//DELETE FROM user WHERE id=?

int result = userMapper.deleteById(2L);
//根据map集合删除

//DELETE FROM user WHERE name = ? AND age = ?

Map<String,Object> map = new HashMap<>();

map.put("name","张三");

map.put("age",23);

int result = userMapper.deleteByMap(map);
// 根据id批量删除

// DELETE FROM user WHERE id IN ( ? , ? , ? )

List<Integer> list = Arrays.asList(1, 2, 3);
int result = userMapper.deleteBatchIds(list);

System.out.println("result="+result);

}
//修改

@Test

public void testUpdate(){

//        UPDATE user SET name=?, email=? WHERE id=?

User user = new User();

user.setId(4L);

user.setName("李四");

user.setEmail("lisi@atguigu.com");

int result = userMapper.updateById(user);

System.out.println("result="+result);

}
//查询

@Test

public void testSelect(){

//根据Id查询用户

//        SELECT id,name,age,email FROM user WHERE id=?

User user = userMapper.selectById(5L);

System.out.println(user);
//        SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )

List<Integer> list = Arrays.asList(1, 2, 4);

List<User> users = userMapper.selectBatchIds(list);

users.forEach(System.out::println);
Map<String,Object> map = new HashMap<>();

map.put("age",23);

List<User> users = userMapper.selectByMap(map);

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

通过观察BaseMapper中的方法，大多方法中都有Wrapper类型的形参，此为条件构造器，可针对于SQL语句设置不同的条件，若没有条件，则可以为该形参赋值null，即查询（删除/修改）所有数据

3.3 通用Service

说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 , 前缀命名方式区分 Mapper 层避免混淆
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承Mybatis-Plus 提供的基类
官网地址：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

3.3.1 IService

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑
在这里插入图片描述
详情查看源码IService和ServiceImpl

3.3.2 创建Service接口和实现类

UserService

/**
* UserService继承IService模板提供的基础功能
*/
public interface UserService extends IService<User> {
}

UserServiceImpl

/**
* ServiceImpl实现了IService，提供了IService中基础功能的实现
* 若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

3.3.3 在spring配置文件中设置自动扫描service的包

在applicationContext.xml中添加扫描组件的配置，扫描业务层组件，用于测试

<context:component-scan base-package="com.atguigu.mybatisplus.service.impl"></context:component-scan>

3.3.4 测试查询记录条数和批量添加

//spring测试类写法一
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyBatisServiceTest {
@Autowired

private UserService userService;
@Test

public void testCount(){
//查询总记录条数

//SELECT COUNT( * ) FROM user

long count = userService.count();

System.out.println("总记录条数" + count);
}
@Test

public void testSaveBatch(){

//实现新增用户

ArrayList<User> list = new ArrayList<>();
// SQL长度有限制，海量数据插入单条SQL无法实行，

// 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper

for (int i = 0; i < 100 ; i++) {
User user = new User();
user.setName("abc"+i);
user.setAge(20+i);
list.add(user);

}
//INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )

boolean b = userService.saveBatch(list);
System.out.println(b);
}
}

错误：
Duplicate entry ‘0’ for key ‘PRIMARY’
原因：发现了是数据库表设计不合理导致的；
因为主键设置不能为空，因此默认是以"0"来进行填充的。因此在数据插入时数据的主键id值被0占据，但由于之前已经有数据了，id为“0”的索引已经被占，在使用就会报这个错误，因此我们只需要对表中的主键“id”设置成自增即可。

纠正：为什么会出现这个问题，是因为在创建实体类的时候id属性的类型写成long了，应该写成Long，不然雪花算法是不会实现的。大小写要注意。

四、常用注解

4.1 @TableName

经过以上的测试，在使用MyBatis-Plus实现基本的CRUD时，我们并没有指定要操作的表，只是在Mapper接口继承BaseMapper时，设置了泛型User，而操作的表为user表:
由此得出结论，MyBatis-Plus在确定操作的表时，由BaseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致

4.1.1 问题

若实体类类型的类名和要操作的表的表名不一致，会出现什么问题？
我们将表user更名为t_user，测试查询功能
程序抛出异常，Table ‘mybatis_plus.user’ doesn’t exist，因为现在的表名为t_user，而默认操作的表名和实体类型的类名一致，即user表

在这里插入图片描述

4.1.2 通过@TableName解决问题

在实体类类型上添加==@TableName(“t_user”)==，标识实体类对应的表，即可成功执行SQL语句。

在这里插入图片描述

4.1.3 通过GlobalConfig解决问题

在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_
此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就不需要在每个实体类上通过@TableName标识实体类对应的表。

在spring配置文件中修改：spring-persist.xml中的sqlsessionfactorybean

 <!--使用mybatisplus-->
    <bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <!--指定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--指定mapper.xml-->
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
        <!--装配数据源-->
        <property name="dataSource" ref="dataSource"/>
<!--设置mybatisplus的全局配置，即表的前缀-->

<property name="globalConfig" ref="globalConfig"></property>

</bean>
<bean id="globalConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig">

<property name="dbConfig">

<bean id="config" class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">

<!--设置实体类所对应的表的前缀-->

<property name="tablePrefix" value="t_"></property>

</bean>

</property>

</bean>

4.2 @TableId

经过以上的测试，MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。

4.2.1 问题引出

若实体类和表中表示主键的不是id，而是其他字段，例如uid，MyBatis-Plus会自动识别uid为主键列吗？
我们实体类中的属性id改为uid，将表中的字段id也改为uid，测试添加功能程序抛出异常，Field ‘uid’ doesn’t have a default value，说明MyBatis-Plus没有将uid作为主键赋值
在这里插入图片描述

4.2.2 通过@TableId解决问题

在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句。

在这里插入图片描述

4.2.3 @TableId的value属性

若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解@TableId，则抛出异常Unknown column ‘id’ in ‘field list’，即MyBatis-Plus仍然会将id作为表的主键操作，而表中表示主键的是字段uid
此时需要通过@TableId注解的value属性，指定表中的主键字段@TableId(“uid”)或@TableId(value=“uid”)


public class User {
//将属性所对应的字段指定为主键

// @TableId注解的value属性用于指定主键的字段

@TableId("uid")

private Long id;

4.2.4 @TableId的type属性

type属性用来定义主键策略

在这里插入图片描述
[1]临时修改


public class User {
//将属性所对应的字段指定为主键

// @TableId注解的value属性用于指定主键的字段

// @TableId注解的type属性设置主键生成策略

// @TableId(value = "uid", type = IdType.AUTO)

@TableId("uid")

private Long id;

[2] 配置全局配置(全局有效)
在spring-persist.xml中修改。

 <bean id="globalConfig" class="com.baomidou.mybatisplus.core.config.GlobalConfig">
        <property name="dbConfig">
            <bean id="config" class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                <!--设置实体类所对应的表的前缀-->
                <property name="tablePrefix" value="t_"></property>
                <!--设置全局主键策略-->
                <property name="idType" value="AUTO"></property>
             </bean>
        </property>
    </bean>

4.2.5 雪花算法

在这里插入图片描述

4.3 @TableField

经过以上的测试，我们可以发现，MyBatis-Plus在执行SQL语句时，要保证实体类中的属性名和表中的字段名一致
如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？
a>情况1

若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格
例如实体类属性userName，表中字段user_name
此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格
相当于在MyBatis中配置

b>情况2

若实体类中的属性和表中的字段不满足情况1
例如实体类属性name，表中字段username
此时需要在实体类属性上使用@TableField(“username”)设置属性所对应的字段名

//注意：如果实体类中属性名为:name,表中字段名也要为:name
   // 在不加@TableField注解的情况下，表中字段为:user_name 代码会报错。
   //指定属性对应的字段名
    //当实体类中是name,表中所对应的字段名是：user_name,可以使用该注解来实现指定属性对应的字段名
    @TableField("user_name")
     private String name;

4.4 @TableLogic（逻辑删除）

4.4.1 逻辑删除

逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
使用场景：可以进行数据恢复

4.4.2 实现逻辑删除

数据库中创建逻辑删除状态列，设置默认值为0
实体类中添加逻辑删除属性

//逻辑删除
   @TableLogic
   private Integer isDeleted;

测试

测试删除功能，真正执行的是修改
UPDATE t_user SET is_deleted=1 WHERE id=? AND is_deleted=0
测试查询功能，被逻辑删除的数据默认不会被查询
SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0

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

5.1 wapper介绍

在这里插入图片描述

5.2 QueryWrapper

5.2.1 组装查询条件

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyBatisPlusWrapperTest {
@Autowired

public UserMapper userMapper;
@Test

public void  test01(){
//查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)

queryWrapper.like("user_name","a")

.between("age",20,30)

.isNotNull("email");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);

}

5.2.2 组装排序条件

  @Test
    public void test02(){
//按年龄降序查询用户，如果年龄相同则按id升序排列
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,uid ASC

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

.orderByAsc("uid");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

5.2.3 组装删除条件

@Test
    public void test03(){
        //删除email为空的用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//UPDATE t_user SET is_deleted=1 WHERE is_deleted=0 AND (email IS  NULL)

//出现这个是因为我们设置了逻辑删除，即删除变成了修改，将状态从0(未删除状态)--->1(已删除状态);

queryWrapper.isNull("email");
int result = userMapper.delete(queryWrapper);
System.out.println("受影响的行数 ： " + result);
}

5.2.4 条件的优先级

	/**
     * update(User entity,Wrapper<User> updateWrapper)
     * 第一个参数为修改的内容，第二个参数为设置修改的条件
     参数1设置修改的字段和值，参数2是查询符合的条件
     **/
@Test

public void test04(){

//条件包装器中条件之间默认是and连接。我们不需要手动设置，但是如果是或，我们需要手动设置or.

//将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//UPDATE t_user SET user_name=?, age=?, email=? WHERE is_deleted=0 AND (user_name LIKE ? AND age > ? OR email IS NULL)

queryWrapper.like("user_name","a")

.gt("age",20)

.or()

.isNull("email");
User user = new User();

user.setName("小明");

user.setEmail("test@atguigu.com");

int result = userMapper.update(user, queryWrapper);
System.out.println("受影响的行数：" + result);
}

@Test
    public void test05(){

        //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
        //lambda表达式内的逻辑优先运算
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        //SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND (age > ? OR email IS NULL))
        queryWrapper.like("user_name","a")
                .and(i ->i.gt("age",20).or().isNull("email"));

        List<User> userList = userMapper.selectList(queryWrapper);

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


    }

5.2.5 组装select子句

 @Test
    public void test06(){
        //查询用户信息的username和age字段
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//SELECT user_name,age FROM t_user WHERE is_deleted=0

queryWrapper.select("user_name","age");
List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
maps.forEach(System.out::println);
}

5.2.6 实现子查询

@Test
    public void test07(){
//查询id小于等于3的用户信息
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (uid IN (select uid from t_user where uid <= 3))

queryWrapper.inSql("uid","select uid from t_user where uid <= 3");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

5.3 UpdateWrapper

 @Test
    public void test08(){
//将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改

// 组装set子句以及修改条件

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
/*写在一起

updateWrapper.set("age",18)

.set("email","user@atguigu.com")

.like("user_name","a")

.and(i ->i.gt("age",20).or().isNull("email"));

*/
//分开写
//UPDATE t_user SET user_name=?,email=? WHERE is_deleted=0 AND (user_name LIKE ? AND (age > ? OR email IS NULL))

updateWrapper.like("user_name","a")

.and(i ->i.gt("age",20).or().isNull("email"));
updateWrapper.set("user_name","小黑").set("email","abc@atguigu.xom");
//这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null

//UPDATE t_user SET username=?, age=?,email=? WHERE (username LIKE ? AND(age > ? OR email IS NULL))

//User user = new User();

//user.setName("张三");

//int result = userMapper.update(user, updateWrapper);

//UPDATE t_user SET age=?,email=? WHERE (username LIKE ? AND (age > ? ORemail IS NULL))

int result = userMapper.update(null, updateWrapper);

System.out.println("result = " + result);
}

5.4 condition

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。

思路一：

@Test
    public void test09(){
        //定义查询条件，有可能为null（用户未输入或未选择）
        String username = null;
        Integer ageBegin = 20;
        Integer ageEnd = 30;
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (age >= ? AND age <= ?)
//StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成

if(StringUtils.isNotBlank(username)){

queryWrapper.like("user_name","a");

}
if (ageBegin != null){

queryWrapper.ge("age",ageBegin);

}
if (ageEnd != null){

queryWrapper.le("age",ageEnd);

}
List<User> list = userMapper.selectList(queryWrapper);

list.forEach(System.out::println);
}

思路2：

上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查询条件，简化代码的编写

  @Test
    public void test10(){
        String username = "a";
        Integer ageBegin = null;
        Integer ageEnd = 30;
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND age <= ?)

queryWrapper.like(StringUtils.isNotBlank(username),"user_name","a")

.ge(ageBegin != null,"age",ageBegin)

.le(ageEnd != null,"age",ageEnd);
List<User> list = userMapper.selectList(queryWrapper);
list.forEach(System.out::println);
}

5.5 LambdaQueryWrapper

 @Test
    public void test11(){
String username = "a";

Integer ageBegin = null;

Integer ageEnd = 30;
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
//SELECT uid AS id,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND age <= ?)

queryWrapper.like(StringUtils.isNotBlank(username),User::getName,"a")

.ge(ageBegin != null,User::getAge,ageBegin)

.le(ageEnd != null,User::getAge,ageEnd);
List<User> list = userMapper.selectList(queryWrapper);
list.forEach(System.out::println);

}

5.6 LambdaUpdateWrapper

@Test
    public void test12(){
//将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改

// 组装set子句以及修改条件

LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
/*合在一起

updateWrapper

.set(User::getAge, 18)

.set(User::getEmail, "user@atguigu.com")

.like(User::getName, "a")

.and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));

*/
//分开写

updateWrapper.like(User::getName, "a")

.and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));

updateWrapper.set(User::getName,"小黑").set(User::getEmail,"abc@atguigu.com");

User user = new User();

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

System.out.println("受影响的行数：" + result);
}

六、插件

6.1 分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能。

6.1.1 添加配置

 <!--使用mybatisplus-->
    <bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <!--指定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--指定mapper.xml-->
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
        <!--装配数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--设置mybatisplus的全局配置，即表的前缀-->
        <property name="globalConfig" ref="globalConfig"></property>
        <!--配置插件-->
        <property name="plugins">
            <array>
                <ref bean="mybatisPlusInterceptor"></ref>
            </array>
        </property>
    </bean>
<!--配置MyBatis-Plus插件-->

<bean id="mybatisPlusInterceptor" class="com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor">

<property name="interceptors">

<list>

<ref bean="paginationInnerInterceptor"></ref>

</list>

</property>

</bean>
<!--配置Mybatis-plus分页插件的bean-->

<bean id="paginationInnerInterceptor" class="com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor">

<!--设置数据库类型-->

<property name="dbType" value="MYSQL"></property>

</bean>

6.1.2 测试


    @Test
    public void testPage(){
        //设置分页参数
        Page<User> page = new Page<>(2,3);
userMapper.selectPage(page,null);
List<User> list = page.getRecords();

list.forEach(System.out::println);
System.out.println("每页显示的条数："+page.getSize());

System.out.println("总记录数："+page.getTotal());

System.out.println("总页数："+page.getPages());

System.out.println( "当前页:"  + page.getCurrent());

System.out.println("是否有下一页:" + page.hasNext());

System.out.println("是否有上一页:" + page.hasPrevious());
}

测试结果：
User(id=1, name=Jone, age=18, email=test1@baomidou.com, isDeleted=0) User(id=2,name=Jack, age=20, email=test2@baomidou.com, isDeleted=0) User(id=3, name=Tom,age=28, email=test3@baomidou.com, isDeleted=0) User(id=4, name=Sandy, age=21,email=test4@baomidou.com, isDeleted=0) User(id=5, name=Billie, age=24, email=test5@baomidou.com, isDeleted=0) 当前页：1 每页显示的条数：5 总记录数：17 总页数：4 是否有上一
页：false 是否有下一页：true

6.2 xml自定义分页

6.2.1 UserMapper中定义接口方法

    /**
     * 根据年龄查询用户列表，分页显示
     * @param page 分页对象，xml中可以从里面进行取值，传递参数 Page 即自动分页，必须放在第一位
     * @param age 年龄
     * @return
     */
    IPage<User> selectPageVo(@Param("page") Page<User> page , @Param("age") Integer age);
}

6.2.2 UserMapper.xml中编写SQL

   <!--IPage<User> selectPageVo(@Param("page") Page<User> page , @Param("age") Integer age);-->
        <select id="selectPageVo" resultType="User">
                select uid,user_name,age,email from t_user  where age > #{age}
        </select>

6.2.3 测试

 @Test
    public void testPageVo(){
Page<User> page = new Page<>(1,5);//第一页索引为1，不是0

userMapper.selectPageVo(page,20);

List<User> list = page.getRecords();

list.forEach(System.out::println);
System.out.println("每页显示的条数："+page.getSize());

System.out.println("总记录数："+page.getTotal());

System.out.println("总页数："+page.getPages());

System.out.println( "当前页:"  + page.getCurrent());

System.out.println("是否有下一页:" + page.hasNext());

System.out.println("是否有上一页:" + page.hasPrevious());
}

结果：
User(id=3, name=Tom, age=28, email=test3@baomidou.com, isDeleted=null)
User(id=4,name=Sandy, age=21,email=test4@baomidou.com, isDeleted=null) User(id=5, name=Billie,age=24, email=test5@baomidou.com, isDeleted=null) User(id=8,name=ybc1, age=21,email=null, isDeleted=null)
User(id=9, name=ybc2, age=22,email=null, isDeleted=null)
当前页：1 每页显示的条数：5 总记录数：12 总页数：3 是否有上一页：false 是否有下一页：true

6.3 乐观锁

6.3.1 场景

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据
库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。
现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多。

6.3.2 乐观锁与悲观锁

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

6.3.3 模拟修改冲突

a>数据库中增加商品表

CREATE TABLE t_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)
);

b>添加数据

INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

c>添加实体

*/@Data
public class Product {
private Long id;

private String name;

private Integer price;
}

d>添加mapper

public interface ProductMapper extends BaseMapper<Product> {
}

f>测试


    @Test
    public void testProduct01(){
        //小李查询价格
        Product productLi = productMapper.selectById(1);
        System.out.println("小李查询的商品价格：" + productLi.getPrice());
//小王查询价格

Product productWang = productMapper.selectById(1);
System.out.println("小王查询的商品价格：" + productWang.getPrice());
//小李将商品价格+50

productLi.setPrice(productLi.getPrice() + 50);

productMapper.updateById(productLi);
//小王将商品价格-30

productWang.setPrice(productWang.getPrice() - 30);

int result = productMapper.updateById(productWang);
//老板查询商品价格

Product productBoss = productMapper.selectById(1);
System.out.println("老板查询的商品价格为：" + productBoss.getPrice());
}

6.3.4 乐观锁实现流程

数据库中添加version字段
取出记录时，获取当前version

SELECT id,`name`,price,`version` FROM product WHERE id=1

更新时，version + 1，如果where语句中的version版本不对，则更新失败

UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND
`version`=1

6.3.5 Mybatis-Plus实现乐观锁

[1]修改实体类

*/@Data
public class Product {
private Long id;

private String name;

private Integer price;
@Version

private Integer version;
}

[2]添加乐观锁插件配置

 <!--配置MyBatis-Plus插件-->
    <bean id="mybatisPlusInterceptor" class="com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor">
        <property name="interceptors">
            <list>
                <ref bean="paginationInnerInterceptor"></ref>
<ref bean="optimisticLockerInnerInterceptor"></ref>

</list>

</property>

</bean>
<!--配置乐观锁插件-->

<bean id="optimisticLockerInnerInterceptor" class="com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor">

</bean>

[3] 测试修改冲突

小李查询商品信息：
SELECT id,name,price,version FROM t_product WHERE id=?
小王查询商品信息：
SELECT id,name,price,version FROM t_product WHERE id=?
小李修改商品价格，自动将version+1
UPDATE t_product SET name=?, price=?, version=? WHERE id=? AND version=?
Parameters: 外星人笔记本(String), 150(Integer), 1(Integer), 1(Long), 0(Integer)
小王修改商品价格，此时version已更新，条件不成立，修改失败
UPDATE t_product SET name=?, price=?, version=? WHERE id=? AND version=?
Parameters: 外星人笔记本(String), 70(Integer), 1(Integer), 1(Long), 0(Integer)
最终，小王修改失败，查询价格：150
SELECT id,name,price,version FROM t_product WHERE id=?

[4]优化流程

 @Test
    public void testProduct01(){
        //小李查询价格
        Product productLi = productMapper.selectById(1);
System.out.println("小李查询的商品价格：" + productLi.getPrice());
//小王查询价格

Product productWang = productMapper.selectById(1);
System.out.println("小王查询的商品价格：" + productWang.getPrice());
//小李将商品价格+50

productLi.setPrice(productLi.getPrice() + 50);

productMapper.updateById(productLi);
//小王将商品价格-30

productWang.setPrice(productWang.getPrice() - 30);

int result = productMapper.updateById(productWang);
if (result == 0){
//操作失败，重试

Product productNew = productMapper.selectById(1);
productNew.setPrice(productNew.getPrice() - 30);
productMapper.updateById(productNew);
}
//老板查询商品价格

Product productBoss = productMapper.selectById(1);
System.out.println("老板查询的商品价格为：" + productBoss.getPrice());
}

七、通用枚举

表中的有些字段值是固定的，例如性别（男或女），此时我们可以使用MyBatis-Plus的通用枚举来实现。

7.1 数据库添加字段sex

在这里插入图片描述

7.2 创建通用枚举

 */@Getter
public enum SexEnum {
MALE(1,"男"),

FEMALE(2,"女");
@EnumValue //将注解所标识的属性的值存储到数据库中

private Integer sex;

private String sexName;
SexEnum(Integer sex, String sexName) {

this.sex = sex;

this.sexName = sexName;

}

}

7.3 配置扫描通用枚举

 <!--使用mybatisplus-->
    <bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <!--指定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--指定mapper.xml-->
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
        <!--装配数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--设置mybatisplus的全局配置，即表的前缀-->
        <property name="globalConfig" ref="globalConfig"></property>
        <!--配置扫描通用枚举-->
        <property name="typeEnumsPackage" value="com.atguigu.mybatisplus.enums"></property>
        <!--配置插件-->
        <property name="plugins">
            <array>
                <ref bean="mybatisPlusInterceptor"></ref>
            </array>
        </property>
    </bean>

7.4 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyBatisPlusEnumTest {
@Autowired

private UserMapper userMapper;
@Test

public void testSexEnum(){
User user = new User();

user.setName("Enum");

user.setAge(20);
//设置性别信息为枚举项，会将@EnumValue注解所标识的属性值存储到数据库

// INSERT INTO t_user ( user_name, age, sex, is_deleted ) VALUES ( ?, ?, ?, ? )

user.setSex(SexEnum.MALE);
userMapper.insert(user);

}

八、代码生成器

8.1 引入依赖

<!--代码生成器逆向工程依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!--代码生成器中 freemarker引擎模板需要这个依赖-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>

8.2 快速生成

public class FastAutoGeneratorTest {
public static void main(String[] args) {

FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false",

"root", "5864@WCY")

.globalConfig(builder -> {

builder.author("atguigu") // 设置作者

// .enableSwagger() // 开启 swagger 模式

.fileOverride() // 覆盖已生成文件

.outputDir("F://JAVA listen//code//mybatis_plus"); // 指定输出目录

})

.packageConfig(builder -> {

builder.parent("com.atguigu") // 设置父包名

.moduleName("mybatisplus") // 设置父包模块名

.pathInfo(Collections.singletonMap(OutputFile.mapperXml, "F://JAVA listen//code//mybatis_plus"));// 设置mapperXml生成路径

})

.strategyConfig(builder -> {

builder.addInclude("t_user") // 设置需要生成的表名

.addTablePrefix("t_", "c_"); // 设置过滤表前缀

})

.templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker 引擎模板，默认的是Velocity引擎模板

.execute();

}
}

九、MyBatisX插件

MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率。
但是在真正开发过程中，MyBatis-Plus并不能为我们解决所有问题，例如一些复杂的SQL，多表联查，我们就需要自己去编写代码和SQL语句，我们该如何快速的解决这个问题呢，这个时候可以使用MyBatisX插件。
MyBatisX一款基于 IDEA 的快速开发插件，为效率而生。

MyBatisX插件用法：https://baomidou.com/pages/ba5b24/

9.1 安装插件

安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装

9.2 功能

9.2.1 XML跳转

当mapper映射文件和mapper很多的时候，可以快速定位并跳转到对应的类容上。

9.2.2 快速生成代码

[1]首先需要在datasource中进行配置
在这里插入图片描述

[2] 选择驱动
在这里插入图片描述
[3]可以直接选择旧版本的驱动,或者按提示下载

[4] 登录后选择数据库、表，然后点击右键选择mybatisx。

在这里插入图片描述
[5] 表的基本配置

[6] 生成的基本配置
在这里插入图片描述
[7]选择好后会自动帮我们生成各种组件

[8]如果我们要自定义查询功能，我们只需要在mapper中写我们的方法名，插件会自动帮助我们补全方法名并且快速生成相对应的sql语句放在mapper映射文件中。
在这里插入图片描述

十、总结

mybatsi-plus可以快速帮助我们完成spring和mybatsi的整合及搭建功能。

posted @ 2022-10-28 21:19 wylja 阅读(106) 评论(0) 收藏举报

刷新页面返回顶部

wylja

MyBatis_Plus(Spring版本笔记)

目录

前言

一、MyBatis-Plus简介

1.1 简介

1.2 特性

1.3 支持数据库

1.4 框架结构

1.5 代码及文档地址

二、 入门案例

2.1 开发环境

2.2 创建数据库和表

2.2.1 创建表

2.2.2 添加数据

2.3 创建maven工程

2.3.1 打包方式 jar

2.3.2 引入依赖

2.4 Spring整合MyBatis

2.4.1 创建实体

2.4.2 创建MyBatis的核心配置文件

2.4.3 创建mapper接口和映射文件

2.4.4 创建jdbc.properties

2.4.5 创建Spring的配置文件

2.4.6 添加日志功能

2.4.7 测试

2.5 加入MyBatis-Plus

2.5.1 创建Mapper接口

2.5.2 测试

2.5.3 结果

2.6 总结

三、基本CRUD

3.1 BaseMapper

3.2 BaseMapper功能测试

3.3 通用Service

3.3.1 IService

3.3.2 创建Service接口和实现类

3.3.3 在spring配置文件中设置自动扫描service的包

3.3.4 测试查询记录条数和批量添加

四、常用注解

4.1 @TableName

4.1.1 问题

4.1.2 通过@TableName解决问题

4.1.3 通过GlobalConfig解决问题

4.2 @TableId

4.2.1 问题引出

4.2.2 通过@TableId解决问题

4.2.3 @TableId的value属性

4.2.4 @TableId的type属性

4.2.5 雪花算法

4.3 @TableField

4.4 @TableLogic（逻辑删除）

4.4.1 逻辑删除

4.4.2 实现逻辑删除

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

5.1 wapper介绍

5.2 QueryWrapper

5.2.1 组装查询条件

5.2.2 组装排序条件

5.2.3 组装删除条件

5.2.4 条件的优先级

5.2.5 组装select子句

5.2.6 实现子查询

5.3 UpdateWrapper

5.4 condition

5.5 LambdaQueryWrapper

5.6 LambdaUpdateWrapper

六、插件

6.1 分页插件

6.1.1 添加配置

6.1.2 测试

6.2 xml自定义分页

6.2.1 UserMapper中定义接口方法

6.2.2 UserMapper.xml中编写SQL

6.2.3 测试

6.3 乐观锁

6.3.1 场景

6.3.2 乐观锁与悲观锁

6.3.3 模拟修改冲突

6.3.4 乐观锁实现流程

二、入门案例

七、通用枚举

九、MyBatisX插件