BaseMapper #

• 注：使用 mvn dependency:resolve -Dclassifier=sources 来获得mapper源码

• 一些接口介绍

      /**
       * 插入一条记录
       *
       * @param entity 实体对象
       */
      int insert(T entity);
  
      /**
       * 根据 ID 删除
       *
       * @param id 主键ID
       */
      int deleteById(Serializable id);
  
      /**
       * 根据实体(ID)删除
       *
       * @param entity 实体对象
       * @since 3.4.4
       */
      int deleteById(T entity);
  
      /**
       * 根据 columnMap 条件，删除记录
       *
       * @param columnMap 表字段 map 对象
       */
      int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
  
      /**
       * 根据 entity 条件，删除记录
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
       */
      int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 删除（根据ID或实体 批量删除）
       *
       * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
       */
      int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);
  
      /**
       * 根据 ID 修改
       *
       * @param entity 实体对象
       */
      int updateById(@Param(Constants.ENTITY) T entity);
  
      /**
       * 根据 whereEntity 条件，更新记录
       *
       * @param entity        实体对象 (set 条件值,可以为 null)
       * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
       */
      int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
  
      /**
       * 根据 ID 查询
       *
       * @param id 主键ID
       */
      T selectById(Serializable id);
  
      /**
       * 查询（根据ID 批量查询）
       *
       * @param idList 主键ID列表(不能为 null 以及 empty)
       */
      List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
  
      /**
       * 查询（根据 columnMap 条件）
       *
       * @param columnMap 表字段 map 对象
       */
      List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
  
      /**
       * 根据 entity 条件，查询一条记录
       * <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
          List<T> ts = this.selectList(queryWrapper);
          if (CollectionUtils.isNotEmpty(ts)) {
              if (ts.size() != 1) {
                  throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
              }
              return ts.get(0);
          }
          return null;
      }
  
      /**
       * 根据 Wrapper 条件，判断是否存在记录
       *
       * @param queryWrapper 实体对象封装操作类
       * @return
       */
      default boolean exists(Wrapper<T> queryWrapper) {
          Long count = this.selectCount(queryWrapper);
          return null != count && count > 0;
      }
  
      /**
       * 根据 Wrapper 条件，查询总记录数
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 根据 entity 条件，查询全部记录
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 根据 Wrapper 条件，查询全部记录
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 根据 Wrapper 条件，查询全部记录
       * <p>注意： 只返回第一个字段的值</p>
       *
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 根据 entity 条件，查询全部记录（并翻页）
       *
       * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
       * @param queryWrapper 实体对象封装操作类（可以为 null）
       */
      <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  
      /**
       * 根据 Wrapper 条件，查询全部记录（并翻页）
       *
       * @param page         分页查询条件
       * @param queryWrapper 实体对象封装操作类
       */
      <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  

