接下来是常用的增加，修改以及删除部分

        首先是增加部分，增加一个新的数据

 @Test
    public void testInsert() {
        // 添加一个新用户记录
        Student s = new Student();
        s.setName("NewStudent");
        s.setAge(25);
        boolean saved = studentService.save(s);
        //可以根据saved来进行后续处理，添加成功则saved=true，反之为false
    }

        然后是批量添加数据：

   @Test
    public void testSaveBatch() {
        // 批量插入多个数据
        ArrayList<Student> students = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Student student = new Student();
            student.setName("Student" + i);
            student.setAge(20 + i);
            students.add(student);
        }
        boolean saved = studentService.saveBatch(students);
        //可以根据saved来进行后续处理，添加成功则saved=true，反之为false
    }

        通常情况下，以上2种的添加方式可以满足大部分的需求，然后是修改部分：

        

  @Test
    public void testUpdateById() {
        // 根据ID更新用户记录
        Student s = new Student();
        s.setId(1L);
        s.setAge(18);
        boolean updated = studentService.updateById(s);
        //后续可以根据updated 进行一些别的处理，true为修改成功，false为修改失败
    }

        运行结果如下：

然后是自定义条件修改数据

 @Test
    public void testUpdate() {
        // 自定义条件修改数据
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();//使用Wrapper记录条件
        queryWrapper.like("name", "折");//模糊查询
        queryWrapper.eq("sex", "女");
        Student s = new Student();
        s.setAge(17);
        boolean updated = studentService.update(s, queryWrapper);
    }

        运行结果如下：

        然后是根据id批量修改：

 @Test
    public void testUpdateBatchById() {
        // 根据id批量修改用户记录
        List<Student> ss = new ArrayList<>();
        for (int i = 23; i <= 27; i++) {
            Student s = new Student();
            s.setId((long) i);
            s.setName("NewStudent" + i);
            s.setAge(30 + i);
            ss.add(s);
        }
        boolean updated = studentService.updateBatchById(ss);
    }

        运行结果如下：        然后是修改或者添加数据

   @Test
    public void testSaveOrUpdate() {
        // 更新数据，如果没有这个数据，则改为添加
        Student s = new Student();
        s.setId(12L);
        s.setAge(40);
        boolean savedOrUpdate = studentService.saveOrUpdate(s);
    }

        运行结果如下：

        没有数据时

        有数据时：

        在上面的基础上，增加判断条件部分：

    @Test
    public void testSaveOrUpdateWithWrapper() {
        // 更新或插入用户记录
        Student s = new Student();
        s.setId(11L);
        s.setName("澪");
        s.setAge(55);
        QueryWrapper<Student> updateWrapper = new QueryWrapper<>();//用于修改用户时判断
        updateWrapper.eq("name", "澪");
        boolean savedOrUpdate = studentService.saveOrUpdate(s, updateWrapper);
    }

        没有数据时：

        有数据时：

        最后是删除部分

        首先是根据id删除：

    @Test
    public void testRemoveById() {
        // 根据ID删除一个用户记录
        boolean removed = studentService.removeById(12L);
    }

运行代码如下：

        由于案例开启了逻辑删除，所以这里采用的是逻辑删除的方式，如果没有开启逻辑删除，则会在数据库中删除这个数据

        然后是使用实体类的id删除

 @Test
    public void testRemoveByIdWithEntity() {
        // 根据实体对象删除一个用户记录
        Student s = new Student();
        s.setId(13L);
        s.setAge(11);
        boolean removed = studentService.removeById(s);
        assertTrue(removed);
    }

结果如下

        可以看到，这个只能根据实体类的id删除，而不能根据其内部的其他数据来删除，而使用map和Wrapper可以实现根据条件删除：

        首先是map：

  @Test
    public void testRemoveByMap() {
        // 根据条件删除用户记录
        Map<String, Object> Map = new HashMap<>();
        Map.put("age", "111");
        boolean removed = studentService.removeByMap(Map);
    }

        运行结果如下：

        接下来是Wrapper

 @Test
    public void testRemoveByWrapper() {
        // 根据条件删除用户记录
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", "22");
        queryWrapper.like("name", "1");//模糊查询
        boolean removed = studentService.remove(queryWrapper);
    }

        结果如下：

        最后是批量删除：

  @Test
    public void testRemoveByIds() {
        // 根据ID列表批量删除用户记录
        List<Long> ids = Arrays.asList(21L, 20L);
        boolean removed = studentService.removeByIds(ids);
    }

        运行结果如下：