MyBatisPlus--基本CRUD接口使用

创建springboot工程，引入依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 简化代码的工具包 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- mybatis-pulus的springboot支持 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>

配置

application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mbplus?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

@MapperScan("psers.zhang.demo.mapper")
@Configuration
public class MyBatisPlusConfig {

    //配置分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }
}

User实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {

    //指定主键为自增
    @TableId(type = IdType.AUTO)
    private Long id;

    //指定数据表中字段名
    @TableField(value = "user_name")
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;


    //指定该字段在表中是不存在的
    @TableField(exist = false)
    private String address;
}

Mapper接口

public interface UserMapper extends BaseMapper<User> {
}

测试

insert:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
class CRUDTest {

    @Autowired
    UserMapper userMapper;

    /*
        测试插入操作:int insert(T t)
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setEmail("[email protected]");
        user.setAge(30);
        user.setName("xiaoqiang");
        user.setPassword("123456");
        user.setUserName("小强");
        user.setAddress("北京");
        //返回受影响的行数
        int rows = userMapper.insert(user);
        System.out.println(rows);

        //获取自增长后的id值,MP会自动回填自增后的id
        System.out.println(user.getId());
    }
}

update:

	/*
        更新操作：
            1. 根据id更新 int updateById(@Param(Constants.ENTITY) T entity);
            2. 根据条件更新 int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(6l);
        user.setEmail("[email protected]");
        //修改年龄为99
        user.setAge(99);
        user.setName("xiaoqiang");
        user.setPassword("123456");
        user.setUserName("小强");
        //返回受影响的行数
        int rows = userMapper.updateById(user);
        System.out.println(rows);

        //第一种方式：
        User user1 = new User();
        user1.setName("条件更新");
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("age", "99");
        //根据条件更新
        int rows1 = userMapper.update(user1, wrapper);
        System.out.println(rows1);

        //第二种方式：
        UpdateWrapper<User> wrapper1 = new UpdateWrapper<>();
        //更新的字段,key为表中字段名
        wrapper1.set("name", "条件更新2").set("password", "9999999");
        //更新条件
        wrapper1.eq("age", "99");

        int rows2 = userMapper.update(null, wrapper1);
        System.out.println(rows2);
    }

delete:

/*
        删除操作：
            根据id删除：int deleteById(Serializable id);
     */
    @Test
    public void testDeleteById(){
        int rows = userMapper.deleteById(6l);
        System.out.println(rows);
    }

    /*
        删除操作：
            根据 columnMap 条件，删除记录
            int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
     */
    @Test
    public void testDeleteByMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("user_name", "xiaoqiang");
        map.put("password", "123456");
        //多条件之间是and关系
        int rows = userMapper.deleteByMap(map);
        System.out.println(rows);
    }


    /*
        删除操作：
         根据 entity 条件，删除记录
            int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
     */
    @Test
    public void testDelete(){
        //用法1
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("user_name", "wangwu").eq("password", "123456");
        int rows1 = userMapper.delete(wrapper);

        //用法2
        User user = new User();
        user.setPassword("123456");
        user.setUserName("zhangsan");
        QueryWrapper<User> wrapper1 = new QueryWrapper<>(user);
        //根据包装条件删除
        int rows2 = userMapper.delete(wrapper1);
        System.out.println(rows2);
    }


    /*
        删除操作：
         删除（根据ID 批量删除）
            int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
     */
    @Test
    public void testDeleteBatchIds(){
        int rows = userMapper.deleteBatchIds(Arrays.asList(7l, 8l, 9l));
        System.out.println(rows);
    }


    /*
        查询操作：
            根据id查询：T selectById(Serializable id);
     */
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(2l);
        System.out.println(user);
    }

select:

    /*
        查询操作：
            根据id查询：T selectById(Serializable id);
     */
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(2l);
        System.out.println(user);
    }

    /*
        查询操作：
         查询（根据ID 批量查询）
            List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
     */
    @Test
    public void testSelectBatchIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(2l, 4l));
        for (User u : users)
            System.out.println(u);
    }

    /*
        查询操作：
             根据 entity 条件，查询一条记录
            T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */
    @Test
    public void testSelectOne(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //查询条件
        wrapper.eq("user_name", "lisi");
        User user = userMapper.selectOne(wrapper);
        //数据不存在返回null，如果数据有多条则报错
        System.out.println(user);
    }

    /*
        查询操作：
         根据 Wrapper 条件，查询总记录数
           Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */
    @Test
    public void testSelectCount(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.gt("age", "1");//年龄大于1岁
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }

    /*
        查询操作：
             根据 entity 条件，查询全部记录
            List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */
    @Test
    public void testSelectList(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.gt("age", "1");//查询年龄大于1岁
        List<User> users = userMapper.selectList(wrapper);
        for (User u : users)
            System.out.println(u);
    }

    /*
        查询操作：
             根据 entity 条件，查询全部记录（并翻页）
            IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */
    @Test
    public void testSelectPage(){
        //设置分页参数  查询第一页，每页显示1条数据
        Page<User> page = new Page<>(1, 1);
        //设置查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.gt("age", "1");
        IPage<User> pages = userMapper.selectPage(page, wrapper);
        List<User> users = pages.getRecords();
        for (User u : users)
            System.out.println(u);
    }