瑞吉外卖项目

软件开发流程

1、需求分析

产品原型、需求规格说明书

2、设计

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

3、编码

项目代码、单元测试

4、测试

测试用例、设施报告

5、上线运维

软件环境安装、配置

角色分工

• 项目经理：对整个项目负责，任务分配，把控进度
• 产品经理：进行需求调研，输出需求调研文档、产品原型等
• UI设计师：根据产品原型输出界面效果图
• 架构师：项目整体架构设计，技术选型等
• 开发工程师：代码实现
• 测试工程师：编写测试用例，输出测试报告
• 运维工程师：软件环境搭建、项目上线

软件环境

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

瑞吉外卖项目介绍

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

本项目共分为3期进行开发:

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

产品原型

就是一款产品成型之前的一个简单的框架，就是将页面的排版布局展现出来，使产品的初步构思有一个可视化的展示。通过原型展示，可以更加直观的了解项目的需求和提供的功能。

导入pom

xxxxxxxxxx
93
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <parent>
8
        <groupId>org.springframework.boot</groupId>
9
        <artifactId>spring-boot-starter-parent</artifactId>
10
        <version>2.4.5</version>
11
        <relativePath/> <!-- lookup parent from repository -->
12
    </parent>
13

14
    <properties>
15
        <java.version>1.8</java.version>
16
    </properties>
17

18
    <groupId>com.os467</groupId>
19
    <artifactId>reggie_take_out</artifactId>
20
    <version>1.0-SNAPSHOT</version>
21

22
    <dependencies>
23

24
        <dependency>
25
            <groupId>org.springframework.boot</groupId>
26
            <artifactId>spring-boot-starter</artifactId>
27
        </dependency>
28

29
        <dependency>
30
            <groupId>org.springframework.boot</groupId>
31
            <artifactId>spring-boot-starter-test</artifactId>
32
            <scope>test</scope>
33
        </dependency>
34

35
        <dependency>
36
            <groupId>org.springframework.boot</groupId>
37
            <artifactId>spring-boot-starter-web</artifactId>
38
            <scope>compile</scope>
39
        </dependency>
40

41
        <dependency>
42
            <groupId>com.baomidou</groupId>
43
            <artifactId>mybatis-plus-boot-starter</artifactId>
44
            <version>3.4.2</version>
45
        </dependency>
46

47
        <dependency>
48
            <groupId>org.projectlombok</groupId>
49
            <artifactId>lombok</artifactId>
50
            <version>1.18.20</version>
51
        </dependency>
52

53
        <dependency>
54
            <groupId>com.alibaba</groupId>
55
            <artifactId>fastjson</artifactId>
56
            <version>1.2.76</version>
57
        </dependency>
58

59
        <dependency>
60
            <groupId>commons-lang</groupId>
61
            <artifactId>commons-lang</artifactId>
62
            <version>2.6</version>
63
        </dependency>
64

65
        <dependency>
66
            <groupId>mysql</groupId>
67
            <artifactId>mysql-connector-java</artifactId>
68
            <scope>runtime</scope>
69
        </dependency>
70

71
        <dependency>
72
            <groupId>com.alibaba</groupId>
73
            <artifactId>druid-spring-boot-starter</artifactId>
74
            <version>1.1.23</version>
75
        </dependency>
76

77
    </dependencies>
78

79

80
    <build>
81
        <plugins>
82
            <plugin>
83
                <groupId>org.springframework.boot</groupId>
84
                <artifactId>spring-boot-maven-plugin</artifactId>
85
                <version>2.3.5.RELEASE</version>
86
            </plugin>
87
        </plugins>
88
    </build>
89

90

91

92

93
</project>

配置springboot启动类

xxxxxxxxxx
15
1
package com.os467.reggie;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class ReggieApplication {
8

9
    public static void main(String[] args) {
10

11
        SpringApplication.run(ReggieApplication.class,args);
12

13
    }
14

15
}

Slf4j

Simple Logging Facade for Java（SLF4J）作为各种日志框架（例如Java.util.Logging、logback、log4j）的简单外观或抽象

首先slf4j可以理解为规则的制定者，是一个抽象层，定义了日志相关的接口。log4j,logback,JDK Logging都是slf4j的实现层，只是出处不同，当然使用起来也就各有千秋

引用文章

为什么加了@slf4j注解 就可以直接使用log了呢?

如果不使用注解，那我们使用log，需要这样定义

xxxxxxxxxx
1
1
static Logger logger = LoggerFactory.getLogger("Update的日志")

