README .md · 小龙人/takeaway_project

# 一、外卖系统项目介绍

![img](imgs/96b3d8ef7b7d4907ad63d25697942c39.png)

**软件开发整体介绍：**

![img](imgs/a8253e0b900b4e4298defae46415e332-168930335687422.png)

![img](imgs/a97ba88752dd446ba1481027c0a1fa66.png)

![img](imgs/b7c5fad61b9f4669a9b30d061b28fbd0-168930342551432.png)

## 项目介绍：

首先我们介绍项目本身：

- 本项目是专门为餐饮企业(餐厅、饭店)定制的一款软件产 品，包括系统管理后台和移动端应用两部分。
- 其中系统管理后台主要提供给餐饮企业内部员工使用，可以对餐厅的菜品、套餐、订单等进行管理维护。
- 移动端应用主要提供给消费者使用，可以在线浏览菜品添加购物车、下单等。

再来介绍我们的开发计划：

- 本项目共分为3期进行开发
- 第一期主要实现基本需求，其中移动端应用通过H5实现，用户可以通过手机浏览器访问。
- 第二期主要针对移动端应用进行改进，使用微信小程序实现，用户使用起来更加方便。
- 第三期主要针对系统进行优化升级，提高系统的访问性能。

## 技术栈

![img](imgs/31696ef84ffc423a83056960ecf6f161.png)

## 功能架构（项目中所用到的全部功能）

![img](imgs/035335dd533b460492849d63e6efebdb.png)

## 角色（不同角色所对应的不同权限）

![img](imgs/558a0efd61734e859f59d90e72f2e7df.png)

# 二、开发环境搭建

## 创建项目对应的数据库

![image-20230714110340632](imgs/image-20230714110340632.png)

### 向数据库当中导入表结构

注1：我们只需要向db_takeaway库中导入该.sql文件即可把该项目所用到的所有的表导入到该reggie库当中了。

注2：注意该.sql文件不要放在中文的目录下，因为放在中文目录下的话会导入表失败。

通过上面的操作点击开始后，就能把.sql文件中的所有表结构和数据创建导入成功了（刷新一下）：

![image-20230714110446352](imgs/image-20230714110446352.png)

**对上面各个表解释：**

![image-20230714110528527](imgs/image-20230714110528527.png)

## maven项目搭建

创建的是maven形式的项目格式：

![image-20230714110625573](imgs/image-20230714110625573.png)

项目创建好之后，一定要注意检查项目的编码、项目maven仓库是否配置的是自己本地的仓库（如果不是本地的仓库，就设定成本地仓库）、jdk配置等。

上面的maven项目创建好并且检查完之后，我们就可以导入该项目所用到的所有maven坐标和yml配置属性了（上面创建的项目形式是maven形式而不是springboot形式的，但是在坐标中导入了springboot的坐标，因此还是springboot的项目）

## 导入maven坐标和yml属性配置

![image-20230714110649648](imgs/image-20230714110649648.png)

![image-20230714110816472](imgs/image-20230714110816472.png)

**当项目中的坐标和yml属性配置好之后，就说明项目已经连接配置好数据库了，因此我们就可以就行测试项目是否能启动成功了：**

![image-20230714110840732](imgs/image-20230714110840732.png)

**测试结果如下所示：（项目启动成功）**

![image-20230714110903648](imgs/image-20230714110903648.png)

## 项目能够启动成功后，导入前端资源：

注意：前端资源的数据一定要放在static静态资源的文件夹当中，如果不放在static静态资源的文件夹当中的话，springmvc就会把客户访问前端的路径拦截下来，因此就访问不到（就需要前面说过的springmvc拦截器了，就需要设定放行才能访问到该前端的路径）

![image-20230714110913783](imgs/image-20230714110913783.png)

**前端资源导入好之后，开启服务器进行访问前端backend文件夹当中的index.html页面：**

![image-20230714110943510](imgs/image-20230714110943510.png)

# 三、后台系统登录功能开发

## 需求分析

**首先我们如果后台想做一些登录的逻辑肯定要先有前端登录的页面，登录页面如下所示：**

**没有登录页面我们后台怎么拿到一些数据呢（比如一些前端登录时向后端请求的访问资源路径和一些登录时输入的用户名和密码，我们后端只有拿到了这些数据，才能向数据库进行校验判断前端用户是否能够登录成功）**

![image-20230714111003211](imgs/image-20230714111003211.png)

访问该登录页面login.html，所展示的登录页面样式如下所示：

![img](imgs/9bddaf0abdcc440c9f1a6adbc8759050.png)

**我们知道，我们后台现在还没有开始写登录的逻辑，我们后台肯定想知道前端用户点击登录后，向后台请求的资源路径是哪里呢：我们点击登录后可以按F12进行查看前端向后台请求的登录资源路径，因此我们后端也好在该路径下做一些逻辑判断是否让前端用户登录了：**

![img](imgs/d1f23588f1894ee5b25b15ca21ead7ae.png)

### **注意1：为什么前端在登录页面点击登录时会是以上面求访问资源路径的形式向后端发送访问请求呢：**

![image-20230714111122156](imgs/image-20230714111122156.png)

![image-20230714111140597](imgs/image-20230714111140597.png)

### **注意2：之所以这个后台登录功能没有写注册功能，是因为这个登录功能只能后台管理人员才能登录进入，不能随便让其他人就能够注册。**

### 注意3：身为后端开发人员，一定要看得懂前端页面的三个地方：

因为我们只有看懂了前端这三个地方的逻辑，那么我们后台就可以把逻辑处理的结果按照这三个地方的形式响应给前端，供前端使用（就相当于我们前面写的把后台处理的逻辑数据封装到Result对象的属性当中响应给前端，一些标识符、是否成功状态码什么的都是开发前，前端人员和后端人员商量好的）

![image-20230714111218924](imgs/image-20230714111218924.png)

## 代码开发

创建实体类Employee和employee表进行映射

**首先第一步：创建实体类Employee，和数据库表employee进行映射**。

也就是说，通过把前端用户输入的账号和密码封装到实体类的属性当中然后和数据库表进行校验，判断是否有该用户的存在，有的话就登录成功，没有的话就登录失败。

**第二步：创建mapper、contriller、service层 （数据层：mapper、service层基于mybatis-plus）**

mapper层、service层如下所示：

![image-20230714111249616](imgs/image-20230714111249616.png)

**思考：mybatis-plus是怎么知道我们操作的是哪张数据库表的呢：**

**是因为我们使用mybatis-plus时，数据层会有一个实体类泛型，该实体类的属性对应着哪张表的字段，就说明这个数据层操作的是哪张数据库表。**

EmployeeMapper：

![image-20230714111305763](imgs/image-20230714111305763.png)

EmployeeService：

![image-20230714111316422](imgs/image-20230714111316422.png)

EmployeeServiceImpl：

![image-20230714111328072](imgs/image-20230714111328072.png)

**表现层逻辑代码如下所示：**

注意1：我们在上面的笔记中知道，客户端在登录页面上点击登录按钮后，向后端请求资源的访问路径是：http：//localhost:8080/employee/login ，因此我们表现层的登录功能的路径就按照客户端的访问路径写。

```

/**
 *  表现层
 */
 
 
@Slf4j  // 开启日志 出bug好调试
@RestController // @Controller和@ResponseBody注解 （表现层bean注解和响应前端数据注解）
@RequestMapping(value = "/employee")  // 请求访问路径
//写成/employee的目的就是：刚才前端用户在登陆页面点击登录的时候(3.1需求分析),访问后台的资源路径为post请求..8080/employee/login
public class EmployController {
 
    /**
     *   自动装配业务层对象 （也可以说拿到业务层对象引用，然后调用业务层对象当中的增删改查等一些功能方法）
     */
    @Autowired
    private EmployeeServiceImpl employeeService;
 
 
    /**
     *  1、登录功能
     *
     *      注意1： 一定要保证前端以json数据格式请求/login路径下的资源的时候，要加上@RequestBody注解，
     *              并且一定要保证json请求数据格式体的属性名一定要和employee类当中的属性名一致，要不然实体类
     *              的属性当中就封装不到前端请求访问的资源数据。
     *              我们知道前端用户在登录页面点击登录按钮后，前端是以json格式的请求数据：（F12查看）
     *                                      password：“123456”
     *                                      username： “admin”
     *              向后端/login路径下请求资源的，因此我们一定要保证employee实体类当中的属性名也为password和username，
     *              那么前端请求的这些登录数据才能封装到后台的实体类当中，我们才能拿到前端的请求数据后做一些逻辑校验，判断
     *              用户是否可以登录成功。
     *
     *
     *      注意2： 使用 HttpServletRequest request的目的：将登录成功的员工id存入到Session域当中
     *
     */
    @PostMapping(value = "/login")
    public R login(HttpServletRequest request, @RequestBody Employee employee){ // json格式注解
 
        // 1、将客户端访问提交的密码password进行md5加密处理
        String password = employee.getPassword();   // 拿到了封装到Employee实体类属性中封装到客户端请求的数据（登录密码数据）
        password = DigestUtils.md5DigestAsHex(password.getBytes()); // 将客户端登录的密码进行md5加密,并且把加密后的密码赋给password变量
 
 
        // 2、根据页面提交的用户名username查询数据库中对应的该用户名的所有字段数据 （  用的方法是：springboot整合SSMP笔记当中的Lambda对象方式的条件查询  ）
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(Employee::getUsername, employee.getUsername());
        // 调用业务层的条件查询功能
        Employee one = employeeService.getOne(queryWrapper); // 这里和我们springboot整合SSMP笔记中有所区别，但是意思还是一样的，因为这里调用的是业务层
                                                            // 我们业务层因为也是用mybatis-plus写的，所以要遵守别人封装好的条件查询功能方法名getOne
                                                            // 其实意思都是通过客户提交的用户名，向数据库查询出该用户名对应的整条数据
 
        // System.out.println(one);    // 查询获取到了前端提供的用户名所对应的数据库中的整条数据,输出的结果如下所示
 
       /* Employee(id=1, username=admin, name=管理员, password=e10adc3949ba59abbe56e057f20f883e, phone=13812312312,
                sex=1, idNumber=110101199001010047, status=1, createTime=2021-05-06T17:20:07, updateTime=2021-05-10T02:24:09,
                createUser=1, updateUser=1)*/
 
 
        // 3、如果条件查询没有查询到结果，说明用户名不存在
        if (one == null){
            return new R("用户名不存在，登录失败");
        }
 
        // 4、到这里说明用户名存在，那么就用客户端输入的密码和该用户名在数据库中对应的md5处理后的密码进行校验
        // 注意：上面调用业务层的条件查询功能，查询出来用户名对应的数据库中的整条数据后，是封装到实体类Employee实体类属性当中了，
        // 因此我们直接在实体类的密码属性当中就能获取到客户端提供的用户名在数据库中对应的密码了，然后就能和客户端输入的密码进行比较了。
        if (! password.equals(one.getPassword())){
            return new R("密码错误，登录失败");
        }
 
        // 5、到这里说明用户名存在并且登录的密码也正确，那么我们就判断一下员工状态，如果为已禁用状态，则响应给客户端信息（0： 禁用  1： 启用）
        if (one.getStatus() == 0){
            return new R("账号已被禁用");
        }
 
        // 6、如果到了这里，就说明用户登录密码也正确，账号也没有被禁用，那么就将员工的id存入到Session域当中，并响应给客户端登录成功信息
        request.getSession().setAttribute("employee",one.getId());
 
        return new R(one,1);
        // 这里响应给前端的信息是上面条件查询出来的用户名整条数据，和成功状态码1
        // 之所以这样写的目的是：看login.html前端页面逻辑，拿到状态码为1的时候表示登录成功，并且跳转到index.html页面上，
        // 然后又用one中所有的数据进行逻辑的处理了
    }
}

```

**测试登录功能结果如下所示：**

**第一种结果**：**当客户端输入的用户名和密码都正确并且账号没有封禁时**

我们后端响应给前端输入的该用户名所对应的整条数据信息，并且响应给前端成功状态码1。

![img](imgs/b403034d6cb84ad0b9395c6dcba55ad0.png)

![img](imgs/16493dc729d747ce8b92126c65c78c8d.png)

在登录页面客户端点击登录按钮后（账户密码没有问题并且没有封禁的前提下），登录成功后跳转到了index.html页面，成功进入到了系统管理内部了。（这就是上面前端的逻辑了，所以这就是说我们必须要看懂前端的几个地方逻辑的原因）：

![img](imgs/198d9c186ba543b9bcf11e27d9392b8a.png)

**第二种：客户端输入的密码不正确的时候**

![img](imgs/2f26f4a3965d48a3bee966adda8f97f1.png)

**第三种**：**客户端的账号被封禁的时候**

![img](imgs/5130b68cff3a4d5e93ab85c43a862850.png)

## 补充：完善登录功能

![img](imgs/05afd0d7e9ed4df9b1bba422e459c286.png)

**重点：在springboot项目当中设定Filter过滤器的话，需要在启动类当中加上 @ServletComponentScan 注解**

### 问题分析

问题：

我们前端客户直接访问index.html路径下的资源不用登录一样能直接进入到该外卖项目的内部当中，那么这肯定是不安全的啊，我们肯定想让客户先登录后才能进入到外卖的项目内部，如果连登录都没有登录就能进入到里面了，那这个项目也太垃圾了，谁都能直接访问index.html路径到项目内部然后进行一些操作了。

![img](imgs/787223c36ed545b0890f5f2f3d734665.png)

问题解决思路：

因此我们后端就需要设定一个过滤器或者拦截器，在过滤器或者拦截器中判断用户是否已经登录过了，如果没有登录过就跳转到登录的页面上，让用户去登录去。（TM的登录都不登录还想进项目内部，你想啥呢）

我们这里就用Filter过滤器进行解决该问题（忘记怎么使用的话，看Filter过滤器笔记）

补充知识： 我们知道使用Filter过滤器的时候，我们拦截的路径如果是 "/*"的话，那么客户端请求访问的所有路径都会被拦截下来（也就是说客户端通过某个路径访问后端资源的时候先走Filter过滤器的代码），而且Filter过滤器也会把css、js、html这些资源都给拦截下来，所有页面上的画面什么的也都没有了，因此我们需要在Filter过滤器代码中把一些用到的css、js、html这些资源放行（也就是说不拦截）  【忘记的话看Filter笔记】

因此：当我们Filter拦截器配置的路径为 ： /* 的时候，客户端访问后端时所展示的效果如下所示（也就是上面说的什么都拦截掉了，甚至连css、html、js都拦截了，所以客户端以任何访问请求路径访问后端资源时，获取的是空白而已）

![img](imgs/92ae3628b1bf4c9ab3702317a9e86275.png)

因此，就需要我们放行一些css，html页面，放行一些客户端请求的资源路径和登录有关的路径，那么客户端才能访问到和登录功能有关的路径资源，那么就能够先登录了（不放行的话，客户端请求访问什么路径都是得到的一片空白了，那还怎么登录啊，因此需要把登录有关的路径放行掉，那么客户端才能够访问到登录有关的资源然后登录。）：
过滤器代码如下所示：

```

/**
 *  Filter过滤器
 *
 *      注1： 只要Filter的拦截路径是/* 那么客户端向后端请求访问的任何url路径都会先被拦截下来。
 *      注2： 在springboot项目中如果使用Filter 一定要记得在springboot类当中加上@ServletComponentScan注解
 */
 
