MyBatis-Plus之通用service

原创于 2025-01-23 19:41:47 发布

· 1k 阅读

21 ·

版权

文章标签：

#mybatis

mybatis-plus 专栏收录该内容

7 篇文章

订阅专栏

说明：

通用service用前缀命名方式区分Mapper层避免混淆，get：查询单行，remove：删除，list：查询集合，page：分页

一、Service

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑

IService:

/*
 * Copyright (c) 2011-2022, baomidou (jobob@qq.com).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.baomidou.mybatisplus.extension.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.ChainQuery;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.ChainUpdate;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 顶级 Service
 *
 * @author hubin
 * @since 2018-06-23
 */
public interface IService<T> {

    /**
     * 默认批次提交数量
     */
    int DEFAULT_BATCH_SIZE = 1000;

    /**
     * 插入一条记录（选择字段，策略插入）
     *
     * @param entity 实体对象
     */
    default boolean save(T entity) {
        return SqlHelper.retBool(getBaseMapper().insert(entity));
    }

    /**
     * 插入（批量）
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveBatch(Collection<T> entityList) {
        return saveBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 插入（批量）
     *
     * @param entityList 实体对象集合
     * @param batchSize  插入批次数量
     */
    boolean saveBatch(Collection<T> entityList, int batchSize);

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveOrUpdateBatch(Collection<T> entityList) {
        return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     * @param batchSize  每次的数量
     */
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    default boolean removeById(Serializable id) {
        return SqlHelper.retBool(getBaseMapper().deleteById(id));
    }

    /**
     * 根据 ID 删除
     *
     * @param id      主键(类型必须与实体类型字段保持一致)
     * @param useFill 是否启用填充(为true的情况,会将入参转换实体进行delete删除)
     * @return 删除结果
     * @since 3.5.0
     */
    default boolean removeById(Serializable id, boolean useFill) {
        throw new UnsupportedOperationException("不支持的方法!");
    }

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体
     * @since 3.4.4
     */
    default boolean removeById(T entity) {
        return SqlHelper.retBool(getBaseMapper().deleteById(entity));
    }

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    default boolean removeByMap(Map<String, Object> columnMap) {
        Assert.notEmpty(columnMap, "error: columnMap must not be empty");
        return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
    }

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default boolean remove(Wrapper<T> queryWrapper) {
        return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
    }

    /**
     * 删除（根据ID 批量删除）
     *
     * @param list 主键ID或实体列表
     */
    default boolean removeByIds(Collection<?> list) {
        if (CollectionUtils.isEmpty(list)) {
            return false;
        }
        return SqlHelper.retBool(getBaseMapper().deleteBatchIds(list));
    }

    /**
     * 批量删除
     *
     * @param list    主键ID或实体列表
     * @param useFill 是否填充(为true的情况,会将入参转换实体进行delete删除)
     * @return 删除结果
     * @since 3.5.0
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean removeByIds(Collection<?> list, boolean useFill) {
        if (CollectionUtils.isEmpty(list)) {
            return false;
        }
        if (useFill) {
            return removeBatchByIds(list, true);
        }
        return SqlHelper.retBool(getBaseMapper().deleteBatchIds(list));
    }

    /**
     * 批量删除(jdbc批量提交)
     *
     * @param list 主键ID或实体列表(主键ID类型必须与实体类型字段保持一致)
     * @return 删除结果
     * @since 3.5.0
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean removeBatchByIds(Collection<?> list) {
        return removeBatchByIds(list, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量删除(jdbc批量提交)
     *
     * @param list    主键ID或实体列表(主键ID类型必须与实体类型字段保持一致)
     * @param useFill 是否启用填充(为true的情况,会将入参转换实体进行delete删除)
     * @return 删除结果
     * @since 3.5.0
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean removeBatchByIds(Collection<?> list, boolean useFill) {
        return removeBatchByIds(list, DEFAULT_BATCH_SIZE, useFill);
    }

    /**
     * 批量删除(jdbc批量提交)
     *
     * @param list      主键ID或实体列表
     * @param batchSize 批次大小
     * @return 删除结果
     * @since 3.5.0
     */
    default boolean removeBatchByIds(Collection<?> list, int batchSize) {
        throw new UnsupportedOperationException("不支持的方法!");
    }

    /**
     * 批量删除(jdbc批量提交)
     *
     * @param list      主键ID或实体列表
     * @param batchSize 批次大小
     * @param useFill   是否启用填充(为true的情况,会将入参转换实体进行delete删除)
     * @return 删除结果
     * @since 3.5.0
     */
    default boolean removeBatchByIds(Collection<?> list, int batchSize, boolean useFill) {
        throw new UnsupportedOperationException("不支持的方法!");
    }

    /**
     * 根据 ID 选择修改
     *
     * @param entity 实体对象
     */
    default boolean updateById(T entity) {
        return SqlHelper.retBool(getBaseMapper().updateById(entity));
    }

    /**
     * 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
     *
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(Wrapper<T> updateWrapper) {
        return update(null, updateWrapper);
    }

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(T entity, Wrapper<T> updateWrapper) {
        return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean updateBatchById(Collection<T> entityList) {
        return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     * @param batchSize  更新批次数量
     */
    boolean updateBatchById(Collection<T> entityList, int batchSize);

    /**
     * TableId 注解存在更新记录，否插入一条记录
     *
     * @param entity 实体对象
     */
    boolean saveOrUpdate(T entity);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    default T getById(Serializable id) {
        return getBaseMapper().selectById(id);
    }

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表
     */
    default List<T> listByIds(Collection<? extends Serializable> idList) {
        return getBaseMapper().selectBatchIds(idList);
    }

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    default List<T> listByMap(Map<String, Object> columnMap) {
        return getBaseMapper().selectByMap(columnMap);
    }

    /**
     * 根据 Wrapper，查询一条记录 <br/>
     * <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")</p>
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default T getOne(Wrapper<T> queryWrapper) {
        return getOne(queryWrapper, true);
    }

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param throwEx      有多个 result 是否抛出异常
     */
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    Map<String, Object> getMap(Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

    /**
     * 查询总记录数
     *
     * @see Wrappers#emptyWrapper()
     */
    default long count() {
        return count(Wrappers.emptyWrapper());
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default long count(Wrapper<T> queryWrapper) {
        return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<T> list(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectList(queryWrapper);
    }

    /**
     * 查询所有
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<T> list() {
        return list(Wrappers.emptyWrapper());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<T>> E page(E page) {
        return page(page, Wrappers.emptyWrapper());
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMaps(queryWrapper);
    }

    /**
     * 查询所有列表
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<Map<String, Object>> listMaps() {
        return listMaps(Wrappers.emptyWrapper());
    }

    /**
     * 查询全部记录
     */
    default List<Object> listObjs() {
        return listObjs(Function.identity());
    }

    /**
     * 查询全部记录
     *
     * @param mapper 转换函数
     */
    default <V> List<V> listObjs(Function<? super Object, V> mapper) {
        return listObjs(Wrappers.emptyWrapper(), mapper);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Object> listObjs(Wrapper<T> queryWrapper) {
        return listObjs(queryWrapper, Function.identity());
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
        return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMapsPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
        return pageMaps(page, Wrappers.emptyWrapper());
    }

    /**
     * 获取对应 entity 的 BaseMapper
     *
     * @return BaseMapper
     */
    BaseMapper<T> getBaseMapper();

    /**
     * 获取 entity 的 class
     *
     * @return {@link Class<T>}
     */
    Class<T> getEntityClass();

    /**
     * 以下的方法使用介绍:
     *
     * 一. 名称介绍
     * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
     * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
     * 二. 支持介绍
     *
     * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
     * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
     *
     * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
     * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
     * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
     *
     */

    /**
     * 链式查询 普通
     *
     * @return QueryWrapper 的包装类
     */
    default QueryChainWrapper<T> query() {
        return ChainWrappers.queryChain(getBaseMapper());
    }

    /**
     * 链式查询 lambda 式
     * <p>注意：不支持 Kotlin </p>
     *
     * @return LambdaQueryWrapper 的包装类
     */
    default LambdaQueryChainWrapper<T> lambdaQuery() {
        return ChainWrappers.lambdaQueryChain(getBaseMapper());
    }

    /**
     * 链式查询 lambda 式
     * kotlin 使用
     *
     * @return KtQueryWrapper 的包装类
     */
    default KtQueryChainWrapper<T> ktQuery() {
        return ChainWrappers.ktQueryChain(getBaseMapper(), getEntityClass());
    }

    /**
     * 链式查询 lambda 式
     * kotlin 使用
     *
     * @return KtQueryWrapper 的包装类
     */
    default KtUpdateChainWrapper<T> ktUpdate() {
        return ChainWrappers.ktUpdateChain(getBaseMapper(), getEntityClass());
    }

    /**
     * 链式更改 普通
     *
     * @return UpdateWrapper 的包装类
     */
    default UpdateChainWrapper<T> update() {
        return ChainWrappers.updateChain(getBaseMapper());
    }

    /**
     * 链式更改 lambda 式
     * <p>注意：不支持 Kotlin </p>
     *
     * @return LambdaUpdateWrapper 的包装类
     */
    default LambdaUpdateChainWrapper<T> lambdaUpdate() {
        return ChainWrappers.lambdaUpdateChain(getBaseMapper());
    }

    /**
     * <p>
     * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
     * 此次修改主要是减少了此项业务代码的代码量（存在性验证之后的saveOrUpdate操作）
     * </p>
     *
     * @param entity 实体对象
     */
    default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
        return update(entity, updateWrapper) || saveOrUpdate(entity);
    }
}

二、创建自己的service接口和实现类

1.UserService接口

import com.baomidou.mybatisplus.extension.service.IService;
import com.qcby.mybatisPlus.model.User;

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

2.UserServiceImpl

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qcby.mybatisPlus.mapper.UserMapper;
import com.qcby.mybatisPlus.model.User;
import com.qcby.mybatisPlus.service.UserService;
import org.springframework.stereotype.Service;

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

三、测试类

1.查询总记录数

package com.qcby.mybatisPlus;

import com.qcby.mybatisPlus.model.User;
import com.qcby.mybatisPlus.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;

/*
 * 相比spring整合测试更加强大
 * 不用再去通过注解来读取配置文件
 * 会自己读取application.yml配置文件
 * */
@SpringBootTest
public class MybatisPlusTest1 {

    @Autowired
    private UserService userService;


    /*
     * 查询总记录数
     * */
    @Test
    public void testCount(){
        Long count=userService.count();//SELECT COUNT( * ) FROM user
        System.out.println("总记录数："+count);//总记录数：9
    }
}

2.批量插入

插入的五条数据：

name:szy0 szy1 szy2 szy3 szy4

age:20 21 22 23 24

/*
 * 批量插入
 * */
@Test
public void testSaveBatch(){
    // SQL长度有限制，海量数据插入单条SQL无法实行，
    // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        User user = new User();
        user.setName("szy" + i);
        user.setAge(20 + i);
        users.add(user);
    }
    userService.saveBatch(users);//INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
}

四、插入

1.插入一条记录

/*
* 1.插入一条记录(选择字段，策略插入)
* 实体对象entity
* default boolean save(T entity)
* */
@Test
public void testSave(){
    User user = new User();
    user.setId(15);
    user.setName("张三");
    user.setAge(20);
    user.setEmail("zs@qq.com");
    boolean result = userService.save(user);//INSERT INTO t_user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    System.out.println("result:"+result);//result:true(操作数据库成功)
}

2.批量插入实体对象集合

上面第二个方法—批量插入

3.批量插入实体对象集合、插入批次数量

/*
* 3.插入(批量)
* 实体对象集合entityList
* 插入批次数量batchSize：每次批量处理的数量
* 例如，如果你有 1000 条记录要保存，并且 batchsize 设置为 100，那么这些记录将会被分成 10 批，每批 100 条记录依次保存。
* boolean saveBatch(Collection<T> entityList, int batchSize)
* */
@Test
public void testSaveBatch2(){
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        User user = new User();
        user.setName("zs" + i);
        user.setAge(20 + i);
        user.setEmail("zs@qq.com");
        users.add(user);
    }
    boolean result =userService.saveBatch(users, 3);
    System.out.println("result:"+result);//result:true
}

五、修改

1.批量修改插入实体对象集合

/*
* 4.批量修改插入
* 没有就插入，有就修改
* 实体对象集合entityList
* default boolean saveOrUpdateBatch(Collection<T> entityList)
* */
@Test
public void testSaveOrUpdateBatch(){
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        User user = new User();
        //user.setId(19 + i);
        user.setUid(34 + i);
        user.setName("王" + i);
        user.setAge(30 + i);
        user.setEmail("wang@qq.com");
        users.add(user);
    }
    //先查再改
    //SELECT id,name,age,email FROM t_user WHERE id=?
    //UPDATE t_user SET name=?, age=?, email=? WHERE id=?
    //没有就插入：INSERT INTO t_user ( uid, name, age, email ) VALUES ( ?, ?, ?, ? )
    //36(Integer), 王2(String), 32(Integer), wang@qq.com(String)
    boolean result = userService.saveOrUpdateBatch(users);
    System.out.println("result:"+result);//result:true
}

在这里插入图片描述

2.批量修改插入实体对象集合、每次的数量

/*
* impl
* 5.批量修改插入
* 没有就插入，有就修改
* 实体对象集合entityList
* 每次的数量batchSize
* boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize)
* */
@Test
public void testSaveOrUpdateBatch2(){
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 4; i++) {
        User user = new User();
        //user.setId(19 + i);
        user.setUid(34 + i);
        user.setName("张三" + i);
        user.setAge(28 + i);
        user.setEmail("zhangsan@qq.com");
        users.add(user);
    }
    //先查再改
    //SELECT uid,name,age,email,is_deleted,sex FROM t_user WHERE uid=? AND is_deleted=0
    //UPDATE t_user SET name=?, age=?, email=? WHERE uid=? AND is_deleted=0
    //INSERT INTO t_user ( uid, name, age, email ) VALUES ( ?, ?, ?, ? )
    boolean result = userService.saveOrUpdateBatch(users, 2);
    System.out.println("result:"+result);//result:true
}

