[项目总结] 抽奖系统项目技术应用总结

🌸个人主页:https://blog.csdn.net/2301_80050796?spm=1000.2115.3001.5343
🏵️热门专栏:
🧊 Java基本语法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12615970.html?spm=1001.2014.3001.5482
🍕 Collection与数据结构 (93平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm=1001.2014.3001.5482
🧀线程与网络(97平均质量分) https://blog.csdn.net/2301_80050796/category_12643370.html?spm=1001.2014.3001.5482
🍭MySql数据库(95平均质量分)https://blog.csdn.net/2301_80050796/category_12629890.html?spm=1001.2014.3001.5482
🍬算法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12676091.html?spm=1001.2014.3001.5482
🍃 Spring(97平均质量分)https://blog.csdn.net/2301_80050796/category_12724152.html?spm=1001.2014.3001.5482
🎃Redis(97平均质量分)https://blog.csdn.net/2301_80050796/category_12777129.html?spm=1001.2014.3001.5482
🐰RabbitMQ(97平均质量分) https://blog.csdn.net/2301_80050796/category_12792900.html?spm=1001.2014.3001.5482
感谢点赞与关注~~~

1. Redis的使用

在向用户发送验证码之后,我们需要把验证码存储到Redis中,方便后面校验

//校验手机号
if (!StringUtils.hasText(phoneNumber) || !RegexUtil.checkMobile(phoneNumber)){throw new ServiceException(ServiceErrorCodeConstants.PHONE_NUMBER_ERROR);
}
String captcha = CaptchaUtil.generateCaptchaCode(4);//生成4位验证码
Map<String,String> map = new HashMap<>();
map.put("code",captcha);//把验证码设置进Map中,再转换为json字符串,之后就会替换掉模版中的对应参数.
smsUtil.sendMessage(VERIFICATION_TEMPLATE_CODE,phoneNumber,objectMapper.writeValueAsString(map));
redisUtil.set(VERIFICATION_PREFIX + phoneNumber,captcha,300L);//把验证码放入redis中

把活动详细信息存储到Redis中.如果ActivityId和原来一致,就会把原来的信息覆盖掉.

//整合活动整体信息,存储在redis中.
//首先获取活动中对应的奖品信息
List<Long> prizeIdList = new ArrayList<>();
for (ActivityPrizeDO activityPrizeDO :activityPrizeDOList) {prizeIdList.add(activityPrizeDO.getPrizeId());
}
List<PrizeDO> prizeDOList = prizeMapper.selectByIdList(prizeIdList);
//把信息整合为存储在Redis中的活动详细信息
ActivityDetailDTO activityDetailDTO = convertToActivityDetailDTO(activityDO,prizeDOList,activityPrizeDOList,activityUserDOList
);
//缓存活动信息
cacheActivity(activityDetailDTO);

之所以要把活动信息缓存到Redis中,有一下的几点:
1. 首先是因为由于活动信息涉及到三张表的相关操作,如果后期再查询活动数据的时候,直接在MySQL中查询,需要查询三张表的数据,那么就会很慢,给用户带来不好的体验,所以要把活动信息提前存储到Redis中.
2. 其次是因为,活动信息是系统的核心数据,访问频率较高,使用Redis可以轻松应对高QPS的场景.

从Redis中获取活动详细信息,如果Redis中没有查询到,再去MySQL中查询,之后将MySQL中查询到的数据同步到Redis中.

@Overridepublic ActivityDetailDTO getActivityDetail(Long activityId) throws JsonProcessingException {if (activityId == null){log.warn("活动id为空");return null;}//首先从缓存中获取信息ActivityDetailDTO activityDetail = getActivityFromCache(activityId);if (activityDetail != null){return activityDetail;}//缓存中没有查询到的时候,去数据库中查ActivityDO activityDO = activityMapper.selectById(activityId);List<ActivityPrizeDO> activityPrizeDOList = activityPrizeMapper.selectByActivityId(activityId);List<ActivityUserDO> activityUserDOList = activityUserMapper.selectByActivityId(activityId);List<Long> prizeId = new ArrayList<>();for (ActivityPrizeDO prizeDO : activityPrizeDOList) {prizeId.add(prizeDO.getPrizeId());}List<PrizeDO> prizeDOList = prizeMapper.selectByIdList(prizeId);activityDetail = convertToActivityDetailDTO(activityDO,prizeDOList,activityPrizeDOList,activityUserDOList);cacheActivity(activityDetail);//缓存活动信息return activityDetail;}

其中下面这几行代码就是在查询三张表的数据,这个过程非常慢,所以我们前期就需要把信息缓存到Redis中.

ActivityDO activityDO = activityMapper.selectById(activityId);
List<ActivityPrizeDO> activityPrizeDOList = activityPrizeMapper.selectByActivityId(activityId);
List<ActivityUserDO> activityUserDOList = activityUserMapper.selectByActivityId(activityId);

抽奖操作完成之后,需要对之前存储的Redis中的详细信息进行更新,把活动的状态,活动奖品的状态和活动用户的状态进行翻转.

if (update){//扭转之后,更新活动相关的信息到缓存中activityService.cacheActivity(activityStatusConvertDTO.getActivityId());
}

抽奖过程中发生异常的时候,把Redis中的记录删除掉.

drawPrizeService.deleteRecords(drawPrizeParam.getActivityId(),drawPrizeParam.getPrizeId());

2. RabbitMQ的使用

由于抽奖的业务逻辑比较复杂,所以我们选择使用RabbitMQ把抽奖请求和抽奖的主业务逻辑做了异步处理,当用户发起抽奖请求之后,前端就可以立即返回结果,后台消费者独立处理业务请求,系统响应时间从秒级降到毫秒级,大大提升了用户的体验.
其次由于抽奖逻辑是系统的主逻辑,有可能有很大的QPS,所以我们可以使用RabbitMQ对请求进行削峰处理,以免系统被压垮.

下面是给队列中发送请求的过程.

@Override
public void drawPrize(DrawPrizeParam param) throws JsonProcessingException {String messageId = UUID.randomUUID().toString();String messageData = objectMapper.writeValueAsString(param);String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));//格式化时间Map<String,String> map = new HashMap<>();map.put("messageId",messageId);map.put("createTime",createTime);map.put("messageData",messageData);//添加中奖信息rabbitTemplate.convertAndSend(EXCHANGE_NAME,ROUTING,map);log.info("mq发送成功");
}