其实在编译完成生成字节码文件的时候idea就已经帮我们生成了这段代码

这就得益于lombok插件了

其实这就是因为Lombok项目是一种自动接通你的编辑器和构建工具的一个Java库

可以理解为有了@slf4j，编辑器里就会给你加log的智能提示，但这并不代表log对象已生成

Lombok

Lombok官网

Lombok项目是一个java库，它可以自动插入到编辑器和构建工具中，增强java的性能，不需要再写getter、setter或equals方法，只要有一个注解，你的类就有一个功能齐全的构建器、自动记录变量等等

@Data

整合了Getter、Setter、ToString、EqualsAndHashCode、RequiredArgsConstructor注解

@Getter

快速构建Getter方法

@Setter

快速构建Setter方法

@ToString

快速将当前对象转换成字符串类型，便于log

@EqualsAndHashCode

快速进行相等判断

@NonNull

判断变量（对象）是否为空

https://blog.csdn.net/weixin_45433031/article/details/121846207

配置核心配置类

方法1 实现WebMvcConfigurer接口

WebMvcConfigurer 接口其实是Spring内部的一种配置方式，我们需要去实现这个接口

（接口中的default关键字规定了接口方法有方法体并且能被实现类继承和重写）

xxxxxxxxxx
27
1
package com.os467.reggie.config;
2

3
import lombok.extern.slf4j.Slf4j;
4
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
5
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
6

7
@Slf4j
8

9
public class WebMvcConfig implements WebMvcConfigurer {
10

11
    /**
12
     * 设置静态资源映射
13
     * @param registry
14
     */
15
    @Override
16
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
17

18
        log.info("开始进行静态资源映射");
19

20
        //将前端拦截到的资源路径映射到本地服务器静态资源
21
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:backend/");
22

23
        registry.addResourceHandler("/front/**").addResourceLocations("classpath:front/");
24
    }
25

26
    
27
}

方法2 继承WebMvcConfigurationSupport类

由于服务器无法访问后端的backend和front资源，我们需要配置一个WebMvcConfig配置类，我们需要让这个类去继承WebMvcConfigurationSupport这个类

这个类为我们提供了一个资源拦截器方法

我们想自定义静态资源映射目录的话，只需重写addResourceHandlers方法即可

SpringBoot拦截器addResourceHandlers()

addResourceLocations() 需要映射到的后端资源地址

xxxxxxxxxx
28
1
package com.os467.reggie.config;
2

3
import lombok.extern.slf4j.Slf4j;
4
import org.springframework.context.annotation.Configuration;
5
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
6
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
7

8
@Slf4j
9
@Configuration
10
public class WebMvcConfig extends WebMvcConfigurationSupport {
11

12
    /**
13
     * 设置静态资源映射
14
     * @param registry
15
     */
16
    @Override
17
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
18

19
        log.info("开始进行静态资源映射");
20

21
        //将前端拦截到的资源路径映射到本地服务器静态资源
22
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:backend/");
23

24
        registry.addResourceHandler("/front/**").addResourceLocations("classpath:front/");
25
        
26
    }
27
}
28

我们在持久层接口上加Mapper标签

让EmployeeMapper去继承MyBatisPlus提供的BaseMapper接口，需要提供一个实体类泛型

xxxxxxxxxx
12
1
package com.os467.reggie.mapper;
2

3
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4
import com.os467.reggie.entity.Employee;
5
import org.apache.ibatis.annotations.Mapper;
6

7
@Mapper
8
public interface EmployeeMapper extends BaseMapper<Employee> {
9

10

11

12
}

表现层

@RequestBody注解 使得接收到的值指定为json串，必须是post方式提交

@PostMapping(“/login”)注解

等价于@RequestMapping(value = “/user/login”,method = RequestMethod.POST)

xxxxxxxxxx
37
1
package com.os467.reggie.controller;
2

3
import com.os467.reggie.common.R;
4
import com.os467.reggie.entity.Employee;
5
import com.os467.reggie.service.EmployeeService;
6
import lombok.extern.slf4j.Slf4j;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.web.bind.annotation.PostMapping;
9
import org.springframework.web.bind.annotation.RequestBody;
10
import org.springframework.web.bind.annotation.RequestMapping;
11
import org.springframework.web.bind.annotation.RestController;
12

13
import javax.servlet.http.HttpServletRequest;
14