在这里插入图片描述

六、删除

1.根据id删除-主键ID

/*
* 6.根据id删除
* 主键id
* default boolean removeById(Serializable id)
* */
@Test
public void testRemoveById(){
    boolean result = userService.removeById(21);//DELETE FROM t_user WHERE id=?
    System.out.println("result:"+result);//result:true
}

2.根据实体id删除-实体

/*
* 8.根据实体id删除
* 实体entity
* default boolean removeById(T entity)
* */
@Test
public void testRemoveById3(){
    User user = new User();
    user.setId(19);
    boolean result = userService.removeById(user);//DELETE FROM t_user WHERE id=?
    System.out.println("result:"+result);//result:true
}

3.根据 columnMap 条件，删除记录-map

/*
* 9.根据 columnMap 条件，删除记录
* 表字段 map 对象 columnMap
* default boolean removeByMap(Map<String, Object> columnMap)
* */
@Test
public void testRemoveByMap(){
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("id", 18);
    boolean result = userService.removeByMap(columnMap);//DELETE FROM t_user WHERE id = ?
    System.out.println("result:"+result);//result:true
}

4.根据 entity 条件，删除记录–queryWrapper

/*
* 10.根据 entity 条件，删除记录
* 实体包装类queryWrapper
* default boolean remove(Wrapper<T> queryWrapper)
* */
@Test
public void testRemove(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "小张");
    boolean result = userService.remove(queryWrapper);//DELETE FROM t_user WHERE (name = ?)
    System.out.println("result:"+result);//result:true
}