消费者从消息队列中收到消息

@RabbitHandler
public void process(Map<String,String> message) throws JsonProcessingException {log.info("接收到生产者消息:{}",message.toString());String messageData = message.get("messageData");//从map中获取到中奖信息DrawPrizeParam drawPrizeParam = objectMapper.readValue(messageData, DrawPrizeParam.class);//将指定的字符串转化为指定类的对象try {//这里之所以使用Boolean作为返回值,是为了用户重复发送抽奖信息,如果采用抛出异常的方式的话,// 在第二次发送之后,就会触发回滚操作,这时候又会把奖品和用户状态全部回滚回来,显然不符合逻辑if (!drawPrizeService.checkDrawPrizeValid(drawPrizeParam)){//对参数进行校验,如果校验不成功,直接返回return;}convertStatus(drawPrizeParam);//翻转状态List<WinningRecordDO> winningRecordDOList = drawPrizeService.saveWinningRecords(drawPrizeParam);//存储获奖者信息syncExecute(winningRecordDOList);//拿到中奖记录之后,去发邮件和短信} catch (ServiceException e){log.error("处理mq消息异常:{},{},{}",e.getCode(),e.getCode(),e.getMessage());rollback(drawPrizeParam);//异常之后需要把数据回滚掉throw e;}catch (Exception e){log.error("处理mq消息异常:{}",e.getMessage());rollback(drawPrizeParam);//异常之后需要把数据回滚掉throw e;}
}

注意: 对抽奖的参数进行校验的时候,我们不可以使用抛出异常的方式,我们应该使用直接返回的方式.如果我们直接抛出异常,会使得异常被捕捉,这样会引起活动的奖品状态和活动的用户状态发生回滚,不符合我们预期的业务逻辑.

3. 抽奖业务逻辑详细梳理

首先就是前端发起抽奖请求,之后把请求发送到消息队列,之后消费者接收到消息,就是我们上面RabbitMQ的逻辑,这里不再多余赘述.
从消息队列里接收到消息之后,对消息队列中的JSON字符串格式的消息转化为对应的对象

