Mybatis Plus条件构造器QueryWrapper，UpdateWrapper

1，条件构造器的方法以及格式说明：

wapper介绍 ：

1，Wrapper ： 条件构造抽象类，最顶端父类，抽象类中提供4个方法西面贴源码展示
2，AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
3，AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
4，LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
5，LambdaUpdateWrapper ： Lambda 更新封装Wrapper
6，QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
7，UpdateWrapper ： Update 条件封装，用于Entity对象更新操作

2，导入maven依赖

		<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>

3，实体类映射

@TableName("t_test")
public class UserDTO {
     

    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    @TableField("name")
    private String name;
    @TableField("hobby")
    private String hobby;

    public Integer getId() {
     
        return id;
    }

    public void setId(Integer id) {
     
        this.id = id;
    }

    public String getName() {
     
        return name;
    }


    public void setName(String name) {
     
        this.name = name;
    }

    public String getHobby() {
     
        return hobby;
    }

    public void setHobby(String hobby) {
     
        this.hobby = hobby;
    }

    @Override
    public String toString() {
     
        return "UserDTO{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", hobby='" + hobby + '\'' +
                '}';
    }
}

以实体类映射数据库表，UserDTO–>t_test，当用实体类User DTO封装作为返回值的时候，会映射t_test的表作为查询，否则会找不到数据库表，如果是没有使用@Table（“t_test”）注解，那么mybatis plus会把默认实体类类名转换为下划线名作为表名去查询，UserDTO–>user_d_t_o，当然如果数据库没有这个表，那么就会查询失败

4，Mapper接口类继承BaseMapper

@Mapper
public interface UserMapper extends BaseMapper<UserDTO> {
     
}

让我们康康BaseMapper里面都有些啥：

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * 
这个 Mapper 支持 id 泛型
 *
 * @author hubin
 * @since 2016-01-23
 */
public interface BaseMapper<T> {
     

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    int deleteById(Serializable id);

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param wrapper 实体对象封装操作类（可以为 null）
     */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

    /**
     * 删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    int updateById(@Param(Constants.ENTITY) T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * 
注意： 只返回第一个字段的值
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

BaseMapper里面的方法基本是满足查询类，但是join是不支持的

5，测试类

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@RunWith(SpringRunner.class)
public class TestMain {
     

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private UserMapper2 userMapper2;

    @Test
    public void fun1(){
     
        UserDTO userDTO = userMapper.selectOne(new QueryWrapper<UserDTO>().eq("id", 1));
        System.err.println(userDTO);

    }

	/**
	* TTest是没有用注解的，为了能查询成功，类名得和表名对应
	*/
    @Test
    public void fun2(){
     
        List<TTest> tTests = userMapper2.selectList(new QueryWrapper<TTest>());
        for (TTest tTest : tTests) {
     
            System.err.println(tTest);
        }
    }

    @Test
    public void fun3(){
     
        UserDTO userDTO = new UserDTO();
        userDTO.setHobby("拳击");
        int id = userMapper.update(userDTO, new UpdateWrapper<UserDTO>().eq("id", 2));
        System.err.println(id);
    }
}

查询成功，没有使用xml的配置