MyBatis-Plus( CRUD-Mapper接口)

                                                                         Mybatis-Plus快速入门


  • Mybatis-Plus简介及快速入门

      需要掌握技能

         1.  熟悉Lambda表达式

         2.  熟悉Spirngboot、Maven

         3.  最好熟悉MyBatis

      简介

         MP是一个Mybatis的增强工具,只做增强不做改变

      特性介绍

         1.  支持自定义全局通用操作、支持关键字自动转义

         2.  内置代码生成器、内置分页插件、内置性能分析插件

         3.  内置全局拦截插件、内置Sql注入剥离器

      文档及项目地址

          官网地址:https://mybatis.plus/

          github:https://github.com/baomidou/mybatis-plus

          码云:https://gitee.com/baomidou/mybatis-plus

      依赖


   org.springframework.boot
   spring-boot-starer


   org.projectlombok
   lombok
   true


  com.baomidou
  mybatis-plus-boot-starter
  3.1.0


  mysql
  mysql-connector-java

  • Mybatis-Plus核心功能

      实体类注解(常用注解)

      @Data : 该注解功能作用是自动配置get与set方法

      @TableName该注解是映射数据库表名

      @TableId该注解是映射表中主键ID字段

      @TableField该注解是映射表中普通字段

     排除非表字段的三种方式

  1.  在该字段中加入transient成员变量

//在实体类变成成员变量
private transient String remark;

  2.  在该字段中加入static变成静态变量

//在实体类变成静态变量
private static String remark;

  3. 在该字段加入TableField(exist=false)

@TableField(exist=false)
private String remark;

