【基于SpringBoot和Mybatis-Plus的关联表关联关系保存和修改】

已于 2022-11-03 22:11:49 修改
阅读量1.8k 收藏 2
点赞数 1
分类专栏： SpringBoot 文章标签： spring boot mybatis-plus cache
于 2022-04-03 16:55:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jike11231/article/details/123939219
版权

本项目是个微服务项目，采用前后端分离方式进行协作开发。需求描述：表A和和表B通过equity_id进行关联，其中A->B是一对多且双向绑定关系。对此关联关系保证可编辑和新增。整体思路：新增时候直接双向绑定，修改时候先根据id全部删除，再新增关联关系。特此设计整理如下：

一、表结构和实体类

1.equity_limit_buy_set

CREATE TABLE `equity_limit_buy_set` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `del_flag` bit(1) NOT NULL DEFAULT b'0' COMMENT '删除状态:0否，1是',
  `equity_id` bigint(20) NOT NULL COMMENT '权益id',
  `effective_days` tinyint(1) NOT NULL DEFAULT '0' COMMENT '自购买后有效天数:默认值0：无限制',
  `limit_buy_num_type` tinyint(1) NOT NULL DEFAULT '0' COMMENT '购买次数类型限制:0不限购，1终身限购，2按周期限购，默认值0',    
  `limit_buy_num_cycle` tinyint(1) NOT NULL DEFAULT '0' COMMENT '购买次数周期限制:0终生，1每天，2每周，3每月',
  `limit_buy_num` int(11) NOT NULL DEFAULT '-1' COMMENT '限购数量:默认值：-1不限购',
  `limit_buy_user` bit(1) NOT NULL DEFAULT b'0' COMMENT '人群标签ID，0不限制购买人群，1：限制',
  `mutex_equity` bit(1) NOT NULL DEFAULT b'0' COMMENT '互斥权益ID列表,默认值：0没有互斥权益，1：有互斥权益',
  `stock_num` int(11) NOT NULL DEFAULT '-1' COMMENT '库存数量',
  `buy_button_text` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '立即购买' COMMENT '权益详情页:按钮文本',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_equity_id` (`equity_id`)
) COMMENT='权益限购设置';

在这里插入图片描述

2.equity_limit_buy_mutex_equity

CREATE TABLE `equity_limit_buy_mutex_equity` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `del_flag` bit(1) NOT NULL DEFAULT b'0' COMMENT '删除状态:0否，1是',
  `equity_id` bigint(20) NOT NULL COMMENT '权益id',
  `mutex_equity_id` bigint(20) NOT NULL COMMENT '互斥权益id',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_equity_id` (`equity_id`),
  KEY `idx_mutex_equity_id` (`mutex_equity_id`)
) COMMENT='互斥权益关联设置';

在这里插入图片描述
其中equity_limit_buy_set中如果没有mutex_equity互斥权益，则mutex_equity为0；如果有则为1。然后在equity_limit_buy_mutex_equity中维护equity_id和mutex_equity_id的双向绑定关联关系。

3.EquityLimitBuySetConstant常量枚举类

public class EquityLimitBuySetConstant {

    /**
     * 购买次数限制:0不限购，1终身限购，2按周期限购，默认值0
     */
    @Getter
    @AllArgsConstructor
    public enum limitBuyNumTypeEnum{
        no_purchase_restrictions(0,"不限购"),
        lifetime_limit(1,"终身限购"),
        restricted_by_cycle(2,"按周期限购");

        private int code;
        private String message;
    }

    /**
     *购买次数限制:0终生，1每天，2每周，3每月
     */
    @Getter
    @AllArgsConstructor
    public enum limitBuyNumCycleEnum{
        lifetime(0,"终生") {
            @Override
            public Date[] getIntervalTime() {
                return null;
            }
        },
        daily(1,"每天") {
            @Override
            public Date[] getIntervalTime() {
                return new Date[]{DateUtils.getStartOfDay(new Date()),DateUtils.getEndOfDay(new Date())};
            }
        },
        weekly(2,"每周") {
            @Override
            public Date[] getIntervalTime() {
                return DateUtils.getWeekStartAndEnd(0);
            }
        },
        monthly(3,"每月") {
            @Override
            public Date[] getIntervalTime() {
                return DateUtils.getMonthStartAndEnd();
            }
        };
        private int code;
        private String message;

