黑马-苍穹外卖-Day4

苏景彦

已于 2024-06-01 19:20:51 修改

阅读量1.1k

点赞数 15

分类专栏：人间不清醒文章标签： java

于 2024-06-01 15:52:11 首次发布

本文链接：https://blog.csdn.net/qq_45662013/article/details/139370763

版权

人间不清醒专栏收录该内容

20 篇文章 1 订阅

订阅专栏

1 新增套餐

接口设计（共涉及到4个接口）：

根据类型查询分类（已完成）
- /admin/category/list
- select * from category where status = 1 and type = 2;
- category（分类表）type = 1返回菜品分类，type = 2返回套餐分类
- 返回的是个列表，可以获取到分类的id
根据分类id查询菜品
图片上传（已完成）
新增套餐

1.1 根据分类id查询菜品表中该分类下的菜品

1.1.1 DishController

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    public Result<List<Dish>> list(long categoryId) {
        List<Dish> list = DishService.list(categoryId);  // 返回某一分类的所有菜品
        return Result.success(list);
    }

1.1.2 DishService

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
     List<Dish> list(long categoryId);

1.1.3 DishServiceImpl

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    public List<Dish> list(long categoryId) {
        Dish dish = Dish.builder()
                .categoryId((categoryId))
                .status(StatusConstant.ENABLE)
                .build();
        
        return dishMapper.list(dish);
    }

1.1.4 DishMapper

    /**
     * 根据分类id查询菜品
     * @param dish
     * @return
     */
    List<Dish> list(Dish dish);

