团队作业4——项目冲刺-4

团队作业4——项目冲刺-4

信息项	内容
课程名称	广工计院计科34班软工
作业要求位置	作业要求
作业目标	在七天敏捷冲刺中，完成工大严选开发，记录每日进展和问题，更新燃尽图、签入代码，并发布集合日志总结成果
GitHub链接	GitHub

一、团队简介

• 队名：小飞棍队

• 团队成员：

姓名	学号
罗振烘（组长）	3122004748
庄崇立	3122004633
李响	3121002802
何昌洲	3122004737

二、会议总结

会议信息

• 日期：2024年11月14日
• 时长：15分钟
• 会议形式：在线会议
• 主持人：罗振烘（组长）

会议照片

昨天完成的工作

任务	内容
商品分类功能开发	完成商品分类模块的增删查改接口，实现了商品分类的基本管理功能。
接口设计与优化	设计RESTful接口，并通过Swagger注解生成API文档，方便团队测试和调用。
分类功能接口调试	进行前后端接口调试，确保商品分类信息可以正常获取、添加、修改和删除。
code review	对代码规范进行了细致检查，统一了字段命名，完善了注释，提升代码一致性和可维护性。
需求文档更新	补充了分类模块的需求细节，基于实际开发中遇到的问题完善了相关文档。

今天完成的工作

任务	内容
热门推荐完善	完善了热门推荐功能，新增、修改、删除都调试顺畅。
商品推荐优化	调整了推荐逻辑，让推荐更精准。
数据库加速	加了索引，查询速度快多了。
前端UI改进	优化了页面布局，用户体验更好。
集成测试完成	测试了主要功能，修复了一些小问题。

工作中遇到的困难

团队在协作中遇到一些挑战，比如前后端接口对接时的数据格式不一致导致调试时间增加，数据库在数据量增多后出现了性能瓶颈，需要进行复杂的索引优化。需求变动也让部分功能返工，前端在UI布局和设计细节上需要多次沟通以确保一致。此外，多人代码合并时也出现冲突，需要谨慎处理才能保证代码的顺利集成。

会议内容

• 目标：确保团队成员同步项目进展，解决昨天遇到的问题。

任务分配

四、燃尽图

五、代码签入记录

签入记录对应的Issue内容与链接

code review编码规范文档

六、项目程序/模块的最新(运行)截图

核心代码

package com.example.hot.controller;

// 引入相关类和包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaJoinQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.goods.pojo.Goods;
import com.example.goods.service.GoodsService;
import com.example.hot.pojo.*;
import com.example.hot.service.*;
import com.example.smartcommon.util.R;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

// 标记为控制器并设置基本请求路径
@RestController
@RequestMapping(value = "/hot/")
@Tag(name = "显示热门推荐")
public class HotController {

    // 自动注入服务层对象
    @Autowired
    private HotService hotService;
    @Autowired
    private HotGoodsService hotGoodsService;
    @Autowired
    private GoodsService goodsService;
    @Autowired
    private TypeService typeService;
    @Autowired
    private RecommendService recommendService;

