Spring项目-抽奖系统(实操项目-用户管理接口)(THREE)

  ^__^
 (oo)\______

 (__)\      )\/\
     ||----w |
     ||     ||  

一、：前言：

        登录接口博客链接：Spring项目-抽奖系统(实操项目-登录接口)(TWO)-CSDN博客

        写完注册和登录接口后，接下来就做抽奖奖品、抽奖活动相应的创建展示过程。

        UI页面如下：
        

接下俩将一一完成下列这些接口。

二：用户管理：

2.1：人员列表展示：

        我们在参与抽奖的人员列表中，必须能够做到展示所有抽奖人员，时序图如下：

2.1.1：Controller层：

        该层需要注意：
        1.参数identity(表示具体要展示什么身份)，当不传时，依旧可以访问，只要JWT令牌通过！！

        2.当传入参数时，需要判断传入的身份是否在预知范围内，用UserIdentityEnum进行简单判断

@RequestMapping("/base-user/find-list")
    public CommonResult<List<UserBaseInfoResult>> findUserBaseInfoList(String identity) {
        log.info("findUserBaseInfoList FindUsersParam:{}",identity);
        List<UserDTO> userDTOList = null;
        if(!StringUtils.hasText(identity)) {
            userDTOList = userService.findUserList(null);
        }else if(UserIdentityEnum.forname(identity) != null) {
            userDTOList = userService.findUserList(identity);
        }
        return CommonResult.succcess(covertToFindUserListResult(userDTOList));
    }

    private List<UserBaseInfoResult> covertToFindUserListResult(List<UserDTO> userDTOList) {
            if(CollectionUtil.isEmpty(userDTOList)) {
                return Arrays.asList();
            }
            return userDTOList.stream().map(userDTO -> {
                UserBaseInfoResult userBaseInfoResult = new UserBaseInfoResult();
                userBaseInfoResult.setUserName(userDTO.getUserName());
                userBaseInfoResult.setIdentity(userDTO.getIdentity());
                userBaseInfoResult.setUserId(userDTO.getUserId());
                return userBaseInfoResult;
            }).collect(Collectors.toList());
    }

2.1.2：Service层：

    
@Service
public interface UserService {
    
    /**
    * 查找用户列表
    * 
    */
    List<UserDTO> findUserList(String identity);
}

ServiceImpl层： 

    @Override
    public List<UserDTO> findUserList(String identity) {
      /*  if(param == null) {
            throw new ServiceException(ServiceErrorCodeConstatns.IDENTITY_ERROR);
        }*/
        List<UserDO> userDOList = userMapper.selectUserListByIdentity(identity);
        return userDOList.stream().map(userDO -> {
            UserDTO userDTO = new UserDTO();
            userDTO.setUserId(userDO.getId());
            userDTO.setUserName(userDO.getUserName());
            userDTO.setIdentity(userDO.getIdentity());
            userDTO.setEmail(userDO.getEmail());
            userDTO.setPhoneNumber(userDO.getPhoneNumber().getPhoneNumber());
            return userDTO;
        }).collect(Collectors.toList());
    }

2.1.3：Dao层：

        由于identity不是必传项，因此此次需要用到动态sql，选用mybaits的xml形式实现动态sql：

        具体的实现方法如下：

步骤一：

          设置配置项：