15
@Slf4j
16
@RestController
17
@RequestMapping("/employee")
18
public class EmployeeController {
19

20
    //注入业务层实例
21
    @Autowired
22
    private EmployeeService employeeService;
23

24
    /**
25
     * 员工登入
26
     * @param request
27
     * @param employee @RequestBody 注解使得接收到的值指定为json串
28
     * @return
29
     */
30
    @PostMapping("/login")
31
    public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee){
32

33

34
        return null;
35
    }
36

37
}

返回结果类

本次工程内封装的返回结果类，用于给前端响应数据

xxxxxxxxxx
41
1
package com.os467.reggie.common;
2

3
import lombok.Data;
4
import java.util.HashMap;
5
import java.util.Map;
6

7
/**
8
 * 通用返回结果类，服务端响应的数据最终都会封装成此对象
9
 * @param <T>
10
 */
11
@Data
12
public class R<T> {
13

14
    private Integer code; //编码：1成功，0和其它数字为失败
15

16
    private String msg; //错误信息
17

18
    private T data; //数据
19

20
    private Map map = new HashMap(); //动态数据
21

22
    public static <T> R<T> success(T object) {
23
        R<T> r = new R<T>();
24
        r.data = object;
25
        r.code = 1;
26
        return r;
27
    }
28

29
    public static <T> R<T> error(String msg) {
30
        R r = new R();
31
        r.msg = msg;
32
        r.code = 0;
33
        return r;
34
    }
35

36
    public R<T> add(String key, Object value) {
37
        this.map.put(key, value);
38
        return this;
39
    }
40

41
}

功能实现

1.1用户登录后端校验

需要对前端传来的用户密码进行md5加密

在后端查询是否有此用户名（用户名在数据库中设置了不能重）

进行密码校验

需要将用户数据存入到session域中

xxxxxxxxxx
50
1
/**
2
 * 员工登入
3
 * @param request
4
 * @param employee @RequestBody 注解使得接收到的值指定为json串
5
 * @return
6
 */
7
@PostMapping("/login")
8
public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee){
9

10
    //1、将页面提交的密码password进行md5加密处理
11
    String password = employee.getPassword();
12

13
    password = DigestUtils.md5DigestAsHex(password.getBytes());
14

15
    //2、根据页面提交的用户名username查询数据库
16
    String username = employee.getUsername();
17

18
    LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
19

20
    queryWrapper.eq(Employee::getUsername, username);
21

22
    Employee anEmployee = employeeService.getOne(queryWrapper);
23

24
    //3、如果没有查询到则返回登录失败结果
25
    if (anEmployee == null){
26

27
        return R.error("登录失败");
28

29
    }
30

31
    //4、密码比对，如果不一致则返回登陆失败结果
32
    if (!anEmployee.getPassword().equals(password)){
33

34
        return R.error("登录失败");
35

36
    }
37

38
    //5、查看员工状态，如果已禁用状态，则返回员工已禁用结果
39
    if (anEmployee.getStatus() == 0){
40

41
        return  R.error("账号已禁用");
42

43
    }
44

45
    //6、登录成功，将员工id存入Session域中并返回登入成功结果
46

47
    request.getSession().setAttribute("employee",employee.getId());
48

49
    return R.success(anEmployee);
50
}

1.2用户注销

xxxxxxxxxx
14
1
/**
2
 * 员工注销方法
3
 * 1、清理Session中的用户id
4
 * 2、返回结果
5
 * @return
6
 */
7
@PostMapping("/logout")
8
public R<String> logout(HttpServletRequest request){
9

10
    //清除Session域中保存的当前登录员工的id
11
    request.getSession().removeAttribute("employee");
12

13
    return R.success("退出成功");
14
}

☆完善登录功能（过滤器）

如果用户不登陆，直接访问系统页面，照样可以正常访问

这种设计并不合理，我们希望看到的效果应该是，只有登录成功后才可以访问系统中的页面，如果没有登录则跳转登录页面

具体如何实现？

使用过滤器或者拦截器，在过滤器或拦截器中判断用户是否已经无参登录，如果没有登录则跳转登录页面

步骤

1、创建自定义过滤器LoginCheckFilter

2、在启动类上加入注解@ServletCompontentScan

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

创建过滤器

首先在springboot启动类上加@ServletComponentScan注解

• 开启扫描包后
• Servlet、Filter、Listener 可以直接通过 @WebServlet、@WebFilter、@WebListener 注解自动注册

@WebFilter注解

在servlet3.0以后，我们可以不用在web.xml文件内配置Filter，只需要加上@WebFilter注解就可以实现，以达到简化配置的目的

该注解用来声明servlet过滤器，将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为过滤器

filterName属性

指定过滤器的名字

