MybatisPlus的日常使用

已于 2024-10-10 16:23:33 修改
阅读量420 收藏 1
点赞数 10
文章标签： mybatis java tomcat
于 2024-10-09 13:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42679286/article/details/142781682
版权

一、基础接口

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 queryWrapper 实体对象封装操作类（可以为 null）
     */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 删除（根据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 实体对象
     */
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询总记录数
     * @param queryWrapper 实体对象
     */
    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);
}

二、条件构造器Wrapper及语法

Wrapper：条件构造抽象类，最顶端父类
AbstractWrapper：用于查询条件封装，生成 sql 的 where 条件
    QueryWrapper：Entity 对象封装操作类，不是用 lambda 语法
    UpdateWrapper：Update 条件封装，用于 Entity 对象更新操作
    AbstractLambdaWrapper：Lambda 语法使用 Wrapper 统一处理解析 lambda 获取 column
        LambdaQueryWrapper：用于 Lambda 语法使用的查询 Wrapper
        LambdaUpdateWrapper：Lambda 更新封装 Wrapper

三、插件的使用

四、Dao层的组装及规范

1.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.Builder;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;


@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("customs")
public class Customs implements Serializable {

    private static final long serialVersionUID=1L;

    /**
     * id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private String id;
	
    /**
     * 贸易方式
     */
    @TableField(value = "trade_way")
    private String tradeWay;

    /**
     * 报关发票号
     */
    @TableField(value = "report_invoice_no")
    private String reportInvoiceNo;

    /**
     * 唛头
     */
    @TableField(value = "mark_head")
    private String markHead;
	
    /**
     * 发票金额
     */
    @TableField(value = "invoice_amount")
    private BigDecimal invoiceAmount;
	
    /**
     * 状态（10草稿、20审批中、21审批通过、22驳回、30中止、40废弃）
     */
    @TableField(value = "status")
    private String status;

    /**
     * 是否删除 0 否 1 是
     */
    @TableField("del_flag")
    private Integer delFlag;
}

2.Dto

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
import java.math.BigDecimal;
import java.util.List;

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CustomsDto {
	
    /**
     * id
     */
    @ApiModelProperty(value = "ID",example = "")
    private String id;

    /**
     * 清关单号
     */
    @ApiModelProperty(value = "清关单号",example = "")
    private String clearCustomsNo;

    /**
     * 报关单ID
     */
    @ApiModelProperty(value = "报关单ID",example = "")
    private String reportCustomsId;

    /**
     * 报关流水号
     */
    @ApiModelProperty(value = "报关流水号",example = "")
    @NotBlank(message = "报关流水号 不能为空", groups = { AddGroup.class, EditGroup.class })
    private String reportCustomsPipeNo;

    /**
     * 贸易方式
     */
    @ApiModelProperty(value = "贸易方式",example = "")
    private String tradeWay;


    /**
     * 币种
     */
    @ApiModelProperty(value = "币种",example = "")
    @NotBlank(message = "币种不能为空", groups = { AddGroup.class, EditGroup.class })
    private String currency;

    /**
     * 状态（10草稿、20审批中、21审批通过、22驳回、30中止、40废弃）
     */
    @ApiModelProperty(value = "状态（10草稿、20审批中、21审批通过、22驳回、30中止、40废弃）",example = "")
    private String status;

  
}

3. Mapper

import com.dao.entity.customs.clear.Customs;
import com.dto.customs.clear.CustomsDto;
import com.adp.commons.utils.mapper.BaseMapperPlus;


public interface CustomsMapper extends BaseMapperPlus<CustomsMapper, Customs, CustomsDto> {
}

4.Dao

import com.commons.group.beans.AuxResponse;
import com.commons.utils.AuxBeanUtil;
import com.commons.utils.AuxStringUtils;
import com.commons.utils.page.QueryBody;
import com.constants.CommonConst;
import com.constants.cumtoms.CumtomsConst;
import com.dao.entity.customs.clear.Customs;
import com.dao.mapper.customs.clear.CustomsMapper;
import com.dto.customs.clear.CustomsDto;
import com.enums.customs.CustomsNumberEnum;
import com.enums.customs.CustomsStatusEnum;
import com.query.customs.clear.CustomsParams;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;


@Slf4j
@Component
public class CustomsDao extends ServiceImpl<CustomsMapper,Customs> {