        protected abstract Date[] getIntervalTime();

        public static Date[] getDateArray(int code){
            final limitBuyNumCycleEnum cycleEnum = Arrays.stream(values()).filter(v -> v.code == code).findFirst().orElse(null);
            if(Objects.isNull(cycleEnum)){
                return null;
            }
            return cycleEnum.getIntervalTime();
        }
    }

4.请求和响应体EquityInfoEditReq

@Data
public class EquityInfoEditReq {

    @ApiModelProperty("权益基本信息")
    @NotNull(message = "权益基本信息不能为空")
    private EquityInfo baseInfo;

    @ApiModelProperty("权益附加信息")
    private EquityInfoExt extInfo;

    @ApiModelProperty("权益限购设置")
    private EquityLimitBuySetReq equityLimitBuySetReq;
}

EquityLimitBuySetReq

@Data
public class EquityLimitBuySetReq{

    @ApiModelProperty("权益id")
    private Long equityId;

    @ApiModelProperty("自购买后有效天数：默认值0：无限制，其他值为实际有效天数")
    private Integer effectiveDays;

    @ApiModelProperty("购买次数限制：0不限购，1终身限购，2按周期限购，默认值0")
    private Integer limitBuyNumType;

    @ApiModelProperty("购买周期限制：0终生，1每天，2每周，3每月，默认值0")
    private Integer limitBuyNumCycle;

    @ApiModelProperty("限购数量：默认值：-1不限购，其他值为实际限购数量")
    private Integer limitBuyNum;

    @ApiModelProperty("限购人群设置：默认0不限制购买人群，1：限制；实际限购人群配置在limitBuyUserGroup")
    private Byte limitBuyUser;

    @ApiModelProperty("互斥权益设置：默认值0没有互斥权益，1：有互斥权益；实际互斥权益配置在mutexEquityIds")
    private Byte mutexEquity;

    @ApiModelProperty("库存数量:默认-1不限制，其他值为实际库存数量")
    private Integer stockNum;

    @ApiModelProperty("限购人群组列表")
    private List<Long> limitBuyUserGroup;

    @ApiModelProperty("互斥权益列表")
    private List<Long> mutexEquityIds;

    @ApiModelProperty(value = "权益详情页:购买按钮文本")
    private String buyButtonText;
}

二、业务逻辑层，主要涉及缓存的处理

1.EquityLimitBuySetService

public interface EquityLimitBuySetService extends IService<EquityLimitBuySet> {

    /**
     * 获取权益限购设置
     * @param limitBuySetByEquityId
     * @return EquityLimitBuySet
     */
    EquityLimitBuySet getLimitBuySetByEquityId(Long limitBuySetByEquityId);

    /**
     * 移除权益限购设置
     * @param equityId
     * @return boolean
    */
    boolean removeByEquityId(Long equityId);