urlPatterns属性

指定一组过滤器的URL匹配模式

xxxxxxxxxx
33
1
package com.os467.reggie.Filter;
2

3
import lombok.extern.slf4j.Slf4j;
4

5
import javax.servlet.*;
6
import javax.servlet.annotation.WebFilter;
7
import javax.servlet.http.HttpServletRequest;
8
import javax.servlet.http.HttpServletResponse;
9
import java.io.IOException;
10

11
/**
12
 * 检查用户是否完成登录
13
 */
14
@Slf4j
15
@WebFilter(filterName = "loginCheckFilter",urlPatterns = "/*")
16
public class LoginCheckFilter implements Filter {
17

18
    @Override
19
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
20

21
        //需要先向下转型
22
        HttpServletRequest request = (HttpServletRequest) servletRequest;
23

24
        HttpServletResponse response = (HttpServletResponse) servletResponse;
25

26
        //日志
27
        log.info("拦截到请求：{}",request.getRequestURI());
28

29
        filterChain.doFilter(request,response);
30

31
    }
32

33
}

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

1、获取本次请求的URI

2、判断本次请求是否需要处理

3、如果不需要处理，则直接放行

4、判断登录状态，如果已登录，则直接放行

5、如果未登录则返回未登录结果

• 过滤器的作用就是之一就是在用户的请求到达servlet之前，拦截下来做预处理
• 处理之后便执行chain.doFilter(request, response)这个方法，如果还有别的过滤器，那么将处理好的请求传给下个过滤器，依此类推
• 当所有的过滤器都把这个请求处理好了之后，再将处理完的请求发给servlet
• 如果就这一个过滤器，那么就将处理好的请求直接发给servlet

AntPathMatcher： 路径匹配器，支持通配符

xxxxxxxxxx
83
1
package com.os467.reggie.Filter;
2

3
import com.alibaba.fastjson.JSON;
4
import com.os467.reggie.common.R;
5
import lombok.extern.slf4j.Slf4j;
6
import org.springframework.util.AntPathMatcher;
7

8
import javax.servlet.*;
9
import javax.servlet.annotation.WebFilter;
10
import javax.servlet.http.HttpServletRequest;
11
import javax.servlet.http.HttpServletResponse;
12
import java.io.IOException;
13

14
/**
15
 * 检查用户是否完成登录
16
 */
17
@Slf4j
18
@WebFilter(filterName = "loginCheckFilter",urlPatterns = "/*")
19
public class LoginCheckFilter implements Filter {
20

21
    //路径匹配器，支持通配符
22
    private static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();
23

24
    @Override
25
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
26

27
        //需要先向下转型
28
        HttpServletRequest request = (HttpServletRequest) servletRequest;
29

30
        HttpServletResponse response = (HttpServletResponse) servletResponse;
31

32
        //1、获取本次请求的URI
33
        String requestURI = request.getRequestURI();
34

35
        //定义不要被处理的请求路径
36
        String[] urls = new String[]{
37
                "/employee/login",
38
                "/employee/logout",
39
                "backend/**",
40
                "/front/**"
41
        };
42

43
        //2、判断本次请求是否需要处理
44
        boolean check = check(urls, requestURI);
45

46
        //3、如果不需要处理，则直接放行
47
        if (check){
48
            filterChain.doFilter(request,response);
49
            return;
50
        }
51

52
        //4、判断登录状态，如果已登录，则直接放行
53
       if(request.getSession().getAttribute("employee") != null){
54
           filterChain.doFilter(request,response);
55
           return;
56
       }
57

58
        //5、如果未登录则返回未登录结果,通过输出流的方式向客户端来响应数据
59
        response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
60
        return;
61
        
62
    }
63

64
    /**
65
     * 路径匹配，检查本次请求是否需要放行
66
     * @param urls
67
     * @param requestURI
68
     * @return
69
     */
70
    public boolean check(String[] urls,String requestURI){
71

72
        for (String url : urls) {
73

74
            boolean match = PATH_MATCHER.match(url, requestURI);
75
            if (match){
76
                return true;
77
            }
78
        }
79

80
        return false;
81
    }
82

83
}

1.3新增员工

为数据库新增员工

xxxxxxxxxx
26
1
/**
2
 * 新增员工
3
 * @param employee
4
 * @return
5
 */
