目录
2)、定义一个实现类,实现自定义的接口UserService之前要继承IService的实现类ServiceImpl
4)、saveOrUpdateBatch方法(批量插入数据或更新数据)
1)、remove方法(根据 entity 条件,删除记录)
3)、removeByMap方法(根据 columnMap 条件,删除记录)
1)、update方法(根据updateWrapper和entity条件,更新记录)
3)、updateBatchById方法(根据ID,批量更新)
通用 Service CRUD 封装IService接口,它采用get(查询单行)、list(查询集合)、page(分页查询)、save(插入)、update(更新)、remove(删除),前缀命名方式区分 Mapper 层接口避免混淆。通用Service的使用场景是,如果方法很简单,例如,就是一个插入,或者根据条件更新,就不用在再Service写方法了,使用通用Service提供的方法即可。如果有较多的业务逻辑,一般在service中自定义方法,自己的service继承通用service。定义方法中,使用通用service要注入mapper。
同时 Service 还提供了一些批量方法(批量插入、批量删除、批量更新数据),这是 Mapper 没有的。
1、相关前提步骤
1)、定义一个接口继承 IService接口
package com.exerciseitems.mybatisplus.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.exerciseitems.mybatisplus.entity.User;
/**
* @author : [LiuYanQiang]
* @version : [v1.0]
* @className : UserService
* @description : [服务业务类]
* @createTime : [2021/9/15 18:52]
* @updateUser : [LiuYanQiang]
* @updateTime : [2021/9/15 18:52]
* @updateRemark : [描述说明本次修改内容]
*/
public interface UserService extends IService<User> {
}
2)、定义一个实现类,实现自定义的接口UserService之前要继承IService的实现类ServiceImpl
package com.exerciseitems.mybatisplus.service.Impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.exerciseitems.mybatisplus.entity.User;
import com.exerciseitems.mybatisplus.mapper.UserMapper;
import com.exerciseitems.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;
/**
* @author : [LiuYanQiang]
* @version : [v1.0]
* @className : UserServiceImpl
* @description : [service实现类,需要继承MybatisPlus提供的service基类
* IService:mp提供的接口。ServiceImpl:MybatisPlus提供的接口实现类。
* ServiceImpl<BaseMapper<T>, T>是IService 的实现类。]
* @createTime : [2021/9/15 18:57]
* @updateUser : [LiuYanQiang]
* @updateTime : [2021/9/15 18:57]
* @updateRemark : [描述说明本次修改内容]
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
}
3)、测试类注入自定义UserService 接口
package com.exerciseitems.mybatisplus.mapper;
import com.exerciseitems.mybatisplus.entity.User;
import com.exerciseitems.mybatisplus.service.UserService;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;
/**
* @author : [LiuYanQiang]
* @version : [v1.0]
* @className : UserServiceTest
* @description : [测试类]
* @createTime : [2021/9/15 19:15]
* @updateUser : [LiuYanQiang]
* @updateTime : [2021/9/15 19:15]
* @updateRemark : [描述说明本次修改内容]
*/
@SpringBootTest
public class UserServiceTest {
@Autowired
private UserService userService;
}
4)、后面就可以进行相关的CRUD的操作了
注,后面实体类使用链式的链式操作需要在实体类上加入注解
//意思是访问器允许链式操作
@Accessors(chain = true)
2、增
1)、save方法(插入一条数据)
(1)、官方提供的接口说明
// 插入一条记录(选择字段,策略插入)
boolean save(T entity);
参数说明
类型 |
参数名 |
描述 |
T |
entity |
实体对象 |
(2)、实现方式
/*
* @version V1.0
* Title: save
* @author LiuYanQiang
* @description 保存方法
* @createTime 2021/9/15 20:31
* @param []
* @return void
* ==> Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
* ==> Parameters: 1439062553530548226(String), 张三(String), 24(Integer), 男(String), 2021-09-18 11:03:43.911(Timestamp), 2021-09-18 11:03:43.911(Timestamp)
*/
@Test
public void save(){
User user = new User();
user.setName("张三");
user.setAge(24);
user.setGender("男");
System.out.println(userService.save(user));
}
2)、saveBatch方法(批量插入数据)
(1)、官方提供的接口说明
// 插入(批量)
boolean saveBatch(Collection<T> entityList);
// 插入(批量)
boolean saveBatch(Collection<T> entityList, int batchSize);
参数说明
类型 |
参数名 |
描述 |
Collection<T> |
entityList |
实体对象集合 |
int |
batchSize |
插入批次数量 |
(2)、实现方式
/*
* @version V1.0
* Title: saveBatch
* @author LiuYanQiang
* @description 批量插入
* @createTime 2021/9/15 20:50
* @param list 实体对象集合
* @return
* ==> Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
* ==> Parameters: 1439062885954277377(String), 王五(String), 22(Integer), 男(String), 2021-09-18 11:05:03.166(Timestamp), 2021-09-18 11:05:03.167(Timestamp)
* ==> Parameters: 1439062887074156546(String), 赵六(String), 23(Integer), 男(String), 2021-09-18 11:05:03.437(Timestamp), 2021-09-18 11:05:03.438(Timestamp)
*/
@Test
public void saveBatch() {
List<User> list=new ArrayList<>();
list.add(new User().setName("王五").setAge(22).setGender("男"));
list.add(new User().setName("赵六").setAge(23).setGender("男"));
userService.saveBatch(list,2);
}
3)、saveOrUpdate方法(插入数据或更新数据)
(1)、官方提供的接口说明
// TableId 注解存在更新记录,否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新,否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
参数说明
类型 |
参数名 |
描述 |
T |
entity |
实体对象 |
Wrapper<T> |
updateWrapper |
实体对象封装操作类 UpdateWrapper |
(2)、实现方式
/*
* @version V1.0
* Title: saveOrUpdate
* @author LiuYanQiang
* @description 插入或修改(当有主键id存在的时候为修改update,当无主键是增加insert)
* @createTime 2021/9/15 20:53
* @param list 实体对象集合
* @return
* ==> Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE id=? AND is_delete=0
* ==> Parameters: 刘二(String), 13(Integer), 女(String), 2021-09-18 11:08:25.246(Timestamp), 4(String)
* ==> Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
* ==> Parameters: 1439064032395919361(String), 张三(String), 23(Integer), 男(String), 2021-09-18 11:09:36.502(Timestamp), 2021-09-18 11:09:36.502(Timestamp)
*/
@Test
public void saveOrUpdate() {
User user = new User();
//添加或修改,同一时间只能进行一项操作
//此修改
user.setId("4").setName("刘二").setAge(13).setGender("女");
//此添加
user.setName("张三").setAge(23).setGender("男");
userService.saveOrUpdate(user);
}
4)、saveOrUpdateBatch方法(批量插入数据或更新数据)
(1)、官方提供的接口说明
// TableId 注解存在更新记录,否插入一条记录
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
参数说明
类型 |
参数名 |
描述 |
Collection<T> |
entityList |
实体对象集合 |
int |
batchSize |
插入批次数量 |
(2)、实现方式
/*
* @version V1.0
* Title: saveOrUpdateBatch
* @author LiuYanQiang
* @description 批量插入或批量修改(当有主键id存在的时候为修改update,当无主键是增加insert)
* @createTime 2021/9/15 20:53
* @param list 实体对象集合
* @return
* ==> Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
* ==> Parameters: 5(String), 张三(String), 12(Integer), 男(String), 2021-09-18 11:11:02.756(Timestamp), 2021-09-18 11:11:02.756(Timestamp)
* ==> Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
* ==> Parameters: 1439064682412408834(String), 张三(String), 21(Integer), 男(String), 2021-09-18 11:12:11.476(Timestamp), 2021-09-18 11:12:11.476(Timestamp)
* ==> Parameters: 1439064683779751938(String), 李四(String), 11(Integer), 男(String), 2021-09-18 11:12:11.851(Timestamp), 2021-09-18 11:12:11.851(Timestamp)
*/
@Test
public void saveOrUpdateBatch() {
//添加或修改,同一时间只能进行一项操作
List<User> list =new ArrayList<>();
//此修改
list.add(new User().setId("5").setName("张三").setAge(12).setGender("男"));
//此添加
list.add(new User().setName("张三").setAge(21).setGender("男"));
list.add(new User().setName("李四").setAge(11).setGender("男"));
userService.saveOrUpdateBatch(list);
}
3、删
1)、remove方法(根据 entity 条件,删除记录)
(1)、官方提供的接口说明
// 根据 entity 条件,删除记录
boolean remove(Wrapper<T> queryWrapper);
参数说明
类型 |
参数名 |
描述 |
Wrapper<T> |
queryWrapper |
实体包装类 QueryWrapper |
(2)、实现方式
/*
* @version V1.0
* Title: remove
* @author LiuYanQiang
* @description 根据实体对象删除
* @createTime 2021/9/16 9:49
* @param []
* @return void
* ==> Preparing: UPDATE user SET is_delete=1 WHERE is_delete=0 AND (name = ?)
* ==> Parameters: 张三(String)
*/
@Test
public void remove(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name","张三");
userService.remove(queryWrapper);
}
2)、removeById方法(根据 ID 删除)
(1)、官方提供的接口说明
// 根据 ID 删除
boolean removeById(Serializable id);
参数说明
类型 |
参数名 |
描述 |
Serializable |
id |
主键ID |
(2)、实现方式
/*
* @version V1.0
* Title: removeByIds
* @author LiuYanQiang
* @description 根据 ID 删除
* @createTime 2021/9/16 10:02
* @param []
* @return void
* ==> Preparing: UPDATE user SET is_delete=1 WHERE id=? AND is_delete=0
* ==> Parameters: 3(Integer)
*/
@Test
public void removeById(){
userService.removeById(3);
}
3)、removeByMap方法(根据 columnMap 条件,删除记录)
(1)、官方提供的接口说明
// 根据 columnMap 条件,删除记录
boolean removeByMap(Map<String, Object> columnMap);
参数说明
类型 |
参数名 |
描述 |
Map<String, Object> |
columnMap |
表字段 map 对象 |
(2)、实现方式
/*
* @version V1.0
* Title: removeByMap
* @author LiuYanQiang
* @description 根据 columnMap 条件,删除记录
* @createTime 2021/9/16 10:07
* @param []
* @return void
* ==> Preparing: UPDATE user SET is_delete=1 WHERE name = ? AND age = ? AND is_delete=0
* ==> Parameters: 小明(String), 23(String)
*/
@Test
public void removeByMap(){
Map<String,Object> map = new HashMap<>();
map.put("name","小明");
map.put("age","23");
userService.removeByMap(map);
}
4)、removeByIds方法(根据 ID 批量删除)
(1)、官方提供的接口说明
// 删除(根据ID 批量删除)
boolean removeByIds(Collection<? extends Serializable> idList);
参数说明
类型 |
参数名 |
描述 |
Collection<? extends Serializable> |
idList |
主键ID列表 |
(2)、实现方式
/*
* @version V1.0
* Title: removeByIds
* @author LiuYanQiang
* @description 根据ID批量删除
* @createTime 2021/9/15 21:22
* @param list 主键ID列表
* @return
* ==> Preparing: UPDATE user SET is_delete=1 WHERE id IN ( ? , ? ) AND is_delete=0
* ==> Parameters: 2(String), 3(String)
*/
@Test
public void removeByIds() {
List<String> list=new ArrayList<>();
list.add("2");
list.add("3");
userService.removeByIds(list);
}
4、改
1)、update方法(根据updateWrapper和entity条件,更新记录)
(1)、官方提供的接口说明
// 根据 UpdateWrapper 条件,更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件,更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
参数说明
类型 |
参数名 |
描述 |
Wrapper<T> |
updateWrapper |
实体对象封装操作类 UpdateWrapper |
(2)、实现方式
/*
* @version V1.0
* Title: updateBatchById
* @author LiuYanQiang
* @description 根据updateWrapper和entity条件,更新记录
* @createTime 2021/9/16 10:23
* @param []
* @return void
* ==> Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE is_delete=0 AND (name = ?)
*==> Parameters: 张三(String), 23(Integer), 男(String), 2021-09-18 11:20:08.948(Timestamp), 张三(String)
* ==> Preparing: UPDATE user SET age=? WHERE is_delete=0 AND (name = ? AND name = ?)
*==> Parameters: 35(Integer), 张三(String), 张三(String)
*/
@Test
public void update(){
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
//条件构造器作为参数进行更新(user可以设置多个属性 , user属性为set = "value" 条件构造器为where字句的条件)
updateWrapper.eq("name","张三");
User user = new User();
user.setName("张三").setAge(23).setGender("男");
userService.update(user,updateWrapper);
//条件构造器Set方法(直接set想要修改的字段和值)
updateWrapper.eq("name","张三").set("age", 35);
userService.update(null,updateWrapper);
}
2)、updateById方法(根据ID,更新记录)
(1)、官方提供的接口说明
// 根据 ID 选择修改
boolean updateById(T entity);
参数说明
类型 |
参数名 |
描述 |
T |
entity |
实体对象 |
(2)、实现方式
/*
* @version V1.0
* Title: updateBatchById
* @author LiuYanQiang
* @description 根据ID更新记录
* @createTime 2021/9/16 10:39
* @param []
* @return void
* ==> Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE id=? AND is_delete=0
* ==> Parameters: 张三(String), 23(Integer), 男(String), 2021-09-18 11:21:50.615(Timestamp), 1(String)
*/
@Test
public void updateById(){
User user = new User();
user.setId("1").setName("张三").setAge(23).setGender("男");
userService.updateById(user);
}
3)、updateBatchById方法(根据ID,批量更新)
(1)、官方提供的接口说明
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);
参数说明
类型 |
参数名 |
描述 |
Collection<T> |
entityList |
实体对象集合 |
int |
batchSize |
更新批次数量 |
(2)、实现方式
/*
* @version V1.0
* Title: updateBatchById
* @author LiuYanQiang
* @description 根据ID批量更新
* @createTime 2021/9/15 21:40
* @param list 实体对象集合
* @return
* ==> Preparing: UPDATE user SET name=?, age=?, update_time=? WHERE id=? AND is_delete=0
* ==> Parameters: 张三(String), 12(Integer), 2021-09-18 11:22:56.381(Timestamp), 1(String)
* ==> Parameters: 李四(String), 13(Integer), 2021-09-18 11:22:56.814(Timestamp), 2(String)
*/
@Test
public void updateBatchById() {
Collection<User> list=new ArrayList<>();
list.add(new User().setAge(12).setName("张三").setId("1"));
list.add(new User().setAge(13).setName("李四").setId("2"));
userService.updateBatchById(list);
}
5、查
1)、Get方法
(1)、官方提供的接口说明
// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper,查询一条记录。结果集,如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper,查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper,查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper,查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
参数说明
类型 |
参数名 |
描述 |
Serializable |
id |
主键ID |
Wrapper<T> |
queryWrapper |
实体对象封装操作类 QueryWrapper |
boolean |
throwEx |
有多个 result 是否抛出异常 |
T |
entity |
实体对象 |
Function<? super Object, V> |
mapper |
转换函数 |
(2)、实现方式
/*
* @version V1.0
* Title: getById
* @author LiuYanQiang
* @description 根据 ID 查询
* @createTime 2021/9/16 10:50
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE id=? AND is_delete=0
* ==> Parameters: 1(Integer)
* */
@Test
public void getById(){
System.out.println(userService.getById(1));
}
/*
* @version V1.0
* Title: getOne
* @author LiuYanQiang
* @description 根据 Wrapper,查询一条记录。结果集,如果是多个会抛出异常,随机取一条加上限制条件
* @createTime 2021/9/16 10:52
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age < ?)
* ==> Parameters: %刘%(String), 40(Integer)
* */
@Test
public void getOne(){
// 查询条件:名字中包含'ha'并且年龄小于40
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"刘").lt(User::getAge,40);
// 开始查询符合的单条记录(如果满足条件的记录有多条,那就不能用这个方法,会报错。)
User user = userService.getOne(queryWrapper);
System.out.println(user);
}
/*
* @version V1.0
* Title: getMap
* @author LiuYanQiang
* @description 根据 Wrapper,查询一条记录
* getMap 的用法和上面的 getOne 很像,都是传入一个查询构造器进行查询。不同的是 getMap 返回的是一个 Map,而不是实体类对象
* 注意: Map 里的 key 为表字段名,而不是对应实体类的属性名。
* @createTime 2021/9/16 10:55
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name = ?)
* ==> Parameters: 张三(String)
* */
@Test
public void getMap(){
QueryWrapper wrapper = new QueryWrapper();
wrapper.eq("name","张三");
Map<String,Object> map = userService.getMap(wrapper);
System.out.println(map);
}
/*
* @version V1.0
* Title: getObj
* @author LiuYanQiang
* @description 根据 Wrapper,查询一条记录(使用查询构造器,查询一条记录,返回这条记录的第一个字段值)
* getObj 的用法和上面的 getOne 很像,都是传入一个查询构造器进行查询。不同的是 getObj 返回的是一个字段值(该方法第二个参数是转换函数,必填)
* @createTime 2021/9/16 11:22
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age < ?)
* ==> Parameters: %刘%(String), 40(Integer)
* */
@Test
public void getObj(){
// 查询条件:名字中包含'刘'并且年龄等于40
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"刘").eq(User::getAge,23);
// 开始查询符合的单条记录的第一个字段值
Integer id = userService.getObj(queryWrapper, (o) -> {
return Integer.parseInt(o.toString());
});
System.out.println(id);
}
2)、List方法
(1)、官方提供的接口说明
// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询(根据ID 批量查询)
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询(根据 columnMap 条件)
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件,查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件,查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
参数说明
类型 |
参数名 |
描述 |
Wrapper<T> |
queryWrapper |
实体对象封装操作类 QueryWrapper |
Collection<? extends Serializable> |
idList |
主键ID列表 |
Map<?String, Object> |
columnMap |
表字段 map 对象 |
Function<? super Object, V> |
mapper |
转换函数 |
(2)、实现方式
/*
* @version V1.0
* Title: list
* @author LiuYanQiang
* @description 使用查询构造器,返回一个 list
* @createTime 2021/9/17 8:15
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
* ==> Parameters:
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
* ==> Parameters: %小%(String), 23(Integer)
* */
@Test
public void list(){
//1.list 方法如果参数为空,则查询所有的数据
List<User> list = userService.list();
//2.list 方法也可以传入查询条件构造器进行查询
// 查询条件:名字中包含'小'并且年龄等于23
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"小").eq(User::getAge,23);
// 开始查询
List<User> list = userService.list(queryWrapper);
System.out.println(list);
}
/*
* @version V1.0
* Title: listByIds
* @author LiuYanQiang
* @description 根据 ID 批量查询,返回一个 list
* @createTime 2021/9/17 10:39
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE id IN ( ? , ? , ? ) AND is_delete=0
* ==> Parameters: 1(Integer), 2(Integer), 3(Integer)
* */
@Test
public void listByIds(){
List<User> list = userService.listByIds(Arrays.asList(1,2,3));
System.out.println(list);
}
/*
* @version V1.0
* Title: listByMap
* @author LiuYanQiang
* @description 通过 MAP 封装的条件查询,返回一个 list
* 注意:map 写的是数据表中的列名,而非实体类的属性名。比如属性名为 userName,数据表中字段为 user_name,这里应该写的是 user_name。
* @createTime 2021/9/17 10:43
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE name = ? AND age = ? AND is_delete=0
* ==> Parameters: 张三(String), 23(Integer)
* */
@Test
public void listByMap(){
Map<String,Object> map = new HashMap<>();
map.put("name", "张三");
map.put("age", 23);
List<User> list = userService.listByMap(map);
System.out.println(list);
}
/*
* @version V1.0
* Title: listMaps
* @author LiuYanQiang
* @description 使用查询构造器,返回一个 list
* listMaps 的用法和上面的 list 很像,都是传入一个查询构造器进行查询,然后返回一个 List。不同在于 listMaps 返回的 List 里面是 Map。
* 注意: Map 里的 key 为表字段名,而不是对应实体类的属性名。
* @createTime 2021/9/17 10:48
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
* ==> Parameters:
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
* ==> Parameters: %张%(String), 23(Integer)
* */
@Test
public void listMaps(){
//1.listMaps 方法如果参数为空,则查询所有的数据
List<Map<String, Object>> list = userService.listMaps();
System.out.println(list);
//2.listMaps 方法也可以传入查询条件构造器进行查询
// 查询条件:名字中包含'张'并且年龄等于23
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"张").eq(User::getAge,23);
// 开始查询
List<Map<String, Object>> list = userService.listMaps(queryWrapper);
System.out.println(list);
}
/*
* @version V1.0
* Title: listObjs
* @author LiuYanQiang
* @description 使用查询构造器,返回一个 List<Object>
* listObjs 的用法和前面的 list 很像,都是传入一个查询构造器进行查询,然后返回一个 List。不同在于 listObjs 返回的 List 里面只有返每条结果的第一个字段值。
* @createTime 2021/9/17 11:05
* @param []
* @return void
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
* ==> Parameters:
* ==> Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
* ==> Parameters: %张%(String), 23(Integer)
* */
@Test
public void listObjs(){
//1.listObjs 方法如果参数为空,则查询所有的数据
List<Object> list = userService.listObjs();
System.out.println(list);
//还可以传入个自定义的转换函数
List<Object> list = userService.listObjs((o) -> {
return "用户" + o.toString();
});
System.out.println(list);
//2.listObjs 方法也可以传入查询条件构造器进行查询
// 查询条件:名字中包含'张'并且年龄等于23
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"张").eq(User::getAge,23);
// 开始查询
List<Object> list = userService.listObjs(queryWrapper);
System.out.println(list);
//3.根据 Wrapper 条件,查询全部记录
// 查询条件:名字中包含'刘'并且年龄等于40
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"刘").eq(User::getAge,23);
List<User> list = userService.listObjs(queryWrapper, new Function<Object, User>() {
@Override
public User apply(Object id) {
System.out.println("apply的参数"+id.toString());
User user = userService.getById(Integer.valueOf(id.toString()));
return user;
}
});
list.stream().forEach(System.out::println);
}
3)、分页查询
(1)、官方提供的接口说明
// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);
参数说明
类型 |
参数名 |
描述 |
IPage<T> |
page |
翻页对象 |
Wrapper<T> |
queryWrapper |
实体对象封装操作类 QueryWrapper |
(2)、实现方式
添加配置
package com.exerciseitems.mybatisplus.config;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author : [LiuYanQiang]
* @version : [v1.0]
* @className : MyBatisPlusConfig
* @description : [分页查询配置]
* @createTime : [2021/9/14 16:25]
* @updateUser : [LiuYanQiang]
* @updateTime : [2021/9/14 16:25]
* @updateRemark : [描述说明本次修改内容]
* 逻辑分页与物理分页比较:
* 逻辑分页:内存开销比较大,在数据量比较小的情况下效率比物理分页高;在数据量很大的情况下,内存开销过大,容易内存溢出,不建议使用。
* 物理分页:内存开销比较小,在数据量比较小的情况下效率比逻辑分页还是低;在数据量很大的情况下,建议使用物理分页。
*/
@Configuration
public class MyBatisPlusConfig {
//mybatis-plus分页插件
@Bean
public PaginationInterceptor paginationInterceptor(){
return new PaginationInterceptor();
}
}
Page方法
/*
* @version V1.0
* Title: PageTst
* @author LiuYanQiang
* @description Page分页方法
* 利用IService 接口提供了 page 方法实现分页查询,比如下面我们查询第1页的数据(每页5条记录)
* @createTime 2021/9/18 9:12
* @param []
* @return com.baomidou.mybatisplus.core.metadata.IPage<com.exerciseitems.mybatisplus.entity.User>*/
@RequestMapping("/PageTest")
public IPage<User> PageTest(){
//查询条件
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"张").eq(User::getAge,23);
// 开始查询
IPage<User> page = userService.page(new Page<>(1,5), queryWrapper);
return page;
}
PageMaps方法
/*
* @version V1.0
* Title: PageMapsTest
* @author LiuYanQiang
* @description PageMaps分页方法
* PageMaps 的用法和上面的 page 很像,都是传入分页查询条件、以及查询构造器进行查询,然后返回一个 List。不同在于 PageMaps 返回的结果里面是 Map
* 注意: Map 里的 key 为表字段名,而不是对应实体类的属性名。
* @createTime 2021/9/18 9:18
* @param []
* @return com.baomidou.mybatisplus.core.metadata.IPage<java.util.Map<java.lang.String,java.lang.Object>>*/
@RequestMapping("/PageMapsTest")
public IPage<Map<String,Object>> PageMapsTest(){
//查询条件
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getName,"张").eq(User::getAge,23);
// 开始查询
IPage<Map<String, Object>> page = userService.pageMaps(new Page<>(1,5), queryWrapper);
return page;
}
4)、查询数量
(1)、官方提供的接口说明
// 查询总记录数
int count();
// 根据 Wrapper 条件,查询总记录数
int count(Wrapper<T> queryWrapper);
参数说明
类型 |
参数名 |
描述 |
Wrapper<T> |
queryWrapper |
实体对象封装操作类 QueryWrapper |
(2)、实现方式
/*
* @version V1.0
* Title: count
* @author LiuYanQiang
* @description 查询总记录数
* @createTime 2021/9/15 21:44
* @param
* @return
*/
@Test
public void count() {
int count = userService.count();
System.out.println(count);
}