Mybatis-plus详解

已于 2022-11-25 14:14:15 修改
阅读量975 收藏 1
点赞数
分类专栏： 框架 文章标签： mybatis spring boot java
于 2022-11-25 12:58:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56154713/article/details/127971160
版权

Mybatis-plus讲解

搭建环境

创建表

DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` int(11) AUTO_INCREMENT PRIMARY KEY,
  `phone` varchar(11) UNIQUE NOT NULL,
  `user_name` varchar(20),
  `age` int(2),
  `is_deleted` int(11) NULL DEFAULT 0
)

创建SpringBoot工程，然后引入依赖
SpringBoot版本是2.7.5。

	<dependencies>
        <!-- SpringBoot依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 小辣椒 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- mybatis-plus依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
    </dependencies>

配置application.properties文件

server.port=8081
# 数据库的配置
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/db_csdn?SSL=false&serverTimezone=UTC
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=123456
spring.datasource.username=root
# 日志输出
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

添加实体类

下面注解会在后面给大家说，这里不必追究。

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User {
    @TableId(value = "id") // 人只有一个value属性，则默认是省略的。
    private Integer id;
    @TableField("user_name")
    private String userName;
    private String phone;
    @TableLogic
    private Integer isDeleted;
}

Mapper类

public interface UserMapper extends BaseMapper<User> {
}

测试搭建的环境

@Test
public void testInsert(){
    User user = new User();
    user.setUserName("老刘");
    user.setPhone("13423458945");
    userMapper.insert(user);
}

常用注解

@TableName

描述：表名注解，标识实体类对应的表。
使用位置：实体类。

代码实现：

@TableName("t_user")
public class User {
}

@TableId

描述：主键注解。
使用位置：实体类的主键字段。

注意：如果主键名与实体类对应的属性名不一致，则必须要有value属性，如果只有value一个属性，则可以省略不写。

属性类型必须指定默认值描述
valueString否“”主键字段名
typeEnum否IdType.NONE指定主键类型

IdType类型有以下

值描述
AUTO数据库 ID 自增，使用前数据库的id必须是自增的
ASSIGN_ID分配ID，默认是雪花算法生成id，与数据库的id是否自增无关
INPUTinsert 前自行 set 主键值
ASSIGN_UUID分配 UUID

代码实现：

@TableName("t_user")
public class User {
 	@TableId(value = "id",type = IdType.AUTO) // 人只有一个value属性，则默认是省略的。
    private Integer id;
}

@TableField

描述：字段注解(非主键)。
使用位置：实体类的非主键字段。

注意：

  1. 如果属性名与实体类对应的属性名不一致，则必须要有value属性，如果只有value一个属性，则可以省略不写。

  2. 如果实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格，那么Mybatis-plus会自动将下划线命名风格转换为驼峰命名风格。

代码实现：

@TableName("t_user")
public class User {
    @TableId(value = "id",type = IdType.AUTO) // 人只有一个value属性，则默认是省略的。
    private Integer id;
    @TableField(value = "user_name",exist = true) // 如果exist的属性为false，则意思是不是数据库中的字段
    private String userName;
}

@TableLogic

描述：表字段逻辑处理注解(逻辑删除)。

属性类型必须指定默认值描述
valueString否“”逻辑未删除值
delvalString否“”逻辑删除值

逻辑删除和物理删除的概念：
逻辑删除：假删除，将对应数据中代表是否被删除字段(is_deleted)的状态修改为被删除状态(值为1)，但是在数据库中仍然能看到此条记录。

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据。
使用场景：可以进行数据的恢复。

使用全局配置解决表名前缀和主键策略

# 配置MyBatis-Plus的主键策略
mybatis-plus.global-config.db-config.id-type=assign_id
# 配置MyBatis-Plus操作表的默认前缀
mybatis-plus.global-config.db-config.table-prefix=t_

CRUD接口

Mapper CRUD接口

BaseMapper接口为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器。其中泛型 T为任意实体对象。

方法如下：
在这里插入图片描述

BaseMapper的源码

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.COLL) Collection<?> 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.COLL) 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 实体对象封装操作类
     * @return 是否存在记录
     */
    default boolean exists(Wrapper<T> queryWrapper) {
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0;
    }

    /**
     * 根据 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);
}

插入

插入一条数据

@Resource
private UserMapper userMapper;
@Test
public void testInsert(){
    User user = new User();
    user.setUserName("老黑");
    user.setPhone("13523458945");
    userMapper.insert(user);
    System.out.println("获取的id" + user.getId());
}

结果：我们发现在插入数据时，是基于雪花算法的策略生成id。并且它会将主键id存到实体类中。

生成的sql语句

INSERT INTO t_user ( user_name, phone ) VALUES ( ?, ? )

删除

通过id删除

@Resource
private UserMapper userMapper;
@Test
public void testDeleteById(){
    int result = userMapper.deleteById(2140147718);
    System.out.println("受影响行数：" + result);
}

生成的sql语句：

UPDATE t_user SET is_deleted=1 WHERE id=? AND is_deleted=0

通过id批量删除

@Resource
private UserMapper userMapper;
@Test
public void testDeleteById(){
   List<Integer> list = Arrays.asList(1, 2, 3);
   int result = userMapper.deleteBatchIds(list);
   System.out.println("受影响行数：" + result);
}

生成的sql语句：

UPDATE t_user SET is_deleted=1 WHERE id IN ( ? , ? , ? ) AND is_deleted=0

通过Map条件删除

@Resource
private UserMapper userMapper;
@Test
public void testDeleteMap(){
    HashMap<String, Object> hashMap = new HashMap<>();
    hashMap.put("phone","15623458945");
    hashMap.put("user_name","李四");
    int result = userMapper.deleteByMap(hashMap);
    System.out.println("受影响行数：" + result);
}

生成的sql语句：

UPDATE t_user SET is_deleted=1 WHERE phone = ? AND user_name = ? AND is_deleted=0

修改

通过id修改信息

@Resource
private UserMapper userMapper;
@Test
public void testUpdateById(){
    User user = new User();
    user.setId(110100482);
    user.setUserName("李四");
    user.setPhone("18954687536");
    int result = userMapper.updateById(user);
    System.out.println("受影响行数：" + result);
}

生成的sql语句：

UPDATE t_user SET user_name=?, phone=? WHERE id=? AND is_deleted=0

查询

根据id查询用户信息

@Resource
private UserMapper userMapper;
@Test
public void testSelectById(){
    User user = userMapper.selectById(1);
    System.out.println(user);
}

生成的sql语句：

SELECT id,user_name,phone,is_deleted FROM t_user WHERE id=? AND is_deleted=0

根据多个id查询多个用户信息

@Resource
private UserMapper userMapper;
@Test
public void testSelectMoreId(){
    List<Integer> list = Arrays.asList(1, 2, 3);
    List<User> userList = userMapper.selectBatchIds(list);
    for (User user : userList) {
        System.out.println(user);
    }
}

生成的sql语句：

SELECT id,user_name,phone,is_deleted FROM t_user WHERE id IN ( ? , ? , ? ) AND is_deleted=0

根据Map条件查询用户信息

@Resource
private UserMapper userMapper;
@Test
public void testSelectByMap(){
    HashMap<String, Object> hashMap = new HashMap<>();
    hashMap.put("phone","15586264781");
    hashMap.put("name","王五");
    List<User> userList = userMapper.selectByMap(hashMap);
    for (User user : userList) {
        System.out.println(user);
    }
}

生成的sql语句：

SELECT id,user_name,phone,is_deleted FROM t_user WHERE phone = ? AND user_name = ? AND is_deleted=0

查询所有用户信息

@Resource
private UserMapper userMapper;
@Test
public void testSelectList(){
	// 这里的参数是Wrapper类型，即为条件构造器，这个是针对Sql语句设置不同的条件，如果没有条件，可以设为null。后面会说的。
    List<User> userList = userMapper.selectList(null);
    for (User user : userList) {
        System.out.println(user);
    }
}

生成的sql语句：

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0

Service CRUD接口

通用 Service CRUD 封装IService接口和其实现类ServiceImpl，其中T为任意的实体对象。

IService部分方法如下所示，由于方法太多了，这里只列举一部分，剩余的可以自己看源码。
在这里插入图片描述

ServiceImpl方法如下所示：
在这里插入图片描述

注意： ServiceImpl实现了IService，提供了IService中基础功能的实现。当然，也可以自定义相应的业务方法完成需求。

由于通用Service中CRUD的方法与通用Mapper中CRUD方法类似，这里只列举不同的。

批量添加

@Resource
private UserService userService;
@Test
public void testSaveBatch(){
    ArrayList<User> list = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        User user = new User();
        user.setPhone("1594561234" + i);
        user.setUserName("张三" + i);
        list.add(user);
    }
    userService.saveBatch(list);
}

生成的sql语句

INSERT INTO t_user ( user_name, phone ) VALUES ( ?, ? )

查询总记录数

@Resource
private UserService userService;
@Test
public void testCount(){
    long count = userService.count();
    System.out.println("总记录数：" + count);
}

生成的sql语句

SELECT COUNT( * ) FROM t_user WHERE is_deleted=0

条件构造器

在这里插入图片描述

AbstractWrapper中的部分方法以及QueryMapper的使用

提示：有的方法会有 boolean condition，也就是表示该条件是否加入最后生成的sql中。默认为true。

allEq

boolean null2IsNull参数：默认为true。若为true，则在map的value为null时调用isNull方法；若为false，则忽略value为null的。

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper1(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    HashMap<String, Object> hashMap = new HashMap<>();
    hashMap.put("phone","15623458964");
    hashMap.put("user_name",null);
    wrapper.allEq(hashMap,false); // SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (phone = ?)
    //wrapper.allEq(false,hashMap,false); // SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0
    List<User> list = userMapper.selectList(wrapper);
    for (User user : list) {
        System.out.println(user);
    }
}

生成的sql语句看后面的注释

eq 和 ne

eq：等于 =
ne：不等于 <>

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper2(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("phone","15623458964")..ne("user_name","张三");
    User user = userMapper.selectOne(wrapper);
    System.out.println(user);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (phone = ? AND user_name <> ?)

gt 和 lt

gt：大于 >
lt： 小于 <

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper3(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.gt("id","110100481").lt("id","227540995");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (id > ? AND id < ?)

ge 和 le

ge：大于等于 >=
le： 小于等于 <=

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper4(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.ge("id","110100481").le("id","227540995");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (id >= ? AND id <= ?)

between 和 notBetween

between ：BETWEEN 值1 AND 值2
notBetween：NOT BETWEEN 值1 AND 值2

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper5(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.between("id","110100481","227540995")
             .notBetween("phone","1695567000","1995567000");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (id BETWEEN ? AND ? AND phone NOT BETWEEN ? AND ?)

like 和 notLike

LIKE：%值%
notLike：NOT LIKE ‘%值%’

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper6(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.like("user_name","张")
             .notLike("phone","169");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND phone NOT LIKE ?)

likeLeft 和 likeRight

likeLeft ：LIKE '%值' likeRight`：LIKE ‘值%’

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper7(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.likeLeft("user_name","张")
             .likeRight("phone","134");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND phone LIKE ?)

