软件开发整体介绍

软件开发流程

• 需求分析：产品原型、需求规格说明书

• 设计：产品文档、UI界面设计、概要设计、详细设计、数据库设计

• 编码：项目代码、单元测试

• 测试：测试用例、测试报告

• 上线运维：软件环境安装、配置

角色分工

• 项目经理：对整个项目负责，任务分配、把控进度

• 产品经理：进行需求调研，输出需求调研文档、产品原型等

• UI设计师：根据产品原型输出界面效果图

• 架构师：项目整体架构设计、技术选型等

• 开发工程师：代码实现

• 测试工程师：编写测试用例，输出测试报告

• 运维工程师：软件环境搭建、项目上线

软件环境

• 开发环境(development)：开发人员在开发阶段使用的环境，一般外部用户无法访问
• 测试环境(testing)：专门给测试人员使用的环境，用于测试项目，一般外部用户无法访问
• 生产环境(production)：即线上环境，正式提供对外服务的环境

瑞吉外卖项目介绍

项目介绍

• 本项目（瑞吉外卖）是专门为餐饮企业（餐厅、饭店）定制的一款软件产品，包括系统管理后台和移动端应用两部分。其中系统管理后台主要提供给餐饮企业内部员工使用，可以对餐厅的菜品、套餐、订单等进行管理维护。移动端应用主要提供给消费者使用，可以在线浏览菜品、添加购物车、下单等。
• 本项目共分为3期进行开发:
  • 第一期主要实现基本需求，其中移动端应用通过H5实现，用户可以通过手机浏览器访问。
  • 第二期主要针对移动端应用进行改进，使用微信小程序实现，用户使用起来更加方便。
  • 第三期主要针对系统进行优化升级，提高系统的访问性能。

技术选型

功能架构

移动端前台(H5、微信小程序)

• 手机号登录
• 微信登录
• 地址管理
• 历史订单
• 菜品规格
• 购物车
• 下单
• 菜品浏览

系统管理后台

• 分类管理
• 菜品管理
• 套餐管理
• 菜品口味管理
• 员工登录
• 员工退出
• 员工管理
• 订单管理

开发环境搭建

数据库环境搭建

• 数据表

序号	表名	说明
1	employee	员工表
2	category	菜品和套餐分类表
3	dish	菜品表
4	setmeal	套餐表
5	setmeal_dish	套餐菜品关系表
6	dish_flavor	菜品口味关系表
7	user	用户表（C端）
8	address_book	地址簿表
9	shopping_cart	购物车表
10	orders	订单表
11	order_detail	订单明细表

Maven环境搭建

1. 创建maven项目
2. 导入pom文件
3. 导入静态资源和配置文件
4. 设置静态资源放行

package com.jihua.reggie.config;import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;@Slf4j
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {/*** 设置静态资源映射** @param registry*/@Overrideprotected void addResourceHandlers(ResourceHandlerRegistry registry) {log.info("开始进行静态资源映射 ...");registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");}
}

后台登录功能开发

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

package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;import java.io.Serializable;
import java.time.LocalDateTime;/*** 员工实体类*/
@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;private LocalDateTime createTime;private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT)private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;}

2. 创建controller、service、mapper

• controller

package com.jihua.reggie.controller;import com.jihua.reggie.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@Slf4j
@RestController
@RequestMapping("/employee")
public class EmployeeController {@Autowiredprivate EmployeeService employeeService;
}

• service

package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
import com.jihua.reggie.entity.Employee;public interface EmployeeService extends IService<Employee> {
}

package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jihua.reggie.entity.Employee;
import com.jihua.reggie.mapper.EmployeeMapper;
import com.jihua.reggie.service.EmployeeService;
import org.springframework.stereotype.Service;@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService {
}

• mapper

package com.jihua.reggie.mapper;import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jihua.reggie.entity.Employee;public interface EmployeeMapper extends BaseMapper<Employee> {
}

3. 创建返回结果类R

• 此类是一个通用结果类，服务端响应的所有结果最终都会包装成此种类型返回给前端页面

package com.jihua.reggie.common;import lombok.Data;import java.util.HashMap;
import java.util.Map;/*** 通用返回结果，服务端响应的数据最终都会封装成此对象** @param <T>*/
@Data
public class R<T> {private Integer code; //编码：1成功，0和其它数字为失败private String msg; //错误信息private T data; //数据private Map map = new HashMap(); //动态数据public static <T> R<T> success(T object) {R<T> r = new R<T>();r.data = object;r.code = 1;return r;}public static <T> R<T> error(String msg) {R r = new R();r.msg = msg;r.code = 0;return r;}public R<T> add(String key, Object value) {this.map.put(key, value);return this;}}

4. 在Controller中创建登录方法

• 处理逻辑如下:
  1. 将页面提交的密码password进行md5加密处理
  2. 根据页面提交的用户名username查询数据库
  3. 如果没有查询到则返回登录失败结果
  4. 密码比对，如果不一致则返回登录失败结果
  5. 查看员工状态，如果为已禁用状态，则返回员工已禁用结果
  6. 登录成功，将员工id存入Session并返回登录成功结果

package com.jihua.reggie.controller;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jihua.reggie.common.R;
import com.jihua.reggie.entity.Employee;
import com.jihua.reggie.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import javax.servlet.http.HttpServletRequest;@Slf4j
@RestController
@RequestMapping("/employee")
public class EmployeeController {@Autowiredprivate EmployeeService employeeService;/*** 员工登录** @param request* @param employee* @return*/@PostMapping("/login")public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee) {//1. 将页面提交的密码password进行md5加密处理String password = employee.getPassword();password = DigestUtils.md5DigestAsHex(password.getBytes());//2. 根据页面提交的用户名username查询数据库LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();queryWrapper.eq(Employee::getUsername, employee.getUsername());Employee emp = employeeService.getOne(queryWrapper);//3. 如果没有查询到则返回登录失败结果if (emp == null) {return R.error("用户不存在");}//4. 密码比对，如果不一致则返回登录失败结果if (!emp.getPassword().equals(password)) {return R.error("密码错误");}//5. 查看员工状态，如果为已禁用状态，则返回员工已禁用结果if (emp.getStatus() == 0) {return R.error("账号已禁用");}//6. 登录成功，将员工id存入Session并返回登录成功结果request.getSession().setAttribute("employee", emp.getId());return R.success(emp);}
}

后台退出功能开发

用户点击页面中退出按钮，发送请求，请求地址为/employee/logout，请求方式为POST。我们只需要在Controller中创建对应的处理方法即可，具体的处理逻辑:

1. 清理Session中的用户id

2. 返回结果

/*** 员工退出* @param request* @return*/
@RequestMapping("/logout")
public R<String> logout(HttpServletRequest request) {//1. 清理Session中的当前登录员工idrequest.getSession().removeAttribute("employee");return R.success("退出成功");
}

完善登录过滤器

实现步骤:

1. 创建自定义过滤器LoginCheckFilter

package com.jihua.reggie.filter;import lombok.extern.slf4j.Slf4j;import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;/*** 检查用户是否已经登录*/
@WebFilter(filterName = "loginCheckFilter", urlPatterns = "/*")
@Slf4j
public class LoginCheckFilter implements Filter {@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) servletRequest;HttpServletResponse response = (HttpServletResponse) servletResponse;log.info("拦截到请求：{}", request.getRequestURI());filterChain.doFilter(request, response);}
}