5.根据id批量删除

/*
* 11.删除(根据ID 批量删除)
* 主键ID或实体列表 list
* default boolean removeByIds(Collection<?> list)
* */
@Test
public void testRemoveByIds(){
    List<Integer> list = new ArrayList<>();
    list.add(15);
    list.add(16);
    boolean result = userService.removeByIds(list);//DELETE FROM t_user WHERE id IN (?, ?)
    System.out.println("result:"+result);//result:true
}

6.批量删除(jdbc批量提交)—主键ID或实体列表 list

/*
* 13.批量删除(jdbc批量提交)
* 主键ID或实体列表 list
* default boolean removeBatchByIds(Collection<?> list)
* */
@Test
public void testRemoveBatchByIds(){
    List<Integer> ids = Arrays.asList(19,20);
    boolean result = userService.removeBatchByIds(ids);//DELETE FROM t_user WHERE id=?
    System.out.println("result:"+result);//result:true
}

在这里插入图片描述

7.批量删除(jdbc批量提交)–主键ID或实体列表 list、批次大小batchSize

/*
* ServiceImpl
* 15.批量删除(jdbc批量提交)
* 主键ID或实体列表 list
* 批次大小batchSize
* default boolean removeBatchByIds(Collection<?> list, int batchSize)
* */
@Test
public void testRemoveBatchByIds3(){
    List<Integer> ids = Arrays.asList(34,35,36,37);
    boolean result = userService.removeBatchByIds(ids, 2);//UPDATE t_user SET is_deleted=1 WHERE uid=? AND is_deleted=0
    System.out.println("result:"+result);//result:true
}

