目录
d1
软件开发流程
具体流程
软件环境
项目介绍
本项目（苍穹外卖）是专门为餐饮企业（餐厅、饭店）定制的一款软件产品，包括 系统管理后台 和 小程序端应用 两部分。其中系统管理后台主要提供给餐饮企业内部员工使用，可以对餐厅的分类、菜品、套餐、订单、员工等进行管理维护，对餐厅的各类数据进行统计，同时也可进行来单语音播报功能。小程序端主要提供给消费者使用，可以在线浏览菜品、添加购物车、下单、支付、催单等。
1). 管理端功能
员工登录/退出 , 员工信息管理 , 分类管理 , 菜品管理 , 套餐管理 , 菜品口味管理 , 订单管理 ，数据统计，来单提醒。
2). 用户端功能
微信登录 , 收件人地址管理 , 用户历史订单查询 , 菜品规格查询 , 购物车功能 , 下单 , 支付、分类及菜品浏览。
产品原型
在提供的资料中有：用于展示项目的业务功能
管理端原型
用户端原型
技术选型
前端环境搭建
1. 从资料中找到前端运行环境的nginx，移动到非中文目录下。
2. 双击 nginx.exe 即可启动 nginx 服务，访问端口号为 80：http://localhost:80
后端环境搭建
后端工程基于 maven 进行项目构建，并且进行分模块开发。
1. 资料找到当天后端初始工程
2. idea打开当天工程
Git版本控制
1. 创建Git本地仓库
当Idea中出现：
说明本地仓库创建成功
2. 创建Git远程仓库
访问https://gitee.com/，新建仓库
点击创建
3. 将本地文件推送到Git远程仓库
a. 提交文件至本地仓库
忽略以下类型文件
开始提交
中间出现：点击commit
b. 添加Git远程仓库地址
复制远程地址： 
添加地址： 
c. 推送
成功推送至远程仓库
数据库环境搭建
1. 从资料中找到sky.sql
2. 执行sky.sql文件
nginx反向代理和负载均衡
不需要在项目中配置，前端已经配置好了）
nginx 反向代理的配置方式：
server{
listen 80;
server_name localhost;
location /api/{
proxy_pass http://localhost:8080/admin/; #反向代理
}
}proxy_pass：该指令是用来设置代理服务器的地址，可以是主机名称，IP地址加端口号等形式。
如上代码的含义是：监听80端口号， 然后当我们访问 http://localhost:80/api/../..这样的接口的时候，它会通过 location /api/ {} 这样的反向代理到 http://localhost:8080/admin/上来。
进到nginx-1.20.2\conf，打开nginx配置
# 反向代理,处理管理端发送的请求
location /api/ {
proxy_pass http://localhost:8080/admin/;
#proxy_pass http://webservers/admin/;
}当在访问http://localhost/api/employee/login，nginx接收到请求后转到http://localhost:8080/admin/，故最终的请求地址为http://localhost:8080/admin/employee/login，和后台服务的访问地址一致。
导入接口文档
使用YAPI
将课程资料中提供的项目接口导入YApi。访问地址：http://yapi.smart-xwork.cn/
Swagger
Swagger是什么
Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务(API Documentation & Design Tools for Teams | Swagger)。
主要作用
使得前后端分离开发更加方便，有利于团队协作
接口的文档在线自动生成，降低后端开发人员编写接口文档的负担
功能测试
Spring已经将Swagger纳入自身的标准，建立了Spring-swagger项目，现在叫Springfox。通过在项目中引入Springfox ，即可非常简单快捷的使用Swagger。
knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案,前身是swagger-bootstrap-ui,取名kni4j是希望它能像一把匕首一样小巧,轻量,并且功能强悍!
目前，一般都使用knife4j框架。
使用
1. pom.xml导入knife4j 的maven坐标
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
</dependency>
2. 在配置类中加入 knife4j 相关配置
WebMvcConfiguration.java
/**
* 通过knife4j生成接口文档
* @return
*/
@Bean
public Docket docket() {
ApiInfo apiInfo = new ApiInfoBuilder()
.title("苍穹外卖项目接口文档")
.version("2.0")
.description("苍穹外卖项目接口文档")
.build();
Docket docket = new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo)
.select()
.apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
.paths(PathSelectors.any())
.build();
return docket;
}
3. 设置静态资源映射，否则接口文档页面无法访问
WebMvcConfiguration.java
/**
* 设置静态资源映射
* @param registry
*/
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}
4. 访问测试
接口文档访问路径为 http://ip:port/doc.html ---> http://localhost:8080/doc.html
问题
通过 Swagger 就可以生成接口文档，那么我们就不需要 Yapi 了？
1、Yapi 是设计阶段使用的工具，管理和维护接口
2、Swagger 在开发阶段使用的框架，帮助后端开发人员做后端的接口测试
d2
本项目约定：
管理端发出的请求，统一使用/admin作为前缀。
用户端发出的请求，统一使用/user作为前缀。
用户登录
代码实现
1、controller层
/**
* 登录
*
* @param employeeLoginDTO
* @return
*/
@PostMapping("/login")
@ApiOperation("登录")
public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
log.info("员工登录：{}", employeeLoginDTO);
Employee employee = employeeService.login(employeeLoginDTO);
//登录成功后，生成jwt令牌
Map<String, Object> claims = new HashMap<>();
claims.put(JwtClaimsConstant.EMP_ID, employee.getId());
String token = JwtUtil.createJWT(
jwtProperties.getAdminSecretKey(),
jwtProperties.getAdminTtl(),
claims);
EmployeeLoginVO employeeLoginVO = EmployeeLoginVO.builder()
.id(employee.getId())
.userName(employee.getUsername())
.name(employee.getName())
.token(token)
.build();
return Result.success(employeeLoginVO);
}注意：
EmployeeLoginDTO //封装前端传来的用户名和密码@RequestBody //前端传来数据在方法体中时，需要加上这个注解String token = JwtUtil.createJWT( jwtProperties.getAdminSecretKey(), jwtProperties.getAdminTtl(), claims); //调用JWTUtil工具类去生成JWT令牌
2.service层
/**
* 员工登录
* @param employeeLoginDTO
* @return
*/
Employee login(EmployeeLoginDTO employeeLoginDTO);3.service实现层
/**
* 员工登录
*
* @param employeeLoginDTO
* @return
*/
public Employee login(EmployeeLoginDTO employeeLoginDTO) {
String username = employeeLoginDTO.getUsername();
String password = employeeLoginDTO.getPassword();
//1、根据用户名查询数据库中的数据
Employee employee = employeeMapper.getByUsername(username);
//2、处理各种异常情况（用户名不存在、密码不对、账号被锁定）
if (employee == null) {
//账号不存在
throw new AccountNotFoundException(MessageConstant.ACCOUNT_NOT_FOUND);
}
//密码比对
//后期需要进行md5加密，然后再进行比对
password = DigestUtils.md5DigestAsHex(password.getBytes());
if (!password.equals(employee.getPassword())) {
//密码错误
throw new PasswordErrorException(MessageConstant.PASSWORD_ERROR);
}
if (employee.getStatus() == StatusConstant.DISABLE) {
//账号被锁定
throw new AccountLockedException(MessageConstant.ACCOUNT_LOCKED);
}
//3、返回实体对象
return employee;
}4.mapper层
/**
* 根据用户名查询员工
* @param username
* @return
*/
@Select("select * from employee where username = #{username}")
Employee getByUsername(String username);MD5密码加密
问题：员工表中的密码是明文存储，安全性太低。
使用MD5加密方式对明文密码加密
在EmployeeServiceImpl.java 中
/**
* 员工登录
*
* @param employeeLoginDTO
* @return
*/
public Employee login(EmployeeLoginDTO employeeLoginDTO) {
//1、根据用户名查询数据库中的数据
//2、处理各种异常情况（用户名不存在、密码不对、账号被锁定）
//.......
//密码比对
// TODO 后期需要进行md5加密，然后再进行比对
password = DigestUtils.md5DigestAsHex(password.getBytes());
if (!password.equals(employee.getPassword())) {
//密码错误
throw new PasswordErrorException(MessageConstant.PASSWORD_ERROR);
}
//........
//3、返回实体对象
return employee;
}新增员工
需求分析与设计
1、查看产品原型
根据产品原型分析注意：
账号必须是唯一的
手机号为合法的11位手机号码
身份证号为合法的18位身份证号码
密码默认为123456
2、接口设计
根据接口文档明确
请求路径、请求方式、请求参数、返回数据。
请求路径：/admin/employee
请求方式：POST
请求参数：在Headers中的json格式：有id,idNumber,name,phone,sex,username(后端用DTO类来接收)
返回数据：统一的响应格式：Result类--code,data,msg
Result类代码：
com.sky.result包下定义了Result.java
package com.sky.result; import lombok.Data; import java.io.Serializable; /** * 后端统一返回结果 * @param <T> */ @Data public class Result<T> implements Serializable { private Integer code; //编码：1成功，0和其它数字为失败 private String msg; //错误信息 private T data; //数据 public static <T> Result<T> success() { Result<T> result = new Result<T>(); result.code = 1; return result; } public static <T> Result<T> success(T object) { Result<T> result = new Result<T>(); result.data = object; result.code = 1; return result; } public static <T> Result<T> error(String msg) { Result result = new Result(); result.msg = msg; result.code = 0; return result; } }
3、表设计
员工表
employee表结构：
| 字段名 | 数据类型 | 说明 | 备注 |
|---|---|---|---|
| id | bigint | 主键 | 自增 |
| name | varchar(32) | 姓名 | |
| username | varchar(32) | 用户名 | 唯一 |
| password | varchar(64) | 密码 | |
| phone | varchar(11) | 手机号 | |
| sex | varchar(2) | 性别 | |
| id_number | varchar(18) | 身份证号 | |
| status | Int | 账号状态 | 1正常 0锁定 |
| create_time | Datetime | 创建时间 | |
| update_time | datetime | 最后修改时间 | |
| create_user | bigint | 创建人id | |
| update_user | bigint | 最后修改人id |
代码开发
1. 设计DTO类接收前端传来的数据
DTO是数据传输对象（DTO）(Data Transfer Object)。
为什么要用DTO来接收，而不是相对应的实体类
传入参数和实体类有较大差别，所以自定义DTO类。
注意：当前端提交的数据和实体类中对应的属性差别比较大时，建议使用DTO来封装数据
com.sky.dto包下，已定义EmployeeDTO
DTO类
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class EmployeeDTO implements Serializable {
private Long id;
private String username;
private String name;
private String phone;
private String sex;
private String idNumber;
}2. controller层
com.sky.controller.admin包下，EmployeeController
/**
* 新增员工
* @param employeeDTO
* @return
*/
@PostMapping
@ApiOperation("新增员工")
public Result save(@RequestBody EmployeeDTO employeeDTO){
log.info("新增员工：{}",employeeDTO);
employeeService.save(employeeDTO);//该方法后续步骤会定义
return Result.success();
}注意：
@PostMapping //Spring框架中的一个注解，用于处理HTTP POST请求。
@ApiOperation("新增员工") //Swagger（knife4j ）的注解，标注是接口信息
3. sevice层
com.sky.server.EmployeeService
/**
* 新增员工
* @param employeeDTO
*/
void save(EmployeeDTO employeeDTO);4. sevice层实现类
com.sky.server.impl.EmployeeServiceImpl
/**
* 新增员工
*
* @param employeeDTO
*/
public void save(EmployeeDTO employeeDTO) {
Employee employee = new Employee();
//对象属性拷贝
BeanUtils.copyProperties(employeeDTO, employee);
//设置账号的状态，默认正常状态 1表示正常 0表示锁定
employee.setStatus(StatusConstant.ENABLE);
//设置密码，默认密码123456
employee.setPassword(DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes()));
//设置当前记录的创建时间和修改时间
employee.setCreateTime(LocalDateTime.now());
employee.setUpdateTime(LocalDateTime.now());
//设置当前记录创建人id和修改人id
employee.setCreateUser(10L);//目前写个假数据，后期修改
employee.setUpdateUser(10L);
employeeMapper.insert(employee);//后续步骤定义
}注意：
BeanUtils.copyProperties(employeeDTO, employee);
//将employeeDTO中与employee变量名相同的赋值；
StatusConstant.ENABLE
//状态常量：==1
DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes())
//PasswordConstant.DEFAULT_PASSWORD是常量123456；
//设置密码时，将密码进行md5加密
常量类
com.sky.constants包下已定义StatusConstant.java
package com.sky.constant;
/**
* 状态常量，启用或者禁用
*/
public class StatusConstant {
//启用
public static final Integer ENABLE = 1;
//禁用
public static final Integer DISABLE = 0;
}
5. mapper层
com.sky.EmployeeMapper
/**
* 插入员工数据
* @param employee
*/
@Insert("insert into employee (name, username, password, phone, sex, id_number, create_time, update_time, create_user, update_user,status) " +
"values " +
"(#{name},#{username},#{password},#{phone},#{sex},#{idNumber},#{createTime},#{updateTime},#{createUser},#{updateUser},#{status})")
void insert(Employee employee);在application.yml中已开启驼峰命名，故id_number和idNumber可对应。
mybatis:
configuration:
#开启驼峰命名
map-underscore-to-camel-case: true
代码完善（ThreadLocal ）
问题：
录入的用户名已存，抛出的异常后没有处理
新增员工时，创建人id和修改人id设置为固定值
问题一：录入的用户名已存，抛出的异常后没有处理
username已经添加了唯一约束，不能重复。
解决：
通过全局异常处理器来处理。
进入到sky-server模块，com.sky.hander包下，GlobalExceptionHandler.java添加方法
/**
* 处理SQL异常
* @param ex
* @return
*/
@ExceptionHandler
public Result exceptionHandler(SQLIntegrityConstraintViolationException ex){
//Duplicate entry 'zhangsan' for key 'employee.idx_username'
String message = ex.getMessage();
if(message.contains("Duplicate entry")){
String[] split = message.split(" ");
String username = split[2];
String msg = username + MessageConstant.ALREADY_EXISTS;
return Result.error(msg);
}else{
return Result.error(MessageConstant.UNKNOWN_ERROR);
}
}注意：
SQLIntegrityConstraintViolationException ex //SQL完整性约束违反异常
//Duplicate entry 'zhangsan' for key 'employee.idx_username'是异常的提示
message.contains("Duplicate entry") //如果提示包含前面两个单词，就会触发异常处理
进入到sky-common模块，在MessageConstant.java添加
public static final String ALREADY_EXISTS = "已存在";
问题二：新增员工时，创建人id和修改人id设置为固定值
//当前设置的id为固定值10//
employee.setCreateUser(10L);
employee.setUpdateUser(10L);
//
解决： 动态获取当前登录员工的id。
员工登录成功后会生成JWT令牌并响应给前端：
在sky-server模块
package com.sky.controller.admin;
/**
* 员工管理
*/
@RestController
@RequestMapping("/admin/employee")
@Slf4j
@Api(tags = "员工相关接口")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
@Autowired
private JwtProperties jwtProperties;
/**
* 登录
*
* @param employeeLoginDTO
* @return
*/
@PostMapping("/login")
@ApiOperation(value = "员工登录")
public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
//.........
//登录成功后，生成jwt令牌
Map<String, Object> claims = new HashMap<>();
claims.put(JwtClaimsConstant.EMP_ID, employee.getId());
String token = JwtUtil.createJWT(
jwtProperties.getAdminSecretKey(),
jwtProperties.getAdminTtl(),
claims);
//............
return Result.success(employeeLoginVO);
}
}后续请求中，前端会携带JWT令牌，通过JWT令牌可以解析出当前登录员工id：
JwtTokenAdminInterceptor.java
package com.sky.interceptor;
/**
* jwt令牌校验的拦截器
*/
@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {
@Autowired
private JwtProperties jwtProperties;
/**
* 校验jwt
*
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//..............
//1、从请求头中获取令牌
String token = request.getHeader(jwtProperties.getAdminTokenName());
//2、校验令牌
try {
log.info("jwt校验:{}", token);
Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
log.info("当前员工id：", empId);
//3、通过，放行
return true;
} catch (Exception ex) {
//4、不通过，响应401状态码
response.setStatus(401);
return false;
}
}
}注意：
Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
//这行代码的意思是使用
JwtUtil工具类中的parseJWT方法，结合从jwtProperties中获取的管理员秘钥，来解析给定的token。如果token是有效的（即它的签名与提供的秘钥匹配），那么parseJWT方法将返回一个Claims对象，该对象包含了JWT中的载荷数据。Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
//这行代码从JWT的
Claims对象中获取了员工ID（作为一个对象），将其转换为字符串，然后再将该字符串解析为Long类型，并将结果存储在empId变量中。这样，您就可以在后续的代码中使用empId变量来引用该员工的ID了。
解析出登录员工id后，如何传递给Service的save方法？
通过ThreadLocal进行传递。
ThreadLocal
ThreadLocal 并不是一个Thread，而是Thread的局部变量。 ThreadLocal为每个线程提供单独一份存储空间，具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问。
-
public void set(T value) 设置当前线程的线程局部变量的值
-
public T get() 返回当前线程所对应的线程局部变量的值
-
public void remove() 移除当前线程的线程局部变量
1. 封装了 ThreadLocal 操作的工具类
在sky-common模块
package com.sky.context;
public class BaseContext {
public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
public static void setCurrentId(Long id) {
threadLocal.set(id);
}
public static Long getCurrentId() {
return threadLocal.get();
}
public static void removeCurrentId() {
threadLocal.remove();
}
}2. 在拦截器中解析出当前登录员工id，并放入线程局部变量中：
在sky-server模块中，拦截器：
package com.sky.interceptor;
/**
* jwt令牌校验的拦截器
*/
@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {
@Autowired
private JwtProperties jwtProperties;
/**
* 校验jwt
*
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//.............................
//2、校验令牌
try {
//.................
Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
log.info("当前员工id：", empId);
/将用户id存储到ThreadLocal
BaseContext.setCurrentId(empId);
//3、通过，放行
return true;
} catch (Exception ex) {
//......................
}
}
}注意：
/将用户id存储到ThreadLocal
BaseContext.setCurrentId(empId);
3. 在Service中获取线程局部变量中的值：
/**
* 新增员工
*
* @param employeeDTO
*/
public void save(EmployeeDTO employeeDTO) {
//.............................
//设置当前记录创建人id和修改人id
employee.setCreateUser(BaseContext.getCurrentId());//目前写个假数据，后期修改
employee.setUpdateUser(BaseContext.getCurrentId());
employeeMapper.insert(employee);
}注意：
//设置当前记录创建人id和修改人id
employee.setCreateUser(BaseContext.getCurrentId());//目前写个假数据，后期修改
employee.setUpdateUser(BaseContext.getCurrentId());
员工分页查询
需求分析与设计
产品原型
注意：
根据页码展示员工信息
每页展示10条数据
分页查询时可以根据需要，输入员工姓名进行查询
接口设计
注意：
请求参数类型为Query，不是json格式提交，在路径后直接拼接。/admin/employee/page?name=zhangsan
返回数据中records数组中使用Employee实体类对属性进行封装。
请求路径：/admin/employee/page
请求方式：GET
请求参数：Query，不是json格式提交，在路径后直接拼
返回参数：total总数，records当前页的数据
代码开发
1、设计DTO类，封装前端传来的参数
在sky-pojo模块中
package com.sky.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class EmployeePageQueryDTO implements Serializable {
//员工姓名
private String name;
//页码
private int page;
//每页显示记录数
private int pageSize;
}2、封装PageResult，分页查询的结果统一封装为这个对象
在sky-common模块
package com.sky.result;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 封装分页查询结果
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageResult implements Serializable {
private long total; //总记录数
private List records; //当前页数据集合
}3、Controller层
com.sky.controller.admin.EmployeeController中添加分页查询方法。
/**
* 员工分页查询
* @param employeePageQueryDTO
* @return
*/
@GetMapping("/page")
@ApiOperation("员工分页查询")
public Result<PageResult> page(EmployeePageQueryDTO employeePageQueryDTO){
log.info("员工分页查询，参数为：{}", employeePageQueryDTO);
PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO);//后续定义
return Result.success(pageResult);
}4、sevice层
EmployeeService
/**
* 分页查询
* @param employeePageQueryDTO
* @return
*/
PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO);5、sevice实现层
EmployeeServiceImpl
/**
* 分页查询
*
* @param employeePageQueryDTO
* @return
*/
public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {
// select * from employee limit 0,10
//开始分页查询
PageHelper.startPage(employeePageQueryDTO.getPage(), employeePageQueryDTO.getPageSize());
Page<Employee> page = employeeMapper.pageQuery(employeePageQueryDTO);//后续定义
long total = page.getTotal();
List<Employee> records = page.getResult();
return new PageResult(total, records);
}注意：
此处采用了mybatis 的分页插件 PageHelper
所以需要在pom.xml中加入依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pagehelper}</version>
</dependency>
6、Mapper层
EmployeeMapper
/**
* 分页查询
* @param employeePageQueryDTO
* @return
*/
Page<Employee> pageQuery(EmployeePageQueryDTO employeePageQueryDTO);src/main/resources/mapper/EmployeeMapper.xml 中编写SQL：
<select id="pageQuery" resultType="com.sky.entity.Employee">
select * from employee
<where>
<if test="name != null and name != ''">
and name like concat('%',#{name},'%')
</if>
</where>
order by create_time desc
</select>问题
问题：
操作时间字段显示有问题。
解决方式：
在WebMvcConfiguration中扩展SpringMVC的消息转换器，统一对日期类型进行格式处理
/** * 扩展Spring MVC框架的消息转化器 * @param converters */ protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) { log.info("扩展消息转换器..."); //创建一个消息转换器对象 MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(); //需要为消息转换器设置一个对象转换器，对象转换器可以将Java对象序列化为json数据 converter.setObjectMapper(new JacksonObjectMapper()); //将自己的消息转化器加入容器中 converters.add(0,converter); }时间格式定义，sky-common模块中
package com.sky.json; public class JacksonObjectMapper extends ObjectMapper { //....... public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm"; //....... } }
启用禁用员工账号
需求分析与设计
产品原型
可以对状态为“启用” 的员工账号进行“禁用”操作
可以对状态为“禁用”的员工账号进行“启用”操作
状态为“禁用”的员工账号不能登录系统
接口设计
注意
1). 路径参数携带状态值。
2). 同时，把id传递过去，明确对哪个用户进行操作。
3). 返回数据code状态是必须，其它是非必须
代码开发
controller层
EmployeeController
/**
* 启用禁用员工账号
* @param status
* @param id
* @return
*/
@PostMapping("/status/{status}")
@ApiOperation("启用禁用员工账号")
public Result startOrStop(@PathVariable Integer status,Long id){
log.info("启用禁用员工账号：{},{}",status,id);
employeeService.startOrStop(status,id);//后绪步骤定义
return Result.success();
}service层
EmployeeService
/**
* 启用禁用员工账号
* @param status
* @param id
*/
void startOrStop(Integer status, Long id);service层实现类
EmployeeServiceImpl
/**
* 启用禁用员工账号
*
* @param status
* @param id
*/
public void startOrStop(Integer status, Long id) {
Employee employee = Employee.builder()
.status(status)
.id(id)
.build();
employeeMapper.update(employee);
}注意
mapper层
EmployeeMapper
/**
* 根据主键动态修改属性
* @param employee
*/
void update(Employee employee);在 EmployeeMapper.xml 中编写SQL：
<update id="update" parameterType="Employee">
update employee
<set>
<if test="name != null">name = #{name},</if>
<if test="username != null">username = #{username},</if>
<if test="password != null">password = #{password},</if>
<if test="phone != null">phone = #{phone},</if>
<if test="sex != null">sex = #{sex},</if>
<if test="idNumber != null">id_Number = #{idNumber},</if>
<if test="updateTime != null">update_Time = #{updateTime},</if>
<if test="updateUser != null">update_User = #{updateUser},</if>
<if test="status != null">status = #{status},</if>
</set>
where id = #{id}
</update>注意：
编辑员工
需求分析与设计
产品原型
接口设计
此处涉及两个接口：
根据id查询员工信息
编辑员工信息
接口1
接口2
代码开发
根据id查询员工信息
controller层
EmployeeController
/**
* 根据id查询员工信息
* @param id
* @return
*/
@GetMapping("/{id}")
@ApiOperation("根据id查询员工信息")
public Result<Employee> getById(@PathVariable Long id){
Employee employee = employeeService.getById(id);
return Result.success(employee);
}service层
EmployeeService
/**
* 根据id查询员工
* @param id
* @return
*/
Employee getById(Long id);EmployeeServiceImpl
/**
* 根据id查询员工
*
* @param id
* @return
*/
public Employee getById(Long id) {
Employee employee = employeeMapper.getById(id);
employee.setPassword("****");
return employee;
}mapper层
EmployeeMapper
/**
* 根据id查询员工信息
* @param id
* @return
*/
@Select("select * from employee where id = #{id}")
Employee getById(Long id);修改员工信息controller层
EmployeeController
/**
* 编辑员工信息
* @param employeeDTO
* @return
*/
@PutMapping
@ApiOperation("编辑员工信息")
public Result update(@RequestBody EmployeeDTO employeeDTO){
log.info("编辑员工信息：{}", employeeDTO);
employeeService.update(employeeDTO);
return Result.success();
}Service层
EmployeeService
/**
* 编辑员工信息
* @param employeeDTO
*/
void update(EmployeeDTO employeeDTO);EmployeeServiceImpl
/**
* 编辑员工信息
*
* @param employeeDTO
*/
public void update(EmployeeDTO employeeDTO) {
Employee employee = new Employee();
BeanUtils.copyProperties(employeeDTO, employee);
employee.setUpdateTime(LocalDateTime.now());
employee.setUpdateUser(BaseContext.getCurrentId());
employeeMapper.update(employee);
}注意
ThreadLocal
导入分类模块功能代码
需求分析与设计
接口设计
-
新增分类
-
分类分页查询
-
根据id删除分类
-
修改分类
-
启用禁用分类
-
根据类型查询分类
表设计
category表结构：
| 字段名 | 数据类型 | 说明 | 备注 |
|---|---|---|---|
| id | bigint | 主键 | 自增 |
| name | varchar(32) | 分类名称 | 唯一 |
| type | int | 分类类型 | 1菜品分类 2套餐分类 |
| sort | int | 排序字段 | 用于分类数据的排序 |
| status | int | 状态 | 1启用 0禁用 |
| create_time | datetime | 创建时间 | |
| update_time | datetime | 最后修改时间 | |
| create_user | bigint | 创建人id | |
| update_user | bigint | 最后修改人id |
代码导入
1120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