1.1.5 DishMapper.xml

    <select id="list" resultType="com.sky.entity.Dish">
        select * from dish
        <where>
            <if test="name != null">
                and name like concat('%', #{name}, '%')
            </if>
            <if test="categoryId != null">
                and category_id = #{categoryId}
            </if>
            <if test="status != null">
                and status  = #{status}
            </if>
        </where>
        order by create_time desc
    </select>

1.2 新增菜品

1.2.1 SetmealController

@RestController
@RequestMapping
@Api("套餐相关接口")
@Slf4j
public class SetmealController {

    @Autowired
    private SetmealService setmealService;

    /**
     * 新增套餐
     * @param setmealDTO
     * @return
     */
    @PostMapping
    @ApiOperation("新增套餐")
    public Result save(@RequestBody SetmealDTO setmealDTO) {
        log.info("新增套餐：", setmealDTO);
        setmealService.save(setmealDTO);
        return Result.success();
    }
}

1.2.2 SetmealService

public interface SetmealService {
    /**
     * 新增套餐
     * @param setmealDTO
     */
    void save(SetmealDTO setmealDTO);
}

1.2.3 SetmealServiceImpl

    /**
     * 新增套餐，同时保存套餐和菜品的关联关系
     * @param setmealDTO
     */
    @Transactional
    public void save(SetmealDTO setmealDTO) {
        Setmeal setmeal = new Setmeal();  // 创建一个新的套餐实体类
        BeanUtils.copyProperties(setmealDTO, setmeal);  // 属性拷贝

        // 向套餐表插入数据
        setmealMapper.insert(setmeal);

        // 获取生成的套餐id
        Long setmealId = setmeal.getId();

        List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
        setmealDishes.forEach(setmealDish -> {
            setmealDish.setSetmealId(setmealId);
        });

        // 套餐-菜品表中保存套餐和菜品的关联关系
        setmealDishMapper.insertBatch(setmealDishes);
    }

1.2.4 SetmealMapper

    /**
     * 新增套餐
     * @param setmeal
     */
    @AutoFill(value = OperationType.INSERT)
    void insert(Setmeal setmeal);

1.2.5 SetmealMapper.xml

parameterType=“com.sky.entity.Setmeal” useGeneratedKeys=“true” keyProperty=“id” ，加上后，setmeal中的id字段会自动更新
如果不加，Long setmealId = setmeal.getId(); 获取到的仍是NULL，后面插入setmeal_dish表也会是NULL

    <insert id="insert" parameterType="com.sky.entity.Setmeal" useGeneratedKeys="true" keyProperty="id">
        insert into setmeal
        (category_id, name, price, status, description, image, create_time, update_time, create_user, update_user)
        values (#{categoryId}, #{name}, #{price}, #{status}, #{description}, #{image}, #{createTime}, #{updateTime},
        #{createUser}, #{updateUser})
    </insert>

1.2.6 SetmealDishMapper

    /**
     * 批量保存套餐和菜品的关联关系
     * @param setmealDishes
     */
    void insertBatch(List<SetmealDish> setmealDishes);

1.2.7 SetmealDishMapper.xml

批量保存套餐和菜品的关联关系

    <insert id="insertBatch" parameterType="list">
        insert into setmeal_dish
        (setmeal_id,dish_id,name,price,copies)
        values
        <foreach collection="setmealDishes" item="sd" separator=",">
            (#{sd.setmealId},#{sd.dishId},#{sd.name},#{sd.price},#{sd.copies})
        </foreach>
    </insert>

2 套餐分页查询

2.1 SetmealController

    /**
     * 分页查询
     * @param setmealPageQueryDTO
     * @return
     */
    @GetMapping("/page")
    @ApiOperation("分页查询")
    public Result<PageResult> page(SetmealPageQueryDTO setmealPageQueryDTO) {
        log.info("套餐分页查询：", setmealPageQueryDTO);
        PageResult pageResult = setmealService.pageQuery(setmealPageQueryDTO);
        return Result.success(pageResult);
    }

2.2 SetmealService

    /**
     * 套餐分页查询
     * @param setmealPageQueryDTO
     * @return
     */
    PageResult pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);

2.3 SetmealServiceImpl

    /**
     * 套餐分页查询
     * @param setmealPageQueryDTO
     * @return
     */
    public PageResult pageQuery(SetmealPageQueryDTO setmealPageQueryDTO) {
        int pageNum = setmealPageQueryDTO.getPage();
        int pageSize = setmealPageQueryDTO.getPageSize();

        PageHelper.startPage(pageNum, pageSize);
        Page<SetmealVO> page = setmealMapper.pageQuery(setmealPageQueryDTO);
        return new PageResult(page.getTotal(), page.getResult());
    }

2.4 SetmealMapper

    /**
     * 套餐分页查询
     * @param setmealPageQueryDTO
     * @return
     */
    Page<SetmealVO> pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);

2.5 SetmealMapper.xml

    <select id="pageQuery" resultType="com.sky.vo.SetmealVO">
        select s.*,c.name categoryName
        from setmeal as s
        left join
        category as c
        on s.category_id = c.id
        <where>
            <if test="name != null">
                and s.name like concat('%',#{name},'%')
            </if>
            <if test="status != null">
                and s.status = #{status}
            </if>
            <if test="categoryId != null">
                and s.category_id = #{categoryId}
            </if>
        </where>
        order by s.create_time desc
    </select>

3 删除套餐

3.1 SetmealController

    /**
     * 批量删除套餐
     * @param ids
     * @return
     */
    @DeleteMapping
    @ApiOperation("批量删除套餐")
    public Result delete(@RequestParam List<Long> ids) {
        log.info("批量删除套餐: ", ids);
        setmealService.delete(ids);        
        return Result.success();
    }

3.2 SetmealService

    /**
     * 批量删除套餐
     * @param ids
     */
    void delete(List<Long> ids);

3.3 SetmealServiceImpl

    /**
     * 批量删除套餐
     * @param ids
     */
    @Transactional
    public void delete(List<Long> ids) {
        // 判断是否有套餐处于启售状态
        ids.forEach(id -> {
            Setmeal setmeal = setmealMapper.getById(id);
            if(setmeal.getStatus() == StatusConstant.ENABLE) {
                // 有套餐处于启售状态，不能删除
                throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE);
            }
        });

        ids.forEach(setmealId -> {
            // 删除套餐表中的数据
            setmealMapper.deleteById(setmealId);
            // 删除套餐菜品关系表中的数据
            setmealDishMapper.deleteBySetmealId(setmealId);
        });
    }

3.4 SetmealMapper

根据id查询套餐

    /**
     * 根据id查询套餐
     * @param id
     * @return
     */
    @Select("select * from setmeal where id = #{id}")
    Setmeal getById(Long id);

根据id删除套餐

    /**
     * 根据id删除套餐
     * @param setmealId
     */
    @Delete("delete from setmeal where id = #{setmealId}")
    void deleteById(Long setmealId);

3.5 SetmealDishMapper

    /**
     * 根据id删除删除套餐菜品关系表中的数据
     * @param setmealId
     */
    @Delete("delete from setmeal_dish where setmeal_id = #{setmealId}")
    void deleteBySetmealId(Long setmealId);

4 修改套餐

4.1 根据id查询套餐

4.1.1 SetmealController

    /**
     * 根据id查询套餐，用于修改页面回显数据
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    @ApiOperation("根据id查询套餐")
    public Result<SetmealVO> getById(@PathVariable Long id) {
        SetmealVO setmealVO = setmealService.getByIdWithDish(id);  // 套餐以及套餐下属菜品列表都返回了
        return Result.success(setmealVO);
    }

4.1.2 SetmealService

    /**
     * 根据id查询套餐和关联的菜品数据
     * @param id
     * @return
     */
    SetmealVO getByIdWithDish(Long id);

4.1.3 SetmealServiceImpl

    /**
     * 根据id查询套餐和关联的菜品数据
     * @param id
     * @return
     */
    public SetmealVO getByIdWithDish(Long id) {
        Setmeal setmeal = setmealMapper.getById(id);
        List<SetmealDish> setmealDishes = setmealDishMapper.getBySetmealId(id);
        
        SetmealVO setmealVO = new SetmealVO();
        BeanUtils.copyProperties(setmeal, setmealVO);
        setmealVO.setSetmealDishes(setmealDishes);
        return setmealVO;
    }

4.4 SetmealDishMapper

    /**
     * 根据套餐id查询套餐和菜品的关联关系
     * @param setmealId
     * @return
     */
    @Select("select * from setmeal_dish where setmeal_id = #{setmealId}")
    List<SetmealDish> getBySetmealId(Long setmealId);

4.2 修改套餐

4.2.1 SetmealController

    /**
     * 修改套餐
     * @param setmealDTO
     * @return
     */
    @PutMapping
    @ApiOperation("修改套餐")
    public Result update(@RequestBody SetmealDTO setmealDTO) {
        setmealService.update(setmealDTO);
        return Result.success();
    }

4.2.2 SetmealService

    /**
     * 修改套餐
     * @param setmealDTO
     */
    void update(SetmealDTO setmealDTO);

4.2.3 SetmealServiceImpl

   /**
     * 修改套餐
     * @param setmealDTO
     */
    @Transactional
    public void update(SetmealDTO setmealDTO) {
        Setmeal setmeal = new Setmeal();
        BeanUtils.copyProperties(setmealDTO, setmeal);

        // 修改套餐表 -- update
        setmealMapper.update(setmeal);

        // 套餐id
        Long setmealId = setmealDTO.getId();

        // 删除套餐和菜品的关联关系 -- 根据套餐id删除套餐-菜品表中的记录
        setmealDishMapper.deleteBySetmealId(setmealId);

        // 重新向套餐-菜品表中插入套餐-菜品的关联关系 -- insert
        List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();
        setmealDishes.forEach(setmealDish -> {
            setmealDish.setSetmealId(setmealId);  // 加上套餐id
        });
        setmealDishMapper.insertBatch(setmealDishes);
    }

4.2.4 SetmealMapper

    /**
     * 更新套餐
     * @param setmeal
     */
    @AutoFill(value = OperationType.UPDATE)
    void update(Setmeal setmeal);

4.2.5 SetmealMapper.xml

别忘了，

    <update id="update" parameterType="com.sky.entity.Setmeal">
        update setmeal
        <set>
            <if test="name != null">name = #{name} ,</if>
            <if test="categoryId != null">category_id = #{categoryId} ,</if>
            <if test="price != null">price = #{price} ,</if>
            <if test="image != null">image = #{image} ,</if>
            <if test="description != null">description = #{description} ,</if>
            <if test="status != null">status = #{status} ,</if>
            <if test="updateTime != null">update_time = #{updateTime} ,</if>
            <if test="updateUser != null">update_user = #{updateUser} ,</if>
        </set>
        where id = #{id}
    </update>

5 起售停售套餐

5.1 SetmealController

    /**
     * 套餐启售停售
     * @param status
     * @param id
     * @return
     */
    @PostMapping("/status/{status}")
    @ApiOperation("套餐启售停售")
    public Result startOrStop(@PathVariable Integer status, Long id) {
        log.info("启售停售套餐: {} -- {}", status, id);
        setmealService.startOrStop(status, id);
        return Result.success();
    }

5.2 SetmealService

    /**
     * 套餐启售停售
     * @param status
     * @param id
     */
    void startOrStop(Integer status, Long id);

5.3 SetmealServiceImpl

    /**
     * 套餐启售停售
     * @param status
     * @param id
     */
    public void startOrStop(Integer status, Long id) {

        // 启售套餐时，判断套餐内是否有停售菜品，有停售菜品提示"套餐内包含未启售菜品，无法启售"
        if(status == StatusConstant.ENABLE) { // 准备启售套餐
        // select a.* from dish as a left join setmeal_dish as b on a.id = b.dish_id where b.setmeal_id = ?
            List<Dish> dishList = dishMapper.getBySetmealId(id);  // 根据套餐id查询菜品，返回菜品列表
            if(dishList != null && dishList.size() > 0) {
                dishList.forEach(dish -> {
                    if(dish.getStatus() == StatusConstant.DISABLE) {  // 只有有一个菜品是停售的
                        throw new SetmealEnableFailedException(MessageConstant.SETMEAL_ENABLE_FAILED);
                    }
                });
            }
        }

        Setmeal setmeal = Setmeal.builder()
                .id(id)
                .status(status)
                .build();
        setmealMapper.update(setmeal);
    }

5.4 DishMapper

    /**
     * 根据套餐id查询菜品
     * @param setmealId
     * @return
     */
    @Select("select a.* from dish as a left join setmeal_dish as b on a.id = b.dish_id where b.setmeal_id = #{setmealId}")
    List<Dish> getBySetmealId(Long setmealId);