isNull 和 isNotNull

isNull：字段 IS NULL
isNotNull：字段 IS NOT NULL

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper8(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.isNull("user_name").isNotNull("phone");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name IS NULL AND phone IS NOT NULL)

in 和notIn

in：字段 IN
notIn：字段 NOT IN

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper9(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.in("phone", Arrays.asList("15945612354","15945612355","15945612356"))
                .notIn("user_name","张三","李四");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (phone IN (?,?,?) AND user_name NOT IN (?,?))

groupBy

groupBy：分组：GROUP BY 字段

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper10(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.groupBy("user_name");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 GROUP BY user_name

orderByAsc 和 orderByDesc

orderByAsc：排序：ORDER BY 字段, … ASC
orderByDesc：排序：ORDER BY 字段, … DESC

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper11(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.orderByAsc("id").orderByDesc("phone");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY id ASC,phone DESC

orderBy

orderBy：排序：ORDER BY 字段,

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper12(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.orderBy(true,true,"id");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY id ASC

having

having：HAVING ( sql语句 )

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper13(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.groupBy("phone").having("phone > 15945612342");
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 GROUP BY phone HAVING phone > 15945612342

or 和 and

or：OR 嵌套
and：AND 嵌套

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper14(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.eq("user_name","张三").or().isNull("phone")
                .and(wrappers -> {
                    wrappers.eq("phone","15945612342");
                });     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name = ? OR phone IS NULL AND (phone = ?))

inSql 和 notInSql

inSql：字段 IN ( sql语句 )
notInSql：字段 NOT IN ( sql语句 )

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper14(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.notInSql("id","select id from t_user where id <= 2123419651")
                .inSql("phone","select phone from t_user where phone <= 15245612344");    List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (id NOT IN (select id from t_user where id <= 2123419651) AND phone IN (select phone from t_user where phone <= 15245612344))

select方法

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper15(){
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.select("user_name");
     // selectMaps返回Map集合列表，通常配合select使用，可以省去没有查询到的列值。
     List<Map<String, Object>> users = userMapper.selectMaps(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT user_name FROM t_user WHERE is_deleted=0

UpdateWrapper的使用

代码实现：

@Resource
private UserMapper userMapper;
@Test
public void testUpdateWrapper16(){
     UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
     updateWrapper.set("phone","15478965231").eq("id","110100482");
     int result = userMapper.update(null, updateWrapper);
     System.out.println(result);
}

生成的sql语句

UPDATE t_user SET phone=? WHERE is_deleted=0 AND (id = ?)

LambdaQueryWrapper

@Resource
private UserMapper userMapper;
@Test
public void testSelectWrapper17(){
     User user = new User();
     user.setPhone("159");
     LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
     wrapper.like(User::getPhone,user.getPhone());
     List<User> users = userMapper.selectList(wrapper);
     users.forEach(System.out::println);
}

生成的sql语句

SELECT id,user_name,phone,is_deleted FROM t_user WHERE is_deleted=0 AND (phone LIKE ?)

LambdaUpdateWrapper

@Resource
private UserMapper userMapper;
@Test
public void testUpdateWrapper18(){
     LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
     wrapper.set(User::getUserName,"李四").eq(User::getId,"227540993");
     int result = userMapper.update(null, wrapper);
     System.out.println(result);
}

生成的sql语句

UPDATE t_user SET user_name=? WHERE is_deleted=0 AND (id = ?)

分页插件

使用Mybatis-Plus自带的分页

①：添加分页的配置类

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return mybatisPlusInterceptor;
    }
}

②：进行测试

@Test
public void testPage(){
    Page<User> page = new Page<>(1,5);
    userMapper.selectPage(page,null);
    List<User> records = page.getRecords();
    System.out.println("第一页的所有记录：");
    records.forEach(System.out::println);
    System.out.println("总页数" + page.getPages());
    System.out.println("总记录数" + page.getTotal());
    System.out.println("每页显示的条数" + page.getSize());
    System.out.println("当前页" + page.getCurrent());
    System.out.println("是否有上一页："+page.hasPrevious());
    System.out.println("是否有下一页："+page.hasNext());
}

使用mapper.xml文件自定义分页

①：添加分页的配置类

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return mybatisPlusInterceptor;
    }
}

②：UserMapper接口

public interface UserMapper extends BaseMapper<User> {
    Page<User> selectPageVo(@Param("page") Page<User> page,@Param("name") String name);
}

③：UserMapper.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.zhang.mapper.UserMapper">
    <select id="selectPageVo" resultType="User">
        select * from t_user where user_name = #{name}
    </select>
</mapper>

④：在application.properties文件中配置Mybatis-Plus的相关配置

# 配置别名
mybatis-plus.type-aliases-package=com.zhang.pojo
# 配置mapper文件
mybatis-plus.mapper-locations=classpath:/mapper/**.xml

⑤：进行测试

@Test
public void testPage(){
    Page<User> page = new Page<>(1,5);
    userMapper.selectPageVo(page,"张三");
    List<User> records = page.getRecords();
    System.out.println("第一页的所有记录：");
    records.forEach(System.out::println);
    System.out.println("总页数" + page.getPages());
    System.out.println("总记录数" + page.getTotal());
    System.out.println("每页显示的条数" + page.getSize());
    System.out.println("当前页" + page.getCurrent());
    System.out.println("是否有上一页："+page.hasPrevious());
    System.out.println("是否有下一页："+page.hasNext());
}

乐观锁插件

乐观锁和悲观锁的概念：

  1. 乐观锁：指别人不会同时修改数据，默认是不会上锁的，只是在执行的时候会判断别人在此刻是否修改了数据，如果修改了数据，则放弃操作，否则执行操作。
  2. 悲观锁：指别人会同时修改数据，默认是在操作数据时是上锁的，直到操作完成后才会释放所，在上锁期间其他人不能操作数据。

实现流程
3. 取出记录时，会获取到当前的version。
4. 更新记录时，会带上这个version。
5. 执行更新时，会将version的版本+1。如果version版本不对，则更新失败。

实现步骤：

首先在数据库中添加version字段。

①：在实体类的 version 属性上加上 @Version注解。

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User {
    @TableId(value = "id",type = IdType.AUTO) // 人只有一个value属性，则默认是省略的。
    private Integer id;
    @TableField(value = "user_name",exist = true) // 如果exist的属性为false，则意思是不是数据库中的字段
    private String userName;
    private String phone;
    private SexEnum sex;
    @TableLogic
    private Integer isDeleted;
    @Version
    private Integer version;
}

②：基于注解配置

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

案例：这里有A、B、C三个人，其中C刚开始想让A帮他修改手机号，然后A说等一会在去。过了一会想换一个手机号，于是C就让B去帮他换新手机号。此时，A和B同时帮C修改手机号，那么原本C最终想要的是B帮忙修改的手机号，结果在B改完后，A又改了，那么此时就造成了结果误差，此时A就把B的操作覆盖了。我们将会使用乐观锁的插件来解决。

代码实现

将@Version注解与注解配置都配置好后，进行下述测试。

@Resource
private UserMapper userMapper;
 @Test
public void testLock(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // A
    User a = userMapper.selectOne(wrapper.eq("user_name", "C"));
    System.out.println("此时A查到C的手机号" + a.getPhone());
    // B
    User b = userMapper.selectOne(wrapper.eq("user_name", "C"));
    System.out.println("此时B查到C的手机号" + a.getPhone());
    // 此时B修改手机号
    b.setPhone("15978651234");
    int resultB = userMapper.updateById(b);  // 1
    System.out.println("B修改手机号的结果：" + resultB);
    // 此时A修改手机号
    a.setPhone("19878651234");
    int resultA = userMapper.updateById(a);  // 0
    System.out.println("A修改手机号的结果：" + resultA);

    // 最后的结果
    User c = userMapper.selectOne(wrapper.eq("user_name", "C"));
    System.out.println("C最终的手机号：" + c.getPhone());
}

通用枚举

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

注意：从 3.5.2 版本开始只需完成 声明通用枚举属性 即可使用。

①：给数据库表添加字段sex
在这里插入图片描述
②：创建通用枚举类型

public enum SexEnum {
    MALE(1,"男"),
    FEMALE(2,"女");
    @EnumValue
    private Integer sex;
    @JsonValue  // 标记响应json值
    private String sexName;
    SexEnum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }

    public String getSexName() {
        return sexName;
    }
}

测试

@Resource
private UserMapper userMapper;
@Test
public void testSexNum(){
    User user = new User();
    user.setSex(SexEnum.MALE);
    user.setPhone("14536586953");
    userMapper.insert(user);
    System.out.println(userMapper.selectById(user.getId()).getSex().getSexName());
}

代码生成器

这里需要重新创建一个SpringBoot工程。

①：添加依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.2</version>
</dependency>
<dependency>
	<groupId>org.freemarker</groupId>
	<artifactId>freemarker</artifactId>
	<version>2.3.31</version>
</dependency>

②：快速生成的代码

public class TestFastAutoGenerator {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/db_csdn?SSL=false&serverTimezone=UTC","root","123456")
                .globalConfig(builder -> {
                    builder.author("zhang")  // 设置作者
                            .enableSwagger()  // 开启swagger模式
                            .fileOverride()   // 覆盖已生成文件
                            .disableOpenDir() // 禁止打开输出目录
                            .outputDir("E:\\代码\\Mybatis-plus\\csdn"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("src.main.java.com.zhang")  // 设置父包名
                            //.moduleName("")  // 设置父包模块名
                            .entity("entity")  // 设置包名
                            .service("service")  // 设置Service包名
                            .serviceImpl("service.impl")  // 设置serviceImpl包名
                            .controller("controller")  // 设置controller包名
                            .xml("mapper.xml")
                            .pathInfo(Collections.singletonMap(OutputFile.xml,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\mapper"))// 设置mapper.xml文件生成路径
                            .pathInfo(Collections.singletonMap(OutputFile.mapper,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\mapper")) // 设置mapper文件生成路径
                            .pathInfo(Collections.singletonMap(OutputFile.controller,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\controller")) // 设置controller文件生成路径
                            .pathInfo(Collections.singletonMap(OutputFile.service,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\service")) // 设置service文件生成路径
                            .pathInfo(Collections.singletonMap(OutputFile.serviceImpl,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\service\\impl")) // 设置serviceImpl文件生成路径
                            .pathInfo(Collections.singletonMap(OutputFile.entity,"E:\\代码\\Mybatis-plus\\csdn\\src\\main\\java\\com\\zhang\\entity")); // 设置entity文件生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user")        // 设置需要生成的表名
                            .addTablePrefix("t_","c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()).execute(); // 使用Freemarker引擎模板，默认是Velocity引擎模板
    }
}

③：生成的目录如下：
在这里插入图片描述

mybatis-plus强大的条件构造器直接干代码
Y_R_Q的博客
07-07 357
导入mybatis-plus依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.1.0</version> </dependency> 实体类注解对应 @
Mybatis-Plus 详解（速成版）
ZHI_YUE的博客
07-10 4088
Mybatis 在Spring系列开发项目中占据重要的地位,但有一款框架提供的功能比他更强,那就是MyBatis Plus,但他与Mybatis 有何不同,又如何使用呢，本文目的意在拥有Mybatis框架的使用基础上,如何学习并过度到Mybatis-Plus。
解读MyabtisPlus中的R类（通用响应包装类）
码农研究僧的博客
01-09 2032
大部分R类可以自已手写一个适配的，但MybatisPlus中有专门的R类，于是就使用封装好的类即可。
mybatisplus官方文档学习笔记四（CRUD 接口）
qq_41628667的博客
11-03 721
一.Service CRUD 接口 说明: 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆， 泛型 T 为任意实体对象 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类 对象 Wrapper 为 条件构造器 Save // 插入一条记录（选择字段，策略插入） boole
整点活，MyBatis-Plus学习笔记（第2.2节 R 基本查询）
weixin_45861935的博客
04-18 1031
前言 上一节介绍了简单的insert操作，本节为简单的select操作。（tia，momoko：老娘杀回来了） 这个是自己学习时候记得笔记要是想详细了解可以去MP官网，上边有更详细的配置流程以及视频教学:MyBatis-Plus 普通查询 根据主键查询单个selectById() 根据主键组成的列表或集合查询selectBatchIds() 根据条件组成的Map对象进行查询selectByMap...
mybatis select 返回值long null_Mybatis框架（二）
weixin_39586335的博客
12-24 527
【31】1. <typeAliases>标签1.1 功能用于给 java 类型定义别名, 方便在配置文件中使用.1.2 使用方式a) 给 User 类型定义别名为 u<!-- typeAliases给类型起别名 --> <typeAliases> <!-- 给User类起别名为u --> <typeAlias type="com.bjsxt.p...
MyBatis-Plus Generator配置详解
09-07
MyBatis-Plus Generator是一款强大的代码生成工具，它是MyBatis-Plus框架的一部分，能够帮助开发者自动生成Java实体类、Mapper接口及XML配置文件等，大大提高了开发效率。下面将详细介绍如何配置和使用MyBatis-Plus ...
Mybatis-Plus通用枚举的使用详解
09-07
Mybatis-Plus是一个扩展了Mybatis功能的轻量级框架，它提供了许多便捷的操作API，大大简化了开发过程。在处理枚举类型时，Mybatis-Plus提供了通用枚举（Generic Enum）的功能，使得枚举在数据库交互中的使用更加优雅...
SpringBoot整合MyBatis及其增强工具MyBatis-Plus详解与实战指南
最新发布
02-09
内容概要：本文档详细介绍了如何在SpringBoot项目中集成MyBatis及其增强工具MyBatis-Plus的方法。涵盖了从环境搭建到具体功能实现的具体步骤和技术细节。主要内容包括mybatis的配置、XML映射文件、注解式编程以及...
整点活，MyBatis-Plus学习笔记（第2.2节 R 分页查询）
weixin_45861935的博客
04-20 321
前言 此前学习了条件构造器查询，一定要记住几个常用的查询方法（比如id,queryWrapper的使用，和连接词估计不常用的也快忘光了），这个比较像Hibernate的QBC，还算可以。这篇介绍MP中的分页查询 这个是自己学习时候记得笔记要是想详细了解可以去MP官网，上边有更详细的配置流程以及视频教学:MyBatis-Plus 分页前言 还记得MyBatis中，需要引入pageHelper来执行分...
mybatis-plus+sqlserver存储过程
weixin_40412301的博客
10-26 1524
mybatis-plus中使用exec执行sqlserver中的存储过程
整点活，MyBatis-Plus学习笔记（第2.2节 R 条件构造器查询）
weixin_45861935的博客
04-20 540
前言 上节为通过id、idList、idSet、Map设置条件进行等值查询，但在实际使用中，还需要使用> <等连接符进行查询，那么此次则介绍条件构造器这一使用方法。 这个是自己学习时候记得笔记要是想详细了解可以去MP官网，上边有更详细的配置流程以及视频教学:MyBatis-Plus 条件构造器使用（QueryWrapper） 执行单表操作的 like > < is ...
MyBatis-Plus条件查询——Wrapper
01-05 7835
在MyBatis-Plus中，对于单表的查询我们基本上不用写sql语句的，那么对于一些带有条件判断的sql语句怎么办呢，官方提供了一个很强的东西——Wrapper条件构造器。环境搭建虽然上一篇文章已经搭建过环境了吧，但是我不太喜欢放链接跳来跳去的，再搭建一次吧。首先创建一张数据库表 DROP TABLE IF EXISTS user; CREATE TABLE user ( id BIGINT(20) NOT NULL COMMENT '主键ID', name VARCH
mybatis select 返回值long null_Mybatis源码阅读(二)
weixin_39869593的博客
11-28 174
点击上方蓝字关注我！正文共：10889字14图预计阅读时间：28分钟本文主要介绍Java中，不使用XML和使用XML构建SqlSessionFactory，通过SqlSessionFactory 中获取SqlSession的方法，使用SqlsessionManager管理Sqlsession复用等等..以及相关的示例代码SqlSessionSqlSessions 是由 SqlSes...
MyBatisPlus学习笔记 学习使用看这一篇就够了
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
04-30 1705
文章目录前言导航工具接口及类BaseMapperIService与ServiceImpl(接口定义与实现)IPage与Page一、springboot集成Mybatis plus实现CRUD二、通用IService使用三、分页查询3.1、借助mp的分页插件3.2、XML 自定义分页3.3、第三方插件：PageHelper四、条件构造器wrapper相关条件构造器4.1、QueryWrapper（独有select）4.2、UpdateWrapper（独有set方法）五、全局id生成策略六、逻辑删除七、自动填充
MyBatis入门
Yuncoco的博客
07-13 326
一、创建项目 二、导包 核心包 mybatis-3.2.1.jar 依赖包 asm-3.3.1.jar cglib-2.2.2.jar commons-logging-1.1.1.jar javassist-3.17.1-GA.jar log4j-1.2.17.jar slf4j-api-1.7.2.jar slf4j-log4j12-1.7.2.jar 数据库驱动包 mysql-connecto...
mybatisPlus的条件构造以及Optional的简单使用
qq_41889899的博客
08-04 3102
使用mybatisplus进行条件构造时不再使用平常的newQueryWrapper而是使用lambdaQuery 这样可以规避使用字符串来进行编写代码 如下: List<MessageStatus> rocketMqEntities = rocketMqRepository.selectList( Wrappers.<MessageStatus>lambdaQuery().eq(MessageStatus::getStatus, Messag.
MyBatis
R的博客
05-19 199
MyBatis 解决的主要问题 减轻使用 JDBC 的复杂性，不用编写重复的创建 Connetion , Statement ; 不用编写关闭资源代码。 直接使用 java 对象，表示结果数据。让开发者专注 SQL 的处理。 其他分心的工作由 MyBatis 代劳。 MyBatis 可以完成 1. 注册数据库的驱动，例如 Class.forName(“com.mysql.jdbc.Driver”)) 2. 创建 JDBC 中必须使用的 Connection ， St...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

☞^O^☜♞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值