    @Autowired
    private CustomsMapper customsMapper;

    public String produceSerialNumber(){
        LambdaQueryWrapper<Customs> lqw = Wrappers.lambdaQuery();
        lqw.eq(Customs::getDelFlag, 1);
        lqw.orderByAsc(Customs::getCreateTime);
        CustomsDto clearCustomsDto =customsMapper.selectVoOne(lqw);
        if(clearCustomsDto==null){
            Customs clearCustoms = new Customs();
            clearCustoms.setDelFlag(1);
            customsMapper.insert(clearCustoms);
            return reportCustomsNo;
        }
        return sequenceService.generate(CustomsNumberEnum.REPORT_CUSTOMS_CLEAR_NO.code).getData();
    }


    /**
     * 通过ID 获取详情
     */
    public CustomsDto getInfoById(String id){
        CustomsDto dto = customsMapper.selectVoById(id);
        if(dto==null){
            return null;
        }
        ShippingCustomsClearAnnexsDto annexsDto = new ShippingCustomsClearAnnexsDto();
        annexsDto.setBusinessType(CommonConst.NUMBER_STR.TEN);
        annexsDto.setBusinessId(id);
        return dto;
    }

    /**
     * 分页查询
     */
    public Page<CustomsDto> queryPageList(QueryBody<CustomsParams> queryBody){
        LambdaQueryWrapper<Customs> lqw = buildQueryWrapper(queryBody.getParams());
        lqw.orderByDesc(Customs::getCreateTime);
        return customsMapper.selectVoPage(queryBody.getPageQuery().build(), lqw);
    }

    /**
     * 列表查询
     */
    public List<CustomsDto> queryList(CustomsParams params){
        LambdaQueryWrapper<Customs> lqw = buildQueryWrapper(params);
        lqw.orderByDesc(Customs::getCreateTime);
        List<CustomsDto> queryRet = customsMapper.selectVoList(lqw);
        Map<String,String> map = new HashMap<>();
        List<CustomsDto> ret = new ArrayList<>();
        for(CustomsDto clearCustomsDto : queryRet){
            String clearInvoiceNo = clearCustomsDto.getClearInvoiceNo();
            if(!map.containsKey(clearInvoiceNo)){
                ret.add(clearCustomsDto);
            }
            map.put(clearInvoiceNo,clearInvoiceNo);
        }
      return ret;
    }

    /**
     * 新增数据
     */
    public AuxResponse<String> add(CustomsDto dto){
        Customs add = AuxBeanUtil.copy(dto, Customs.class);
        String clearCustomsNo = add.getClearCustomsNo();
        if(clearCustomsNo==null||clearCustomsNo.isEmpty()){
            clearCustomsNo = sequenceService.generate(CustomsNumberEnum.REPORT_CUSTOMS_CLEAR_NO.code).getData();
        }
        // 判断是否已保存
        LambdaQueryWrapper<Customs> lqw = Wrappers.lambdaQuery();
        lqw.eq(Customs::getClearCustomsNo, clearCustomsNo);
        lqw.last(CommonConst.SQL_LIMIT);
        Customs getOneEntity = customsMapper.selectOne(lqw);
        if(getOneEntity!=null){
            return AuxResponse.FAILED(CumtomsConst.THIS_NO_HAVE_DATA);
        }
        add.setClearCustomsNo(clearCustomsNo);
        boolean flag = customsMapper.insert(add) > 0;
        String retId = add.getId();
        if (flag) {
            return AuxResponse.SUCCESS(retId);
        }
        return AuxResponse.FAILED(CommonConst.ERROR);
    }

    /**
     * 修改数据
     */
    public AuxResponse<String> update(CustomsDto dto){
        String id = dto.getId();
        Customs ret  = customsMapper.selectById(id);
        if(ret==null){
            return AuxResponse.FAILED(CumtomsConst.NOT_THIS_DATA);
        }
        String status = ret.getStatus();
        if(CustomsStatusEnum.DRAFT.code.equals(status)||CustomsStatusEnum.REJECTED.code.equals(status)||CustomsStatusEnum.APPROVAL_ING.code.equals(status)){
            try {
                if(CustomsStatusEnum.APPROVAL_ING.code.equals(status)){
                    Customs update = new Customs();
                    update.setId(dto.getId());
                    update.setAmountIsEqual(dto.getAmountIsEqual());
                    customsMapper.updateById(update);
                }else {
                    Customs update = AuxBeanUtil.copy(dto, Customs.class);
                    customsMapper.updateById(update);
                }
            }catch (Exception e){
                log.error("ShippingClearCustomsDao---update{}",e.getMessage());
                return AuxResponse.FAILED(e.getMessage());
            }
            return AuxResponse.SUCCESS(id);
        }
        return AuxResponse.FAILED(CumtomsConst.ONLY_OPERA_DRAFT_DATA);
    }