    // 获取所有热门推荐
    @Operation(summary = "获得所有的热门推荐")
    @GetMapping(value = "/getAllHot")
    public R getAllHot() {
        // 创建连接查询包装器，进行表连接查询
        LambdaJoinQueryWrapper<HotGoods> wrapper = new LambdaJoinQueryWrapper<>(HotGoods.class);
        wrapper.innerJoin(Hot.class, Hot::getHotPicturesId, HotGoods::getHotId)
                .innerJoin(Goods.class, Goods::getGoodsId, HotGoods::getGoodsId);
        QueryWrapper<HotGoods> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByAsc("rand()"); // 按随机顺序排列

        // 查询所有热门商品并进行打乱处理
        List<HotGoods> hotGoodsList = hotGoodsService.list(wrapper);
        Collections.shuffle(hotGoodsList, new Random());

        // 创建用于存储热门推荐的列表和已添加的热门推荐 ID 集合
        List<HotVo> hotVoList = new ArrayList<>();
        Set<Integer> addedHotIds = new HashSet<>();

        // 根据热门 ID 排序并遍历每个商品
        hotGoodsList.sort(Comparator.comparingInt(hotGoods -> hotGoods.getHot().getHotId()));
        hotGoodsList.forEach(item -> {
            int hotId = item.getHot().getHotId();
            if (!addedHotIds.contains(hotId)) {
                // 获取图片并构建热点推荐视图对象
                String[] hotImages = hotGoodsList.stream()
                        .filter(hotGoods -> hotGoods.getHot().getHotId() == hotId)
                        .map(hotGoods -> hotGoods.getGoods().getGoodsPicture())
                        .limit(2)
                        .toArray(String[]::new);

                HotVo hotVo = new HotVo();
                BeanUtils.copyProperties(item, hotVo);
                hotVo.setHotId(hotId);
                hotVo.setHotPictures(hotImages);
                hotVo.setHotTitle(item.getHot().getHotTitle());
                hotVo.setHotAlt(item.getHot().getHotAlt());
                hotVo.setHotTarget(item.getHot().getHotTarget());
                hotVo.setHotType(item.getHot().getHotType());
                hotVoList.add(hotVo);
                addedHotIds.add(hotId);
            }
        });
        return R.ok("查询所有热门推荐成功").data("hot", hotVoList);
    }

    // 获取热门商品推荐
    @Operation(summary = "获得热门商品推荐")
    @GetMapping(value = "/getHotGoods")
    public R getHotGoods() {
        LambdaJoinQueryWrapper<HotGoods> wrapper = new LambdaJoinQueryWrapper<>(HotGoods.class);
        wrapper.innerJoin(Hot.class, Hot::getHotPicturesId, HotGoods::getHotId)
                .innerJoin(Goods.class, Goods::getGoodsId, HotGoods::getGoodsId);
        List<HotGoods> hotGoodsList = hotGoodsService.list(wrapper);
        return R.ok("查询热门商品推荐成功").data("hot", hotGoodsList);
    }

    // 获取特惠推荐
    @Operation(summary = "获得特惠推荐")
    @GetMapping(value = "/getPreference")
    public R getPreference(@RequestParam(name = "page", defaultValue = "1") Long page,
                           @RequestParam(name = "pageSize", defaultValue = "10") Long pageSize) {
        return getRecommendData(page, pageSize, 0, "获得特惠推荐成功");
    }

    // 获取爆款推荐
    @Operation(summary = "获得爆款推荐")
    @GetMapping(value = "/getInVogue")
    public R getInVogue(@RequestParam(name = "page", defaultValue = "1") Long page,
                        @RequestParam(name = "pageSize", defaultValue = "10") Long pageSize) {
        return getRecommendData(page, pageSize, 1, "获得爆款推荐成功");
    }

    // 获取一站买全推荐
    @Operation(summary = "获得一站买全")
    @GetMapping(value = "/getOneStop")
    public R getOneStop(@RequestParam(name = "page", defaultValue = "1") Long page,
                        @RequestParam(name = "pageSize", defaultValue = "10") Long pageSize) {
        return getRecommendData(page, pageSize, 2, "获得一站买全成功");
    }

    // 获取新鲜好物推荐
    @Operation(summary = "获得新鲜好物")
    @GetMapping(value = "/getNewShop")
    public R getNewShop(@RequestParam(name = "page", defaultValue = "1") Long page,
                        @RequestParam(name = "pageSize", defaultValue = "10") Long pageSize) {
        return getRecommendData(page, pageSize, 3, "获得新鲜好物成功");
    }