Mapper源码接口(CRUD接口)

       Mapper 继承该接口后,无需编写Mapper.xml文件,即可获得CRUD功能,包括基本增删改查、分页查询及条件查询等等。

  新增

    /**
     * 插入一条记录
     *
     * @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 columnMap);

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

    /**
     * 删除(根据ID 批量删除)
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection 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 updateWrapper);

  条件查询

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


   /**
     * 查询(根据 columnMap 条件)
     *
     * @param columnMap 表字段 map 对象
     */
    List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap);


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


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


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

   /**
     * 根据 Wrapper 条件,查询全部记录
     * 

注意: 只返回第一个字段的值

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

  批量查询

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

  统计个数

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

  测试代码效果:

MyBatis-Plus( CRUD-Mapper接口)_第1张图片 

 entity

package com.bdqn.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
@TableName("t_shop_address")
public class ShopAddress implements Serializable {
  private static final long serialVersionUID = 1L;

  @TableId(value = "id", type = IdType.AUTO)
  private Long id;
  @TableField("create_time")
  private Date createTime;
  @TableField("modify_time")
  private Date modifyTime;
  @TableField("address_detail")
  private String addressDetail;
  @TableField("area_code")
  private String areaCode;
  @TableField("city")
  private String city;
  @TableField("district")
  private String district;
  @TableField("id_user")
  private Long idUser;
  @TableField("is_default")
  private Long isDefault;
  @TableField("is_delete")
  private Long isDelete;
  @TableField("name")
  private String name;
  @TableField("post_code")
  private String postCode;
  @TableField("province")
  private String province;
  @TableField("tel")
  private String tel;


}

  Mapper

package com.bdqn.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.bdqn.entity.ShopAddress;

public interface ShopAddressMapper extends BaseMapper {

}

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mall?useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: 123

logging:
  level:
    root: warn
    com.bdqn.dao: trace
  pattern:
    console: '%p%m%n'

Springboot启动类

package com.bdqn;

import org.junit.runner.RunWith;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.ManagedBean;

@SpringBootApplication
@MapperScan("com.bdqn.dao")
public class MybatisplusApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisplusApplication.class, args);
    }

}

  测试类:

package com.bdqn;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.bdqn.dao.ShopAddressMapper;
import com.bdqn.entity.ShopAddress;
import org.junit.jupiter.api.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 org.springframework.util.Assert;

import javax.annotation.Resource;
import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
class MybatisplusApplicationTests {
    @Resource
    private ShopAddressMapper shopAddressMapper;

    /**
     * 查询所有
     */
    @Test
    public void select() {
        List shopAddresses = shopAddressMapper.selectList(null);
        shopAddresses.forEach(System.out::println);
    }

    /**
     * 新增
     */
    @Test
    public void insert(){
        ShopAddress shopAddress =new ShopAddress();
        shopAddress.setCreateTime(new Date(System.currentTimeMillis()));
        shopAddress.setAddressDetail("民乐大道");
        shopAddress.setAreaCode("321012");
        shopAddress.setCity("深圳市");
        shopAddress.setDistrict("民治区");
        shopAddress.setIdUser(Long.valueOf(3));
        shopAddress.setIsDefault(Long.valueOf(1));
        shopAddress.setName("鹿晗飞");
        shopAddress.setProvince("深圳市");
        shopAddress.setTel("13523921132");
        int insert = shopAddressMapper.insert(shopAddress);
        System.out.println("影像记录数:"+insert);
    }

    /**
     * 根据ID修改
     */
    @Test
    public void updateById(){
        ShopAddress shopAddress=new ShopAddress();
        shopAddress.setId(Long.valueOf(1));
        shopAddress.setName("向东");
        int count = shopAddressMapper.updateById(shopAddress);
        System.out.println("更新一条记录数"+count);
    }
    /**
     *根据条件查询结果进行修改
     */
    @Test
    public void update(){
        ShopAddress shopAddress=new ShopAddress();
        shopAddress.setId(Long.valueOf(1));
        shopAddress.setName("向东");
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.like("name","飞").lt("id_user",4);
         int update = shopAddressMapper.update(shopAddress, queryWrapper);
        System.out.println("更新一条记录数:"+update);
    }

    /**
     * 批量删除(必须集合类型)
     */
    @Test
    public void deleteBatchIds(){
        List list = Arrays.asList(1, 5, 2, 6);
         int count = shopAddressMapper.deleteBatchIds(list);
        System.out.println("删除总记录数:"+count);
    }

    /**
     * 批量删除(必须Map集合类型)
     */
    @Test
    public void deleteByMp(){
        Map map=new HashMap<>();
        map.put("name","路飞");
        map.put("city","北京市");
        int count = shopAddressMapper.deleteByMap(map);
        System.out.println("删除总记录数:"+count);
    }

    /**
     * 根据条件删除
     */
    @Test
    public void delete(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.like("name","飞").lt("id_user",4);
        int count = shopAddressMapper.delete(queryWrapper);
        System.out.println("删除总记录数:"+count);
    }


}
package com.bdqn;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.bdqn.dao.ShopAddressMapper;
import com.bdqn.entity.ShopAddress;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
class RetrieveTest {
    @Resource
    private ShopAddressMapper shopAddressMapper;

    /**
     * (条件查询)
     * 根据 ID 查询
     */
    @Test
    public void selectById() {
         ShopAddress shopAddress = shopAddressMapper.selectById(1);
        System.out.println(shopAddress);
    }

    /**
     * (条件查询)
     * 查询(根据ID 批量查询)
     *  在实战中Excel批量导出
     *  selectBatchIds:参数是List集合
     */
    @Test
    public void selectBatchIds(){
         List list = Arrays.asList(1, 5, 2, 6);
         List shopAddresses = shopAddressMapper.selectBatchIds(list);
         shopAddresses.forEach(System.out::print);
    }

    /**
     * (条件查询)
     * 分页查询带条件查询
     * selectByMap:参数必须是Map集合
     */
    @Test
    public void selectByMap(){
        Map map=new HashMap<>();
        map.put("name","路飞");
        map.put("city","北京市");
        List shopAddresses = shopAddressMapper.selectByMap(map);
        shopAddresses.forEach(System.out::println);
    }