2. 在启动类上加入注解@ServletComponentScan

@Slf4j//配置log
@SpringBootApplication
@ServletComponentScan//开启filter注解扫描
public class ReggieApplication {public static void main(String[] args) {SpringApplication.run(ReggieApplication.class, args);log.info("项目启动成功...");}
}

3. 完善过滤器的处理逻辑

• 过滤器具体的处理逻辑如下:

1. 获取本次请求的URI
2. 判断本次请求是否需要处理
3. 如果不需要处理，则直接放行
4. 判断登录状态，如果已登录，则直接放行
5. 如果未登录则返回未登录结果

/*** 检查用户是否已经登录*/
@WebFilter(filterName = "loginCheckFilter", urlPatterns = "/*")
@Slf4j
public class LoginCheckFilter implements Filter {//路径匹配器，支持通配符public static final AntPathMatcher ANT_PATH_MATCHER = new AntPathMatcher();@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {HttpServletRequest request = (HttpServletRequest) servletRequest;HttpServletResponse response = (HttpServletResponse) servletResponse;//1. 获取本次请求的URIString requestURI = request.getRequestURI();//定义不需要处理的请求路径String[] urls = new String[]{"/employee/login","/employee/logout","/backend/**","/front/**"};//2. 判断本次请求是否需要处理boolean check = check(urls, requestURI);//3. 如果不需要处理，则直接放行if (check) {filterChain.doFilter(request, response);return;}//4. 判断登录状态，如果已登录，则直接放行if (request.getSession().getAttribute("employee") != null) {filterChain.doFilter(request, response);return;}//5. 如果未登录则返回未登录结果，通过输出流方式向客户端页面响应数据response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));log.info("拦截到请求：{}", request.getRequestURI());}/*** 路径匹配，检查本次请求是否需要放行** @param urls* @param requestURI* @return*/public boolean check(String[] urls, String requestURI) {for (String url : urls) {boolean match = ANT_PATH_MATCHER.match(url, requestURI);if (match) {return true;}}return false;}}

员工管理

新增员工

• 新增员工，其实就是将我们新增页面录入的员工数据插入到employee表。

• 需要注意，employee表中对username字段加入了唯一约束，因为username是员工的登录账号，必须是唯一的。

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面发送ajax请求，将新增员工页面中输入的数据以json的形式提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service将数据进行保存
3. Service调用Mapper操作数据库，保存数据

/*** 新增员工** @param request* @param employee* @return*/
@PostMapping
public R<String> save(HttpServletRequest request, @RequestBody Employee employee) {log.info("新增员工，员工信息：{}", employee.toString());//设置初始密码为123456，md5加密处理employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));//设置创建时间、修改时间employee.setCreateTime(LocalDateTime.now());employee.setUpdateTime(LocalDateTime.now());//获取当前登录用户idLong empID = (Long) request.getSession().getAttribute("employee");//设置创建人、修改人employee.setCreateUser(empID);employee.setUpdateUser(empID);employeeService.save(employee);return R.success("新增员工成功");
}

• 当用户名重复时会报错，使用AOP错误捕获，进行全局错误处理
  1. 创建全局错误处理类GlobalExceptionHandler
  2. 对用户名重复错误进行前端消息返回

/*** 全局异常处理*/
@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {/*** 异常处理方法** @return*/@ExceptionHandler(SQLIntegrityConstraintViolationException.class)public R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex) {//用户名重复异常if (ex.getMessage().contains("Duplicate")) {String[] s = ex.getMessage().split(" ");String msg = "用户" + s[2] + "已存在";return R.error(msg);}log.error(ex.getMessage());return R.error("未知错误");}
}

员工信息分页查询

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面发送ajax请求，将分页查询参数(page、pageSize、name)提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service查询数据
3. Service调用Mapper操作数据库，查询分页数据
4. Controller将查询到的分页数据响应给页面
5. 页面接收到分页数据并通过ElementUI的Table组件展示到页面上

/*** 分页查询（包括搜索）** @param page     当前页面* @param pageSize 每页大小* @param name     搜索参数* @return 附带Page的成功消息*/
@GetMapping("/page")
public R<Page> page(int page, int pageSize, String name) {log.info("page={},pageSize={},name={}", page, pageSize, name);//制作分页查询构造器Page<Employee> pageInfo = new Page<Employee>(page, pageSize);//制作条件查询构造器LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<Employee>();//添加过滤条件queryWrapper.like(StringUtils.isNotEmpty(name), Employee::getName, name);//添加排序条件queryWrapper.orderByDesc(Employee::getUpdateTime);//执行查询employeeService.page(pageInfo, queryWrapper);return R.success(pageInfo);
}

启用/禁用员工账号

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面发送ajax请求，将参数(id、status)提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service更新数据
3. Service调用Mapper操作数据库

启用、禁用员工账号，本质上就是一个更新操作，也就是对status状态字段进行操作

在Controller中创建update方法，此方法是一个通用的修改员工信息的方法

/*** 根据id修改员工信息* @param request* @param employee* @return*/
@PutMapping
public R<String> update(HttpServletRequest request, @RequestBody Employee employee) {log.info(employee.toString());employee.setUpdateTime(LocalDateTime.now());employee.setUpdateUser((Long) request.getSession().getAttribute("employee"));employeeService.updateById(employee);return R.success("员工信息修改成功");
}

• 为避免js处理Long型id出现精度丢失，应该在后端传id数据时将Long转换为String

具体实现步骤:

1. 提供对象转换器JacksonObjectMapper，基于Jackson进行Java对象到JSON数据的转换(同时也修改了时间的返回格式)

package com.jihua.reggie.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 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]*/
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);}
}