    // 通用推荐数据查询方法
    private R getRecommendData(Long page, Long pageSize, int index, String message) {
        LambdaJoinQueryWrapper<Recommend> wrapper = new LambdaJoinQueryWrapper<>(Recommend.class);
        wrapper.innerJoin(Type.class, Type::getTypeId, Recommend::getTypeId);

        // 获取推荐列表和类型映射
        List<Recommend> recommendList = recommendService.list(wrapper);
        Map<Integer, Type> typeMap = typeService.list().stream()
                .collect(Collectors.toMap(Type::getTypeId, Function.identity()));
        Recommend recommend = recommendList.isEmpty() ? null : recommendList.get(index);
        List<RecommendVo> recommendVoList = new ArrayList<>();

        // 若推荐项存在，进行类型和商品数据的获取与封装
        if (recommend != null) {
            String[] typeSplit = recommend.getTypeId().split(",");
            List<Type> types = Arrays.stream(typeSplit)
                    .map(Integer::valueOf)
                    .map(typeMap::get)
                    .toList();

            RecommendVo recommendVo = new RecommendVo();
            BeanUtils.copyProperties(recommend, recommendVo);

            List<TypeVo> typeVoList = new ArrayList<>();
            for (Type type : types) {
                TypeVo typeVo = new TypeVo();
                BeanUtils.copyProperties(type, typeVo);

                // 设置商品分页查询及结果存储
                Page<Goods> goodsPage = new Page<>(page, pageSize);
                QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
                queryWrapper.orderByDesc("rand()");
                goodsService.page(goodsPage, queryWrapper);

                List<Goods> goodsList = goodsPage.getRecords();
                Map<String, Object> map = new HashMap<>();
                map.put("counts", goodsPage.getTotal());
                map.put("pageSize", goodsPage.getSize());
                map.put("pages", goodsPage.getPages());
                map.put("page", goodsPage.getCurrent());
                map.put("goodsList", goodsList);

                typeVo.setGoodsItems(map);
                typeVoList.add(typeVo);
            }
            recommendVo.setTypeList(typeVoList);
            recommendVoList.add(recommendVo);
        }

        // 返回封装后的推荐数据
        Map<String, Object> maps = new HashMap<>();
        maps.put("recommendList", recommendVoList);
        return R.ok(message).data(maps);
    }

    // 增加热门推荐
    @Operation(summary = "增加热门推荐")
    @PostMapping(value = "/addHot")
    public R addHot(@RequestBody Hot hot) {
        boolean flag = hotService.save(hot);
        return flag ? R.ok("增加热门推荐成功") : R.error("增加热门推荐失败");
    }

    // 删除指定 ID 的热门推荐
    @Operation(summary = "删除热门推荐数据")
    @DeleteMapping(value = "/deleteHot/{id}")
    public R deleteHot(@PathVariable("id") Integer bannerId) {
        boolean flag = hotService.removeById(bannerId);
        return flag ? R.ok("删除热门推荐成功") : R.error("删除热门推荐失败");
    }

    // 按热门推荐编号查询数据
    @Operation(summary = "按照热门推荐编号查询数据")
    @GetMapping(value = "/getHotById/{id}")
    public R getByIdHot(@PathVariable("id") Integer bannerId) {
        Hot hot = hotService.getById(bannerId);
        return R.ok("按照热门推荐编号查询数据成功").data("banner", hot);
    }

    // 修改热门推荐数据
    @Operation(summary = "修改热门推荐数据")
    @PutMapping(value = "/updateHot")
    public R updateHot(@RequestBody Hot hot) {
        boolean flag = hotService.updateById(hot);
        if (flag) {
            return R.ok("修改热门推荐成功");
        } else {
            return R.error("修改热门推荐失败");
        }
    }
}

最新模块截图

七、每日每人总结

姓名	总结
罗振烘	调试接口时终于通了，有大家协作支持，解决问题更高效了。
庄崇立	页面细节改进了不少，和后端的对接顺利，协作真的让进展飞快。
李响	数据库优化后效果显著，和前端配合更默契，整体性能提升看得见。
何昌洲	布局更灵活，UI提升不少，大家配合默契，开发效率明显提高了。