    /**
     * (条件查询)
     * 模糊查询带“飞”用户,用户ID必须大于等于4
     * 返回值是集合类型
     */
    @Test
    public void  selectByWrapper(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.like("name","飞").lt("id_user",4);

        List shopAddresses = shopAddressMapper.selectList(queryWrapper);
        shopAddresses.forEach(System.out::println);
    }

    /**
     * (条件查询)
     * 模糊查询带“飞”用户并且用户ID必须是1到4,时间不能为空
     * 返回值是集合类型
     */
    @Test
    public void selectByWrapper2(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.like("name","飞").between("id_user",1,4).isNotNull("create_time");
        List shopAddresses = shopAddressMapper.selectList(queryWrapper);
        shopAddresses.forEach(System.out::println);
    }

    /**
     * (条件查询)
     * 模糊查询带“飞”用户并且用户Id大于四,对用户Id进行降序,对主键ID进行生序排列
     * 返回值是集合类型
     */
    @Test
    public void selectByWrapper3(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.likeRight("name","飞").or().ge("id_user",4).orderByDesc("id_user").orderByAsc("id");
        List shopAddresses = shopAddressMapper.selectList(queryWrapper);
        shopAddresses.forEach(System.out::println);
    }

    /**
     * (条件查询)
     * 模糊查询带“飞”用户并且用户Id大于四,对用户Id进行降序,对主键ID进行生序排列
     * 返回值是对象类型
     */
    @Test
    public void selectByWrapper4(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.likeRight("name","飞").or().ge("id_user",4).orderByDesc("id_user").orderByAsc("id");
        ShopAddress shopAddress = shopAddressMapper.selectOne(queryWrapper);
        System.out.println(shopAddress);
    }

    /**
     * (条件查询)
     * 模糊查询带“飞”用户并且用户Id大于四,对用户Id进行降序,对主键ID进行生序排列
     * 返回值是Integer类型
     */
    @Test
    public void selectByWrapper5(){
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.likeRight("name","飞").or().ge("id_user",4).orderByDesc("id_user").orderByAsc("id");
        Integer count = shopAddressMapper.selectCount(queryWrapper);
        System.out.println("统计总记录数:"+count);
    }

}

 

MybatisplusApplicationTests测试结果:

MyBatis-Plus( CRUD-Mapper接口)_第2张图片

 

RetrieveTest测试结果:

MyBatis-Plus( CRUD-Mapper接口)_第3张图片

MyBatis-Plus( CRUD-Mapper接口)_第4张图片

Serivce源码接口(CRUD接口)

  新增

   /**
     * 插入一条记录(选择字段,策略插入)
     *
     * @param entity 实体对象
     */
    boolean save(T entity);

    /**
     * 插入(批量)
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveBatch(Collection entityList) {
        return saveBatch(entityList, 1000);
    }

    /**
     * 插入(批量)
     *
     * @param entityList 实体对象集合
     * @param batchSize  插入批次数量
     */
    boolean saveBatch(Collection entityList, int batchSize);

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveOrUpdateBatch(Collection entityList) {
        return saveOrUpdateBatch(entityList, 1000);
    }

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     * @param batchSize  每次的数量
     */
    boolean saveOrUpdateBatch(Collection entityList, int batchSize);

   /**
     * TableId 注解存在更新记录,否插入一条记录
     *
     * @param entity 实体对象
     */
    boolean saveOrUpdate(T entity);

   删除

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

    /**
     * 根据 columnMap 条件,删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    boolean removeByMap(Map columnMap);

    /**
     * 根据 entity 条件,删除记录
     *
     * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    boolean remove(Wrapper queryWrapper);

    /**
     * 删除(根据ID 批量删除)
     *
     * @param idList 主键ID列表
     */
    boolean removeByIds(Collection idList);

  修改

   /**
     * 根据 ID 选择修改
     *
     * @param entity 实体对象
     */
    boolean updateById(T entity);

    /**
     * 根据 whereEntity 条件,更新记录
     *
     * @param entity        实体对象
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    boolean update(T entity, Wrapper updateWrapper);

    /**
     * 根据 UpdateWrapper 条件,更新记录 需要设置sqlset
     *
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(Wrapper updateWrapper) {
        return update(null, updateWrapper);
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean updateBatchById(Collection entityList) {
        return updateBatchById(entityList, 1000);
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     * @param batchSize  更新批次数量
     */
    boolean updateBatchById(Collection entityList, int batchSize);

  根据ID查询

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

    /**
     * 查询(根据ID 批量查询)
     *
     * @param idList 主键ID列表
     */
    Collection listByIds(Collection idList);

    /**
     * 查询(根据 columnMap 条件)
     *
     * @param columnMap 表字段 map 对象
     */
    Collection listByMap(Map columnMap);