@WebFilter("/*")
public class LoginCheckFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
 
        HttpServletRequest req = (HttpServletRequest) request;
        // 注意：Session中的调用getSession()方法的request是HttpServletRequest包下的request所以需要把
        // Filter包下的request转换成HttpServletRequest包下的request
 
        /**
         *  接下来的任务就是放行一些与登录功能有关的资源（如：登录页面html、css等）
         *  如果我们不放行的话，那么客户端当访问这些资源的时候，得到的响应是一片空白，那肯定是不行的。
         */
 
        // 第一步： 把和登录有关的资源路径都写在urls数组当中 （注意：这里最好路径写全，别用通配符 ** ）
        String[] urls ={
                "/employee/login",
                "/employee/logout",
                "/backend/page/login/login.html",
                "/front/**"
        };
 
        // 第二步： 判断客户端请求的访问路径是否在urls数组里
 
        // 获取当前客户端请求访问的资源路径
        String url = req.getRequestURL().toString();
        System.out.println(url); // 如：http://localhost:8080/backend/index.html
 
        for (String u: urls){   // 遍历urls数组里面的资源路径
 
            if (url.contains(u)){   // 如果客户端请求的访问资源路径包含了遍历urls数组里面的资源路径
 
                // 包含的话，放行即可（让客户端访问资源去吧，毕竟人家访问的资源路径和登录有关咱们也不拦截这个资源路径了。）
                chain.doFilter(request,response);
                return;
            }
        }
 
        // 注意：放行后的return结束的是for循环语句，结束后代码还会继续for同级往下执行
 
        /**
         * 如果上面的urls数组都遍历完了，并且判断客户端请求的访问资源路径都没在urls数组（我们设立的放行资源数组）当中，
         * 那么就需要进行一些判断了：
         *
         *      我们知道在登录功能中，登录成功后我们把员工id存放到Session域当中了，那么我们这里就可以判断Session域当中
         *      是否能取到对应的储存的员工id数据：
         *          能取到的话说明客户端确实登录成功了，那么既然客户端登录过了，那么我们就放行客户端请求的这次访问资源路径就可以了（毕竟人家都登陆成功了，任何资源都让他访问就行了）。
         *          不能取到的话，说明客户端还没有登录过，那么我们就让客户端先登录去。
         */
 
        // 1、判断Session域当中是否有数据 （数据：登录功能登录成功时存储在Session域当中的员工id）
        Object o = req.getSession().getAttribute("employee");   // 通过key获取Session域当中的数据
 
        if (o !=null){
            // 不为null，说明客户端之前登录过（要不然Session域当中不会储存数据），那么我们就放行客户端这次向后端请求的路径访问资源就行了，
            // 人家登录过了，你还拦着人家不让人家访问干啥
            chain.doFilter(request,response);
            return;
        }
 
        else {
            // Session域当中数据为null，说明客户端就没有登录过，所以让他回去登录去，登录都没有登录你还想访问其他的资源想毛呢。
            // 通过输出流方式向客户端页面响应数据
 
            response.getWriter().write(JSON.toJSONString(new R("NOTLOGIN",0)));
        }
 
    }
}
```

**代码解释**： 为什么响应给前端的数据是 new R（"NOTLOGIN",0）;

![image-20230714111520712](imgs/image-20230714111520712.png)

设定好Filter过滤器之后，客户端再次访问index.html页面时，结果如下所示：（会发现就自动跳转到登录页面先让登录了。这就是过滤器Filter的魅力所在）

![img](imgs/bc8d1697e9e2434499b7173372c9c2ed.png)

# 四、后台退出功能开发

![img](imgs/7a73de94b3394998a6ff30e49ac71f43.png)

## 需求分析

![img](imgs/33059b151b9f4c158c5428f38e2297d0.png)

我们知道点击此退出系统按钮后，客户端是会向后端发送一个资源访问请求路径的：

![img](imgs/a67febac506848c6b2ee8b4f9afd2a53.png)

## 代码开发

因此我们后台只需要在表现层根据前端点击退出按钮后发送的访问请求路径下，做一些处理逻辑即可，处理的逻辑如下所示：

![img](imgs/f2f9fddf19594fcc87ec65f20f44b305.png)

表现层代码如下：

```
    /**
     *  2、退出功能
     *
     *      注1：我们知道客户端点击退出按钮后向后端请求的访问路径为post形式：http://localhost:8080/employee/logout ，因此我们后台的资源路径就按照这个写即可
     *      注2：客户端点击退出按钮的时候，是没有向后端提供任何参数请求数据的，因此我们后端也没必要用参数接收客户端请求的数据，
     *      因此我们这里只需要用一个request参数即可，因为我们需要清空Session域当中保存的登录成功的用户名id
     *
     */
 
    @PostMapping(value = "/logout")
    public R logout(HttpServletRequest request){
 
        // 清理登录成功时存储在Session域当中的用户id
        request.getSession().removeAttribute("employee");   // 通过key键删除登录功能登录成功
                                       // 时存储的用户id值（value值）
        return new R("退出成功",1);
    }
 
}
```

**之所以响应给前端1字符码的原因如下所示：（因此退出成功后，就会帮我们自动跳转到了登录的页面上）**

![img](imgs/8f9e008fd70747bcb61c41b6cd23b227.png)

**并且我们也会发现，当用户登录功能登录成功时存储在Session域当中的用户名id也清理成功了：**

![img](imgs/f6a8f108f43f4b8db99e727ed0529a9a.png)

![img](imgs/c30749ec1d2f48a596ae4922417c5373.png)

# 五、员工添加功能管理系统开发

![img](imgs/75b945062950469aa84c2c6297ef42c2.png)

员工管理系统样式如下所示：

![img](imgs/7303d5c72b9746a48e391fd35d672b22.png)

## 需求分析

点击添加员工按钮时的样式如下所示（跳转到下面样式的页面上）：

![img](imgs/e50c62c787a346f691db1040466d7219.png)

## 数据模型

也就是说：上面分析中，保存员工信息，保存到哪张数据表当中。

![img](imgs/cd94b752d4fa494599fdc35623fd742d-168930488890995.png)

## 代码开发

![img](imgs/b3e9ab57d5f347db9e8776299757971c.png)

注1： 我们前面已经知道，实体类Employee属性名和数据库的字段名是一致的。

注2： 一定要保证客户端请求保存的JSON数据格式属性名要和实体类的属性名一致，要不然客户端请求的资源数据封装不到实体类的属性当中。

总体代码如下所示：

初始化这些前端没有传递的字段数据的原因还有：因为数据库当中有这些字段，如果前端没有传递这些字段的数据，并且我们也没有初始化这些字段数据的话，那么就会报错（因为数据库中有这些字段啊，并且这些字段设定的不能为null了，如果不初始化一些数据的话就会出错了，所以必须为这些前端没有传递的字段数据初始化值）

```
 /**
     *  3、新增员工功能
     *
     *      // 我们知道客户端请求新增员工功能时，是以JSON数据格式请求的，因此我们需要加上 @RequestBody 注解
     *      // 一定要保证json请求数据格式体的属性名一定要和employee类当中的属性名一致，要不然实体类的属性当中就封装不到前端请求访问的资源数据。
     */
    @PostMapping
    public R save(HttpServletRequest request,@RequestBody Employee employee){ // 前端请求的JSON资源数据，封装到了Employee实体类的属性当中了。
        // System.out.println(employee);
       /**
        *  我们知道：前端用户添加员工信息的时候，只添加了：账号、员工姓名、手机号、性别、身份证号。
        *   而我们数据库的字段名当中还有createTime、updateTime、createUser、updateUser、password这些字段。 （status字段数据库默认为1了）
        *   因此我们总不能让这些数据库中还有的这些字段名为null吧，（因为数据库中设定好了不能为null的属性，如果为null的话就会报错了）。因此我们可以在这里为这些客户端没有添加的字段数据设定一下初始化数据。
        *
        * Employee(id=null, username=daaa, name=a, password=null, phone=13523180000, sex=1,
        *       idNumber=000000000000000000, status=null, createTime=null, updateTime=null, createUser=null, updateUser=null)
        */
 
        // 设置初始化密码123456（md5加密处理）
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
        // 设置创建时间
        employee.setCreateTime(LocalDateTime.now());    //  LocalDateTime.now() 系统当前时间
        // 设置修改时间
        employee.setUpdateTime(LocalDateTime.now());
        // 记录谁添加的员工信息 （谁登录的该项目系统，肯定就是谁添加的员工信息，那么只需要把登录时存放到session域当中的登录人员id取出来，设置到实体类的createTime属性中即可）
        Object o = request.getSession().getAttribute("employee");
        employee.setCreateUser((Long) o);
        employee.setUpdateUser((Long) o);
 
 
        /**
         *  然后后台employee实体类的属性当中封装到了前端请求的资源数据的时候，
         *  并且把一些字段设定成初始化值后（其实不设定也没什么问题，只是为了让数据库中的每个字段都有数据，好记录而已）
         *  不设定的话同样可以把客户端请求的资源数据保存到数据库当中，只不过没有封装的实体类属性数据所对应的数据库字段数据为null而已。
         *
         *  就可以调用业务层的添加功能让员工信息添加到数据库当中了。
         */
 
        // 调用业务层的添加功能，将员工信息添加到数据库当中。
        employeeService.save(employee);
        return new R("添加成功");
    }
```

![img](imgs/ee951527e5df4b29a34dc82efa323339.png)

![img](imgs/c6bef77578d9479998d790b8e0cfc2d2.png)

### 添加功能优化（异常处理）

问题： 我们知道数据库当中username字段我们已经设置成unique唯一了，也就是说数据库当中的username字段的数据是唯一的了，当我们再次添加一个username字段数据和数据库当中已经添加过的username字段数据一致的时候，那么因为设置了唯一标识，因此就会报错了。

![img](imgs/8cd7d1add83d4f96a6b3eb95c35cdfec.png)

![img](imgs/9c757aa4263e47b7a759667123ac416e.png)

![img](imgs/9c757aa4263e47b7a759667123ac416e-1689304940198108.png)

![img](imgs/5529b327f306469b8c0baf08ec5b455e.png)

**我们使用第二种：异常处理器方式 （忘记的话看笔记）**

**思路： 就是当我们项目中出现异常的时候，我们的异常处理器就可以捕获到该异常信息，然后运行异常处理器当中的方法，响应给前端客户一些提示信息。**

![img](imgs/b212dade05154ab0b0dbfab01a809808.png)

用异常处理器处理好异常之后，当客户端再次以相同的账户向数据库当中储存数据的时候（数据库账户字段设定的是唯一的unique，因此不能重复储存相同的数据）：客户端就不会收到异常信息了，而是收到我们异常处理器当中捕获到该异常的方法中响应给客户端的信息

![img](imgs/7c29e60b86fc4df69e6eb1bc01b40043.png)

# 六、员工信息分页查询

![img](imgs/f50c62642fda4bd594c1e81670462873.png)

## 需求分析

![img](imgs/3a4ae760646d4cd7bd138098ce800e20.png)

## 代码开发

![img](imgs/32b5bef4836043d880f624e32bb4545f.png)

在项目员工管理中，我们可以看到前端用户是向后端发送了请求分页查询的资源路径的，请求路径格式如下所示：

![img](imgs/090ebf80574a4db0b4c6d9e09d5b10c7.png)

注意：springboot分页查询需要设定一个分页查询拦截器（要不设定的话，尽管调用的是分页查询的功能，但是却拿到的是数据库中的全部数据信息），这个分页查询拦截器的写法是固定的。忘记的话就看springboot整合ssmp的笔记中的分页查询。

因此第一步：设定分页查询拦截器

![image-20230714112322660](imgs/image-20230714112322660.png)

第二步：在表现层接收客户端发送的请求分页查询资源，进行一些逻辑处理：

我们知道前端页面发送的请求分页查询访问路径有两种形式：

第一种：

![img](imgs/e3b799ea03a04c469d73a0f3d2c1493b.png)

第二种：

![img](imgs/bc0dc45eeae54bcba54cca5c8bc1edc7.png)

因此总结：

通过上面两种的可能，我们后端可以直接设定三个参数（page、pageSize、name）用来接收客户端发送的请求资源。 当客户端没有进行模糊条件查询时，我们后台设定的这三个参数只接收前端发送的page、pageSize资源然后进行分页查询即可（name为null没有影响），而当客户端进行模糊条件查询的时候，我们后台的这三个参数都接收然后进行分页查询即可，只不过这次的分页查询是按照名字模糊查询出来的结果后进行分页查询的（还是按照page、pageSize 进行分页的）。

再次总结： 其实分页构造器（limit）和条件构造器（where、like等）的目的都是拼接sql语句，如：假如我们在代码逻辑中使用到了分页构造器，那么我们的sql语句就相当于多了一个limit分支，没有这个分页构造器的话，也就意味着sql语句中没有这个limt分支而已，并不会报错，并且分页构造器和条件构造器是可以一起使用的，一起使用的话相当于sql语句中多了limt分支和where或者like等分支而已。

总体代码如下所示：（下面的两个构造器，也可以理解为分页查询和条件查询功能写在一起了。）

```
/**
	 * 员工信息分页查询
	 *
	 * @param page
	 * @param pageSize
	 * @param name
	 * @return
	 */
	@GetMapping("/page")
	public R<Page> page(int page, int pageSize, String name) {
		log.info("page={},pageSize={},name={}", page, pageSize, name);
		// 构造分页构造器
		Page pageInfo = new Page(page, pageSize);
		// 构造条件
		LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
		queryWrapper.like(StringUtils.isNotEmpty(name), Employee::getName, name).or()
				.like(StringUtils.isNotEmpty(name), Employee::getUsername, name);
		// 添加排序
		queryWrapper.orderByDesc(Employee::getUpdateTime);
		// 执行查询
		employeeService.page(pageInfo, queryWrapper);
		return R.success(pageInfo);
	}
```

结果如下所示：

当客户端没有进行模糊条件查询时，进行了分页查询：

![img](imgs/73f12ccbac1d4035bc4e0b5a5a12ce5b.png)

当客户端进行模糊条件查询时，进行了分页条件查询：

![img](imgs/1df7e8488ad748f28370772395ad92aa.png)

# 七、启用/禁用员工账号

![img](imgs/687b738fc9044e65b14fb7245bd8cbee.png)

## 需求分析

![img](imgs/1cc11a31a10b4ca1bf166b4a24c303d2.png)

补充细节：

我们这里有一个细节，也就是当用户是admin登录该系统的时候，才可以进行启用/禁用的操作，而当其他用户登录该项目系统的时候，是不可以进行启用/禁用操作的，只有admin用户有这个启用/禁用操作的权限。

![img](imgs/4ea873e254b04ae59f8d8168d72608a4.png)

## 代码开发

![img](imgs/03fdba7cfa784b8285b8cee900811365.png)

### **问题：代码开发前有个问题（精度损失问题）需要先处理：**

我们知道数据库当中的id是通过雪花算法进行自动分配的id数值，而不是通过自动增长帮我们生成的id数值，使用雪花算法的方式是有精度损失的，问题如下所示：

![img](imgs/d2fe150494284f6cbe2b0a8ec30dccf5.png)

前端发送的id如果和数据库中对应的id数据不一致的话，就会导致后台在数据库当中无法通过id字段修改数据(也就是说，没办法修改账户状态status的数据了~)。

![img](imgs/b7275d5112bd4adb98160cb7f9bb7472.png)

![img](imgs/d2fe150494284f6cbe2b0a8ec30dccf5-1689305138800145.png)

**具体实现步骤（两个步骤）：**

![img](imgs/dde2ab39cc6a4cb1816a47804b98c121.png)

![image-20230714112608161](imgs/image-20230714112608161.png)

**对象转换器类：**

JacksonObjectMapper

```
package com.xiaolong.takeaway.common;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import org.springframework.stereotype.Component;