# 配置 mybatis xml 的⽂件路径，在 resources/mapper 创建所有表的 xml ⽂件
mybatis.mapper-locations=classpath:mapper/**Mapper.xml

步骤二：

        创建mapper文件与xxxMapper.xml文件;

步骤三：

填写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="com.example.lotterysystemplus.dao.mapper.UserMapper">
    <select id="selectUserListByIdentity"  resultType="com.example.lotterysystemplus.dao.dataobject.UserDO">
        select * from user
    <if test="identity != null">
        where identity = #{identity}
    </if>
        order by id desc
    </select>
</mapper>

步骤五：

        编写UserMapper包中的相关代码：

   List<UserDO> selectUserListByIdentity(@Param("identity") String identity);

三：奖品模块：

        写完人员管理模块之后，就开始写奖品模块，

奖品模块分为两个板块：

1.设置奖品模块

2.奖品展示模块

UI界面如下：

首先编写创建奖品模块：

3.1：创建奖品：

首先写保存图片相关接口：

         添加配置项：

## 图⽚服务 ##
pic.local-path=D:/PIC
# spring boot3 升级配置名
spring.web.resources.static-locations=classpath:/static/,file:${pic.local-path}

3.1.1：controller层：

    @RequestMapping("/pic/upload")
    public String upLodePic(MultipartFile file) {
        return pictureService.savePicture(file);
    }

3.1.2：Service层：

存放图片的服务是为了后期创建奖品时发挥作用！！
创建PictureService:

public interface PictureService {

    /**
     * 保存图片
     * @param pic
     * @return
     */
    String savePicture(MultipartFile pic);
}

3.1.3：创建PictureServiceImpl:        

@Service
public class PictureServiceImpl implements PictureService {

    /**
     * 设置图片存放路径
     */
    @Value("${pic.local-path}")
    private String picLocalPath;
    @Override
    public String savePicture(MultipartFile pic) {
        File dir = new File(picLocalPath);
        if(!dir.exists()) {
            dir.mkdirs();
        }

        //获取文件名
        String fileName = pic.getOriginalFilename();
        assert fileName != null;

        //获取文件后缀名
        String suffixName = fileName.substring(fileName.lastIndexOf("."));
        //生成随机数防止图片重名
        fileName = UUID.randomUUID()+suffixName;
        try {
            //设置图片路径
            pic.transferTo(new File(picLocalPath+"/"+fileName));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return fileName;
    }
}

3.2：创建奖品相关接口：

3.2.1：controller层:
        

    /**
     * RequestPart:用于接收表单数据 multipart/form-data
     * 创建奖品
     * @param param
     * @param picFile
     * @return
     */
    @RequestMapping("/prize/create")
    public CommonResult<Integer> createPrize(@RequestPart("param") @Valid CreatePrizeParam param,
                                          @RequestPart("prizePic") MultipartFile picFile) {
        log.info("createPrize CreatePrizeParam:{} MultipartFile:{}",
                JacksonUtil.writeValueAsString(param),picFile);
        return CommonResult.succcess(prizeService.createPrize(param,picFile));
    }

 注意：

        @RequestPart注解用于form-data格式的发送，但是对于文件的上传只有一个@RequestPart是远远不够的，还需要加一个序列化与发序列化的转化器：
        如果没有这个转换器，当我们在前端测试时，就会报此类错误:

        大概意思就是：

        前端给我们传过来的是数据类型是application/octet-stream，但是由于我们写了@RequestPart注解，希望接收到的是form-data表单格式数据，因此报错！！

        所以对于文件的传输前端传过来的默认是octet-stream格式，我们需要手动写一个转换器，代码如下：

/**
 * 实现二进制到对象的转换
 */
@Component
public class MultipartJackson2HttpMessageConverter extends AbstractJackson2HttpMessageConverter {
    protected MultipartJackson2HttpMessageConverter(ObjectMapper objectMapper)
    {
        // MediaType.APPLICATION_OCTET_STREAM 表⽰这个转换器⽤于处理⼆进制流数据，通常⽤于⽂件上传。
        super(objectMapper, MediaType.APPLICATION_OCTET_STREAM);
    }
    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return false;
    }
    @Override
    public boolean canWrite(Type type, Class<?> clazz, MediaType mediaType) {
        return false;
    }
    @Override
    protected boolean canWrite(MediaType mediaType) {
        return false;
    }
}

3.2.2：service层：

@Service
public interface PrizeService {
    Integer createPrize(CreatePrizeParam param, MultipartFile file);
}

3.2.3：serviceimpl层：

        service层的具体实现。