DrawPrizeParam drawPrizeParam = objectMapper.readValue(messageData, DrawPrizeParam.class);//将指定的字符串转化为指定类的对象

之后对获取到的抽奖参数进行校验,注意这里我们使用直接返回的方式来表示没有通过校验(原因见上),checkDrawPrizeValid方法也是直接使用返回false的方式,没有使用抛出异常的方式.

if (!drawPrizeService.checkDrawPrizeValid(drawPrizeParam)){//对参数进行校验,如果校验不成功,直接返回return;
}

@Override
public Boolean checkDrawPrizeValid(DrawPrizeParam param) {//校验奖品和活动是否存在ActivityDO activityDO = activityMapper.selectById(param.getActivityId());ActivityPrizeDO activityPrizeDO =activityPrizeMapper.selectByActivityAndPrizeId(param.getActivityId(),param.getPrizeId());if (activityDO == null || activityPrizeDO == null){return false;}//判断奖品是否足够if (param.getWinnerList().size() > activityPrizeDO.getPrizeAmount()){return false;}//判断活动或者奖品是否有效if (activityDO.getStatus().equals(ActivityStatusEnum.COMPLETED.name())){return false;}if (activityPrizeDO.getStatus().equals(ActivityPrizeStatusEnum.COMPLETED.name())){return false;}return true;
}

之后对关联表中的活动奖品状态和活动用户状态进行翻转.

convertStatus(drawPrizeParam);//翻转状态

首先构造状态翻转参数,构造活动奖品的状态和活动用户的状态全部为已完成,之后调用活动状态管理器中的handlerEvent方法,对活动相关的信息进行状态翻转.

/*** 扭转活动相关信息的状态* @param drawPrizeParam 活动相关信息*/
private void convertStatus(DrawPrizeParam drawPrizeParam) throws JsonProcessingException {//构造状态翻转参数,将活动状态和奖品状态都翻转成已完成ActivityStatusConvertDTO statusConvertDTO = new ActivityStatusConvertDTO();statusConvertDTO.setActivityId(drawPrizeParam.getActivityId());statusConvertDTO.setPrizeId(drawPrizeParam.getPrizeId());statusConvertDTO.setActivityTargetStatus(ActivityStatusEnum.COMPLETED);statusConvertDTO.setPrizeTargetStatus(ActivityPrizeStatusEnum.COMPLETED);List<Long> winnerIdList = new ArrayList<>();for (DrawPrizeParam.Winner winner : drawPrizeParam.getWinnerList()) {winnerIdList.add(winner.getUserId());}statusConvertDTO.setUserIds(winnerIdList);statusConvertDTO.setUserTargetStatus(ActivityUserStatusEnum.COMPLETED);//使用活动状态管理器进行状态翻转activityStatusManager.handlerEvent(statusConvertDTO);
}

首先这里我们使用到了@Transactional注解,如果翻转状态的中间发生了异常,也就是调用processStatusConversion方法的时候抛出了ServiceException(ServiceErrorCodeConstants.CONVERT_ACTIVITY_STATUS_ERROR);异常,那么就会进行事务回滚,之前翻转的奖品,用户的状态全部回滚.使用processStatusConversion方法对用户状态和活动状态进行翻转.这里采用了责任链模式和策略模式,我们放到后面细说.扭转完成奖品,活动,用户状态之后,把活动的详细信息更新到Redis中.

/*** 转换状态* @param activityStatusConvertDTO 状态转换参数*/
@Override
@Transactional(rollbackFor = Exception.class)
public void handlerEvent(ActivityStatusConvertDTO activityStatusConvertDTO) throws JsonProcessingException {if (operatorMap == null || operatorMap.isEmpty()){log.warn("AbstractActivityOperatorMap 为空");return;}//扭转活动状态Boolean update = false;//先扭转奖品和用户的状态Map<String, AbstractActivityOperator> currMap = new HashMap<>(operatorMap);update = processStatusConversion(activityStatusConvertDTO,currMap,1);//奖品和用户状态都扭转完成之后,后扭转奖品的状态update = processStatusConversion(activityStatusConvertDTO,currMap,2) || update;if (update){//扭转之后,更新活动相关的信息到缓存中activityService.cacheActivity(activityStatusConvertDTO.getActivityId());}
}

