1
/**
2
 * 菜品管理
3
 */
4
@RestController
5
@RequestMapping("/admin/dish")
6
@Api(tags = "菜品相关接口")
7
@Slf4j
8
public class DishController {
9

10
    @Autowired
11
    private DishService dishService;
12
    //新增菜品
13
    @PostMapping
14
    @ApiOperation("新增菜品")
15
    public Result save(@RequestBody DishDTO dishDTO) {
16
        log.info("新增菜品：{}", dishDTO);
17
        dishService.saveWithFlavor(dishDTO);//后绪步骤开发
18
        return Result.success();
19
    }
20
}

1
@Service
2
@Slf4j
3
public class DishServiceImpl implements DishService {
4

5
    @Autowired
6
    private DishMapper dishMapper;
7
    @Autowired
8
    private DishFlavorMapper dishFlavorMapper;
9
    //新增菜品和对应的口味
10
    @Transactional
11
    public void saveWithFlavor(DishDTO dishDTO) {
12
    // 菜品数据对象 dish无需传入口味
13
        //DishDTO多了口味集合
14
        Dish dish = new Dish();
15
        BeanUtils.copyProperties(dishDTO, dish);
16
        //向菜品表插入1条数据
17
        dishMapper.insert(dish);//后绪步骤实
18

19
        //获取insert语句生成的主键值
20
        Long dishId = dish.getId();
21
//前端没有传递id,
22

23
        List<DishFlavor> flavors = dishDTO.getFlavors();
24
        if (flavors != null && flavors.size() > 0) {
25
            flavors.forEach(dishFlavor -> {
26
                dishFlavor.setDishId(dishId);
27
            });
28
            //向口味表插入n条数据
29
            dishFlavorMapper.insertBatch(flavors);//后绪步骤实
30
        }
31
    }
32
}

1
<!--    //分页查询-->
2
    <select id="pageQuery" resultType="com.sky.vo.DishVO">
3
            select d.*, c.name as categoryName  from dish d left outer join category c on d.category_id = c.id
4
            <where>
5
                 <if test="name != null and name != ''">