import java.math.BigInteger;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
@Component
public class JacksonObjectMapper extends ObjectMapper {

public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

//反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))

.addSerializer(BigInteger.class, ToStringSerializer.instance)
                .addSerializer(Long.class, ToStringSerializer.instance)
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

//注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

```

**扩展MVC消息转换器**：

```
    /**
     * 扩展MVC消息转换器
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("扩展消息转换器");
        // 创建消息转换器
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        // 设置对象转换器，底层使用Jackson将Java对象转为json
        messageConverter.setObjectMapper(new JacksonObjectMapper());
        // 将上面的消息转换器对象追加到MVC框架的转换器集合中
        converters.add(0,messageConverter);
    }

```

***\*注意：如果出现404的报错问题的话：\****

***\*扩展消息转换器类用实现 WebMvcConfigurer，别用继承WebMvcConfigurationSupport，要不然会出现下面的bug问题：（访问其他的好好的业务功能前端页面直接显示404问题）\****

![img](imgs/e3363de235924b80b726dbea944f5d01.png)

**通过设定的上面两个步骤后，雪花算法精度损失问题就解决了。**

我们知道前端通过id修改员工账户状态的时候，传递过来的请求数据如下所示：

![img](imgs/94462da8b1dc4296913554b8821cd373.png)

表现层代码如下所示：

总体思路：

就是通过Employee实体类把客户端请求的修改员工账户状态的id和处理过的账户状态（如：已经把原来员工的账户状态1修改成0了，也就是说点击启用的时候，前端已经把账户状态从0变成1了。 0表示：已禁用、1表示：正常）封装到实体类的属性当中，然后我们知道实体类当中有很多属性呢：如修改人属性、更改时间属性、因此虽然客户端没有为这些属性传值，但是我们可以手动记录一下这是谁修改的等，最后我们就可以调用业务层的通过id修改功能了。最终由mybatis-plus拿到我们传递的实体类后，它就可以对封装到实体类属性当中的数据拿出来进行sql处理了。

```
/**
	 * 根据ID去修改员工信息
	 *
	 * @param request
	 * @param employee
	 * @return
	 */
	@PutMapping
	public R<String> update(HttpServletRequest request, @RequestBody Employee employee) {
		long id = Thread.currentThread().getId();
		log.info("线程ID为：{}", id);
		// 获取员工ID
		// Long empId = (Long) request.getSession().getAttribute("employee");
		//employee.setUpdateTime(LocalDateTime.now());
		//employee.setUpdateUser(empId);

employeeService.updateById(employee);

return R.success("员工信息修改成功");
	}

```

![img](imgs/4a2ca4d916b14e0f840d7bdc7cd98532.png)

![img](imgs/959268a264ba4a88b8cce79d1fd62e80.png)

禁用后，我们看后端会发现君哥的帐号状态status字段确实变成0了（总的来说就是通过前端传递的君哥的id修改的君哥的账户状态status）：

![img](imgs/69a7c4d7ac774ef1a4d8b8fd51163f85.png)

![img](imgs/2dbe5b159b1e4393965328a14c93c624.png)

![img](imgs/dae2f37efd8c40cfa43f634e576368ed.png)

# 八、编辑员工信息

![img](imgs/c7d1371b862a4235ac9d14da2469e08a.png)

## 需求分析

![img](imgs/dda23f754eaa463fac7895bf7a7851da.png)

## 代码开发

数据回显
： 也就是说前端用户通过点击编辑按钮后，通过携带员工信息的id向后端发送get请求，然后后端通过拿到请求的id后，可以通过id对数据库中的该id对应的数据进行查询，把该id对应的整条员工数据先查询出来然后响应给前端，最后前端拿到响应的数据后进行数据回显。（数据回显的形式如上面8.1中的形式，数据显示出来了）

![img](imgs/3a6eced71f30435ab396a4fe6bb883d8.png)

表现层代码如下所示：

/**
    	 * 通过id查询员工信息 (把查询出来的员工信息响应给前端，前端把数据回显在页面上
    	 * 步骤： 第一步：获取客户端传递的id
    	 * 		第二步：获取到客户端传递的id后，通过调用业务层通过id查询数据，把该id对应的员工数据全部查询出来
    	 *     第三步：数据查询出来后，响应给前端，前端接收到响应后进行数据回显操作。
    	 * 		
    	 * 客户端点击编辑按钮后向后端发送的get请求如：http://localhost:8080/employee/1564536166675939329
    	 * 因此我们该如何获取到该客户端发送的请求中携带的员工id呢？
    	 * 通过@Pathvariable占位符获取该请求id。（因为前端是以REST风格进行发送的，所以url上的id需要通过占位符获取,忘记的话看Restful笔记）
    	 * 注意：这个客户端传递的id是long型的。（因为数据库中的id就是long类型的）
    	 *
    	 * @param id
    	 * @return
    	 */
    
    	@GetMapping("/{id}")
    	public R<Employee> getById(@PathVariable Long id) {
    		log.info("根据ID查询员工信息");
    		Employee employee = employeeService.getById(id);
    		return R.success(employee);
    	}

前端拿到后台查询的数据和成功标识符后，就可以进行回显操作了：

![img](imgs/94a9fac0a841420987e28b7ab18b15fe.png)

回显数据如下所示

![image-20230714112732371](imgs/image-20230714112732371.png)

回显成功后，我们就可以对上面的一些数据进行修改了，修改完之后点击保存即可修改成功（之所以能够修改成功，是因为点击保存后前端向后台发送的请求是后端第五个功能：通过id修改员工信息功能，通过把修改后的员工信息封装到Employee实体类当中然后调用业务层的修改功能，最终就修改成功了。）

# ======分类管理======

# 九、公共字段自动填充

## 问题分析

总的来说、就是一句话：

当客户端访问添加功能或者修改功能的时候，这些数据库中对应的创建时间、创建人、修改时间、修改人等字段数据，当前端没有为这些字段传递数据的时候，我们后端不再手动为这些字段初始化数据了，直接让mybatis-plus填充功能帮我们自动初始化这些数据。

![img](imgs/bb0e8ae47e4c40f3bb727001b1642a34.png)

## 代码实现

![image-20230714112809386](imgs/image-20230714112809386.png)

![img](imgs/fe4d0554db4541e88043657556eb5572.png)

再次理解一下这个公共字段自动填充到底是干啥的：

首先我们看数据库中的字段（也就是说框起来的字段我们在设计表的时候字段类型设置了不能为null）：

![img](imgs/20bc54c66a5a42369f2e0b87068dda2f.png)

但是呢：前端用户向后端请求添加员工功能的时候，传递过来的数据没有上面框起来的四个字段的数据：

![img](imgs/a953b194a9fa47f4ac93d5405bcb176e.png)

因此我们知道，后台我们的数据库中有九个字段，客户端有四个字段的数据没有传递，我们知道客户端没有传递的这四个字段类型是不能为null的，既然客户端没有为这四个字段传递数据，那么前端传递的五个字段数据是肯定插入不到数据库表当中的，肯定会报错（因为向数据库表中插入数据的时候必须要保证数据库的九个字段都有数据）。

因此为了解决客户端没有传递的这四个字段数据，我们后端就初始化手动为该四个字段赋值了：

赋上值后，我们知道实体类属性当中拿到前端传递的五个字段数据后再加上我们手动赋值的四个字段数据，刚好满足数据库表中的九个字段数据了，那么肯定就能把客户端请求的添加员工信息插入到数据库当中了（毕竟sql语句不会出错了因为九个数据都有了，肯定就能插入成功了）。

![img](imgs/4e8f54022cf64bf880d34fbb23e7036a.png)

现在我们使用mybatis-plus的自动填充功能目的就是：解决上面手动初始化字段值的问题。

也就是说，我们手动赋值的四个字段数据不再用代码写了，用mybatis-plus的自动填充功能帮我们写，其意义还是和我们上面手动为四个字段数据赋值是一样的。

**mybatis-plus的自动填充代码实现：**

**第一步**：在和数据库表对应的实体类属性上加上@TableFiled注解，并且指定上是在添加功能时还是修改功能时为其字段赋值或者修改值。

**分析该类上加上注解的作用：**

就是只要哪个属性当中加上的有@TableField注解，那么这些加上该注解的属性就能自动填充数据，属性上加上的有fill = FieldFill.INSERT注解的属性 意味着当客户端向后端访问添加功能的时候，并且客户端没有对这个属性对应的数据库中的字段传数据的时候，那么mybatis-plus就会自动为这个属性（数据库字段）填充值（赋值）。

fill = FieldFill.INSERT_UPDATE 意味着当客户端访问添加功能或者修改功能的时候，并且客户端没有对这个属性对应的数据库中的字段传数据的时候，那么mybatis-plus就会自动为这个属性（数据库字段）填充值（赋值）、修改功能的话就会把上次那个值覆盖掉然后重新填充值。

package com.xiaolong.takeaway.entity;
    
    import com.baomidou.mybatisplus.annotation.FieldFill;
    import com.baomidou.mybatisplus.annotation.TableField;
    import lombok.Data;
    import java.io.Serializable;
    import java.time.LocalDateTime;
    
    /**
     * 员工实体类
     * @author xiaolong
     * @date 2023/6/5
     */
    @Data
    public class Employee implements Serializable {
    
        /** 序列号*/
        private static final long serialVersionUID = 1L;
    
        /**唯一主键*/
        private Long id;
    
        /**用户名*/
        private String username;
    
        /**姓名*/
        private String name;
    
        /**密码*/
        private String password;
    
        /**电话*/
        private String phone;
    
        /**性别*/
        private String sex;
    
        /**身份证号码*/
        private String idNumber;
    
        /**状态*/
        private Integer status;
    
        /**创建时间*/
        @TableField(fill = FieldFill.INSERT)// 配上FieldFill.INSERT 意味着 当客户端访问添加功能并且客户端没有为该属性传数据的时候，就用mybatis-plus自动填充该数据
        private LocalDateTime createTime;//该属性字段对应的数据库中的create_time 创建时间字段（创建时间在添加的时候填充一次就可以了，修改的时候不用再填充了）
    
        /**更新时间*/
        @TableField(fill = FieldFill.INSERT_UPDATE) // 配成FieldFill.INSERT_UPDATE 意思是：当客户端访问添加功能或者修改功能的时候，都会为该对应的数据库中的字段填充值
                                                    // （当是修改功能的时候，代表的就不是赋值了，代表的是修改值，也就是说把以前数据库中对应的该字段的数据覆盖掉重新赋上我们定义的值）。
        private LocalDateTime updateTime; // 对应的是数据库表中修改时间字段
    
        /**添加用户时使用*/
        @TableField(fill = FieldFill.INSERT) 
        private Long createUser;// 对应的是数据库表中的创建人字段
    
        /**更新用户时使用*/
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Long updateUser;  // 对应的是数据库表中的修改用户字段
    }

因为就上面四个字段前端基本上不传递数据，因此我们就在这四个字段上加注解进行配置。

第二步：指定好之后，设定为第一步该字段赋值的数据

分析这个类的作用：

该类的作用就是该类有两个方法，一个是添加功能时的方法，另一个是修改功能的方法，意义就是为第一步设定注解的属性赋值（也就是说为第一步实体类的属性设定填充的值），第一步实体类属性当中有fill=FileldFill.INSERT注解的，就在该类的添加功能当中为第一步的添加属性赋值

```
package com.xiaolong.takeaway.common;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;

/**
 * 自定义元数据对象处理器
 */
@Component
@Slf4j
public class MyMetaObjecthandler implements MetaObjectHandler {
    /**
     * 插入操作，自动填充
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("公共字段自动填充[insert]...");
        log.info(metaObject.toString());
        metaObject.setValue("createTime", LocalDateTime.now());
        metaObject.setValue("updateTime",LocalDateTime.now());
        metaObject.setValue("createUser", BaseContext.getCurrentId());
        metaObject.setValue("updateUser", BaseContext.getCurrentId());
    }

/**
     * 更新操作，自动填充
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("公共字段自动填充[update]...");
        log.info(metaObject.toString());

long id = Thread.currentThread().getId();
        log.info("线程id为：{}",id);

metaObject.setValue("updateTime",LocalDateTime.now());
        metaObject.setValue("updateUser",BaseContext.getCurrentId());
    }
}

```

因此通过上面的两个步骤后，我们就可以把表现层中手动为属性初始化值的操作注释掉了：

也就是说上面两个步骤代替了下面我们手动为属性初始化赋值的操作（更高级了）

![img](imgs/8241e342f7314392af92b201253ae138.png)

修改功能中初始化值的方法也可以注释掉了：

![img](imgs/e4cb9d37d7234a048ce02a0e7af88e4e.png)

## 解决第二步中无法获取session域当中数据问题

问题分析：

我们以前用老方法set设定创建人/修改人属性的时候，我们设定的是session域当中的employee对应的数据：

![img](imgs/6f52e844ff604fd4bf2eb819df3e8266.png)

而第二步当中为其属性赋填充值的时候，无法获取到request域（因为在第二步的MyMetaObjectHandler类当中是不能获取HttpSession对象的），因此没有办法为其赋session域当中的数据：

![img](imgs/aeee06601d75496283cd504eb56a4557.png)

因此我们有什么办法解决上面的问题呢（如何能够在9.2第二步骤中为其属性赋上session域中的数据呢）？

我们可以使用ThreadLocal来解决此问题，它是JDK中提供的一个类。

### 解决问题：ThreadLocal

首先我们要知道：

![img](imgs/2e3173d97b72435cacbcd013e4938372.png)

因为上面三个地方的方法中是同一个线程了，所以我们可以通过ThreadLocal线程的常用方法，set、get方法设置一些局部变量的值（一个地方set设定封装到值，另一个地方get取数据）：

（也就是说：因为客户端请求的资源路径，是先进入到拦截器的，然后进入到表现层的功能当中，我们知道了ThreadLocal线程在上面的上个地方的方法当中是同一个线程了，因此我们可以在表现层的update方法中，通过ThreadLocal线程的set方法把储存在session域当中的登录员工数据封装到ThreadLocal的储存空间中，然后再在mybatis-plus自动填充的第二步类当中的updatefill方法中（注意有updatefill方法是和那两个玩意同一个线程）通过ThreadLocal线程的get方法把刚才封装到ThreadLocal储存空间中的数据取出来就可以了，最后就可以填充session域当中的数据了。）

![img](imgs/8d325b8a320a45bf90edd6bb91a3a09c.png)

代码实现步骤如下所示：

![img](imgs/63e6b7a1870445e48c37a42a5b9db40a.png)

再次注意：只有在拦截器的doFilter方法、表现层的update方法、填充类的updateFill方法中的线程是同一个，才能够在这三个方法中get、set，其他方法中就不是同一个线程了，就get/set不到数据了。

第一步：编写BaseContext工具类：

```
package com.xiaolong.takeaway.common;

/**
 * 基于ThreadLocal封装工具类，用户保存和获取当前登录用户id
 */
public class BaseContext {
    private static ThreadLocal<Long> threadLocal = new ThreadLocal<>();

/**
     * 设置值
     * @param id
     */
    public static void setCurrentId(Long id){
        threadLocal.set(id);
    }

/**
     * 获取值
     * @return
     */
    public static Long getCurrentId(){
        return threadLocal.get();
    }
}

```

第二步：在表现层的update方法中把session域当中的数据封装到ThreadLocal线程的储存空间中：

![img](imgs/059ffc253d61449c9d8808e6b52cdbd6.png)

第三步：在mybatis-plus自动填充类当中获取ThreadLocal线程储存空间中封装的session数据：

![img](imgs/29762dc80d334df8b9aae66e02758764.png)

注意：

![img](imgs/c444863ebda54af19d103fca254b2daa.png)

# 十、分类管理----新增分类

![img](imgs/f039e529028540b1b1e163733bd66ba4.png)

##  需求分析

![img](imgs/c100f1d651a2404c90dbe1a4de96c0e8.png)

![img](imgs/c60e83c4640a4449ad57f62f3b53bcae.png)

## 数据模型

![img](imgs/37fd3af80ce244348db88a76f7c71880.png)

## 代码开发

因为从新换数据库表了（换成category数据库表了），也就是说重新做一些逻辑了，因此在开发之前首先要先把架子搭起来，先把映射数据库字段名的实体类、表现层、业务层、数据层骨架搭出来（和分类管理上面的员工管理的增上改查的过程其实还是一样的，只不过这个处理的是category表，上面那个是employee员工表。）。

![img](imgs/563b2d65bd054ed3afbe6ef4258ec2c1.png)

注意：一定要保证实体类Category的属性和分类管理category数据库表的字段名保持一致：

只有一致了才能将数据封装到实体类当中，然后映射到数据库的字段上，如果不一致那就映射不到数据库对应的字段上，那么数据就进入不到数据库当中了。

![img](imgs/2a7c2aa5bc5a488f9e33471ed629cf09.png)

然后再把基于mybatis-plus的数据层和业务层和表现层骨架先搭出来（也就是说一切重新开始了，而且开始的过程和做员工管理的项目过程是一摸一样的。）：搭建的过程和3.2笔记中的员工管理时的搭建过程是一样的。

![img](imgs/4de2c4f8b7e54f719c29531df8e1477f.png)

骨架做好之后，我们表现层就可以接收前端用户传递的请求数据，然后进行一些逻辑操作了：

前端向后端发送的请求如下所示：

![img](imgs/4b6efb916a224f548503a6ac94ed271d.png)

![img](imgs/360f994f39904a10bda99afdbc20795a.png)

代码如下所示：

package com.xiaolong.takeaway.controller;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.xiaolong.takeaway.common.R;
    import com.xiaolong.takeaway.entity.Category;
    import com.xiaolong.takeaway.service.CategoryService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    /**
     * @author xiaolong
     * @date 2023年05月06日 21:47
     */
    @RestController
    @Slf4j
    @RequestMapping("/category")
    public class CategoryController {
    
    	@Resource
    	private CategoryService categoryService;
    
    	/**
    	 * 新增分类
    	 *
    	 * @param category
    	 * @return
    	 */
    	@PostMapping
    	public R<String> save(@RequestBody Category category) {
    		log.info("category:{}", category);
    		categoryService.save(category);
    		return R.success("新增分类成功");
    	}
    
    	@GetMapping("/page")
    	public R<Page> page(int page, int pageSize) {
    		// 分页构造
    		Page<Category> pageInfo = new Page<Category>(page, pageSize);
    		// 查询并排序
    		LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper();
    		queryWrapper.orderByAsc(Category::getSort);
    		// 分页查询
    		categoryService.page(pageInfo, queryWrapper);
    		return R.success(pageInfo);
    	}
    
    	@DeleteMapping
    	public R<String> delete(Long ids) {
    		// categoryService.removeById(id);
    		categoryService.remove(ids);
    		return R.success("分类信息删除成功");
    	}
    
    	@PutMapping
    	public R<String> update(@RequestBody Category category) {
    		log.info("修改分类信息{}" + category);
    		categoryService.updateById(category);
    		return R.success("分类修改成功");
    	}
    
    	/**
    	 * 根据条件查询分类
    	 *
    	 * @param category
    	 * @return
    	 */
    	@GetMapping("/list")
    	public R<List<Category>> list(Category category) {
    		// 条件构造
    		LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper();
    		queryWrapper.eq(category.getType() != null, Category::getType, category.getType());
    		// 排序
    		queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);
    		List<Category> list = categoryService.list(queryWrapper);
    		return R.success(list);
    	}
    }

![img](imgs/66fc9dca8aec4d1293707f273df1e3cb.png)

当前端向后台请求保存一个数据库中name字段没有的数据的时候就能添加成功了：

![img](imgs/15efdcf57f8349ee83d25481fb5c29b2.png)

![img](imgs/442a5f611ff54c2fa28f5aabd9af3f89.png)

并且数据库中确实保存了前端用户请求保存的数据了：（注意我们知道前端仅仅向后端发送的请求资源是name字段数据和type字段数据还有sort字段数据，而我们数据库当中还有四个字段呢并且数据库设定的这四个字段不能为null，客户端仅仅传递了三个字段的数据之所以能够添加成功到数据库当中，是因为那四个字段我们设定了mybatis-plus自动填充）

![img](imgs/13f8b519e6eb4da0946401bfe2e156e0.png)

![img](imgs/4600b1fc32cc46c88af05655e95150b9.png)

# 十一、分类管理----分页查询

![img](imgs/dd6604bf91c94e9f9892fd458b687d78.png)

##  需求分析

![img](imgs/eb680273c60444b1b540132ad0b62655.png)

## 代码开发

![img](imgs/d3891a8cf3c2483cb9856aec9f26a5e5.png)

代码如下所示：

@GetMapping("/page")
    	public R<Page> page(int page, int pageSize) {
    		// 分页构造
    		Page<Category> pageInfo = new Page<Category>(page, pageSize);
    		// 查询并排序
    		LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper();
    		queryWrapper.orderByAsc(Category::getSort);
    		// 分页查询
    		categoryService.page(pageInfo, queryWrapper);
    		return R.success(pageInfo);
    	}

客户端拿到后端响应的分页查询出来的数据后，把数据展示在页面上的格式如下所示：

![img](imgs/7f7fcc36c19841f0bd1cdf74dfdcae88.png)

![img](imgs/0039b27495d04470be436a49637a9e03.png)

# 十二、分类管理----删除分类

![img](imgs/db6d7b2c9afc44a18b721ffae5679d7e.png)

## 需求分析

![img](imgs/aaa244de5651423780d5b1df3c12bc25.png)

## 代码开发

![img](imgs/7e20a0e600b242019a049874df293ad2.png)

代码写之前，需要处理一下id精度损失问题。

我们知道数据库当中的id是通过雪花算法进行自动分配的id数值，而不是通过自动增长帮我们生成的id数值，使用雪花算法的方式是有精度损失的。

因此我们需要用到扩展消息转换器来解决雪花算法生成的id精度损失问题（如果项目中已经配的有扩展消息转换器了，那么就不用再配置了。）

前端点击删除按钮时，前端向后端发送的路径资源请求如下图所示：

![img](imgs/b8b4eeb34f2741f4a1c04e8a8e7d138f.png)

因此后端代码如下所示：

```
@DeleteMapping
	public R<String> delete(Long ids) {
		// categoryService.removeById(id);
		categoryService.remove(ids);
		return R.success("分类信息删除成功");
	}

```

上面的过程仅仅是简单的删除逻辑，下面我们也可以进行优化。

## 删除分类----功能完善

我们在12.1的需求分析当中知道，当分类管理的分类名称，关联了菜品（菜品数据库）或者套餐（套餐数据库）的时候（也就是说客户端想要删除的一个菜的id，对应着菜品或者套餐的category_id，也就是说相同，那么就不让他删除了。），就不允许它删除了。

菜品数据库：

![img](imgs/d60d1fe4848d4f6e86392551b4bac155.png)

套餐数据库：

![img](imgs/3c4f07bc9c2d40f4930835de3a4e5a80.png)

功能完善的思路：

当分类管理的分类名称，关联了菜品或者套餐的时候，就不允许它删除了。

简单点说就是：通过上面的演示知道我们通过在分类管理中点击删除按钮删除某个菜的时候，是会向后端发送一个请求路径的，并且携带着该菜的id，后台通过该前端发送过来的菜的id把该菜的数据删除掉了。

而我们这里要完善的功能就是：当前端向后端发送的删除某个菜的id的时候，我们后台拿到前端发送的请求删除某个菜的id的时候，而不是直接把该id对应的数据库中的菜的信息删除掉，而是拿着前端客户传递的菜的id值先进行一下判断，判断该客户传递的该菜的id是否和上面两个数据库（菜品数据库、套餐数据库）中的某个category_id字段的值一致，一致的话就说明客户端想要删除的该菜关联了菜品或者套餐，那么我们后端就不允许客户端删除这个菜。（你这个菜都关联菜品或者套餐了，你还想删除你想啥呢，滚犊子把。不关联这两个数据库的话我才能让你删除懂了吗。）

因此完善的逻辑我们搞懂后，就可以用代码进行处理了：

**重**：因为关联到了上面的菜品数据库和套餐数据库，因此我们首先需要把菜品和套餐数据库对应的实体类、业务层、数据层、表现层（表现层可以先不写）写出来，也就是说只要关联某个数据库了，首先先把该数据库对应的实体类、数据层、业务层、表现层写出来，方便以后做各种逻辑。（写法和员工管理/分类管理刚开始写骨架（实体类、业务层、表现层、数据层）的格式是一样的，都是基于mybatis-plus）

![img](imgs/69b666c7610d441ea1e5bb4057d13aba.png)

注：表现层可以先不写，等前端真正想向该数据库发送资源请求的时候再写。

![img](imgs/0e6664644f16437da4cff55a3cd5f243.png)

因此这些都弄完之后，就可以写判断客户端传递的菜的id是否关联该两个数据库（菜品、套餐数据库）的代码逻辑了：

注：因为要写很多的判断逻辑代码了，因此我们就不用mybatis-plus的增删改查的方法了，我们自己手写一个通过id删除的功能，在业务层做一些逻辑，就不再表现层直接调用mybatis-plus的通过id删除的功能方法了。

我们如何判断客户端想要删除的菜是否和菜品（菜品数据库）、套餐（套餐数据库）关联呢：

因此我们可以通过拿到客户端想要删除的菜的id，然后通过条件sql分别在菜品数据库、套餐数据库中进行select查询，判断菜品数据库、套餐数据库中的category_id字段是否有和客户端想要删除的菜的id相同，如果查询出来的数量不为0，那么就说明客户端想要删除的菜确实和菜品或者套餐关联了。（毕竟菜品或者套餐中category_id字段有该菜的id）

具体判断是否有关联的sql语句如下所示：

![img](imgs/202dbdeaa7534484afff4f4ee4dff131.png)

补充知识：

我们知道sql中有where条件形式，因此我们首先要在写代码的时候想到用条件构造器，如果没有用条件构造器的话，就相当于sql语句中没有写where后面的东西，就相当于select

count（*） frim dish；了，只有用了条件构造器才能有where条件部分。

代码如下所示：

表现层逻辑代码：

@DeleteMapping
    	public R<String> delete(Long ids) {
    		// categoryService.removeById(id);
    		categoryService.remove(ids);
    		return R.success("分类信息删除成功");
    	}

业务层逻辑代码：

package com.xiaolong.takeaway.service.impl;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.xiaolong.takeaway.common.CustomException;
    import com.xiaolong.takeaway.entity.Category;
    import com.xiaolong.takeaway.entity.Dish;
    import com.xiaolong.takeaway.entity.Setmeal;
    import com.xiaolong.takeaway.mapper.CategoryMapper;
    import com.xiaolong.takeaway.service.CategoryService;
    import com.xiaolong.takeaway.service.DishService;
    import com.xiaolong.takeaway.service.SetmealService;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    /**
     * @author xiaolong
     * @date 2023年05月06日 21:44
     */
    @Service
    public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
    
        @Resource
        private DishService dishService;
    
        @Resource
        private SetmealService setmealService;
    
        /**
         * 根据ID删除分类，分类之前需要判断
         * @param id
         */
        @Override
        public void remove(Long id) {
            LambdaQueryWrapper<Dish> dishLambdaQueryWrapper =  new LambdaQueryWrapper<>();
            // 查询当前分类是否关联了菜品，若关联菜品，抛出异常
            dishLambdaQueryWrapper.eq(Dish::getCategoryId,id);
            int count = dishService.count(dishLambdaQueryWrapper);
            if(count > 0){
                // 已经关联菜品，抛出异常
                throw new CustomException("当前分类已关联菜品，不可删除");
            }
            // 查询当前分类是否关联了套餐，若关联菜品，抛出异常
            LambdaQueryWrapper<Setmeal> setmealLambdaQueryWrapper =  new LambdaQueryWrapper<>();
            setmealLambdaQueryWrapper.eq(Setmeal::getCategoryId,id);
            int count1 = setmealService.count(setmealLambdaQueryWrapper);
            if(count>0){
                // 已经关联套餐，抛出异常
                throw new CustomException("当前分类已关联套餐，不可删除");
            }
            // 正常删除分类
            super.removeById(id);
        }

}

业务异常类：

package com.xiaolong.takeaway.common;
    
    /**
     * @author xiaolong
     * @date 2023年05月10日 22:26
     */
    public class CustomException extends RuntimeException{
    
        public CustomException(String msg){
            super(msg);
        }
    }

异常处理器：

package com.xiaolong.takeaway.common;

import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.sql.SQLIntegrityConstraintViolationException;
    
    /**
     * @author xiaolong
     * @Date2023/4/29
     */
    
    @ControllerAdvice(annotations = {RestController.class, Controller.class})
    @ResponseBody
    @Slf4j
    public class GlobalExceptionHandler {
    
        /**
         * 异常处理方法
         * @param ex
         * @return
         */
        @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
        public R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex){
            log.error(ex.getMessage());
            if(ex.getMessage().contains("Duplicate entry")){
                String[] split = ex.getMessage().split(" ");
                String msg = split[2] + "已存在";
                return R.error(msg);
            }
            return R.error("该账号已经存在");
        }

/**
         * 异常处理方法
         * @param customException
         * @return
         */
        @ExceptionHandler(CustomException.class)
        public R<String> exceptionHandler(CustomException customException){
            log.error(customException.getMessage());
            return R.error(customException.getMessage());
        }
    }

代码逻辑完成之后，客户端删除关联着菜品或者套餐的菜时页面效果如下所示：

![img](imgs/f84bcc2235c84918b9dec3873ce55578.png)

# 十三、分类管理----修改分类功能

![img](imgs/b5f20fee32554d589b2f34eb8f766e74.png)

## 需求分析

![img](imgs/63a0711ccb5745a6b7524166341f4a57.png)

![img](imgs/af3614be7cb84e8fa16ce7f7e217fb83.png)

![img](imgs/9b869217481546609aff2ffe7cf35fee.png)

注意：前端向后端请求携带的数据是JSON格式的数据。

## 代码开发

```
@PutMapping
	public R<String> update(@RequestBody Category category) {
		log.info("修改分类信息{}" + category);
		categoryService.updateById(category);
		return R.success("分类修改成功");
	}
```

![img](imgs/e734c81e092b49238ff3c9beb0db78bc.png)

# ==== 菜品管理 ====

# 十四、菜品管理---- 效果展示

![img](imgs/aa91aa32a2c0441c8b834672c65f9fae.png)

移动端（手机）展示效果：

![img](imgs/165f038895ed44b6829c18dc9252562d.png)

# 十五、菜品管理----新增菜品【多表查询重点】

![img](imgs/b28cc5d4f4e749e7969e820fda1f9ca9.png)

## 需求分析

![img](imgs/da47347c9cfd4ad88049cd08f1786bd0.png)

## 数据模型

![img](imgs/9ade46b75e834dae83cbf6a45f3d0448.png)

菜品dish表结构：

![img](imgs/b845164d913f40fb86041b3d37997541.png)

补充：status字段。  0：代表停售   1：代表起售

菜品口味表dish_flavor:

![img](imgs/76794ccc3ae349f9b44ec08e4a77781f.png)

![img](imgs/45ec661cb16645a78433352375e4919b.png)

![img](imgs/4f3df1e5b5f740758201d920251192ee.png)

## 代码开发

![img](imgs/c3160064e3364b389c3f4d6cbc742a7c.png)

代码开发：

![img](imgs/c9e648b0d99d4e61bb17dec2cb098fa9.png)

![img](imgs/42c6e7559f25487abc63b8cae28c7ea5.png)

![img](imgs/38272b95c93e4510853f2bae434020f5.png)

![img](imgs/0b997e98fe08466b84684b23dd1ed84f.png)

![img](imgs/d60f1c66d2a34c68bfd484c6cf23ad31.png)

因此我们首先要先在categroy表现层接收客户端发送的资源请求（因为这个菜品管理想要拿到的就是分类管理对应的数据库中的name字段数据，毕竟这个是菜品管理，想要拿分类管理中的菜品分类type=1正常操作啊。）：

代码演示如下所示：

/**
    	 * 根据条件查询分类
    	 *
    	 * @param category
    	 * @return
    	 */
    	@GetMapping("/list")
    	public R<List<Category>> list(Category category) {
    		// 条件构造
    		LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper();
    		queryWrapper.eq(category.getType() != null, Category::getType, category.getType());
    		// 排序
    		queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);
    		List<Category> list = categoryService.list(queryWrapper);
    		return R.success(list);
    	}

![img](imgs/c84d8f5c45ae4eb191b7709049f81a62.png)

前端用户拿到我们响应给他的type为1（菜品分类）的所有数据的时候，前端就可以做一些逻辑把这些type为1的数据的name字段的数据拿出来展示在下拉框中了：

![img](imgs/cb37721473f74749addba2e3609a062b.png)

![img](imgs/a6db7e350681444eaf8012c292055ffb.png)

![img](imgs/a6db7e350681444eaf8012c292055ffb-1689305913201310.png)

然后我们就可以填写添加的菜品进行保存了：
补充：前端拿到菜品分类后，当客户端选择一个菜品的时候，就把这个菜品对应的id携带过去了，就是下面的categoryId。

![img](imgs/01380a3673d341d898f5e765b8ac52b9.png)

![img](imgs/07e76d445450408486c4b87fd2a60897.png)

但是通过上面的客户端请求dish路径的请求所携带的数据来看，我们后端的Dish实体类是没有flavors属性的，因此我们的Dish实体类根本无法接收客户端请求时所携带的数据，也就是说客户端请求时所携带的请求数据无法封装到实体类的属性当中。（实体类Dish没有flavors属性，但是其他的对应接收前端请求数据的属性还是都有的，仅仅是没有flavors属性）

因此我们需要怎么解决实体类中没有flavors属性来封装前端请求所携带的flavors的json数据呢？

## 解决方法：DTO思想

![img](imgs/a81236f9dbb343769c0f8a1ccc73afc9.png)

![img](imgs/664ac4131ff64c3ab5d72712d0723982.png)

DishDto代码如下所示：

package com.xiaolong.takeaway.dto;
    
    import com.xiaolong.takeaway.entity.Dish;
    import com.xiaolong.takeaway.entity.DishFlavor;
    import lombok.Data;
    import java.util.ArrayList;
    import java.util.List;
    
    @Data
    public class DishDto extends Dish {
    
        /** 菜品口味*/
        private List<DishFlavor> flavors = new ArrayList<>();
    
        private String categoryName;
    
        private Integer copies;
    }

当我们表现层用DTO创建的实体类来接收客户端传递请求的数据的时候，会发现确实能够把前端请求的数据参数封装到DTO实体类的属性当中了，并且前端携带的flavors集合数据确实是封装到集合的泛型DishFlavor实体类的属性当中，然后把该对象封装到List集合中的：

![img](imgs/ca4888d830274795a22d7e69da2117e8.png)

DishController表现层测试代码如下所示（还真的接收到了数据）：

```
  /**
     * * 1、添加菜品功能
     *
     *      客户端发送的post请求： http://localhost:8080/dish
     *
     *      思路： 用DTO思想创建的实体类接收客户端请求时携带的json数据，
     *
     */
    @PostMapping
    public R dish(@RequestBody DishDto dishDto){
        log.info("是否接收到了携带的数据："+dishDto.toString());
        return null;
    }
 
}
```

![img](imgs/2ffc93c5386f45ed86c5a12d174b7e63.png)

总体的逻辑代码如下所示：

DishController表现层逻辑代码：

```
package com.xiaolong.takeaway.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xiaolong.takeaway.common.CommonsConst;
import com.xiaolong.takeaway.common.R;
import com.xiaolong.takeaway.dto.DishDto;
import com.xiaolong.takeaway.entity.Category;
import com.xiaolong.takeaway.entity.Dish;
import com.xiaolong.takeaway.entity.DishFlavor;
import com.xiaolong.takeaway.entity.SetmealDish;
import com.xiaolong.takeaway.service.CategoryService;
import com.xiaolong.takeaway.service.DishFlavorService;
import com.xiaolong.takeaway.service.DishService;
import com.xiaolong.takeaway.service.SetmealDishService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author xiaolong
 * @date 2023年05月16日 22:22
 */
@RestController
@Slf4j
@RequestMapping("/dish")
public class DishController {

@Resource
	private DishService dishService;

@Resource
	private CategoryService categoryService;

@Resource
	private DishFlavorService flavorService;

@Resource
	SetmealDishService setmealDishService;

/**
	 * 新增菜品，同时插入菜品对应的口味数据
	 *
	 * @param dishDto
	 * @return R<String>
	 */
	@PostMapping
	public R<String> save(@RequestBody DishDto dishDto) {
		log.info("DishDTO===>{}", dishDto);
		dishService.saveWithFlover(dishDto);
		return R.success("菜品添加成功");
	}
}
```

业务层逻辑代码如下所示：

/**
         * 新增菜品，同时插入菜品对应的口味数据
         * @param dishDto
         */
        @Override
        @Transactional
        public void saveWithFlover(DishDto dishDto) {
            // 保存菜品基本信息到菜品表dish
            this.save(dishDto);
            // 获取菜品ID
            Long dishId = dishDto.getId();
            List<DishFlavor> flavors = dishDto.getFlavors();
            // 菜品ID设置进口味中
            flavors = flavors.stream().map((item)->{
                item.setDishId(dishId);
                return item;
            }).collect(Collectors.toList());
    
            // 菜品口味数据保存
            dishFlavorService.saveBatch(flavors);
        }

代码释义
     
    /**
     *  业务层实现类      ---- 基于 mybatis-plus
     *
     *  用法： 继承mybatis-plus提供的ServiceImpl，并且泛型第一个是数据层接口，第二个是实体类。
     *      并且也要实现业务层接口
     */
     
    @Service
    public class DishServiceImpl extends ServiceImpl<DishMapper,Dish> implements DishService {
     
        /**
         *  自动装配口味表和菜品表业务层对象
         */
        @Autowired
        private DishServiceImpl dishService;
        @Autowired
        private DishFlavorServiceImpl dishFlavorService;

/**
         *      我们知道，参数dishDto中封装的是客户端请求时携带的数据，而这些数据我们前面已经知道了，
         *      前端请求时flavors集合中携带的数据是封装到了实体类DishFlavor的属性当中的，然而这个实体类DishFlavor的属性对应的是dish_flavor这张数据库表，
         *      因此我们这里把客户端请求时携带的flavors集合数据保存到dish_flavors口味表当中。
         *
         *      然后又因为客户端请求时携带的数据除了flavors数据其他的所有数据对应的是Dish实体类的属性，而Dish实体类属性对应的是dish这张数据库表
         *      因此我们这里把客户端请求时携带的除flavors集合数据外的所有数据保存到dish菜品表当中。
         *
         *      总结： 因此我们这里就是相当于操作两张表，一张是口味表dish_flavor、一张是dish菜品表，
         *             而这两种表中所要保存的数据现在都在实体类DishDto属性当中了（一个flavor集合属性，一个继承的Dish属性）
          * 再次总结： 也就是说DishDto实体类中的属性中flavors集合属性中封装的是菜品的口味数据，我们现在要把菜品的口味单独放入一个口味数据库当中进行保存，DishDto实体类中的除了flavors集合的其他属性中封装的数据是菜品所对应的菜品名字、价格....，因此我们把这些实体类中的属性单独再放入一个菜品数据库当中。最终为了知道口味对应的是什么菜，就需要让口味数据库中关联着菜品的id
         *
         */
        public void DishWith(DishDto dishDto){
     
            /**
             *  因此这里就可以先调用菜品表对应的业务层，将DishDto实体类的属性中封装的数据保存到菜品表中 （就是flavors除外的所有数据都是菜品表中的数据）
             *
             *      思路： 直接用菜品表对应的业务层调用数据层的保存功能即可。
             */
            dishService.save(dishDto);  // 这里直接把dishDto对象传递给保存功能即可，因为dishDto对象属性中封装的有菜品表对应的数据和口味表对应的数据（flavors），
                                        // 这里直接把对象传入给保存功能，mybatisPlus会自动识别获取菜品表在dishDto对象属性中想要的数据

/**
             *  这里上面菜品表保存数据成功后，那么那条保存的菜品数据在数据库中就会自动生成一个id
             *  我们这里先获取到那个id，等会和口味表做关联。
             *
             *      因为菜品表保存成功后，我们口味表肯定要用菜品表某条菜品数据的id和我们的口味相关联一下啊，要不然谁他妈知道这个口味表中的口味是哪个菜的口味啊。
             *
             *      做法： 直接用实体类.getId的方式就能获取dishService.save(dishDto);保存成功后，该保存的菜在数据库中对应的id了。
             */
            Long id = dishDto.getId();  // 获取到了菜品的id

/**
             *  调用口味表的数据层的保存功能，把实体类DishDto对象flavors属性当中封装的口味集合数据保存到口味数据库当中。
             *
             *      但是要注意的是：将口味数据保存到口味数据库之前，要把该口味数据关联上菜品的id，不关联的话谁他妈知道这个口味是哪个菜啊。
             *
             */
             // 首先我们知道，口味数据是封装到DishDto实体类的flavors属性当中的，该属性是List集合，因为一个菜可能客户会选择好几种口味，
            // 因此我们这里需要先把该集合属性中封装的口味数据遍历循环出来，然后为遍历出来的口味数据添加到口味数据库之前关联一下菜品的id，
            // 假如在flavors属性口味集合中遍历出来了6条口味数据，那么我们就要让这6条数据都关联一下菜品id，要不关联的话这6条口味数据保存
            // 到口味数据库中，我们查看口味数据库的时候谁他妈知道这6条口味是哪个菜的啊卧槽。
     
            // 1、因此先把DishDto实体类当中的flavors属性获取出来
            List<DishFlavor> flavors = dishDto.getFlavors();    // 我们知道前端请求携带的数据都封装在了这个List集合当中了
            // 2、遍历List集合，把里面的每条口味的数据都遍历出来关联一下菜品的id然后再调用数据层进行往口味数据库中保存处理。
            for (DishFlavor dishFlavor:flavors){    // 我们知道List集合中的数据是封装到DishFlavor属性当中后以DishFlavor对象的形式封装到List集合当中的，所以元素类型就是DishFlavor
                // System.out.println(dishFlavor); //  DishFlavor(id=null, dishId=null, name=辣度, value=["不辣","微辣","中辣","重辣"], createTime=null, updateTime=null, createUser=null, updateUser=null, isDeleted=null)
                                                // 循环遍历打印就可以把封装在List集合中的DishFlavor对象一条一条的循环打印出来了（上面我们只列出了一条循环打印的数据，格式就是这样的）
     
                dishFlavor.setDishId(id);   // 因此我们就可以循环遍历出每一个口味属性的对象，然后为其dishId关联菜品的id字段赋值，关联上菜品的id
     
                /**
                 *  然后为其菜品口味数据关联了菜品的id后，就可以调用口味数据层的保存功能了，将其对象中封装的口味数据保存到菜品口味数据库中。
                 */
                dishFlavorService.save(dishFlavor); // 这里也就相当于传入的一个dishFlavor对象，
                    // 我们知道传入到一个数据库中对象的话，如果该对象的属性映射的到数据库的字段名        
                   // 的话，就能把属性中的数据封装到数据库当中了。 之所以这里相当于传入的一个 
                 // dishFlavor对象，就是因为我们把List集合中封装数据的dishFlavor对象遍历出来后一    
      // 个一个的调用数据层保存功能，把该对象一个一个传入进去了，因此就又回到以前的写法了。（只要对象 
       // 中的属性能对应到数据库中的字段名，那么调用数据层的增删改查功能的时候，mybatisplus都可以 
        // 帮我们自动把属性中封装的数据映射到数据库对应的字段上）
     
            }
     
        }
    }

当客户端向后端发送添加菜品请求时：

![image-20230714113935737](imgs/image-20230714113935737.png)

通过我们后端的逻辑我们会发现我们的菜品数据库当中确实添加成功了菜品数据：

![img](imgs/6d5adbba4cfe4688a639a0958d72d70b.png)

并且口味数据库也添加成功了数据，并且客户对上面的那个菜所选择的几种口味也成功关联了菜的id（这样就知道这个口味数据库中的口味对应的是哪个菜了）：

![img](imgs/7adda3545ac74aada83c5d99059688c7.png)

# 十六、菜品管理----菜品信息分页查询  【多表查询重点】

![img](imgs/e3e3ab2af71b4f0e9ec4be762565e1d4.png)

## 需求分析

![img](imgs/043e310ccc4e4844b67bd9832340cf8b.png)

## 代码开发

![img](imgs/2570274de5444cf1bc0d6fd0d3a8272e.png)

首先我们要知道（和我们写员工管理时的模糊条件查询一样的）：

![img](imgs/b14718ba2a1e413a846ab069b07c390b.png)

代码如下所示：

@GetMapping("/page")
    	public R<Page> page(int page, int pageSize, String name) {
    		log.info("page={},pageSize={},name={}", page, pageSize, name);
    		// 构造分页构造器
    		Page<Dish> pageInfo = new Page(page, pageSize);
    		// 因为前端需要展示分类的名称，所以封装成DishDto对象
    		Page<DishDto> dishDtoPage = new Page(page, pageSize);
    		// 构造条件
    		LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper();
    		queryWrapper.like(StringUtils.isNotEmpty(name), Dish::getName, name);
    		// 添加排序
    		queryWrapper.orderByDesc(Dish::getUpdateTime);
    		// 执行查询
    		dishService.page(pageInfo, queryWrapper);
    		// 进行对象拷贝,去除之前已经查出来的集合
    		BeanUtils.copyProperties(pageInfo, dishDtoPage, "records");
    
    		List<Dish> records = pageInfo.getRecords();
    		List<DishDto> list = records.stream().map((item) -> {
    			DishDto dishDto = new DishDto();
    			BeanUtils.copyProperties(item, dishDto);
    			// 获取categoryId
    			Long categoryId = item.getCategoryId();
    			// 给categoryName赋值
    			Category category = categoryService.getById(categoryId);
    			if (category != null) {
    				dishDto.setCategoryName(category.getName());
    			}
    			// 当前菜品ID
    			Long dishId = item.getId();
    			LambdaQueryWrapper<DishFlavor> dishFlavorQueryWrapper = new LambdaQueryWrapper<>();
    			dishFlavorQueryWrapper.eq(DishFlavor::getDishId, dishId);
    			List<DishFlavor> dishFlavorList = flavorService.list(dishFlavorQueryWrapper);
    			dishDto.setFlavors(dishFlavorList);
    			return dishDto;
    		}).collect(Collectors.toList());
    		dishDtoPage.setRecords(list);
    		return R.success(dishDtoPage);
    	}

![img](imgs/340795b4714543dbb11923c7741c1ff9.png)

通过上面的代码逻辑，把dish数据库中的数据查询出来后，后端就可以响应给前端查询出来的这些数据了，然后前端拿到这些数据之后，就可以把这些数据展示在前端的页面上了：

![img](imgs/645da9529b21441a8b1457b4958629dd.png)

但是需要思考的是：为什么菜品分类没有数据呢？

这是因为我们后端对dish数据库查询出来的数据中，是没有菜品分类的数据的，我们dish数据库表中只有菜品分类数据对应的id（我们把这个id响应给前端了，前端也不知道是啥玩意，这他妈一串什么玩意），因此后端对数据库dish查询出来的数据响应给前端的时候，前端自然也就拿不到菜品分类的数据：

![img](imgs/352afc57143d43e4916b126d9d71bb29.png)

而前端想要的并不是dish数据库中响应的一串菜品分类的id，前端想要的就是下面菜品分类的名称，也就是下面的name字段的数据，但是呢这个name字段名字又TM不在dish的数据库当中，是category数据库中的。但是两张表category_id字段数据和id字段数据是有关联的，因此就可以想办法，把下面这张不是dish表的name字段对应的数据响应给前端让前端展示菜品分类名称。

![image-20230714114118556](imgs/image-20230714114118556.png)

我们还要知道前端是通过拿到后端响应的数据进行在页面上展示的，前端的代码逻辑是这样的：

![img](imgs/0b60f625cecb48da84813d65bce4c556.png)

因此我们也可以看出，前端对菜品分类展示的数据对应的后端名称是categoryName字段，因此需要我们后端实体类当中有这个categoryName属性，那么前端才能从这个属性当中获取数据，而这个属性呢在我们dish实体类当中又他妈没有（其他的售卖状态、最后操作时间等实体类当中都是有的，所以前端能够获取到这几个数据就是因为没有categoryName属性，因此菜品分类的数据获取不到）

因此就一句话，前端如果想获取到分类名称的数据，那么就需要我们后端实体类当中有这个对应着前端分类名称的属性categroyName，要是没有这个属性的话，怎么封装数据库中的数据响应给前端进行页面展示呢？（注意除了categroyName属性没有，其他的前端页面对应的属性Dish实体类当中都是有的）

因此解决思路就是还用DTO思想：

![img](imgs/5ca0331727fd4ae2bc12e1cab09aaf26-1689306106408346.png)

最终前端效果展示：

![img](imgs/da8991d5b635487894fabec4804d4523.png)

# 十七、菜品管理----修改菜品

![img](imgs/25f48c989f12473581aeb3a6293579d9.png)

## 需求分析

最终回显的结果如下所示：

结论： 就是需要拿着客户端想要删除的id值，对菜品表和口味表进行查询操作。

![img](imgs/69974508ab4548c4a1f29ee44a9d6c07.png)

步骤如下：

![img](imgs/6bf23cf79415416e9d2efcdd1145b6fa.png)

我们知道我们点击修改菜品后，前端页面给我们就展示了如上的形式，会发现页面上没有回显数据，因此我们需要先把想要修改的菜品数据回显在上面的格式里面，然后再进行修改操作：

![img](imgs/0e0c65b6b6a94deca232c764113de392.png)

那么我们点击修改按钮后：就会跳转到第一张没有回显的图上了：

![img](imgs/08521ca7b1224de3bfcad4845cbcafa8.png)

因此前端就先通过拿想要删除的辣子鸡的id，进行向后端发送资源请求，先把辣子鸡在dish数据库中对应的整条数据通过后端查询出来并且把该辣子鸡对应的口味表中的口味查询出来后响应给前端，然后前端先把该辣子鸡的数据回显在页面上后，再供客户进行修改：

![img](imgs/5dda280222dd49eaabce593db05c5cff.png)

![img](imgs/32f45d4498434d58b927c0a87f72f5b1.png)

## 代码开发1 ---- （页面数据回显）

表现层

/**
    	 * 根据ID查询菜品信息以及对应的口味信息
    	 *
    	 * @param id
    	 * @return
    	 */
    	@GetMapping("/{id}")
    	public R<DishDto> get(@PathVariable Long id) {
    		DishDto dishDto = dishService.getByIdWithFlavor(id);
    		return R.success(dishDto);
    	}

业务层：

```
 /**
     * 根据ID查询菜品信息以及对应的口味信息
     * @param id
     * @return
     */
    @Override
    public DishDto getByIdWithFlavor(Long id) {
        // 查询菜品基本信息，从dish表查询
        Dish dish = this.getById(id);
        DishDto dishDto = new DishDto();
        BeanUtils.copyProperties(dish,dishDto);
        // 查询对应的口味信息
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DishFlavor::getDishId,dish.getId());
        List<DishFlavor> list = dishFlavorService.list(queryWrapper);
        dishDto.setFlavors(list);
        return dishDto;
    }