    /**
     * 取消
     */
    public String cancel(String id){
        try {
            Customs ret  = customsMapper.selectById(id);
            if(ret==null){
                return CumtomsConst.NOT_THIS_DATA;
            }
            String status =  ret.getStatus();
            if(CustomsStatusEnum.DRAFT.code.equals(status)||CustomsStatusEnum.REJECTED.code.equals(status)){
                ret = new Customs();
                ret.setId(id);
                ret.setStatus(CustomsStatusEnum.DISUSE.code);
                customsMapper.updateById(ret);
                return CommonConst.SUCCESS;
            }
            return CumtomsConst.ONLY_CANEL_DATA;
        }catch (Exception e){
            log.error("ShippingClearCustomsDao---cancel{}",e.getMessage());
        }
        return CommonConst.ERROR;
    }

    private LambdaQueryWrapper<Customs> buildQueryWrapper(CustomsParams params) {
        LambdaQueryWrapper<Customs> lqw = Wrappers.lambdaQuery();
        lqw.like(AuxStringUtils.isNotBlank(params.getClearCustomsNo()), Customs::getClearCustomsNo, params.getClearCustomsNo());
        lqw.eq(AuxStringUtils.isNotBlank(params.getReportCustomsPipeNo()), Customs::getReportCustomsPipeNo, params.getReportCustomsPipeNo());
        lqw.eq(AuxStringUtils.isNotBlank(params.getReportInvoiceNo()), Customs::getReportInvoiceNo, params.getReportInvoiceNo());
        lqw.like(AuxStringUtils.isNotBlank(params.getClearInvoiceNo()), Customs::getClearInvoiceNo, params.getClearInvoiceNo());
        lqw.like(AuxStringUtils.isNotBlank(params.getUnitName()), Customs::getUnitName, params.getUnitName());
        lqw.like(AuxStringUtils.isNotBlank(params.getCustomName()), Customs::getCustomName, params.getCustomName());
        lqw.eq(AuxStringUtils.isNotBlank(params.getStatus()), Customs::getStatus, params.getStatus());
        lqw.ne(AuxStringUtils.isNotBlank(params.getFromStatus()), Customs::getStatus, params.getFromStatus());
        return lqw;
    }

}

五、常用注解

<!--mybatis-plus-->
<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-boot-starter</artifactId>
	<version>3.0.5</version>
