springboot实现高并发红包系统（java 全网最全包括语音口令 文字口令 普通 拼手气）

置顶 已于 2023-12-12 12:45:54 修改
阅读量1.1k 收藏 6
点赞数 3
分类专栏： 红包 高并发 文章标签： redis rabbitmq spring boot java
于 2022-06-14 10:14:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40942490/article/details/125273041
版权

一起探讨学习

欢迎大家进群，一起讨论学习

每天给大家提供技术干货

在这里插入图片描述

博主技术笔记 https://notes.xiyankt.com


博主开源微服架构前后端分离技术博客项目源码地址，欢迎各位star https://gitee.com/bright-boy/xiyan-blog


springboot实现高并发红包系统（全网最全）

下面的业务处理请根据你们实际的场景进行处理

1.sql设计

CREATE TABLE `red_packet_info`  (
  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '自增id',
  `packet_id` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包id',
  `type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包类型（0=拼手气红包，1=普通红包，2=文字口令红包，3=语音口令红包）',
  `watchword_content` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '口令内容',
  `user_id` int(0) NOT NULL COMMENT '用户id，哪个用户发的红包',
  `total_amount` decimal(8, 2) NOT NULL COMMENT '红包总金额',
  `total_packet` int(0) NOT NULL COMMENT '红包个数',
  `amount_one` decimal(8, 2) NULL DEFAULT NULL COMMENT '单个红包金额',
  `blessing` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包祝福语',
  `cover` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包封面',
  `left_amount` decimal(8, 2) NOT NULL COMMENT '剩余红包金额',
  `left_packet` int(0) NOT NULL COMMENT '剩余红包个数',
  `expire_time` datetime(0) NOT NULL COMMENT '红包过期时间',
  `send_type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '发送红包类型（0=私发,1=群发）',
  `status` char(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包状态（1=已创建，-1=已失效，2=已抢完）',
  `create_time` datetime(0) NOT NULL COMMENT '创建时间',
  `update_time` datetime(0) NOT NULL COMMENT '更新时间',
  `deleted` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '0' COMMENT '是否删除',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT '' COMMENT '创建者',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '更新者',
  `tenant_id` bigint(0) NOT NULL DEFAULT 0 COMMENT '租户编号',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `packet_id`(`packet_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 775 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '红包表' ROW_FORMAT = Dynamic;

CREATE TABLE `red_packet_records`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `user_id` int(0) NOT NULL COMMENT '用户id',
  `amount` decimal(8, 2) NOT NULL COMMENT '抢到的金额',
  `watchword_content` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '口令内容',
  `red_packet_id` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '红包id',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT '' COMMENT '创建者',
  `create_time` datetime(0) NOT NULL COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT '' COMMENT '更新者',
  `update_time` datetime(0) NOT NULL COMMENT '更新时间',
  `deleted` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '1' COMMENT '是否删除',
  `tenant_id` bigint(0) NOT NULL DEFAULT 0 COMMENT '租户编号',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 223 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '红包记录表' ROW_FORMAT = Dynamic;

2.实体类

RedPacketInfoDO
package cn.inno.pala.module.packet.dal.dataobject;

import cn.inno.pala.framework.tenant.core.db.TenantBaseDO;
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 lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.math.BigDecimal;
import java.util.Date;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description: 红包表
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("red_packet_info")
public class RedPacketInfoDO extends TenantBaseDO {

    private static final long serialVersionUID = 1L;

    /**
     * 自增id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 红包id
     */
    private String packetId;

    /**
     * 红包类型（0=拼手气红包，1=普通红包，2=文字口令红包，3=语音口令红包）
     */
    private String type;

    /**
     * 口令内容
     */
    private String watchwordContent;

    /**
     * 用户id，哪个用户发的红包
     */
    private Integer userId;

    /**
     * 红包总金额
     */
    private BigDecimal totalAmount;

    /**
     * 红包个数
     */
    private Integer totalPacket;

    /**
     * 单个红包金额
     */
    private BigDecimal amountOne;

    /**
     * 红包祝福语
     */
    private String blessing;

    /**
     * 红包封面
     */
    private String cover;

    /**
     * 剩余红包金额
     */
    private BigDecimal leftAmount;

    /**
     * 剩余红包个数
     */
    private Integer leftPacket;

    /**
     * 发送红包类型（0=私发,1=群发）
     */
    private String sendType;

    /**
     * 红包过期时间
     */
    private Date expireTime;

    /**
     * 红包状态（1=已创建，-1=已失效，2=已抢完）
     */
    private String status;

    /**
     * 用户昵称
     */
    @TableField(exist = false)
    private String nickname;

    /**
     * 用户头像
     */
    @TableField(exist = false)
    private String avatar;

}
RedPacketRecordsDO
package cn.inno.pala.module.packet.dal.dataobject;

import cn.inno.pala.framework.tenant.core.db.TenantBaseDO;
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 lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.math.BigDecimal;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description: 红包记录表
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("red_packet_records")
public class RedPacketRecordsDO extends TenantBaseDO {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 用户id
     */
    private Integer userId;

    /**
     * 抢到的金额
     */
    private BigDecimal amount;

    /**
     * 口令内容
     */
    private String watchwordContent;
    /**
     * 红包id
     */
    private String redPacketId;


    /**
     * 用户昵称
     */
    @TableField(exist = false)
    private String nickname;

    /**
     * 用户头像
     */
    @TableField(exist = false)
    private String avatar;
}

3.Mapper

RedPacketInfoMapper
package cn.inno.pala.module.packet.dal.mysql;

import cn.inno.pala.framework.mybatis.core.mapper.BaseMapperX;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketInfoDO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description:
 */
@Mapper
public interface RedPacketInfoMapper extends BaseMapperX<RedPacketInfoDO> {
    /**
     * 红包查询
     *
     * @param packetId
     * @return
     */
    RedPacketInfoDO getRedPacket(@Param("packetId") String packetId);
}
RedPacketRecordsMapper
package cn.inno.pala.module.packet.dal.mysql;

import cn.inno.pala.framework.mybatis.core.mapper.BaseMapperX;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketRecordsDO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description:
 */
@Mapper
public interface RedPacketRecordsMapper extends BaseMapperX<RedPacketRecordsDO> {
    /**
     * 根据用户id和红包id查询红包记录
     *
     * @param packetId
     * @param userId
     * @return
     */
    RedPacketRecordsDO getRedPacketRecord(@Param("packetId") String packetId, @Param("userId") Long userId);

    /**
     * 根据红包id查询红包记录列表
     *
     * @param packetId
     * @return
     */
    List<RedPacketRecordsDO> getRedPacketRecordList(@Param("packetId") String packetId);
}

4.xml

RedPacketInfoMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.inno.pala.module.packet.dal.mysql.RedPacketInfoMapper">
    <resultMap id="redPacketResultMap" type="RedPacketInfoDO">
        <id column="id" property="id"></id>
        <result column="packet_id" property="packetId"></result>
        <result column="type" property="type"></result>
        <result column="watchword_content" property="watchwordContent"></result>
        <result column="user_id" property="userId"></result>
        <result column="total_amount" property="totalAmount"></result>
        <result column="total_packet" property="totalPacket"></result>
        <result column="amount_one" property="amountOne"></result>
        <result column="blessing" property="blessing"></result>
        <result column="cover" property="cover"></result>
        <result column="left_amount" property="leftAmount"></result>
        <result column="left_packet" property="leftPacket"></result>
        <result column="expire_time" property="expireTime"></result>
        <result column="send_type" property="sendType"></result>
        <result column="status" property="status"></result>
        <result column="create_time" property="createTime"></result>
        <result column="update_time" property="updateTime"></result>
        <result column="deleted" property="deleted"></result>
        <result column="creator" property="creator"></result>
        <result column="updater" property="updater"></result>
        <result column="tenant_id" property="tenantId"></result>
    </resultMap>

    <select id="getRedPacket" resultMap="redPacketResultMap">
        SELECT r.*, m.nickname, m.avatar
        FROM `red_packet_info` r
                 INNER JOIN member_user m ON r.user_id = m.id
        WHERE r.packet_id = #{packetId}
    </select>
</mapper>
RedPacketRecordsMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.inno.pala.module.packet.dal.mysql.RedPacketRecordsMapper">
    <resultMap id="redPacketRecordResultMap" type="RedPacketRecordsDO">
        <id column="id" property="id"></id>
        <result column="user_id" property="userId"></result>
        <result column="amount" property="amount"></result>
        <result column="watchword_content" property="watchwordContent"></result>
        <result column="red_packet_id" property="redPacketId"></result>
        <result column="create_time" property="createTime"></result>
        <result column="nickname" property="nickname"></result>
        <result column="avatar" property="avatar"></result>
    </resultMap>

    <select id="getRedPacketRecord" resultMap="redPacketRecordResultMap">
        SELECT r.id, r.user_id,r.watchword_content, r.amount, r.red_packet_id, r.create_time, m.nickname, m.avatar
        FROM `red_packet_records` r
                 INNER JOIN member_user m ON r.user_id = m.id
        WHERE r.red_packet_id = #{packetId}
          AND r.user_id = #{userId}
        ORDER BY r.create_time ASC
    </select>

    <select id="getRedPacketRecordList" resultMap="redPacketRecordResultMap">
        SELECT r.id, r.user_id,r.watchword_content, r.amount, r.red_packet_id, r.create_time, m.nickname, m.avatar
        FROM `red_packet_records` r
                 INNER JOIN member_user m ON r.user_id = m.id
        WHERE r.red_packet_id = #{packetId}
        ORDER BY r.create_time ASC
    </select>
</mapper>

5.Service

RedPacketInfoService
package cn.inno.pala.module.packet.service;

import cn.inno.pala.module.packet.controller.app.dto.DismantleRedPacketDTO;
import cn.inno.pala.module.packet.controller.app.dto.RedPacketsDTO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketInfoVO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketQualificationsVO;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketInfoDO;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description:
 */
public interface RedPacketInfoService extends IService<RedPacketInfoDO> {
    /**
     * 发红包
     *
     * @param packetsDTO
     * @return
     */
    String sendRedPacket(RedPacketsDTO packetsDTO);


    /**
     * 抢红包
     *
     * @param packetId
     * @return
     */
    RedPacketQualificationsVO grabPacket(String packetId);


    /**
     * 拆红包
     *
     * @param dismantleRedPacketDTO
     * @return
     */
    RedPacketInfoVO getPacket(DismantleRedPacketDTO dismantleRedPacketDTO);


    /**
     * 红包记录
     *
     * @param packetId
     * @return
     */
    RedPacketInfoVO getPacketRecord(String packetId);
}

6.impl

RedPacketInfoServiceImpl
package cn.inno.pala.module.packet.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.inno.pala.framework.common.util.collection.ObjectConvertUtil;
import cn.inno.pala.framework.common.util.md5.MD5Util;
import cn.inno.pala.framework.common.util.validation.AssertUtils;
import cn.inno.pala.framework.security.core.LoginUser;
import cn.inno.pala.framework.security.core.util.SecurityFrameworkUtils;
import cn.inno.pala.framework.tenant.core.context.TenantContextHolder;
import cn.inno.pala.module.packet.constants.Constant;
import cn.inno.pala.module.packet.controller.app.bo.RedPacketRecordsBO;
import cn.inno.pala.module.packet.controller.app.dto.DismantleRedPacketDTO;
import cn.inno.pala.module.packet.controller.app.dto.RedPacketsDTO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketInfoVO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketQualificationsVO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketRecordsVO;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketInfoDO;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketRecordsDO;
import cn.inno.pala.module.packet.dal.mysql.RedPacketInfoMapper;
import cn.inno.pala.module.packet.dal.mysql.RedPacketRecordsMapper;
import cn.inno.pala.module.packet.dal.redis.packet.RedPacketQualificationDAO;
import cn.inno.pala.module.packet.dal.redis.packet.RedPacketRedisDAO;
import cn.inno.pala.module.packet.dal.redis.records.RedPacketRecordsRedisDAO;
import cn.inno.pala.module.packet.enums.RedPacketSendTypeEnum;
import cn.inno.pala.module.packet.enums.RedPacketStatusEnum;
import cn.inno.pala.module.packet.enums.RedPacketTypeEnum;
import cn.inno.pala.module.packet.service.RedPacketInfoService;
import cn.inno.pala.module.pay.enums.wallet.PalaWalletEnum;
import cn.inno.pala.module.pay.wallet.ApiWalletService;
import cn.inno.pala.module.pay.wallet.vo.ApiJudgeAmplePalaCoinReqVO;
import cn.inno.pala.module.pay.wallet.vo.ApiReducePalaCoinReqVO;
import cn.inno.pala.module.pay.wallet.vo.ApiReducePalaCoinRespVO;
import cn.inno.pala.module.system.api.dict.DictDataApi;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;

import static cn.inno.pala.module.packet.enums.ErrorCodeConstants.*;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description:
 */
@Service
@SuppressWarnings("rawtypes")
@Slf4j
public class RedPacketInfoServiceImpl extends ServiceImpl<RedPacketInfoMapper, RedPacketInfoDO> implements RedPacketInfoService {
    @Value("${red-packet.backtrack.delayed-exchange-name}")
    public String delayedExchangeName;
    @Value("${red-packet.backtrack.delayed-routing-key}")
    public String delayedRoutingKey;
    @Value("${red-packet.warehousing.entry-exchange-name}")
    public String entryExchangeName;
    @Value("${red-packet.warehousing.entry-routing-key}")
    public String entryRoutingKey;
    @Resource
    private RedPacketRedisDAO redPacketRedisDAO;
    @Resource
    private DictDataApi dictDataApi;
    @Resource
    private RedPacketInfoMapper redPacketInfoMapper;
    @Resource
    private RedPacketRecordsMapper redPacketRecordsMapper;
    @Resource
    private RedPacketRecordsRedisDAO redPacketRecordsRedisDAO;
    @Resource
    private RedPacketQualificationDAO redPacketQualificationDAO;
    @Resource
    private RabbitTemplate rabbitTemplate;
    @Resource
    private ApiWalletService apiWalletService;
    @Resource
    private RedissonClient redissonClient;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String sendRedPacket(RedPacketsDTO packetsDTO) {
        log.info("request param 【{}】", packetsDTO);
        LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
        Long loginUserId = loginUser.getId();
        RedPacketInfoDO redPackets = new RedPacketInfoDO();
        RLock lock = redissonClient.getLock(Constant.RED_PACKET_LOCK_KEY + loginUserId);
        lock.lock();
        try {
            //设置默认的祝福语
            if (StrUtil.isBlank(packetsDTO.getBlessing())) {
                packetsDTO.setBlessing(Constant.DEFAULT_BLESSING_MESSAGE);
            }

            if (StrUtil.isBlank(packetsDTO.getCover())) {
                packetsDTO.setCover(Constant.DEFAULT_RED_PACKET_COVER);
            }
            //红包的总个数
            int totalPacket = Integer.valueOf(packetsDTO.getTotalPacket());
            //红包总金额
            BigDecimal totalAmount = packetsDTO.getTotalAmount();
            //单个红包金额
            BigDecimal amountOne = packetsDTO.getAmountOne();
            AssertUtils.isTrue(totalPacket <= 0, NUMBER_NOT_ZERO);
            //拼手气红包或者口令红包
            if (packetsDTO.getType().equals(RedPacketTypeEnum.LUCKY.getType()) || packetsDTO.getType().equals(RedPacketTypeEnum.TEXT_WATCHWORD.getType()) || packetsDTO.getType().equals(RedPacketTypeEnum.VOICE_WATCHWORD.getType())) {
                AssertUtils.isTrue(null == totalAmount, TOTAL_AMOUNT_NOT_NULL);
                amountOne = totalAmount.divide(BigDecimal.valueOf(totalPacket), 2, RoundingMode.DOWN);
            }
            //普通红包
            if (packetsDTO.getType().equals(RedPacketTypeEnum.ORDINARY.getType())) {
                AssertUtils.isTrue(null == amountOne, ONE_AMOUNT_NOT_NULL);
                totalAmount = amountOne.multiply(BigDecimal.valueOf(totalPacket));
            }
            //从数据字段获取金额的最大值和最小值
            Integer minRedPacket = Integer.valueOf(dictDataApi.dictDatalist("min_red_packet").get(0).getValue());
            Integer maxRedPacket = Integer.valueOf(dictDataApi.dictDatalist("max_red_packet").get(0).getValue());

            Integer minTotalPacket = Integer.valueOf(dictDataApi.dictDatalist("min_total_packet").get(0).getValue());
            Integer maxTotalPacket = Integer.valueOf(dictDataApi.dictDatalist("max_total_packet").get(0).getValue());

            //判断用户发的红包是否在限制内
            AssertUtils.isTrue(amountOne.compareTo(BigDecimal.valueOf(minRedPacket)) == -1, MIN_AMOUNT_ERROR, minRedPacket);
            AssertUtils.isTrue(amountOne.compareTo(BigDecimal.valueOf(maxRedPacket)) == 1, MAX_AMOUNT_ERROR, maxRedPacket);
            AssertUtils.isTrue(Integer.valueOf(packetsDTO.getTotalPacket()) < minTotalPacket, TOTAL_PACKET);
            AssertUtils.isTrue(Integer.valueOf(packetsDTO.getTotalPacket()) > maxTotalPacket, TOTAL_PACKET);
            AssertUtils.isTrue(BigDecimal.valueOf(totalAmount.intValue()).compareTo(totalAmount) == -1, NOT_DECIMAL);
            //需要校验用户的账户余额
            Boolean result = apiWalletService.judgeAmplePalaCoin(new ApiJudgeAmplePalaCoinReqVO(loginUserId, totalAmount));
            AssertUtils.isTrue(!result, INSUFFICIENT_BALANCE);

            BeanUtils.copyProperties(packetsDTO, redPackets);
            redPackets.setUserId(loginUserId.intValue());
            redPackets.setCreateTime(new Date());
            redPackets.setTotalPacket(totalPacket);
            redPackets.setTotalAmount(totalAmount);
            redPackets.setWatchwordContent(packetsDTO.getWatchwordContent());
            redPackets.setLeftAmount(totalAmount);
            redPackets.setLeftPacket(totalPacket);
            redPackets.setStatus(RedPacketStatusEnum.CREATED.getStatus());
            redPackets.setSendType(packetsDTO.getSendType());
            redPackets.setNickname(loginUser.getNickname());
            redPackets.setAvatar(loginUser.getAvatar());
            //采用雪花算法生成红包id，保证唯一性
            redPackets.setPacketId(String.valueOf(IdUtil.getSnowflake((long) (0 + Math.random() * (30 - 0 + 1)), (long) (0 + Math.random() * (30 - 0 + 1))).nextId()));
            Date date = new Date();
            //一天过期
            redPackets.setExpireTime(DateUtil.offsetDay(date, 1));

            //1.扣减账户额度
            ApiReducePalaCoinReqVO palaCoinReq = new ApiReducePalaCoinReqVO().setUserId(loginUserId).setBusiness(PalaWalletEnum.REDUCE_HAND_OUT_RED_ENVELOPES.getStatus()).setTargetId(redPackets.getPacketId()).setOperationPalaCoin(totalAmount).setContent(RedPacketSendTypeEnum.PRIVATE.getStatus().equals(packetsDTO.getSendType()) ? "给昵称" + packetsDTO.getNickname() + "发红包" : "世界频道发出红包");
            ApiReducePalaCoinRespVO apiReducePalaCoinResp = apiWalletService.reducePalaCoin(palaCoinReq);
            AssertUtils.isTrue(!apiReducePalaCoinResp.getState(), DEDUCTION_ACCOUNT_ERROR);
            log.info("扣减账户额度成功状态【{}】", apiReducePalaCoinResp.getState());
            //2.保存红包信息
            redPacketInfoMapper.insert(redPackets);
            log.info("用户【{}】，插入红包成功记录【{}】", loginUserId, redPackets);
            //3.往mq发送一条延迟消息，方便做24小时红包到期退款的作用
            rabbitTemplate.convertAndSend(delayedExchangeName, delayedRoutingKey, redPackets.getPacketId(), correlationData -> {
                //设置24小时延迟时间
                correlationData.getMessageProperties().setDelay(24 * 60 * 60 * 1000);
                correlationData.getMessageProperties().setHeader("tenant-id", TenantContextHolder.getTenantId());
                correlationData.getMessageProperties().setHeader("user-id", loginUserId);
                return correlationData;
            });
            log.info("往mq发送延迟消息");
            //4.写入redis中  过期时间是3天
            redPacketRedisDAO.set(redPackets.getPacketId(), redPackets);
            log.info("红包记录写入redis");
            //5.返回红包id
            return redPackets.getPacketId();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public RedPacketQualificationsVO grabPacket(String packetId) {
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
        judge(loginUserId, packetId, new RedPacketInfoDO(), new RedPacketRecordsDO());
        String md5 = MD5Util.getMD5(loginUserId.toString());
        redPacketQualificationDAO.set(Constant.RED_PACKET_QUALIFICATIONS_KEY + loginUserId + "_" + packetId, md5);
        return RedPacketQualificationsVO.builder().build().setFlag(true).setSign(md5);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public RedPacketInfoVO getPacket(DismantleRedPacketDTO dismantleRedPacketDTO) {
        //登录用户
        LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
        RedPacketInfoDO redPackets = new RedPacketInfoDO();
        RedPacketRecordsDO redPacketRecords = new RedPacketRecordsDO();
        RLock lock = redissonClient.getLock(Constant.RED_PACKET_LOCK_KEY + dismantleRedPacketDTO.getPacketId());
        lock.lock();
        try {
            //md5验签
            String value = redPacketQualificationDAO.get(Constant.RED_PACKET_QUALIFICATIONS_KEY + loginUserId + "_" + dismantleRedPacketDTO.getPacketId());
            AssertUtils.isTrue(ObjectUtil.notEqual(value, dismantleRedPacketDTO.getSign()), SIGN_ERROR);

            judge(loginUserId, dismantleRedPacketDTO.getPacketId(), redPackets, redPacketRecords);
            //如果是私发，自己不能领取自己的红包
            if (redPackets.getSendType().equals(RedPacketSendTypeEnum.PRIVATE.getStatus())) {
                AssertUtils.isTrue(loginUserId.intValue() == redPackets.getUserId(), NOT_AVAILABLE);
            }
            //抢到的红包金额
            BigDecimal amount = calculate(redPackets);
            //更新红包的剩余金额和数量
            redPackets.setLeftPacket(redPackets.getLeftPacket() - 1);
            redPackets.setLeftAmount(redPackets.getLeftAmount().subtract(amount));
            if (redPackets.getLeftPacket() == 0) {
                //更新红包的状态为已领完
                redPackets.setStatus(RedPacketStatusEnum.WITHOUT.getStatus());
            }
            //构建抢红包记录
            RedPacketRecordsDO packetRecords = new RedPacketRecordsDO();
            packetRecords.setAmount(amount);
            packetRecords.setUserId(loginUserId.intValue());
            packetRecords.setRedPacketId(redPackets.getPacketId());
            packetRecords.setAvatar(loginUser.getAvatar());
            packetRecords.setCreateTime(new Date());
            packetRecords.setNickname(loginUser.getNickname());
            packetRecords.setWatchwordContent(dismantleRedPacketDTO.getWatchwordContent());

            RedPacketRecordsBO redPacketRecordsBO = new RedPacketRecordsBO();
            BeanUtils.copyProperties(packetRecords, redPacketRecordsBO);
            redPacketRecordsBO.setNickname(redPackets.getNickname());

            Map<String, Object> map = new HashMap<>(3);
            map.put("redPackets", redPackets);
            map.put("redPacketRecords", redPacketRecordsBO);
            //异步入账
            rabbitTemplate.convertAndSend(entryExchangeName, entryRoutingKey, map, correlationData -> {
                correlationData.getMessageProperties().setHeader("tenant-id", TenantContextHolder.getTenantId());
                correlationData.getMessageProperties().setHeader("user-id", loginUserId);
                return correlationData;
            });
            log.info("mq异步入账");

            //更新redis状态
            redPacketRedisDAO.set(dismantleRedPacketDTO.getPacketId(), redPackets);
            log.info("红包记录状态更新【{}】,并写入redis", redPackets);

            //添加到redis中
            redPacketRecordsRedisDAO.set(dismantleRedPacketDTO.getPacketId(), loginUserId.toString(), packetRecords);
            log.info("用户【{}】抢到的红包【{}】", loginUser, packetRecords);
            //构建返回红包信息
            RedPacketInfoVO redPacketVO = buildRedPacketVO(redPackets, packetRecords);
            //删除签名
            redPacketQualificationDAO.delete(Constant.RED_PACKET_QUALIFICATIONS_KEY + loginUserId + "_" + dismantleRedPacketDTO.getPacketId());
            return redPacketVO;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public RedPacketInfoVO getPacketRecord(String packetId) {
        //从缓存中读取红包信息
        RedPacketInfoDO redPackets = redPacketRedisDAO.get(packetId);
        //校验红包是否存在
        AssertUtils.isTrue(ObjectUtil.isEmpty(redPackets), RECORD_ERROR);
        //登录用户
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
        //该用户用户领过红包记录
        RedPacketRecordsDO redPacketRecords = redPacketRecordsRedisDAO.get(packetId, loginUserId.toString());
        //构建返回红包信息
        RedPacketInfoVO redPacketVO = buildRedPacketVO(redPackets, redPacketRecords);
        log.info("红包记录【{}】", redPacketVO);
        return redPacketVO;
    }

    /**
     * 计算金额
     *
     * @param redPacketInfo
     * @return
     */
    private BigDecimal calculate(RedPacketInfoDO redPacketInfo) {
        BigDecimal amount = BigDecimal.valueOf(0);
        if (redPacketInfo.getType().equals(RedPacketTypeEnum.LUCKY.getType()) || redPacketInfo.getType().equals(RedPacketTypeEnum.TEXT_WATCHWORD.getType()) || redPacketInfo.getType().equals(RedPacketTypeEnum.VOICE_WATCHWORD.getType())) {
            //如果只剩下一个红包
            if (redPacketInfo.getLeftPacket() == 1) {
                //抢到的红包金额就是剩下的红包金额
                amount = redPacketInfo.getLeftAmount();
            } else {
                //如果还有多个红包通过二倍均值法计算
                //剩余红包金额/剩余红包个数
                BigDecimal result = redPacketInfo.getLeftAmount().divide(BigDecimal.valueOf(redPacketInfo.getLeftPacket()), 0, RoundingMode.UP);
                //二倍均值发 （M/N）*2 剩余红包金额/剩余红包个数*2
                result = result.multiply(BigDecimal.valueOf(2));
                //将金额单位元拆分为分
                int limit = (int) (result.doubleValue() * 100);
                amount = BigDecimal.valueOf(RandomUtil.randomInt(limit - 1) + 1).divide(BigDecimal.valueOf(100), 0, RoundingMode.UP);
            }
        } else if (redPacketInfo.getType().equals(RedPacketTypeEnum.ORDINARY.getType())) {
            //如果是普通红包，抢到的金额就是单个红包的金额
            amount = redPacketInfo.getAmountOne();
        }
        return amount;
    }


    /**
     * 数据构建
     *
     * @param redPackets
     * @param redPacketRecordsDO
     * @return
     */
    private RedPacketInfoVO buildRedPacketVO(RedPacketInfoDO redPackets, RedPacketRecordsDO redPacketRecordsDO) {
        RedPacketInfoVO redPacketVO = new RedPacketInfoVO();
        redPacketVO.setSendUserName(redPackets.getNickname());
        redPacketVO.setAvatar(redPackets.getAvatar());
        if (null != redPacketRecordsDO) {
            redPacketVO.setReceiveAmount(redPacketRecordsDO.getAmount());
        }
        redPacketVO.setTotalPacket(redPackets.getTotalPacket());
        //已领取红包的个数
        redPacketVO.setGetPacket(redPackets.getTotalPacket() - redPackets.getLeftPacket());
        redPacketVO.setTotalAmount(redPackets.getTotalAmount());
        redPacketVO.setLeftAmount(redPackets.getLeftAmount());
        redPacketVO.setBlessing(redPackets.getBlessing());
        redPacketVO.setWatchwordContent(redPackets.getWatchwordContent());
        //当前红包所有抢到的记录
        Map<String, RedPacketRecordsDO> entries = redPacketRecordsRedisDAO.entries(redPackets.getPacketId());
        List<RedPacketRecordsDO> redPacketRecordList = new ArrayList<>(entries.values());
        if (entries.size() == 0) {
            redPacketRecordList = redPacketRecordsMapper.getRedPacketRecordList(redPackets.getPacketId());
        }
        //类型转换
        List<RedPacketRecordsVO> list = ObjectConvertUtil.convertInstance().objectConvert(redPacketRecordList, RedPacketRecordsVO.class);
        redPacketVO.setRecordsList(list);
        return redPacketVO;
    }


    /**
     * 数据判断
     *
     * @param loginUserId
     * @param packetId
     * @param redPackets
     * @param redPacketRecords
     */
    private void judge(Long loginUserId, String packetId, RedPacketInfoDO redPackets, RedPacketRecordsDO redPacketRecords) {
        AssertUtils.isTrue(StrUtil.isBlank(packetId), PARAMETER_EXCEPTION);
        RedPacketInfoDO redPacketInfoDO = redPacketRedisDAO.get(packetId);
        if (ObjectUtil.isNotNull(redPacketInfoDO)) {
            BeanUtils.copyProperties(redPacketInfoDO, redPackets);
        }
        //校验红包是否存在
        AssertUtils.isTrue(ObjectUtil.isNull(redPacketInfoDO), RECORD_ERROR);
        RedPacketRecordsDO redPacketRecordsDO = redPacketRecordsRedisDAO.get(packetId, loginUserId.toString());
        if (ObjectUtil.isNotNull(redPacketRecordsDO)) {
            BeanUtils.copyProperties(redPacketRecordsDO, redPacketRecords);
        }
        //判断用户是否领过红包
        AssertUtils.isTrue(ObjectUtil.isNotNull(redPacketRecordsDO), RECEIVED);
        //判断红包是否过期
        AssertUtils.isTrue(ObjectUtil.equals(RedPacketStatusEnum.EXPIRED.getStatus(), redPacketInfoDO.getStatus()), EXPIRED);
        //判断红包是否已抢完
        AssertUtils.isTrue(RedPacketStatusEnum.WITHOUT.getStatus().equals(redPacketInfoDO.getStatus()) || redPacketInfoDO.getLeftPacket() < 1, ROBBED);
    }
}

7.application.yaml


数据库配置省略了，你自己加上

spring:
  # rabbitmq
  rabbitmq:
    host: 10.0.99.114
    port: 5672 # tcp端口
    username: admin # 用户名
    password: admin # 用户密码
    #确认消息已发送到交换机(Exchange)
    publisher-confirm-type: correlated
    #保证交换机能把消息推送到队列中
    publisher-returns: true
    virtual-host: / # 虚拟主机
    #这个配置是保证消费者会消费消息，手动确认
    listener:
      simple:
        acknowledge-mode: manual
    template:
      mandatory: true
    # Redis 配置。Redisson 默认的配置足够使用，一般不需要进行调优
  redis:
	 host: 10.0.99.191 # 地址
	 port: 6379 # 端口
	 database: 8 # 数据库索引
	 password: 'password'
#红包队列
red_packet:
  backtrack:
    # 24小时退回业务队列
    delayed-queue-name: red.packet.delayed.queue-test
    delayed-exchange-name: red.packet.delayed.exchange-test
    delayed-routing-key: red.packet.delayed.routing.key-test
    # 24小时退回死信队列
    dead-letter-queue-name: red.packet.dead.letter.delayed.queue-test
    dead-letter-exchange-name: red.packet.dead.letter.delayed.exchange-test
    dead-letter-routing-key: red.packet.dead.letter.delayed.routing.key-test

8.controller

package cn.inno.pala.module.packet.controller.app;

import cn.inno.pala.framework.common.pojo.CommonResult;
import cn.inno.pala.module.packet.controller.app.dto.DismantleRedPacketDTO;
import cn.inno.pala.module.packet.controller.app.dto.RedPacketsDTO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketInfoVO;
import cn.inno.pala.module.packet.controller.app.vo.RedPacketQualificationsVO;
import cn.inno.pala.module.packet.service.RedPacketInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;

import static cn.inno.pala.framework.common.pojo.CommonResult.success;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description:
 */
@RestController
@Api(tags = "用户 APP - 红包")
@RequestMapping("/redPacket")
public class RedPacketInfoController {
    @Resource
    private RedPacketInfoService redPacketInfoService;

    @PostMapping("/send")
    @ApiOperation("发红包接口")
    public CommonResult<String> sendPacket(@RequestBody @Valid RedPacketsDTO redPacketsDTO) {
        return success(redPacketInfoService.sendRedPacket(redPacketsDTO));
    }

    @GetMapping("/grab/{packetId}")
    @ApiOperation("抢红包接口")
    public CommonResult<RedPacketQualificationsVO> grabPacket(@PathVariable("packetId") String packetId) {
        return success(redPacketInfoService.grabPacket(packetId));
    }

    @PostMapping("/rob")
    @ApiOperation("拆红包接口")
    public CommonResult<RedPacketInfoVO> getPacket(@RequestBody DismantleRedPacketDTO dismantleRedPacketDTO) {
        return success(redPacketInfoService.getPacket(dismantleRedPacketDTO));
    }

    @GetMapping("/get/{packetId}")
    @ApiOperation("红包记录接口")
    public CommonResult<RedPacketInfoVO> getPacketRecord(@PathVariable("packetId") String packetId) {
        return success(redPacketInfoService.getPacketRecord(packetId));
    }
}
9.VO
RedPacketInfoVO
package cn.inno.pala.module.packet.controller.app.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.List;

/**
 * @author: bright
 * @date:Created in 2022/6/4 16:42
 * @describe : 抢红包返回对象
 */
@Data
public class RedPacketInfoVO implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "发红包的用户名")
    private String sendUserName;

    @ApiModelProperty(value = "头像")
    private String avatar;

    @ApiModelProperty(value = "当前登陆用户领取的红包金额")
    private BigDecimal receiveAmount;

    @ApiModelProperty(value = "红包总数量")
    private Integer totalPacket;

    @ApiModelProperty(value = "已领取的红包数量")
    private Integer getPacket;

    @ApiModelProperty(value = "红包总金额")
    private BigDecimal totalAmount;

    @ApiModelProperty(value = "剩余红包金额")
    private BigDecimal leftAmount;

    @ApiModelProperty(value = "口令内容")
    private String watchwordContent;

    @ApiModelProperty(value = "祝福语")
    private String blessing;

    @ApiModelProperty(value = "红包领取记录集合")
    private List<RedPacketRecordsVO> recordsList;

}
RedPacketQualificationsVO
package cn.inno.pala.module.packet.controller.app.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;

import java.io.Serializable;

/**
 * @author: bright
 * @description:
 * @time: 2022-07-25 19:04
 */
@Data
@Builder
public class RedPacketQualificationsVO implements Serializable {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "true 有资格抢")
    private Boolean flag;

    @ApiModelProperty(value = "拆红包签名")
    private String sign;
}
RedPacketRecordsVO
package cn.inno.pala.module.packet.controller.app.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

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

/**
 * @author: bright
 * @date:Created in 2022/6/3 13:40
 * @describe :红包记录
 */
@Data
public class RedPacketRecordsVO implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "用户名")
    private String nickname;

    @ApiModelProperty(value = "红包金额")
    private BigDecimal amount;

    @ApiModelProperty(value = "抢红包时间")
    private Date createTime;

    @ApiModelProperty(value = "头像")
    private String avatar;

}
10.DTO
DismantleRedPacketDTO
package cn.inno.pala.module.packet.controller.app.dto;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.io.Serializable;

/**
 * @author: bright
 * @description:
 * @time: 2022-07-06 12:30
 */
@Data
public class DismantleRedPacketDTO implements Serializable {
    @ApiModelProperty(value = "红包id", required = true)
    @NotBlank(message = "红包id不能为空")
    private String packetId;

    @ApiModelProperty(value = "口令内容")
    private String watchwordContent;

    @ApiModelProperty(value = "签名")
    private String sign;
}
RedPacketsDTO
package cn.inno.pala.module.packet.controller.app.dto;

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Range;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import java.io.Serializable;
import java.math.BigDecimal;

/**
 * @author: bright
 * @date:Created in 2022/6/3 13:40
 * @describe :红包表
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RedPacketsDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "红包类型（0=拼手气红包，1=普通红包，2=文字口令红包，3=语音口令红包）", required = true)
    @NotBlank(message = "红包类型不能为空")
    @Range(min = 0, max = 3, message = "红包类型必须在规定内")
    private String type;

    @ApiModelProperty(value = "红包总金额")
    private BigDecimal totalAmount;

    @ApiModelProperty(value = "口令内容")
    private String watchwordContent;

    @ApiModelProperty(value = "红包个数", required = true)
    @NotNull(message = "红包个数不能为空")
    @Pattern(regexp = "-?[1-9]\\d*", message = "红包个数不能为小数")
    private String totalPacket;

    @ApiModelProperty(value = "单个红包金额")
    private BigDecimal amountOne;

    @ApiModelProperty(value = "祝福语")
    private String blessing;

    @ApiModelProperty(value = "封面")
    private String cover;

    @ApiModelProperty(value = "0.私发,1.群发")
    @NotBlank(message = "类型不能为空")
    @Range(min = 0, max = 1, message = "类型必须在规定内")
    private String sendType;

    @ApiModelProperty(value = "私发的目标昵称,群发不需要传")
    private String nickname;
}
11.BO
RedPacketRecordsBO
package cn.inno.pala.module.packet.controller.app.bo;

import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.math.BigDecimal;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description: 红包记录表
 */
@Data
@Accessors(chain = true)
public class RedPacketRecordsBO implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer userId;

    private BigDecimal amount;

    private String redPacketId;

    private String nickname;

    private String watchwordContent;
}

12.mp

RedPacketDelayMessage
package cn.inno.pala.module.packet.mp.message;


import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author: Bright
 * @time: 2022-06-07 13:58
 * @description: 红包过期退款延迟消息配置类
 */
@Configuration
public class RedPacketDelayMessage {

    /*=====================业务队列===================*/

    @Value("${red-packet.backtrack.delayed-queue-name}")
    public String delayedQueueName;

    @Value("${red-packet.backtrack.delayed-exchange-name}")
    public String delayedExchangeName;

    @Value("${red-packet.backtrack.delayed-routing-key}")
    public String delayedRoutingKey;


    /*=====================死信队列===================*/

    @Value("${red-packet.backtrack.dead-letter-queue-name}")
    public String deadLetterQueueName;

    @Value("${red-packet.backtrack.dead-letter-exchange-name}")
    public String deadLetterExchangeName;


    @Value("${red-packet.backtrack.dead-letter-routing-key}")
    public String deadLetterRoutingKey;

    /**
     * 业务队列
     *
     * @return
     */
    @Bean
    public Queue delayedQueue() {
        Map<String, Object> args = new HashMap<>(2);
        // x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", deadLetterExchangeName);
        // x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", deadLetterRoutingKey);
        return QueueBuilder.durable(delayedQueueName).withArguments(args).build();
    }


    /**
     * 声明死信队列
     *
     * @return
     */
    @Bean
    public Queue delayedDeadLetterQueue() {
        return new Queue(deadLetterQueueName);
    }

    /**
     * 自定义交换机 我们在这里定义的是一个延迟交换机
     *
     * @return
     */
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>(1);
        //自定义交换机的类型
        args.put("x-delayed-type", "direct");
        return new CustomExchange(delayedExchangeName, "x-delayed-message", true, false, args);
    }

    /**
     * 声明死信Exchange
     *
     * @return
     */
    @Bean
    public DirectExchange delayedDeadLetterExchange() {
        return new DirectExchange(deadLetterExchangeName);
    }

    /**
     * 业务队列绑定关系
     *
     * @param queue
     * @param delayedExchange
     * @return
     */
    @Bean
    public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
                                       @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(queue).to(delayedExchange).with(delayedRoutingKey).noargs();
    }


    /**
     * 声明死信队列绑定关系
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding bindingDelayedDeadLetterQueue(@Qualifier("delayedDeadLetterQueue") Queue queue,
                                      @Qualifier("delayedDeadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(deadLetterRoutingKey);
    }

}
RedPacketEntryMessage
package cn.inno.pala.module.packet.mp.message;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author: bright
 * @description: 抢红包入账队列
 * @time: 2022-06-11 15:29
 */
@Configuration
public class RedPacketEntryMessage {

    /*=====================业务队列===================*/

    /**
     * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
     * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
     * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
     *
     * @return
     */
    @Value("${red-packet.warehousing.entry-queue-name}")
    public String entryQueueName;

    @Value("${red-packet.warehousing.entry-exchange-name}")
    public String entryExchangeName;


    @Value("${red-packet.warehousing.entry-routing-key}")
    public String entryRoutingKey;


    /*=====================死信队列===================*/


    @Value("${red-packet.warehousing.dead-letter-queue-name}")
    public String deadLetterQueueName;

    @Value("${red-packet.warehousing.dead-letter-exchange-name}")
    public String deadLetterExchangeName;


    @Value("${red-packet.warehousing.dead-letter-routing-key}")
    public String deadLetterRoutingKey;

    /**
     * 业务队列
     *
     * @return
     */
    @Bean
    public Queue entryQueue() {
        Map<String, Object> args = new HashMap<>(2);
        // x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", deadLetterExchangeName);
        // x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", deadLetterRoutingKey);
        return QueueBuilder.durable(entryQueueName).withArguments(args).build();
    }

    /**
     * 声明死信队列
     *
     * @return
     */
    @Bean
    public Queue entryDeadLetterQueue() {
        return new Queue(deadLetterQueueName);
    }

    /**
     * 业务交换机
     *
     * @return
     */
    @Bean
    public DirectExchange entryExchange() {
        return new DirectExchange(entryExchangeName, true, false);
    }


    /**
     * 声明死信Exchange
     *
     * @return
     */
    @Bean
    public DirectExchange entryDeadLetterExchange() {
        return new DirectExchange(deadLetterExchangeName);
    }

    /**
     * 业务队列绑定关系
     *
     * @param queue
     * @param entryExchange
     * @return
     */
    @Bean
    public Binding bindingEntryQueue(@Qualifier("entryQueue") Queue queue,
                                     @Qualifier("entryExchange") DirectExchange entryExchange) {
        return BindingBuilder.bind(queue).to(entryExchange).with(entryRoutingKey);
    }

    /**
     * 声明死信队列绑定关系
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding bindingEntryDeadLetterQueue(@Qualifier("entryDeadLetterQueue") Queue queue,
                                     @Qualifier("entryDeadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(deadLetterRoutingKey);
    }
}
RedPacketDelayConsumer
package cn.inno.pala.module.packet.mp.consumer;

import cn.hutool.core.util.ObjectUtil;
import cn.inno.pala.framework.common.exception.ServiceException;
import cn.inno.pala.framework.common.util.validation.AssertUtils;
import cn.inno.pala.framework.tenant.core.context.TenantContextHolder;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketInfoDO;
import cn.inno.pala.module.packet.dal.mysql.RedPacketInfoMapper;
import cn.inno.pala.module.packet.dal.redis.packet.RedPacketRedisDAO;
import cn.inno.pala.module.packet.enums.RedPacketStatusEnum;
import cn.inno.pala.module.pay.enums.wallet.PalaWalletEnum;
import cn.inno.pala.module.pay.wallet.ApiWalletService;
import cn.inno.pala.module.pay.wallet.vo.ApiAddPalaCoinReqVO;
import cn.inno.pala.module.pay.wallet.vo.ApiAddPalaCoinRespVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import static cn.inno.pala.module.packet.enums.ErrorCodeConstants.ADD_ACCOUNT_ERROR;

/**
 * @author: bright
 * @description:
 * @time: 2022-06-11 10:17
 */
@Component
@Slf4j
public class RedPacketDelayConsumer {

    @Resource
    private RedPacketInfoMapper redPacketInfoMapper;

    @Resource
    private ApiWalletService apiWalletService;

    @Resource
    private RedPacketRedisDAO redPacketRedisDAO;

    /**
     * 普通消费
     *
     * @param message
     * @param channel
     * @throws Exception
     */
    @RabbitListener(queues = "#{delayedQueue.name}")
    @Transactional(rollbackFor = Exception.class)
    public void receiveDelayedQueue(Message message, Channel channel) throws Exception {
        try {
            business(message);
            //手动确认
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            if (e instanceof ServiceException) {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                return;
            }
            //丢到死信队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
            e.printStackTrace();
        }
    }


    /**
     * 死信消费
     *
     * @param message
     * @param channel
     * @throws Exception
     */
    @RabbitListener(queues = "#{delayedDeadLetterQueue.name}")
    @Transactional(rollbackFor = Exception.class)
    public void receiveDelayedDeadLetterQueue(Message message, Channel channel) throws Exception {
        try {
            business(message);
            //手动确认
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            if (e instanceof ServiceException) {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                return;
            }
            //这里需要做插入数据库的操作防止消息丢失，在通过订单任务进行重新投递，我这里持久化就省略了
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
            e.printStackTrace();
        }
    }

    private void business(Message message) {
        //获取tenantId
        String tenantId = message.getMessageProperties().getHeader("tenant-id").toString();
        //获取当前登录用户id
        String userId = message.getMessageProperties().getHeader("user-id").toString();
        //设置tenantId
        TenantContextHolder.setTenantId(Long.valueOf(tenantId));
        String redPacketId = new String(message.getBody());
        RedPacketInfoDO redPacketInfo = redPacketInfoMapper.selectOne("packet_id", redPacketId);
        //未抢完需求进行退款处理
        if (ObjectUtil.isNotNull(redPacketInfo) && redPacketInfo.getLeftPacket() != 0 && redPacketInfo.getLeftAmount().intValue() != 0) {
            ApiAddPalaCoinReqVO palaCoinReq = new ApiAddPalaCoinReqVO()
                    .setUserId(Long.valueOf(redPacketInfo.getUserId()))
                    .setContent("红包退款")
                    .setBusiness(PalaWalletEnum.ADD_RETURN_THE_RED_ENVELOPE.getStatus())
                    .setTargetId(redPacketInfo.getPacketId())
                    .setOperationPalaCoin(redPacketInfo.getLeftAmount());

            ApiAddPalaCoinRespVO apiAddPalaCoinResp = apiWalletService.addPalaCoin(palaCoinReq);
            log.info("退还给用户【】,金额【{}】,红包id【{}】", redPacketInfo.getUserId(), redPacketInfo.getLeftAmount(), redPacketInfo.getPacketId());
            AssertUtils.isTrue(!apiAddPalaCoinResp.getState(), ADD_ACCOUNT_ERROR);
            //修改状态为已过期
            RedPacketInfoDO redPacketInfoDO = new RedPacketInfoDO();
            redPacketInfoDO.setStatus(RedPacketStatusEnum.EXPIRED.getStatus());
            redPacketInfoDO.setUpdater(userId);
            redPacketInfoMapper.update(redPacketInfoDO, new QueryWrapper<RedPacketInfoDO>().eq("packet_id", redPacketInfo.getPacketId()));
            log.info("修改数据库状态为已过期");
            //修改redis状态
            redPacketInfo.setStatus(RedPacketStatusEnum.EXPIRED.getStatus());
            redPacketRedisDAO.set(redPacketInfo.getPacketId(), redPacketInfo);
            log.info("修改redis状态为已过期");
        }
    }
}
RedPacketEntryConsumer
package cn.inno.pala.module.packet.mp.consumer;

import cn.inno.pala.framework.common.exception.ServiceException;
import cn.inno.pala.framework.common.util.validation.AssertUtils;
import cn.inno.pala.framework.tenant.core.context.TenantContextHolder;
import cn.inno.pala.module.packet.controller.app.bo.RedPacketRecordsBO;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketInfoDO;
import cn.inno.pala.module.packet.dal.dataobject.RedPacketRecordsDO;
import cn.inno.pala.module.packet.dal.mysql.RedPacketInfoMapper;
import cn.inno.pala.module.packet.dal.mysql.RedPacketRecordsMapper;
import cn.inno.pala.module.pay.enums.wallet.ConversionTypeEnum;
import cn.inno.pala.module.pay.enums.wallet.PalaTypeEnum;
import cn.inno.pala.module.pay.enums.wallet.PalaWalletDiamondsnEnum;
import cn.inno.pala.module.pay.wallet.ApiWalletService;
import cn.inno.pala.module.pay.wallet.vo.ApiDiamondsnRespVO;
import cn.inno.pala.module.pay.wallet.vo.ApiSetDiamondsnReqVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.Map;

import static cn.inno.pala.module.packet.enums.ErrorCodeConstants.ADD_ACCOUNT_ERROR;

/**
 * @author: bright
 * @description: 抢红包入账消费
 * @time: 2022-06-13 15:29
 */
@Component
@Slf4j
public class RedPacketEntryConsumer {
    @Resource
    private ApiWalletService apiWalletService;

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Resource
    private RedPacketInfoMapper redPacketInfoMapper;

    @Resource
    private RedPacketRecordsMapper redPacketRecordsMapper;

    /**
     * 普通消费
     *
     * @param message
     * @param channel
     * @throws Exception
     */
    @RabbitListener(queues = "#{entryQueue.name}")
    @Transactional(rollbackFor = Exception.class)
    public void receiveEntryQueue(Message message, Channel channel) throws IOException {
        try {
            business(message);
            //手动确认
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            if (e instanceof ServiceException) {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                return;
            }
            //丢到死信队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
            e.printStackTrace();
        }
    }

    /**
     * 死信消费
     *
     * @param message
     * @param channel
     * @throws Exception
     */
    @RabbitListener(queues = "#{entryDeadLetterQueue.name}")
    @Transactional(rollbackFor = Exception.class)
    public void receiveEntryDeadLetterQueue(Message message, Channel channel) throws Exception {
        try {
            business(message);
            //手动确认
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            if (e instanceof ServiceException) {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                return;
            }
            //这里需要做插入数据库的操作防止消息丢失，在通过订单任务进行重新投递，我这里持久化就省略了
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
            e.printStackTrace();
        }
    }

    private void business(Message message) {
        //获取tenantId
        String tenantId = message.getMessageProperties().getHeader("tenant-id").toString();
        //获取当前登录用户id
        String userId = message.getMessageProperties().getHeader("user-id").toString();
        //设置tenantId
        TenantContextHolder.setTenantId(Long.valueOf(tenantId));
        Map<String, Object> map = (Map<String, Object>) rabbitTemplate.getMessageConverter().fromMessage(message);
        //更新数据库剩余金额和个数，如果已抢完，也需要修改状态
        RedPacketInfoDO redPackets = (RedPacketInfoDO) map.get("redPackets");
        //更新数据库状态
        redPacketInfoMapper.update(redPackets, new QueryWrapper<RedPacketInfoDO>().eq("packet_id", redPackets.getPacketId()));
        log.info("修改数据库红包金额和个数【{}】", redPackets);
        RedPacketRecordsBO redPacketRecords = (RedPacketRecordsBO) map.get("redPacketRecords");
        ApiSetDiamondsnReqVO apiSetDiamondsnReq = new ApiSetDiamondsnReqVO();
        apiSetDiamondsnReq.setUserId(Long.valueOf(userId));
        apiSetDiamondsnReq.setContent("抢到昵称" + redPacketRecords.getNickname() + "红包");
        apiSetDiamondsnReq.setBusiness(PalaWalletDiamondsnEnum.ADD_RECEIVED_A_RED_ENVELOPE.getStatus());
        apiSetDiamondsnReq.setTargetId(redPacketRecords.getRedPacketId());
        apiSetDiamondsnReq.setConversionType(ConversionTypeEnum.PARRA_CURRENCY.getStatus());
        apiSetDiamondsnReq.setType(PalaTypeEnum.TYPE_ADD.getStatus());
        apiSetDiamondsnReq.setOperationQuota(redPacketRecords.getAmount());
        ApiDiamondsnRespVO apiDiamondsnResp = apiWalletService.setDiamondsn(apiSetDiamondsnReq);
        AssertUtils.isTrue(!apiDiamondsnResp.getState(), ADD_ACCOUNT_ERROR);
        log.info("抢到昵称【{}】 金额【{}】", redPacketRecords.getNickname(), redPacketRecords.getAmount());
        //添加抢到记录
        RedPacketRecordsDO redPacketRecordsDO = new RedPacketRecordsDO();
        redPacketRecordsDO.setAmount(redPacketRecords.getAmount());
        redPacketRecordsDO.setRedPacketId(redPacketRecords.getRedPacketId());
        redPacketRecordsDO.setUserId(redPacketRecords.getUserId());
        redPacketRecordsDO.setUpdater(userId);
        redPacketRecordsDO.setCreator(userId);
        redPacketRecordsDO.setWatchwordContent(redPacketRecords.getWatchwordContent());
        //插入数据库中
        redPacketRecordsMapper.insert(redPacketRecordsDO);
        log.info("插入红包记录【{}】", redPacketRecordsDO);
    }
}
刘明同学呀
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
「高并发秒杀」微信抢红包实战案例，阿里java面试算法
2401_83974783的博客
04-02 1042
学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！最后再分享的一些BATJ等大厂20、21年的面试题，把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。Mybatis面试专题MySQL面试专题并发编程面试专题实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。
详解利用redis + lua解决抢红包高并发的问题
12-15
抢红包的需求分析 抢红包的场景有点像秒杀，但是要比秒杀简单点。 因为秒杀通常要和库存相关。而抢红包则可以允许有些红包没有被抢到，因为发红包的人不会有损失，没抢完的钱再退回给发红包的人即可。 另外像小米这样的抢购也要比淘宝的要简单，也是因为像小米这样是一个公司的，如果有少量没有抢到，则下次再抢，人工修复下数据是很简单的事。而像淘宝这么多商品，要是每一个都存在着修复数据的风险，那如果出故障了则很麻烦。 基于redis的抢红包方案 下面介绍一种基于Redis的抢红包方案。 把原始的红包称为大红包，拆分后的红包称为小红包。 1.小红包预先生成，插到数据库里，红包对应的用户ID是null。生成算法
并发编程学习案例-模拟抢红包
腾蛟起凤吕学士
01-09 832
再来系统动手学习一下Java并发编程。的发令枪使用模式；红包均分，最后一个分不完的解决方法抢红包的需求,每个红包均分，最后一个除外1. 设置红包总额2. 设置红包的个数3. 模拟抢红包的人数 （细节：涉及余额分配 10元3个人抢，得把钱分完）4. 抢红包，同一时间多个人可以同时开始 （细节：要保证同时开始）
java抢红包并发设计_高并发开发之-使用redis抢红包设计
weixin_29254029的博客
02-13 1939
假设一个需求，在某个预告活动中准备了10w个红包，100w人在某个时间点去开抢，每人只能抢1次，如何保证性能和准确性，下面我给出我的一个设计方案，抛砖引玉分析瓶颈查询用户是否已参与过活动获取一个可抢的红包，保证多个人不能获取到同一个红包建立红包与用户的关系设计数据结构解决瓶颈问题查询用户是否已参与过活动：可以使用Set的特性，集合中不能出现重复的数据，每个用户发起抢的动作就将用户标识放入Set中，...
抢红包系统搭建和超发现象，以及解决问题提高性能
cuichunchi的博客
04-25 2606
以传统的数据库作为存储介质、以Redis+Lua来作为库存存储介质最后落到数据库 本次案例介绍抢红包的场景，模拟20万红包，分为400个小红包，每个红包500元，有1000千人并发同时抢夺，并讲解会出现超发和保证如何数据一致性问题，在高并发场景下还需要保证性能的问题。 在这里，首先查看红包库存，是否有，如果有，则更新库存减一，然后插入一条记录到抢红包信息表中，这3个操作作为一个事务，原子性来操...
怎么解决高并发下抢红包和商品超卖问题?
Dream_it_possible！的博客
03-15 1840
一、场景模拟 在抢红包或秒杀商品的时候，肯定会有高并发的情况出现，程序中如果出现库存重复减扣的情况，那肯定是不行的！接下来模拟一下高并发下的库存重复减扣问题以及相应的解决方案。 在测试前，需要预先给redis设置一个key用来作为库存。 @GetMapping("/redis/stuck") public String getRedisStuck()...
小程序口令红包源码、微信语音口令红包、全套完整版源码.rar
07-11
小程序口令红包源码、微信语音口令红包、全套完整版源码、PHP语言开发、带有详细安装教程。 语音口令红包小程序源码/前端+后台PHP/开源/支持二次开发，ThinkPHP3.2新版推荐微信语音 小程序口令红包,发红包的同时还...
嵌入式系统/ARM技术中的基于嵌入式系统的语音口令识别系统的实现
11-05
【嵌入式系统/ARM技术中的基于嵌入式系统的语音口令识别系统的实现】 嵌入式系统在现代科技发展中扮演着重要角色，特别是在人机交互领域。语音口令识别是一种利用计算机技术理解并响应人类语音指令的技术，它使得...
PHP微信语音口令红包小程序源码文档齐全
03-12
语音口令红包小程序源码/前端+后台PHP/开源/支持二次开发，Thinkphp3.2新版推荐微信语音小程序口令红包，发红包的同时还可以带上自己的广告，带详细安装说明和小程序配置文档。 二、注意事项 开发语言：PHP，...
java动态口令登录实现过程详解
08-25
Java 动态口令登录实现过程详解 Java 动态口令登录实现过程是指通过 Java 语言实现动态口令登录的过程。动态口令登录是一种安全的身份验证方式，通过生成一个动态的口令来验证用户的身份。在这个过程中，客户端需要...
基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发
06-14
基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测试，确保可以运行！ 基于springboot+mybatis redis构建的在线抽奖系统，管理后台，采用队列处理，支持高并发 项目经过严格测
基于Windows CE的语音口令识别系统的设计
08-20
本文探讨了基于Windows CE的语音口令识别系统的设计，该系统是嵌入式技术在专用设备上的典型应用。随着微电子技术的飞速发展，嵌入式系统在资源受限、成本敏感、实时性要求高的设备中扮演着重要角色。语音口令识别...
高并发系统设计 -- 抢红包设计
qq_61039408的博客
01-02 1841
可以明显的看到打开了红包不一定可以抢到。预拆包：我在发红包的时候，就已经把所有的东西都计算好了放在redis里面了。实时计算：在抢红包的时候进行现场计算。我选择的时把红包提前拆好，虽然提前拆好需要占用Redis的一些存储，但是这样可以让抢红包的速度到达最快。
基于Redis实现微信抢红包功能
qq_42889658的博客
02-16 1140
基于Redis实现微信抢红包功能
基于SpringBoot2 + Redis + MySQL实现一个抢红包系统（至尊典藏版）
热门推荐
人生若只初相见@的博客
07-21 1万+
如何实现一个抢红包的程序
SpringBoot编写一个抢红包的程序
最新发布
琼楼玉宇
08-31 142
Conster。
Springboot入门经典项目——红包项目
无名之辈，我是谁
10-11 294
一.新建一个Springboot项目 IDEA新建 项目结构 pom.xml文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" x...
【分布式】红包秒杀系统、高并发安全分布式锁
a23452的博客
09-13 2393
红包系统作为一个非常广泛的服务，可以切实提高网站的收益，吸引流量，这里Cfeng将分享如何设计一款抢红包系统 本文会从最开始的业务流程、业务流程分析、到数据库表和 红包分发算法、 JMeter高并发测试、高并发状态下使用分布式锁进行优化
【后端笔记】如何设计高并发商品秒杀、抢红包场景
xwmisc的博客
01-01 455
这两种场景通常表现为：由于数量有限，所有用户在同一时间读取和写入相关数据。例如，对于某些热门产品，比如抢购口罩，由于口罩数量有限，会有大量用户同时抢购，从而造成瞬时流量巨大。在高并发场景中，要尽量拦截请求，从前端和网关层进行限流。对写请求做串行化能减少很多问题。系统稳定性：前端页面层，网关层，服务层都要进行限流，尽量拦截请求。使用缓存减轻数据库压力，但要注意缓存击穿，可以使用写请求直接写缓存的方式。数据准确性：使用队列限制写请求数量，数据库用并发写锁，或者直接串行化解决超卖。写数据库后回写缓存解决
java怎么实现某数据库字段选择输入
07-09
在Java中，你可以使用控制台输入来实现数据库选择输入。以下是一个简单的示代码： ```java import java.util.Scanner; public class DatabaseFieldSelection { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请选择数据库字段："); System.out.println("1. 姓名"); System.out.println("2. 电话号码"); System.out.println("3. 电子邮件"); int choice = scanner.nextInt(); switch (choice) { case 1: System.out.println("您选择了姓名字段"); // TODO: 执行对应的数据库操作 break; case 2: System.out.println("您选择了电话号码字段"); // TODO: 执行对应的数据库操作 break; case 3: System.out.println("您选择了电子邮件字段"); // TODO: 执行对应的数据库操作 break; default: System.out.println("无效的选择"); break; } scanner.close(); } } ``` 在上述示例中，我们使用`Scanner`类来读取用户的输入。用户可以通过输入数字选择不同的数据库字段。根据用户的选择，可以执行相应的数据库操作。你可以根据实际需求修改代码来适应你的数据库和具体业务逻辑。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘明同学呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值