分批次：一次两个，共两次，sql语句写的是update是因为做的是逻辑删除，不是物理删除

在这里插入图片描述

七、修改

1.根据id选择修改–实体对象

/*
* 17.根据id选择修改
* 实体对象 entity
* default boolean updateById(T entity)
* */
@Test
public void testUpdateById(){
    User user = new User(14,"小王",20,"xiaowang@qq.com");
    boolean result = userService.updateById(user);//UPDATE t_user SET name=?, age=?, email=? WHERE id=?
    System.out.println("result:"+result);//result:true
}

2.根据 whereEntity 条件，更新记录–实体对象、实体对象封装操作类 updateWrapper

/*
* 18.根据 whereEntity 条件，更新记录
* 实体对象 entity
* 实体对象封装操作类 updateWrapper
* default boolean update(T entity, Wrapper<T> updateWrapper)
* */
@Test
public void testUpdate(){
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.eq("id", 14).set("age", 30);
    boolean result=userService.update(null, updateWrapper);//UPDATE t_user SET age=? WHERE (id = ?)
    System.out.println("result："+result);//result：true
}

3.根据id批量更新–实体对象集合

/*
 * 19.根据id批量更新
 * 实体对象集合 entityList
 * default boolean updateBatchById(Collection<T> entityList)
 * */
 @Test
 public void testUpdateBatchById(){
     List<User> userList = new ArrayList<>();
     userList.add(new User(13,"小王",30,"xiaowang@qq.com"));
     userList.add(new User(14,"小李",30,"xiaoli@qq.com"));
     boolean result = userService.updateBatchById(userList);//UPDATE t_user SET name=?, age=?, email=? WHERE id=?
     System.out.println("result:"+result);//result:true
}