</dependency>
JunSouth
关注
MyBatis-Plus常用功能教程
www.h y p e r p l a s m a.top
06-27 1308
MyBatis-Plus是MyBatis的增强工具，在其基础上只做增强不做改变，简化开发。无侵入，损耗小，内置强大的CRUD操作，支持Lambda形式调用，内置代码生成器、分页插件且支持多种数据库。
关于使用Mybatisplus自带的selectById和insert方法时的一些问题
09-07
主要介绍了关于使用Mybatisplus自带的selectById和insert方法时的一些问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
MyBatis-Plus常用方法
mkmmkkghhhhhhhh的博客
06-25 1030
MyBatis-Plus的常用方法
超详细超全面的MyBatisPlus的所有使用方法
热门推荐
緑水長流*z
02-25 1万+
真真正正的一文拿下全部MyBatisPlus知识点，包括BaseMapper的使用、Wrapper的详细使用、子查询、分组、排序、多条件拼接、Wrapper的全部子类使用方式、LambdaQueryMapper、LambdaUpdateMapper、Mapper的分页查询、MyBatisPlus的service通用查询、MyBatisPlus的全部注解使用方法、ActiveRecord的使用、多数据源的配置等等.....后续还会持续更新....
Mybatis Plus常见用法
攀登Fox的博客
07-14 1526
目录一、级目录二级目录三级目录 一、级目录 二级目录 三级目录
你用的mybatis plus 都用过哪些功能
大连赵哥的博客
02-11 385
你用的mybatis plus 都用过哪些功能
MybatisPlus中使用通用CRUD实现插入操作示例代码
04-18
MybatisPlus是一个基于Mybatis和Spring的数据访问增强工具，它为Mybatis提供了便捷的CRUD操作，大大简化了日常开发中的数据库操作。本示例主要介绍如何在MybatisPlus中利用其通用CRUD功能实现数据的插入操作。 首先...
springboot-mybatisplus-demo.zip
03-10
七、使用MyBatisPlus 在Service层或Controller层，我们可以直接注入Mapper接口，调用其提供的方法进行数据操作。例如，查询所有用户： ```java @Service public class UserService { @Autowired private ...
MyBatisPlus初体验
06-02
MyBatisPlus是一款基于MyBatis框架的扩展工具，它为开发者提供了强大的数据操作功能，简化了日常的 CRUD（创建、读取、更新、删除）操作。MyBatisPlus通过简化MyBatis的配置和SQL编写，使得开发更加高效。在本教程中...
MybatisPlus从入门到精通
08-30
MybatisPlus是一个强大的Java持久层框架，它是...通过这两个教程，你将全面了解MybatisPlus的使用，不仅能够熟练地进行日常的数据库操作，还能掌握如何优化和扩展MybatisPlus，使其更好地适应各种复杂的业务需求。
MybatisPlus的基本使用
最新发布
2301_80093566的博客
08-31 2092
是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。MybatisPlus通过扫描实体类，并基于反射获取实体类信息作为数据库信息。通过继承BaseMapper，Server层可以直接使用BaseMapper所提供的方法，这意味着像下面一样功能的函数无需我们自己定义，直接使用便可，非常的方便👍。提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper。
MyBatis-Plus基本使用。
weixin_60414376的博客
08-08 1323
通过前面的学习我们知道MyBatis-Plus已经为我们提供了很多方便的方法供我们使用，但是我们发现对于简单的selectById()方法，我们需要controller层调用serviceImpl层，然后serviceImpl再调用对应的Mapper层，我们试想能不能直接在Controller调用这种简单的方法，此时需要用到ServiceImpl类。表面上好像是删除了，但是实际上执行的是update语句，是用一个字段作为标志，来表示这个数据是否被删除。less than or equalto 小于等于。
mybatis-plus的使用 ------ 入门
z69183787的专栏
10-03 836
前言： mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中通过SQL语句操作数据库，很是灵活。但正其操作都要通过SQL语句进行，就必须写大量的xml文件，很是麻烦。mybatis-plus就很好的解决了这个问题。 欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。 一、mybatis-plus简介： Mybatis-Plus（简称MP）是一个 Myba
MyBatisPlus学习记录
qq_46018521的博客
09-18 782
文章目录简介特性快速入门 简介 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 官方地址：https://baomidou.com/ 愿景 我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍 特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作。 强大的 C
MybatisPlus 核心功能
Mwt258的博客
07-11 1329
MybatisPlus 核心功能使用（条件构造器、自定义SQL、Service接口）
mybatis-plus中函数使用
李振伟的博客
04-06 6923
前景： 工作中记录一场景，需要对查询出来的语句进行排序。正常来说可以直接用 orderByDesc 或 orderBy函数来用。 但是我这里需要使用到 函数 length() 排序。所以需要用到 mybatis-plus中 lambdaQueryWrapper的条件 构造，所以最终可以这么实现： queryWrapper.last(" order by length(enterprise_name)"); 这样就会在sql的最后拼上这句。 附图：lambdaQueryWrapper的条件构造图 ..
plus 什么是mybais_Mybatis-plus 入门
weixin_39792686的博客
12-24 300
1 Mybatis-Plus简介1.1 什么是Mybatis-PlusMyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。1.2 为什么要学习Mybatis-Plus我们已经学习过Mybatis这个框架，我们只需要在dao层定义抽象接口，基于Mybatis零实现的特性，就可以实现对数据库的crud操作。在...
MybatisPlus（常见注解、常见配置、条件构造器、自定义SQL、Service接口、代码生成、静态工具、逻辑删除、枚举及JSON处理器、配置加密、分页插件）
sjp991012的博客
08-01 568
MybatisPlus（常见注解、常见配置、条件构造器、自定义SQL、Service接口、代码生成、静态工具、逻辑删除、枚举及JSON处理器、配置加密、分页插件）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值