6
@PostMapping
7
public R<String> save(HttpServletRequest request,@RequestBody Employee employee){
8
    log.info("新增员工，员工信息：{}",employee.toString());
9

10
    //设置初始密码123456，并且md5加密
11
    employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
12

13
    //设置创建和更新时间
14
    employee.setCreateTime(LocalDateTime.now());
15
    employee.setUpdateTime(LocalDateTime.now());
16

17
    Long empId = (Long)request.getSession().getAttribute("employee");
18

19
    //设置账户的创建更新人id
20
    employee.setCreateUser(empId);
21
    employee.setUpdateUser(empId);
22

23
    employeeService.save(employee);
24

25
    return R.success("新增员工成功");
26
}

☆全局异常捕获（AOP）

前面的程序还存在一个问题，就是当我们在新增员工时输入的账号已经存在，由于employee表中对该字段加入了唯一约束，此时程序会抛出异常

此时需要我们的程序进行异常捕获，通常由两种处理方式：

1、在Controller方法中加入try、catch进行异常捕获（不推荐）

2、使用异常处理器进行全局异常捕获

第二种方法其实就是通过AOP底层动态代理来对目标方法的增强（异常通知）

@ControllerAdvice注解

annotations属性： 被其中存放的注解修饰的方法会被拦截，传入注解字节码数组

@ExceptionHandler注解

传入异常类的字节码，修饰方法（异常通知的内容），指定异常的处理类型

xxxxxxxxxx
39
1
package com.os467.reggie.common;
2

3
import lombok.extern.slf4j.Slf4j;
4
import org.springframework.web.bind.annotation.ControllerAdvice;
5
import org.springframework.web.bind.annotation.ExceptionHandler;
6
import org.springframework.web.bind.annotation.ResponseBody;
7
import org.springframework.web.bind.annotation.RestController;
8

9
import java.sql.SQLIntegrityConstraintViolationException;
10

11
/**
12
 * 全局异常捕获
13
 */
14
@ControllerAdvice(annotations = {RestController.class})
15
@ResponseBody
16
@Slf4j
17
public class GlobalExceptionHandler {
18

19
    /**
20
     * 异常处理方法
21
     * @return
22
     */
23
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
24
    public R<String> exceptionHandler(SQLIntegrityConstraintViolationException exception){
25

26
        log.error(exception.getMessage());
27

28
        //根据异常提示定位到具体异常处理
29
        if (exception.getMessage().contains(("Duplicate entry"))){
30

31
            String msg = exception.getMessage().split(" ")[2] + "已存在";
32

33
            return R.error(msg);
34
        }
35

36
        return R.error("未知错误");
37
    }
38
}
39

总结

1、根据产品原型明确业务需求

2、重点分析数据的流转过程和数据格式

3、通过debug断点调试跟踪程序执行过程

2.1员工信息的分页查询

系统中的员工很多的时候，如果在一个页面中全部展示出来会显得比较乱，不便于查看，所以一般的系统中都会以分页的方式来展示列表数据

代码开发

1、页面发送ajax请求，将分页查询参数（page，pageSize，name）提交到服务器

2、服务器Controller接收页面提交的数据并调用Service查询数据

3、Service调用Mapper操作数据库，查询分页数据

4、Controller将查询到的分页数据响应给页面

5、页面接收到分页数据并通过ElementUI的Table组件展示到页面上

xxxxxxxxxx
29
1
/**
2
 * 员工信息的分页查询
3
 * @param page
4
 * @param pageSize
5
 * @param name
6
 * @return
7
 */
8
@GetMapping("/page")
9
public R<Page> page(int page,int pageSize,String name){
10

11
    log.info("page = {},pageSize={},name={}",page,pageSize,name);
12

13
    //构造分页构造器
14
    Page pageConstructor = new Page(page,pageSize);
15

16
    //构造条件构造器，需要提供泛型
17
    LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
18

19
    //添加过滤条件
20
    queryWrapper.like(StringUtils.isNotBlank(name),Employee::getUsername,name);
21

22
    //排序条件
23
    queryWrapper.orderByDesc(Employee::getUpdateTime);
24

25
    //执行查询
26
    employeeService.page(pageConstructor,queryWrapper);
27

28
    return R.success(pageConstructor);
29
}

2.2启用/禁用员工账号

需求分析

在员工管理列表页面，可以对某个员工账号进行启用或者禁用操作，账号禁用的员工不能登录系统，启用后的员工可以正常登录

需要注意，只有管理员（admin用户）可以对其他普通用户进行启用、禁用操作，所以普通用户登录系统后启用、禁用按钮不显示

管理员admin登录系统可以对所有员工账号进行启用，禁用操作

如果某个员工账号状态为正常，则按钮显示“禁用”，如果员工账号状态为已禁用，则按钮显示为“启用”

