mybatisplus增删改查（所有实例总结）

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.studydemo.entity.User2;
import com.example.studydemo.mapper.User2Mapper;
import com.example.studydemo.service.User2Service;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
public class PlusTest {

    @Autowired
    private User2Mapper userMapper;

    @Autowired
    private User2Service user2Service;


    @Test
    public void testQuery(){
        System.out.println("SUCESS！！！");
    }

    //------------------------------------------添加-----------------------------------------------------------------------------------

    /*
    * 添加（主键自增，在实体类上加上@TableId既可以  @TableId(value = "id", type = IdType.AUTO)）
    * */
    @Test
    public void testUser2Add(){
        User2 user2=new User2();
        user2.setName("李一鸣");
        user2.setSex("男");
        int rusult = userMapper.insert(user2);
        System.out.println(rusult);
    }

    /*
     * 批量添加-----查询集合所有数据，批量添加
     * */
    @Test
    public void  testUser2bach(){
        List<User2> listuser=    new ArrayList<>();
        for(int i=0;i<10;i++){
            User2 user=    new User2();
            user.setName(i+"小红");
            user.setSex(i+"女");
            listuser.add(user);
            if(i==20){//验证出错时，有没有添加进去
                int a=i/0;
            }
        }
        user2Service.saveBatch(listuser);//批量导入
        System.out.println("成功");
    }

    //---------------------------------------------查询-----------------------------------------------------------
    /*
    * 普通查询所有
    * */
    @Test
    public void testUser2Select() {
        List<User2> userList = userMapper.selectList(null);
        for(User2 user:userList) {
            System.out.println(user);
        }

    }


    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */

    @Test
    public void testSelectById() {
        //根据id查询数据
        User2 user = this.userMapper.selectById(3L);
        System.out.println("result = " + user);
    }

    /**
     * 批量查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    @Test
    public void testSelectBatchIds() {
        //根据id集合批量查询
        List<User2> users = this.userMapper.selectBatchIds(Arrays.asList( 3L, 14L));
        for (User2 user : users) {
            System.out.println(user);
        }
    }


    /**
     * 根据 entity 条件，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testSelectOne() {
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        wrapper.eq("name", "梁启超");

        //根据条件查询一条数据，如果结果超过一条会报错
        User2 user = this.userMapper.selectOne(wrapper);
        System.out.println(user);
    }


    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testSelectCount() {
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        wrapper.eq("sex", "男"); //年龄大于23岁

        //根据条件查询数据条数
        Integer count = this.userMapper.selectCount(wrapper);
        System.out.println("count = " + count);
    }

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */

    @Test
    public void testSelectList() {
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        wrapper.eq("sex", "男"); //年龄大于23岁

        //根据条件查询数据
        List<User2> users = this.userMapper.selectList(wrapper);
        for (User2 user : users) {
            System.out.println("user = " + user);
        }
    }

    /**
     * 条件分页-- 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testSelectPage() {
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        wrapper.eq("sex", "男"); //年龄大于20岁

        //current:当前页  size：没页条数
        Page<User2> page = new Page<>(1,2);

        //根据条件查询数据
        IPage<User2> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数：" + iPage.getTotal());
        System.out.println("总页数：" + iPage.getPages());


        List<User2> users = iPage.getRecords();
        for (User2 user : users) {
            System.out.println("user = " + user);
        }
    }

    /**
     * 条件分页模糊查询-- 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testSelectPage2() {
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        //查询姓名中带“小”，性别是男的人
        wrapper.like("name", "小").eq("sex","男"); //模糊查询

        //current:当前页  size：没页条数
        Page<User2> page = new Page<>(1,10);

        //根据条件查询数据
        IPage<User2> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数：" + iPage.getTotal());
        System.out.println("总页数：" + iPage.getPages());


        List<User2> users = iPage.getRecords();
        for (User2 user : users) {
            System.out.println("user = " + user);
        }
    }


//------------------------------------------------修改------------------------------------------------------------------------

    /*
     * 繁琐一点条件修改Update
     * */
    @Test
    public void testUser2Update() {
        //更新的字段
        User2 user2=new User2();
        user2.setSex("女");

        //更新的条件
        QueryWrapper<User2> wrapper = new QueryWrapper<User2>();
        wrapper.eq("id", 4);

        //执行更新操作
        int result = this.userMapper.update(user2, wrapper);
        System.out.println("result = " + result);
    }



    /*
     * 简单条件修改Update
     * */
    @Test
    public void testUpdate() {
        //更新的条件以及字段
        UpdateWrapper<User2> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 4).set("sex", "男");

        //执行更新操作
        int result = this.userMapper.update(null, wrapper);
        System.out.println("result = " + result);
    }

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    @Test
    public void testUpdateById() {
        User2 user = new User2();
        user.setId(14L); //主键
        user.setSex("女"); //更新的字段

        //根据id更新，更新不为null的字段
        this.userMapper.updateById(user);
    }

//----------------------------------------------删除----------------------------------------------------------

    /**
     * 根据 entity 条件，删除记录
     *
     * @param wrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testDeleteByMap() {
        User2 user = new User2();
        user.setName("张三");
        user.setSex("男");

        //将实体对象进行包装，包装为操作条件
        QueryWrapper<User2> wrapper = new QueryWrapper<>(user);

        int result = this.userMapper.delete(wrapper);
        System.out.println("result = " + result);
    }


    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    @Test
    public void testDeleteById() {
        //执行删除操作
        int result = this.userMapper.deleteById(11L);
        System.out.println("result = " + result);
    }

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    @Test
    public void testDeleteByMap2() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("sex","女");
        columnMap.put("name","张三");

        //将columnMap中的元素设置为删除的条件，多个之间为and关系
        int result = this.userMapper.deleteByMap(columnMap);
        System.out.println("result = " + result);
    }


    /**
     * 批量删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    @Test
    public void testDelete4() {
        //根据id集合批量删除
        int result = this.userMapper.deleteBatchIds(Arrays.asList(2L,13L));
        System.out.println("result = " + result);
    }




}