Mapper CRUD 接口

Mapper CRUD 接口

1. selectById

    // 根据 ID 查询
    // T selectById(Serializable id);
    @Test
    void testSelectById(){
        ActivityType activityType = activityTypeMapper.selectById(9);
        System.out.println("activityType = " + activityType);
    }

2. selectOne

     // 根据 entity 条件，查询一条记录(查询结果大于一条会报错)
     // T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
	 @Test
     void testSelectOne(){
        ActivityType activityType = activityTypeMapper.selectOne(new QueryWrapper<ActivityType>().eq("id", 9));
        System.out.println("activityType = " + activityType);
    }

3. selectBatchIds

	// 查询（根据ID 批量查询）
	// List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    @Test
    void testSelectBatchIds(){
        ArrayList<Integer> ids = new ArrayList<>();
        ids.add(9);
        ids.add(11);
        List<ActivityType> activityTypes = activityTypeMapper.selectBatchIds(ids);
        activityTypes.forEach(System.out::println);
    }

4. selectList

	// 根据 entity 条件，查询全部记录
    // List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectList(){
        List<ActivityType> activityTypeList = activityTypeMapper.selectList(new QueryWrapper<ActivityType>().gt("id", 9));
        activityTypeList.forEach(System.out::println);
    }

5.selectByMap

    // 查询（根据 columnMap 条件）
    // List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    @Test
    void testSelectByMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("id",10);
        List<ActivityType> activityTypes = activityTypeMapper.selectByMap(map);
        activityTypes.forEach(System.out::println);
    }

6. selectMaps

 	// 根据 Wrapper 条件，查询全部记录
    // List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectMaps(){
        List<Map<String, Object>> mapList = activityTypeMapper.selectMaps(new QueryWrapper<ActivityType>().gt("id", 8));
        mapList.forEach(System.out::println);
    }

7. selectObjs

  	// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
    // List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectObjs(){
        List<Object> objectList = activityTypeMapper.selectObjs(new QueryWrapper<ActivityType>().likeLeft("name","1").gt("id", 8));
        objectList.forEach(System.out::println);
    }

8.selectPage

    // 根据 entity 条件，查询全部记录（并翻页）
    // IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectPage(){
        Page<ActivityType> activityTypePage = new Page<>();
        activityTypePage.setSize(3);
        activityTypePage.setCurrent(1);
        Page<ActivityType> typePage = activityTypeMapper.selectPage(activityTypePage, new QueryWrapper<ActivityType>().gt("id", 0));
        typePage.getRecords().forEach(System.out::println);
    }

9.selectMapsPage

    // 根据 Wrapper 条件，查询全部记录（并翻页）
    // IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectMapsPage(){
        Page<Map<String, Object>> mapPage = new Page<>();
        mapPage.setSize(3);
        mapPage.setCurrent(1);
        Page<Map<String, Object>> mapsPage = activityTypeMapper.selectMapsPage(mapPage, new QueryWrapper<ActivityType>().gt("id", 0));

        mapsPage.getRecords().forEach(System.out::println);
    }

10.selectCount

    // 根据 Wrapper 条件，查询总记录数
    // Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    @Test
    void testSelectCount(){
        Integer count = activityTypeMapper.selectCount(new QueryWrapper<ActivityType>().notLike("name", "1"));
        System.out.println("count = " + count);
    }

11.update

    // 根据 whereEntity 条件，更新记录
    // int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
    @Test
    void testUpdate(){
        ArrayList<Integer> ids = new ArrayList<>();
        ids.add(9);
        ids.add(11);
        ActivityType activityType = new ActivityType();
        activityType.setName("666");
        int id = activityTypeMapper.update(activityType, new QueryWrapper<ActivityType>().in("id", ids));
        System.out.println("id = " + id);
    }

12.updateById

	// 根据 ID 修改
    // int updateById(@Param(Constants.ENTITY) T entity);
   @Test
   void testUpdateById(){
       ActivityType activityType = new ActivityType();
       activityType.setId(9);
       activityType.setName("999");
       int updateById = activityTypeMapper.updateById(activityType);
       System.out.println("updateById = " + updateById);
   }

13.deleteByMap

    // 根据 columnMap 条件，删除记录
    // int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    @Test
    void testDeleteByMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("Name","222");
        int count = activityTypeMapper.deleteByMap(map);
        System.out.println("count = " + count);
    }

14.deleteBatchIds

    // 删除（根据ID 批量删除）
    // int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    @Test
    void testDeleteBatchIds(){
        List<Integer> ids = new ArrayList<>();
        ids.add(9);
        ids.add(11);
        int count = activityTypeMapper.deleteBatchIds(ids);
        System.out.println("count = " + count);
    }

15.deleteById

    // 根据 ID 删除
    // int deleteById(Serializable id);
    @Test
    void testDeleteById(){
        int count = activityTypeMapper.deleteById(9);
        System.out.println("count = " + count);
    }

16.delete

 	// 根据 entity 条件，删除记录
 	// int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
    @Test
    void testDelete(){
        int delete = activityTypeMapper.delete(new QueryWrapper<ActivityType>().eq("Name","111"));
        System.out.println("delete = " + delete);
    }

17.insert

    // 插入一条记录
    // int insert(T entity);
    @Test
    void testInsert(){
        ActivityType activityType = new ActivityType();
        activityType.setName("111");
        activityType.setAddTime(new Date());
        activityType.setAddMenId(0);
        activityType.setIsDel(false);
        activityType.setAddTimeStr("");
        int insert = activityTypeMapper.insert(activityType);
        System.out.println("insert = " + insert);
    }