4.根据id批量更新–实体对象集合、更新批次数量

/*
* ;20.根据id批量更新
* 实体对象集合 entityList
* 更新批次数量batchSize
* boolean updateBatchById(Collection<T> entityList, int batchSize);
* */
@Test
public void testUpdateBatchById2(){
    List<User> userList = new ArrayList<>();
    userList.add(new User(13,"小王1",14,"xiaowang@qq.com"));
    userList.add(new User(14,"小李1",34,"xiaoli@qq.com"));
    boolean result = userService.updateBatchById(userList, 2);//UPDATE t_user SET name=?, age=?, email=? WHERE id=?
    System.out.println("result:"+result);//result:true
}

5.TableId 注解存在更新记录，否插入一条记录

有这条记录

/*
* ;21.TableId 注解存在更新记录，否插入一条记录
* 实体对象 entity
* boolean saveOrUpdate(T entity)
* */
@Test
public void testSaveOrUpdate(){
    User user = new User(13,"小王",30,"xiaowang@qq.com");
    //先查后改，因为id存在
    //SELECT id,name,age,email FROM t_user WHERE id=?
    //UPDATE t_user SET name=?, age=?, email=? WHERE id=?
    boolean result = userService.saveOrUpdate(user);
    System.out.println("result:"+result);//result:true
}

在这里插入图片描述

没这条记录

/*
* ;21.TableId 注解存在更新记录，否插入一条记录
* 实体对象 entity
* boolean saveOrUpdate(T entity)
* */
@Test
public void testSaveOrUpdate(){
    User user = new User(15,"王",23,"wang@qq.com");
    //先查后插入，因为id不存在
    //SELECT id,name,age,email FROM t_user WHERE id=?
    //INSERT INTO t_user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    boolean result = userService.saveOrUpdate(user);
    System.out.println("result:"+result);//result:true
}