2. 在WebMvcConfig配置类中扩展Spring mvc的消息转换器，在此消息转换器中使用提供的对象转换器进行Java对象到json数据的转换

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

编辑员工信息

在开发代码之前需要梳理一下操作过程和对应的程序的执行流程:

1. 点击编辑按钮时，页面跳转到add.html，并在url中携带参数[员工id]
2. 在add.html页面获取url中的参数[员工id]
3. 发送ajax请求，请求服务端，同时提交员工id参数
4. 服务端接收请求，根据员工id查询员工信息，将员工信息以json形式响应给页面
5. 页面接收服务端响应的json数据，通过VUE的数据绑定进行员工信息回显
6. 点击保存按钮，发送ajax请求，将页面中的员工信息以json方式提交给服务端
7. 服务端接收员工信息，并进行处理，完成后给页面响应
8. 页面接收到服务端响应信息后进行相应处理

• 注意: add.html页面为公共页面，新增员工和编辑员工都是在此页面操作

/*** 根据id查询员工信息** @param id* @return*/
@GetMapping("/{id}")
public R<Employee> getById(@PathVariable Long id) {log.info("根据id查询员工信息 ...");Employee employee = employeeService.getById(id);if (employee != null) {return R.success(employee);}return R.error("没有查询到对应员工信息");
}

• 点击修改后会调用前面的update方法

公共字段自动填充

• 问题分析

前面我们已经完成了后台系统的员工管理功能开发，在新增员工时需要设置创建时间、创建人、修改时间、修改人等字段，在编辑员工时需要设置修改时间和修改人等字段。这些字段属于公共字段，也就是很多表中都有这些字段，如下:

employee.setUpdateTime(LocalDateTime.now());
employee.setUpdateUser((Long) request.getSession().getAttribute("employee"));

能不能对于这些公共字段在某个地方统一处理，来简化开发呢?

答案就是使用Mybatis Plus提供的公共字段自动填充功能。

• 代码实现

Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。

实现步骤:

1. 在实体类的属性上加入@TableField注解，指定自动填充的策略

@TableField(fill = FieldFill.INSERT) //插入时填充字段
private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE) //插入和更新时填充字段
private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT) //插入时填充字段
private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE) //插入和更新时填充字段
private Long updateUser;

2. 按照框架要求编写元数据对象处理器，在此类中统一为公共字段赋值，此类需要实现MetaObjectHandler接口

package com.jihua.reggie.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*/@Overridepublic void insertFill(MetaObject metaObject) {log.info("公共字段自动填充[insert] ...");metaObject.setValue("createTime", LocalDateTime.now());metaObject.setValue("updateTime", LocalDateTime.now());metaObject.setValue("createUser", 1L);metaObject.setValue("updateUser", 1L);log.info(metaObject.toString());}/*** 更新操作，自动填充** @param metaObject*/@Overridepublic void updateFill(MetaObject metaObject) {log.info("公共字段自动填充[update] ...");metaObject.setValue("updateTime", LocalDateTime.now());metaObject.setValue("updateUser", 1L);log.info(metaObject.toString());}
}

注意，我们在MyMetaObjectHander类中是不能获得HttpSession对象的，所以我们需要通过其他方式来获取登录用户id。
可以使用ThreadLocal来解决此问题,它是JDK中提供的一个类。

在使用ThreadLocal之前，我们需要先确认一个事情，就是客户端发送的每次http请求，对应的在服务端都会分配一个新的线程来处理，在处理过程中涉及到下面类中的方法都属于相同的一个线程:

1. LogincheckFilter的doFilter方法
2. EmployeeController的update方法
3. MyMetaobjectHandler的updateFill方法

可以在上面的三个方法中分别加入下面代码（获取当前线程id)

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

执行编辑员工功能进行验证，通过观察控制台输出可以发现，一次请求对应的线程id是相同的

• 什么是ThreadLocal?

ThreadLocal并不是一个Thread，而是Thread的局部变量。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal为每个线程提供单独一份存储空间，具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问。

ThreadLocal常用方法:

• public void set(T value)设置当前线程的线程局部变量的值
• public T get()返回当前线程所对应的线程局部变量的值

我们可以在LoginCheckFilter的doFilter方法中获取当前登录用户id，并调用ThreadLocal的set方法来设置当前线程的线程局部变量的值（用户id），然后在MyMetaObjectHandler的updateFill方法中调用ThreadLocal的get方法来获得当前线程所对应的线程局部变量的值（用户id）。