```

最终前端拿到数据后页面展示如下所示：（确实展示出来了。）

![img](imgs/c98db1cd7dce44e19317f75fc60d2449.png)

补：

![img](imgs/cb484fa0aa3440c79beac305024cbaea.png)

## 代码开发2---- 修改菜品

![img](imgs/411d07f5b4c046bbafe0f6a4adb58215.png)

假设我们现在想要修改的菜品就是辣子鸡这个菜品，我们点击辣子鸡对应的修改按钮后，会知道首先会先通过辣子鸡的id对数据库进行查询辣子鸡的数据然后展示在前面页面上：

![img](imgs/71220cb793614d1ea97a6e7b9c0fa8b4.png)

此时假设我们想修改这个辣子鸡的菜品数据，想修改的样式如下所示：

![img](imgs/88505e056b2840a7ae1c434a6da0640d.png)

此时我们修改了辣子鸡的数据之后，点击提交按钮后，前端页面就会带着我们刚修改的菜品数据向后端发送请求（注意请求携带的id值，还是以前没修改之前的id值）：

![img](imgs/88505e056b2840a7ae1c434a6da0640d-1689306199847375.png)

代码如下所示：

表现层：

```
/**
	 * 修改菜品
	 *
	 * @param dishDto
	 * @return R<String>
	 */
	@PutMapping
	public R<String> update(@RequestBody DishDto dishDto) {
		log.info("DishDTO===>{}", dishDto);
		dishService.updateWithFlavor(dishDto);
		return R.success("菜品修改成功");
	}