• BaseMapper测试

  • 新增

        @Test
        public void testInsert(){
            User user=new User();
            user.setName("小明");
            user.setAge(11);
            user.setEmail("xx@163.com");
            int insertNum = userMapper.insert(user);
            System.out.println("result:"+insertNum);
            System.out.println("result:"+user);
        }
    

    • sql日志输出

      ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
      ==> Parameters: 1532542803866394625(Long), 小明(String), 11(Integer), xx@163.com(String)
      <==    Updates: 1
      

  • 删除

    • id删除

          @Test
          public void testDelete(){
              int result = userMapper.deleteById(1532542803866394625L);
              System.out.println(result);
          }
      

      sql日志输出

      ==>  Preparing: DELETE FROM user WHERE id=?
      ==> Parameters: 1532542803866394625(Long)
      <==    Updates: 1
      

    • Map删除

          @Test
          public void testDeleteByMap(){
              Map<String,Object> hash=new HashMap<>();
              hash.put("name","Sandy");
              hash.put("age","1234");
              int result = userMapper.deleteByMap(hash);
              System.out.println(result);
          }
      

      sql日志输出

      ==>  Preparing: DELETE FROM user WHERE name = ? AND age = ?
      ==> Parameters: Sandy(String), 1234(String)
      <==    Updates: 0
      

    • 批量删除

          @Test
          public void testDeleteByIds(){
              List<Long> ids = Arrays.asList(1L, 2L, 5L);
              int result = userMapper.deleteBatchIds(ids);
              System.out.println(result);
          }
      

      sql日志输出

      ==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? , ? )
      ==> Parameters: 1(Long), 2(Long), 5(Long)
      <==    Updates: 3
      

  • 修改

    • 根据id修改

          @Test
          public void testUpdateById (){
              User user=new User();
              user.setId(5L);
              user.setEmail("email被修改了" );
              int result = userMapper.updateById(user);
              System.out.println(result);
          }
      

      sql日志输出

      ==>  Preparing: UPDATE user SET email=? WHERE id=?
      ==> Parameters: email被修改了(String), 5(Long)
      <==    Updates: 1
      

      注意，这里不会修改另一个字段name的值

  • 查询

    • 通过id查询用户信息

          @Test
          public void testSelectById (){
              User user = userMapper.selectById(3);
              System.out.println(user);
          }
      

      sql日志输出

      ==>  Preparing: SELECT id,name,age,email FROM user WHERE id=?
      ==> Parameters: 3(Integer)
      <==    Columns: id, name, age, email
      <==        Row: 3, Tom, 28, test3@baomidou.com
      <==      Total: 1
      

    • 通过id集合查询

          @Test
          public void testSelectByIds() {
              List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 5L));
              users.forEach(System.out::println);
          }
      

      sql日志输出

      ==>  Preparing: SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
      ==> Parameters: 1(Long), 2(Long), 5(Long)
      <==    Columns: id, name, age, email
      <==        Row: 1, Jone, 18, test1@baomidou.com
      <==        Row: 2, Jack, 20, test2@baomidou.com
      <==        Row: 5, Billie, 24, email被修改了
      <==      Total: 3
      

    • 通过map查询

          @Test
          public void testSelectMap() {
              Map<String, Object> hashMap = new HashMap<>();
              hashMap.put("name","Jon");
              hashMap.put("age",18);
              List<User> users = userMapper.selectByMap(hashMap);
              users.forEach(System.out::println);
          }
      

      sql日志输出

      ==>  Preparing: SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
      ==> Parameters: Tom(String), 18(Integer)
      <==    Columns: id, name, age, email
      <==        Row: 3, Tom, 18, test3@baomidou.com
      <==      Total: 1
      

    • 查询所有数据

          @Test
          public void testSelectAll() { 
              List<User> users = userMapper.selectList(null);
              users.forEach(System.out::println);
          }
      

      sql日志输出

      ==>  Preparing: SELECT id,name,age,email FROM user
      ==> Parameters: 
      <==    Columns: id, name, age, email
      <==        Row: 1, Jone, 18, test1@baomidou.com
      <==        Row: 2, Jack, 20, test2@baomidou.com
      <==        Row: 3, Tom, 18, test3@baomidou.com
      <==        Row: 4, Sandy, 21, test4@baomidou.com
      <==        Row: 5, Billie, 24, email被修改了
      <==      Total: 5
      

自定义功能 #

• mapper映射文件默认位置

  mybatis-plus:
    configuration:
      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    mapper-locations:
      - classpath:/mapper/**/*.xml #默认位置
  

  

• 映射文件配置 /mapper/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="com.ly.mybatisplus.mapper.UserMapper">
      <select id="selectMapById" resultType="map">
          select id,name,age,email from user
          where id = #{id} and 1=1 
      </select>
  </mapper>
  

• 代码执行

      @Test
      public void testSelectCustom() {
          Map<String, Object> map = userMapper.selectMapById(2L);
          System.out.println(map);
      }
  

  sql日志执行

  ==>  Preparing: select id,name,age,email from user where id = ? and 1=1
  ==> Parameters: 2(Long)
  <==    Columns: id, name, age, email
  <==        Row: 2, Jack, 20, test2@baomidou.com
  <==      Total: 1
  

通用Service接口 #

• 和通用Mapper的方法名有区分 Service CRUD中

  • 使用get查询【mapper-select】
  • remove删除 【mapper-delete】
  • list查询集合
  • page分页

• IService源码

  /**
   * 顶级 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);
      }
  }
  

  IService有一个实现类：ServiceImpl

• 自定义一个业务Service接口，继承IService

  public interface UserService extends IService<User>{
  
  }
  

  • 编写一个实现类，实现UserService接口，并继承ServiceImpl

    public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    
    }
    

  • 这样既可以使用自定义的功能，也可以使用MybatisPlus提供的功能

#