• 实现步骤:

  1. 编写BaseContext工具类，基于ThreadLocal封装的工具类

     package com.jihua.reggie.common;/*** 基于ThreadLocal封装工具类，用于保存和获取当前登录用户id*/
     public class BaseContext {private static ThreadLocal<Long> threadLocal = new ThreadLocal<Long>();/*** 设置id** @param id 存放当前登录用户的id*/public static void setCurrentId(Long id) {threadLocal.set(id);}/*** 获取id** @return 返回当前登录用户的id*/public static Long getCurrentId() {return threadLocal.get();}
     }

  2. 在LoginCheckFilter的doFilter方法中调用BaseContext来设置当前登录用户的id

     //获取当前登录用户的id
     Long userId = (Long) request.getSession().getAttribute("employee");
     BaseContext.setCurrentId(userId);
     

  3. 在MyMetaobjectHandler的方法中调用BaseContext获取登录用户的id

     metaObject.setValue("updateUser", BaseContext.getCurrentId());
     

分类管理

后台系统中可以管理分类信息，分类包括两种类型，分别是菜品分类和套餐分类。当我们在后台系统中添加菜品时需要选择一个菜品分类，当我们在后台系统中添加一个套餐时需要选择一个套餐分类，在移动端也会按照菜品分类和套餐分类来展示对应的菜品和套餐。

• 需求分析

可以在后台系统的分类管理页面分别添加菜品分类和套餐分类，如下:

需要注意，category表中对name字段加入了唯一约束，保证分类的名称是唯一的

• 代码开发

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

• 实体类Category

  package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
  import com.baomidou.mybatisplus.annotation.TableField;
  import lombok.Data;import java.io.Serializable;
  import java.time.LocalDateTime;/*** 分类*/
  @Data
  public class Category implements Serializable {private static final long serialVersionUID = 1L;private Long id;//类型 1 菜品分类 2 套餐分类private Integer type;//分类名称private String name;//顺序private Integer sort;//创建时间@TableField(fill = FieldFill.INSERT)private LocalDateTime createTime;//更新时间@TableField(fill = FieldFill.INSERT_UPDATE)private LocalDateTime updateTime;//创建人@TableField(fill = FieldFill.INSERT)private Long createUser;//修改人@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;//是否删除private Integer isDeleted;}
  

• Mapper接口CategoryMapper

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

• 业务层接口CategoryService

  package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
  import com.jihua.reggie.entity.Category;public interface CategoryService extends IService<Category> {
  }
  

• 业务层实现类CategoryServicelmpl

  package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  import com.jihua.reggie.entity.Category;
  import com.jihua.reggie.mapper.CategoryMapper;
  import com.jihua.reggie.service.CategoryService;
  import org.springframework.stereotype.Service;@Service
  public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
  }
  

• 控制层CategoryController

  package com.jihua.reggie.controller;import com.jihua.reggie.service.CategoryService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;/*** 分类管理*/
  @RestController
  @RequestMapping("/Category")
  public class CategoryController {@Autowiredprivate CategoryService categoryService;
  }
  

新增分类

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面(backend/page/category/list.html)发送ajax请求，将新增分类窗口输入的数据以json形式提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service将数据进行保存
3. Service调用Mapper操作数据库，保存数据

新增菜品分类和新增套餐分类请求的服务端地址和提交的json数据结构相同，使用type字段区分，所以服务端只需要提供一个方法统—处理即可

分类信息分页查询

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面发送ajax请求，将分页查询参数(page、pageSize)提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service查询数据
3. Service调用Mapper操作数据库，查询分页数据
4. Controller将查询到的分页数据响应给页面
5. 页面接收到分页数据并通过Elementul的Table组件展示到页面上

/*** 分页查询** @param page* @param pageSize* @return*/
@GetMapping("/page")
public R<Page> page(int page, int pageSize) {//分页构造器Page<Category> pageInfo = new Page<>(page, pageSize);//条件构造器LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();//添加排序字段，根据sort排序queryWrapper.orderByAsc(Category::getSort);//进行分页查询categoryService.page(pageInfo, queryWrapper);return R.success(pageInfo);
}

删除分类

在分类管理列表页面，可以对某个分类进行删除操作。需要注意的是当分类关联了菜品或者套餐时，此分类不允许删除。

• 代码开发

在开发代码之前，需要梳理一下整个程序的执行过程:

1. 页面发送ajax请求，将参数(id)提交到服务端
2. 服务端Controller接收页面提交的数据并调用Service删除数据
3. Service调用Mapper操作数据库

/*** 根据id删除分类** @param ids* @return*/
@DeleteMapping
public R<String> delete(Long ids) {log.info("删除分类，id：{}", ids);categoryService.removeById(ids);return R.success("分类信息删除成功");
}

前面我们已经实现了根据id删除分类的功能，但是并没有检查删除的分类是否关联了菜品或者套餐，所以我们需要进行功能完善。

要完善分类删除功能，需要先准备基础的类和接口:

1. 实体类Dish和Setmeal

   package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
   import com.baomidou.mybatisplus.annotation.TableField;
   import lombok.Data;import java.io.Serializable;
   import java.math.BigDecimal;
   import java.time.LocalDateTime;/*** 菜品*/
   @Data
   public class Dish implements Serializable {private static final long serialVersionUID = 1L;private Long id;//菜品名称private String name;//菜品分类idprivate Long categoryId;//菜品价格private BigDecimal price;//商品码private String code;//图片private String image;//描述信息private String description;//0 停售 1 起售private Integer status;//顺序private Integer sort;@TableField(fill = FieldFill.INSERT)private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE)private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT)private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;//是否删除private Integer isDeleted;}
   

   package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
   import com.baomidou.mybatisplus.annotation.TableField;
   import lombok.Data;import java.io.Serializable;
   import java.math.BigDecimal;
   import java.time.LocalDateTime;/*** 套餐*/
   @Data
   public class Setmeal implements Serializable {private static final long serialVersionUID = 1L;private Long id;//分类idprivate Long categoryId;//套餐名称private String name;//套餐价格private BigDecimal price;//状态 0:停用 1:启用private Integer status;//编码private String code;//描述信息private String description;//图片private String image;@TableField(fill = FieldFill.INSERT)private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE)private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT)private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;//是否删除private Integer isDeleted;
   }
   

2. Mapper接口DishMapper和SetmealMapper

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

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

3. Service接口DishService和SetmealService

   package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
   import com.jihua.reggie.entity.Dish;public interface DishService extends IService<Dish> {
   }
   

   package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
   import com.jihua.reggie.entity.Setmeal;public interface SetmealService extends IService<Setmeal> {
   }
   

4. Service实现类DishServicelmpl和SetmealServicelmpl

   package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
   import com.jihua.reggie.entity.Dish;
   import com.jihua.reggie.mapper.DishMapper;
   import com.jihua.reggie.service.DishService;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.stereotype.Service;@Service
   @Slf4j
   public class DishServiceImpl extends ServiceImpl<DishMapper, Dish> implements DishService {
   }
   

   package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
   import com.jihua.reggie.entity.Setmeal;
   import com.jihua.reggie.mapper.SetmealMapper;
   import com.jihua.reggie.service.SetmealService;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.stereotype.Service;@Service
   @Slf4j
   public class SetmealServiceImpl extends ServiceImpl<SetmealMapper, Setmeal> implements SetmealService {
   }
   

• 带判断的删除方法实现

1. 自定义业务异常类

package com.jihua.reggie.common;/*** 自定义业务异常类*/
public class CustomException extends RuntimeException {public CustomException(String message) {super(message);}
}

2. 修改CategoryService和CategoryServiceImpl，自定义带判断的remove方法

package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
import com.jihua.reggie.entity.Category;public interface CategoryService extends IService<Category> {/*** 根据id删除分类，并进行删除之前的判断** @param id*/public void remove(Long id);
}

package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jihua.reggie.common.CustomException;
import com.jihua.reggie.entity.Category;
import com.jihua.reggie.entity.Dish;
import com.jihua.reggie.entity.Setmeal;
import com.jihua.reggie.mapper.CategoryMapper;
import com.jihua.reggie.service.CategoryService;
import com.jihua.reggie.service.DishService;
import com.jihua.reggie.service.SetmealService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {@Autowiredprivate DishService dishService;@Autowiredprivate SetmealService setmealService;/*** 根据id删除分类，并进行删除之前的判断** @param id*/@Overridepublic void remove(Long id) {//查询当前分类是否关联了菜品，如果已经关联，抛出一个业务异常LambdaQueryWrapper<Dish> dishLambdaQueryWrapper = new LambdaQueryWrapper<>();//添加查询条件，根据分类id进行查询dishLambdaQueryWrapper.eq(Dish::getCategoryId, id);int count1 = dishService.count(dishLambdaQueryWrapper);if (count1 > 0) {//抛出业务异常throw new CustomException("当前分类下关联了菜品，不能删除");}//查询当前分类是否关联了套餐，如果已经关联，抛出一个业务异常LambdaQueryWrapper<Setmeal> setmealLambdaQueryWrapper = new LambdaQueryWrapper<>();//添加查询条件，根据分类id进行查询setmealLambdaQueryWrapper.eq(Setmeal::getCategoryId, id);int count2 = setmealService.count(setmealLambdaQueryWrapper);if (count2 > 0) {//抛出业务异常throw new CustomException("当前分类下关联了套餐，不能删除");}//正常删除分类super.removeById(id);}
}

3. 在全局异常处理类中添加CustomException的处理方法

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

修改分类

• 需求分析

在分类管理列表页面点击修改按钮，弹出修改窗口，在修改窗口回显分类信息并进行修改，最后点击确定按钮完成修改操作

/*** 根据id修改分类信息* @param category* @return*/
@PutMapping
public R<String> update(@RequestBody Category category) {log.info("修改分类信息：{}", category);categoryService.updateById(category);return R.success("修改分类信息成功");
}

菜品管理

文件上传下载

• 文件上传介绍

文件上传，也称为upload，是指将本地图片、视频、音频等文件上传到服务器上，可以供其他用户浏览或下载的过程。文件上传在项目中应用非常广泛，我们经常发微博、发微信朋友圈都用到了文件上传功能。

文件上传时，对页面的form表单有如下要求:

• method=“post” 采用post方式提交数据

• enctype=“multipart/form-data” 采用multipart格式上传文件

• type=“file” 使用input的file控件上传

举例:

<form method="post" action="/common/upload" enctype="multipart/form-data"><input name="myFile" type="file" /><input type="submit" value="提交"/>
</form>

目前一些前端组件库也提供了相应的上传组件，但是底层原理还是基于form表单的文件上传。例如ElementUI中提供的upload上传组件:

服务端要接收客户端页面上传的文件，通常都会使用Apache的两个组件:

• commons-fileupload
• commons-io

Spring框架在spring-web包中对文件上传进行了封装，大大简化了服务端代码，我们只需要在Controller的方法中声明一个MultipartFile类型的参数即可接收上传的文件，例如：

/*** 文件上传* @param file* @return*/
@PostMapping(value = "upload")
public R<String> upload(MultipartFile file) {System.out.println(file);return R.success("文件上传成功");
}

• 文件下载介绍

文件下载，也称为download，是指将文件从服务器传输到本地计算机的过程。

通过浏览器进行文件下载，通常有两种表现形式:

• 以附件形式下载，弹出保存对话框，将文件保存到指定磁盘目录
• 直接在浏览器中打开

通过浏览器进行文件下载，本质上就是服务端将文件以流的形式写回浏览器的过程。

文件上传代码实现

文件上传，页面端可以使用ElementUI提供的上传组件。

<el-upload class="avatar-uploader"action="/common/upload":show-file-list="false":on-success="handleAvatarSuccess":before-upload="beforeUpload"ref="upload"><img v-if="imageUrl" :src="imageUrl" class="avatar"></img><i v-else class="el-icon-plus avatar-uploader-icon"></i>
</el-upload>

后端代码实现

/*** 文件上传** @param file* @return*/
@PostMapping(value = "/upload")
public R<String> upload(MultipartFile file) {//file是一个临时文件，需要转存到指定位置，否则本次请求完成后临时文件会删陈log.info(file.toString());//原始文件名String originalFilename = file.getOriginalFilename();//abc.jpg//获得文件后缀名称String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));//使用UUID重新生成文件名，防止文件名称重复造成文件覆盖String fileName = UUID.randomUUID().toString() + suffix;//xxxxxxxx.jpg//创建一个目录对象File dir = new File(basePath);//判断当前目录是否存在if (!dir.exists()) {//目录不存在，需要创建dir.mkdirs();}//将临时文件转存到指定位置try {file.transferTo(new File(basePath + fileName));} catch (IOException e) {e.printStackTrace();}return R.success(fileName);
}

文件下载代码实现

文件下载，页面端可以使用标签展示下载的图片

<img v-if="imageUrl" : src="imageUrl" class="avatar"></img>

handleAvatarSuccess (response，file，fileList){this.imageUrl ='/common/download?name=${response.data}'
}

• 后端代码实现

/*** 文件下载** @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();}
}

新增菜品

后台系统中可以管理菜品信息，通过新增功能来添加一个新的菜品，在添加菜品时需要选择当前菜品所属的菜品分类，并日需要卜传菜品图片，在移动端会按照菜品分类来展示对应的菜品信息。

新增菜品，其实就是将新增页面录入的菜品信息插入到dish表，如果添加了口味做法，还需要向dish_flavor表插入数据。所以在新增菜品时，涉及到两个表:

• dish 菜品表
• dish_flavor 菜品口味表

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

• 实体类DishFlavor(Dish实体前面已经导入过了)

  package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
  import com.baomidou.mybatisplus.annotation.TableField;
  import lombok.Data;import java.io.Serializable;
  import java.time.LocalDateTime;/*** 菜品口味*/
  @Data
  public class DishFlavor implements Serializable {private static final long serialVersionUID = 1L;private Long id;//菜品idprivate Long dishId;//口味名称private String name;//口味数据listprivate String value;@TableField(fill = FieldFill.INSERT)private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE)private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT)private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;//是否删除private Integer isDeleted;}
  

• Mapper接口DishFlavorMapper

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

• 业务层接口DishFlavorService

  package com.jihua.reggie.service;import com.baomidou.mybatisplus.extension.service.IService;
  import com.jihua.reggie.entity.DishFlavor;public interface DishFlavorService extends IService<DishFlavor> {
  }
  

• 业务层实现类DishFlavorServicelmpl

  package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  import com.jihua.reggie.entity.DishFlavor;
  import com.jihua.reggie.mapper.DishFlavorMapper;
  import com.jihua.reggie.service.DishFlavorService;
  import org.springframework.stereotype.Service;@Service
  public class DishFlavorServiceImpl extends ServiceImpl<DishFlavorMapper, DishFlavor> implements DishFlavorService {
  }
  

• 控制层DishController

  package com.jihua.reggie.controller;import com.jihua.reggie.service.DishFlavorService;
  import com.jihua.reggie.service.DishService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;/*** 菜品管理*/
  @RestController
  @RequestMapping("/dish")
  @Slf4j
  public class DishController {@Autowiredprivate DishService dishService;@Autowiredprivate DishFlavorService dishFlavorService;}
  

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

1. 页面(backend/page/food/add.html)发送ajax请求，请求服务端获取菜品分类数据并展示到下拉框中

   //在CategoryController中书写
   /*** 根据条件查询分类数据** @param type 区分菜品分类（1）和套餐（2）分类* @return*/
   @GetMapping("/list")
   public R<List<Category>> list(String type) {//条件构造器LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();//添加条件queryWrapper.eq(type != null, Category::getType, type);//添加排序条件queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);List<Category> list = categoryService.list(queryWrapper);return R.success(list);
   }
   

2. 页面发送请求进行图片上传，请求服务端将图片保存到服务器

3. 页面发送请求进行图片下载，将上传的图片进行回显

4. 点击保存按钮，发送ajax请求，将菜品相关数据以json形式提交到服务端

开发新增菜品功能，其实就是在服务端编写代码去处理前端页面发送的这4次请求即可。

• DTO

DTO，全称为Data Transfer object，即数据传输对象，一般用于展示层与服务层之间的数据传输.

前面的内容前端传过来的数据可以直接用实体类来接收，如：

@PutMapping
public R<String> update(@RequestBody Category category)

当前端传送的数据不能直接接受时，就要编写DTO，例如此处还需要接收flavors数组：

@Data
public class DishDto extends Dish {private List<DishFlavor> flavors = new ArrayList<>();
}

• 新增菜品代码实现

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

此处的saveWithFlavor是自己编写的同时保存菜品，同时保存对应的口味数据选择两个数据的功能

public interface DishService extends IService<Dish> {/*** 新增菜品，同时保存对应的口味数据** @param dishDto*/public void saveWithFlavor(DishDto dishDto);
}

/*** 新增菜品，同时保存对应的口味数据** @param dishDto*/
@Override
@Transactional//多表操作，需要开启事务
public void saveWithFlavor(DishDto dishDto) {//保存菜品的基本信息到菜品表dishthis.save(dishDto);Long dishId = dishDto.getId();//菜品id//菜品口味List<DishFlavor> flavors = dishDto.getFlavors();flavors.forEach(flavor -> flavor.setDishId(dishId));//保存菜品口味数据到菜品口味表dish_flavordishFlavorService.saveBatch(flavors);
}

因为同时操作了多张表，需要进行事务处理，在启动类上开启事务注解支持注解

@Slf4j//配置log
@SpringBootApplication
@ServletComponentScan//开启filter注解扫描
@EnableTransactionManagement//开启事务注解支持
public class ReggieApplication {public static void main(String[] args) {SpringApplication.run(ReggieApplication.class, args);log.info("项目启动成功...");}
}

菜品信息分页查询

在开发代码之前，需要梳理一下菜品分页查询时前端页面和服务端的交互过程:

1. 页面(backend/page/food/list.html)发送ajax请求，将分页查询参数(page、pageSize、name)提交到服务端，获取分页数据
2. 页面发送请求，请求服务端进行图片下载，用于页面图片展示

开发菜品信息分页查询功能，其实就是在服务端编写代码去处理前端页面发送的这2次请求即可

• 注：直接返回Page<Dish>类型的数据没有菜品分类的具体名称，需要在后端重新封装一个Page<DishDto>，将

/*** 菜品信息分页查询** @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> pageDto = new Page<>(page, pageSize);//构造条件构造器LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();//添加过滤条件queryWrapper.like(name != null, Dish::getName, name);//添加排序条件queryWrapper.orderByDesc(Dish::getUpdateTime);//执行分页查询dishService.page(pageInfo, queryWrapper);//对象拷贝BeanUtils.copyProperties(pageInfo, pageDto, "records");//忽略records，因为records需要进行处理List<Dish> records = pageInfo.getRecords();List<DishDto> list = records.stream().map((item) -> {DishDto dishDto = new DishDto();BeanUtils.copyProperties(item, dishDto);Long categoryId = item.getCategoryId();//分类id//根据id查询分类对象Category category = categoryService.getById(categoryId);if (category != null) {//获取分类的名称String categoryName = category.getName();dishDto.setCategoryName(categoryName);}return dishDto;}).collect(Collectors.toList());pageDto.setRecords(list);return R.success(pageDto);}

修改菜品

在开发代码之前，需要梳理一下修改菜品时前端页面(add.html)和服务端的交互过程:

1. 页面发送ajax请求，请求服务端获取分类数据，用于菜品分类下拉框中数据展示
2. 页面发送ajax请求，请求服务端，根据id查询当前菜品信息，用于菜品信息回显
3. 页面发送请求，请求服务端进行图片下载，用于页图片回显
4. 点击保存按钮，页面发送ajax请求，将修改后的菜品相关数据以json形式提交到服务端

开发修改菜品功能，其实就是在服务端编写代码去处理前端页面发送的这4次请求即可。

回显

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

此处的getByIdWithFlavor是自己编写的方法：

/*** 根据id查询菜品信息和对应的口味信息** @param id*/
public DishDto getByIdWithFlavor(Long id);

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

修改

/*** 根据id修改菜品信息** @param dishDto* @return*/
@PutMapping
public R<String> update(@RequestBody DishDto dishDto) {dishService.updateWithFlavor(dishDto);log.info("修改菜品信息：{}", dishDto);return R.success("菜品信息修改成功");
}

此处的updateWithFlavor是自己编写的方法：

/*** 更新菜品信息，同时更新对应的口味信息** @param dishDto*/
public void updateWithFlavor(DishDto dishDto);

/*** 更新菜品信息，同时更新对应的口味信息** @param dishDto*/
@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.forEach(flavor -> flavor.setDishId(dishDto.getId()));dishFlavorService.saveBatch(flavors);
}

删除菜品

删除菜品时需要同时删除菜品信息、口味信息以及菜品图片

/*** 根据id删除菜品** @param arrayIDs* @return*/
@DeleteMapping()
public R<String> delete(@RequestParam("ids") Long[] arrayIDs) {List<Long> ids = Arrays.asList(arrayIDs);log.info("删除菜品id：{}", ids);dishService.deleteWithFlavor(ids);return R.success("菜品信息删除成功");
}

其中的deleteWithFlavor时自己写的方法

/*** 删除菜品信息，同时删除对应的口味信息和图片** @param ids*/
public void deleteWithFlavor(List<Long> ids); 

@Value("${reggie.path}")
private String basePath;/*** 删除菜品信息，同时删除对应的口味信息和图片** @param ids*/
@Override
@Transactional//事务
public void deleteWithFlavor(List<Long> ids) {//先查询图片名称，否则菜品信息删除后无法查询到图片名称LambdaQueryWrapper<Dish> fileQueryWrapper = new LambdaQueryWrapper<>();fileQueryWrapper.eq(Dish::getId, ids);List<Dish> dishList = this.listByIds(ids);//根据id删除菜品信息this.removeByIds(ids);//清理当前菜品对应口味数据——dish_flavor表的delete操作LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();queryWrapper.in(DishFlavor::getDishId, ids);dishFlavorService.remove(queryWrapper);//删除菜品图片for (Dish dish : dishList) {File pictureFile = new File(basePath + dish.getImage());boolean delete = pictureFile.delete();if (delete) {log.info("图片{}删除成功", dish.getImage());} else {log.info("图片{}删除失败", dish.getImage());}}
}

套餐管理

新增套餐

套餐就是菜品的集合。

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

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

• setmeal 套餐表
• setmeal_dish 套餐菜品关系表

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

• 实体类SetmealDish（Setmeal实体前面已经导入过了）

  package com.jihua.reggie.entity;import com.baomidou.mybatisplus.annotation.FieldFill;
  import com.baomidou.mybatisplus.annotation.TableField;
  import lombok.Data;import java.io.Serializable;
  import java.math.BigDecimal;
  import java.time.LocalDateTime;/*** 套餐菜品关系*/
  @Data
  public class SetmealDish implements Serializable {private static final long serialVersionUID = 1L;private Long id;//套餐idprivate Long setmealId;//菜品idprivate Long dishId;//菜品名称 （冗余字段）private String name;//菜品原价private BigDecimal price;//份数private Integer copies;//排序private Integer sort;@TableField(fill = FieldFill.INSERT)private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE)private LocalDateTime updateTime;@TableField(fill = FieldFill.INSERT)private Long createUser;@TableField(fill = FieldFill.INSERT_UPDATE)private Long updateUser;//是否删除private Integer isDeleted;
  }
  

• DTO SetmealDto

  package com.jihua.reggie.dto;import com.jihua.reggie.entity.Setmeal;
  import com.jihua.reggie.entity.SetmealDish;
  import lombok.Data;import java.util.List;@Data
  public class SetmealDto extends Setmeal {private List<SetmealDish> setmealDishes;private String categoryName;
  }
  

• Mapper接口SetmealDishMapper

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

• 业务层接口SetmealDishService

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

• 业务层实现类SetmealDishServicelmpl

  package com.jihua.reggie.service.impl;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  import com.jihua.reggie.entity.SetmealDish;
  import com.jihua.reggie.mapper.SetmealDishMapper;
  import com.jihua.reggie.service.SetmealDishService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.stereotype.Service;@Service
  @Slf4j
  public class SetmealDishServiceImpl extends ServiceImpl<SetmealDishMapper, SetmealDish> implements SetmealDishService {}
  

• 控制层SetmealController

  package com.jihua.reggie.controller;import com.jihua.reggie.service.SetmealDishService;
  import com.jihua.reggie.service.SetmealService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;/*** 套餐管理*/
  @RestController
  @RequestMapping("/setmeal")
  @Slf4j
  public class SetmealController {@Autowiredprivate SetmealService setmealService;@Autowiredprivate SetmealDishService setmealDishService;
  }
  

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

1. 页面(backend/page/combo/add.html)发送ajax请求，请求服务端获取套餐分类数据并展示到下拉框中（前面已完成，和菜品分类共用）

2. 页面发送ajax请求，请求服务端获取菜品分类数据并展示到添加菜品窗口中（菜品分类前面已完成）

3. 页面发送ajax请求，请求服务端，根据菜品分类查询对应的菜品数据并展示到添加菜品窗口中（其实就是根据分类条件和搜索条件进行菜品的条件查询，所以写在DishController中）

   /*** 根据条件查询对应的菜品数据** @param dish* @return*/
   @GetMapping("list")
   public R<List<Dish>> list(Dish dish) {//构造查询条件LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();queryWrapper.eq(dish.getCategoryId() != null, Dish::getCategoryId, dish.getCategoryId());//添加条件，查询状态为1(起售状态）的菜品queryWrapper.eq(dish.getStatus() != null, Dish::getStatus, dish.getStatus());//添加name搜索条件queryWrapper.like(dish.getName() != null, Dish::getName, dish.getName());//添加排序条件queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);List<Dish> list = dishService.list(queryWrapper);return R.success(list);
   }
   

4. 页面发送请求进行图片上传，请求服务端将图片保存到服务器

5. 页面发送请求进行图片下载，将上传的图片进行回显

6. 点击保存按钮，发送ajax请求，将套餐相关数据以json形式提交到服务端

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

   此处的saveWithDish是自己写的方法

   /*** 新增套餐，同时需要保存套餐和菜品的关联关系** @param setmealDto*/
   public void saveWithDish(SetmealDto setmealDto);
   

   /*** 新增套餐，同时需要保存套餐和菜品的关联关系** @param setmealDto*/
   @Override
   @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);
   }
   