@Service
public class PrizeServiceImpl implements PrizeService {
    @Autowired
    private PrizeMapper prizeMapper;

    @Autowired
    private PictureService pictureService;
    @Override
    public Integer createPrize(CreatePrizeParam param, MultipartFile file) {
        String fileName = pictureService.savePicture(file);
        PrizeDO prizeDO = new PrizeDO();
        prizeDO.setName(param.getPrizeName());
        prizeDO.setDescription(param.getDescription());
        prizeDO.setPrice(param.getPrice());
        prizeDO.setImageUrl(fileName);
        prizeMapper.insert(prizeDO);
        return prizeDO.getId();
    }
}

3.3：展示奖品+翻页功能：

        将创建好的奖品进行展示，从数据库获取信息，发送给前端进行展示，并且带有翻页功能：

        翻页功能我们通过sql中的limit语句进行操作。需要传入两个参数：offset、pagesize完相应的功能。

3.3.1：controller层：   

    @RequestMapping("/prize/find-list")
    public CommonResult<PrizeFindListResult> prizeFindList(@Valid PageListParam param) {
        log.info("prizeFindList PageListParam:{}",
                JacksonUtil.writeValueAsString(param));
        PrizeListDTO<PrizeDTO> prizeDTOList = prizeService.findPrizeList(param);
        return CommonResult.succcess(convertToPrizeList(prizeDTOList));
    }

3.3.2：service层:

@Service
public interface PrizeService {
    Integer createPrize(CreatePrizeParam param, MultipartFile file);

    PrizeListDTO<PrizeDTO> findPrizeList(PageListParam param);
}

3.3.3：  serviceImpl层：

        service具体实现：

    @Override
    public PrizeListDTO<PrizeDTO> findPrizeList(PageListParam param) {
        int count = prizeMapper.count();
        List<PrizeDO> prizeDOList = prizeMapper.queryPrizeByPage(param.offset(), param.getPageSize());
        List<PrizeDTO> prizeDTOList = new ArrayList<>();
        for (PrizeDO prizeDO:prizeDOList) {
            PrizeDTO prizeDTO = new PrizeDTO();
            prizeDTO.setId(prizeDO.getId());
            prizeDTO.setName(prizeDO.getName());
            prizeDTO.setDescription(prizeDO.getDescription());
            prizeDTO.setPrice(prizeDO.getPrice());
            prizeDTO.setImageUrl(prizeDO.getImageUrl());
            prizeDTOList.add(prizeDTO);
        }
        return new PrizeListDTO<>(count,prizeDTOList);
    }

3.3.4：Dao层：

    @Select("select count(1) from prize")
    int count();
    @Select("select * from prize order by id desc limit #{offset} , #{pageSize}")
    List<PrizeDO> queryPrizeByPage(@Param("offset") Integer offset,
                                   @Param("pageSize") Integer pageSize);

四：活动模块：

        创建完奖品之后，接下俩就需要设置好活动内容，最后开始仅从抽奖：

4.1：创建活动：

        前后端约定：   

[ 请求 ] /activity/create POST

{

"activityName": " 抽奖测试 ",

"description": " 年会抽奖活动 ",

"activityPrizeList": [

{

"prizeId": 13,

"prizeAmount": 1,

"prizeTiers": "FIRST_PRIZE"

},

"prizeId": 12,

"prizeAmount": 1,

"prizeTiers": "SECOND_PRIZE"

}

],

"activityUserList": [

{

"userId": 25,

"userName": " 郭靖 "

},

{

"userId": 23,

"userName": " 杨康 "

}

]

}

[ 响应 ]

{

"code": 200,

"data": {

"activityId": 23

},

"msg": ""

}

4.1.1：controller层：

        有了前后端约定，就可以直接定义后端controller接口，接收类型、返回类型都表达的非常清楚：