```

业务层：

@Override
        @Transactional
        public void updateWithFlavor(DishDto dishDto) {
            // 更新菜品表
            this.updateById(dishDto);
            // 清理当前菜品对应口味数据（删除操作）
            LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper();
            queryWrapper.eq(DishFlavor::getDishId,dishDto.getId());
            dishFlavorService.remove(queryWrapper);
            // 加载当前提交过来的口味数据（插入操作）
            List<DishFlavor> flavors = dishDto.getFlavors();
            flavors = flavors.stream().map((item)->{
                item.setDishId(dishDto.getId());
                return item;
            }).collect(Collectors.toList());
            dishFlavorService.saveBatch(flavors);
        }

假设就是修改的辣子鸡的数据：把辣子鸡变成辣子鸡12345：

![img](imgs/d77605b6609f433e87b1ab90a1487d44.png)

前端页面确实展示成功了：

![img](imgs/da60a26b578d43afa9560dbb893747df.png)

后端数据库也都修改成功：

![img](imgs/25ca4f7746cb4c6982e86144c0369d93.png)

![img](imgs/f30f10924cd046e98cce67a76c0a6880.png)

# ====套餐管理====

# 十八、套餐管理----新增套餐

![img](imgs/9297a5659da341e28d4ebe06cfaf5708.png)

## 需求分析

![img](imgs/6d885509a5a441aaa1c41e7f718e194a.png)

## 数据模型

![image-20230714114416182](imgs/image-20230714114416182.png)

套餐表结构：

![img](imgs/9755a19de3d64deaae24f7c7ea5b9cc1.png)

![img](imgs/b1ed5063028341ec9e55f984ca1d235d.png)

![img](imgs/e48560cc26bd4f0ca524cd02db7e8efe.png)

注：setmeal是套餐表，setmeal_dish： 套餐菜品关系表

## 代码开发----前期准备

前期准备：

因为涉及到setmeal是套餐表，setmeal_dish： 套餐菜品关系表，两张表，因此我们先把该两张表对应的实体类、表现层（表现层可以先不写）、业务层、数据层骨架搭出来。

【也就是说以后项目开发中，只要有表，就先把表对应的实体类、业务层、数据层、（表现层）骨架先搭建出来，然后想获取表中数据的话，就直接在骨架中写代码就能获取了。】

![img](imgs/48b27c3645d342e69a5774a71778bf76.png)

并且通过下面套餐表和套餐菜品关系表可以看出，套餐表和套餐菜品关系表是通过id键和setmeal_id做关联的。

![img](imgs/2ebae41f81ba42459daf410f1e9479cc.png)

![img](imgs/bd17522b62f74aefa6f9e1c5fcebe6e1.png)

## 新增套餐代码开发

首先我们要知道：当客户端点击

![image-20230714114519759](imgs/image-20230714114519759.png)

新建套餐按钮时，套餐分类那个地方的代码逻辑，前端已经向后端发送过请求了，并且我们后台已经做过了该请求逻辑的代码了，因此套餐分类那里已经查询到了数据了：

![img](imgs/d8868857355c49829ee049a510cdec8f.png)

现在我们要做的就是一点一点的向后端发送请求获取数据进行添加套餐：

我们点击添加菜品按钮时：我们会知道的效果如下所示：

![img](imgs/995084a4da44471db15af33ec7c8b224.png)

![img](imgs/507f876745154333943d179dac2fc745.png)

我们要知道周口菜套餐表中的id字段是对应菜品表中的category_id字段的，也就是说当我们选择周口菜这个套餐的时候，我们就可以通过周口菜在数据库表中对应的id字段，通过在菜品表的category_id字段进行比对，把菜品表中的category_id字段和周口菜套餐对应的id一致的菜品数据都查询出来响应给前端页面，那么就能获取到所有是周口菜套餐里面的菜了。（同理其他的菜品套餐对应的其他的菜品数据也是可以获取出来的，如获取川菜套餐里面的所有的菜品，也是通过前端传递的川菜套餐id和菜品里面的category_id字段做比较，然后把查询到的所有川菜套餐里面的菜品都查询出来响应给前端页面）：

![img](imgs/e29fe5d9e3d2409ab036e6cc6152d1e2.png)

![image-20230714114605389](imgs/image-20230714114605389.png)

因此前端页面通过传递请求携带着套餐的id（如周口菜套餐的id），我们就可以拿着这个套餐id和菜品数据库中的category_id作比较了，把菜品数据库中category_id字段和套餐id对应的菜品数据都响应给前端，那么也就可以说如果前端选择传递的是周口菜套餐id，那么我们后台就把周口菜套餐中所有的菜品都响应给前端页面了：

![img](imgs/f0fbaaa568664ecc925b71cf3967a37a.png)

![img](imgs/19bd38951ed442cd9101fa26ab115309.png)

代码如下所示：

```
@GetMapping("/list")
	public R<List<DishDto>> list(Dish dish) {
		// 构造条件
		LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper();
		queryWrapper.eq(Dish::getStatus, CommonsConst.DISH_OPEN);
		queryWrapper.eq(dish.getCategoryId() != null, Dish::getCategoryId, dish.getCategoryId());
		// 添加排序条件
		queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
		List<Dish> dishList = dishService.list(queryWrapper);

List<DishDto> dishDtoList = dishList.stream().map((item) -> {
			DishDto dishDto = new DishDto();
			BeanUtils.copyProperties(item, dishDto);
			// 获取categoryId
			Long categoryId = item.getCategoryId();
			// 给categoryName赋值
			Category category = categoryService.getById(categoryId);
			if (category != null) {
				dishDto.setCategoryName(category.getName());
			}
			// 当前菜品ID
			Long dishId = item.getId();
			LambdaQueryWrapper<DishFlavor> dishFlavorQueryWrapper = new LambdaQueryWrapper<>();
			dishFlavorQueryWrapper.eq(DishFlavor::getDishId, dishId);
			List<DishFlavor> dishFlavorList = flavorService.list(dishFlavorQueryWrapper);
			dishDto.setFlavors(dishFlavorList);
			return dishDto;
		}).collect(Collectors.toList());
		return R.success(dishDtoList);
	}

```

![img](imgs/c00a2a1387f94088bdbcd5e237559c6a.png)

![img](imgs/580f0bc1544b4762af404703913a2453.png)

选择好之后点击确定就可变成下面的页面形式了。

这里的逻辑处理好之后，接下来我们就可以进行新增套餐了：
注意：接下来的操作就和菜品管理新增菜品的过程是一样的了。

分析前端页面添加的数据是怎么分配到后端数据库的：

![img](imgs/3965f742a9564f2c92d331fa6d13dd72.png)

![img](imgs/8f4f6a7a539447c2a412ec56c0b7966f.png)

携带的数据如下所示：（注意：这些数据是json格式的）

![img](imgs/ca8922c926b64fa7bb59475244b4f2f3.png)

重点之处：（套餐表和套餐菜品表之间的关系【和菜品管理添加菜品时一样，一个菜品对应多种口味，但是要在口味表中关联着菜品，要不然谁知道他妈这些添加的口味是哪个菜的，这里也一样套餐菜品表中的数据也要关联着套餐表中的数据，要不然谁知道这些菜是他妈哪个套餐里面的。】）

![img](imgs/83da851a1c5a4027b5a0c6a924b554a7.png)

![img](imgs/52471788a4024d2ca26703018ea03174.png)

因此我们到底该如何接收客户端请求携带的上面的那些数据呢？用套餐表对应setmeal实体类接收？那肯定是不行的，因为用套餐表setmeal实体类接收的话，那些紫色的套餐菜品的数据就无法接收到了（也就是说，套餐表setmeal实体类当中没有那些接收套餐菜品的数据属性），同理，用套餐菜品表对应的setmealDish实体类接收上面的客户端请求的数据也是不行的，因为又接收不到套餐数据了，也就是红色圈起来的数据。

所以我们到底该怎么解决这种接收不在同一条数据库中的前端请求携带的数据呢？

使用DTO思想。

DTO思想简单点说：（就是创建一个能封装前端请求携带的全部数据的实体类）

DTO实体类格式如下所示：

```
@Data
/**

还是和菜品管理时新增菜品的操作是一样的。
*

1、  这里因为DTO实体类继承了Setmeal实体类，我们知道Setmeal实体类中的属性是专门用来封装套餐表数据的

也就是我们前面客户端传递的数据红色框起来的那部分数据，是可以封装到Setmeal实体类属性当中，然后存入到setmeal套餐表数据库中的）

因此该DTO实体类继承了Setmeal实体类，也就是说该DTO实体类就有了Setmeal实体类的属性，可以说该DTO实体类可以接收前端请求传递的套餐数据了（红色框起来的）
 *

2、  又因为这个DTO实体类有一个setmealDishes集合属性，又因为集合泛型是SetmealDish实体类，我们知道SetmealDish实体类中的属性就是专门封装客户端请求携带过来

的那套餐菜品数据的（也就是紫色部分的数据），因此接收过来后，就可以保存到setmeal_dish数据库当中了（因为setmeal_dish数据库对应的实体类就是SetmealDish）

又因为套餐菜品数据有可能是多条数据，因此我们就把该接收套餐菜品数据的属性用了集合的形式，也就是说把客户端请求的数据封装到SetmealDish实体类属性当中，然后以

对象的形式封装在List集合中。最终这个DTO实体类就能接收封装到前端传递过来的套餐菜品的所有数据了。
 *

3、这就是客户端请求携带的四条套餐菜品数据：

这些数据的 copies、dishId、name、price....对应的就是套餐菜品实体类SetmealDish的属性，因此可以把这客户端请求的数据封装在SetmealDish的属性中

然后以对象的形式存入到List集合中 （因为数据多，所以以集合的时候储存）
*

0: {copies: 1, dishId: "1397854865672679425", name: "鱼香炒鸡蛋", price: 2000}

1: {copies: 1, dishId: "1397854652581064706", name: "麻辣水煮鱼", price: 14800}

2: {copies: 1, dishId: "1568582209071792129", name: "毛蛋", price: 2000}

3: {copies: 1, dishId: "1413385247889891330", name: "米饭", price: 200}
 *
 *

总结： 因此最终我们这个DTO实体类就可以接收到前端传递请求时携带的所有数据了。
 */
@Data
public class SetmealDto extends Setmeal {

private List<SetmealDish> setmealDishes;

private String categoryName;
}
```

业务代码如下所示：

表现层：

@PostMapping
    	public R<String> save(@RequestBody SetmealDto setmealDto) {
    		log.info("SetmealDto===>{}" + setmealDto);
    		setmealService.saveWithDish(setmealDto);
    		return R.success("套餐信息插入成功");
    	}

业务层：

```
/**
     * 新增套餐以及新增套餐关联关系
     *
     * @param setmealDto
     */
    @Override
    @Transactional
    public void saveWithDish(SetmealDto setmealDto) {
        // 保存套餐基本信息 操作setmeal执行insert操作
        this.save(setmealDto);
        // 保存套餐与菜品的关联关系，操作setmeal_dish执行insert操作
        List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
        setmealDishes.stream().map((item) -> {
            item.setSetmealId(setmealDto.getId());
            return item;
        }).collect(Collectors.toList());
        // 保存套餐与菜品的关联信息
        setmealDishService.saveBatch(setmealDishes);
    }