普通员工登录系统后，启用、禁用按钮不显示

代码开发

启用、禁用员工账号，本质上就是一个更新操作，也就是对status状态字段进行操作，在Controller中创建update方法，此方法时一个通用的修改员工信息的方法

☆JS处理Long类型精度丢失

代码修复

通过观察控制台输出的SQL发现页面传递过来的员工id的值和数据库中的id值不一致，这是怎么回事？

• 原来 JS 内置有 32 位整数，而 number 类型的安全整数是 53 位。如果超过 53 位，则精度会丢失。正如现在后台传来一个 64 位的 Long 类型整数，因此超过了 53 位，所以后台返回的值和前台获取的值会不一样
• 页面中js处理long型数字只能精确到前16位，所以最终通过ajax请求提交给服务端的时候id的后三位被四舍五入了

如何解决这个问题？

我们可以在服务端给页面响应json数据时进行处理，将long型数据统一转为String字符串

方法一

使用@JsonSerialize注解

该注解用于属性或者getter⽅法上，⽤于在序列化时嵌⼊开发者⾃定义的代码

@JsonSerialize(using = ToStringSerializer.class)

• 通过fastjson序列化时，增加该字段的序列化类，该序列化类通过CODE查找名称，并序列化到前端，就不会丢失精度了
• 使得Json序列化的时候将此属性转化为String类型

使用以下包

xxxxxxxxxx
2
1
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
2
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer

xxxxxxxxxx
2
1
@JsonSerialize(using = ToStringSerializer.class)
2
private Long id;

方法二

1、提供对象转换器JacksonObjectMapper，基于jackson进行java对象到json数据的转换

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

直接使用JacksonObjectMapper类

xxxxxxxxxx
54
1
package com.os467.reggie.common;
2

3
import com.fasterxml.jackson.databind.DeserializationFeature;
4
import com.fasterxml.jackson.databind.ObjectMapper;
5
import com.fasterxml.jackson.databind.module.SimpleModule;
6
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
7
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
8
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
9
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
10
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
11
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
12
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
13
import java.math.BigInteger;
14
import java.time.LocalDate;
15
import java.time.LocalDateTime;
16
import java.time.LocalTime;
17
import java.time.format.DateTimeFormatter;
18
import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;
19

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

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

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

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

39

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

45
                .addSerializer(BigInteger.class, ToStringSerializer.instance)
46
                .addSerializer(Long.class, ToStringSerializer.instance)
47
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
48
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
49
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
50

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

我们需要去扩展mvc框架的消息转换器

在WebMvcConfig配置类中重写extendMessageConverters方法

消息转换器

添加自定义消息转换器不覆盖默认转换器

使用springboot中默认的Json消息转换器MappingJackson2HttpMessageConverter类创建转换器

这个类的主要实现逻辑是在AbstractJackson2HttpMessageConverter抽象类中实现的

这个列实现序列化与反序列化的最核心组件是ObjectMapper这个类

这些组件之间是如何协助，怎样才能合理的改写组件而实现自定义呢，这就需要了解起原理了

消息转换器创建和生效原理

CSDN博文引用

xxxxxxxxxx
18
1
/**
2
 * 扩展mvc框架的消息转换器
3
 * @param converters
4
 */
5
@Override
6
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
7

8
    //创建新的消息转换器
9
    MappingJackson2CborHttpMessageConverter messageConverter = new MappingJackson2CborHttpMessageConverter();
10

11
    //设置对象转换器，底层使用Jackson将java对象转成json
12
    messageConverter.setObjectMapper(new JacksonObjectMapper());
13

14
    //将上面的消息转换器对象追加到mvc框架的转换器集合中，放在最前面优先使用
15
    converters.add(0,messageConverter);
16

17
    super.extendMessageConverters(converters);
18
}

通用修改员工数据方法

xxxxxxxxxx
19
1
/**
2
 * 根据id来修改员工信息
3
 * @param employee
4
 * @return
5
 */
6
@PutMapping
7
public R<String> update(HttpServletRequest request, @RequestBody Employee employee){
8

9
    log.info(employee+"");
10

11
    Long empId = (Long) request.getSession().getAttribute("employee");
12

13
    employee.setUpdateUser(empId);
14
    employee.setUpdateTime(LocalDateTime.now());
15

16
    employeeService.updateById(employee);
17

18
    return R.success("修改成功");
19
}

2.3编辑员工信息