public class ActivityController {
    private static final Logger logger = LoggerFactory.getLogger(ActivityController.class);
    @Resource
    private ActivityService createActivityService;

    /**
     * 创建活动
     * @param param
     * @return
     */
    @RequestMapping("/activity/create")
    public CommonResult<Long> createActivity(@Valid @RequestBody CreateActivityParam param) {
        logger.info("createActivity CreateActivityParam: " +
                JacksonUtil.writeValueAsString(param));
        CreateActivityDTO createActivit = createActivityService.createActivity(param);
        return CommonResult.succcess(createActivit.getActivityid());
    }
}

注：大家也可以根据自己的喜好可以对返回值在进行一层封装和判断！！

4.1.2： service层：

@Service
public interface ActivityService {
    public CreateActivityDTO createActivity(CreateActivityParam param);
}

serviceImpl：

        需要注意一个非常重要的一点：

        我们需要将创建好的数据放入redis缓存当中，提高后期抽奖后活动奖品展示的效率！！

        service层接口的具体实现：

 @Override
    public CreateActivityDTO createActivity(CreateActivityParam param) {
        //校验活动信息
        checkActivityInfo(param);
        //创建活动，并保存至数据库
        ActivityDO activityDO = new ActivityDO();
        activityDO.setActivityName(param.getActivityName());
        activityDO.setDescription(param.getDescription());
        activityDO.setStatus(ActivityStatusEnum.RUNNING.name());
        activityMapper.insert(activityDO);
        //关联奖品信息，并保存至数据库
        List<CreateActivityParam.CreatePrizeByActivityParam> createActivityParams = param.getActivityPrizeList();
        List<ActivityPrizeDO> activityPrizeDOList = new ArrayList<>();
        createActivityParams.forEach(item->{
            ActivityPrizeDO activityPrizeDO = new ActivityPrizeDO();
            activityPrizeDO.setActivityId(activityDO.getId());
            activityPrizeDO.setPrizeId(item.getPrizeId());
            activityPrizeDO.setPrizeAmount(item.getPrizeAmount());
            activityPrizeDO.setPrizeTiers(item.getPrizeTiers());
            activityPrizeDO.setStatus(ActivityPrizeStatusEnum.INIT.name());
            activityPrizeDOList.add(activityPrizeDO);
        });
        activityPrizeMapper.batchInsert(activityPrizeDOList);
        //关联人员信息,并保存至数据库
        List<CreateActivityParam.CreateUserByActivityParam> createUserByActivityParams = param.getActivityUserList();
        List<ActivityUserDO> activityUserDOList = new ArrayList<>();
        createUserByActivityParams.forEach(item->{
            ActivityUserDO activityUserDO = new ActivityUserDO();
            activityUserDO.setActivityId(activityDO.getId());
            activityUserDO.setUserId(item.getUserId());
            activityUserDO.setUserName(item.getUserName());
            activityUserDO.setStatus(ActivityUserStatusEnum.INIT.name());
            activityUserDOList.add(activityUserDO);
        });
        activityUserMapper.batchInsert(activityUserDOList);
        //查询奖品信息列表
        //使用stream中的map方法映射：提取ActivityPrizeDO类型中的每个prizeid映射，并且使用distinct方法去重
        List<Long> prizeIds = activityPrizeDOList.stream()
                .map(ActivityPrizeDO::getPrizeId)
                .distinct().toList();
        List<PrizeDO> prizeDOList = prizeMapper.batchSelectByIds(prizeIds);
        //将活动以及关联的奖品缓存至redis
        cacheActivity(convertToActivityDetilDTO(activityDO,activityPrizeDOList,activityUserDOList,prizeDOList));
        //返回活动id
        CreateActivityDTO createActivityDTO = new CreateActivityDTO();
        createActivityDTO.setActivityid(activityDO.getId());
        return createActivityDTO;
    }

//校验活动信息