```

假设客户端想要添加的套餐，和套餐里面对应的几个菜如下所示：

![img](imgs/25296e93632240b69ec627db72ec4e1b.png)

会发现：套餐数据和套餐菜品数据确实添加到指定的数据库当中来 ：

并且套餐菜品数据库中的数据setmeal_id确实关联到了套餐数据库中的id，因此就知道这几个菜是哪个套餐里的菜了哈哈。

![img](imgs/5b1f36d5e46a4cae9407b30fc44a553c.png)

![img](imgs/6459fd11602e483e9569cbda534f73ec.png)

# 十九、套餐管理----分页查询

逻辑其实和菜品管理的分页查询思路和代码是大差不差的（直接看菜品管理的分页查询笔记即可）。

# 二十、套餐管理----删除套餐功能

## 需求分析

![img](imgs/fa3294e4c454426eb523cda6c7dd59a5.png)

注意要求：对于售卖状态套餐为起售状态时，需要先转换成停售然后才能删除该套餐。

## 代码开发准备

![img](imgs/3495cadf1cb3412b83c1b16973891e15.png)

首先我们要先熟悉sql语句in的用法：

![img](imgs/350ab401988d4b12a47d4fc536f9b626.png)

业务层代码：

```
 /**
     * 根据ID删除套餐信息，同时删除所关联的菜品
     *
     * @param ids
     */
    @Override
    @Transactional
    public void removeWithDish(List<Long> ids) {
        // 查询套餐状态确定是否可以删除
        LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(Setmeal::getId, ids);
        queryWrapper.eq(Setmeal::getStatus, 1);
        int count = this.count(queryWrapper);
        // 查到起售数据
        if (count > 0) {
            throw new CustomException("套餐正在售卖,无法删除");
        }
        // 可以删除，先删除套餐表中数据
        this.removeByIds(ids);
        // 删除关系表中数据
        LambdaQueryWrapper<SetmealDish> setmealDishLambdaQueryWrapper = new LambdaQueryWrapper<>();
        setmealDishLambdaQueryWrapper.in(SetmealDish::getSetmealId, ids);
        setmealDishService.remove(setmealDishLambdaQueryWrapper);
    }
```

## 配置代码生成器

pom依赖

```

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>

<dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
```

```
CodeGet
```

```
package com.itheima.test;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

public class CodeGet {

public static void main(String[] args) {

// 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

// 2、全局配置
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir("E:\\work\\code\\takeaway\\takeaway_project"+"/src/main/java");

gc.setServiceName("%sService");	//去掉Service接口的首字母I
        gc.setAuthor("xiaolong");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

// 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/db_takeaway?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        //设置数据库类型
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

// 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.xiaolong");
        pc.setModuleName("takeaway"); //模块名
        pc.setController("controller");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

// 5、策略配置
        StrategyConfig strategy = new StrategyConfig();
        //数据库表名
        strategy.setInclude("dish_flavor");

strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略

strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

mpg.setStrategy(strategy);

// 6、执行
        mpg.execute();
    }
}

```

```
serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=
utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&
allowPublicKeyRetrieval=true  
```

```
这是一个关于数据库连接的字符串，包含了一些参数和配置选项。下面是各个参数的含义和作用的简要释义：

1. `serverTimezone=Asia/Shanghai`：指定数据库服务器的时区为亚洲/上海，用于在存储和检索日期和时间时正确处理时区。
2. `useUnicode=true`：设置使用Unicode字符集来处理数据，确保支持存储和检索Unicode字符。
3. `characterEncoding=utf-8`：设置字符编码为UTF-8，以支持存储和检索多语言字符（如中文）。
4. `zeroDateTimeBehavior=convertToNull`：设置当数据库存储的日期或时间为零值（如1970-01-01）时，将其转换为Java中的null值。
5. `useSSL=false`：禁用SSL连接，以不使用安全套接字层加密传输数据。
6. `allowPublicKeyRetrieval=true`：允许从服务器获取公钥用于SSL连接认证。

```

## 后台系统登录功能

![image-20230714114805393](imgs/image-20230714114805393.png)

![image-20230714114815653](imgs/image-20230714114815653.png)

![image-20230714114828358](imgs/image-20230714114828358.png)

![image-20230714114844636](imgs/image-20230714114844636.png)

![image-20230714114854563](imgs/image-20230714114854563.png)

![image-20230714114910487](imgs/image-20230714114910487.png)

## 后台系统退出功能

## 完善登录功能

## 新增员工

## 员工信息分页查询

## 启用、禁用员工账号

## 编辑工具信息

## 编辑员工信息

## 公共字段自动填充

## 新增分类

## 分类信息分页查询

## 文件上传和下载

### 上传介绍

![image-20230714114927465](imgs/image-20230714114927465.png)

![image-20230714114949496](imgs/image-20230714114949496.png)

### 下载介绍

![image-20230714115000639](imgs/image-20230714115000639.png)

![image-20230714115010987](imgs/image-20230714115010987.png)

### 文件上传 代码实现

```
package com.xiaolong.takeaway.controller;

import com.xiaolong.takeaway.common.R;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;

/**
 * @author Administrator
 * @ClassName CommonController
 * @description: TODO
 * @date 2023年07月01日
 * @version: 1.0
 */
@RestController
@RequestMapping("/common")
@Slf4j
public class CommonController {

@Value("${takeaway.path}")
    private String basePath;

/**
     * 文件上传
     *
     * @param file
     * @return
     */
    @PostMapping("/upload")
    public R<String> upload(MultipartFile file) {
        //file时一个临时文件，需要转存到指定位置，否则本次请求完成后临时文件会删除
        log.info(file.toString());
        //原始文件名
        String originalFilename = file.getOriginalFilename();
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));

//使用UUID重新生成文件名，防止文件名重复造成文件覆盖
        String fileName = UUID.randomUUID().toString() + suffix;
        //创建一个目录对象
        File dir = new File(basePath);
        //判断当前目录是否存在
        if (!dir.exists()) {
            //目录不存在 需要创建
            dir.mkdirs();
        }
        //transferTo 转存到
        try {
            //将临时文件转存到
            file.transferTo(new File(basePath + fileName));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return R.success(fileName);
    }
}

```

### 文件下载 代码实现

```
 /**
     * 下载文件
     *
     * @param name
     * @param response
     */
    @GetMapping("/download")
    public void download(String name, HttpServletResponse response) {
        try {
            //输入流 通过输入流读取文件内容
            FileInputStream fileInputStream = new FileInputStream(new File(basePath + name));

//输出流 通过输出流将文件写回浏览器，在浏览器展示图片
            ServletOutputStream outputStream = response.getOutputStream();

response.setContentType("image/jpeg");
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = fileInputStream.read(bytes)) != -1) {
                outputStream.write(bytes, 0, len);
                outputStream.flush();
            }
            //关闭资源
            outputStream.close();
            fileInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
```

## 新增菜品

### 需求分析

![image-20230714115030628](imgs/image-20230714115030628.png)

### 数据模型

![image-20230714115040735](imgs/image-20230714115040735.png)

### 代码开发

![image-20230714115049868](imgs/image-20230714115049868.png)

![image-20230714115058291](imgs/image-20230714115058291.png)

![image-20230714115115831](imgs/image-20230714115115831.png)

![image-20230714115127269](imgs/image-20230714115127269.png)

DishDto

```
package com.xiaolong.takeaway.dto;

import com.xiaolong.takeaway.entity.Dish;
import com.xiaolong.takeaway.entity.DishFlavor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Administrator
 * @ClassName DishDto
 * @description: TODO
 * @date 2023年07月03日
 * @version: 1.0
 */
@Data
public class DishDto extends Dish {
    private List<DishFlavor> flavors = new ArrayList<>();
    private String categoryName;
    private Integer copies;
}

```

DishController

```
package com.xiaolong.takeaway.controller;

import com.xiaolong.takeaway.common.R;
import com.xiaolong.takeaway.dto.DishDto;
import com.xiaolong.takeaway.service.DishFlavorService;
import com.xiaolong.takeaway.service.DishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * 菜品口味关系表 前端控制器
 * </p>
 *
 * @author xiaolong
 * @since 2023-07-03
 */
@RestController
@RequestMapping("/dish")
@Slf4j
public class DishController {

@Autowired
    DishService dishService;

@Autowired
    DishFlavorService dishFlavorService;

/**
     * 新增菜品
     *
     * @param dishDto
     * @return
     */
    @PostMapping
    public R<String> save(@RequestBody DishDto dishDto) {
        log.info(dishDto.toString());
        dishService.saveWithFlavor(dishDto);
        return R.success("新增菜品成功");
    }
}

```

DishService

```
//新增菜品 同时插入菜品对应的口味数据，需要操作的两张表：dish，dish_flavor
    public void saveWithFlavor(DishDto dishDto);
```

DishServiceImpl

```
@Service
public class DishServiceImpl extends ServiceImpl<DishMapper, Dish> implements DishService {
    @Autowired
    private DishFlavorService dishFlavorService;

/**
     * 新增菜品同时保存接口味数据
     *
     * @param dishDto
     */
    @Transactional//事务控制 保证数据一致性
    public void saveWithFlavor(DishDto dishDto) {
        //保存菜品的基本信息到菜品表dish
        this.save(dishDto);
        Long dishId = dishDto.getId();//菜品id
        //菜品口味
        List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((item) -> {
            item.setDishId(dishId);
            return item;
        }).collect(Collectors.toList());
        //保存菜品口味数据到菜品口味表dish flavor
        dishFlavorService.saveBatch(flavors);
    }
}

```

## 菜品信息分页查询

![image-20230714115143010](imgs/image-20230714115143010.png)

![image-20230714115152918](imgs/image-20230714115152918.png)

![image-20230714115202359](imgs/image-20230714115202359.png)

DishController

```
 /**
     * 菜品信息分页查询
     *
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page, int pageSize, String name) {
        //构造分页构造器对象
        Page<Dish> pageInfo = new Page<>(page, pageSize);
        Page<DishDto> dishDtoPage = new Page<>();
        //条件构造器
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        //添加过滤条件
        queryWrapper.like(name != null, Dish::getName, name);
        //添加排序条件
        queryWrapper.orderByDesc(Dish::getUpdateTime);
        //执行分页查询
        dishService.page(pageInfo, queryWrapper);
        //使用BeanUtils.copyProperties方法将pageInfo对象除了records属性以外的属性值复制到dishDtoPage对象中
        BeanUtils.copyProperties(pageInfo, dishDtoPage, "records");
        List<Dish> records = pageInfo.getRecords();
        List<DishDto> list = records.stream().map((item) -> {
            DishDto dishDto = new DishDto();
            //将item对象的属性值复制到dishDto对象中
            BeanUtils.copyProperties(item, dishDto);

Long categoryId = item.getCategoryId();
            //根据id查询分类对象
            Category category = categoryService.getById(categoryId);
            if (category != null) {
                String categoryName = category.getName();
                dishDto.setCategoryName(categoryName);
            }
            return dishDto;
        }).collect(Collectors.toList());

dishDtoPage.setRecords(list);

return R.success(dishDtoPage);

}
```

## 菜品管理

![image-20230714115213440](imgs/image-20230714115213440.png)

![image-20230714115223578](imgs/image-20230714115223578.png)

DishController

```

/**
     * 修改菜品
     *
     * @param dishDto
     * @return
     */
    @PutMapping
    public R<String> update(@RequestBody DishDto dishDto) {
        log.info(dishDto.toString());
        dishService.updateWithFlavor(dishDto);
        return R.success("新增菜品成功");
    }
```

DishService

```
//更新菜品信息同时更行对应的口味信息
    void updateWithFlavor(DishDto dishDto);
```

DishServiceImpl

```
//更新菜品信息同时更行对应的口味信息
    @Override
    @Transactional
    public void updateWithFlavor(DishDto dishDto) {
        //更新dish表信息
        this.updateById(dishDto);
        //清理当前菜品对应口味数据——dish_flavor表的delete操作
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DishFlavor::getDishId, dishDto.getId());
        dishFlavorService.remove(queryWrapper);
        //添加当前提交过来的口味数据--dish_flavor表的insert操作
        List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((item) -> {
            item.setDishId(dishDto.getId());
            return item;
        }).collect(Collectors.toList());
        dishFlavorService.saveBatch(flavors);
    }
```

```
        //添加当前提交过来的口味数据--dish_flavor表的insert操作
        List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((item) -> {
            item.setDishId(dishDto.getId());
            return item;
        }).collect(Collectors.toList());
        dishFlavorService.saveBatch(flavors);
        
```

```
这段代码的功能是将一个列表中的每个元素的dishId属性设置为dishDto的id，并保存到数据库中。

具体的代码释义如下：

List<DishFlavor> flavors = dishDto.getFlavors(); - 从dishDto对象中获取flavors列表，并赋值给flavors变量。
flavors = flavors.stream().map((item) -> { item.setDishId(dishDto.getId()); return item; }).collect(Collectors.toList()); - 使用流操作对flavors列表进行处理。对于每个元素，将其dishId属性设置为dishDto的id，并将处理后的元素收集到一个新的列表中。
dishFlavorService.saveBatch(flavors); - 调用dishFlavorService的saveBatch方法，将处理后的flavors列表保存到数据库中。

```

## 套餐管理业务开发

![image-20230714115234565](imgs/image-20230714115234565.png)

### 新增套餐

![image-20230704145843986](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230704145843986.png)

![image-20230714115249191](imgs/image-20230714115249191.png)

![image-20230714115302203](imgs/image-20230714115302203.png)

![image-20230714115312423](imgs/image-20230714115312423.png)

![image-20230714115321008](imgs/image-20230714115321008.png)

SetmealController

```
/**
     * 新增套餐
     * @param setmealDto
     * @return
     */
    @PostMapping
    public R<String> save(@RequestBody SetmealDto setmealDto) {
        setmealService.saveWithDish(setmealDto);
        return R.success("新增套餐成功");
    }

```

SetmealService

```
 //新增套餐同时需要保存套餐信息和菜品的关联关系表
    void saveWithDish(SetmealDto setmealDto);
```

SetmealServiceImpl

```
  /**
     * 新增套餐同时需要保存套餐信息和菜品的关联关系表
     *
     * @param setmealDto
     */
    @Transactional
    public void saveWithDish(SetmealDto setmealDto) {
        //保存套餐的基本信息,操作setmeal,执行insert操作
        this.save(setmealDto);

List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
        setmealDishes.stream().map((item) -> {
            item.setSetmealId(setmealDto.getId());
            return item;
        }).collect(Collectors.toList());
        //保存套餐和菜品的关联信息，操作setmeal_dish,执行insert操作
        setmealDishService.saveBatch(setmealDishes);
    }
```

### 套餐信息分页查询

![image-20230714115331220](imgs/image-20230714115331220.png)

SetmealController

```
/**
     * 套餐分页查询
     *
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page, int pageSize, String name) {
        //分页构造器对象
        Page<Setmeal> pageInfo = new Page<>(page, pageSize);
        Page<SetmealDto> dtoPage = new Page<>();
        LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
        // 添加查询条件，根据name进行like模糊查询
        queryWrapper.like(name!=null,Setmeal::getName, name);
        //添加排序条件 根据根据时间进行降序排列
        setmealService.page(pageInfo, queryWrapper);
        //对象拷贝
        BeanUtils.copyProperties(pageInfo, dtoPage, "records");
        List<Setmeal> records = pageInfo.getRecords();

List<SetmealDto> list = records.stream().map((item) -> {
            SetmealDto setmealDto = new SetmealDto();
            //对象拷贝
            BeanUtils.copyProperties(item, setmealDto);
            //分类id
            Long categoryId = item.getCategoryId();
            //根据分类id查询分类对象
            Category category = categoryService.getById(categoryId);
            if (category != null) {
                //分类名称
                String categoryName = category.getName();
                setmealDto.setCategoryName(categoryName);
            }
            return setmealDto;
        }).collect(Collectors.toList());
        dtoPage.setRecords(list);
        return R.success(dtoPage);
    }
```

### 删除套餐

![image-20230714115342443](imgs/image-20230714115342443.png)

## 短信发送

![image-20230714115350055](imgs/image-20230714115350055.png)

![image-20230714115405392](imgs/image-20230714115405392.png)

![image-20230714115414892](imgs/image-20230714115414892.png)

![image-20230714115423576](imgs/image-20230714115423576.png)

## 手机验证码登录

![image-20230714115442724](imgs/image-20230714115442724.png)

![image-20230714115459279](imgs/image-20230714115459279.png)

![image-20230714115507631](imgs/image-20230714115507631.png)

![image-20230714115522794](imgs/image-20230714115522794.png)

# 菜品展示、购物车、下单

![image-20230714115532019](imgs/image-20230714115532019.png)

## 导入用户地址簿

![image-20230714115542335](imgs/image-20230714115542335.png)

### 需求分析

![image-20230714115548815](imgs/image-20230714115548815.png)

### 数据模型

![image-20230714115606947](imgs/image-20230714115606947.png)

### 导入功能代码

![image-20230714115615278](imgs/image-20230714115615278.png)

AddressBookController

```
package com.xiaolong.takeaway.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.xiaolong.takeaway.common.BaseConText;
import com.xiaolong.takeaway.common.R;
import com.xiaolong.takeaway.entity.AddressBook;
import com.xiaolong.takeaway.service.AddressBookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 地址簿管理
 */
@Slf4j
@RestController
@RequestMapping("/addressBook")
public class AddressBookController {

@Autowired
    private AddressBookService addressBookService;

/**
     * 新增
     */
    @PostMapping
    public R<AddressBook> save(@RequestBody AddressBook addressBook) {
        addressBook.setUserId(BaseConText.getCurrentId());
        log.info("addressBook:{}", addressBook);
        addressBookService.save(addressBook);
        return R.success(addressBook);
    }

/**
     * 设置默认地址
     */
    @PutMapping("default")
    public R<AddressBook> setDefault(@RequestBody AddressBook addressBook) {
        log.info("addressBook:{}", addressBook);
        LambdaUpdateWrapper<AddressBook> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(AddressBook::getUserId, BaseConText.getCurrentId());
        wrapper.set(AddressBook::getIsDefault, 0);
        //SQL:update address_book set is_default = 0 where user_id = ?
        addressBookService.update(wrapper);

addressBook.setIsDefault(1);
        //SQL:update address_book set is_default = 1 where id = ?
        addressBookService.updateById(addressBook);
        return R.success(addressBook);
    }

/**
     * 根据id查询地址
     */
    @GetMapping("/{id}")
    public R get(@PathVariable Long id) {
        AddressBook addressBook = addressBookService.getById(id);
        if (addressBook != null) {
            return R.success(addressBook);
        } else {
            return R.error("没有找到该对象");
        }
    }

/**
     * 查询默认地址
     */
    @GetMapping("default")
    public R<AddressBook> getDefault() {
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AddressBook::getUserId, BaseConText.getCurrentId());
        queryWrapper.eq(AddressBook::getIsDefault, 1);

//SQL:select * from address_book where user_id = ? and is_default = 1
        AddressBook addressBook = addressBookService.getOne(queryWrapper);

if (null == addressBook) {
            return R.error("没有找到该对象");
        } else {
            return R.success(addressBook);
        }
    }