在员工管理列表页面点击编辑按钮，跳转到编辑页面，在编辑页面回显员工信息并进行修改，最后点击保存按钮完成编辑操作

代码开发

1、点击编辑按钮时,页面跳转到add.html，并在url中携带参数[员工id]

2、在add.html页面获取url中的参数[员工id]

3、发送ajax请求，请求服务端，同时提交员工id参数

4、服务端接收请求，根据员工id查询员工信息，将员工信息以json形式响应给页面

5、页面接收服务端响应的json数据，通过VUE的数据绑定进行员工信息回显

6、点击保存按钮，发送ajax请求，将页面中的员工信息以json方式提交给服务端

7、服务端接收员工信息，并进行处理，完成后给页面响应

8、页面接收到服务端响应信息后进行相应处理

@PathVariable注解

通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中：URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx“) 绑定到操作方法的入参中

xxxxxxxxxx
9
1
@GetMapping("/{id}")
2
public R<Employee> getById(@PathVariable Long id){
3

4
    log.info("根据id来查询员工信息");
5

6
    Employee employee = employeeService.getById(id);
7

8
    return R.success(employee);
9
}

3.分类管理业务开发

☆公共字段自动填充

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

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

使用MybatisPlus提供的公共字段自动填充功能

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

实现步骤：

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

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

使用@TableField注解

@TableField(fill = FieldFill.INSERT)

指定填充策略

• DEFAULT 默认不处理
• INSERT 插入时填充字段
• UPDATE 更新时填充字段
• INSERT_UPDATE 插入和更新时填充字段

元数据对象处理器(填充策略的具体实现)

要实现一个MetaObjectHandler接口

xxxxxxxxxx
46
1
package com.os467.reggie.common;
2

3
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
4
import lombok.extern.slf4j.Slf4j;
5
import org.apache.ibatis.reflection.MetaObject;
6
import org.springframework.stereotype.Component;
7

8
import java.time.LocalDateTime;
9

10
/**
11
 * 元数据对象处理器
12
 */
13
@Component
14
@Slf4j
15
public class MyMetaObjectHandler implements MetaObjectHandler {
16

17
    /**
18
     * 插入操作自动填充
19
     * @param metaObject
20
     */
21
    @Override
22
    public void insertFill(MetaObject metaObject) {
23
        log.info("公共字段自动填充[insert]...");
24
        log.info(metaObject+"");
25

26
        metaObject.setValue("createTime", LocalDateTime.now());
27
        metaObject.setValue("updateTime", LocalDateTime.now());
28
        metaObject.setValue("createUser", new Long(1));
29
        metaObject.setValue("updateUser", new Long(1));
30
    }
31

32
    /**
33
     * 更新操作自动填充
34
     * @param metaObject
35
     */
36
    @Override
37
    public void updateFill(MetaObject metaObject) {
38
        log.info("公共字段自动填充[update]...");
39
        log.info(metaObject+"");
40

41
        metaObject.setValue("updateTime", LocalDateTime.now());
42
        metaObject.setValue("updateUser", new Long(1));
43

44
    }
45
}
46

注意：当前我们设置createUser和updateUser为固定值，后面我们需要进行改造，改为动态获得当前登录用户的id

功能完善

前面我们已经完成了公共字段自动填充功能的代码开发，但是还有一个问题没有解决

• 就是我们在自动填充createUser和updateUser时，设置的用户id是固定值，现在我们需要改造成动态获取当前登录用户的id

有的同学可能想到，用户登录成功后我们将用户id存入了HttpSession中，现在我从HttpSession中获取不就行了?

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

ThreadLocal类

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

1、LoginCheckFilter的doFilter方法

2、EmployeeController的update方法

3、MyMetaObjectHandler的updateFill方法

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

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

什么是ThreadLocal？

ThreadLocal并不是一个线程，而是线程的局部变量，当使用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封装的工具类

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

3、在MyMetaObjectHandler的方法中调用BaseContext获取登录用户的id

编写工具类

xxxxxxxxxx
18
1
package com.os467.reggie.common;
2

3
/**
4
 * 基于ThreadLocal封装工具类，用户保存和获取当前登录用户id
5
 */
6
public class BaseContext {
7

8
    private static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
9

10
    public static void setCurrentId(Long id){
11
        threadLocal.set(id);
12
    }
13

14
    public static Long getCurrentId(){
15
        return threadLocal.get();
16
    }
17

18
}

在doFilter方法中获取id并且存储id值

