黑马程序员Java项目实战《瑞吉外卖》笔记 Day5：视频P69-P88

红太狼 2023-10-09 16:06 56阅读 0赞

## 黑马程序员Java项目实战《瑞吉外卖》 笔记 ##

本课程以当前热门的外卖点餐为业务基础，业务真实、实用、广泛。基于流行的Spring Boot、mybatis  
plus等技术框架进行开发，带领学员体验真实项目开发流程、需求分析过程和代码实现过程。学完本课程能够收获：锻炼需求分析能力、编码能力、bug调试能力，增长开发经验。

*  链接：https://www.bilibili.com/video/BV13a411q753

## 20230322 Day5：视频P69-P88 ##

*  套餐系统管理
 *  新增套餐
 *  套餐分页查询
 *  套餐删除
 *  短信发送
 *

### 套餐系统管理： ###

需求分析：

> 套餐就是菜品的集合.  
> 后台系统中可以管理套餐信息，通过新增套餐功能来添加一个新的套餐，在添加套餐时需要选择当前套餐所属的套餐  
> 分类和包含的菜品！并且需要上传套餐对应的图片，在移动端会按照套餐分类来展示对应的套餐。

数据模型：

> 新增套餐，其实就是将新增页面录入的套餐信息插入到setmeal表，还需要向setmeal\_dish表插入套餐和菜品关联数据。  
> 所以在新增套餐时，涉及到两个表：
> 
>  *  setmeal 套餐表
>  *  setmeal\_dish 套餐菜品关系表

在开发业务功能前，先将需要用到的类和接口基本结构创建好：  
实体类SetmealDish

DTO SetmealDto

package com.reggie.DTO;
    
    import com.reggie.entity.Setmeal;
    import com.reggie.entity.SetmealDish;
    im坎普iopt 吃点饭认得日日日f't'ge'w's'xport lombok.Data;
    import java.util.List;
    
    @Data
    public class SetmealDto extends Setmeal {
        
    
        private List<SetmealDish> setmealDishes;
    
        private String categoryName;
    }

Mapper接口SetmealDishMapper

package com.reggie.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.reggie.entity.SetmealDish;
    import org.apache.ibatis.annotations.Mapper;
    
    @Mapper
    public interface SetmealDishMapper extends BaseMapper<SetmealDish> {
        
        
    }

业务层接▣SetmealDishService

package com.reggie.service;
    
    import com.baomidou.mybatisplus.extension.service.IService;
    import com.reggie.entity.SetmealDish;
    
    public interface SetmealDishService extends IService<SetmealDish> {
        
    
    }

业务层实现类SetmealDishServicelmpl

package com.reggie.service.impl;
    
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.reggie.entity.SetmealDish;
    import com.reggie.mapper.SetmealDishMapper;
    import com.reggie.mapper.SetmealMapper;
    import com.reggie.service.SetmealDishService;
    import org.springframework.stereotype.Service;
    
    @Service
    public class SetmealDishServicelmpl extends ServiceImpl<SetmealDishMapper, SetmealDish> implements SetmealDishService {
        
        
    }

控制层SetmealController

package com.reggie.controller;
    
    import com.reggie.service.SetmealDishService;
    import com.reggie.service.SetmealService;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.ibatis.annotations.Mapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @Slf4j
    @RestController
    @RequestMapping("/setmeal")
    public class SetmealController {
        
        @Autowired
        private SetmealDishService setmealDishService;
        @Autowired
        private SetmealService setmealService;
        
    }

### 新增套餐： ###

在开发代码之前，需要梳理一下新增套餐时前端页面和服务端的交互过程：

> 1、页面(backend/page/combo/add.html)发送ajax请求，请求服务端获取套餐分类数据并展示到下拉框中  
> 2、页面发送ajx请求，请求服务端获取菜品分类数据并展示到添加菜品窗口中  
> 3、页面发送ajx请求，请求服务端，根据菜品分类查询对应的菜品数据并展示到添加菜品窗口中  
> 4、页面发送请求进行图片上传，请求服务端将图片保存到服务器  
> 5、页面发送请求进行图片下载，将上传的图片进行回显  
> 6、点击保存按钮，发送ajax请求，将套餐相关数据以)json形式提交到服务端  
> 开发新增套餐功能，其实就是在服务端编写代码去处理前端页面发送的这6次请求即可。

在DishController中创建List方法，用于查询菜品