/**
     * 查询指定用户的全部地址
     */
    @GetMapping("/list")
    public R<List<AddressBook>> list(AddressBook addressBook) {
        addressBook.setUserId(BaseConText.getCurrentId());
        log.info("addressBook:{}", addressBook);

//条件构造器
        LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(null != addressBook.getUserId(), AddressBook::getUserId, addressBook.getUserId());
        queryWrapper.orderByDesc(AddressBook::getUpdateTime);

//SQL:select * from address_book where user_id = ? order by update_time desc
        return R.success(addressBookService.list(queryWrapper));
    }
}

```

## 菜品展示

![image-20230714115625246](imgs/image-20230714115625246.png)

![image-20230714115634290](imgs/image-20230714115634290.png)

![image-20230714115643246](imgs/image-20230714115643246.png)

## 购物车

![image-20230714115650311](imgs/image-20230714115650311.png)

### 需求分析

![image-20230714115658470](imgs/image-20230714115658470.png)

### 数据模型

![image-20230714115710886](imgs/image-20230714115710886.png)

### 代码开发

![image-20230714115720222](imgs/image-20230714115720222.png)

代码实现：

```
package com.xiaolong.takeaway.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xiaolong.takeaway.common.BaseContext;
import com.xiaolong.takeaway.common.R;
import com.xiaolong.takeaway.entity.ShoppingCart;
import com.xiaolong.takeaway.service.ShoppingCartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author xiaolong
 * @date 2023年05月28日 0:55
 */
@RestController
@RequestMapping("/shoppingCart")
@Slf4j
public class ShoppingCartController {

@Resource
	private ShoppingCartService shoppingCartService;

/**
	 * 添加购物车
	 *
	 * @param shoppingCart
	 */
	@PostMapping("/add")
	public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart) {
		// 设置用户ID，指定当前是哪个用户的购物车数据
		Long currentId = BaseContext.getCurrentId();
		shoppingCart.setUserId(currentId);
		// 构造查询条件
		LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(ShoppingCart::getUserId, currentId);
		// 查询当前菜品或者套餐是否在购物车里
		Long dishId = shoppingCart.getDishId();
		// 根据菜品ID是否为NULL
		if (dishId != null) {
			// 添加菜品
			queryWrapper.eq(ShoppingCart::getDishId, dishId);
		} else {
			// 添加套餐
			queryWrapper.eq(ShoppingCart::getSetmealId, shoppingCart.getSetmealId());
		}
		ShoppingCart shoppingCartOne = shoppingCartService.getOne(queryWrapper);
		if (shoppingCartOne != null) {
			// 如果存在就在原来基础上加上1
			Integer number = shoppingCartOne.getNumber();
			shoppingCartOne.setNumber(number + 1);
			shoppingCartService.updateById(shoppingCartOne);
		} else {
			// 如果不存在则添加至购物车默认为1
			shoppingCart.setNumber(1);
			shoppingCartService.save(shoppingCart);
			shoppingCartOne = shoppingCart;
		}
		return R.success(shoppingCartOne);
	}

/**
	 * 查询购物车
	 *
	 * @return
	 */
	@GetMapping("/list")
	public R<List<ShoppingCart>> list() {
		// 构建查询条件 根据用户ID查询
		LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
		queryWrapper.orderByAsc(ShoppingCart::getCreateTime);
		List<ShoppingCart> list = shoppingCartService.list(queryWrapper);
		return R.success(list);
	}

/**
	 * 清空购物车
	 *
	 * @return
	 */
	@DeleteMapping("/clean")
	public R<String> clean() {
		LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
		shoppingCartService.remove(queryWrapper);
		return R.success("清空购物车成功");

}

/**
	 * 客户端的套餐或者是菜品数量减少设置
	 * 没必要设置返回值
	 *
	 * @param shoppingCart
	 */
	@PostMapping("/sub")
	@Transactional
	public R<ShoppingCart> sub(@RequestBody ShoppingCart shoppingCart) {

Long dishId = shoppingCart.getDishId();
		LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();

//代表数量减少的是菜品数量
		if (dishId != null) {
			//通过dishId查出购物车对象
			queryWrapper.eq(ShoppingCart::getDishId, dishId);
			//这里必须要加两个条件，否则会出现用户互相修改对方与自己购物车中相同套餐或者是菜品的数量
			queryWrapper.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
			ShoppingCart cart1 = shoppingCartService.getOne(queryWrapper);
			cart1.setNumber(cart1.getNumber() - 1);
			Integer LatestNumber = cart1.getNumber();
			if (LatestNumber > 0) {
				//对数据进行更新操作
				shoppingCartService.updateById(cart1);
			} else if (LatestNumber == 0) {
				//如果购物车的菜品数量减为0，那么就把菜品从购物车删除
				shoppingCartService.removeById(cart1.getId());
			} else if (LatestNumber < 0) {
				return R.error("操作异常");
			}

return R.success(cart1);
		}

Long setmealId = shoppingCart.getSetmealId();
		if (setmealId != null) {
			//代表是套餐数量减少
			queryWrapper.eq(ShoppingCart::getSetmealId, setmealId).eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
			ShoppingCart cart2 = shoppingCartService.getOne(queryWrapper);
			cart2.setNumber(cart2.getNumber() - 1);
			Integer LatestNumber = cart2.getNumber();
			if (LatestNumber > 0) {
				//对数据进行更新操作
				shoppingCartService.updateById(cart2);
			} else if (LatestNumber == 0) {
				//如果购物车的套餐数量减为0，那么就把套餐从购物车删除
				shoppingCartService.removeById(cart2.getId());
			} else if (LatestNumber < 0) {
				return R.error("操作异常");
			}
			return R.success(cart2);
		}
		//如果两个大if判断都进不去
		return R.error("操作异常");
	}

}

```

## 用户下单

![image-20230714115730932](imgs/image-20230714115730932.png)

### 需求分析

![image-20230714115740081](imgs/image-20230714115740081.png)

### 数据模型

![image-20230714115752153](imgs/image-20230714115752153.png)

![image-20230714115802222](imgs/image-20230714115802222.png)

![image-20230714115811024](imgs/image-20230714115811024.png)

![image-20230714115819413](imgs/image-20230714115819413.png)

![image-20230714115830581](imgs/image-20230714115830581.png)

### 代码开发

Controller

```
package com.xiaolong.takeaway.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xiaolong.takeaway.common.BaseContext;
import com.xiaolong.takeaway.common.R;
import com.xiaolong.takeaway.dto.OrdersDto;
import com.xiaolong.takeaway.entity.OrderDetail;
import com.xiaolong.takeaway.entity.Orders;
import com.xiaolong.takeaway.entity.ShoppingCart;
import com.xiaolong.takeaway.service.OrdersService;
import com.xiaolong.takeaway.service.ShoppingCartService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author xiaolong
 * @date 2023年05月28日 17:20
 */
@RestController
@RequestMapping("/order")
@Slf4j
public class OrdersController {

@Resource
	private OrdersService ordersService;

@Resource
	private com.xiaolong.takeaway.service.OrderDetailService OrderDetailService;

@Resource
	private ShoppingCartService shoppingCartService;

/**
	 * 下单
	 *
	 * @param orders
	 * @return
	 */
	@PostMapping("/submit")
	public R<String> submit(@RequestBody Orders orders) {
		ordersService.submit(orders);
		return R.success("下单成功");
	}

/**
	 * 后端管理查询查询订单
	 */
	@GetMapping("/page")
	public R<Page<Orders>> page(int page, int pageSize, String number,
								@DateTimeFormat(pattern = "yyyy-mm-dd HH:mm:ss") Date beginTime,
								@DateTimeFormat(pattern = "yyyy-mm-dd HH:mm:ss") Date endTime) {
		log.info("beginTime={},endTime={}", beginTime, endTime);
		// 构建订单分页对象
		Page<Orders> pageInfo = new Page<>(page, pageSize);
		// 构造条件
		LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper();
		// 模糊查询根据订单号或者时间间隔查询
		// SELECT * FROM Order where number like ? or order_time between ? and ?
		queryWrapper.like(StringUtils.isNotEmpty(number), Orders::getNumber, number);
		if (beginTime != null) {
			queryWrapper.between(Orders::getOrderTime, beginTime, endTime);
		}
		// 时间降序
		queryWrapper.orderByDesc(Orders::getOrderTime);
		// 封装为分页对象
		ordersService.page(pageInfo, queryWrapper);
		return R.success(pageInfo);
	}

/**
	 * 订单状态修改
	 *
	 * @param orders
	 * @return
	 */
	@PutMapping()
	public R<String> orderStatus(@RequestBody Orders orders) {
		// 修改状态
		ordersService.updateById(orders);
		return R.success("修改成功");
	}

//    /**
//     * 用户订单分页查询
//     * @param page
//     * @param pageSize
//     * @return
//     */
//    @GetMapping("/userPage")
//    public R<Page> page(int page, int pageSize){
//
//        //分页构造器对象
//        Page<Orders> pageInfo = new Page<>(page,pageSize);
//        //构造条件查询对象
//        LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
//
//        //添加排序条件，根据更新时间降序排列
//        queryWrapper.orderByDesc(Orders::getOrderTime);
//        ordersService.page(pageInfo,queryWrapper);
//
//        return R.success(pageInfo);
//    }

//抽离的一个方法，通过订单id查询订单明细，得到一个订单明细的集合
	//这里抽离出来是为了避免在stream中遍历的时候直接使用构造条件来查询导致eq叠加，从而导致后面查询的数据都是null
	public List<OrderDetail> getOrderDetailListByOrderId(Long orderId) {
		LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(OrderDetail::getOrderId, orderId);
		List<OrderDetail> orderDetailList = OrderDetailService.list(queryWrapper);
		return orderDetailList;
	}

/**
	 * 用户端展示自己的订单分页查询
	 *
	 * @param page
	 * @param pageSize
	 * @return 遇到的坑：原来分页对象中的records集合存储的对象是分页泛型中的对象，里面有分页泛型对象的数据
	 * 开始的时候我以为前端只传过来了分页数据，其他所有的数据都要从本地线程存储的用户id开始查询，
	 * 结果就出现了一个用户id查询到 n个订单对象，然后又使用 n个订单对象又去查询 m 个订单明细对象，
	 * 结果就出现了评论区老哥出现的bug(嵌套显示数据....)
	 * 正确方法:直接从分页对象中获取订单id就行，问题大大简化了......
	 */
	@GetMapping("/userPage")
	public R<Page> page(int page, int pageSize) {
		//分页构造器对象
		Page<Orders> pageInfo = new Page<>(page, pageSize);
		Page<OrdersDto> pageDto = new Page<>(page, pageSize);
		//构造条件查询对象
		LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(Orders::getUserId, BaseContext.getCurrentId());
		//这里是直接把当前用户分页的全部结果查询出来，要添加用户id作为查询条件，否则会出现用户可以查询到其他用户的订单情况
		//添加排序条件，根据更新时间降序排列
		queryWrapper.orderByDesc(Orders::getOrderTime);
		ordersService.page(pageInfo, queryWrapper);

//通过OrderId查询对应的OrderDetail
		LambdaQueryWrapper<OrderDetail> queryWrapper2 = new LambdaQueryWrapper<>();

//对OrderDto进行需要的属性赋值
		List<Orders> records = pageInfo.getRecords();
		List<OrdersDto> orderDtoList = records.stream().map((item) -> {
			OrdersDto orderDto = new OrdersDto();
			//此时的orderDto对象里面orderDetails属性还是空 下面准备为它赋值
			Long orderId = item.getId();//获取订单id
			List<OrderDetail> orderDetailList = this.getOrderDetailListByOrderId(orderId);
			BeanUtils.copyProperties(item, orderDto);
			//对orderDto进行OrderDetails属性的赋值
			orderDto.setOrderDetails(orderDetailList);
			return orderDto;
		}).collect(Collectors.toList());
		//使用dto的分页有点难度.....需要重点掌握
		BeanUtils.copyProperties(pageInfo, pageDto, "records");
		pageDto.setRecords(orderDtoList);
		return R.success(pageDto);
	}

//客户端点击再来一单

/**
	 * 前端点击再来一单是直接跳转到购物车的，所以为了避免数据有问题，再跳转之前我们需要把购物车的数据给清除
	 * ①通过orderId获取订单明细
	 * ②把订单明细的数据的数据塞到购物车表中，不过在此之前要先把购物车表中的数据给清除(清除的是当前登录用户的购物车表中的数据)，
	 * 不然就会导致再来一单的数据有问题；
	 * (这样可能会影响用户体验，但是对于外卖来说，用户体验的影响不是很大，电商项目就不能这么干了)
	 */
	@PostMapping("/again")
	public R<String> againSubmit(@RequestBody Map<String, String> map) {
		String ids = map.get("id");

long id = Long.parseLong(ids);

LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
		queryWrapper.eq(OrderDetail::getOrderId, id);
		//获取该订单对应的所有的订单明细表
		List<OrderDetail> orderDetailList = OrderDetailService.list(queryWrapper);

//通过用户id把原来的购物车给清空，这里的clean方法是视频中讲过的,建议抽取到service中,那么这里就可以直接调用了
		LambdaQueryWrapper<ShoppingCart> queryWrapper1 = new LambdaQueryWrapper<>();
		queryWrapper1.eq(ShoppingCart::getUserId, BaseContext.getCurrentId());
		shoppingCartService.remove(queryWrapper1);
		//shoppingCartService.clean();

//获取用户id
		Long userId = BaseContext.getCurrentId();
		List<ShoppingCart> shoppingCartList = orderDetailList.stream().map((item) -> {
			//把从order表中和order_details表中获取到的数据赋值给这个购物车对象
			ShoppingCart shoppingCart = new ShoppingCart();
			shoppingCart.setUserId(userId);
			shoppingCart.setImage(item.getImage());
			Long dishId = item.getDishId();
			Long setmealId = item.getSetmealId();
			if (dishId != null) {
				//如果是菜品那就添加菜品的查询条件
				shoppingCart.setDishId(dishId);
			} else {
				//添加到购物车的是套餐
				shoppingCart.setSetmealId(setmealId);
			}
			shoppingCart.setName(item.getName());
			shoppingCart.setDishFlavor(item.getDishFlavor());
			shoppingCart.setNumber(item.getNumber());
			shoppingCart.setAmount(item.getAmount());
			shoppingCart.setCreateTime(LocalDateTime.now());
			return shoppingCart;
		}).collect(Collectors.toList());

//把携带数据的购物车批量插入购物车表  这个批量保存的方法要使用熟练！！！
		shoppingCartService.saveBatch(shoppingCartList);

return R.success("操作成功");
	}
}

```

Service

```
package com.xiaolong.takeaway.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.xiaolong.takeaway.entity.Orders;

/**
 * @author xiaolong
 * @date 2023年05月28日 17:17
 */
public interface OrdersService extends IService<Orders> {

/**
     * 提交用户订单
     * @param orders
     */
    void submit(Orders orders);
}

```

Impl

```
package com.xiaolong.takeaway.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaolong.takeaway.common.BaseContext;
import com.xiaolong.takeaway.common.CustomException;
import com.xiaolong.takeaway.entity.*;
import com.xiaolong.takeaway.mapper.OrdersMapper;
import com.xiaolong.takeaway.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

/**
 * @author xiaolong
 * @date 2023年05月28日 17:18
 */