private void checkActivityInfo(CreateActivityParam param) {
        //判断创建的活动是否为空
    if(param == null) {
        throw new ServiceException(ServiceErrorCodeConstatns.CREATE_ACTIVITY_IS_EMPTY);
    }
        //校验所选人员id是否存在
        List<Long> userIds = param.getActivityUserList()
                .stream().map(CreateActivityParam.CreateUserByActivityParam::getUserId)
                .distinct().toList();
        List<Long> existUserIds = userMapper.selectByIdsList(userIds);
        if(existUserIds == null) {
            throw new ServiceException(ServiceErrorCodeConstatns.ACTIVITY_USER_ERROR);
        }
        userIds.forEach(id->{
            if (!existUserIds.contains(id)) {
                throw new ServiceException(ServiceErrorCodeConstatns.ACTIVITY_USER_ERROR);
            }
        });

        //奖品id在奖品表中是否存在
        List<Long> prizeIds = param.getActivityPrizeList().stream()
                .map(CreateActivityParam.CreatePrizeByActivityParam::getPrizeId)
                .distinct().toList();
        List<Long> existPrizeIds = prizeMapper.selectByIdsList(prizeIds);
        if(existPrizeIds == null) {
            throw new ServiceException(ServiceErrorCodeConstatns.ACTIVITY_PRIZE_ERROR);
        }
        prizeIds.forEach(id->{
            if (!existPrizeIds.contains(id)) {
                throw new ServiceException(ServiceErrorCodeConstatns.ACTIVITY_PRIZE_ERROR);
            }
        });

        //人员数量大于等于奖品数量
        int userAmount = param.getActivityUserList().size();
        long prizeAmount = param.getActivityPrizeList().stream()
                .mapToLong(CreateActivityParam.CreatePrizeByActivityParam::getPrizeAmount)
                .sum();
        if (userAmount < prizeAmount) {
            throw new ServiceException(ServiceErrorCodeConstatns.USER_PRIZE_AMOUNT_ERROR);
        }

        //活动奖品等级有效性
        param.getActivityPrizeList().forEach(
                prize->{
                    if(null == ActivityPrizeTiersEnum.forName(prize.getPrizeTiers())) {
                        throw new ServiceException(ServiceErrorCodeConstatns.ACTIVITY_PRIZE_TIERS_ERROR);
                    }
                }
        );
    }
    /**
     * 将所获取的详细信息存放至redis缓存
     * @param detailDTO
     */
    private void cacheActivity(ActivityDetailDTO detailDTO) {
        // key: ACTIVITY_+
        // value: ActivityDetailDTO(json)
        if(detailDTO == null || detailDTO.getActivityId() == null) {
            log.error("要缓存的活动信息不存在");
            return;
        }
        try {
            redisUtil.set(ACTIVITY_PREFIX + detailDTO.getActivityId(),
                    JacksonUtil.writeValueAsString(detailDTO),
                    ACTIVITY_TIMEOUT);
        }catch (Exception e) {
            logger.error("缓存活动异常，ActivityDetailDTO={}",
                    JacksonUtil.writeValueAsString(detailDTO), e);
        }
    }
}

4.1.3：dao层：

        与数据库进行直接接触的层：

mapper层代码实现：

@Mapper
public interface ActivityMapper {

    @Insert("insert into activity (activity_name, description, status)" +
            " values (#{activityName}, #{description}, #{status})")
    @Options(useGeneratedKeys = true, keyProperty ="id", keyColumn ="id")
    Integer insert( ActivityDO activityDO);


    @Select("select count(1) from activity")
    long count();

    @Select("select * from activity order by id desc limit #{offset} , #{pageSize}")
    List<ActivityDO> queryActivitiesByPage(@Param("offset") Long offset,
                                           @Param("pageSize") Long pageSize);
}

4.2：展示活动：

前后端交互约定：      

[ 请求 ] /activity/find-list?currentPage=1&pageSize=10 GET

[ 响应 ]

