MyBatis-Plus CRUD接口

╰半橙微兮° 2023-07-01 10:58 27阅读 0赞

## 引入mybatis-plus（MP）依赖 ##

<dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
                <scope>provided</scope>
            </dependency>
                    
            
    
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.3.0</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.10</version>
            </dependency>

## 配置 ##

application.yml

spring.datasource.druid.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    spring.datasource.druid.username=root
    spring.datasource.druid.password=root
    spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
    
    logging.level.com.ljj.dao=debug

在springboot启动类添加@MapperScan

@MapperScan("com.ljj.dao")

## entity ##

@Data
    @ToString
    @Builder
    public class User { 
        private String id;
        private String realName;
        private String gender;
        private String age;
        private String email;
        private String address;
        private String nickName;
        private String account;
        private String password;
    }

## 使用 ##

MP提供了2种封装完成了的CRUD接口供我们直接调用

### 1.Mapper CRUD接口 ###

@Component
    public interface UserDao extends BaseMapper<User> { 
    }

这就是mybatis-plus的重点，User是泛型。BaseMapper里面封装里一些数据库操作的常用方法。

public interface BaseMapper<T> extends Mapper<T> { 
        int insert(T entity);
    
        int deleteById(Serializable id);
    
        int deleteByMap(@Param("cm") Map<String, Object> columnMap);
    
        int delete(@Param("ew") Wrapper<T> wrapper);
    
        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 userDao;

### 测试 ###

#### 1.int insert(T entity); ####

int row = userDao.insert(User.builder().account("545430111").address("广东省xx市xx区" + count).age("21").email("545430111@qq.com").nickName("空想").password("{OP:JHYGGTYUUKOK").realName("妲己").gender(UserSex.MAN.getCode()).build());
            
    log.info("插入用户数据成功------------->返回row:{}", count);

当然为了测试需要有更多的数据

int count = 0;
            for (int i = 0; i < 10; i++) { 
                count += userDao.insert(User.builder().account("545430111").address("广东省xx市xx区" + count).age("21").email(
                        "545430111@qq.com").nickName("空想" + count).password("{OP:JHYGGTYUUKOK").realName("妲己" +count).gender(UserSex.MAN.getCode()).build());
            }
            log.info("插入用户数据成功------------->返回row:{}", count);

#### 2.int deleteById(Serializable id); ####

int row = userDao.deleteById("1215901606834593794");
    log.info("删除用户数据成功------------->返回row:{}", count);

#### 3.int deleteByMap(@Param(“cm”) Map<String, Object> columnMap); ####

Map<String, Object> map = new HashMap<String, Object>();
    map.put("nick_name", "空想2");
    int row = userDao.deleteByMap(map);
    log.info("删除用户数据成功------------->返回row:{}", count);

#### 4.int delete(@Param(“ew”) Wrapper wrapper); ####

int row = userDao.delete(new QueryWrapper<User>().eq("real_name","甄姬"));
    log.info("删除用户数据成功------------->返回row:{}", count);

#### 5.int deleteBatchIds(@Param(“coll”) Collection<? extends Serializable> idList); ####

List<String> list = new ArrayList<>();
    list.add("1215902267827527682");
    list.add("1215902272369958914");
    int row = userDao.deleteBatchIds(list);

#### 6.int updateById(@Param(“et”) T entity); ####

int count = userDao.updateById(User.builder().realName("甄姬").id("1215900383502876673").build());
    log.info("更新用户数据成功------------->返回row:{}", count);

#### 7.int update(@Param(“et”) T entity, @Param(“ew”) Wrapper updateWrapper); ####

int row = userDao.update(User.builder().realName("王昭君").build(), new QueryWrapper<User>().gt("id","1215900383502876673"));
    log.info("更新用户数据成功------------->返回row:{}", count);

#### 8.T selectById(Serializable id); ####

User user = userDao.selectById("1215900383502876673");
    log.info("获取id为1215900383502876673的账号信息：{}",user.toString());

#### 9.List selectBatchIds(@Param(“coll”) Collection<? extends Serializable> idList); ####

List<String> idlist = new ArrayList<>();
            idlist.add("1215900383502876673");
            idlist.add("1215901606834593794");
            idlist.add("1215902267827527682");
            idlist.add("1215902272369958914");
            idlist.add("1215902272395124737");
            idlist.add("1215902272407707650");
            idlist.add("1215902272424484866");
            List<User> userList = userDao.selectBatchIds(idlist);
            for (User user : userList) { 
                log.info("获取id为{}的账号信息：{}", user.getId(), user.toString());
            }

#### 10.List selectByMap(@Param(“cm”) Map<String, Object> columnMap); ####

Map<String, Object> colum = new HashMap<>();
            colum.put("real_name","妲己");
            colum.put("id","1215902272508370946");
            List<User> userList = userDao.selectByMap(colum);
            for (User user : userList) { 
                log.info("获取id为{}的账号信息：{}", user.getId(), user.toString());
            }

#### 11.T selectOne(@Param(“ew”) Wrapper queryWrapper); ####

User user = userDao.selectOne(new QueryWrapper<User>().eq("id", "1215900383502876673"));
    log.info("获取id为{}的账号信息：{}", user.getId(), user.toString());

#### 12.Integer selectCount(@Param(“ew”) Wrapper queryWrapper); ####

Integer count = userDao.selectCount(new QueryWrapper<User>().gt("id", "1215900383502876673"));
    log.info("统计用户数据成功------------->返回row:{}", count);

#### 13.List selectList(@Param(“ew”) Wrapper queryWrapper); ####

List<User> userList = userDao.selectList(new QueryWrapper<User>().gt("id", "1215900383502876673"));
    for (User user : userList) { 
        log.info("获取id为{}的账号信息：{}", user.getId(), user.toString());
    }

#### 14.List<Map<String, Object>> selectMaps(@Param(“ew”) Wrapper queryWrapper); ####

List<Map<String, Object>> maps = userDao.selectMaps(new QueryWrapper<User>().gt("id", "1215900383502876673"));
    