在扭转用户和奖品状态的时候,我们使用的是责任链模式和策略模式,我们使用的是Map来管理责任链.通过@Autowired注入Map中的是Bean的名称和抽象类的子类的具体实现.

@Autowired
private Map<String, AbstractActivityOperator> operatorMap;//注入抽象类对应继承的子类

我们首先定义了一个抽象类(抽象操作器),确定针对活动,奖品,用户的状态如何进行翻转,即采用什么样的策略进行翻转.采用的具体策略是:确定转换的次序,用户,活动,奖品的状态,先转换哪一个,后转换那一个,用一个整形表示.之后查看当前的状态是否需要翻转,主要是查询数据库中的状态和传入的状态是否一致,如果一致,就不需要翻转.最后翻转状态.

/*** 转换抽奖活动相关参数的状态* 使用策略模式*/
public abstract class AbstractActivityOperator {public abstract Integer sequence();//转换的次序.使用责任链模式public abstract Boolean needConvert(ActivityStatusConvertDTO statusConvertDTO);//是否需要转换状态public abstract Boolean convertStatus(ActivityStatusConvertDTO statusConvertDTO);//转换状态
}

针对这个抽象类有三个子类继承与实现,分别是活动的操作器,奖品操作器,用户操作器,首先是奖品操作和用户操作,首先实现的是责任链顺序,他们在public Integer sequence()中返回的是1,是责任链的第一层,实现的第二个方法是查看状态是否需要翻转,首先保证状态翻转参数正确,如果不正确,返回false,之后从数据库中查询相关活动奖品/用户的数据,如果不存在,返回false,最后查看传入的参数中的状态和数据库中的状态是否一致,如果一致,则不需要翻转,返回false,走到最后,说明需要翻转,返回true.实现的第三个方法就是翻转数据库中的状态.

