Mybatis-Plus 之BaseMapper 方法详解

package com.itheima.dao;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.apache.ibatis.session.RowBounds;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

public class baseMapper1 {
    /**
     * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
     * 这个 Mapper 支持 id 泛型
     */
    public interface BaseMapper<T> {

        /**
         * 插入一条记录
         *
         * @param entity 实体对象: T
         * @return int
         */
        Integer insert(T entity);

        /**
         * 根据 ID 删除
         *
         * @param id 主键ID
         * @return int
         */
        Integer deleteById(Serializable id);

        /**
         * 根据 columnMap 条件，删除记录
         *
         * @param columnMap 表字段 map 对象
         * @return int
         */
        Integer deleteByMap(@Param("cm") Map<String, Object> columnMap);

        /**
         * 根据 entity 条件，删除记录
         *
         * @param querywrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
         * @return int
         */
// 　　     int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        Integer delete(@Param("ew") Wrapper<T> querywrapper);

        /**
         * 删除（根据ID或实体 批量删除）
         *
         * @param idList 主键ID列表
         *               　　　* @param idList 主键ID列表或者实体类列表（不能为 null 以及 empty）
         * @return int
         */
// 　　      int deleteBatchIds(@Param(constants.COLLECTION) Collection<?> idList);
// 　　      Integer deleteBatchIds(List<? extends Serializable> idList);
        int deleteBatchIds(@Param("coll") Collection<?> idList);

        /**
         * 根据 ID 修改
         *
         * @param entity 实体对象
         * @return int
         */
        //      int updataById(@Param(Constants.ENTITY) T entity);
        // 　　  Integer updateById(T entity);
        int updateById(@Param("et") T entity);

        /**
         * 根据 whereEntity 条件，更新记录
         *
         * @param entity  实体对象（set 条件值，可以为null）
         *                实体对象
         * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
         *                实体对象封装操作类（可以为 null）
         * @return
         */
        // Integer update(@Param("et") T entity, @Param("ew") Wrapper<T> wrapper);
        int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

        /**
         * 根据 ID 查询
         *
         * @param id 主键ID
         * @return T
         */
        T selectById(Serializable id);

        /**
         * 查询（根据ID 批量查询）
         *
         * @param idList 主键ID列表（不能为 null 以及 empty）
         *               主键ID列表
         * @return List<T>
         */
        // List<T> selectBatchIds(List<? extends Serializable> idList);
        List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

        /**
         * 查询（根据 columnMap 条件）
         *
         * @param columnMap 表字段 map 对象
         * @return List<T>
         */
        List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

        /**
         * 根据 entity 条件，查询一条记录,查询一条记录，例如 qw.last（“limit 1”）限制取一条记录，注意：多条数据会报异常。
         *
         * @param entity 实体对象
         * @param queryWrapper 实体对象封装操作类（可以为null）
         * @return T
         */
        // T selectOne(@Param("ew") T entity);　//完整如下
        default T selectOne(@Param("ew") Wrapper<T> queryWrapper) {
            List<T> list = this.selectList(queryWrapper);
            if (list.size() == 1) {
                return list.get(0);
            } else if (list.size() > 1) {
                throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
            } else {
                return null;
            }
        }

        /**
         * exists 存在（参数构造器）
         * 根据 Wrapper 条件，判断是否存在记录
         *
         * @param queryWrapper 实体对象封装操作类
         * @return {@link boolean}
         **/
        default boolean exists(Wrapper<T> queryWrapper) {
            Long count = this.selectCount(queryWrapper);
            return null != count && count > 0L;
        }

        /**
         * 根据 Wrapper 条件构造器，查询总记录数
         *
         * @param queryWrapper 实体对象封装操作类（可以为 null)
         *                     实体对象
         * @return int
         */
        // Long selectCount(@Param("Constants.WRAPPER") Wrapper<T> wrapper);
        Long selectCount(@Param("ew") Wrapper<T> queryWrapper);

        /**
         * 根据 Wrapper<T> queryWrapper 条件构造器，查询全部记录
         *
         * @param queryWrapper 实体对象封装操作类（可以为 null）
         * @return List<T>
         */
        List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

        /**
         * 根据 Wrapper 条件，查询全部记录
         *
         * @param queryWrapper 实体对象封装操作类（可以为 null）
         * @return List<T>
         */
        List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

        /**
         * 根据 Wrapper<T> queryWrapper 条件构造器，查询全部记录
         *
         * @param queryWrapper 实体对象封装操作类（可以为 null）
         * @return List<Object>
         */
        List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

        /**
         * 根据 entity 条件，查询全部记录（并翻页）
         *
         * @param page 分页查询条件（可以为 RowBounds.DEFAULT）
         * @param queryWrapper  实体对象封装操作类（可以为 null）
         * @return List<T>
         */
        <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);


        /**
         * 根据 Wrapper 条件，查询全部记录（并翻页）
         *
         * @param page 分页查询条件（可以为 RowBounds.DEFAULT）
         * @param queryWrapper   实体对象封装操作类
         * @return List<Map < String, Object>>
         */
        // List<Map<String, Object>> selectMapsPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper); }
        <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param("ew") Wrapper<T> queryWrapper);
    }
}