在这里插入图片描述

6.链式更改普通

/*
* 49.链式更改 普通
* default UpdateChainWrapper<T> update()
* */
@Test
public void testUpdate1() {
    boolean updated = userService.update()
            .eq("age", 20)
            .set("name", "张三")
            .update();
    //UPDATE t_user SET name=? WHERE is_deleted=0 AND (age = ?)
    System.out.println("updated:" + updated);
}

7.链式更改 lambda 式

/*
* 50.链式更改 lambda 式
* default LambdaUpdateChainWrapper<T> lambdaUpdate()
* */
@Test
public void testLambdaUpdate() {
    boolean updated = userService.lambdaUpdate()
            .eq(User::getAge, 20)
            .set(User::getName, "张三")
            .update();
    //UPDATE t_user SET name=? WHERE is_deleted=0 AND (age = ?)
    System.out.println("updated:" + updated);
}

八、查询

1.根据id查询

/*
* 22.根据id查询
* 主键id
* default T getById(Serializable id)
* */
@Test
public void testGetById(){
    User user = userService.getById(13);//SELECT id,name,age,email FROM t_user WHERE id=?
    System.out.println("user:"+user);//user:User(id=13, name=小王, age=30, email=xiaowang@qq.com)
}

2.根据ID 批量查询

/*
* 23.查询（根据ID 批量查询）
* 主键ID列表idList
* default List<T> listByIds(Collection<? extends Serializable> idList)
* */
@Test
public void testListByIds(){
    List<User> userList = userService.listByIds(Arrays.asList(13,14));//SELECT id,name,age,email FROM t_user WHERE id IN ( ? , ? )
    System.out.println("userList:"+userList);//userList:[User(id=13, name=小王, age=30, email=xiaowang@qq.com), User(id=14, name=小李1, age=34, email=xiaoli@qq.com)]
}

3.根据 columnMap 条件查询

/*
* 24.查询（根据 columnMap 条件）
* 表字段 map 对象 columnMap
* default List<T> listByMap(Map<String, Object> columnMap)
* */
@Test
public void testListByMap(){
    Map<String,Object> map = new HashMap<>();
    map.put("age",30);
    List<User> userList = userService.listByMap(map);//SELECT id,name,age,email FROM t_user WHERE age = ?
    System.out.println("userList:"+userList);//userList:[User(id=13, name=小王, age=30, email=xiaowang@qq.com), User(id=14, name=小李1,age=34, email=xiaoli@qq.com)]
}

4.根据 Wrapper，查询一条记录

/*
* 25.根据 Wrapper，查询一条记录
* 结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
* default T getOne(Wrapper<T> queryWrapper)
* */
@Test
public void testGetOne(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("age",30);
    User user = userService.getOne(queryWrapper);//SELECT id,name,age,email FROM t_user WHERE (age = ?)
    System.out.println("user:"+user);//user:User(id=13, name=小王, age=30, email=xiaowang@qq.com)
}

5.根据 Wrapper，查询一条记录–是否抛出异常throwEx

/*
* ;26.根据 Wrapper，查询一条记录
* 实体对象封装操作类queryWrapper
* 有多个 result 是否抛出异常throwEx
* T getOne(Wrapper<T> queryWrapper, boolean throwEx);
* */
@Test
public void testGetOne2(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("age",30);//有两条age=30的数据
    User user = userService.getOne(queryWrapper, false);//SELECT id,name,age,email FROM t_user WHERE (age = ?)
    System.out.println("user:"+user);//user:User(id=13, name=小王, age=30, email=xiaowang@qq.com)
}

在这里插入图片描述

6.根据 Wrapper ,查询一条记录

/*
* 27.根据 Wrapper ,查询一条记录
* 实体对象封装操作类queryWrapper
* Map<String, Object> getMap(Wrapper<T> queryWrapper);
* */
@Test
public void testGetMap(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name","张三").lt("age",30);//lt:小于--有两条数据
    Map<String,Object> map = userService.getMap(queryWrapper);//SELECT id,name,age,email FROM t_user WHERE (name = ? AND age < ?)
    System.out.println("map:"+map);//map:{name=张三, id=7, age=18, email=123@qq.com}
}