{

"code": 200,

"data": {

"total": 10,

"records": [

{

"activityId": 23,

"activityName": " 抽奖测试 ",

"description": " 年会抽奖活动 ",

"valid": true

},

{

"activityId": 22,

"activityName": " 抽奖测试 ",

"description": " 年会抽奖活动 ",

"valid": true

},

{

"activityId": 21,

"activityName": " 节⽇抽奖 ",

"description": " ⽐特年会抽奖活动 ",

"valid": true

}

]

},

"msg": ""

}

    4.2.1：controller层：

@RequestMapping("/activity/find-list")
     public CommonResult<FindActivityListResult> findActivityList(
             @Valid PageListParam param) {
            logger.info("findActivityList :{}",JacksonUtil.writeValueAsString(param));
            PageListDTO<ActivityDTO> pageListDTO = createActivityService.findActivityList(param);
            return CommonResult.succcess(covertToFindActivityList(pageListDTO));
     }
   private FindActivityListResult covertToFindActivityList(PageListDTO<ActivityDTO> pageListDTO) {
        if(pageListDTO == null) {
            throw new ControllerException(ControllerErrorCodeConstants.FIND_ACITVITY_LIST_ERROR);
        }
        FindActivityListResult activityListResult = new FindActivityListResult();
        activityListResult.setTotal(pageListDTO.getTotal());
        activityListResult.setRecords(
                pageListDTO.getRecords().stream()
                        .map(item->{
                         FindActivityListResult.FindActivityInfo findActivityInfo = new FindActivityListResult.FindActivityInfo();
                         findActivityInfo.setActivityId(item.getActivityId());
                         findActivityInfo.setActivityName(item.getActivityName());
                         findActivityInfo.setDescription(item.getDescription());
                         findActivityInfo.setValid(item.valid());
                         return findActivityInfo;
                        }).collect(Collectors.toList())
        );
        return activityListResult;
    }
}

4.2.2：service层：

        需要注意的是，展示活动列表，获取活动信息还是从数据库中去获取，因为redis中的信息有设置过期时间，所以为了稳定去数据库直接拿！

        当后期设计抽奖后展示详细信息时可以从redis中去快速拿！

@Service
public interface ActivityService {

    PageListDTO<ActivityDTO> findActivityList(PageListParam param);
}

serviceimpl层：

/**
     * 活动列表展示
     * @return
     */
    @Override
    public PageListDTO<ActivityDTO> findActivityList(PageListParam param) {
        //total总数
        long count = activityMapper.count();
        //获取活动列表
        List<ActivityDO> activityDOList = activityMapper.queryActivitiesByPage(param.offset(),param.getPageSize());
        List<ActivityDTO> activityDTOList = new ArrayList<>();
        activityDOList.forEach(activityDO -> {
            ActivityDTO activityDTO = new ActivityDTO();
            activityDTO.setActivityId(activityDO.getId());
            activityDTO.setActivityName(activityDO.getActivityName());
            activityDTO.setDescription(activityDO.getDescription());
            activityDTO.setStatus(ActivityStatusEnum.fromName(activityDO.getStatus()));
            activityDTOList.add(activityDTO);
        });
        return new PageListDTO<>(count,activityDTOList);
    }

4.2.3：dao层：

@Mapper
public interface ActivityMapper {

    @Insert("insert into activity (activity_name, description, status)" +
            " values (#{activityName}, #{description}, #{status})")
    @Options(useGeneratedKeys = true, keyProperty ="id", keyColumn ="id")
    Integer insert( ActivityDO activityDO);


    @Select("select count(1) from activity")
    long count();

    @Select("select * from activity order by id desc limit #{offset} , #{pageSize}")
    List<ActivityDO> queryActivitiesByPage(@Param("offset") Long offset,
                                           @Param("pageSize") Long pageSize);

    @Select("select * from activity where id = #{activityId}")
    ActivityDO selectByActivityId(@Param("activityId") Long activityId);
}

接下来就是重头戏了，对于整个抽奖的设计！！