开发新增套餐功能，其实就是在服务端编写代码去处理前端页面发送的这6次请求即可。

套餐信息分页查询

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

1. 页面(backend/pagelcombo/list.html)发送ajax请求，将分页查询参数(page、pageSize、name)提交到服务端，获取分页数据
2. 页面发送请求，请求服务端进行图片下载，用于页面图片展示

开发套餐信息分页查询功能，其实就是在服务端编写代码去处理前端页面发送的这2次请求即可。

/*** 分页查询套餐信息* @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);//添加排序条件，根据更新时间降序排列queryWrapper.orderByAsc(Setmeal::getUpdateTime);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);//分类idLong 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);
}

删除套餐

在套餐管理列表页面点击删除按钮，可以删除对应的套餐信息。也可以通过复选框选择多个套餐，点击批量删除按钮一次删除多个套餐。

注意，对于状态为售卖中的套餐不能删除，需要先停售，然后才能删除。

/*** 删除套餐** @param ids* @return*/
@DeleteMapping
public R<String> delete(@RequestParam List<Long> ids) {setmealService.deleteWithDish(ids);return R.success("套餐数据删除成功");
}

此处的deleteWithDish是自己写的方法

/*** 删除套餐，同时需要删除套餐和菜品的关联数据，以及套餐图片** @param ids*/
public void deleteWithDish(List<Long> ids);