在这里插入图片描述

7.根据 Wrapper，查询一条记录–实体对象封装操作类queryWrapper、转换函数 mapper

/*
* impl
* 28.根据 Wrapper，查询一条记录
* 实体对象封装操作类queryWrapper
* 转换函数 mapper
* V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
* */
@Test
public void testGetObj() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "王");
    Long userId = userService.getObj(queryWrapper, obj -> (Long) obj);//SELECT id,name,age,email FROM t_user WHERE (name = ?)
    System.out.println(userId);//15
}

8.查询总记录数

/*
* 29.查询总记录数
* default long count()
* */
@Test
public void testCount1(){
    long count = userService.count();//SELECT COUNT( * ) FROM t_user
    System.out.println("count:"+count);//count:15
}

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

/*
* 30.根据 Wrapper 条件，查询总记录数
* 实体对象封装操作类queryWrapper
* default long count(Wrapper<T> queryWrapper)
* */
@Test
public void testCount2(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.lt("age",20);
    long count = userService.count(queryWrapper);//SELECT COUNT( * ) FROM t_user WHERE (age < ?)
    System.out.println("count:"+count);//count:5
}

10.查询列表

/*
* 31.查询列表
* 实体对象封装操作类queryWrapper
* default List<T> list(Wrapper<T> queryWrapper)
* */
@Test
public void testList(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.lt("age",20);
    List<User> userList = userService.list(queryWrapper);//SELECT id,name,age,email FROM t_user WHERE (age < ?)
    System.out.println("userList:"+userList);
}

11.查询所有

/*
* 32.查询所有
* default List<T> list()
* */
@Test
public void testList1(){
    List<User> userList = userService.list();//SELECT id,name,age,email FROM t_user
    System.out.println("userList:"+userList);
}

12.查询列表

/*
* 35.查询列表
* 实体对象封装操作类queryWrapper
* default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper)
* */
@Test
public void testListMaps(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("age",30);
    List<Map<String, Object>> userList = userService.listMaps(queryWrapper);//SELECT id,name,age,email FROM t_user WHERE (age = ?)
    System.out.println("userList:"+userList);//userList:[{name=小王, id=13, age=30, email=xiaowang@qq.com}, {name=小李1, id=14, age=30, email=xiaoli@qq.com}]
}

13.查询所有列表

/*
* 36.查询所有列表
* default List<Map<String, Object>> listMaps()
* */
@Test
public void testListMaps1() {
    List<Map<String, Object>> userList = userService.listMaps();//SELECT id,name,age,email FROM t_user
    System.out.println("userList:" + userList);
}

14.查询全部记录

/*
* 37.查询全部记录
* default List<Object> listObjs()
* */
@Test
public void testListObjs() {
    List<Object> userList = userService.listObjs();//SELECT id,name,age,email FROM t_user
    System.out.println("userList:" + userList);//userList:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
}

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

/*
* 39.根据 Wrapper 条件，查询全部记录
* 实体对象封装操作类queryWrapper
* default List<Object> listObjs(Wrapper<T> queryWrapper)
* */
@Test
public void testListObjs1() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.lt("age", 20);
    List<Object> userList = userService.listObjs(queryWrapper);//SELECT id,name,age,email FROM t_user WHERE (age < ?)
    System.out.println("userList:" + userList);//userList:[1, 6, 7, 10, 11]
}

16.链式查询普通

/*
* 45.链式查询 普通
* default QueryChainWrapper<T> query()
* */
@Test
public void testQuery() {
    List<User> users = userService.query()
            .eq("age", 20)
            .like("name", "张三")
            .list();
    //SELECT uid AS id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (age = ? AND name LIKE ?)
    users.forEach(System.out::println);
}

17.链式查询 lambda 式

/*
* 46.链式查询 lambda 式
* default LambdaQueryChainWrapper<T> lambdaQuery()
* */
@Test
public void testLambdaQuery() {
    List<User> users = userService.lambdaQuery()
            .eq(User::getAge, 20)
            .list();
    users.forEach(System.out::println);
}