准备工作
创建数据库
创建数据库以及表
创建数据库并设置字符集为utf-8：
CREATE DATABASE `mp` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
创建表和测试数据：
--
-- 表的结构 `tb_user`
--
CREATE TABLE IF NOT EXISTS `tb_user` (
`id` bigint(20) NOT NULL COMMENT '主键ID',
`user_name` varchar(20) NOT NULL COMMENT '用户名',
`password` varchar(20) NOT NULL COMMENT '密码',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
`birthday` datetime DEFAULT NULL
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
--
-- 表中的数据 `tb_user`
--
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`, `birthday`) VALUES
(1, 'zhangsan', '123456', '张三', 18, '[email protected]', '2022-03-09 00:00:00'),
(2, 'lisi', '123456', '李四', 20, '[email protected]', '2022-03-09 00:00:00'),
(3, 'wangwu', '123456', '王五', 28, '[email protected]', '2022-03-09 00:00:00'),
(4, 'zhaoliu', '123456', '赵六', 21, '[email protected]', '2022-03-09 00:00:00'),
(5, 'sunqi', '123456', '孙七', 24, '[email protected]', '2022-03-09 00:00:00');
工程搭建
工程结构
创建工程
创建maven工程，分别填写GroupId ArtifactId和Version，如下：
<groupId>cn.yyl.mp</groupId>
<artifactId>yyl-mp-springboot</artifactId>
<version>1.0-SNAPSHOT</version>
导入依赖
导入maven依赖，由于本例采用Spring boot技术，使用mybatis-plus-boot-starter能与其便捷集成： 版本规划：
Spring boot： 2.1.3.RELEASE
mybatis-plus： 3.1.0
pom文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
</parent>
<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>
</dependency>
<!--简化代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!--mybatis-plus的springboot支持-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
</dependencies>
</project>
编写application.properties
spring.application.name = yyl-mp-springboot
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
# Logger Config
logging.level.root: debug
编写pojo
package cn.yyl.mp.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import java.time.LocalDateTime;
/**
* @author Administrator
* @version 1.0
**/
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
@TableId(value = "id",type= IdType.ID_WORKER)//指定主键的字段名
private Long id;
@TableField("user_name")//指定对应字段名
private String userName;
@TableField("PASSWORD")
private String password;
@TableField("NAME")
private String name;
@TableField("AGE")
private Integer age;
@TableField("EMAIL")
private String email;
@TableField("BIRTHDAY")
private LocalDateTime birthday;
}
注解说明：
lomlok：
@Data：lombok的注解，使用它可以省略getter/setter方法。
@NoArgsConstructor： 生成无参构造 方法
@AllArgsConstructor：生成所有参数构造 方法，参数顺序与属性定义顺序一致。
mybaits-plus：
@TableName：指定表名
@TableId：指定主键名
@TableField：指定列名
编写mapper
package cn.yyl.mp.mapper;
import cn.yyl.mp.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* Created by Administrator.
*/
public interface UserMapper extends BaseMapper<User> {
}
该mapper类继承mybatisplus中的BaseMapper类
BaseMapper类中有一些常用的数据库查询方法，使用Base类之外的查询方法可以自己手动配置xml实现：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.baomidou.mybatisplus.core.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
public interface BaseMapper<T> {
int insert(T entity);
int deleteById(Serializable id);
int deleteByMap(@Param("cm") Map<String, Object> columnMap);
int delete(@Param("ew") Wrapper<T> wrapper);
int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);
int updateById(@Param("et") T entity);
int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);
T selectById(Serializable id);
List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
T selectOne(@Param("ew") Wrapper<T> queryWrapper);
Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);
List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);
IPage<T> selectPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);
}
编写启动类
package cn.yyl.mp;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author Administrator
* @version 1.0
**/
@SpringBootApplication
@MapperScan("cn.yyl.mp.mapper") //设置mapper接口的扫描包
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class,args);
}
}
注解说明：
@SpringBootApplication springboot启动入口标识
@MapperScan("cn.yyl.mp.mapper") mapper接口的扫描包
测试
编写测试用例
编写UserMapper的测试用例 ，使用UserMapper查询用户列表。
在test下创建测试类，包名为 cn.yyl.mp。
package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
/**
* @author Administrator
* @version 1.0
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
UserMapper userMapper;
x
@Test
public void testSelect(){
//查询tb_user记录
List<User> users = userMapper.selectList(null);
System.out.println(users.toString());
}
}
运行测试
[
User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@itcast.cn, birthday=2022-03-09T00:00),
User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@itcast.cn, birthday=2022-03-09T00:00),
User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@itcast.cn, birthday=2022-03-09T00:00),
User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@itcast.cn, birthday=2022-03-09T00:00),
User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@itcast.cn, birthday=2022-03-09T00:00)
]
mybatisplus常见配置
在MP中有大量的配置，其中有一部分是Mybatis原生的配置，另一部分是MP的配置，详情： https://baomidou.com/pages/56bac0/
下面我们对常用的配置做讲解。
configLocations
configLocations即MyBatis 配置文件位置，如果您有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatis Configuration 的具体内容请参考MyBatis 官方文档
示例： 1 在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>
<settings>
<!--mapUnderscoreToCamelCase=true-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!--<plugins>-->
<!--<plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"></plugin>-->
<!--</plugins>-->
</configuration>
在application.properties下配置configLocations，如下：
#指定mybatis-config.xml的位置
mybatis-plus.config-location = classpath:mybatis/mybatis-config.xml
mapperLocations
#指定mapper文件位置
mybatis-plus.mapper-locations = classpath*:mybatis/mapper/*.xml
mapperLocations即MyBatis Mapper 所对应的 mapper配置 文件位置，如果您在 Mapper 中有自定义方法 （XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。
如果不配置mapperLocations时，mapper的xml文件存放路径需要和mapper class文件保持一致，文件名保持 一 致，如下：（还是配置好一些）
mapper.xml代码案例
新建UserMapper.xml：
可以将此文件放在resources/cn/itcast/mp/mapper下，这里我们直接放到mybatis/mapper/UserMapper.xml下，然后进行配置
#指定mapper文件位置
mybatis-plus.mapper-locations = classpath*:mybatis/mapper/*.xml
在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="cn.itcast.mp.mapper.UserMapper">
<select id="findById" resultType="user" parameterType="java.lang.Long">
select * from tb_user where id = #{id}
</select>
</mapper>
在UserMapper接口类中新增findById方法
package cn.itcast.mp.mapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* Created by Administrator.
*/
public interface UserMapper extends BaseMapper<User> {
public User findById(Long id);
}
在测试类中添加查找id 的方法
代码如下：
@Test
public void testFindByid(){
//查询tb_user记录
User user = userMapper.findById(2L);
System.out.println(user.toString());
}
运行结果：
注意：Maven 多模块项目的扫描路径需以 classpath*: 开头 （即加载多个 jar 包下的 XML 文件）
typeAliasesPackage
设置MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以 直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）
mybatis‐plus.type‐aliases‐package = cn.itcast.mp.pojo
mapUnderscoreToCamelCase
类型： boolean
默认值： true
是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java 属性名 aColumn（驼峰命名） 的类似映射。
注意： 在 MyBatis-Plus 中此属性默认值为true，用于生成最终的 SQL 语句 如果您的数据库命名符合规则无需使用 @TableField 注解指定数据库字段名
#开启自动驼峰映射
#mybatis-plus.configuration.map-underscore-to-camel-case=true
注意：配置configuration.map-underscore-to-camel-case则不能配置config-location
那么配置了config-location，在想配置mapUnderscoreToCamelCase 怎么办呢？
这里就用之前mybaits的配置就可以了，在mybatis/mybatis-config.xml中添加配置：
<settings>
<!--mapUnderscoreToCamelCase=true-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
就可以了
开启了自动转驼峰， 我们就可以屏蔽@TableField了，
再进行测试，没有问题
如果项目中有符合驼峰规则的定义也有不符合的，此时建议统一使用@TableField。
如果使用mybatis-config.xml的同时在application.properties配置mybatis-plus.configuration则报错
Property 'configuration' and 'configLocation' can not specified with together
解决方法： 只使用一种配置方法。
本案例屏蔽mybatis-plus.configuration.map-underscore-to-camel-case=true，在mybatis-config.xml中配置 settings。
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
mybaitsplus通用CRUD
通过前面的学习，我们了解到通过继承BaseMapper就可以获取到各种各样的单表操作，接下来我们将详细讲解这 些操作，下图是BaseMapper的各各方法：
插入操作
方法定义
/**
* 插入一条记录
* **
* @param entity 实体对象
*/
int insert(T entity);
该方法返回的result是受影响的行数，并不是自增后的id
测试用例
//插入
@Test
public void testInsert(){
User user = new User();
// user.setId(100L);
user.setName("曹操");
user.setPassword("111111");
user.setAge(20);
user.setUserName("caocao");
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-DD HH:mm:ss");
LocalDateTime localDateTime = LocalDateTime.parse("1990-01-01 00:00:00", dateTimeFormatter);
user.setBirthday(localDateTime);
int i = userMapper.insert(user);
System.out.println(i);
//自增后的id会回填到对象中
System.out.println(user.getId());
}
mybaitsplus主键生成策略
上例中Mybatis-plus自动生成ID，如何设置id的生成策略呢？
MP支持的id策略如下：
package com.baomidou.mybatisplus.annotation;
import lombok.Getter;
/**
*生成ID类型枚举类
*
*@author hubin
* @since 2015‐11‐10
*/ @Getter
public enum IdType {
/**
* 数据库ID自增
*/
AUTO(0),
/**
* 该类型为未设置主键类型
*/
NONE(1),
/**
* 用户输入ID
* <p>该类型可以通过自己注册自动填充插件进行填充</p>
*/
INPUT(2),
/**
* 全局唯一ID (idWorker)
*/
ID_WORKER(3),
/**
* 全局唯一ID (UUID)
*/
UUID(4),
/**
* 字符串全局唯一ID (idWorker 的字符串表示)
*/
ID_WORKER_STR(5);
private final int key;
IdType(int key) {
this.key = key;
}
}
在对象类中添加对应注解即可，例如下面这样
下面我们具体说一下每个主键：
设置自增主键
设置完全采用数据库自增主键方式。
-
设置mysql数据库主键为自增
-
修改User对象：
@TableId(value = "ID", type = IdType.AUTO) private Long id; 或: @TableId(value = "ID") private Long id; -
程序中不用设置主键
设置输入主键：
手动设置主键值。
- mysql数据库主键为自增或不是自增都可以
- 修改User对象：
@TableId(value = "ID",type = IdType.INPUT) private Long id; - 程序中需要设置主键
UUID：
生成全局唯一ID。
-
mysql数据库主键为字符串类型，不是自增类型。
-
修改User对象。
@TableId(value = "ID",type = IdType.UUID) private String id; -
程序中不用设置主键
ID_WORKER_STR：
采用雪花片算法（雪花算法生成的ID是纯数字且具有时间顺序，适合分布式场景）生成全局唯一ID，字符串类型。
-
mysql数据库主键为字符串类型，不是自增类型。
-
修改User对象。
@TableId(value = "ID",type = IdType.ID_WORKER_STR) private String id; -
程序中不用设置主键
ID_WORKER：
采用雪花片算法生成全局唯一ID，数值类型。
- mysql数据库主键为数值类型，不是自增类型。
- 修改User对象。
@TableId(value = "ID",type = IdType.ID_WORKER) private Long id; - 程序中不用设置主键
更新操作
根据id更新
方法定义：
/**
*根 据 ID 修 改
*
*@param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);
方法步骤
根据id更新操作步骤：
- 首先需要设置对象的主键属性值。
- 再设置要更新的属性值。
- 根据主键找到对象，更新设置属性值。
- 返回影响的记录数。
注意：只能将对象中不为NULL的属性更新到表中。
测试案例：
@Test
public void testUpdate(){
User user = new User();
//更新记录的主键值
user.setId(2L);
user.setAge(100);//要更新的值
user.setPassword("12222");//要更新的值
//只将对象中不为NULL的值更新到数据库中
int i = userMapper.updateById(user);
System.out.println(i);
System.out.println(user);
}
运行结果：
数据库更新结果：
根据条件更新
方法定义：
/**
*根据 whereEntity 条件，更新记录
*
*@param entity 实体对象 (set 条件值,可以为 null)
*@param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(
@Param(Constants.ENTITY) T entity,
@Param(Constants.WRAPPER) Wrapper<T> updateWrapper
);
根据ID更新一次只能更新一条记录，根据条件更新可实现批量更新。
更新步骤：
根据条件更新步骤：
- 在对象中设置要更新的属性值。
- 设置QueryWrapper，设置更新条件，可以设置多个。
- 返回影响的记录数。
注意：只能将对象中不为NULL的属性更新到表中。
测试用例：下次将name等于“曹操”的记录全部更新。
//根据条件进行更新
@Test
public void testUpdate2(){
User user = new User();
user.setAge(100);//要更新的值
user.setPassword("12222");//要更新的值
//设置条件
QueryWrapper<User> queryWrapper =new QueryWrapper<>();
queryWrapper.eq("name","曹操");
//只将对象中不为NULL的值更新到数据库中
int i = userMapper.update(user,queryWrapper);
System.out.println(i);
}
数据库更新结果：
根据条件更新（可以更新NULL）
上边根据id更新 根据条件更新的方法只能将对象中不为NULL的属性更新到表中，下边通过UpdateWrapper进行更新，将birthday字段更新为NULL。
//根据条件进行更新，可以将为NULl的值更新到数据库
@Test
public void testUpdate3(){
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name","曹操").set("birthday",null);
//只将对象中不为NULL的值更新到数据库中
int i = userMapper.update(null,updateWrapper);
System.out.println(i);
}
还可以同时更新多个属性
//根据条件进行更新，可以将为NULl的值更新到数据库
@Test
public void testUpdate4(){
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name","曹操").set("age", 999).set("birthday",null);
//只将对象中不为NULL的值更新到数据库中
int i = userMapper.update(null,updateWrapper);
System.out.println(i);
}
删除操作
根据id删除
方法定义：
/**
*根 据 ID 删 除
*
*@param id 主键ID
*/
int deleteById(Serializable id);
删除步骤：
- 指定要删除记录的主键值。
- 调用deleteById方法执行删除。
测试用例：
@Test
public void testDeleteById() {
//执行删除操作
int result = this.userMapper.deleteById(6L);
System.out.println("result = " + result);
}
根据 entity 条件删除
方法定义：
/**
*根据 entity 条件，删除记录
*
*@param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
删除步骤：
根据条件删除步骤：
- 定义对象，设置属性值，指定删除条件 ，可指定多个删除条件注意：删除条件只匹配对象中不为NULL的属性值
- 设置QueryWrapper
- 执行删除
测试案例：
@Test
public void testDelete(){
//设置条件
User user = new User();
user.setAge(999);
user.setName("曹操1");
QueryWrapper<User> queryWrapper =new QueryWrapper<>(user);
//根据条件删除
int delete = userMapper.delete(queryWrapper);
System.out.println(delete);
}
注意：定义QueryWrapper可以不包装模型对象，手动设置条件，如下：
@Test
public void testDelete(){
//设置条件
QueryWrapper<User> queryWrapper =new QueryWrapper<>();
queryWrapper.eq("age",999);
queryWrapper.eq("name","曹操1");
//根据条件删除
int delete = userMapper.delete(queryWrapper);
System.out.println(delete);
}
上面两种写法是一样的，运行结果如下：
影响了一行，看一下数据库前后，确实删掉了：
根据ID 批量删除
方法定义：
/**
*删除（根据ID 批量删除）
*
*@param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
删除步骤：
批量删除操作步骤：
- 指定 id列表
- 执行删除
测试案例：
删除id为101、102、103的
//批量删除
@Test
public void testDelete2(){
//根据条件删除
int delete = userMapper.deleteBatchIds(Arrays.asList(101L,102L,103L));
System.out.println(delete);
}
查询操作
MP提供了多种查询操作，包括根据id查询 批量查询 查询单条数据 查询列表 分页查询等操作。
根据id查询
方法定义：
/**
*根 据 ID 查 询
*
*@param id 主键ID
*/
T selectById(Serializable id);
查询步骤：
根据id查询步骤：
- 设置查询记录的主键值。
- 执行查询。
- 查询结果返回一个对象。
注意：这里返回的就是对象了，之前都是返回影响的行数。
测试用例：
@Test
public void testSelectById() {
//根据id查询数据
User user = this.userMapper.selectById(2L);
System.out.println("result = " + user);
}
查询结果：
根据id批量查询
方法定义：
/**
*查询（根据ID 批量查询）
*
*@param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
查询步骤：
根据id列表查询：
- 设置id列表
- 执行查询
- 查询对象返回List
注意：这里返回的就是对象list了
测试案例：
@Test
public void testSelectBatchIds() {
//根据id集合批量查询
List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
for (User user : users) {
System.out.println(user);
}
}
查询结果：
根据 entity 条件查询一条记录
方法定义：
/**
*根据 entity 条件，查询一条记录
*
*@param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
查询步骤：
- 设置QueryWrapper对象，设置查询条件，可以设置多个条件
- 执行查询
注意：如果查询结果为多条记录则报错（TooManyResultsException）。
测试案例：
@Test
public void testSelectOne(){
QueryWrapper<User> queryWrapper =new QueryWrapper<>();
queryWrapper.eq("name","张三");
//根据条件查询，只能查询出一条记录，否则报错
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
查询结果：
根据 Wrapper 条件查询总记录数
方法定义：
/**
*根据 Wrapper 条件，查询总记录数
*
*@param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
测试案例：
@Test
public void testSelectCount() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据条数
Integer count = this.userMapper.selectCount(wrapper);
System.out.println("count = " + count);
}
运行结果为：count = 2
点进gt方法的声明类里，还可以看到其的 Wrapper 条件：
根据 entity 条件查询全部记录
方法定义：
/**
*根据 entity 条件，查询全部记录
*
*@param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
测试案例：
@Test
public void testSelectList() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23);
//年龄大于23岁
// 根据条件查询数据
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
运行结果为：
根据 entity 条件查询全部记录（并翻页）
方法定义：
/**
*根据 entity 条件，查询全部记录（并翻页）
*
*@param page 分页查询条件（可以为 RowBounds.DEFAULT）
*@param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
测试案例：
@Test
public void testSelectPage() {
//条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// queryWrapper.eq("name","张三");//等于
queryWrapper.gt("age", 20);//大于?
//用构造方法设置当前页码，每页记录数
int pageIndex = 2;//当前页码
int size = 3;//每页记录数
Page<User> page = new Page<>(pageIndex, size);
IPage<User> userIPage = userMapper.selectPage(page, queryWrapper);
// 打印一下记录信息
long pages = userIPage.getPages();//总页数
long total = userIPage.getTotal();//总记录数
System.out.println("数据总条数 ：" + total);
System.out.println("总页数：" + pages);
//记录列表
List<User> records = userIPage.getRecords();
System.out.println(records);
}
运行结果：
2022-03-23 21:14:39.335 DEBUG 138796 --- [ main] c.b.m.e.p.p.o.JsqlParserCountOptimize : JsqlParserCountOptimize sql=SELECT id,user_name,password,name,age,email,birthday FROM tb_user
WHERE age > ?
2022-03-23 21:14:39.372 DEBUG 138796 --- [ main] c.i.mp.mapper.UserMapper.selectPage : ==> Preparing: SELECT COUNT(1) FROM tb_user WHERE age > ?
2022-03-23 21:14:39.402 DEBUG 138796 --- [ main] c.i.mp.mapper.UserMapper.selectPage : ==> Parameters: 20(Integer)
2022-03-23 21:14:39.558 DEBUG 138796 --- [ main] c.i.mp.mapper.UserMapper.selectPage : ==> Preparing: SELECT id,user_name,password,name,age,email,birthday FROM tb_user WHERE age > ? LIMIT ?,?
2022-03-23 21:14:39.559 DEBUG 138796 --- [ main] c.i.mp.mapper.UserMapper.selectPage : ==> Parameters: 20(Integer), 3(Long), 3(Long)
2022-03-23 21:14:39.715 DEBUG 138796 --- [ main] c.i.mp.mapper.UserMapper.selectPage : <== Total: 3
2022-03-23 21:14:39.716 DEBUG 138796 --- [ main] org.mybatis.spring.SqlSessionUtils : Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7fd987ef]
数据总条数 ：6
总页数：2
[User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@itcast.cn, birthday=2022-03-09T00:00), User(id=1506541267385905153, userName=caocao, password=12222, name=曹操, age=999, email=null, birthday=null), User(id=1506541407249121282, userName=caocao, password=12222, name=曹操, age=999, email=null, birthday=null)]
条件构造器
在MP中，Wrapper接口的实现类关系如下：
在MP查询中，还可以使用lambda方式查询，降低数据库列表写错的风险。
Wrapper中基本比较操作
| 操作方法 | 方法说明 |
|---|---|
eq |
等于 = |
ne |
不等于 <> |
gt |
大于 > |
ge |
大于等于 >= |
lt |
小于 < |
le |
小于等于 <= |
between |
BETWEEN 值1 AND 值2 |
notBetween |
NOT BETWEEN 值1 AND 值2 |
in |
字段 IN (value.get(0), value.get(1), …) |
notIn |
字段 NOT IN (v0, v1, …) |
测试案例：
@Test
public void testEqCp() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
wrapper.eq("password", "123456")
.ge("age", 20)
.in("name", "李四", "王五", "赵六");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
也可以用Lambda方式构造条件：
@Test
public void testEqCp() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
wrapper.eq(User::getPassword, "123456")
.ge(User::getAge, 20)
.in(User::getName, "李四", "王五", "赵六");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
上面是最简单的查询方法，通常在开发中要根据表达式进行判断，表达式为true则拼接条件，如下：
eq(boolean condition, R column, Object val)
in(boolean condition, R column, Object... values) ...
上面代码中的condition就是要进行计算的表达式，最终表达式结果为boolean类型。
举个例子：
比如根据name来判断，如果name不为空则拼接条件 String name = null;
wrapper.eq(User::getPassword, "123456")
.ge(User::getAge, 20)
.in(name!=null,User::getName, "李四", "王五", "赵六");
下面那个具体的案例，条件查询测试案例：
@Test
public void testEq3() {
//条件
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
String name = null;
Integer age = 20;
queryWrapper.eq(name != null && !name.equals(""), User::getName, name);//等于
queryWrapper.gt(age != null, User::getAge, age);//大于?
List<User> users = userMapper.selectList(queryWrapper);
System.out.println(users);
}
模糊查询
like ：
LIKE '%值%'
例: like("name", "王") ---> name like '%王%'
notLike：
NOT LIKE '%值%'
例: notLike("name", "王") ---> name not like '%王%'
likeLeft ：
LIKE '%值'
例: likeLeft("name", "王") ---> name like '%王'
likeRight ：
LIKE '值%'
例: likeRight("name", "王") ---> name like '王%'
测试案例：
@Test
public void testWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE name LIKE ?
//Parameters: %曹%(String)
wrapper.likeRight("name", "曹");
wrapper.select("id", "name","birthday");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
运行结果为：
逻辑查询
or
拼接 OR
主动调用 or 表示紧接着下一个**方法**不是用 and 连接!(不调用 or 则默认为使用 and 连接)
and
AND 嵌套
例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')
测试案例：
@Test
public void testOr() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? OR age = ?
wrapper.eq("name", "李四").or().eq("age", 24);
//变为and方式
wrapper.eq("name", "李四").eq("age", 24);
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
将上面代码改为lambda方式构造条件：
@Test
public void testOr() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? OR age = ?
wrapper.eq(User::getName,"李四").or().eq(User::getAge, 24);
//变为and方式
wrapper.eq(User::getName, "李四").eq(User::getAge", 24);
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
select
在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段。
测试案例：
@Test
public void testWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>(); //SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
wrapper.eq("name", "李四")
.or()
.eq("age", 24)
.select("id", "name", "age");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
Lambda方式构造条件：
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "李四")
.or()
.eq(User::getAge, 24)
.select(User::getId, User::getName, User::getAge);
排序
orderByAsc ：升序排序
参数：变长数组，设置多个字段名
例: orderByAsc("id", "name") ---> order by id ASC,name ASC
orderByDesc ：降序排序
参数：变长数组，设置多个字段名
例: orderByDesc("id", "name") ---> order by id DESC,name DESC
orderBy ： 自定义排序规则
方法定义：orderBy(boolean condition, boolean isAsc, R... columns)
参数1：true有效，false无效 ，参数2：是否升序，参数3..设置多个字段
例: `orderBy(true, true, "id", "name")`‐‐‐>`order by id ASC,name ASC`
也可以多个orderBy拼装，如下：
orderBy(true, true, "id").orderBy(true, true, "name")
效果同上面语句。
测试案例：
@Test
public void testOrder() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age DESC
wrapper.orderByDesc("age");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
Lambda方式构造条件：
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.orderByDesc(User::getAge);