查询一条记录
   /**
     * 根据 Wrapper,查询一条记录 
*

结果集,如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last("LIMIT 1")

* * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper} */ default T getOne(Wrapper queryWrapper) { return getOne(queryWrapper, true); } /** * 根据 Wrapper,查询一条记录 * * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper} * @param throwEx 有多个 result 是否抛出异常 */ T getOne(Wrapper queryWrapper, boolean throwEx); /** * 根据 Wrapper,查询一条记录 * * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper} */ Map getMap(Wrapper queryWrapper); /** * 根据 Wrapper,查询一条记录 * * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper} * @param mapper 转换函数 */ default V getObj(Wrapper queryWrapper, Function mapper) { return SqlHelper.getObject(listObjs(queryWrapper, mapper)); }

  查询所有及条件查询

   /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    List list(Wrapper queryWrapper);

    /**
     * 查询所有
     *
     * @see Wrappers#emptyWrapper()
     */
    default List list() {
        return list(Wrappers.emptyWrapper());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    IPage page(IPage page, Wrapper queryWrapper);

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default IPage page(IPage page) {
        return page(page, Wrappers.emptyWrapper());
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    List> listMaps(Wrapper queryWrapper);

    /**
     * 查询所有列表
     *
     * @see Wrappers#emptyWrapper()
     */
    default List> listMaps() {
        return listMaps(Wrappers.emptyWrapper());
    }

    /**
     * 查询全部记录
     */
    default List listObjs() {
        return listObjs(Function.identity());
    }

    /**
     * 查询全部记录
     *
     * @param mapper 转换函数
     */
    default  List listObjs(Function mapper) {
        return listObjs(Wrappers.emptyWrapper(), mapper);
    }

    /**
     * 根据 Wrapper 条件,查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List listObjs(Wrapper queryWrapper) {
        return listObjs(queryWrapper, Function.identity());
    }

    /**
     * 根据 Wrapper 条件,查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
     List listObjs(Wrapper queryWrapper, Function mapper);

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    IPage> pageMaps(IPage page, Wrapper queryWrapper);

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default IPage> pageMaps(IPage page) {
        return pageMaps(page, Wrappers.emptyWrapper());
    }
 
  

 按条件查询及无条件查询

   /**
     * 根据 Wrapper 条件,查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    int count(Wrapper queryWrapper);

    /**
     * 查询总记录数
     *
     * @see Wrappers#emptyWrapper()
     */
    default int count() {
        return count(Wrappers.emptyWrapper());
    }

  ShopAddressService:

package com.bdqn.serivce;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.bdqn.entity.ShopAddress;

import java.sql.Wrapper;
import java.util.List;
import java.util.Map;

public interface ShopAddressService extends IService {
    /**
     * 根据 ID 删除
     */
    boolean delete(Long id);

    /**
     *批量删除
     */
    boolean delete(Map map);
    /**
     *条件删除
     */
    boolean delete(QueryWrapper wrapper,ShopAddress shopAddress);
    /**
     * 批量删除
     */
    boolean delete(List shopAddressList);

    /**
     * 修改
     */
    boolean update(ShopAddress shopAddress);
    /**
     * 批量修改
     */
    boolean update(List shopAddressList);
    /**
     * 批量修改
     */
    boolean update(List shopAddressList,Integer size);
    /**
     * 条件修改
     */
    boolean update(ShopAddress shopAddress, QueryWrapper queryWrapper);
    /**
     * 条件修改
     */
    boolean update(QueryWrapper wrapper);

    /**
     * 插入
     */
    boolean add(ShopAddress shopAddress);
    /**
     * 批量插入
     */
    boolean saveBatch(List shopAddressList);
    /**
     * 批量插入
     */
    boolean saveBatch(List shopAddressList,Integer size);


    /**
     * 根据ID 查询
     */
    ShopAddress selectId(Long id);
    /**
     * 查询(根据ID 批量查询)
     */
    List selectList(List shopAddressList);
    /**
     * 查询(根据 columnMap 条件)
     */
    List selectList(Map map);


    /**
     * 查询一条记录
     */
    ShopAddress get(QueryWrapper wrapper);
    /**
     * 查询一条记录
     */
    ShopAddress get(QueryWrapper  wrapper,boolean flag);
    /**
     * 查询一条记录
     */
    Map getMap(QueryWrapper  wrapper);


    /**
     * 查询总记录数
     */
    int total(QueryWrapper wrapper);


    /**
     * 查询所有
     */
    List queryAll(QueryWrapper wrapper);
    /**
     * 条件查询
     */
    List> listMaps(QueryWrapper wrapper);

    /**
     * 翻页查询
     */
    IPage Pagination(IPage page,QueryWrapper wrapper);

    /**
     * 无条件翻页查询
     */
    IPage Pagination(IPage page);
}

ShopAddressServiceImpl:

package com.bdqn.serivce.Impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bdqn.dao.ShopAddressMapper;
import com.bdqn.entity.ShopAddress;
import com.bdqn.serivce.ShopAddressService;
import org.springframework.stereotype.Service;

import java.sql.Wrapper;
import java.util.List;
import java.util.Map;

@Service
public class ShopAddressServiceImpl extends ServiceImpl implements ShopAddressService {
    /**
     * 根据 ID 删除
     *
     * @param id id 主键ID
     */
    @Override
    public boolean delete(Long id) {
        return this.removeById(id);
    }

    /**
     * 批量删除
     *
     * @param map 实体对象集合
     */
    @Override
    public boolean delete(Map map) {
        return this.removeByMap(map);
    }

    /**
     * 条件删除
     *  @param wrapper 实体包装类
     * @param shopAddress
     */
    @Override
    public boolean delete(QueryWrapper wrapper, ShopAddress shopAddress) {
        wrapper.like("name",shopAddress.getName()).lt("id_user",shopAddress.getIdUser());
        return this.remove(wrapper);
    }

    /**
     * 批量删除
     *
     * @param shopAddressList 实体对象集合
     */
    @Override
    public boolean delete(List shopAddressList) {
        return this.removeByIds(shopAddressList);
    }

    /**
     * 修改
     *
     * @param shopAddress 对象修改
     */
    @Override
    public boolean update(ShopAddress shopAddress) {
        return this.update(shopAddress);
    }

    /**
     * 批量修改
     *
     * @param shopAddressList 实体对象集合
     */
    @Override
    public boolean update(List shopAddressList) {
        return this.update(shopAddressList);
    }

    /**
     * 批量修改
     *
     * @param shopAddressList 实体对象集合
     * @param size            每次的数量
     */
    @Override
    public boolean update(List shopAddressList, Integer size) {
        return this.update(shopAddressList,size);
    }

    /**
     * 条件修改
     *
     * @param shopAddress 实体对象
     * @param queryWrapper     实体包装类
     */
    @Override
    public boolean update(ShopAddress shopAddress, QueryWrapper queryWrapper) {
        ShopAddress shop=new ShopAddress();
        shop.setName(shopAddress.getName());
        queryWrapper.like("name",shopAddress.getName()).lt("id_user",shopAddress.getIdUser());
        return this.update(shopAddress,queryWrapper);
    }

    /**
     * @param wrapper 实体包装类
     * @return 返回值 boolean
     */
    @Override
    public boolean update(QueryWrapper wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.update(wrapper) ;
    }

    /**
     * 插入
     *
     * @param shopAddress 实体对象
     */
    @Override
    public boolean add(ShopAddress shopAddress) {
        return this.save(shopAddress);
    }

    /**
     * 批量插入
     *
     * @param shopAddressList 实体对象集合
     */
    @Override
    public boolean saveBatch(List shopAddressList) {
        return this.saveBatch(shopAddressList);
    }

    /**
     * 批量插入
     *
     * @param shopAddressList 实体对象集合
     * @param size            每次的数量
     */
    @Override
    public boolean saveBatch(List shopAddressList, Integer size) {
        return this.saveBatch(shopAddressList,size);
    }

    /**
     * 根据ID 查询
     *
     * @param id 根据ID 主键
     */
    @Override
    public ShopAddress selectId(Long id) {
        return this.selectId(id);
    }

    /**
     * 查询(根据ID 批量查询)
     *
     * @param shopAddressList 实体对象集合
     */
    @Override
    public List selectList(List shopAddressList) {
        return this.selectList(shopAddressList);
    }

    /**
     * 查询(根据 columnMap 条件)
     *
     * @param map 实体对象集合
     */
    @Override
    public List selectList(Map map) {
        return this.selectList(map);
    }

    /**
     * 查询一条记录
     *
     * @param wrapper
     */
    @Override
    public ShopAddress get(QueryWrapper  wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.getOne(wrapper);
    }

    /**
     * 查询一条记录
     *
     * @param wrapper 实体对象封装操作类
     * @param flag    有多个 result 是否抛出异常
     */
    @Override
    public ShopAddress get(QueryWrapper  wrapper, boolean flag) {
        wrapper.like("name",new ShopAddress().getName());
        return this.getOne(wrapper,true);
    }

    /**
     * 查询一条记录
     *
     * @param wrapper 实体对象封装操作类
     */
    @Override
    public Map getMap(QueryWrapper  wrapper) {
        wrapper.like("name",new ShopAddress().getName());

        return this.getMap(wrapper);
    }

    /**
     * 查询总记录数
     *
     * @param wrapper 实体对象封装操作类
     */
    @Override
    public int total(QueryWrapper wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.count(wrapper);
    }

    /**
     * 查询所有记录数
     *
     * @param wrapper 实体对象封装操作类
     */
    @Override
    public List queryAll(QueryWrapper wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.list(wrapper);
    }

    /**
     * 条件查询
     *
     * @param wrapper 实体对象封装操作类
     */
    @Override
    public List> listMaps(QueryWrapper wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.listMaps(wrapper);
    }

    /**
     * 翻页查询
     *
     * @param page    翻页对象
     * @param wrapper 实体对象封装操作类
     */
    @Override
    public IPage Pagination(IPage page, QueryWrapper wrapper) {
        wrapper.like("name",new ShopAddress().getName());
        return this.page(page,wrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     */
    @Override
    public IPage Pagination(IPage page) {
        return this.page(page);
    }
}

以下是对BaseMapper及IService接口大致测试结果,条件查询功能是MybatisPlus核心点,多敲敲代码就明白其中用法,就可以早点下班陪家人啦!

 

MyBatis-Plus( CRUD-Mapper接口)_第5张图片


 

你可能感兴趣的:(MybatisPlus,java)