xxxxxxxxxx
11
1
/4、判断登录状态，如果已登录，则直接放行
2
if(request.getSession().getAttribute("employee") != null){
3

4
    Long empId = (Long)request.getSession().getAttribute("employee");
5

6
    BaseContext.setCurrentId(empId);
7

8
    log.info("用户已登录，用户id为：{}",request.getSession().getAttribute("employee"));
9
    filterChain.doFilter(request,response);
10
    return;
11
}

在MyMetaObjectHandler类中获取需要的id值

xxxxxxxxxx
13
1
/**
2
 * 更新操作自动填充
3
 * @param metaObject
4
 */
5
@Override
6
public void updateFill(MetaObject metaObject) {
7
    log.info("公共字段自动填充[update]...");
8
    log.info(metaObject+"");
9

10
    metaObject.setValue("updateTime", LocalDateTime.now());
11
    metaObject.setValue("updateUser", BaseContext.getCurrentId());
12

13
}

3.1新增分类

需求分析

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

xxxxxxxxxx
14
1
/**
2
 * 新增分类
3
 * @param category
4
 * @return
5
 */
6
@PostMapping
7
public R<String> save(@RequestBody Category category){
8

9
    log.info("category:{}",category);
10

11
    categoryService.save(category);
12

13
    return R.success("新增分类成功");
14
}

分页列表

xxxxxxxxxx
23
1
/**
2
 * 分类分页
3
 * @param page
4
 * @param pageSize
5
 * @return
6
 */
7
@GetMapping("page")
8
public R<Page> page(int page,int pageSize){
9

10
    log.info("page = {},pageSize={},",page,pageSize);
11

12
    Page<Category> pageConstructor = new Page<>(page,pageSize);
13

14
    //条件构造器
15
    LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
16

17
    //根据sort字段排序
18
    queryWrapper.orderByAsc(Category::getSort);
19

20
    categoryService.page(pageConstructor,queryWrapper);
21

22
    return R.success(pageConstructor);
23
}

3.2删除分类

删除分类

xxxxxxxxxx
14
1
/**
2
 * 删除分类
3
 * @param ids
4
 * @return
5
 */
6
@DeleteMapping
7
public R<String> delete(Long ids){
8

9
    log.info("删除分类，id为{}",ids);
10

11
    categoryService.removeById(ids);
12

13
    return R.success("分类信息删除成功");
14
}

功能完善

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

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

实体类Dish和Setmeal

Mapper接口

Service实接口

Service实现类

根据条件删除分类，同时判断是否抛出异常

xxxxxxxxxx
64
1
package com.os467.reggie.service.impl;
2

3
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
4
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
5
import com.os467.reggie.common.CustomException;
6
import com.os467.reggie.entity.Category;
7
import com.os467.reggie.entity.Dish;
8
import com.os467.reggie.entity.Setmeal;
9
import com.os467.reggie.mapper.CategoryMapper;
10
import com.os467.reggie.service.CategoryService;
11
import com.os467.reggie.service.DishService;
12
import com.os467.reggie.service.SetmealService;
13
import org.springframework.beans.factory.annotation.Autowired;
14
import org.springframework.stereotype.Service;
15

16
@Service
17
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
18

19
    @Autowired
20
    private SetmealService setmealService;
21

22
    @Autowired
23
    private DishService dishService;
24

25
    /**
26
     * 根据id来删除分类，删除之前进行判断
27
     * @param id
28
     */
29
    @Override
30
    public void remove(Long id) {
31

32
        LambdaQueryWrapper<Dish> queryWrapperDish = new LambdaQueryWrapper<>();
33
        //添加查询条件，根据分类id进行查询
34
        queryWrapperDish.eq(Dish::getCategoryId, id);
35

36
        //查询当前分类是否关联了菜品
37
        int count1 = dishService.count(queryWrapperDish);
38

39
        if (count1 > 0){
40

41
            //已经关联了菜品，抛出一个业务异常
42
            throw new CustomException("当前分类下关联了菜品，不能删除");
43

44
        }
45

46
        //查询当前的分类是否关联了相应的套餐
47
        LambdaQueryWrapper<Setmeal> queryWrapperSetmeal = new LambdaQueryWrapper<>();
48

49
        queryWrapperSetmeal.eq(Setmeal::getCategoryId,id);
50

51
        int count2 = setmealService.count(queryWrapperSetmeal);
52

53
        if (count2 > 0){
54

55
            //已经关联了套餐，抛出一个业务异常
56
            throw new CustomException("当前分类下关联了套餐，不能删除");
57

58
        }
59

60
        //正常删除分类
61
        super.removeById(id);
62

63
    }
64
}