6
                  and  d.name like concat('%',#{name},'%')
7
                 </if>
8
                <if test="categoryId != null">
9
                  and    d.category_id = #{categoryId}
10
                </if>
11
                <if   test="status != null">
12
                    and  d.status = #{status}
13
                </if>
14
            </where>
15
            order by d.create_time desc
16
    </select>

1
 @Autowired
2
    private SetmealDishMapper setmealDishMapper;
3
  /**
4
     * 菜品批量删除
5
     *
6
     * @param ids
7
     */
8
    @Transactional//事务
9
    public void deleteBatch(List<Long> ids) {
10
        //判断当前菜品是否能够删除---是否存在起售中的菜品？？
11
        for (Long id : ids) {
12
            Dish dish = dishMapper.getById(id);//后绪步骤实现
13
            if (dish.getStatus() == StatusConstant.ENABLE) {
14
                //当前菜品处于起售中，不能删除
15
                throw new DeletionNotAllowedException(MessageConstant.DISH_ON_SALE);
16
            }
17
        }
18

19
        //判断当前菜品是否能够删除---是否被套餐关联了？？
20
        List<Long> setmealIds = setmealDishMapper.getSetmealIdsByDishIds(ids);
21
        if (setmealIds != null && setmealIds.size() > 0) {
22
            //当前菜品被套餐关联了，不能删除
23
            throw new DeletionNotAllowedException(MessageConstant.DISH_BE_RELATED_BY_SETMEAL);
24
        }
25

26
        //删除菜品表中的菜品数据
27
        for (Long id : ids) {
28
            dishMapper.deleteById(id);//后绪步骤实现
29
            //删除菜品关联的口味数据
30
            dishFlavorMapper.deleteByDishId(id);//后绪步骤实现
31
        }
32
    }

1
  //根据id修改菜品基本信息和对应的口味信息
2
    public void updateWithFlavor(DishDTO dishDTO) {
3
        Dish dish = new Dish();
4
        BeanUtils.copyProperties(dishDTO, dish);
5

6
        //修改菜品表基本信息
7
        dishMapper.update(dish);
8

9
        //删除原有的口味数据
10
        dishFlavorMapper.deleteByDishId(dishDTO.getId());
11

12
        //重新插入口味数据
13
        List<DishFlavor> flavors = dishDTO.getFlavors();
14
        if (flavors != null && flavors.size() > 0) {
15
            flavors.forEach(dishFlavor -> {
16
                dishFlavor.setDishId(dishDTO.getId());
17
            });
18
            //向口味表插入n条数据
19
            dishFlavorMapper.insertBatch(flavors);
20
        }
21
    }

1
<!--    修改菜品信息-->
2
    <update id="update">
3
        update dish
4
        <set>
5
            <if test="name != null">name = #{name},</if>
6
            <if test="categoryId != null">category_id = #{categoryId},</if>
7
            <if test="price != null">price = #{price},</if>
8
            <if test="image != null">image = #{image},</if>
9
            <if test="description != null">description = #{description},</if>
10
            <if test="status != null">status = #{status},</if>
11
            <if test="updateTime != null">update_time = #{updateTime},</if>
12
            <if test="updateUser != null">update_user = #{updateUser},</if>
13
        </set>
14
        where id = #{id}
15
    </update>
16
</mapper>

1
@Data
2
public class SetmealDTO implements Serializable {
3

4
    private Long id;
5

6
    //分类id
7
    private Long categoryId;
8

9
    //套餐名称
10
    private String name;
11

12
    //套餐价格
13
    private BigDecimal price;
14

15
    //状态 0:停用 1:启用
16
    private Integer status;
17

18
    //描述信息
19
    private String description;
20

21
    //图片
22
    private String image;
23

24
    //套餐菜品关系
25
    private List<SetmealDish> setmealDishes = new ArrayList<>();
26

27
}

1
@Data
2
@Builder
3
@NoArgsConstructor
4
@AllArgsConstructor
5
public class Setmeal implements Serializable {
6

7
    private static final long serialVersionUID = 1L;
8

9
    private Long id;
10

11
    //分类id
12
    private Long categoryId;
13

14
    //套餐名称
15
    private String name;
16

17
    //套餐价格
18
    private BigDecimal price;
19

20
    //状态 0:停用 1:启用
21
    private Integer status;
22

23
    //描述信息
24
    private String description;
25

26
    //图片
27
    private String image;
28

29

30

31
    private LocalDateTime createTime;
32

33
    private LocalDateTime updateTime;
34

35
    private Long createUser;
36

37
    private Long updateUser;
38
}

1
/**
2
 * 套餐菜品关系
3
 */
4
@Data
5
@Builder
6
@NoArgsConstructor
7
@AllArgsConstructor
8
public class SetmealDish implements Serializable {
9

10
    private static final long serialVersionUID = 1L;
11

12
    private Long id;
13

14
    //套餐id
15
    private Long setmealId;
16

17
    //菜品id
18
    private Long dishId;
19

20
    //菜品名称 （冗余字段）
21
    private String name;
22

23
    //菜品原价
24
    private BigDecimal price;
25

26
    //份数
27
    private Integer copies;
28
}

1
@RestController
2
@RequestMapping("/admin/setmeal")
3
@Api(tags = "套餐相关接口")
4
@Slf4j
5
public class SetmealController {
6
    @Autowired
7
    private SetmealService setmealService;
8
    //SetmealDTO 套餐实体类嵌套菜品集合SetmealDish
9
//新增套餐
10
    @ApiOperation("新增套餐")
11
    @PostMapping
12
    public Result insertSetmeal(@RequestBody SetmealDTO setmealDTO) {
13
        log.info("新增套餐");
14
        setmealService.insertSetmeal(setmealDTO);
15
        return Result.success();
16
    }

1
@Service
2
public class SetmealServiceImpl implements SetmealService {
3
    @Autowired
4
    private SetmealMapper setmealMapper;
5
    @Autowired
6
    private SetmealDishMapper setmealDishMapper;
7
    //新增菜品
8
    @Transactional
9
    @Override
10
    public void insertSetmeal(SetmealDTO dto) {
11
        Setmeal setmeal=new Setmeal();
12
        BeanUtils.copyProperties(dto,setmeal);
13
        //利用aop实现其他属性的填充
14
        //像套餐表插入数据
15
        setmealMapper.insert(setmeal);
16
      /
17
      /SetmealDish  套餐里的菜品
18
        //菜品都设置套餐的id属性
19
        List<SetmealDish> setmealDishes = dto.getSetmealDishes();
20
        setmealDishes.forEach(setmealDish -> {
21
            setmealDish.setSetmealId(setmeal.getId());
22
        });
23
        //批量插入套餐里的菜品
24
        setmealDishMapper.insertBatch(setmealDishes);
25
    }
26
}

1
@Data
2
public class SetmealPageQueryDTO implements Serializable {
3

4
    private int page;
5

6
    private int pageSize;
7

8
    private String name;
9

10
    //分类id
11
    private Integer categoryId;
12

13
    //状态 0表示禁用 1表示启用
14
    private Integer status;
15
}

1
@Data
2
@Builder
3
@NoArgsConstructor
4
@AllArgsConstructor
5
public class SetmealVO implements Serializable {
6

7
    private Long id;
8

9
    //分类id
10
    private Long categoryId;
11

12
    //套餐名称
13
    private String name;
14

15
    //套餐价格
16
    private BigDecimal price;
17

18
    //状态 0:停用 1:启用
19
    private Integer status;
20

21
    //描述信息
22
    private String description;
23

24
    //图片
25
    private String image;
26

27
    //更新时间
28
    private LocalDateTime updateTime;
29

30
    //分类名称
31
    private String categoryName;
32

33
    //套餐和菜品的关联关系
34
    private List<SetmealDish> setmealDishes = new ArrayList<>();
35
}

1
<mapper namespace="com.sky.mapper.SetmealMapper">
2
<!--    查询套餐-->
3
    <select id="listPageQuery" resultType="com.sky.vo.SetmealVO">
4
            select t1 *,t2.name as categoryName  from setmeal t1
5
           left join Category t2 on t2.category_id = t1.id
6
        <where>
7
            <if test="name != null">
8
                and s.name like concat('%',#{name},'%')
9
            </if>
10
            <if test="status != null">
11
                and s.status = #{status}
12
            </if>
13
            <if test="categoryId != null">
14
                and s.category_id = #{categoryId}
15
            </if>
16
        </where>
17
    </select>
18
</mapper>

1
   //删除套餐
2
    @Transactional
3
    @Override
4
    public void deleteBatch(List<Long> ids) {
5
        ids.forEach(id -> {
6
            Setmeal setmeal = setmealMapper.getById(id);
7
            if(StatusConstant.ENABLE == setmeal.getStatus()){
8
                //起售中的套餐不能删除
9
                throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE);
10
            }
11
        });
12
        ids.forEach(setmealId -> {
13
            //删除套餐表中的数据
14
            setmealMapper.deleteById(setmealId);
15
            //删除套餐菜品关系表中的数据
16
            setmealDishMapper.deleteBySetmealId(setmealId);
17
        });
18
    }

1
<delete id="deleteBatch">
2
    delete from setmeal where id in
3
    <foreach collection="ids" item="id" open="(" close=")" separator=",">
4
        #{id}
5
    </foreach>
6
</delete>
7

8
setmealDishMapper的批量删除方法同上
9

10
<delete id="deleteBatch">
11
    delete from setmeal_dish where setmeal_id in
12
    <foreach collection="ids" item="id" open="(" close=")" separator=",">
13
        #{id}
14
    </foreach>
15
</delete>

1
//2.编辑套餐
2
@Override
3
public void update(SetmealDTO dto) {
4
    Setmeal setmeal = new Setmeal();
5
    BeanUtils.copyProperties(dto,setmeal);
6
    //更新套餐的基本信息
7
    setmealMapper.update(setmeal);
8

9
    //删除套餐菜品关系表中的菜品关系数据
10
    setmealDishMapper.deleteById(setmeal.getId());
11

12
//批量插入套餐菜品关系数据
13
    List<SetmealDish> dishes = dto.getSetmealDishes();
14
    //判断菜品关系数据是否为空
15
    //菜品关联id赋值
16
    if (dishes !=null && dishes.size()>0){
17
        dishes.forEach(dish ->{
18
            dish.setSetmealId(dto.getId());
19
        });
20
        setmealDishMapper.insert(dishes);
21
    }
22
}

1
//套餐起售停售
2
    @Override
3
    public void updateStatus(Integer status, Long id) {
4
        // 设置为起售，判断套餐里面的菜品是否存在停售状态，如果有抛出自定义异常
5
        if (status == StatusConstant.ENABLE) {
6
            List<Dish> dishList = setmealDishMapper.selectDishById(id);
7
            dishList.forEach(dish -> {
8
                if (dish.getStatus() == StatusConstant.DISABLE) {
9
                    throw new SetmealEnableFailedException(MessageConstant.SETMEAL_ENABLE_FAILED);
10
                }
11
            });
12
        }
13
        // 更新起售停售信息
14
        Setmeal setmeal = new Setmeal();
15
        setmeal.setStatus(status);
16
        setmeal.setId(id);
17
        setmealMapper.update(setmeal);
18
    }

1
@Configuration
2
@Slf4j
3
public class RedisConfiguration {
4

5
        @Bean
6
        public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
7
            log.info("开始创建redis模板对象...");
8
            RedisTemplate redisTemplate = new RedisTemplate();
9

10
            // 设置Key的序列化器为StringRedisSerializer    默认为JdkSerializationRedisSerializer
11
            redisTemplate.setKeySerializer(new StringRedisSerializer());
12
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
13

14
            // 不推荐修改Value的序列化器为单一的StringRedisSerializer之类的
15
            // redisTemplate.setValueSerializer(new StringRedisSerializer());
16

17
            redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
18
            redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
19
            // 通过redis工厂创建对象，帮助RedisTemplate获取数据库连接，即连接Redis服务器的能力
20
            redisTemplate.setConnectionFactory(redisConnectionFactory);
21

22
            return redisTemplate;
23
        }
24
}

1
@Test
2
public void test1() {
3
    // 1.获取hashOperations对象
4
    HashOperations hashOperations = redisTemplate.opsForHash();
5

6
    // 2.通过hashOperations对象，操作hash类型对象
7
    hashOperations.put("user", "name", "lisi");
8
    hashOperations.put("user", "age", 20);
9
    hashOperations.put("user", "gender", "男");
10

11
    Set user = hashOperations.keys("user");
12
    System.out.println(user);
13

14
    List user1 = hashOperations.values("user");
15
    System.out.println(user1);
16

17
    Map user2 = hashOperations.entries("user");
18
    System.out.println(user2);
19
}

1
@Test
2
public void test2() {
3
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();
4

5
    zSetOperations.add("zset01", "lisi", 99);
6
    zSetOperations.add("zset01", "zhangsan", 88);
7
    zSetOperations.add("zset01", "yuanshen", 77);
8

9
    Set zset1 = zSetOperations.range("zset01", 0, -1);
10
    System.out.println(zset1);
11

12
    Set<DefaultTypedTuple> zset2 = zSetOperations.rangeWithScores("zset01", 0, -1);
13
    System.out.println(zset2);
14

15
    for (DefaultTypedTuple object : zset2) {
16
        System.out.println(object.getValue() + "--" + object.getScore());
17
    }
18
}

1
@Test
2
public void test3() {
3
    SetOperations setOperations = redisTemplate.opsForSet();
4

5
    setOperations.add("set01", "java", "go", "python", "c");
6
    setOperations.add("set02", "java", "go", "dance", "sing");
7

8
    Set set01 = setOperations.members("set01");
9
    System.out.println(set01);
10

11
    Set set02 = setOperations.members("set02");
12
    System.out.println(set02);
13

14
    Set union = setOperations.union("set01", "set02");
15
    System.out.println(union);
16

17
    Set intersect = setOperations.intersect("set01", "set02");
18
    System.out.println(intersect);
19

20
    Set difference = setOperations.difference("set01", "set02");
21
    System.out.println(difference);
22
}

1
@Test
2
public void test3() {
3
    SetOperations setOperations = redisTemplate.opsForSet();
4

5
    setOperations.add("set01", "java", "go", "python", "c");
6
    setOperations.add("set02", "java", "go", "dance", "sing");
7

8
    Set set01 = setOperations.members("set01");
9
    System.out.println(set01);
10

11
    Set set02 = setOperations.members("set02");
12
    System.out.println(set02);
13

14
    Set union = setOperations.union("set01", "set02");
15
    System.out.println(union);
16

17
    Set intersect = setOperations.intersect("set01", "set02");
18
    System.out.println(intersect);
19

20
    Set difference = setOperations.difference("set01", "set02");
21
    System.out.println(difference);
22
}

1
@RestController("userShopController")
2
@RequestMapping("/user/shop")
3
@Slf4j
4
@Api("店铺相关接口")
5
public class ShopController {
6
    public static final String KEY="SHOP_STATUS";
7
    @Autowired
8
    private RedisTemplate redisTemplate;
9
    @GetMapping("/status")
10
    @ApiOperation("查询营业状态")
11
    public Result<Integer> getStatus(){
12
        Integer shopStatus = (Integer) redisTemplate.opsForValue().get("SHOP_STATUS");
13
        log.info("查询营业状态:{}",shopStatus == 1 ? "营业中" : "打烊中");
14
        return Result.success(shopStatus);
15
    }
16
}