Data Access 之 MyBatis Plus（一）- BaseMapper CRUD（Part B）

//根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

//根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

@Test
public void updateById(){
    Tesla updateTesla = new Tesla();
    updateTesla.setId(5);
    updateTesla.setVehicleName("Model 3P");
    int count = teslaMapper.updateById(updateTesla);
    System.out.println("更新的行数为：" + count);
}

/**
 * 根据 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);

@Test
public void selectBatchIds(){

    Collection<Integer> batchIds = new HashSet<>();
    // 构造查询的id的集合
    for (int i = 0; i < 5; i++) {
        batchIds.add(i);
    }

    List<Tesla> teslaList = teslaMapper.selectBatchIds(batchIds);
    // 遍历查询到的数据
    for (Tesla tesla : teslaList) {
        System.out.println("查询到的内容为：" + tesla);
    }
}

@Test
public void selectByMap(){
    Map<String, Object> conditionMap = new HashMap<>();
    // 构造查询条件，key为查询条件，value为查询条件的值
    conditionMap.put("factory","Fremont Gigafactory");
    conditionMap.put("name","Model S");

    List<Tesla> teslaList = teslaMapper.selectByMap(conditionMap);

    for (Tesla tesla : teslaList) {
        System.out.println("selectByMap方法查询到的数据：" + tesla);
    }
}

conditionMap.put("name","Model S");

/**
 * 根据 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);

@Test
public void selectPage(){

    Page<Tesla> teslaPage = new Page<>(2,4);

    Page<Tesla> page = teslaMapper.selectPage(teslaPage, null);

    System.out.println("--------------------");
    System.out.println("查询当前页面的数据：" + page.getRecords());
    System.out.println("--------------------");
}

<!--配置分页插件-->
<bean id="paginationInnerInterceptor" class="com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor">
    <property name="dbType" value="MYSQL"></property>
</bean>
<!--配置拦截器-->
<bean id="mybatisPlusInterceptor" class="com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor">
    <property name="interceptors" ref="paginationInnerInterceptor"></property>
</bean>

<bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <!--其他配置保持不变-->
    <!--设置使用分页插件，否则分页会失效-->
    <property name="plugins" ref="mybatisPlusInterceptor"></property>
</bean>

@Test
public void selectMapsPage(){

    Page<Map<String,Object>> teslaPage = new Page<>(2,4);
    
    Page<Map<String, Object>> mapPage = teslaMapper.selectMapsPage(teslaPage, null);

    System.out.println("--------------------");
    System.out.println("查询当前页面的数据：" + mapPage.getRecords());
    System.out.println("--------------------");
}

/**
 * 根据 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);

/**
 * 删除（根据ID或实体 批量删除）
 *
 * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
 */
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);

@Test
public void deleteByIdWithInteger(){
    int id = 1166057479;
    int count = teslaMapper.deleteById(id);
    System.out.println("根据ID删除，更新行数为：" + count);
}

@Test
public void deleteByIdWithEntity(){
    Tesla tesla = new Tesla();
    tesla.setId(1166057478);
    int count = teslaMapper.deleteById(tesla);
    System.out.println("根据Entity删除，更新行数为：" + count);
}

@Test
public void deleteByMap(){
    Map<String,Object> map = new HashMap<>();
    map.put("factory","Texas Cybertruck Gigafactory");

    int count = teslaMapper.deleteByMap(map);
    System.out.println("根据Map删除，更新行数为：" + count);
}

@Test
public void deleteByBachIds(){
    List<Integer> idList = new ArrayList<>();
    for (int i = 1166057474; i < 1166057478; i++) {
        idList.add(i);
    }

    Integer count = teslaMapper.deleteBatchIds(idList);
    System.out.println("根据idList删除，更新行数为：" + count);
}