@GetMapping("/list")
    public R<List<Dish>> List(Dish dish){
        
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(dish.getCategoryId()!=null,Dish::getCategoryId,dish.getCategoryId());
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
        
        List<Dish> list = dishService.list(queryWrapper);
        return R.success(list);
    }

在SetmealService中创建方法saveWithDish，并在SetmealServiceImpl中实现，仿照之前代码，使用stream流，从中setmealDto读出ID，最后在SetmealController中调用方法完成保存

@Transactional
    @Override
    public void saveWithDish(SetmealDto setmealDto) {
        
        this.save(setmealDto);
    
        List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
        setmealDishes.stream().map((item)->{
        
           item.setDishId(setmealDto.getId());
           return item;
        }).collect(Collectors.toList());
    
        setmealDishService.saveBatch(setmealDishes);
    }

@PostMapping
    public R<String> save(@RequestBody SetmealDto setmealDto){
        
        setmealService.saveWithDish(setmealDto);
        return R.success("套餐保存成功！") ;
    }

### 套餐分页查询： ###

跟菜品分页查询几乎一模一样，此处跳过

@GetMapping("/page")
        public R<Page> page(int page, int pageSize, String name){
        
            log.info("接收到查询请求，page={}，pageSize={}，name={}",page,pageSize,name);
            //构造分页构造器
            Page<Setmeal> pageinfo=new Page<>(page,pageSize);
            Page<SetmealDto> setmealDtoPage = new Page<>(page,pageSize);
            //构造条件构造器
            LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper();
            //添加过滤条件
            queryWrapper.like(StringUtils.isNotEmpty(name),Setmeal::getName,name);
            //添加排序条件
            queryWrapper.orderByDesc(Setmeal::getUpdateTime);
            //执行查询
            setmealService.page(pageinfo,queryWrapper);
            BeanUtils.copyProperties(pageinfo,setmealDtoPage,"records");
    
            List<Setmeal> records = pageinfo.getRecords();
            List<SetmealDto> list = null;
    
            list = records.stream().map((item)->{
        
                SetmealDto setmealDto = new SetmealDto();
    
                BeanUtils.copyProperties(item,setmealDto);
    
                Long categoryId = item.getCategoryId();
                Category category = categoryService.getById(categoryId);
                if(category!=null){
        
                    String categoryName = category.getName();
                    setmealDto.setCategoryName(categoryName);
                }
    
                return setmealDto;
    
            }).collect(Collectors.toList());
    
            setmealDtoPage.setRecords(list);
    
            return R.success(setmealDtoPage);
        }

### 套餐删除： ###

需求分析

> 在套餐管理列表页面点击删除按钮，可以删除对应的套餐信息。也可以通过复选框选择多个套餐，点击批量删  
> 除按钮一次删除多个套餐。注意，对于状态为售卖中的套餐不能删除，需要先停售，然后才能删除。

在SetmealController中创建方法，并添加@PostMapping注解，传入参数为@RequestBody SetmealDto setmealDto

@DeleteMapping
    public R<String> delete(@RequestParam List<Long> ids){
        
        return null;
    }

在SetmealService中创建removeWithDish方法，并在SetmealServiceImpl中实现方法

@Override
        public void removeWithDish(List<Long> ids) {
        
            LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(Setmeal::getId,ids).eq(Setmeal::getStatus,1);
            int count = this.count(queryWrapper);
            if(count>0){
        
                throw new CustomException("套餐正在售卖中，无法删除！");
            }
            this.removeByIds(ids);
            LambdaQueryWrapper<SetmealDish> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(SetmealDish::getSetmealId,ids);
            setmealDishService.remove(queryWrapper1);
    
        }

### 短信发送： ###

创建utils包，拷入两个工具类

package com.reggie.utils;
    
    import com.aliyuncs.DefaultAcsClient;
    import com.aliyuncs.IAcsClient;
    import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
    import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
    import com.aliyuncs.exceptions.ClientException;
    import com.aliyuncs.profile.DefaultProfile;
    
    /**
     * 短信发送工具类
     */
    public class SMSUtils {
        
    
    	/**
    	 * 发送短信
    	 * @param signName 签名
    	 * @param templateCode 模板
    	 * @param phoneNumbers 手机号
    	 * @param param 参数
    	 */
    	public static void sendMessage(String signName, String templateCode,String phoneNumbers,String param){
        
    		DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "", "");
    		IAcsClient client = new DefaultAcsClient(profile);
    
    		SendSmsRequest request = new SendSmsRequest();
    		request.setSysRegionId("cn-hangzhou");
    		request.setPhoneNumbers(phoneNumbers);
    		request.setSignName(signName);
    		request.setTemplateCode(templateCode);
    		request.setTemplateParam("{\"code\":\""+param+"\"}");
    		try {
        
    			SendSmsResponse response = client.getAcsResponse(request);
    			System.out.println("短信发送成功");
    		}catch (ClientException e) {
        
    			e.printStackTrace();
    		}
    	}
    
    }

