一、查询
构造器分为QueryWrapper和LambdaQueryWrapper
创建实体类User
package com.system.mybatisplus.model;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.Data;import java.io.Serializable;@TableName("user") // 指定表名,如果表名和类名一致,可以省略
@Data // 使用Lombok简化开发
public class User implements Serializable { // 实现序列化接口@TableId(type = IdType.AUTO)private Long id;@TableField("name") // 指定表字段名,如果字段名和属性名一致,可以省略private String name;// @TableField(select = false) // select = false 表示查询时不查询该字段private Integer age;private String email;@TableField(exist = false) // exist = false 表示该字段不是数据库字段,但是可以使用private Boolean isOnline;
}
编写mapper接口UserMapper
package com.system.mybatisplus.mapper;import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.system.mybatisplus.model.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;@Mapper // 此注解用于标记这是一个mybatis的mapper类,否则会报错,因为没有加@Mapper
public interface UserMapper extends BaseMapper<User> {// 继承BaseMapper// 根据名称查询User selectByName(@Param("name") String name);
}
编写service及其实现类
package com.system.mybatisplus.service;import com.baomidou.mybatisplus.extension.service.IService;
import com.system.mybatisplus.model.User;
// 需要继承IService
public interface UserService extends IService<User> {}
package com.system.mybatisplus.service.impl;import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.system.mybatisplus.mapper.UserMapper;
import com.system.mybatisplus.model.User;
import com.system.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;@Service // 此注解用于标记这是一个service类,否则会报错,因为没有加@Service
// 此处继承ServiceImpl(ServiceImpl实现了IService接口),同时实现UserService接口
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
1、等值查询
查询条件必须完全匹配才行,可以拼接多个eq
@Testvoid testEq() {// 1、创建条件构造器QueryWrapper<User> wrapper = new QueryWrapper<>();// 2、设置条件,指定字段名和字段值wrapper.eq("name", "jone");// 3、执行查询,使用selectOne方法,查询结果只能有一条,否则报错,如果查询结果有多条,使用selectList方法System.out.println(userMapper.selectList(wrapper));}
@Testvoid testEq() {// 简写System.out.println(userMapper.selectList(new QueryWrapper<User>().eq("name", "jone")));}
相当于执行了如下SQL
SELECT id,name,age,email FROM user WHERE (name = ?)
可以使用LambdaQueryWrapper
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "jone"); // 等价于wrapper.eq("name", "jone"); 但是这样写更安全,因为不会出现字段名写错的情况
System.out.println(userMapper.selectList(wrapper));
同时多个查询条件,必须同时满足才行
@Testvoid testEq() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.eq(User::getName, "jone").eq(User::getAge, 19); // 相当于并列条件System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (name = ? AND age = ?)
空值null的判断与处理
当某个查询条件值为空时,不参与拼接
一般用于多条件查询中
@Testvoid testNull() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();String name = "jone";// 查询条件是否为null的判断wrapper.eq(name != null, User::getName, name); // 如果name不为空,就加入条件,否则不加入条件System.out.println(userMapper.selectOne(wrapper));}
多条件查询也可以使用allEq
使用HashMap存储查询条件,就没法使用LambdaQueryWrapper
@Testvoid testAllEq() {QueryWrapper<User> wrapper = new QueryWrapper<>();HashMap<String, Object> map = new HashMap<>();map.put("name", "jone");map.put("age", 19);wrapper.allEq(map, false); // 等价于wrapper.eq("name", "jone").eq("age", 19); 如果第二个参数为false,表示如果map中有null值,就不加入条件System.out.println(userMapper.selectList(wrapper));}
除了eq,还有ne,即不等值查询
@Testvoid testNe() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.ne("name", "jone"); // 不等于System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (name <> ?) <> 不等于
2、范围查询
- gt 大于
@Testvoid testGt() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.gt("age", 20); // 大于,适用于数据类型为数字的字段和日期类型的字段System.out.println(userMapper.selectList(wrapper));}
- ge 大于等于
@Testvoid testGe() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.ge("age", 20); // 大于等于,适用于数据类型为数字的字段和日期类型的字段System.out.println(userMapper.selectList(wrapper));}
- lt 小于
@Testvoid testLt() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.lt("age", 20); // 小于,适用于数据类型为数字的字段和日期类型的字段System.out.println(userMapper.selectList(wrapper));}
- le 小于等于
@Testvoid testLe() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.le("age", 20); // 小于等于,适用于数据类型为数字的字段和日期类型的字段System.out.println(userMapper.selectList(wrapper));}
- between
@Testvoid testBetween() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.between(User::getAge, 18, 20); // 适用于数据类型为数字的字段和日期类型的字段, 包含18和20System.out.println(userMapper.selectList(wrapper));}
- notBetween
@Testvoid testNotBetween() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.notBetween(User::getAge, 18, 20); // 适用于数据类型为数字的字段和日期类型的字段, 不包含18和20System.out.println(userMapper.selectList(wrapper));}
3、模糊查询
- like
@Testvoid testLike() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.like(User::getName, "j"); // 模糊查询System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (name LIKE %j%)
- notLike
查询名称中不含 j的,不区分大小写
@Testvoid testLike() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.notLike(User::getName, "j"); // 模糊查询System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (name NOT LIKE %j%)
- likeLeft
区分大小写
@Testvoid testLikeLeft() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.likeLeft(User::getName, "j"); // 左模糊查询, 等价于wrapper.like(User::getName, "%j")System.out.println(userMapper.selectList(wrapper));}
- likeRight
@Testvoid testLikeRight() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// 查找名字以j开头的用户,区分大小写wrapper.likeRight(User::getName, "j"); // 右模糊查询, 等价于wrapper.like(User::getName, "j%")System.out.println(userMapper.selectList(wrapper));}
4、判空查询
- isNull
@Testvoid testIsNull() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.isNull(User::getEmail); // 查找email为null的用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (email IS NULL)
- isNotNull
@Testvoid testIsNull() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.isNotNull(User::getEmail); // 查找email不为null的用户System.out.println(userMapper.selectList(wrapper));}
5、包含查询
- in
@Testvoid testIn() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.in(User::getAge, Arrays.asList(18,19,20)); // 查找年龄为18,19,20的用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (age IN (?,?,?))
- notIn
@Testvoid testNotIn() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.notIn(User::getAge, Arrays.asList(18,19,20)); // 查找年龄不为18,19,20的用户System.out.println(userMapper.selectList(wrapper));}
- inSql
可以编写嵌套查询
@Testvoid testInSql() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.inSql(User::getId, "select id from user where id < 3"); // 查找id小于3的用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (id IN (select id from user where id < 3))
- notInSql
@Testvoid testNotInSql() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.notInSql(User::getId, "select id from user where id < 3"); // 查找id不小于3的用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (id NOT IN (select id from user where id < 3))
6、分组查询
使用groupBy分组
@Testvoid testGroupBy() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.groupBy("age"); // 按照年龄分组// 这里使用字符串的方式,所以只能使用QueryWrapper,不能使用LambdaQueryWrapperwrapper.select("age, count(*) as count"); // 查询年龄和年龄的数量System.out.println(userMapper.selectMaps(wrapper)); // 返回类型为List<Map<String, Object>>}
SELECT age, count(*) as count FROM user GROUP BY age
7、聚合查询
在6的基础上,过滤出count大于等于2的数据,就需要使用having过滤
先分组,再查询,最后过滤
@Testvoid testHaving() {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.groupBy("age"); // 按照年龄分组wrapper.select("age, count(*) as count"); // 查询年龄和年龄的数量wrapper.having("count >= 2"); // 查询数量大于等于2的年龄System.out.println(userMapper.selectMaps(wrapper)); // 返回类型为List<Map<String, Object>>}
SELECT age, count(*) as count FROM user GROUP BY age HAVING count >= 2
[{count=2, age=18}, {count=2, age=20}]
8、排序查询
- orderByASC 升序
@Testvoid testOrderByAsc() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.select(User::getId, User::getName, User::getAge); // 查询id, name, age字段wrapper.orderByAsc(User::getAge); // 按照年龄升序排序System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age FROM user ORDER BY age ASC
- orderByDesc 降序
@Testvoid testOrderByDesc() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.select(User::getId, User::getName, User::getAge); // 查询id, name, age字段wrapper.orderByDesc(User::getAge); // 按照年龄降序排序System.out.println(userMapper.selectList(wrapper));}
- orderBy
相比较前面两个,灵活性更高
@Testvoid testOrderBy() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.select(User::getId, User::getName, User::getAge); // 查询id, name, age字段// 第一个参数表示当该字段值为null时,是否还要作为排序条件// 第二个参数表示是否升序排序// 第三个参数表示排序的字段wrapper.orderBy(true, true, User::getAge); // 按照年龄升序排序// 当年龄相同时,按照id降序排序wrapper.orderBy(true, false, User::getId); // 按照id降序排序System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age FROM user ORDER BY age ASC,id DESC
9、逻辑查询
(1)内嵌逻辑查询func
当某个需求的条件有多个时,可以使用func
@Testvoid testFunc() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// func函数需要传入一个Consumer接口,该接口的accept方法接收一个LambdaQueryWrapper对象wrapper.func(new Consumer<LambdaQueryWrapper<User>>() {@Overridepublic void accept(LambdaQueryWrapper<User> userLambdaQueryWrapper) {// 这里需要使用实际开发中的业务逻辑来替换if(true) {userLambdaQueryWrapper.eq(User::getId, 1);}else {userLambdaQueryWrapper.ne(User::getId, 1);}}});System.out.println(userMapper.selectList(wrapper));}
@Testvoid testFunc() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// func函数需要传入一个Consumer接口,该接口的accept方法接收一个LambdaQueryWrapper对象// 使用Lambda表达式来简化代码wrapper.func(userLambdaQueryWrapper -> {// 这里需要使用实际开发中的业务逻辑来替换if(true) {userLambdaQueryWrapper.eq(User::getId, 1);}else {userLambdaQueryWrapper.ne(User::getId, 1);}});System.out.println(userMapper.selectList(wrapper));}
(2)and
正常的拼接默认就是and,表示条件需要同时成立
@Testvoid testAnd() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.gt(User::getAge, 18).lt(User::getAge, 25); // 查询年龄大于18并且小于20的用户System.out.println(userMapper.selectList(wrapper));}
使用and嵌套
通常需要嵌套or
@Testvoid testAnd() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.eq(User::getId, 1).and(userLambdaQueryWrapper -> userLambdaQueryWrapper.eq(User::getAge, 18).or().eq(User::getAge, 20)); // 查询id为1并且年龄为18或20的用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (id = ? AND (age = ? OR age = ?))
(3)or
表示多个条件只需要成立其中之一即可
@Testvoid testOr() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.gt(User::getAge, 25).or().lt(User::getAge, 20); // 查询年龄大于25或小于20的用户System.out.println(userMapper.selectList(wrapper));}
or也可以嵌套
(4)nested
表示嵌套查询
@Testvoid testNested() {// nested表示嵌套查询, 用于构建复杂的查询条件LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.eq(User::getId, 1).nested(userLambdaQueryWrapper -> userLambdaQueryWrapper.eq(User::getAge, 18).or().eq(User::getAge, 20)); // 查询id为1并且年龄为18或20的用户System.out.println(userMapper.selectList(wrapper));}
10、自定义查询
使用apply函数
可以定制更复杂的查询条件
@Testvoid testApply() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// apply方法用于拼接SQL语句,这里需要使用实际开发中的业务逻辑来替换wrapper.apply("id = 1"); // 查询id为1的用户System.out.println(userMapper.selectList(wrapper));}
11、last
last主要用于分页查询中,需要传入字符串参数
@Testvoid testLast() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.last("limit 1"); // 查询第一个用户System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user limit 1
@Testvoid testLast() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.last("limit 0, 2"); // 查询前两条数据System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user limit 0, 2
12、exists
@Testvoid testExists() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// 查询age为18的用户是否存在,如果存在则返回true,否则返回false// 返回true后,会继续执行后面的查询操作wrapper.exists("select id from user where age = 18");System.out.println(userMapper.selectList(wrapper));}
SELECT id,name,age,email FROM user WHERE (EXISTS (select id from user where age = 18))
@Testvoid testNotExists() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// 查询age为18的用户是否不存在,如果不存在则返回true,否则返回false// 返回true后,会继续执行后面的查询操作wrapper.notExists("select id from user where age = 18");System.out.println(userMapper.selectList(wrapper));}
二、主键策略
1、AUTO
需要在表的主键上设置自增,然后在实体类上的对应的属性上加上注解
@TableId(type = IdType.AUTO)
private Long id;
这样设置后,每次增加一条数据时,会自动生成对应的id
2、INPUT
不需要在表的主键上设置自增,每次新增数据时需要自己设置id
@TableId(type = IdType.AUTO)
private Long id;
3、ASSIGN_ID
使用雪花算法可以实现有序、唯一、且不直接暴露排序的数字
@TableId(type = IdType.ASSIGN_ID)
private Long id;
4、NONE
使用该策略表示不指定主键生成策略,而是跟随全局策略,可以在配置文件中使用id-type指定全局主键策略
@TableId(type = IdType.NONE)
private Long id;
5、ASSIGN_UUID
UUID是全局唯一标识符,定义为一个字符串主键,采用32位字符组成,保证始终唯一,需要设置id的类型为字符串
@TableId(type = IdType.ASSIGN_UUID)
private Long id;
三、分页查询
首先需要编写配置类
以下适用于mybatis-plus 3.5以上版本
@Configuration
// @MapperScan("com.system.mybatisplus.mapper") // 如果在启动类上已经配置了,这里就不需要再配置了
public class MybatisPlusConfig {@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();// DbType.MYSQL 表示数据库类型是mysqlinterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));return interceptor;}
}
测试
@Testvoid testPage() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();// 创建一个分页对象,传入两个参数:当前页和每页显示的记录数IPage<User> pageParam = new Page<>(1, 2);// 调用分页查询的方法,将分页对象和查询条件对象传入userMapper.selectPage(pageParam, wrapper);// 从分页对象中获取分页数据System.out.println("总页数:" + pageParam.getPages());System.out.println("总记录数:" + pageParam.getTotal());System.out.println("当前页码:" + pageParam.getCurrent());System.out.println("每页显示的记录数:" + pageParam.getSize());}
一般会自定义查询语句,所以通用的写法如下
controller中
@RestController
public class UserController {@Autowiredprivate UserService userService;@GetMapping("/users/{page}/{limit}")public IPage<User> listPage(@PathVariable("page") Long page, @PathVariable("limit") Long limit) {// 创建一个分页对象,传入两个参数:当前页和每页显示的记录数IPage<User> pageParam = new Page<>(page, limit);// 调用Service中的方法,一般还会传入一个条件查询对象return userService.listPage(pageParam);}
}
Service中
public interface UserService extends IService<User> {IPage<User> listPage(IPage<User> pageParam);
}
@Service // 此注解用于标记这是一个service类,否则会报错,因为没有加@Service
// 此处继承ServiceImpl(ServiceImpl实现了IService接口),同时实现UserService接口
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {@Autowiredprivate UserMapper userMapper;@Overridepublic IPage<User> listPage(IPage<User> pageParam) {return userMapper.selectUserByPage(pageParam);}
}
mapper中
@Mapper // 此注解用于标记这是一个mybatis的mapper类,否则会报错,因为没有加@Mapper
public interface UserMapper extends BaseMapper<User> {// 返回值是一个IPage对象IPage<User> selectUserByPage(IPage<User> pageParam); // 传入分页参数
}
<?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.system.mybatisplus.mapper.UserMapper"><select id="selectUserByPage" resultType="com.system.mybatisplus.model.User">select * from user</select>
</mapper>
四、SimpleQuery
SimpleQuery可以对selectList查询后的结果使用Stream流进行了一些封装,使其可以返回一些指定结果,简化了Api的调用。
1、list
例如,查询出所有User的姓名,返回一个List
使用Stream流
@Testvoid testList() {List<User> users = userMapper.selectList(null);// 自己调用Stream的ApiList<String> names = users.stream().map(User::getName).toList();names.forEach(System.out::println);}
使用SimpleQuery的list
// 必须传入一个wrapper,而不能写null
List<String> names = SimpleQuery.list(new LambdaQueryWrapper<User>(), User::getName);names.forEach(System.out::println);
获取年龄为20的用户姓名列表
List<String> names = SimpleQuery.list(new LambdaQueryWrapper<User>().eq(User::getAge, 20), User::getName);System.out.println(names);
[Jack, Billie]
2、map
可以指定键值对
以id为键,user对象为值
Map<Long, User> map = SimpleQuery.keyMap(new LambdaQueryWrapper<>(), User::getId);System.out.println(map);
只查询age为20的User
Map<Long, User> map = SimpleQuery.keyMap(new LambdaQueryWrapper<User>().eq(User::getAge, 20), User::getId);System.out.println(map);
以id为键,name为值
这里需要使用map方法,第二、三个参数分别表示要获得的键、值
Map<Long, String> longUserMap = SimpleQuery.map(new LambdaQueryWrapper<User>(), User::getId, User::getName);System.out.println(longUserMap);
{1=Jone, 2=Jack, 3=Tom, 4=Sandy, 5=Billie, 6=test}
3、group
可以按照字段进行分组
比如,按照年龄进行分组
使用group方法,第二个参数是待分组字段
Map<Integer, List<User>> group = SimpleQuery.group(new LambdaQueryWrapper<User>(), User::getAge);System.out.println(group);
五、逻辑删除
逻辑删除的目的是方便做统计,状态可恢复(用户的可用与禁用)
首先数据库中的表字段添加status
并使用默认值1,表示未删除
然后Java实体类添加对应的属性
@TableLogic(value = "1", delval = "0") // value是默认值,即未删除,delVal是删除时的值private Integer status;
测试
@Testvoid testLogicDelete() {userMapper.deleteById(4L);System.out.println(userMapper.selectList(null));}
首先执行
UPDATE user SET status=0 WHERE id=? AND status=1
将id为4的user的status更新为0,表示删除
然后再次查询
SELECT id,name,age,email,status FROM user WHERE status=1
查询时都会看status是否为1(未删除)
可以全局配置逻辑删除字段及其值
六、通用枚举
例如,对性别字段使用枚举
0–女性, 1–男性
数据库表中添加字段
Java中编写枚举
public enum GenderEnum {MAN(1, "男"), WOMAN(0, "女");@EnumValue // 表示插入到数据库中的是gender,即0或1private Integer gender;private String genderName;GenderEnum(Integer gender, String genderName){this.gender = gender;this.genderName = genderName;}
}
User属性
private GenderEnum gender; // 必须是gender,对应0或1
测试插入
@Testvoid testEnum() {User user = new User();user.setName("zzs");user.setGender(GenderEnum.MAN); // 使用枚举值userMapper.insert(user);}
测试查询
System.out.println(userMapper.selectList(null));
[User(id=1, name=Jone, age=18, email=test1@baomidou.com, isOnline=null, status=1, gender=MAN), User(id=2,
输出的gender是MAN
七、字段处理器
实体类中使用Map集合作为属性接受前端传递的数据,但是这些数据在数据库中存储时,是使用JSON格式的数据进行存储,JSON本质上是一个字符串,即数据库中的varchar类型。要将实体类的Map类型和数据库中的varchar类型的数据相互转换,可以使用字段处理器来完成。
首先在实体类中添加一个Map集合
private Map<String, String> contact; // 联系方式,可以有两种,即手机号和座机号
在数据库中添加对应的表字段contact,设置为varchar类型。
再次修改实体类,需要添加两个地方
@TableName(value = "user", autoResultMap = true) @TableField(typeHandler = FastjsonTypeHandler.class)
private Map<String, String> contact; // 联系方式,可以有两种,即手机号和座机号
整体代码如下:
// 使用字段处理器,需要 autoResultMap = true
@TableName(value = "user", autoResultMap = true) // 指定表名,如果表名和类名一致,可以省略
@Data
public class User implements Serializable { // 实现序列化接口@TableId(type = IdType.AUTO)private Long id;@TableField("name") // 指定表字段名,如果字段名和属性名一致,可以省略private String name;// @TableField(select = false) // select = false 表示查询时不查询该字段private Integer age;private String email;@TableField(exist = false) // exist = false 表示该字段不是数据库字段,但是可以使用private Boolean isOnline;@TableLogic(value = "1", delval = "0") // value是默认值,即未删除,delVal是删除时的值private Integer status;private GenderEnum gender;// 使用FastjsonTypeHandler@TableField(typeHandler = FastjsonTypeHandler.class)private Map<String, String> contact; // 联系方式,可以有两种,即手机号和座机号
}
添加fastjson依赖
<!-- fastjson--><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.31_noneautotype</version></dependency>
测试插入,即Map转JSON
@Testvoid testMapToJson(){User user = new User();user.setName("xxx");user.setAge(23);user.setGender(GenderEnum.MAN);// 添加Map集合Map<String, String> map = new HashMap<>();map.put("phone", "19122345566");map.put("tel", "001-123456");user.setContact(map);userMapper.insert(user);}
在数据库中contact字段存储如下
{"phone":"19122345566","tel":"001-123456"}
测试查询,即JSON转Map
@Testvoid testJsonToMap(){System.out.println(userMapper.selectList(null));}
contact={phone=19122345566, tel=001-123456}
八、自动填充
有一些属性,比如时间,我们可以设置为自动填充
在实体类User中添加两个属性
private Date createTime;private Date updateTime;
数据库对应字段 ,都是datetime类型
需要开启下划线和驼峰映射 map-underscore-to-camel-case: true
# mybatis-plus配置
mybatis-plus:global-config:banner: falseconfiguration:log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 打印sql语句map-underscore-to-camel-case: true # 下划线和小驼峰映射
设置自动填充时间
写一个工具类MyMetaHandler,定义插入和更新数据时怎么自动填充
@Component
public class MyMetaHandler implements MetaObjectHandler {@Overridepublic void insertFill(MetaObject metaObject) {// 插入数据时,两个时间都填充setFieldValByName("createTime", new Date(), metaObject);setFieldValByName("updateTime", new Date(), metaObject);}@Overridepublic void updateFill(MetaObject metaObject) {setFieldValByName("updateTime", new Date(), metaObject);}
}
在属性上写上注解
@TableField(fill = FieldFill.INSERT) // 插入时填充private Date createTime;@TableField(fill = FieldFill.INSERT_UPDATE) // 插入或更新时填充private Date updateTime;
设置时区对应
yml文件中连接数据库修改serverTimezone=Asia/Shanghai
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
数据库中新增查询,设置全局时间
SET GLOBAL time_zone = '+8:00';SELECT NOW(); // 测试,看是否与本地时间相同
测试,是否能够实现时间自动填充
插入新数据时,createTime和updateTime都自动填充
@Test
void testFillTime(){User user = new User();user.setName("nihao");user.setAge(23);user.setGender(GenderEnum.MAN);userMapper.insert(user);
}
修改数据时,updateTime自动修改
@Test
void updateTime(){User user = new User();user.setId(9L);userMapper.updateById(user);
}
九、防止全表更新与删除插件
在实际开发中,全表更新和删除是非常危险的操作,Mybatis-plus提供了一个插件可以防止全表更新。
在mybatis-plus配置类中添加上
interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
整体代码
@Configuration
// @MapperScan("com.system.mybatisplus.mapper") // 如果在启动类上已经配置了,这里就不需要再配置了
public class MybatisPlusConfig {@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();// DbType.MYSQL 表示数据库类型是mysqlinterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));// 防止全表更新插件interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());return interceptor;}
}
测试
@Test
void updateBlock(){User user = new User();user.setGender(GenderEnum.MAN);userMapper.update(user, null);
}
以上代码更新时未设置条件,就会导致所有数据的性别改为MAN
但是设置了防止全表更新的插件后,mybatis-plus会自动报错,抛出异常
十、逆向工程-MybatisX插件
在idea插件市场中找到插件并且安装
连接数据库,点击红线处
自动生成SQL
在mapper里面写上方法名,然后选中,再Alt+enter
十一、并发问题分析
- 乐观锁
乐观锁是通过表字段完成设计的,其核心思想是,在读取的时候不加锁,其他请求依然可以读取到这个数据,在修改的时候判断这个数据是否有被修改过,如果有被修改过,那么本次请求的修改操作失败。
具体的SQL是这样实现的
update 表 set 字段 = 新值, version = version + 1 where version = 1
这样做不会对数据读取产生影响,并发的效率较高,但是目前看到的数据可能不是真实的数据,是被修改之前的,这在多数情况下是不会产生很大的影响。例如,有时候我们看到某种商品是有库存的,或者都加入到购物车了,但是点进去发现库存不足了。
- 悲观锁
悲观锁是在查询的时候就锁定数据,在这次请求未完成之前,不会释放锁。等到这次请求完毕后,再释放锁,释放了锁之后,其他请求才可以对这条数据完成读写。
这样做能够保证读取到的信息就是当前的信息,保证了信息的准确性,但是并发效率很低。
所以,实际开发中,使用悲观锁的场景很少,因为需要保持效率。
乐观锁实现
首先在数据库中添加字段version,默认值为1
然后在实体类User中添加对应的字段
@Versionprivate Integer version;
在mybatis-plus配置类中添加乐观锁插件
// 乐观锁插件interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
测试并发修改
@Testvoid testLock(){// 模拟操作1的查询User user1 = userMapper.selectById(9L);System.out.println("user1查询结果" + user1);// 模拟操作2的查询User user2 = userMapper.selectById(9L);System.out.println("user2查询结果" + user2);// 模拟操作1的修改user1.setName("zhangsan");userMapper.updateById(user1);// 模拟操作2的修改user2.setName("lisi");userMapper.updateById(user2);}
结果只有操作1修改成功,说明乐观锁生效
都能查询到,但是只有操作1修改成功,因为操作1修改时,version未发生变化,但是操作2修改时,version被操作1修改为2了。
user1查询结果User(id=9, name=nihao, age=23, email=null, isOnline=null, status=1, gender=MAN, contact=null, createTime=Thu Sep 07 08:48:53 CST 2023, updateTime=Thu Sep 07 08:52:48 CST 2023, version=1)user2查询结果User(id=9, name=nihao, age=23, email=null, isOnline=null, status=1, gender=MAN, contact=null, createTime=Thu Sep 07 08:48:53 CST 2023, updateTime=Thu Sep 07 08:52:48 CST 2023, version=1)
十二、代码生成器
打开mybatis-plus的官网,找到代码生成器章节
适用版本:mybatis-plus-generator 3.5.1 及其以上版本,对历史版本不兼容!3.5.1 以下的请参考 代码生成器旧
首先引入依赖
<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-generator</artifactId><version>最新版本</version>
</dependency>
本人使用的mybatis-plus版本
<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.5.3.1</version></dependency>
所以mybatis-plus-generator我也使用3.5.3.1
写个main方法执行
FastAutoGenerator.create("url", "username", "password").globalConfig(builder -> {builder.author("baomidou") // 设置作者.enableSwagger() // 开启 swagger 模式.fileOverride() // 覆盖已生成文件.outputDir("D://"); // 指定输出目录}).dataSourceConfig(builder -> builder.typeConvertHandler((globalConfig, typeRegistry, metaInfo) -> {int typeCode = metaInfo.getJdbcType().TYPE_CODE;if (typeCode == Types.SMALLINT) {// 自定义类型转换return DbColumnType.INTEGER;}return typeRegistry.getColumnType(metaInfo);})).packageConfig(builder -> {builder.parent("com.baomidou.mybatisplus.samples.generator") // 设置父包名.moduleName("system") // 设置父包模块名.pathInfo(Collections.singletonMap(OutputFile.xml, "D://")); // 设置mapperXml生成路径}).strategyConfig(builder -> {builder.addInclude("t_simple") // 设置需要生成的表名.addTablePrefix("t_", "c_"); // 设置过滤表前缀}).templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板,默认的是Velocity引擎模板.execute();
十三、SQL分析打印
需要查看执行的SQL语句时,以及了解它的执行时间,方便分析是否出现了慢SQL问题,可以使用mybatis-plus提供的SQL分析打印的功能,来获取SQL语句执行的时间。
首先引入依赖
<!-- SQL分析打印依赖--><dependency><groupId>p6spy</groupId><artifactId>p6spy</artifactId><version>3.9.1</version></dependency>
修改yml文件中连接数据库的驱动和URL
jdbc:p6spy:mysql
driver-class-name: com.p6spy.engine.spy.P6SpyDriver
# 配置数据库
spring:datasource:username: rootpassword: 123456url: jdbc:p6spy:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghaidriver-class-name: com.p6spy.engine.spy.P6SpyDriver #com.mysql.cj.jdbc.Driver
创建
module.log=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.p6spy.engine.spy.appender.SingleLineFormat
#logMessageFormat=com.p6spy.engine.spy.appender.CustomLineFormat
#customLogMessageFormat=%(currentTime) | SQL耗时: %(executionTime) ms | 连接信息: %(category)-%(connectionId) | 执行语句: %(sql)
# 使用控制台记录sql
appender=com.p6spy.engine.spy.appender.StdoutLogger
## 配置记录Log例外
excludecategories=info,debug,result,batc,resultset
# 设置使用p6spy driver来做代理
deregisterdrivers=true
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动
driverlist=com.mysql.cj.jdbc.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 秒
outagedetectioninterval=2
十四、多数据源
首先添加依赖
<!--多数据源依赖 --><dependency><groupId>com.baomidou</groupId><artifactId>dynamic-datasource-spring-boot-starter</artifactId><version>3.1.0</version></dependency>
spring:datasource:dynamic:primary: master #设置默认的数据源或者数据源组,默认值即为masterstrict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源datasource:master:url: jdbc:mysql://xx.xx.xx.xx:3306/dynamicusername: rootpassword: 123456driver-class-name: com.mysql.jdbc.Driver # 3.2.0开始支持SPI可省略此配置slave_1:url: jdbc:mysql://xx.xx.xx.xx:3307/dynamicusername: rootpassword: 123456driver-class-name: com.mysql.jdbc.Driverslave_2:url: ENC(xxxxx) # 内置加密,使用请查看详细文档username: ENC(xxxxx)password: ENC(xxxxx)driver-class-name: com.mysql.jdbc.Driver#......省略#以上会配置一个默认库master,一个组slave下有两个子库slave_1,slave_2
# 多主多从 纯粹多库(记得设置primary) 混合配置
spring: spring: spring:datasource: datasource: datasource:dynamic: dynamic: dynamic:datasource: datasource: datasource:master_1: mysql: master:master_2: oracle: slave_1:slave_1: sqlserver: slave_2:slave_2: postgresql: oracle_1:slave_3: h2: oracle_2:
使用 @DS 切换数据源。
@DS 可以注解在方法上或类上,同时存在就近原则 方法上注解 优先于 类上注解。
注解 | 结果 |
---|---|
没有@DS | 默认数据源 |
@DS(“dsName”) | dsName可以为组名也可以为具体某个库的名称 |