@Value("${reggie.path}")
private String basePath;/*** 删除套餐，同时需要删除套餐和菜品的关联数据，以及套餐图片** @param ids*/
@Override
@Transactional//事务
public void deleteWithDish(List<Long> ids) {//查询套餐状态,确定是否可用删陈LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();queryWrapper.in(ids != null, Setmeal::getId, ids);queryWrapper.eq(Setmeal::getStatus, 1);int count = this.count(queryWrapper);//如果不能删除，抛出一个业务异常if (count > 0) {throw new CustomException("套餐正在售卖中，不能删除");}//先查询图片名称，否则套餐信息删除后无法查询到图片名称LambdaQueryWrapper<Setmeal> fileQueryWrapper = new LambdaQueryWrapper<>();fileQueryWrapper.eq(Setmeal::getId, ids);List<Setmeal> setmealList = this.listByIds(ids);//如果可以删除,先删除套餐表中的数据——setmealthis.removeByIds(ids);//删除关系表中的数据——setmeal_dishLambdaQueryWrapper<SetmealDish> dishQueryWrapper = new LambdaQueryWrapper<>();dishQueryWrapper.in(SetmealDish::getSetmealId, ids);setmealDishService.remove(dishQueryWrapper);//删除套餐图片for (Setmeal setmea : setmealList) {File pictureFile = new File(basePath + setmea.getImage());boolean delete = pictureFile.delete();if (delete) {log.info("图片{}删除成功", setmea.getImage());} else {log.info("图片{}删除失败", setmea.getImage());}}
}