    for (Map<String, Object> map : maps) { 
        log.info("获取id为{}的账号信息：{}", map.get("id"), map.toString());
    }

#### 15.List selectObjs(@Param(“ew”) Wrapper queryWrapper); ####

//只会返回第一个字段的值，无法转User类
    List<Object> selectObjs = userDao.selectObjs(new QueryWrapper<User>().gt("id", "1215900383502876673"));
    
    for (Object obj : selectObjs) { 
        log.info("获取的账号的id信息：{}", obj.toString());
    }

#### 16.<E extends IPage> E selectPage(E page, @Param(“ew”) Wrapper queryWrapper); ####

IPage<User> userIPage = new Page<>(1, 3);
    IPage<User> pageList = userDao.selectPage(userIPage, new QueryWrapper<User>().gt("id","1215900383502876673"));
    for (User record : pageList.getRecords()) { 
        log.info("获取id为{}的账号信息：{}",record.getId(),record.toString());
    }

#### 17.<E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(“ew”) Wrapper queryWrapper); ####

IPage<Map<String, Object>> userIPage = new Page<>(1, 3);
    
    IPage<Map<String, Object>> pageList = userDao.selectMapsPage(userIPage, new QueryWrapper<User>().gt("id","1215900383502876673"));
    
    for (Map<String, Object> map : pageList.getRecords()) { 
        log.info("获取id为{}的账号信息：{}", map.get("id"), map.toString());
    }

### 2.Service CRUD 接口 ###

public interface UserService extends IService<User> { 
    
    }

@Service
    public class UserServiceImpl extends ServiceImpl<UserDao, User> implements UserService { 
    
    }

使用方法同basemapper

#### Save ####

// 插入一条记录（选择字段，策略插入）
    boolean save(T entity);
    // 插入（批量）
    boolean saveBatch(Collection<T> entityList);
    // 插入（批量）
    boolean saveBatch(Collection<T> entityList, int batchSize);

#### SaveOrUpdate ####

// TableId 注解存在更新记录，否插入一条记录
    boolean saveOrUpdate(T entity);
    // 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
    boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
    // 批量修改插入
    boolean saveOrUpdateBatch(Collection<T> entityList);
    // 批量修改插入
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

#### Remove ####

// 根据 entity 条件，删除记录
    boolean remove(Wrapper<T> queryWrapper);
    // 根据 ID 删除
    boolean removeById(Serializable id);
    // 根据 columnMap 条件，删除记录
    boolean removeByMap(Map<String, Object> columnMap);
    // 删除（根据ID 批量删除）
    boolean removeByIds(Collection<? extends Serializable> idList);

#### Update ####

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
    boolean update(Wrapper<T> updateWrapper);
    // 根据 whereEntity 条件，更新记录
    boolean update(T entity, Wrapper<T> updateWrapper);
    // 根据 ID 选择修改
    boolean updateById(T entity);
    // 根据ID 批量更新
    boolean updateBatchById(Collection<T> entityList);
    // 根据ID 批量更新
    boolean updateBatchById(Collection<T> entityList, int batchSize);

#### Get ####

// 根据 ID 查询
    T getById(Serializable id);
    // 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
    T getOne(Wrapper<T> queryWrapper);
    // 根据 Wrapper，查询一条记录
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);
    // 根据 Wrapper，查询一条记录
    Map<String, Object> getMap(Wrapper<T> queryWrapper);
    // 根据 Wrapper，查询一条记录
    <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

#### List ####

// 查询所有
    List<T> list();
    // 查询列表
    List<T> list(Wrapper<T> queryWrapper);
    // 查询（根据ID 批量查询）
    Collection<T> listByIds(Collection<? extends Serializable> idList);
    // 查询（根据 columnMap 条件）
    Collection<T> listByMap(Map<String, Object> columnMap);
    // 查询所有列表
    List<Map<String, Object>> listMaps();
    // 查询列表
    List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
    // 查询全部记录
    List<Object> listObjs();
    // 查询全部记录
    <V> List<V> listObjs(Function<? super Object, V> mapper);
    // 根据 Wrapper 条件，查询全部记录
    List<Object> listObjs(Wrapper<T> queryWrapper);
    // 根据 Wrapper 条件，查询全部记录
    <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

#### Page ####

// 无条件翻页查询
    IPage<T> page(IPage<T> page);
    // 翻页查询
    IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
    // 无条件翻页查询
    IPage<Map<String, Object>> pageMaps(IPage<T> page);
    // 翻页查询
    IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

#### Count ####

// 查询总记录数
    int count();
    // 根据 Wrapper 条件，查询总记录数
    int count(Wrapper<T> queryWrapper);

#### Chain ####

##### \#query #####

// 链式查询 普通
    QueryChainWrapper<T> query();
    // 链式查询 lambda 式。注意：不支持 Kotlin
    LambdaQueryChainWrapper<T> lambdaQuery(); 
    
    // 示例：
    query().eq("column", value).one();
    lambdaQuery().eq(Entity::getId, value).list();

##### \#update #####

// 链式更改 普通
    UpdateChainWrapper<T> update();
    // 链式更改 lambda 式。注意：不支持 Kotlin 
    LambdaUpdateChainWrapper<T> lambdaUpdate();
    
    // 示例：
    update().eq("column", value).remove();
    lambdaUpdate().eq(Entity::getId, value).update(entity);