    /**
     * 获取权益购买限制配置
     * @param id
     * @return
     * @throws Exception
     */
    EquityLimitBuySetReq getLimitBuySet(Long id) throws Exception;
}

2.EquityLimitBuySetServiceImpl

@Service
public class EquityLimitBuySetServiceImpl extends ServiceImpl<EquityLimitBuySetMapper, EquityLimitBuySet>
    implements EquityLimitBuySetService{

    @Autowired
    private EquityLimitBuyUserService equityLimitBuyUserService;

    @Autowired
    private EquityLimitBuyMutexEquityService equityLimitBuyMutexEquityService;

    private static final String BUY_SET = "buySet";

     /**
     * 获取权益限购设置
     * @param equityId
     * @return EquityLimitBuySet
     */
    @Override
    @Cacheable(value = BUY_SET,key = "#p0")
    public EquityLimitBuySet getLimitBuySetByEquityId(Long equityId) {
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("equity_id",equityId);
        return baseMapper.selectOne(queryWrapper);
    }

    /**
     * 移除权益限购设置
     * @param equityId
     * @return boolean
     */
    @CacheEvict(value=BUY_SET,key="#p0")
    @Override
    public boolean removeByEquityId(Long equityId) {
         return lambdaUpdate()
                .eq(EquityLimitBuySet::getEquityId, equityId)
                .remove();
    }
    
    /**
     * 获取权益购买限制配置
     * @param id
     * @return
     * @throws Exception
     */
    @Override
    public EquityLimitBuySetReq getLimitBuySet(Long id) throws Exception {
        EquityLimitBuySet equityLimitBuySet = this.getLimitBuySetByEquityId(id);
        if (equityLimitBuySet != null) {
            EquityLimitBuySetReq equityLimitBuySetReq = BeanCopyUtils.copyProperties(EquityLimitBuySetReq.class, equityLimitBuySet);
            if(equityLimitBuySet.getMutexEquity()){
                equityLimitBuySetReq.setMutexEquityIds(equityLimitBuyMutexEquityService.getMutexEquity(id));
            }
            if(equityLimitBuySet.getLimitBuyUser()){
                equityLimitBuySetReq.setLimitBuyUserGroup(equityLimitBuyUserService.getEquityLimitBuyUserByEquityId(id));
            }
            return equityLimitBuySetReq;
        }
        return null;
    }

    /**
     * 重写saveOrUpdate方法，清空缓存
     * */
    @CacheEvict(value=BUY_SET,key="#p0.equityId")
    @Override
    public boolean saveOrUpdate(EquityLimitBuySet entity) {
        return super.saveOrUpdate(entity);
    }
}

3.EquityLimitBuyMutexEquityService

public interface EquityLimitBuyMutexEquityService extends IService<EquityLimitBuyMutexEquity> {
    /**
     * 查找互斥权益
     * @param limitBuyMutexByEquityId
     * @return
     */
    List<Long> getMutexEquity(Long limitBuyMutexByEquityId);

    /**
     * 保存权益和互斥权益关联关系
     * @param equityId
     * @param mutexEquityIds
     */
    void saveOrUpdateLimitBuyMutex(Long equityId, List<Long> mutexEquityIds);

    /**
     * 移除互斥权益关联设置关系
     * @param equityId
     * @return
     */
    boolean removeByEquityId(Long equityId);
}

4.EquityLimitBuyMutexEquityServiceImpl

@Service
public class EquityLimitBuyMutexEquityServiceImpl extends ServiceImpl<EquityLimitBuyMutexEquityMapper, EquityLimitBuyMutexEquity>
    implements EquityLimitBuyMutexEquityService{

    private final static String BUY_MUTEX_EQUITY = "buyMutexEquity";

    /**
     * 查找互斥权益
     * @param limitBuyMutexByEquityId
     * @return
     */
    @Override
    @Cacheable(value = BUY_MUTEX_EQUITY,key = "#p0")
    public List<Long> getMutexEquity(Long limitBuyMutexByEquityId) {
        final List<EquityLimitBuyMutexEquity> equities = lambdaQuery().eq(EquityLimitBuyMutexEquity::getEquityId, limitBuyMutexByEquityId)
                .select(EquityLimitBuyMutexEquity::getMutexEquityId)
                .list();
        return equities.stream().map(EquityLimitBuyMutexEquity::getMutexEquityId).collect(Collectors.toList());
    }

    /**
     * 保存权益和互斥权益关联关系
     * @param equityId
     * @param mutexEquityIds
     */
    @CacheEvict(value = BUY_MUTEX_EQUITY,key="#p0")
    @Override
    public void saveOrUpdateLimitBuyMutex(Long equityId, List<Long> mutexEquityIds) {
        List<EquityLimitBuyMutexEquity> buyMutexEquity = new ArrayList<>();

        //删除双向绑定的互斥关系，采用nonIn是增量更新删除，提升效率
        lambdaUpdate()
                .notIn(EquityLimitBuyMutexEquity::getMutexEquityId,mutexEquityIds)
                .eq(EquityLimitBuyMutexEquity::getEquityId,equityId)
                .remove();
        lambdaUpdate()
                .notIn(EquityLimitBuyMutexEquity::getEquityId,mutexEquityIds)
                .eq(EquityLimitBuyMutexEquity::getMutexEquityId,equityId)
                .remove();

        //查找双向绑定的互斥关系
        List<EquityLimitBuyMutexEquity> mutexIdsList = lambdaQuery()
                .in(EquityLimitBuyMutexEquity::getMutexEquityId, mutexEquityIds)
                .eq(EquityLimitBuyMutexEquity::getEquityId,equityId)
                .list();
        List<EquityLimitBuyMutexEquity> equityIdsList = lambdaQuery()
                .eq(EquityLimitBuyMutexEquity::getMutexEquityId, equityId)
                .in(EquityLimitBuyMutexEquity::getEquityId,mutexEquityIds)
                .list();

        //获取双向绑定的互斥权益id和权益id
        Set<Long> mutexIds = mutexIdsList.stream().map(EquityLimitBuyMutexEquity::getMutexEquityId).collect(Collectors.toSet());
        Set<Long> equityIds = equityIdsList.stream().map(EquityLimitBuyMutexEquity::getEquityId).collect(Collectors.toSet());

        //保存双向绑定的关联关系
        mutexEquityIds.stream().forEach(
                i -> {
                    if(!mutexIds.contains(i)){
                        EquityLimitBuyMutexEquity mutexIdEquity = EquityLimitBuyMutexEquity.builder()
                                .equityId(equityId)
                                .mutexEquityId(i)
                                .build();
                        buyMutexEquity.add(mutexIdEquity);
                    }

                    if(!equityIds.contains(i)){
                        EquityLimitBuyMutexEquity equityIdEquity = EquityLimitBuyMutexEquity.builder()
                                .equityId(i)
                                .mutexEquityId(equityId)
                                .build();
                        buyMutexEquity.add(equityIdEquity);
                    }
                });
        this.saveBatch(buyMutexEquity);
    }

    /**
     * 移除互斥权益关联设置关系
     * @param equityId
     * @return
     */
    @CacheEvict(value = BUY_MUTEX_EQUITY,key="#p0")
    @Override
    public boolean removeByEquityId(Long equityId) {
        return lambdaUpdate()
                .eq(EquityLimitBuyMutexEquity::getEquityId,equityId)
                .remove();
    }
}

5.saveOrUpdateEquityLimitBuySet