@Service
public class OrdersServiceImpl extends ServiceImpl<OrdersMapper, Orders> implements OrdersService {

// @Resource
    // private ShoppingCartService shoppingCartService;
    //
    // @Resource
    // private UserService userService;
    //
    // @Resource
    // private AddressBookService addressBookService;
    //
    // @Resource
    // private OrderDetailService orderDetailService;
    //
    // /**
    //  * 提交用户订单
    //  * @param orders
    //  */
    // @Override
    // @Transactional
    // public void submit(Orders orders) {
    //     // 获取当前用户
    //     Long currentId = BaseContext.getCurrentId();
    //     orders.setUserId(currentId);
    //     // 查询当前用户的购物车数据
    //     LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
    //     queryWrapper.eq(ShoppingCart::getUserId,currentId);
    //     List<ShoppingCart> shoppingCarts = shoppingCartService.list(queryWrapper);
    //     // 判断购物车
    //     if (shoppingCarts==null||shoppingCarts.size()==0){
    //         throw new CustomException("购物车为空，不能下单");
    //     }
    //     // 查询用户数据
    //     User user = userService.getById(currentId);
    //     // 查询地址数据
    //     Long addressBookId = orders.getAddressBookId();
    //     AddressBook addressBook = addressBookService.getById(addressBookId);
    //     if(addressBook==null){
    //         throw new CustomException("地址为空，不能下单");
    //     }
    //     // 订单号
    //     long orderId = IdWorker.getId();
    //     // 计算购物车总金额 保证多线程情况下线程安全计算
    //     AtomicInteger amount = new AtomicInteger(0);
    //     List<OrderDetail> orderDetails = shoppingCarts.stream().map((item) -> {
    //         OrderDetail orderDetail = new OrderDetail();
    //         orderDetail.setOrderId(orderId);
    //         orderDetail.setNumber(item.getNumber());
    //         orderDetail.setDishFlavor(item.getDishFlavor());
    //         orderDetail.setDishId(item.getDishId());
    //         orderDetail.setSetmealId(item.getSetmealId());
    //         orderDetail.setName(item.getName());
    //         orderDetail.setImage(item.getImage());
    //         orderDetail.setAmount(item.getAmount());
    //         amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
    //         return orderDetail;
    //     }).collect(Collectors.toList());
    //
    //     // 设置订单信息
    //     orders.setId(orderId);
    //     orders.setOrderTime(LocalDateTime.now());
    //     orders.setCheckoutTime(LocalDateTime.now());
    //     orders.setStatus(2);
    //     orders.setAmount(new BigDecimal(amount.get()));//总金额
    //     orders.setUserId(currentId);
    //     orders.setNumber(String.valueOf(orderId));
    //     orders.setUserName(user.getName());
    //     orders.setConsignee(addressBook.getConsignee());
    //     orders.setPhone(addressBook.getPhone());
    //     orders.setAddress((addressBook.getProvinceName() == null ? "" : addressBook.getProvinceName())
    //             + (addressBook.getCityName() == null ? "" : addressBook.getCityName())
    //             + (addressBook.getDistrictName() == null ? "" : addressBook.getDistrictName())
    //             + (addressBook.getDetail() == null ? "" : addressBook.getDetail()));
    //     //向订单表插入数据，一条数据
    //     this.save(orders);
    //
    //     //向订单明细表插入数据，多条数据
    //     orderDetailService.saveBatch(orderDetails);
    //
    //     //清空购物车数据
    //     shoppingCartService.remove(queryWrapper);
    //
    //
    // }
    @Autowired
    private ShoppingCartService shoppingCartService;

@Autowired
    private UserService userService;

@Autowired
    private AddressBookService addressBookService;

@Autowired
    private OrderDetailService orderDetailService;

/**
     * 用户下单
     * @param orders
     */
    @Transactional
    public void submit(Orders orders) {
        //获得当前用户id
        Long userId = BaseContext.getCurrentId();

//查询当前用户的购物车数据
        LambdaQueryWrapper<ShoppingCart> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ShoppingCart::getUserId,userId);
        List<ShoppingCart> shoppingCarts = shoppingCartService.list(wrapper);

if(shoppingCarts == null || shoppingCarts.size() == 0){
            throw new CustomException("购物车为空，不能下单");
        }

//查询用户数据
        User user = userService.getById(userId);

//查询地址数据
        Long addressBookId = orders.getAddressBookId();
        AddressBook addressBook = addressBookService.getById(addressBookId);
        if(addressBook == null){
            throw new CustomException("用户地址信息有误，不能下单");
        }

long orderId = IdWorker.getId();//订单号

AtomicInteger amount = new AtomicInteger(0);

List<OrderDetail> orderDetails = shoppingCarts.stream().map((item) -> {
            OrderDetail orderDetail = new OrderDetail();
            orderDetail.setOrderId(orderId);
            orderDetail.setNumber(item.getNumber());
            orderDetail.setDishFlavor(item.getDishFlavor());
            orderDetail.setDishId(item.getDishId());
            orderDetail.setSetmealId(item.getSetmealId());
            orderDetail.setName(item.getName());
            orderDetail.setImage(item.getImage());
            orderDetail.setAmount(item.getAmount());
            amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
            return orderDetail;
        }).collect(Collectors.toList());

orders.setId(orderId);
        orders.setOrderTime(LocalDateTime.now());
        orders.setCheckoutTime(LocalDateTime.now());
        orders.setStatus(2);
        orders.setAmount(new BigDecimal(amount.get()));//总金额
        orders.setUserId(userId);
        orders.setNumber(String.valueOf(orderId));
        orders.setUserName(user.getName());
        orders.setConsignee(addressBook.getConsignee());
        orders.setPhone(addressBook.getPhone());
        orders.setAddress((addressBook.getProvinceName() == null ? "" : addressBook.getProvinceName())
                + (addressBook.getCityName() == null ? "" : addressBook.getCityName())
                + (addressBook.getDistrictName() == null ? "" : addressBook.getDistrictName())
                + (addressBook.getDetail() == null ? "" : addressBook.getDetail()));
        //向订单表插入数据，一条数据
        this.save(orders);

//向订单明细表插入数据，多条数据
        orderDetailService.saveBatch(orderDetails);

//清空购物车数据
        shoppingCartService.remove(wrapper);
    }
}

```

# 项目优化

![image-20230714115846357](imgs/image-20230714115846357.png)

## 环境搭建

### Maven坐标

```
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
```

### 配置文件

在application.yml中加入redis相关配置

```
redis:
    host: 127.0.0.1
    port: 6379
    password: 123456
    database: 0
```

### 配置类

RedisConfig

```
package com.xiaolong.takeaway.config;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
	@Bean
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
		RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
		//默认的Key序列化器为：JdkSerializationRedisSerializer
		redisTemplate.setKeySerializer(new StringRedisSerializer());
		redisTemplate.setConnectionFactory(connectionFactory);
		return redisTemplate;
	}
}

```

## 缓存短信验证码

![image-20230714115905865](imgs/image-20230714115905865.png)

## 缓存菜品数据

![image-20230714115854879](imgs/image-20230714115854879.png)

## Spring cache

![image-20230714115945660](imgs/image-20230714115945660.png)

![image-20230714115953935](imgs/image-20230714115953935.png)

## 缓存套餐数据

# 数据库表结构

![外卖系统数据库关系图](imgs/外卖系统数据库关系图.png)

# Linux

![image-20230714141121875](imgs/image-20230714141121875.png)

![image-20230714141131401](imgs/image-20230714141131401.png)

![image-20230714141148127](imgs/image-20230714141148127.png)

## 在linux中部署项目需要用到：

```
要在Linux上部署Spring Boot + Vue前后端分离项目，您需要安装以下几个主要组件和工具：

1. Java运行时环境（JRE）：确保您的Linux服务器上已安装适当版本的Java运行时环境，用于运行Spring Boot应用程序。

2. Node.js和npm：Node.js是一个JavaScript运行时环境，而npm是Node.js的包管理器。您可以使用npm来安装和管理您的前端依赖项。在Linux上安装Node.js和npm可以使用包管理器例如apt或yum，也可以手动下载安装。

3. Nginx：Nginx是一个高性能的Web服务器和反向代理服务器，用于提供前端静态文件和代理后端API请求。在Linux上安装Nginx可以使用包管理器，并根据需要进行相关配置。

4. 编译工具（如Maven或Gradle）：如果您使用的是Java项目，需要安装适当的编译工具来构建项目。例如，使用Maven进行编译和构建管理，可以安装Maven并配置环境变量。

5. Git：Git是一个版本控制工具，用于管理您的项目代码。您可以安装Git来克隆和更新代码库。

6. 数据库：根据您的项目需求，您可能需要安装和配置相应的数据库，例如MySQL、PostgreSQL或MongoDB等。

以上是基本的组件和工具列表，根据您的项目需求和特定的技术栈，可能还需要安装其他依赖项和工具。请确保在部署之前详细了解项目的要求和依赖，以便正确安装和配置所需的组件。
```

### 在CentOS上安装JRE

```
在CentOS上安装Java Runtime Environment（JRE）可以按照以下步骤进行：
1. 打开终端并使用root用户或具有管理员权限的用户登录到CentOS系统。

2. 使用以下命令更新系统软件包：
```
   sudo yum update
   ```

3. 安装OpenJDK（Open Java Development Kit），它是一个开源的JRE实现：
   ```
   sudo yum install java-1.8.0-openjdk
   ```

请注意，上述命令会安装Java 8，你也可以选择其他版本，例如java-11-openjdk或java-14-openjdk等。

4. 验证Java安装是否成功：
   输入以下命令检查Java版本：
   ```
   java -version
   ```

如果成功安装，你应该能够看到Java的版本信息。

以上步骤将帮助你在CentOS上安装OpenJDK并配置JRE。你可以根据自己的需要来选择适合的Java版本，并通过验证命令来确认安装是否成功。
   ```

### 在CentOS上安装Node.js和npm

```
在CentOS上安装Node.js和npm，你可以按照以下步骤进行操作：

1. 更新系统软件包列表：
```
   sudo yum update
   ```

2. 安装Node.js和npm的包管理器，使用以下命令：
   ```
   sudo yum install -y gcc-c++ make
   curl -sL https://rpm.nodesource.com/setup_14.x | sudo -E bash -
   sudo yum install -y nodejs
   ```

上述代码假定你要安装的是Node.js 14版本（可以根据需要修改版本号），它还安装了必要的编译工具（gcc-c++和make）。

3. 验证Node.js和npm是否已成功安装。运行以下命令，分别检查Node.js和npm的版本：
   ```
   node -v
   npm -v
   ```

如果输出了相应的版本号，则说明安装成功。

这样，你就成功在CentOS上安装了Node.js和npm。你可以使用它们来开发和运行JavaScript应用程序。

希望对你有所帮助！如果还有其他问题，请随时提问。
   ```

### 在CentOS中安装Tomcat

```
在CentOS中安装Tomcat，你可以按照以下步骤进行操作：

1. 下载Tomcat安装包。你可以在Tomcat官方网站（http://tomcat.apache.org/）上找到适合你的Tomcat版本和安装包。

2. 在CentOS上创建Tomcat目录。使用以下命令：
```
   sudo mkdir /opt/tomcat
   ```

3. 解压安装包并将文件复制到Tomcat目录。使用以下命令：
   ```
   sudo tar -xf <tomcat-package.tar.gz> -C /opt/tomcat --strip-components=1
   ```

将 `<tomcat-package.tar.gz>` 替换为你下载的Tomcat安装包的文件名。

4. 更改Tomcat文件夹及其内容的权限，使用以下命令：
   ```
   sudo chown -R <username> /opt/tomcat
   sudo chmod +x /opt/tomcat/bin/*.sh
   ```

将 `<username>` 替换为你的用户名。

5. 配置环境变量。打开`.bashrc`或`.bash_profile`文件，使用以下命令：
   ```
   vi ~/.bashrc
   ```

将以下行添加到文件底部：
   ```
   export CATALINA_HOME="/opt/tomcat"
   ```

保存并关闭文件。

6. 重新加载bash配置文件，使用以下命令：
   ```
   source ~/.bashrc
   ```

7. 启动Tomcat服务，使用以下命令：
   ```
   $CATALINA_HOME/bin/startup.sh
   ```

8. 验证Tomcat是否成功安装。在Web浏览器中输入服务器的IP地址或域名，加上Tomcat默认端口号8080（例如，http://localhost:8080）。

如果看到Tomcat欢迎页面，则表示Tomcat已成功安装。

现在，你已经成功在CentOS上安装了Tomcat。你可以配置Tomcat以适应你的需求，并部署Java Web应用程序。

希望对你有所帮助！如果还有其他问题，请随时提问。
   ```

### 在CentOS上安装Nginx

```
在CentOS上安装Nginx，你可以按照以下步骤进行操作：

1. 更新系统软件包列表：
```
   sudo yum update
   ```

2. 安装Nginx软件包，使用以下命令：
   ```
   sudo yum install epel-release
   sudo yum install nginx
   ```

第一条命令用于安装额外的软件包仓库（EPEL）。

3. 安装完成后，启动Nginx服务，使用以下命令：
   ```
   sudo systemctl start nginx
   ```

4. 验证安装是否成功。
在CentOS中，你可以通过以下方法验证Nginx是否成功安装：

1. 检查Nginx服务状态，使用以下命令：
   ```
   sudo systemctl status nginx
   ```

如果Nginx已成功安装并正在运行，你将看到类似以下输出：
   ```
   ● nginx.service - The nginx HTTP and reverse proxy server
   Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
   Active: active (running) since <timestamp>
   ...
   ```

在`Active:`行的状态中，如果显示`(running)`，则表示Nginx已成功安装并正在运行。

2. 打开Web浏览器，并在地址栏中输入服务器的IP地址或域名。

如果你看到类似以下的页面内容，则表示Nginx安装成功：
   ```
   Welcome to nginx!
   ```

这是Nginx的默认页面，表明Nginx已准备就绪并可以提供Web服务。

如果在上述步骤中都没有出现错误，那么Nginx已经成功安装在CentOS上并正在运行。

5. 配置Nginx自动启动，并开启防火墙端口。使用以下命令：
   ```
   sudo systemctl enable nginx
   sudo firewall-cmd --permanent --add-service=http
   sudo firewall-cmd --reload

```

第一条命令将Nginx服务添加到自动启动列表中，以便在系统启动时自动启动Nginx。第二条命令开放HTTP端口80，允许外部访问Nginx服务。第三条命令重新加载防火墙配置。

现在，你已经成功在CentOS上安装了Nginx，并可以通过服务器的IP地址或域名访问Nginx的默认页面。

希望对你有所帮助！如果还有其他问题，请随时提问。
   ```

### 在CentOS上安装Maven并配置环境变量

```
要在CentOS上安装Maven并配置环境变量，您可以按照以下步骤进行操作：

1. 打开终端并以root权限登录。
2. 安装Java Development Kit (JDK)。Maven需要依赖Java，请确保已经安装了JDK。您可以在终端中运行以下命令来检查是否安装了JDK：

```shell
   java -version
```

如果未安装JDK，请使用适合您的方式安装。您可以参考OpenJDK官方网站获得更多信息。

3. 下载Maven。您可以在Maven官方网站（https://maven.apache.org/download.cgi）的下载页面中找到最新的稳定版本。使用wget或curl命令下载Maven安装包。例如，对于Maven 3.8.1版本，可以运行以下命令：

```shell
   wget https://downloads.apache.org/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz
   ```

4. 解压缩Maven安装包。运行以下命令解压缩刚刚下载的Maven安装包：

```shell
   tar -zxvf apache-maven-3.8.8-bin.tar.gz
   ```

5. 将Maven移动到适当的位置。将解压缩后的Maven文件夹移动到适当的位置，例如`/opt`目录下：

```shell
   mv apache-maven-3.8.8 /opt
   ```

6. 配置环境变量。打开`/etc/profile`文件，并在文件末尾添加以下行：

```shell
   export M2_HOME=/opt/apache-maven-3.8.8
   export MAVEN_HOME=/opt/apache-maven-3.8.8
   export PATH=${M2_HOME}/bin:${PATH}
   ```

保存并关闭文件后，使用以下命令使更改生效：

```shell
   source /etc/profile
   ```

7. 验证安装。在终端中运行以下命令验证Maven是否成功安装：

```shell
   mvn -v
   ```

如果成功安装，并显示Maven的版本信息，则表示安装和配置都已成功完成。

现在您已经在CentOS上成功安装了Maven并配置了环境变量。您可以开始使用Maven来构建和管理Java项目了。

### 在CentOS上安装Git

在CentOS上安装Git，您可以按照以下步骤进行操作：

1. 更新系统软件包：
   ```bash
   sudo yum update
   ```

2. 安装Git：
   ```bash
   sudo yum install git
   ```

如果提示确认安装，请输入`Y`继续安装。

3. 验证Git安装：
   ```bash
   git --version
   ```

如果成功安装，您将看到Git的版本信息。

4. 配置Git用户信息：
   - 设置全局用户名：
     ```bash
     git config --global user.name "Your Name"
     ```

- 设置全局用户邮箱：
     ```bash
     git config --global user.email "your.email@example.com"
     ```

将上述命令中的`Your Name`替换为您的姓名，`your.email@example.com`替换为您的邮箱地址。

5. （可选）配置Git的其他设置，如编辑器、默认分支等。您可以根据需要使用以下命令进行配置：
   ```bash
   git config --global core.editor "vim"
   git config --global init.defaultBranch "main"
   ```

上述命令将编辑器设置为Vim，并将默认分支设置为"main"。

安装完成后，您就可以在CentOS上使用Git版本控制工具了。您可以使用`git clone`命令克隆Git代码库，使用`git add`和`git commit`命令管理文件变更，并使用其他Git命令进行版本控制操作。

### 在CentOS上安装MySQL

在CentOS上安装MySQL，您可以按照以下步骤进行操作：

1. 更新系统软件包：
   ```bash
   sudo yum update
   ```

2. 安装MySQL软件包：
   ```bash
   sudo yum install mysql-server
   ```

如果提示确认安装，请输入`Y`继续安装。

3. 启动MySQL服务：
   ```bash
   sudo systemctl start mysqld
   ```

4. 运行安全脚本以加强MySQL安全性：
   ```bash
   sudo mysql_secure_installation
   ```

您将会被要求设置root密码和其他安全选项。建议按照提示进行设置。

5. 验证MySQL安装：
   ```bash
   mysql --version
   ```

如果成功安装，您将看到MySQL的版本信息。

6. 运行MySQL服务，使其在系统启动时自动启动：
   ```bash
   sudo systemctl enable mysqld
   ```

现在，MySQL已成功安装在您的CentOS系统上。您可以使用命令行或其他MySQL客户端工具连接到MySQL服务，并进行数据库的创建、管理和查询等操作。

### 在CentOS上安装Redis

在CentOS上安装Redis，您可以按照以下步骤进行操作：

1. 更新系统软件包：
   ```bash
   sudo yum update
   ```

2. 安装Redis软件包：
   ```bash
   sudo yum install redis
   ```

如果提示确认安装，请输入`Y`继续安装。

3. 启动Redis服务：
   ```bash
   sudo systemctl start redis
   ```

4. 配置Redis为在系统启动时自动启动：
   ```bash
   sudo systemctl enable redis
   ```

5. 验证Redis安装：
   ```bash
   redis-cli --version
   ```

如果成功安装，您将看到Redis的版本信息。

此时，Redis已经成功安装在您的CentOS系统上，并且Redis服务已经启动。您可以使用`redis-cli`命令行工具连接到Redis服务器，并进行操作，如设置键值对、执行命令等。此外，如果需要通过网络远程访问Redis服务，您可能需要配置防火墙规则和Redis的配置文件进行相关设置。

## 在CentOS中设置linux时钟校准

在CentOS中配置NTP服务器相对简单，以下是一般的步骤：

1. 安装NTP服务器软件：
   在终端中执行以下命令安装NTP软件包：

```
  sudo yum install ntp
```

2. 配置NTP服务器：
   
   ```
   2. 使用任一文本编辑器（如vi或nano）打开NTP服务器配置文件`/etc/ntp.conf`：
   
      sudo vi /etc/ntp.conf
   ```

3. 将以下内容添加到配置文件中（根据你的需求可根据实际情况进行修改）：

```
  driftfile /var/lib/ntp/ntp.drift

server 0.pool.ntp.org
   server 1.pool.ntp.org
   server 2.pool.ntp.org
   server 3.pool.ntp.org
```

4. 保存并关闭文件。

5. 启动NTP服务：
   执行以下命令启动NTP服务：

sudo systemctl start ntpd

6. 设置NTP服务开机自启动：
   执行以下命令使NTP服务在系统启动时自动启动：

sudo systemctl enable ntpd

7. 验证NTP服务器状态：
   执行以下命令检查NTP服务器的状态：

systemctl status ntpd

如果一切顺利，应该会显示NTP服务器正在运行且同步至指定的NTP服务器。

![image-20230714141209044](imgs/image-20230714141209044.png)

![image-20230714141217671](imgs/image-20230714141217671.png)

## linux常用命令

![image-20230714141229944](imgs/image-20230714141229944.png)

![image-20230704214949378](C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230704214949378.png)

# 问题总结：

## 在实现插入操作自动填充时，代码提示：

Cause: java.sql.SQLException: Field 'create_time' doesn't have a default value
```

```
原因：java.sql.sql异常：字段“create_time”没有默认值

![image-20230714141240720](imgs/image-20230714141240720.png)

解决办法：

在employee里面分别添加 @TableField(fill = FieldFill.INSERT) 和@TableField(fill = FieldFill.INSERT_UPDATE) 字段

![image-20230714141252669](imgs/image-20230714141252669.png)

## 在根据id删除分类时id=null

解决办法：![image-20230714141307050](imgs/image-20230714141307050.png)

将ids对应起来

![image-20230714141320194](imgs/image-20230714141320194.png)

小龙人/takeaway_project

简介

发行版

贡献者

近期动态

小龙人/takeaway_project .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

小龙人/takeaway_project