Java项目实战【超级详细】

软件开发流程

角色分工

---

开发环境搭建

创建普通Maven项目编写pom.xml导入依赖

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>com.yjq</groupId>
    <artifactId>reggie_take_out</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <!--         将对象 转化为JSON格式-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.5</version>
            </plugin>
        </plugins>
    </build>


</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

配置文件application.yml

server:
  port: 8080
spring:
  application:
    #应用的名称，可选
    name: reggie_take_out
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db_reggie?serverTimezone=Asia/Ningbo&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
      username: root
      password: 123456

mybatis-plus:
  configuration:
    #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

启动类编写

src/main/java/com/XXX/reggie/ReggieApplication.java

package com.yjq.reggie;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@Slf4j //直接可使用log日志
@SpringBootApplication
public class ReggieApplication {
    public static void main(String[] args) {
        SpringApplication.run(ReggieApplication.class,args);
        log.info("项目启动成功..."); //测试项目启动
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

配置类编写 完成MVC框架静态资源映射

config/WebMvcConfig

package com.yjq.reggie;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@Slf4j //直接可使用loge
@SpringBootApplication
public class ReggieApplication {
    public static void main(String[] args) {
        SpringApplication.run(ReggieApplication.class,args);
        log.info("项目启动成功...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

再次启动查看日志是否成功，然后访问页面http://localhost:8080/backend/index.html

ps:不管用的看看放的路径是否正确，启动类要在最外层

---

员工管理功能

---

后台登录功能

需求分析

http://localhost:8080/backend/page/login/login.html打开登陆页面
按下F12，点击登录按钮，发送请求并题交参数

数据模型

创建实体类Employee与数据模型（employee表）映射

创建实体类entity / Employee.java

package com.yjq.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;       //性别
    /**
     * 驼峰命名自动映射sql表中的下划线命名
     * application.yml配置文件中配置
     */
    private String idNumber;  // 身份证号

    private Integer status;   //状态 0:禁用，1:正常


    @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;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

代码开发

创建mapper,service,controller层
项目结构图

mapper层
( 注意：写接口，使用MybatisPlus可继承BaseMapper<>方便简单CRUD)

package com.yjq.reggie.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yjq.reggie.entity.Employee;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface EmployeeMapper extends BaseMapper<Employee> {
}
1
2
3
4
5
6
7
8
9

service层

实现通用增删改查的service接口
（[service接口继承IService]
(https://blog.csdn.net/weixin_38111957/article/details/92415413)）

package com.yjq.reggie.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.yjq.reggie.entity.Employee;
/***
 * 通用 Service CRUD 封装IService (opens new window)接口，
 * 进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页
 * 前缀命名方式区分 Mapper 层避免混淆，(mapper用select等字眼，service用get等字眼)
 * 泛型 T 为任意实体对象
 * 建议如果存在自定义通用 Service 方法的可能，
 * 请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类 ServiceImpl
 * 对象 Wrapper 为 条件构造器
 */
public interface EmployeeService extends IService<Employee> {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

自定义通用Service方法
service实现类 继承ServiceImpl<EmployeeMapper,Employee>
并执行EmployeeService 接口

package com.yjq.reggie.service.impl;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yjq.reggie.entity.Employee;
import com.yjq.reggie.mapper.EmployeeMapper;
import com.yjq.reggie.service.EmployeeService;
import org.springframework.stereotype.Service;
/***
 *  service实现类   继承mp提供通用的service基类 ServiceImpl
 *  ServiceImpl<EmployeeMapper, Employee>
 *      2个泛型 1.EmployeeMapper  Mapper接口
 *              2.Employee       对应entity(对象、实体)
 */
@Service
public class EmployeeServiceImpl  extends ServiceImpl<EmployeeMapper,Employee> implements EmployeeService {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

controller层

import com.yjq.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")   //请求路径url
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

编写 通用返回结果Result类
/common / Result
（通用结果类，服务端响应的所以结果最终都会包装成各种类型返回给前端页面）

需要后端返给前端code,data,msg

package com.yjq.reggie.common;

import lombok.Data;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * 通用结果类，服务端响应的所以结果最终都会包装成各种类型返回给前端页面
 * @Data注解没写，会显示接口406错误
 * @param <T>
 */
 
 @Data
public class Result<T>{

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

    private String msg; //错误信息

    private T data; //数据

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

    public static <T> Result<T> success(T object) {
        Result<T> res = new Result<T>();
        res.data = object;
        res.code = 1;
        return res;
    }


    public static <T> Result<T> error(String msg) {
        Result res = new Result();
        res.msg = msg;
        res.code = 0;
        return res;
    }

    public Result<T> add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

登陆方法代码实现

根据post请求方式，请求URL @PostMapping("/login")

根据返回的Jason数据@RequestBody Employee employee

需要用到request去getSession

public Result<Employee> login(HttpServletRequest request, @RequestBody Employee employee)
{
   return null;
}
1
2
3
4

业务逻辑：

在controller中创建登录方法

   @Autowired
    private EmployeeService employeeService;

    /**
     * 员工登录
     * @param request
     * @param employee
     * @return
     */

    @PostMapping("/login")              //    @RequestBody接收前端 发送过来的JSON风格的数据，将其转化为相应的对象
    public Result<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);//数据唯一（表中属性为Unique）

        //3.如果没有查询到则返回登录失败结果
        if (emp == null){
            return Result.error("用户名不存在！");
        }

        //4.密码比对，如果不一样则返回登录失败结果
        if (!emp.getPassword().equals(password)){
            return Result.error("用户名或密码错误！");
        }

        //5.查看员工状态，如果已禁用状态，则返回员工已禁用结果
        if (emp.getStatus() != 1){  // 账号被禁用，status == 1,账号可以正常登录
            return Result.error("账号被禁用，请联系管理员或客服！");
        }

        //6.登录成功，将用户id存入Session并返回登录成功
        request.getSession().setAttribute("employee",emp.getId());
        return Result.success(emp);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

功能测试

---

完善登录功能(过滤器)

需求分析

代码开发

实现步骤:
1、创建自定义过滤器LoginCheckFilter
2、在启动类上加入注解@ServletComponentScan
3.完善过滤器的处理逻辑

…/Application.java 启动类中加上@ServletComponentScan注解

package com.yjq.reggie;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@Slf4j //直接可使用loge
@SpringBootApplication
@ServletComponentScan //过滤器
public class ReggieApplication {
    public static void main(String[] args) {
        SpringApplication.run(ReggieApplication.class,args);
        log.info("项目启动成功...");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

业务逻辑

package com.yjq.reggie.filter;

import com.alibaba.fastjson.JSON;
import com.yjq.reggie.common.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.AntPathMatcher;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 检查用户是否已登录
 */
@Slf4j
@WebFilter(filterName = "loginCheckFilter",urlPatterns = "/*")
public class LoginCheckFilter implements Filter {

    public static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();  //匹配器，专门用来路径匹配的

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //1.获取本次请求的URI
        String requestURI = request.getRequestURI();
        log.info("拦截到请求:{}",requestURI);

        //定义不需要处理的请求路径
        String[] urls = new String[]{
            "/employee/login",
            "/employee/logout",
            "/backend/**",   //AntPathMatcher  路径比较，通配符匹配
            "/front/**"
        };
        //2.判断本次请求是否需要处理
        boolean check = check(urls,requestURI);

        //3.如果不需要处理，则直接放行
        if(check){
            log.info("本次请求{}不需要处理",requestURI);
            filterChain.doFilter(request,response);
            return;
        }


        //4.判断登录状态，如果已登录，则直接放行
        if(request.getSession().getAttribute("employee") != null){
            log.info("用户已登录，用户id为：{}",request.getSession().getAttribute("employee"));
            filterChain.doFilter(request,response);
            return;
        }

        log.info("用户未登录");
        //5.如果未登录则返回未登录结果,通过输出流方式向客户端页面响应数据
        response.getWriter().write(JSON.toJSONString(Result.error("NOTLOGIN")));
        return;
    }

    /**
     * 路径匹配，检查本次请求是否需要放行
     * @param urls
     * @param requestURI
     * @return
     */
    public boolean check(String[] urls,String requestURI){
        //遍历请求路径
        for (String url : urls) {
            boolean match = PATH_MATCHER.match(url, requestURI);
            if(match){
                return true; //匹配就返回true，放行
            }
        }
        return false;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

注意：response.getWriter().write(JSON.toJSONString(Result.error("NOTLOGIN")));
NOTLOGIN 与静态资源中…/js/request.js中响应拦截器里msg信息要一致不然刷新到index.html页面不会跳转到登录页面

功能测试

---

后台退出功能

需求分析

员工登录成功后，页面跳转到后台系统首页面(backend/indexhtml)，此时会显示当前登录用户的姓名:
如果员工需要退出系统，直接点击右侧的退出按钮即可很出系统，退出系统后页面应跳转回登录页面

代码开发

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

/**
     * 退出登录
     * @param request
     * @return
     */
    @PostMapping("/logout")
    public Result<String> logout(HttpServletRequest request){
        //清理用户id
        request.getSession().removeAttribute("employee");
        return Result.success("退出成功");
    }
    
1
2
3
4
5
6
7
8
9
10
11
12

功能测试

省略

---

新增员工功能

需求分析

数据模型

新增用户的用户名设置为unique具有唯一属性，status状态要有默认值1不被禁用

代码开发

 /**
     * 新增员工
     * @param request
     * @param employee
     * @return
     */
    @PostMapping
    public Result<String> save(HttpServletRequest request,@RequestBody Employee employee){
        log.info("新增员工，员工信息:{}",employee.toString());

        // 在新增员工操作中，对员工的密码进行初始化( MD5加密 )
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));

        //下面设置 公共属性的值(createTime、updateTime、createUser、updateUser)交给 MyMetaObjectHandler类处理
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());

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

        employee.setCreateUser(empId);
        employee.setUpdateUser(empId);

        employeeService.save(employee);

        return Result.success("成功新增员工");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.yjq.reggie.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;

// 全局异常处理
// 如果类上加有 @RestController、@Controller注解(annotations的属性值)的类中有方法抛出异常，由GlobalExceptionHander来处理异常
@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody  // 将结果封装成JSON数据并返回
@Slf4j
public class GlobalExceptionHander {

    // 解决 字段username被唯一索引约束的情况下，添加相同的username，抛出SQLIntegrityConstraintViolationException 的全局异常
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public Result<String> exceptionHandler(SQLIntegrityConstraintViolationException e){
        log.info(e.getMessage());

        if (e.getMessage().contains("Duplicate entry")){
            String[] split = e.getMessage().split(" ");
            String msg = split[2] + "已存在";
            return Result.error(msg);
        }
        return Result.error("操作失败！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

功能测试

前端返给服务端参数，服务端返还jason数据

---

员工信息分页查询功能

需求分析

代码开发

…/config/MybatisPlusConfig

package com.yjq.reggie.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//  配置MybatisPlus的分页插件
@Configuration  // 标注MybatisPlusConfig是一个配置类
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());

        return mybatisPlusInterceptor;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

    /**
     * 分页展示功能
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    //     1、页面发送Ajax请求，将分页查询参数(page、pageSize、name)提交到服务端
    //     2、服务端Controller接收页面提交的数据 并调用Service查询数据
    //     3、Service调用Mapper操作数据库，查询分页的数据
    //     4、Controller将查询的分页数据 响应给页面
    //     5、页面接收到分页数据并通过前端(ElementUI)的table组件展示到页面上
    @GetMapping("/page")
    public Result<Page> pageShow(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();
        //   name不为null，才会 比较 getUsername方法和前端传入的name是否匹配 的过滤条件
        queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getUsername,name);

        // 去数据库查询
        employeeService.page(pageInfo,queryWrapper);
        return Result.success(pageInfo);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

功能测试

---

启用/禁用员工账号功能

需求分析

代码开发

功能测试

    @PutMapping   
    //                     ！！！！ @RequestBody不要忘
    public Result<String> update(HttpServletRequest request,@RequestBody Employee employee){
        log.info(employee.toString());

        // 下面设置 公共属性的值(createTime、updateTime、createUser、updateUser)交给 MyMetaObjectHandler类处理
        Long empId = (Long) request.getSession().getAttribute("employee");
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(empId);

        employeeService.updateById(employee);
        return Result.success("员工信息修改成功！");

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

原来修改代码可执行但无效修改，需要修复

代码修复

…/common/JacksonObjectMapper配置类

package com.yjq.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]
 */
//  将 较大值的Long类型数据 传到前端，可能会造成数值的精度丢失，将Long类型数据转化为字符串再传到前端就可以解决该问题
//  同时，在WebMvcConfig中 添加消息转换方法extendMessageConverters(List<HttpMessageConverter<?>> converters)
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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

扩展SpringMvc的消息转换器

…/config/WebMvcConfig.java

 /**
     * 扩展SpringMvc的消息转换器
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("自定义消息转化器 被调用!");
        // 创建消息转换器对象
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        // 设置对象转换器，底层使用JackSON 将Java对象 转化为JSON
        messageConverter.setObjectMapper(new JacksonObjectMapper());

        // 将上面的消息转换器对象追加到SpringMVC的 转换器容器 的第一个位置(优先采用下标为 0 位置的消息转换器)
        converters.add(0,messageConverter);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

再次测试

---

编辑员工信息功能

需求分析

代码开发

 /**
     * 根据id查询员工信息(编辑接口)
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public Result<Employee> getById (@PathVariable Long id) {
        log.info("根据id查询员工信息...");

        Employee employee = employeeService.getById(id);
        if (employee != null) {
            return Result.success(employee);
        }

        return Result.error("没有查询到员工信息");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

功能测试

---

分类管理功能

---

公共字段自动填充功能

需求分析

代码开发

package com.yjq.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;       //性别
    /**
     * 驼峰命名自动映射sql表中的下划线命名
     * application.yml配置文件中配置
     */
    private String idNumber;  // 身份证号

    private Integer status;   //状态 0:禁用，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;                //插入和更新时填充字段

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

这里先将createUser和updateUser的id值写死为1，后面完善功能会用获取的id替换

package com.yjq.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;

@Slf4j
@Component
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", new Long(1));
        metaObject.setValue("updateUser", new Long(1));
    }

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

        metaObject.setValue("updateTime", LocalDateTime.now());
        metaObject.setValue("updateUser", new Long(1));  
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

功能完善

验证一次请求，走的同一个线程

把测试日志插入
LoginCheckFiter.java
EmployeeController.java
MyMetaObjectHandler.java程序中，打开修改页面保存看结果

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

ThreadLocal

package com.yjq.reggie.common;

/**
 * 基于ThreadLocal 封装工具类，用户保存和获取当前登录的用户id
 * ThreadLocal以线程为 作用域，保存每个线程中的数据副本
 */
public class BaseContext {

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


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

    /**
     * 获取当前用户id值
     * @return
     */
    public static Long getCurrentId(){
        return threadLocal.get();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package com.yjq.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;

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    /**
     * 插入操作，自动填充
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("公共字段自动填充[insert]...");
        log.info(metaObject.toString());

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

        metaObject.setValue("createTime", LocalDateTime.now());
        metaObject.setValue("updateTime", LocalDateTime.now());
        /**
         * 获取当前用户id值
         */
        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());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

功能测试

---

新增分类功能

需求分析

数据模型

代码开发

Entity实体类

package com.yjq.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;


//    是否删除(逻辑删除，Category表中没有isDeleted 字段)
//    private Integer isDeleted;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

Mapper接口

package com.yjq.reggie.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yjq.reggie.entity.Category;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface CategoryMapper extends BaseMapper<Category> {
}

1
2
3
4
5
6
7
8
9
10

业务层Service接口

package com.yjq.reggie.service;


import com.baomidou.mybatisplus.extension.service.IService;
import com.yjq.reggie.entity.Category;

public interface CategoryService extends IService<Category> {
}

1
2
3
4
5
6
7
8
9

业务层ServiceImpl实现类

package com.yjq.reggie.service.impl;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yjq.reggie.entity.Category;
import com.yjq.reggie.mapper.CategoryMapper;
import com.yjq.reggie.service.CategoryService;
import org.springframework.stereotype.Service;

/***
 *  service实现类   继承mp提供通用的service基类 ServiceImpl
 *  ServiceImpl<CategoryMapper, Category>
 *      2个泛型 1.CategoryMapper  Mapper接口
 *             2.Category      对应entity(对象、实体)
 */
@Service
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Controller控制层

package com.yjq.reggie.controller;

import com.yjq.reggie.entity.Category;
import com.yjq.reggie.service.CategoryService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 分类管理
 */
@Slf4j
@RestController
@RequestMapping("/category")
public class CategoryController {

    @Autowired
    private CategoryService categoryService;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  /**
     * 新增分类
     * @param category
     * @return
     */
    @PostMapping
    public Result<String> save(@RequestBody Category category){
        log.info("category: {}",category);
        categoryService.save(category);
        return Result.success("新增分类成功");
    }
1
2
3
4
5
6
7
8
9
10
11

功能测试

---

分类信息分类查询功能

需求分析

代码开发

构造根据sort值排序的条件构造器

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
    @GetMapping("/page")
    public Result<Page> pageShow(int page, int pageSize){

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

        // 创建分页构造器对象
        Page pageInfo = new Page(page,pageSize);

        //  条件构造器
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper();
        //  根据 Category对象的sort字段 来排序展示
        queryWrapper.orderByAsc(Category::getSort);
        // 去数据库查询
        categoryService.page(pageInfo,queryWrapper);
        return Result.success(pageInfo);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

功能测试

---

删除功能

需求分析

代码开发

 /**
     * 删除分类
     * @param id
     * @return
     */
    @DeleteMapping
    public Result<String> deleteById(Long id){
        log.info("删除分类，分类id为：{}",id);

        categoryService.removeById(id);

        return Result.success("删除成功");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

这里只给Dish和Setmeal的实体类代码，剩下的接口和实现类与之前类似，此处省略

package com.yjq.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;


/**
 * 菜品分类，id为1
 */
@Data
public class Dish implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;


    //菜品名称
    private String name;


    //菜品分类id
    private 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;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package com.yjq.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;



/**
 * 套餐分类，id为2
 */
@Data
public class Setmeal implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;


    //分类id
    private 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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

回到categoryService层重写remove方法

public void remove(Long id);

自定义异常类

package com.yjq.reggie.common;

/**
 * 自定义异常
 */
public class MyCustomException extends RuntimeException{
    //有参构造器
    public MyCustomException(String msg){
        super(msg);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

在全局处理中处理异常

    @ExceptionHandler(MyCustomException.class)
    public Result<String> exceptionHandler(MyCustomException e){
        log.info(e.getMessage());

        return Result.error(e.getMessage());

    }
```v
在删除功能中重新调用Service的自定义remove方法
```java
   /**
     * 删除分类
     * @param id
     * @return
     */
    @DeleteMapping
    public Result<String> deleteById(Long id){
        log.info("删除分类，分类id为：{}",id);

        //categoryService.removeById(id);

        categoryService.remove(id);

        return Result.success("删除成功");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

功能测试

出现bug,属于前后端id名不同导致，多亏弹幕大军

然后在静态资源中找到发现，前端定义的接口参数是ids,而我们controller写的参数是id
刚开始我以为两种方式改变其中任意一个对应上就行，但改前端接口还是不行，所以只能妥协的改掉controller方法里的参数为ids

ps：有知道的大佬还请赐教

/**
     * 删除分类
     * @param ids
     * @return
     */
    @DeleteMapping
    public Result<String> deleteById(Long ids){
        log.info("删除分类，分类id为：{}",ids);

        //categoryService.removeById(id);

        categoryService.remove(ids);

        return Result.success("删除成功");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

修改分类功能

需求分析

代码开发

    /**
     * 根据id修改功能
     * @param category
     * @return
     */
    @PutMapping
    public Result<String> update(@RequestBody Category category){
        log.info("修改分类信息:{}",category);

        categoryService.updateById(category);

        return Result.success("分类信息 修改成功！");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

功能测试

---

菜品管理功能

文件上传下载

简要介绍

文件上传

前端文件上传组件

文件下载

代码开发

服务端文件上传

两种方式：
1.在过滤器中添加放行路径

2.先登录再打开上传界面

package com.yjq.reggie.controller;

import com.yjq.reggie.common.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
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 javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.UUID;

@RestController
@RequestMapping("/common")
@Slf4j
public class CommonController {

    @Value("${upload.filePath}")
    private String basePath;

    // 文件上传
    @PostMapping("/upload")
    public Result<String> upload(MultipartFile file){
        // file是一个临时文件，需要转存到磁盘中的某个指定位置，否则本次请求完成后，临时文件file会删除
        //   upload方法名中的参数名 必须是file（文件上传表单的 中name属性值必须是file,name="file"）
        log.info("上传的文件为: "+file.toString());

        // 原始文件名
        String originFileName = file.getOriginalFilename();   // 设 fileName为 abc.jpg
        String suffix = originFileName.substring(originFileName.lastIndexOf("."));  // suffix = .jpg

        // 使用UUID重新生成文件名，防止文件名重复，造成后面上传的文件覆盖前面上传的文件
        String fileName = UUID.randomUUID().toString() + suffix;

        // 创建一个目录对象 dir
        File dir = new File(basePath);

        if (!dir.exists()){
            dir.mkdirs();
        }

        try {
            // 将临时文件转存到指定 位置
            file.transferTo(new File(basePath + fileName));
        } catch (IOException e) {
            e.printStackTrace();
        }

        return Result.success(fileName);
    }
    // 文件下载  download
    @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];
            // 输入流读取到 内容放到 bytes数组中
            while((len = fileInputStream.read(bytes)) != -1){ // 输入流还没有读取完数据
                outputStream.write(bytes,0,len);
                outputStream.flush();
            }

            fileInputStream.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

功能测试

---

新增菜品

需求分析

数据模型

代码开发

下菜品分类下拉框选项数据展示功能

…/controller/CatergoryController

    // 根据条件查询分类数据
    @GetMapping("/list")
    public Result<List<Category>> categoryList(Category category){
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        //  只有当 category.getType()不为空，才会比较 前端传入的category的type和 实体类中 type属性是否相等
        queryWrapper.eq(category.getType() != null, Category::getType,category.getType());

        queryWrapper.orderByAsc(Category::getSort).orderByDesc(Category::getUpdateTime);

        List<Category> list = categoryService.list(queryWrapper);

        return Result.success(list);
    }
    // 前端传输到服务端的数据 和实体类中的属性 不是一一对应关系，
    // 需要用到DTO(Data Transfer Object)对象，即数据传输对象，一般用于Controller和Service层之间的数据传输
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

添加菜品页面数据保存功能

DishDTo实体类（原来的Dish实体类中没有菜品口味的name和value属性）

package com.yjq.reggie.dto;

import com.yjq.reggie.entity.Dish;
import com.yjq.reggie.entity.DishFlavor;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;

// 前端传输到服务端的数据 和实体类中的属性 不是一一对应关系，
// 需要用到DTO(Data Transfer Object)对象，即数据传输对象，一般用于Controller和Service层之间的数据传输
@Data
public class DishDto extends Dish {
    //  Dish 不符合前端传过来的数据,需要将其转化为DishDto
    // flavors: 菜品对应的口味数据
    private List<DishFlavor> flavors = new ArrayList<>();

    private String categoryName;

    private Integer copies;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在接口中自定义方法（操作两张表）

package com.yjq.reggie.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.yjq.reggie.dto.DishDto;
import com.yjq.reggie.entity.Dish;


public interface DishService extends IService<Dish> {

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

实现类重写方法

package com.yjq.reggie.service.impl;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yjq.reggie.dto.DishDto;
import com.yjq.reggie.entity.Dish;
import com.yjq.reggie.entity.DishFlavor;
import com.yjq.reggie.mapper.DishMapper;
import com.yjq.reggie.service.DishFlavorService;
import com.yjq.reggie.service.DishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
public class DishServiceImpl extends ServiceImpl<DishMapper, Dish> implements DishService {

    @Autowired
    private DishService dishService;

    @Autowired
    private DishFlavorService dishFlavorService;

    /**
     *新增菜品，同时保存对应的口味数据
     * @param dishDto
     */
    // 由于涉及到对dish、dish_flavor两张表的操作，应该使用 @Transactional 来标注事务
    // 要让@Transactional 生效，还需在启动类添加@EnableTransactionManagement 来开启事务
    @Transactional
    public void saveWithFlavor(DishDto dishDto) {
        //保存菜品的基本信息到菜品表dish
        this.save(dishDto);
        //保存菜品口味数据到菜品口味表dish_flavor

        Long dishId = dishDto.getId(); //菜品Id

        //菜品口味
        List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((flavor)->{
            flavor.setDishId(dishId);
            return flavor;
        }).collect(Collectors.toList());

        dishFlavorService.saveBatch(flavors);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

JAVA 批量修改List里面某个字段的方法

方法一：通过流的方式

List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((item) -> {
            item.setDishId(dishId);
            return item;
        }).collect(Collectors.toList());
1
2
3
4
5

方法二：通过forEach

List<DishFlavor> flavors = dishDto.getFlavors();
flavors.forEach(item -> item.setDishId(dishId));
1
2

最后在DishController中的save方法中调用自定义方法

   /**
     * 新增菜品
     * @param dishDto
     * @return
     */
    @PostMapping
    public Result<String> save(@RequestBody DishDto dishDto) {
        log.info(dishDto.toString());
        dishService.saveWithFlavor(dishDto);
        return Result.success("新增菜品操作成功");
    }
1
2
3
4
5
6
7
8
9
10
11

功能测试

---

菜品信息分页查询

需求分析

代码开发

 //  分页展示菜品信息
    @GetMapping("/page")
    // dish/page?page=1&pageSize=10&name=122334,name 是搜索框中的输入值
    public Result<Page> pageShow(int page,int pageSize,String name){
        Page pageInfo = new Page(page,pageSize);

        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        // 添加过滤条件
        queryWrapper.like(name != null,Dish::getName,name);
        queryWrapper.orderByDesc(Dish::getUpdateTime);
        //  执行分页查询
        dishService.page(pageInfo,queryWrapper);

        return Result.success(pageInfo);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

菜品分类一栏没有显示，可以看到后端返回的是categoryId,应该返回categoryName菜品名称

 /**
     * 分页展示菜品信息
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    // dish/page?page=1&pageSize=10&name=122334,name 是搜索框中的输入值
    public Result<Page> pageShow(int page,int pageSize,String name){
        // 构造分页构造器对象
        Page<Dish> dishPage = new Page(page,pageSize);

        Page<DishDto> dtoPage = new Page<>();

        // 条件构造器
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        // 添加过滤条件
        queryWrapper.like(name != null,Dish::getName,name);
        // 添加排序条件
        queryWrapper.orderByDesc(Dish::getUpdateTime);
        // 执行分页查询
        dishService.page(dishPage,queryWrapper);

        //  将 dish 中的属性值复制到 dtoPage，但是忽略 records
        //  records需要另外去设置
        BeanUtils.copyProperties(dishPage,dtoPage,"records"); //忽略records，因为dishPage的records数据中不包括菜品名称categoryName

        List<Dish> records = dishPage.getRecords();

        List<DishDto> dtoList = records.stream().map((dish) -> {  // dish 为每个菜品对象
            DishDto dishDto = new DishDto();

            BeanUtils.copyProperties(dish,dishDto);

            Long categoryId = dish.getCategoryId();  // 菜品的分类id

            Category category = categoryService.getById(categoryId);   //根据菜品分类的id得到菜品对象
            if (category != null){
                dishDto.setCategoryName(category.getName());         //根据菜品得到菜品名称
            }

            return dishDto;
        }).collect(Collectors.toList());

        dtoPage.setRecords(dtoList); //将包含菜品名称的list赋给dtoPage
        return Result.success(dtoPage);
    }





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

功能测试

---

修改菜品

需求分析

代码开发

修改前数据回显

回显数据涉及两个表的数据，到DishService中自定义get方法（获取dish表中基本信息以及dish_flavor中对应的口味信息）

这里使用DishDto为返回对象类型，与页面数据对应

 // 根据dishId查询 菜品信息和口味信息
    public DishDto getByDishIdWithFlavor(Long dishId);
1
2

 /**
     * 根据id查询菜品信息和对应的口味信息
     * @param dishId
     * @return
     */
    @Override
    public DishDto getByDishIdWithFlavor(Long dishId) {
        // 只是关联查询两张表，没有涉及事务，不用加 @Transactional
        // 从dish表中查询 菜品的基本信息
        Dish dish = this.getById(dishId);
        DishDto dishDto = new DishDto();

        BeanUtils.copyProperties(dish,dishDto);

        //  从dish_flavor表查询 当前菜品对应的口味信息
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DishFlavor::getDishId,dishId);

        List<DishFlavor> list = dishFlavorService.list(queryWrapper);

        dishDto.setFlavors(list);
        return dishDto;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

  /**
     * 根据id查询菜品信息和对应的口味信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public Result<DishDto> get(@PathVariable Long id){

        DishDto dishDto = dishService.getByDishIdWithFlavor(id);

        return Result.success(dishDto);
    }
1
2
3
4
5
6
7
8
9
10
11
12

回显后修改保存

功能测试

---

自我完善部分

---

菜品售卖状态修改功能(批量修改)

菜品删除功能（批量删除）

---

套餐管理功能

新增套餐功能

需求分析

数据模型

代码开发

SetmealDish 套餐餐品

package com.yjq.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;


    //套餐id
    private Long setmealId;


    //菜品id
    private 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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

SetmealDto 继承 Setmeal套餐的基本属性，
另外根据前端页面需求数据添加了特有属性

package com.yjq.reggie.dto;

import com.yjq.reggie.entity.Setmeal;
import com.yjq.reggie.entity.SetmealDish;
import lombok.Data;

import java.util.List;

@Data
public class SetmealDto extends Setmeal {

    //新增套餐中自选菜品的集合
    private List<SetmealDish> setmealDishes;
    //设置分页查询页面的套餐分类名称
    private String categoryName;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

接口和控制层省略…

---

1-2.套餐分类和菜品分类的数据获取（CategoryController中处理过）
3.在DishController中

    /**
     * 套餐管理/新增套餐/
     * 添加菜品功能中根据套餐id查询相应的菜品
     * @param dish
     * @return
     */
    @GetMapping("/list")
    public Result<List<Dish>> list(Dish dish){
        //构造条件查询
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        //等值查询
        queryWrapper.eq(dish.getCategoryId() != null,Dish::getCategoryId,dish.getCategoryId());
        //必须是起售的菜品才显示
        queryWrapper.eq(Dish::getStatus,1);
        //排序条件：根据sort升序排，根据更新时间降序排
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

        List<Dish> dishList = dishService.list(queryWrapper);

        return Result.success(dishList);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4-5.图片上传下载也已经处理过了

6.需要自定义保存方法
（原因：只操作setmeal表，套餐中的菜品信息无法保存）
在SetmealService中自定义保存方法，调用setmeal和seatmeal_dish表

 /**
     * 新增套餐，同时需要保存套餐和菜品的关联关系
     * @param setmealDto
     */
    @Transactional
    public void saveWithDish(SetmealDto setmealDto) {
        //保存套餐的基本信息，操作setmeal，执行insert操作
        this.save(setmealDto);
        //保存套餐和菜品的关联关系，操作setmeal_dish，执行insert操作
        List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
        setmealDishes.stream().map((item)->{
            //setmealDto.getId()就是setmeal表中每次创建一个新的套餐分类自动生成的id
            //setSetmealId是SetmealDish套餐菜品关系中的setmealId属性，对应setmeal_dish表中的setmeal_id
            //新增套餐下的自选菜品的每个setmeal_id都会在setmeal表中的id中找到对应，大家想不通的去数据库看这两个表
            item.setSetmealId(setmealDto.getId());
            return item;
        }).collect(Collectors.toList());

        //保存套餐和菜品的关联信息，操作setmeal_dish,执行insert操作
        setmealDishService.saveBatch(setmealDishes);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

功能测试

可选菜品展示

保存功能
setmeal套餐表

setmeal_dish套餐菜品关联表

套餐信息分页查询功能

需求分析

代码开发

   /**
     * 套餐管理分页信息展示页面
     * @param page
     * @param pageSize
     * @return
     */
    @GetMapping("/page")
    // http://localhost:8080/setmeal/page?page=1&pageSize=10&name=123
    public Result<Page> pageShow(int page,int pageSize,String name){
        Page<Setmeal> mealPage = new Page<>(page,pageSize);
        Page<SetmealDto> dtoPage = new Page<>(); //为了展示 套餐分类 名称 categoryName

        LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
        //分页展示面，模糊查询
        queryWrapper.like(name != null,Setmeal::getName,name);
        //根据更新时间降序排列
        queryWrapper.orderByDesc(Setmeal::getUpdateTime);
        setmealService.page(mealPage,queryWrapper);

        /* 上面可以展示套餐基本信息，除套餐分类 展示列*/

        //将Setmeal中的属性复制到dtoPage,但是忽略records
        BeanUtils.copyProperties(mealPage,dtoPage,"records");

        List<Setmeal> records = mealPage.getRecords();

        List<SetmealDto> dtoList = records.stream().map((setmeal)->{
            SetmealDto setmealDto = new SetmealDto();

            BeanUtils.copyProperties(setmeal,setmealDto);
            //套餐分类id
            Long categoryId = setmeal.getCategoryId();
            //根据套餐分类id获得套餐分类对象
            Category category = categoryService.getById(categoryId);

            if(category != null){
                setmealDto.setCategoryName(category.getName());
            }

            return setmealDto;
        }).collect(Collectors.toList());

        dtoPage.setRecords(dtoList);
        return Result.success(dtoPage);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

功能测试

删除套餐

需求分析

代码开发

功能测试

短信发送功能

短信服务

阿里云短信服务

官网注册——>控制台——>云通信



了解即可，签名申请需要三证合一比较繁琐

模板详情

AccessKey 创建子用户安全系数高

创建用户

需求分析

数据模型

代码开发

阿里云短信服务官方文档

Java SDK使用手册

导入短信发送所需maven坐标

        <!--导入短信发送所需maven坐标-->
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>4.5.16</version>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-dysmsapi</artifactId>
            <version>2.1.0</version>
        </dependency>

1
2
3
4
5
6
7
8
9
10
11
12

User实体类创建

package com.yjq.reggie.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * 用户信息
 */
@Data
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;


    //姓名
    private String name;


    //手机号
    private String phone;


    //性别 0 女 1 男
    private String sex;


    //身份证号
    private String idNumber;


    //头像
    private String avatar;


    //状态 0:禁用，1:正常
    private Integer status;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

短信发送SMSUtils工具类

package com.yjq.reggie.utils;

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.profile.DefaultProfile;
import com.google.gson.Gson;
import com.sun.xml.internal.ws.resources.SenderMessages;

/**
 * 短信发送工具类
 */
public class SMSUtils {
    /**
     * 发送短信
     * @param signName      签名
     * @param templateCode  模板
     * @param phoneNumber   手机号
     * @param param         参数
     */
    public static void sendMessage(String signName,String templateCode,String phoneNumber,String param){
        //构建一个阿里云客户端, 用于发起请求。
        //构建阿里云客户端时需要设置AccessKey ID和AccessKey Secret。
        DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "<accessKeyId>", "<accessSecret>");
        IAcsClient client = new DefaultAcsClient(profile);

        //构建请求，设置请求参数。
        SendSmsRequest request = new SendSmsRequest();
        request.setSysRegionId("cn-hangzhou");
        request.setPhoneNumbers(phoneNumber);
        request.setSignName(signName);
        request.setTemplateCode(templateCode);
        request.setTemplateParam("{\"code\":\""+param+"\"}");
        
        try {
            SendSmsResponse response = client.getAcsResponse(request);
            System.out.println("短信发送成功");
        } catch (ClientException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

随机生成验证码工具类ValidateCodeUtils工具类

package com.yjq.reggie.utils;

import java.util.Random;

/**
 * 随机生成验证码工具类
 */
public class ValidateCodeUtils {
    /**
     * 随机生成验证码
     * @param length 长度为4位或者6位
     * @return
     */
    public static Integer generateValidateCode(int length){
        Integer code =null;
        if(length == 4){
            code = new Random().nextInt(9999);//生成随机数，最大为9999
            if(code < 1000){
                code = code + 1000;//保证随机数为4位数字
            }
        }else if(length == 6){
            code = new Random().nextInt(999999);//生成随机数，最大为999999
            if(code < 100000){
                code = code + 100000;//保证随机数为6位数字
            }
        }else{
            throw new RuntimeException("只能生成4位或6位数字验证码");
        }
        return code;
    }

    /**
     * 随机生成指定长度字符串验证码
     * @param length 长度
     * @return
     */
    public static String generateValidateCode4String(int length){
        Random rdm = new Random();
        String hash1 = Integer.toHexString(rdm.nextInt());
        String capstr = hash1.substring(0, length);
        return capstr;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

修改LoginCheckFilter过滤器