    /**
     * 保存或修改权益限购设置
     *
     * @param equityId
     * @param req
     * @return Long
     * @throws CommonException
     */
    public Boolean saveOrUpdateEquityLimitBuySet(Long equityId, EquityInfoEditReq req) throws Exception {
        EquityLimitBuySetReq buySetReq = req.getEquityLimitBuySetReq();
        if (buySetReq != null) {
            EquityLimitBuySet equityLimitBuySet = BeanCopyUtils.copyProperties(EquityLimitBuySet.class, buySetReq);
            equityLimitBuySet.setDelFlag(false);
            equityLimitBuySet.setEquityId(equityId);
            EquityLimitBuySet limitBuySetByEquityId = equityLimitBuySetService.getLimitBuySetByEquityId(equityId);
            if(limitBuySetByEquityId != null){
			    //后续用于保存或者新增判断标志
                equityLimitBuySet.setId(limitBuySetByEquityId.getId());
            }
            //互斥权益id列表
            List<Long> mutexEquityIds = buySetReq.getMutexEquityIds();

            //保存或修改互斥权益id列表
            if (CollectionUtils.isEmpty(buySetReq.getMutexEquityIds())) {
                equityLimitBuySet.setMutexEquity(false);
				//删除缓存
                equityLimitBuyMutexEquityService.removeByEquityId(equityId);
            } else {
                equityLimitBuySet.setMutexEquity(true);
                equityLimitBuyMutexEquityService.saveOrUpdateLimitBuyMutex(equityId, mutexEquityIds);
            }
            equityLimitBuySetService.saveOrUpdate(equityLimitBuySet);
        }else{
            //权益限购设置为空的时候移除缓存
            equityLimitBuySetService.removeByEquityId(equityId);
            equityLimitBuyMutexEquityService.removeByEquityId(equityId);
        }
        return true;
    }

三、测试结果

在这里插入图片描述
在这里插入图片描述

四、总结

新增和删除关联关系表数据时候，需要考虑各种情况，尤其是对缓存淘汰时机的把控。

懒虫虫~
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis 一对多关联查询（两种方法）
04-26
NULL 博文链接：https://qihaibo1989.iteye.com/blog/2354597
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql
05-30
通用权限管理系统可练手可毕设，如果项目中有权限开发要求可直接拿来基础开发。 系统设计包括前端Vue框架和后端SpringBoot框架的搭建，以及数据库和权限控制模块的设计。前端使用Vue框架进行页面开发，利用Vue Router实现路由管理和权限控制。后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户信息，角色模块用于管理角色信息，权限模块用于管理权限信息。实现对用户访问资源的控制，可以通过将权限与角色进行关联。 系统实现主要包括用户登录、权限验证、角色管理、权限管理、资源管理等功能。当用户尝试登录时，系统会通过核实其用户名和密码来确认其身份。权限验证时，根据用户的角色和权限信息，系统评估用户是否具备访问该资源的权利。角色管理、权限管理和资源管理等功能，通过对应的模块实现。 总的来说，基于SpringBoot+Vue的通用权限控制系统设计与实现，可以提供灵活、可扩展、易维护的权限控制功能，适用于各种应用
Spring boot2基于Mybatis实现多表关联查询
08-19
主要介绍了Spring boot2基于Mybatis实现多表关联查询,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Mybatis增删改查实例（含联合查询）
07-31
一个入门级别的Mybatis 增删改查实例，包含多表联合查询，实体集合返回值。经测试可以跑通。
基于springboot+springmvc+mybatis-plus的微信小程序美容预约平台源码(前后台).zip
08-31
【资源说明】 基于springboot+springmvc+mybatis-plus的微信小程序美容预约平台源码(前后台).zip 简介 本小程序是一个在线的美容预约平台。其主要服务类型为：美甲，美容，美发，美睫。用户可以通过该平台进行相关服务的预约。 实现技术 # 简介 本项目是一个前后端分离的一个项目，前端是微信小程序语言，后端是java语言。 技术栈： 用到了spring boot技术栈。即springboot+springmvc+mybatis-plus为主要技术。Mybatis-plus可以在操作单表时极大优化效率，无需写sql语句。 # 数据库 数据库的设计遵循了设计规范，第三范式，mybatis-plus取数据时用到了表关联查询。详细设计见数据表。 # 前后端交互 前后端交互主要前端使用微信小程序中ajax请求，即wx.request以json格式向后台传递数据。后端接收后进行相应处理。 小程序功能 # 信息页 主要是根据服务类型进行服务项目的展示，用户点击服务项目可以查看项目详细信息，点击预定可以进行服务的预定。 # 订单页 订单页允许用户查看自己至今的订单列表，点击订单可以查看订单详细信息。如果订单未过期允许取消订单。 # 我的页 允许用户登陆后查看自己的信息即钱包余额。点击修改资料即可跳转到资 修改页。 注意：小程序大部分页面会检查用户登陆状态，未登录提示用户登陆后操作！！！ 【备注】 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 欢迎下载，沟通交流，互相学习，共同进步！
mybatisplus分批次保存数据到数据库
进击的豌豆的博客
02-23 937
一次保存1000条 public void addCatDocument(String sourceJsonFilePath, Long catProjectId, Long catFileId) { String json = FileUtils.readFile2String(sourceJsonFilePath); List<CatDocument> catDocumentList = new ArrayList<>(); try { O
mybatis---级联保存，级联删除
热门推荐
szq648477620的博客
06-09 2万+
mybatis如何试用级联保存，级联删除
Mybatis级联操作
石头视角
12-12 9022
对于Mybatis级联操作，网上好多资料都在讲级联查询的一些Mapping的标签，但是对于级联更新和插入的资料不是很多，但是这似乎是和Mybatis关系不大，只是之前用Hibernate用习惯了，感觉这些东西是由持久层框架l来维护的，由于Mybatis比Hibernate高效，摒弃了这些，所以对于INSERT和UPDATE的级联关系大部分是由数据库本身去维护的。 级联更新  有两个对象
mybatis plus中的save保存方法解释
liuliu0616的博客
07-05 3463
【代码】mybatis plus中的save保存方法解释。
Mybatis实现多表查询，级联，缓存
九点六
04-19 536
一对一，一对多，多对多，级联查询 一二级缓存
springboot整合mybatis-plus实现多表分页查询
06-20
springboot整合mybatis-plus实现多表分页查询，assocication和collection一对一，一对多关联。简单易懂，容易上手！
使用SpringBoot、Mybatis-Plus、Shiro、JWT等技术实现宿舍管理系统，实现了权限管理、数据字典、宿舍、宿
02-24
一、系统管理 系统管理模块对用户、角色、资源管理，实现权限分配。对系统日志管理，对系统的操作的日志记录查看。 1.用户管理（CRUD、用户关联角色、用户关联资源） 功能按钮 新增 编辑 删除 启用 禁用 角色 权限 角色按钮：用户关联角色。权限按钮：用户关联资源 2.角色管理（CRUD、角色关联资源、角色关联人员） 功能按钮 新增 编辑 删除 用户 权限 用户按钮：角色关联用户。权限按钮：角色关联资源 3.资源管理（CRUD） 功能按钮 新增 编辑 删除 显示部分 树形结构部分 对应节点可编辑部分 对应节点按钮列表 树形结构部分显示字段 资源名称 对应节点详细信息显示字段 父级菜单名称 菜单名称 菜单类型 菜单编码 菜单状态 菜单链接 菜单描述 对应节点按钮列表显示字段 按钮名称 按钮编码 按钮状态 按钮描述 4.日志管理（RD) 日志记录记录系统操作日志，仅提供查看和删除功能 5.在线用户 功能按钮 下线 二、学生管理 1.初始化学生（导入excel） 2.学生信息管理 学生管理模块包含初始化学生与学生信息管理，初始化学生是将学生信息
竞拍网后台，基于springboot、mybatis-plus、jpa、mysql。数据库已提供.zip
最新发布
04-22
MySQL基于关系型数据库模型，数据以表格形式组织，并通过预定义的键（如主键、外键）在表之间建立关联。它完全支持结构化查询语言（SQL），允许用户进行数据查询、插入、更新、删除、创建和管理数据库结构等操作。...
Mysql批量删除大量数据
jike11231的博客
08-27 1万+
假设有一个表(syslogs)有1000万条记录，需要在业务不停止的情况下删除其中statusid=1的所有记录，差不多有600万条， 直接执行 DELETE FROM syslogs WHERE statusid=1 会发现删除失败，因为lock wait timeout exceed的错误。如果要用order by 必须要和 limit 联用，否则被优化掉。然后分多次执行就可以把这些记录成功删除。...
SpringBoot启动后实现自动执行其它业务方法功能
jike11231的博客
06-23 5929
一、业务应用场景 1：需要在容器启动的时候执行一些内容。比如读取配置文件，数据库连接之类的。SpringBoot给我们提供了两个接口来帮助我们实现这种需求。 2：应用服务启动时，加载一些数据和执行一些应用的初始化动作。如：删除临时文件，清除缓存信息，读取配置文件信息，数据库连接等。 对于小型项目进行定时任务的启动。 ...
SpringBoot中SpringContextHolder工具类使用
jike11231的博客
02-15 5317
SpringContextHolder作用： 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext。 SpringContextHolder @Component public class SpringContextHolder implements ApplicationContextAware { /** * 以静态变量保存ApplicationContext,可在任意代码中取出Applicaiton
SpringBoot集成ElasticSearch
jike11231的博客
05-28 5054
被逼无奈，各行各业都在卷，给自己充电学习了Elasticsearch，在学完基础知识后（其实就是CRUD😂），就去Springboot中尝试整合ES。终于抽出时间，将学习的东西整理分享在此，欢迎大家批评指正哈~
使用webhook推送消息给群中钉钉机器人或者用户
jike11231的博客
07-17 4419
项目中需要给企业微信群使用钉钉机器人定时提醒功能，特此整理设计开发方案如下。 一、创建钉钉群 创建步骤请参考: 自定义机器人接入，创建好机器人后，复制出机器人的Webhook地址，将其塞入数据库表DINGTALK_ROBOT_TOKEN中。 ...
SpringBoot利用AOP记录系统日志
jike11231的博客
05-07 4086
利用Spring框架中aop,我们可以实现业务代码与系统级服务进行解耦，例如日志记录、事务及其他安全业务等，可以使得我们的工程更加容易维护、优雅。 一、添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 二、自定义注解 @T
springboot mybatis-plus多表关联查询
04-25
好的，关于这个问题，我可以告诉你，在Spring Boot中，可以使用MyBatis-Plus进行多表关联查询。使用MyBatis-Plus的Wrapper类，可以很方便地实现多表关联查询。例如，可以使用Join方法连接表，或者使用LambdaQueryWrapper和LambdaUpdateWrapper等方法进行复杂的多表查询和更新操作。另外，MyBatis-Plus还提供了一些方便的注解，比如@TableJoin注解和@ColumnJoin注解，可以更便捷地定义多表关联查询语句。希望这些信息对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值