package com.reggie.utils;
    
    import java.util.Random;
    
    /**
     * 随机生成验证码工具类
     */
    public class ValidateCodeUtils {
        
        /**
         * 随机生成验证码
         * @param length 长度为4位或者6位
         * @return
         */
        public static Integer generateValidateCode(int length){
        
            Integer code =null;
            if(length == 4){
        
                code = new Random().nextInt(9999);//生成随机数，最大为9999
                if(code < 1000){
        
                    code = code + 1000;//保证随机数为4位数字
                }
            }else if(length == 6){
        
                code = new Random().nextInt(999999);//生成随机数，最大为999999
                if(code < 100000){
        
                    code = code + 100000;//保证随机数为6位数字
                }
            }else{
        
                throw new RuntimeException("只能生成4位或6位数字验证码");
            }
            return code;
        }
    
        /**
         * 随机生成指定长度字符串验证码
         * @param length 长度
         * @return
         */
        public static String generateValidateCode4String(int length){
        
            Random rdm = new Random();
            String hash1 = Integer.toHexString(rdm.nextInt());
            String capstr = hash1.substring(0, length);
            return capstr;
        }
    }

创建实体类User

package com.reggie.entity;
    
    import lombok.Data;
    import java.time.LocalDateTime;
    import java.util.Date;
    import java.util.List;
    import java.io.Serializable;
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableId;
    /**
     * 用户信息
     */
    @Data
    public class User implements Serializable {
        
    
        private static final long serialVersionUID = 1L;
    
        private Long id;
    
    
        //姓名
        private String name;
    
    
        //手机号
        private String phone;
    
    
        //性别 0 女 1 男
        private String sex;
    
    
        //身份证号
        private String idNumber;
    
    
        //头像
        private String avatar;
    
    
        //状态 0:禁用，1:正常
        private Integer status;
    }

依次创建Mapper/Service/ServiceImpl/Controller

package com.reggie.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.reggie.entity.User;
    import org.apache.ibatis.annotations.Mapper;
    
    @Mapper
    public interface UserMapper extends BaseMapper<User> {
        
    
    }

package com.reggie.service;
    
    import com.baomidou.mybatisplus.extension.service.IService;
    import com.reggie.entity.User;
    
    public interface UserService extends IService<User> {
        
    }

package com.reggie.service.impl;
    
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.reggie.entity.User;
    import com.reggie.mapper.UserMapper;
    import com.reggie.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    @Slf4j
    @Service
    public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
        
    
    }

package com.reggie.controller;
    
    import com.reggie.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @Slf4j
    @RestController
    @RequestMapping("/user")
    public class UserController {
        
        @Autowired
        private UserService userService;
    
    
    }

在UserController中创建sendMsg方法用于发送验证码

@PostMapping("/sendMsg")
    public R<String> sendMsg(@RequestBody User user, HttpSession session){
        
        String phone = user.getPhone();
        if(StringUtils.isNotEmpty(phone)){
        
            String  code = ValidateCodeUtils.generateValidateCode(4).toString();
            //调用api发送短信
            log.info("验证码为：{}",code);
            //需要申请签名，先跳过
            session.setAttribute(phone,code);
            return R.success("验证码发送成功！");
    
        }
        return R.error("验证码发送失败！");
    }

在UserController中创建login方法判断验证码是否正确，并在验证码正确后进行查询，若数据库中不存在此用户，则自动创建

@PostMapping("/login")
    public R<User> login(@RequestBody Map map, HttpSession session){
        
        String phone = map.get("phone").toString();
        String code = map.get("code").toString();
    
        Object codeInSession = session.getAttribute(phone);
    
        if(codeInSession!= null&&codeInSession.equals(code)){
        
            LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(User::getPhone,phone);
            User user = userService.getOne(queryWrapper);
            if(user==null){
        
                user = new User();
                user.setPhone(phone);
                user.setStatus(1);
                userService.save(user);
                log.info("用户{}注册成功！",user.toString());
            }
            session.setAttribute("user",phone);
            return R.success(user);
        }
    
        return R.error("");
    }