/*** 转换奖品状态*/
@Component
public class PrizeOperator extends AbstractActivityOperator{@Autowiredprivate ActivityPrizeMapper activityPrizeMapper;@Overridepublic Integer sequence() {return 1;}@Overridepublic Boolean needConvert(ActivityStatusConvertDTO statusConvertDTO) {if (statusConvertDTO.getPrizeId() == null ||statusConvertDTO.getActivityTargetStatus() == null){//如果状态转换种不存在相关参数,直接返回falsereturn false;}//从数据库中查询活动奖品ActivityPrizeDO activityPrizeDO = activityPrizeMapper.selectByActivityAndPrizeId(statusConvertDTO.getActivityId(),statusConvertDTO.getPrizeId());//如果没有查询到,返回falseif (activityPrizeDO == null){return false;}//和查询出的数据的状态比较,状态和传入的"完成"状态一致的时候不许要反转if (activityPrizeDO.getStatus().equals(statusConvertDTO.getPrizeTargetStatus().name())){return false;}return true;}@Overridepublic Boolean convertStatus(ActivityStatusConvertDTO statusConvertDTO) {activityPrizeMapper.updateStatus(statusConvertDTO.getActivityId(),statusConvertDTO.getPrizeId(),statusConvertDTO.getActivityTargetStatus().name());return true;}
}

/*** 转换人员状态*/
@Component
public class UserOperator extends AbstractActivityOperator{@Autowiredprivate ActivityUserMapper activityUserMapper;@Overridepublic Integer sequence() {return 1;}@Overridepublic Boolean needConvert(ActivityStatusConvertDTO statusConvertDTO) {if (statusConvertDTO.getUserIds() == null ||statusConvertDTO.getActivityId() == null ||statusConvertDTO.getUserIds().isEmpty()){return false;}Long activityId = statusConvertDTO.getActivityId();//从mapper层查询用户信息for (Long userId :statusConvertDTO.getUserIds()) {ActivityUserDO activityUserDO = activityUserMapper.selectUserById(userId,activityId);if (activityUserDO == null){//没有查询到活动对应的用户return false;}//查询状态是否和传入的"完成一致if (activityUserDO.getStatus().equals(statusConvertDTO.getUserTargetStatus().name())){return false;}}return true;}@Overridepublic Boolean convertStatus(ActivityStatusConvertDTO statusConvertDTO) {Long activityId = statusConvertDTO.getActivityId();for (Long userId : statusConvertDTO.getUserIds()) {activityUserMapper.batchUpdateStatus(statusConvertDTO.getUserTargetStatus().name(),activityId,userId);}return true;}
}

之后是活动操作器,实现的第一个方法还是处于责任链中的位置,sequence()方法返回的是2,处于责任链中的第二个位置.之后是实现的第二个方法,首先对参数进行校验,如果校验不通过,返回false,之后查看数据库中的状态和传入的状态是否一致,如果一致,就不需要翻转,返回false,之后校验和活动相关的奖品是否全部抽取完成,如果还有奖品没有抽取完成,证明活动还为结束,返回false,如果以上校验全部通过,返回true,证明活动已经结束,可以翻转.第三个方法和上面的一样,翻转活动状态.

@Component
public class ActivityOperator extends AbstractActivityOperator{@Autowiredprivate ActivityMapper activityMapper;@Autowiredprivate ActivityPrizeMapper activityPrizeMapper;@Overridepublic Integer sequence() {return 2;}@Overridepublic Boolean needConvert(ActivityStatusConvertDTO statusConvertDTO) {//判断后续需要校验的参数是否为空if (statusConvertDTO.getActivityId() == null ||statusConvertDTO.getActivityTargetStatus() == null){return false;}//校验活动状态是否和数据库中的一致,如果一致就是翻转过的String activityStatus =activityMapper.selectById(statusConvertDTO.getActivityId()).getStatus();if (activityStatus.equals(statusConvertDTO.getActivityTargetStatus().name())){return false;}//校验活动奖品是否均抽取完成int count = activityPrizeMapper.countRunningPrizeByActivityId(statusConvertDTO.getActivityId(),ActivityPrizeStatusEnum.INIT.name());if (count > 0){return false;}return true;}@Overridepublic Boolean convertStatus(ActivityStatusConvertDTO statusConvertDTO) {activityMapper.convert(statusConvertDTO.getActivityId(),statusConvertDTO.getActivityTargetStatus().name());return true;}
}

我们使用processStatusConversion方法来对活动,用户以及奖品的相关信息来进行翻转.首先是对奖品和用户状态的扭转,传入的责任链顺序是1,之后就是对活动状态的扭转,传入的责任链顺序是2.

//先扭转奖品和用户的状态
Map<String, AbstractActivityOperator> currMap = new HashMap<>(operatorMap);
update = processStatusConversion(activityStatusConvertDTO,currMap,1);
//奖品和用户状态都扭转完成之后,后扭转奖品的状态
update = processStatusConversion(activityStatusConvertDTO,currMap,2) || update;

首先把Map转换为可迭代的Iterator,对Iterator进行遍历,知道遇到Map中的sequence和传入参数一致的sequence,证明找到了Map中想要执行的责任链,即operator.sequence() != sequence逻辑,之后判断状态是否需要翻转,即!operator.needConvert(convertActivityStatusDTO)逻辑,只要这连个条件有一个满足,就直接跳过Map中的当前执行器(Operator)的Bean.如果不满足,就证明找到了需要转换状态的实体,调用convertStatus进行状态转换.

private Boolean processStatusConversion(ActivityStatusConvertDTO convertActivityStatusDTO,Map<String, AbstractActivityOperator> currMap,int sequence) {Boolean update = false;// 遍历currMapIterator<Map.Entry<String, AbstractActivityOperator>> iterator = currMap.entrySet().iterator();while (iterator.hasNext()) {AbstractActivityOperator operator = iterator.next().getValue();// Operator 是否需要转换if (operator.sequence() != sequence|| !operator.needConvert(convertActivityStatusDTO)) {continue;}// 需要转换：转换if (!operator.convertStatus(convertActivityStatusDTO)) {log.error("{}状态转换失败！", operator.getClass().getName());throw new ServiceException(ServiceErrorCodeConstants.CONVERT_ACTIVITY_STATUS_ERROR);}// currMap 删除当前 Operatoriterator.remove();update = true;}// 返回return update;
}

翻转状态之后,需要把中奖人的名单保存进入数据库中,数据中保存的数据包括活动,奖品,人员三方面的信息,具体见WinningRecordDO.

List<WinningRecordDO> winningRecordDOList = drawPrizeService.saveWinningRecords(drawPrizeParam);//存储获奖者信息

/*** 中奖记录DO*/
@Data
public class WinningRecordDO extends BaseDO{private Long activityId;//活动idprivate String activityName;//活动名称private Long prizeId;//奖品idprivate String prizeName;//奖品名称private String prizeTier;//奖品等级private Long winnerId;//获奖者idprivate String winnerName;//获奖者名称private String winnerEmail;//获奖者邮箱private Encrypt winnerPhoneNumber;//获奖者手机号码private Date winningTime;//获奖时间
}

saveWinningRecords方法返回中奖记录之后,拿到用户的手机号和邮箱,使用阿里云的短信服务和邮箱服务,为指定的用户发送中奖记录.

/*** 抽奖之后进行邮件和短信的发送* @param winningRecordDOList 获奖记录*/
public void syncExecute(List<WinningRecordDO> winningRecordDOList){//利用并发给中奖者发信息asyncServiceExecutor.execute(() -> sendMessage(winningRecordDOList));asyncServiceExecutor.execute(() -> sendMail(winningRecordDOList));
}

如果在消费者收到消息的过程中发生了异常,则异常会被捕捉,最后把活动相关的数据全部回滚掉

} catch (ServiceException e){log.error("处理mq消息异常:{},{},{}",e.getCode(),e.getCode(),e.getMessage());rollback(drawPrizeParam);//异常之后需要把数据回滚掉throw e;
}catch (Exception e){log.error("处理mq消息异常:{}",e.getMessage());rollback(drawPrizeParam);//异常之后需要把数据回滚掉throw e;
}

还是和之前的状态翻转的流程一样,首先构造回滚参数,之后调用活动状态管理器中的rollback方法进行回滚.只不过就是把之前的convertStatus方法中的完成状态改为初始化状态,把之前handlerEvent方法中的Redis更新变为删除.这里需要注意的是,在回滚之前,需要先判断数据是否有真的落库,如果没有落库,就不需要回滚,直接返回.

/*** 回滚活动相关信息的状态* @param drawPrizeParam 抽奖参数*/
private void rollback(DrawPrizeParam drawPrizeParam) throws JsonProcessingException {if (!convertStatusSuccess(drawPrizeParam)){//没有翻转成功,直接返回return;}//构建状态翻转参数,回滚回原来的状态ActivityStatusConvertDTO statusConvertDTO = new ActivityStatusConvertDTO();statusConvertDTO.setActivityId(drawPrizeParam.getActivityId());statusConvertDTO.setPrizeId(drawPrizeParam.getPrizeId());for (DrawPrizeParam.Winner winner :drawPrizeParam.getWinnerList()) {List<Long> userIds = new ArrayList<>();userIds.add(winner.getUserId());statusConvertDTO.setUserIds(userIds);}statusConvertDTO.setActivityTargetStatus(ActivityStatusEnum.RUNNING);statusConvertDTO.setPrizeTargetStatus(ActivityPrizeStatusEnum.INIT);statusConvertDTO.setUserTargetStatus(ActivityUserStatusEnum.INIT);activityStatusManager.rollback(statusConvertDTO);//回滚数据//回滚之后判断中奖记录是否已经落库if (!hasRecords(drawPrizeParam)){return;//如果没有落库,直接返回}//如果落库,删除其中的数据,包括缓存和数据库中的数据drawPrizeService.deleteRecords(drawPrizeParam.getActivityId(),drawPrizeParam.getPrizeId());
}

针对数据的状态进行回滚的时候,我们可以对上面的状态翻转接口进行复用,即operator.convertStatus(convertDTO);,因为他们本质上都是对状态进行翻转,只不过一个是翻转到完成状态,一个是翻转到初始化状态.

@Override
public void rollback(ActivityStatusConvertDTO convertDTO) throws JsonProcessingException {if (convertDTO == null){log.warn("无需回滚状态");return;}Collection<AbstractActivityOperator> values = operatorMap.values();//获取所有需要回滚的类for (AbstractActivityOperator operator : values) {//回滚全部类的状态operator.convertStatus(convertDTO);}//回滚缓存中的数据activityService.cacheActivity(convertDTO.getActivityId());
}

4. 阿里云短信服务与邮件服务

4.1 中奖通知服务

在活动结束,即抽奖完成之后,我们使用线程池的方式,去同时为用户的手机和邮箱发送中奖通知.

/*** 抽奖之后进行邮件和短信的发送* @param winningRecordDOList 获奖记录*/
public void syncExecute(List<WinningRecordDO> winningRecordDOList){//利用并发给中奖者发信息asyncServiceExecutor.execute(() -> sendMessage(winningRecordDOList));//todoasyncServiceExecutor.execute(() -> sendMail(winningRecordDOList));
}

在为用户发送短信的时候,首先针对List<WinningRecordDO>中的每一条记录进行遍历,拿到其中的相关信息放入templateParam中,以便后面对短信模版中的相关参数进行替换,在使用smsUtil.sendMessage调用阿里云短信服务的时候,传入的参数包括短信模版id,获奖者手机号,替换短信模版的参数的JSON字符串.

/*** 发送短信给中奖者* @param winningRecordDOList 中奖记录*/
private void sendMessage(List<WinningRecordDO> winningRecordDOList){//对参数进行校验if (winningRecordDOList == null || winningRecordDOList.isEmpty()){log.warn("中奖名单为空！");return;}winningRecordDOList.forEach(record -> {Map<String, String> templateParam = new HashMap<>();templateParam.put("name", record.getWinnerName());templateParam.put("activityName", record.getActivityName());templateParam.put("prizeTiers", ActivityPrizeTiersEnum.checkForName(record.getPrizeTier()).getMessage());templateParam.put("prizeName", record.getPrizeName());templateParam.put("winningTime",DateUtil.formatTime(record.getWinningTime()));try {smsUtil.sendMessage(WINNING_TEMPLATE_CODE,record.getWinnerPhoneNumber().getValue(),objectMapper.writeValueAsString(templateParam));} catch (JsonProcessingException e) {throw new RuntimeException(e);}});
}

之后就是发邮件,在调用mailUtil.sendSampleMail阿里云发送邮件的接口的时候,需要传入的参数为获奖者的邮件,和提前构造好的邮件内容.

/*** 给中奖者发送邮件* @param recordDOList 中奖记录*/private void sendMail(List<WinningRecordDO> recordDOList) {if(CollectionUtils.isEmpty(recordDOList)) {log.warn("中奖名单为空！");return;}for (WinningRecordDO winningRecordDO : recordDOList) {// Hi,xxx。恭喜你在抽奖活动活动中获得二等奖:吹风机。获奖奖时间为18:18:44,请尽快领取您的奖励String context = "Hi，" + winningRecordDO.getWinnerName() + "。恭喜你在"+ winningRecordDO.getActivityName() + "活动中获得"+ ActivityPrizeTiersEnum.checkForName(winningRecordDO.getPrizeTier()).getMessage()+ "：" + winningRecordDO.getPrizeName() + "。获奖时间为"+ DateUtil.formatTime(winningRecordDO.getWinningTime()) + "，请尽快领 取您的奖励！";mailUtil.sendSampleMail(winningRecordDO.getWinnerEmail(),"中奖通知", context);}}

4.2 短信验证码服务

和上面的道理一样,为短信服务传入的参数还是短信的模版id,用户的手机号,还有填充短信模版中参数的JSON字符串.

@Override
public void sendVerificationCode(String phoneNumber) throws JsonProcessingException {//校验手机号if (!StringUtils.hasText(phoneNumber) || !RegexUtil.checkMobile(phoneNumber)){throw new ServiceException(ServiceErrorCodeConstants.PHONE_NUMBER_ERROR);}String captcha = CaptchaUtil.generateCaptchaCode(4);//生成4位验证码Map<String,String> map = new HashMap<>();map.put("code",captcha);//把验证码设置进Map中,再转换为json字符串,之后就会替换掉模版中的对应参数.smsUtil.sendMessage(VERIFICATION_TEMPLATE_CODE,phoneNumber,objectMapper.writeValueAsString(map));redisUtil.set(VERIFICATION_PREFIX + phoneNumber,captcha,300L);//把验证码放入redis中
}

5. 数据库表设计

其中包含三张基本表,三张联合表,基本表包含用户,活动,奖品,联合表包含用户活动联合表,主要用于记录一个用户在一个活动中的状态,所以有status字段.还有奖品活动联合表,主要用于记录奖品在当前活动中的数量,奖品在当前活动中属于几等奖,还有奖品的状态.还有中奖记录表,主要用于记录那个用户,在那个活动中,中了什么奖.
在这里插入图片描述