MybatisPlus(四) BaseMapper层CRUD相关接口使用

BaseMapper接口API：

Insert（添加）：

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

参数说明：

类型	参数名	描述
T	entity	实体对象

 

 

Delete（删除）:

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

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

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

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

参数说明：

类型	参数名	描述
Wrapper<T>	wrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键 ID 列表(不能为 null 以及 empty)
Serializable	id	主键 ID
Map<String, Object>	columnMap	表字段 map 对象

 

 

 

 

Update（修改）：

    /**
     * 根据 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);

参数说明：

类型	类型	描述
T	entity	实体对象 (set 条件值,可为 null)
Wrapper<T>	Wrapper<T>	Wrapper<T>

 

 

 

Select（查询）：

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

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

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

参数说明：

类型	参数名	描述
Serializable	id	主键 ID
Wrapper<T>	queryWrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键 ID 列表(不能为 null 以及 empty)
Map<String, Object>	columnMap	表字段 map 对象
IPage<T>	page	分页查询条件（可以为 RowBounds.DEFAULT）

 

 

 

 

 

 

 

 

demo项目实现步骤：

1.启动类

@MapperScan("dao包名")

2.实体类

@Data
@TableName("数据库表名")
public class UserDO implements Serializable {
    @TableId()
    private Long id;
    private String name;
    private String sex;
    private String password;
    private Integer status;

}

3.dao层

public interface MyDao extends BaseMapper<实体类> {}

4.测试

package com.gao;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.gao.dao.UserDao;
import com.gao.pojo.DO.UserDO;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.*;

@SpringBootTest
class MybatisPlusApplicationTests {
        /*  ********************************** ->BaseMapper<- *****************************

    int insert(T entity);

    int deleteById(Serializable id);

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    int delete(@Param("ew") Wrapper<T> queryWrapper);

    int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    int updateById(@Param("et") T entity);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectById(Serializable id);

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    T selectOne(@Param("ew") Wrapper<T> queryWrapper);

    Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);

    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);



    */

    @Autowired
    private UserDao ud;

    /**
     * 查询
     */
    @Test
    void select() {
        // 1. 根据ID 查询
        UserDO uId = ud.selectById(1);
        System.out.println(uId);

        // 2. 根据 多个ID  批量查询
        List<Integer> asList = Arrays.asList(1, 2, 3, 4);
        List<UserDO> userDOS = ud.selectBatchIds(asList);
        userDOS.forEach(u-> System.out.println(u));

        // 3. 根据 map 条件进行查询
        Map<String, Object> map = new HashMap<>();
        map.put("name","小红");
        map.put("status",500000);
        List<UserDO> u = ud.selectByMap(map);
        u.forEach(x-> System.out.println(x));



        // 4. 根据 Wrapper条件查一个
        QueryWrapper<UserDO> udw = new QueryWrapper<>();
        udw.eq("password",999999);
        UserDO userDO = ud.selectOne(udw);
        System.out.println(userDO);

        // 5. 根据条件查条数
        QueryWrapper<UserDO> udq = new QueryWrapper<>();
        udq.eq("name","xiaogao");
        Integer count = ud.selectCount(udq);
        System.out.println(count);

        // 6.  根据条件 查符合条件的内容  list集合
        QueryWrapper<UserDO> userDOQueryWrapper = new QueryWrapper<>();
        userDOQueryWrapper.eq("name","xiaogao");
        userDOQueryWrapper.eq("sex","女");
        List<UserDO> userDOS1 = ud.selectList(userDOQueryWrapper);
        userDOS1.forEach(d-> System.out.println(d));


        System.out.println("************************************");
        // 6.1  根据条件查 in
        QueryWrapper<UserDO> userDOQueryWrapper3 = new QueryWrapper<>();
        userDOQueryWrapper3.eq("name","xiaogao");
        userDOQueryWrapper3.in("status",500000,90000);
        List<UserDO> userDOS2 = ud.selectList(userDOQueryWrapper3);
        for (UserDO aDo : userDOS2) {
            System.out.println(aDo);
        }


        System.out.println("*****************************************");


        // 7.  根据条件  查符合条件的内容 list<Map>
        QueryWrapper<UserDO> userDOQueryWrapper1 = new QueryWrapper<>();
        userDOQueryWrapper1.eq("name","xiaogao");
        userDOQueryWrapper1.eq("sex","女");
        List<Map<String, Object>> maps = ud.selectMaps(userDOQueryWrapper1);
        maps.forEach( l-> System.out.println(l) );
        //maps.forEach( l->l.forEach( (k,v)-> System.out.println(k+"=="+v) ) );

        //8.  根据条件  查符合条件的id号
        QueryWrapper<UserDO> userDOQueryWrapper2 = new QueryWrapper<>();
        userDOQueryWrapper2.eq("name","小");
        List<Object> objects = ud.selectObjs(userDOQueryWrapper2);
        objects.forEach(o-> System.out.println(o));

    }


    /**
     * 更新
     */
    @Test
    void update() {
        // 1.根据 id 进行修改
        UserDO userDO = new UserDO();
        userDO.setId(1584571860312420361L);
        userDO.setName("小红");
        userDO.setPassword("999999");
        userDO.setStatus(500000);
        ud.updateById(userDO);

        // 2. 根据条件构造器中的条件进行修改
        UpdateWrapper uw = new UpdateWrapper();
        uw.eq("sex","男");
        uw.eq("id",1584571860312420362L);

        UserDO user = new UserDO();
        user.setStatus(90000);
        user.setPassword("90000");
        ud.update(user,uw);

    }


    /**
     * 删除
     */
    @Test
    void delete() {
        //  1. 根据id删除   需要实现implements Serializable
        //Integer i = ud.deleteById(1584571860379529224L);
        //System.out.println(i);

        //  2. 根据 map条件 删除
        Map<String, Object> map = new HashMap<>();
        map.put("id",1584571860379529222L);
        map.put("name","xiaogao");
        ud.deleteByMap(map);

        //  3. 根据 Wrapper条件构造器  删除
        QueryWrapper<UserDO> wrapper = new QueryWrapper<>();
        wrapper.eq("id",1584571860379529221L);
        wrapper.eq("sex","男");
        wrapper.eq("status",1);
        ud.delete(wrapper);

        //  4. 根据 集合 批量删除
        List<Long> longs = Arrays.asList(1584571860379529220L, 1584571860379529218L);
        ud.deleteBatchIds(longs);

    }


    /**
     * 添加 相关
     * <p>
     * T                entity    实体对象
     * Collection<T>    entityList    实体对象集合
     * int                batchSize    插入批次数量
     */
    @Test
    void save() {
            UserDO userDO = new UserDO();
            userDO.setName("xiaogao");
            userDO.setPassword("123456");
            userDO.setSex("男");
            userDO.setStatus(1);
            // 插入一条记录（选择字段，策略插入）
            int insert = ud.insert(userDO);
            System.out.println(userDO.getId());
    }

}