mybatis-plus的crud操作

• 说明:
  • 通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
  • 泛型 T 为任意实体对象
  • 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
  • 对象 Wrapper 为 条件构造器
    - 插入

 /**
     * 插入一条记录
     * int insert(T entity);
     */
    @Test
    void insert() {
        System.out.println(("----- insert method test ------"));
        User user = new User();
        user.setAge(18);
        user.setName("嘻哈");
        user.setEmail("[email protected]");
        int i = userMapper.insert(user);
    }

- 删除

 /**
     *根据 ID 删除
     * int deleteById(Serializable id);
     */
    @Test
    void deleteById() {
        System.out.println(("----- deleteById method test ------"));
        userMapper.deleteById("1");
    }


    /**
     * 删除（根据ID 批量删除）
     * int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);
     */
    @Test
    void deleteBatchIds() {
        System.out.println(("----- deleteBatchIds method test ------"));
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        userMapper.deleteBatchIds(list);
    }



    /**
     * 根据 columnMap 条件，删除记录
     * int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
     */
    @Test
    void deleteByMap() {
        System.out.println(("----- deleteByMap method test ------"));
        Map<String,Object> map = new HashMap();
        map.put("name","Jone");
        userMapper.deleteByMap(map);
    }


    /**
     * 根据 entity 条件，删除记录
     * int delete(@Param(Constants.WRAPPER) Wrapper wrapper);
     */
    @Test
    void delete() {
        System.out.println(("----- delete method test ------"));
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","Jack");
        userMapper.delete(wrapper);
    }

- 修改

  /**
     *根据 whereEntity 条件，更新记录
     * int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper);
     */
    @Test
    void update() {
        System.out.println(("----- update method test ------"));
        User user = new User();
        user.setName("赵云");
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq("age","30");
        userMapper.update(user,wrapper);
    }


    /**
     *根据 ID 修改
     *int updateById(@Param(Constants.ENTITY) T entity);
     */
    @Test
    void updateById() {
        System.out.println(("----- updateById method test ------"));
        User user = new User();
        user.setName("黄忠");
        user.setAge(60);
        user.setId(4L);
        userMapper.updateById(user);
    }

- 查询

 /**
     * 根据 ID 查询
     * T selectById(Serializable id);
     */
    @Test
    void selectById(){
        System.out.println(("----- selectById method test ------"));
        User user = userMapper.selectById(4);
        System.out.println(user);
    }


    /**
     * 根据 entity 条件，查询一条记录
     * T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);
     */
    @Test
    void selectOne(){
        System.out.println(("----- selectOne method test ------"));
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        QueryWrapper<User> age = wrapper.eq("age", "60");//查询年龄为60的一个人
        User user = userMapper.selectOne(age);
        System.out.println(user);
    }


    /**
     * // 查询（根据ID 批量查询）
     * List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);
     */
    @Test
    void selectBatchIds(){
        System.out.println(("----- selectBatchIds method test ------"));
        List<Integer> list = new ArrayList<>();
        list.add(4);
        list.add(8);
        list.add(5);
        List<User> userList = userMapper.selectBatchIds(list);
        System.out.println(userList);
    }


    /**
     * // 根据 entity 条件，查询全部记录
     * List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);
     */
    @Test
    void selectList(){
        System.out.println(("----- selectList method test ------"));
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        QueryWrapper<User> age = wrapper.ge("age", "24");
        List<User> userList = userMapper.selectList(age);//传null查全部
        System.out.println(userList);
    }


    /**
     * // 查询（根据 columnMap 条件）
     * List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
     */
    @Test
    void selectByMap() {
        System.out.println(("----- selectByMap method test ------"));
        Map<String,Object> map = new HashMap<>();
        map.put("name","黄忠");
        List<User> userList = userMapper.selectByMap(map);
        System.out.println(userList);
    }

    /**
     * // 根据 Wrapper 条件，查询全部记录
     * List> selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);
     */
    @Test
    void selectMaps(){
        System.out.println(("----- selectMaps method test ------"));
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        QueryWrapper<User> age = wrapper.ge("age", "24");
        List<User> userList = userMapper.selectList(age);//传null查全部
        System.out.println(userList);
    }

    /**
     * // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
     * List