JAVA项目实战《苍穹外卖》

前言

你好：

首先感谢你使用这份笔记手册，本学习笔记是我在自学过程（网课视频在下方链接）中的随手笔记，可能出现遗漏，顺序错误或语法，单词等错误，你可以在自己的学习过程中对这份笔记更正即可。

说明： 本笔记为本人学习过程中随手写的笔记，为复习使用，笔记中可能存在遗漏或错误，具体请以官方文档和权威书籍为准！谢谢！ 笔记中的一些图片等元素因路径配置问题，可能会发生丢失。 笔记中展示的知识点仅为部分内容，完整内容请查阅官方开发文档内容！

参考资料

【黑马程序员Java项目实战《苍穹外卖》，最适合新手的SpringBoot+SSM的企业级Java项目实战】 https://www.bilibili.com/video/BV1TP411v7v6/?p=3&share_source=copy_web&vd_source=ea0cf64e8dac6f0193a7e28187a0fccb

项目开发整体介绍

软件开发流程

需求分析（查看需求规格说明书，产品原型） ↓ 设计（UI设计，数据库设计，接口设计） ↓ 编码（项目代码，单元测试） ↓ 测试（测试用例，测试报告） ↓ 上线运维（软件环境安装，配置）

开发分工

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

软件环境

• 开发环境(development)：开发人员在开发阶段使用的环境，一般外部用户无法访问

• 测试环境（testing)：专门给测试人员使用的环境，用于测试项目，一般外部用户无法访问

• 生产环境(production)：即线上环境，正式提供对外服务的环境

苍穹外卖项目介绍

项目介绍

• 产品定位 专门为餐饮企业（餐厅、饭店）定制的一款软件产品

• 功能架构

  体现项目中的业务功能模块

产品原型

用于展示项目的业务功能，一般由产品经理进行设计

更多页面原型，需要下载课程资料。

技术选型

展示项目中使用到的技术框架和中间件等

开发环境搭建

前端环境搭建（管理端）

启动资料中提供的Nginx服务器

后端环境搭建

使用IDEA打开资料中提供的初始工程，并了解该项目的整体结构。

项目结构介绍

实体说明

使用Git版本控制

• 创建Git本地仓库 选择项目目录，出现GIT相关按钮

• 创建Git远程仓库 再Gitee或者Github上创建一个远程代码仓库。 将项目代码推送到远程仓库

• 将本地文件推送到Git远程仓库

数据库环境搭建

通过资料中的数据库脚本创建数据库表结构

恢复数据库信息

【补充】数据库设计文档

1. employee

employee表为员工表，用于存储商家内部的员工信息。具体表结构如下：

2. category

category表为分类表，用于存储商品的分类信息。具体表结构如下：

3. dish

dish表为菜品表，用于存储菜品的信息。具体表结构如下：

4. dish_flavor

dish_flavor表为菜品口味表，用于存储菜品的口味信息。具体表结构如下：

5. setmeal

setmeal表为套餐表，用于存储套餐的信息。具体表结构如下：

6. setmeal_dish

setmeal_dish表为套餐菜品关系表，用于存储套餐和菜品的关联关系。具体表结构如下：

7. user

user表为用户表，用于存储C端用户的信息。具体表结构如下：

8. address_book

address_book表为地址表，用于存储C端用户的收货地址信息。具体表结构如下：

9. shopping_cart

shopping_cart表为购物车表，用于存储C端用户的购物车信息。具体表结构如下：

10. orders

orders表为订单表，用于存储C端用户的订单数据。具体表结构如下：

11. order_detail

order_detail表为订单明细表，用于存储C端用户的订单明细数据。具体表结构如下：

前后端联调测试

设置好数据库连接信息，启动后端程序

启动前端程序，登录，测试，可以进入管理平台，成功

在本项目中，后端登录接口为/admin/employee/login

而前端请求的地址是：http://localhost/api/employee/login

实现以上功能，使用的是nginx反向代理，就是将前端发送的动态请求由nginx转发到后端服务器

使用反向代理的好处

• 可以进行缓存，提高访问速度

• 可以进行负载均衡，把大量请求分配给集群中的多台服务器

• 可以保证后端服务的安全性

nginx反向代理的配置

xxxxxxxxxx
# 反向代理,处理管理端发送的请求
        location /api/ {
            proxy_pass   http://localhost:8080/admin/;
            #proxy_pass   http://webservers/admin/;
        }

负载均衡配置

xxxxxxxxxx
upstream webservers{
      server 127.0.0.1:8080 weight=90 ;
      #server 127.0.0.1:8088 weight=10 ;
    }

更多详细的Nginx服务器配置相关操作，参考《Nginx教程》

登陆完善

当前登录问题：员工表中的密码是明文存储，安全性太低。

解决方案：将密码加密后存储，提高安全性

• MD5加密（本项目）---不可逆加密方式

• hash加密

• 对称加密

• 非对称加密

功能完善

小技巧：在注释中添加TODO 可以标记当前未完成的功能

xxxxxxxxxx
// TODO 后期需要进行md5加密，然后再进行比对

1. 修改数据库中的明文密码为加密后的密码

   xxxxxxxxxx
   123456
   MD5加密
   e10adc3949ba59abbe56e057f20f883e
   

    

2. 修改Java代码，对前端的密码进行加密

   xxxxxxxxxx
   //密码比对
           // TODO 后期需要进行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);
           }
   

    

导入接口文档

前后端分离开发的流程图

将资料中提供的接口数据导入到接口管理平台中。

【注】接口管理平台推荐

Swagger

介绍

Swagger 是一套用于设计、构建、文档化和测试 RESTful API 的开源工具集。

Swagger 提供了一种标准化的方式来描述 API 的结构、请求参数、响应格式等信息，使得前后端开发人员能够更高效地协作。

官网：API Documentation & Design Tools for Teams | Swagger

Knife4j

Knife4i是为JavaMVC框架集成Swagger生成Api文档的增强解决方案。

Knife4j的前身是swagger-bootstrap-ui,前身swagger-bootstrap-ui是一个纯swagger-ui的ui皮肤项目

一开始项目初衷是为了写一个增强版本的swagger的前端ui,但是随着项目的发展,面对越来越多的个性化需求,不得不编写后端Java代码以满足新的需求,在swagger-bootstrap-ui的1.8.5~1.9.6版本之间,采用的是后端Java代码和Ui都混合在一个Jar包里面的方式提供给开发者使用.这种方式虽说对于集成swagger来说很方便,只需要引入jar包即可,但是在微服务架构下显得有些臃肿。

因此,项目正式更名为knife4j,取名knife4j是希望她能像一把匕首一样小巧,轻量,并且功能强悍,更名也是希望把她做成一个为Swagger接口文档服务的通用性解决方案,不仅仅只是专注于前端Ui前端.

swagger-bootstrap-ui的所有特性都会集中在knife4j-spring-ui包中,并且后续也会满足开发者更多的个性化需求.

主要的变化是,项目的相关类包路径更换为com.github.xiaoymin.knife4j前缀,开发者使用增强注解时需要替换包路径

后端Java代码和ui包分离为多个模块的jar包,以面对在目前微服务架构下,更加方便的使用增强文档注解(使用SpringCloud微服务项目,只需要在网关层集成UI的jar包即可,因此分离前后端)

官网：Knife4j · 集Swagger2及OpenAPI3为一体的增强解决方案. | Knife4j

使用方式

1. 在pom中导入Knife4j的starter，Maven坐标

   xxxxxxxxxx
   <dependency>
       <groupId>com.github.xiaoymin</groupId>
       <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
       <version>4.4.0</version>
   </dependency>
   

2. 在配置类中加入knife4j相关配置

   xxxxxxxxxx
    /**
        * 通过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. 设置静态资源映射，否则接口文档页面无法访问

   xxxxxxxxxx
       /**
        * 设置静态资源映射
        * @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://localhost:8080/doc.html 可以看到生成的接口文档

常见注解

项目接口功能实现

本项目约定： 管理端发出的请求，统一使用/admin作为前缀 用户端发出的请求，统一使用/user作为前缀

员工管理模块

新增员工

产品原型 输入账号，员工姓名，手机号，性别，身份证号，完成员工账号的注册，默认密码123456

代码开发

根据新增员工接口设计对应的DTO

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

}

Controller 层业务代码示例

xxxxxxxxxx
@ApiOperation("新增员工")
@PostMapping()
public Result<String> register(@RequestBody EmployeeDTO employeeDTO) {
    employeeService.save(employeeDTO);
    return Result.success();
}

server层业务代码

xxxxxxxxxx
@Override
public void save(EmployeeDTO employeeDTO) {
    Employee employee = new Employee();
    BeanUtils.copyProperties(employeeDTO, employee);

    // 设置默认密码
    employee.setPassword(DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes()));

    // 设置默认状态
    employee.setStatus(StatusConstant.DISABLE);

    // 设置创建和修改时间
    employee.setCreateTime(LocalDateTime.now());
    employee.setUpdateTime(LocalDateTime.now());

    // 设置创建人ID和修改人ID
    // TODO 创建修改人ID后期动态获取
    employee.setCreateUser(10L);
    employee.setUpdateUser(10L);

    employeeMapper.insert(employee);
}

Mapper层

xxxxxxxxxx
@Insert("insert into employee (name, username, password, phone, sex, id_number, create_time, update_time, create_user, update_user) " +
        "values " +
        "(#{name},#{username},#{password},#{phone},#{sex},#{create_time},#{},#{update_time},#{create_user},#{update_user})")
void insert(Employee employee);

代码优化

问题1：当用户名已存在时，前端会出现500响应码

xxxxxxxxxx
// 在异常处理器中定义一个处理该错误的方法
@ExceptionHandler
public Result exceptionHandler(
    SQLIntegrityConstraintViolationException ex){
    return Result.error("账号已存在");

}

问题2：在创建人ID和修改人ID部分使用了固定值，应动态获取

后续请求中，前端会携带JWT令牌，通过WT令牌可以解析出当前登录员工id

【补充】ThreadLocal介绍 ThreadLocal并不是一个Thread，而是Thread的局部变量。 ThreadLocal为每个线程提供单独一份存储空间，具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问。

定义工具类

xxxxxxxxxx
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();
    }

}

在解析JWT令牌后存入ThreadLocal

在使用时通过Get方法获取值

员工分页查询

接口设计

Controller

xxxxxxxxxx
/**
     *
     * 员工列表分页查询
     */
@ApiOperation("员工分页查询")
@GetMapping("/page")
public Result<PageResult> GetEmployeePage(EmployeePageQueryDTO employeePageQueryDTO) {
    return employeeService.getEmployee(employeePageQueryDTO);

}

server

xxxxxxxxxx
@Override
public Result<PageResult> getEmployee(EmployeePageQueryDTO employeePageQueryDTO) {
    PageHelper.startPage(employeePageQueryDTO.getPage(),employeePageQueryDTO.getPageSize());
    Page<Employee> page = employeeMapper.getEmployee(employeePageQueryDTO.getName());
    PageResult pageResult = new PageResult();
    pageResult.setTotal(page.getTotal());
    pageResult.setRecords(page.getResult());
    return Result.success(pageResult);
}

Mapper

xxxxxxxxxx
Page<Employee> getEmployee(String name);

Mapper.XML

代码完善

在时间显示中，操作时间格式显示不正确，需要对时间进行格式化输出

解决方案：

1. 在属性上加上注解，对日期进行格式化

   xxxxxxxxxx
   @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
   private LocalDateTime updateTime;
   

    

2. 在WebMvcConfiguration中扩展Spring MVC的消息转换器统一对时间进行格式化处理。

   xxxxxxxxxx
   @Override
   protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
       // 自定义消息转换器，并将其加入到消息转换器队列
       MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
       converter.setObjectMapper(new JacksonObjectMapper());
       converters.add(0,converter);
   }
   

   前后端联调测试，成功

启用禁用员工账号

接口设计

Controller

xxxxxxxxxx
/**
     * 修改员工状态
     */
@ApiOperation("修改员工状态")
@PostMapping("status/{status}")
public Result<String> changeStatus(@PathVariable Integer status,Long id) {
    employeeService.stareOrStop(status,id);
    return Result.success();

}

Server

xxxxxxxxxx
@Override
public void stareOrStop(Integer status, Long id) {
    Employee buildEmp = Employee.builder().status(status).id(id).build();
    employeeMapper.ChangeEmp(buildEmp);
}

Mapper.xml

SQL设置成适配多种修改信息的。提高适用性

xxxxxxxxxx
<update id="ChangeEmp">
    update employee
    <set>
        <if test="name!=null and name!=''">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查询员工信息

• 编辑员工信息接口

代码实现示例

xxxxxxxxxx
/**
     * 根据ID查询员工信息
     */
@ApiOperation("根据ID查询员工信息")
@GetMapping("/{id}")
public Result GetEmployeeById(@PathVariable Long id) {
    Employee employee = employeeService.getEmployeeById(id);
    return Result.success(employee);
}

/**
     * 编辑员工信息
     */

@ApiOperation("编辑员工信息")
@PutMapping
public Result updateEmployee(@RequestBody  EmployeeDTO employeeDTO) {
    employeeService.updateEmp(employeeDTO);
    return Result.success();
}

xxxxxxxxxx
@Override
public Employee getEmployeeById(Long id) {
    Employee employee = employeeMapper.getEmployeeById(id);
    employee.setPassword("****");
    return  employee;
}

@Override
public void updateEmp(EmployeeDTO employeeDTO) {
    Employee employee = new Employee();
    BeanUtils.copyProperties(employeeDTO, employee);
    employee.setUpdateUser(BaseContext.getCurrentId());
    employee.setUpdateTime(LocalDateTime.now());
    employeeMapper.ChangeEmp(employee);
}

xxxxxxxxxx
void ChangeEmp(Employee buildEmp);

@Select("SELECT * FROM employee where id=#{id}")
Employee getEmployeeById(Long id);

xxxxxxxxxx
<update id="ChangeEmp">
    update employee
    <set>
        <if test="name!=null and name!=''">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>

菜品分类与上方代码类似

菜品分类与上方代码类似

菜品分类与上方代码类似

【补充】公共字段自动填充

问题分析

在业务表中，有许多公共字段。例如：

代码冗余。不便于后期维护

解决方案

• 自定义注解AutoFill，用于标识需要进行公共字段自动填充的方法

  xxxxxxxxxx
  package com.sky.anotation;
  
  import com.sky.enumeration.OperationType;
  
  import java.lang.annotation.ElementType;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.lang.annotation.Target;
  
  /**
   * 自定义注解，用于标识某些需要特殊处理的方法
   */
  @Target(ElementType.METHOD)
  @Retention(RetentionPolicy.RUNTIME)
  public @interface AutoFill {
      // 导入需要操作的类型（常量）
      OperationType value();
  
  }
  

   

• 自定义切面类AutoFillAspect，统一拦截加入了AutoFill注解的方法，通过反射为公共字段赋值

  xxxxxxxxxx
  package com.sky.aspect;
  
  import com.sky.anotation.AutoFill;
  import com.sky.constant.AutoFillConstant;
  import com.sky.context.BaseContext;
  import com.sky.enumeration.OperationType;
  import lombok.extern.slf4j.Slf4j;
  import org.aspectj.lang.JoinPoint;
  import org.aspectj.lang.Signature;
  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.Before;
  import org.aspectj.lang.annotation.Pointcut;
  import org.aspectj.lang.reflect.MethodSignature;
  
  import org.springframework.stereotype.Component;
  
  import java.lang.reflect.Method;
  import java.time.LocalDateTime;
  
  
  /**
   * 自定义切面类，实现公共字段自动填充
   */
  
  @Aspect
  @Component
  @Slf4j
  public class AutoFillAspect {
      // 定义切入点
      @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.anotation.AutoFill)")
      public void AutoFillPointCut() {
      }
  
      /**
       * 定义通知
       * 前置通知（√）
       * 后置通知
       * 。。。
       */
      @Before("AutoFillPointCut()")
      public void beforeAutoFill(JoinPoint joinPoint) {
          log.info("切入");
          // 获取到当前的操作类型
          MethodSignature signature = (MethodSignature) joinPoint.getSignature();
          AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);
          OperationType operationType = autoFill.value();
          // 获取当前被拦截的方法的参数（实体对象）
          Object[] args = joinPoint.getArgs();
          if (args==null || args.length==0) {
              return;
          }
          Object object = args[0];
  
          // 准备赋值的数据
          LocalDateTime now = LocalDateTime.now();
          Long id = BaseContext.getCurrentId();
  
          // 根据操作类型将数据赋值给实体
          if (operationType==OperationType.INSERT) {
              // 插入操作。需要为四个字段赋值
              try {
                  Method setCreateTime = object.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                  Method setCreateUser = object.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                  Method setUpdateTime = object.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                  Method setUpdateUser = object.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
  
                  setCreateTime.invoke(object, now);
                  setCreateUser.invoke(object, id);
                  setUpdateTime.invoke(object, now);
                  setUpdateUser.invoke(object, id);
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
          }
          else if (operationType==OperationType.UPDATE) {
              // 更新操作。需要对两个字段赋值
              try {
                  Method setUpdateTime = object.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                  Method setUpdateUser = object.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
  
                  setUpdateTime.invoke(object, now);
                  setUpdateUser.invoke(object, id);
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
          }
  
  
      }
  
  }
  
  

   

• 在Mapper的方法上加入AutoFill注解

  xxxxxxxxxx
  @Mapper
  public interface CategoryMapper {
      Page<Category> getAllCategory(CategoryPageQueryDTO queryDTO);
  
      @AutoFill(OperationType.UPDATE)
      void updateCategory(Category category);
  
      @Insert("insert into category (TYPE, NAME, SORT, STATUS, CREATE_TIME, UPDATE_TIME, CREATE_USER, UPDATE_USER) VALUES " +
              "(#{type},#{name},#{sort},#{status},#{createTime},#{updateTime},#{createUser},#{updateUser})")
      @AutoFill(value = OperationType.INSERT)
      void addCategory(Category category);
  
      @Select("select * from category where type=#{type}")
      Category getCategoryByType(String type);
  }
  

   

技术点：枚举、注解、AOP、反射

菜品管理模块

新增菜品

接口设计与描述

业务规则：

• 菜品名称必须是唯一的

• 菜品必须属于某个分类下，不能单独存在

• 新增菜品时可以根据情况选择菜品的口味

• 每个菜品必须对应一张图片

需要的接口

• 根据类型查询分类（已完成）

• 文件上传

• 新增菜品

示例代码展示

controller

xxxxxxxxxx
/**
     * 新增菜品的接口
     * @param dish
     * @return
     */
@ApiOperation("新增菜品接口")
@PostMapping
public Result addDish(@RequestBody DishDTO dish) {
    dishService.addDish(dish);
    return Result.success();

}

Service

xxxxxxxxxx
@Override
public void addDish(DishDTO dish) {
    Dish dish1 = new Dish();
    BeanUtils.copyProperties(dish, dish1);

    // 新增菜品信息
    // 将菜品信息插入数据表，再获得该菜品的ID
    Long id =dishMapper.addDish(dish1);

    // 将菜品ID赋给口味
    List<DishFlavor> flavors = dish.getFlavors();
    for (DishFlavor f : flavors) {
        f.setDishId(id);
    }
    // 插入菜品的口味信息
    dishFlavorMapper.addFlavor(flavors);

}

Mapper

xxxxxxxxxx
@Mapper
public interface DishMapper {
    @Select("SELECT COUNT(id) from dish where category_id=#{id} ")
    int deleteByCategoryID(Long id);


    @AutoFill(value = OperationType.INSERT)
    Long addDish(Dish dish);
}

XML (DishMapper)

xxxxxxxxxx
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.DishMapper">

    <insert id="addDish" useGeneratedKeys="true" keyProperty="id">
        insert into dish (name, category_id, price, image, description, status, create_time, update_time, create_user, update_user) VALUES
        (#{name},#{categoryId},#{price},#{image},#{description},#{status},#{createTime},#{updateTime},#{createUser},#{updateUser})

    </insert>
</mapper>

(DishFlavorMapper)

xxxxxxxxxx
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.DishFlavorMapper">


    <insert id="addFlavor">
        INSERT INTO dish_flavor (dish_id, name, value) VALUES
        <foreach collection="flavors" item="item" separator=",">
            (#{item.dishId}, #{item.name}, #{item.value})
        </foreach>
    </insert>
</mapper>

菜品分页查询

接口设计

代码示例

在返回值字段中，有一个新的字段categoryName没有合适的实体类进行封装，需要设计一个新的VO

xxxxxxxxxx
package com.sky.vo;

import com.sky.entity.DishFlavor;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DishVO implements Serializable {

    private Long id;
    //菜品名称
    private String name;
    //菜品分类id
    private Long categoryId;
    //菜品价格
    private BigDecimal price;
    //图片
    private String image;
    //描述信息
    private String description;
    //0 停售 1 起售
    private Integer status;
    //更新时间
    private LocalDateTime updateTime;
    //分类名称
    private String categoryName;
    //菜品关联的口味
    private List<DishFlavor> flavors = new ArrayList<>();

    //private Integer copies;
}

sql映射文件xml

xxxxxxxxxx
    <select id="getDishList" resultType="com.sky.vo.DishVO">
        SELECT d.*,c.name AS category_name  <!-- 建议明确指定别名，避免字段名冲突 -->
        FROM dish d left join category c on d.category_id = c.id
        <where>

            <if test="name != null">
                AND d.name LIKE CONCAT('%', #{name}, '%')  <!-- 注意：字段名前加表别名 -->
            </if>
            <if test="categoryId != null">
                AND d.category_id = #{categoryId}  <!-- 去掉逗号 -->
            </if>
            <if test="status != null">
                AND d.status = #{status}  <!-- 去掉逗号 -->
            </if>
        </where>
    </select>

修改菜品信息

接口设计：

• 根据id查询菜品 主要业务代码（service层)

  xxxxxxxxxx
  @Override
  public DishVO QueryDishById(Long id) {
      // 查询菜品信息
      DishVO dish  = dishMapper.queryDishById(id);
      // 根据菜品ID查询口味信息
      List<DishFlavor> flavors =  dishFlavorMapper.queryByDishId(dish.getId());
      dish.setFlavors(flavors);
      return dish;
  }
  

• 根据类型查询分类（已实现）

• 文件上传 (已实现)

• 修改菜品

菜品信息删除

业务需求分析

• 一次可以删除一个菜品，也可以批量删除菜品

• 当前起售中的菜品不能被删除

• 已被套餐关联的菜品不能被删除

• 删除菜品后，关联的口味数据也需要删除

业务代码实现示例

controller

xxxxxxxxxx
/**
     * 这是菜品删除接口
     * @param ids
     * @return
     */
@ApiOperation("菜品删除")
@DeleteMapping
public Result deleteDish(@RequestParam List<Long> ids) {
    dishService.delDishBatch(ids);
    return Result.success();
}

Service

xxxxxxxxxx
/**
     * 删除菜品信息的逻辑
     * @param ids
     */
@Override
public void delDishBatch(List<Long> ids) {

    // 先检查菜品是否被起售，当前起售中的菜品不能被删除
    for (Long id : ids) {

        int status = dishMapper.findStatus(id);
        if (status == StatusConstant.ENABLE) {
            throw new DeletionNotAllowedException("菜品已上架，无法删除");

        }
    }

    // 检查菜品是否被套餐关联，已被套餐关联的菜品不能被删除
    List<Long> count = setmealDishMapper.findSetmealDish(ids);
    if (count!=null && count.size() > 0) {
        throw  new DeletionNotAllowedException("有菜品已与套餐绑定，无法删除");
    }
    // 删除菜品数据
    dishMapper.deleteDishById(ids);
    // 删除菜品后，关联的口味数据也需要删除
    dishFlavorMapper.deleteFlavorByDishId(ids);



}

Mapper.XML

xxxxxxxxxx
<delete id="deleteDishById">
    delete from dish where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

Redis

Redis介绍

Redis - 官网

Redis中文网

什么是Redis？

Redis 是一个强大的内存数据结构存储，用作数据库、缓存和消息代理。

Redis 与Mysql的区别

• 前者是将数据存储在内存中，后者将数据存储在磁盘中

• 前者使用key-value存储，后者通过二维表进行存储

Redis 的优势

• 基于内存存储，读写速度高

• 适合存储热点数据居（例如：热点商品、资讯、新闻）

• 数据类型丰富。

• 支持丰富的个性化内容。Redis 支持通知、消息发布/订阅、键过期等特性。

下载与安装

Releases · tporadowski/redis

redis为绿色版，直接解压后就可以使用

Another Redis Desktop Manager | Redis桌面(GUI)管理客户端，兼容Windows、Mac、Linux

Redis数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

• 字符串 string：普通字符串，Redis中最简单的数据类型

• 哈希 hash：也叫散列，类似于Java中的HashMap结构

• 列表list：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList

• 集合 set：无序集合，没有重复元素，类似于Java中的HashSet

• 有序集合sorted set/zset：集合中每个元素关联一个分数 （score），根据分数升序排序，没有重复元素

Redis常用指令

字符串操作命令

哈希操作命令

Redishash是一个string类型的field和value的映射表，hash特别适合用于存储对象，常用命令：

列表操作命令

集合操作命令

Redis set是string类型的无序集合。集合成员是唯一的，集合中不能出现重复的数据，常用命令：

有序集合操作命令

Redis有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数。常用命令：

通用命令

Redis通用命令是不分数据类型的，都可以使用的命令：

Java中操作Redis

• Redis的Java客户端

  • Spring Data Redis

    SpringDataRedis是Spring的一部分，对Redis底层开发包进行了高度封装。 在Spring项目中，可以使用SpringData Redis来简化操作。

  • Jedis

  • Lettuce

Spring Data Redis使用方式

• 导入Spring Data Redis 的 Maven坐标

  xxxxxxxxxx
  <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <version>3.5.3</version>
  </dependency>
  

   

• 配置Redis数据源

  xxxxxxxxxx
  spring:  
    redis:
      host: localhost
      port: 6379
      password: 123456
  

   

• 编写配置类，创建RedisTemplate对象

  xxxxxxxxxx
  package com.sky.config;
  
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.serializer.StringRedisSerializer;
  
  @Configuration
  
  public class RedisConfiguration {
      @Bean
      public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
          RedisTemplate redisTemplate = new RedisTemplate();
          // 设置redis连接工厂对象
          redisTemplate.setConnectionFactory(redisConnectionFactory);
          // 设置redis key 序列化对象
          redisTemplate.setKeySerializer(new StringRedisSerializer());
          return redisTemplate;
      }
  }
  

   

• 通过RedisTemplate对象操作Redis

  xxxxxxxxxx
  @Test
  public void testString() {
      // 操作String类型的数据
      ValueOperations valueOperations = redisTemplate.opsForValue();
      valueOperations.set("city", "Beijing");
      System.out.println(valueOperations.get("city"));
      valueOperations.set("name", "xiaoming", 3, TimeUnit.MINUTES);
      valueOperations.setIfAbsent("age", "17");
      valueOperations.setIfAbsent("age", "18");
  }
  
  @Test
  public void test2Hash() {
      //        操作Hash类型的数据
      HashOperations hashOperations = redisTemplate.opsForHash();
      hashOperations.put("people","name","xiaoming" );
      hashOperations.put("people","age","18" );
      hashOperations.put("people","gender","man" );
  
      // 获取字段
      hashOperations.get("people","name");
  
      // 获取全部keys
      hashOperations.keys("people");
  
      // 获取全部value
      hashOperations.values("people");
  
      // 删除字段
      hashOperations.delete("people","gender");
  }
  

  其他数据类型，操作方式与以上类似

店铺营业状态设置

接口设计：

• 设置营业状态

• 管理端查询营业状态

• 用户端查询营业状态

营业状态数据存储方式：基基于Redis的字符串来进行存储

xxxxxxxxxx
@RestController("adminShopController")
@RequestMapping("/admin/shop")
public class ShopController {
    @Autowired
    // 导入配置类
    private RedisTemplate redisTemplate;

    /**
     * 查询营业状态
     * @return
     */
    @GetMapping("/status")
    public Result getStatus() {
        Integer status = (Integer) redisTemplate.opsForValue().get("SHOP_STATUS");
        return Result.success(status);
    }

    /**
     * 设置店铺营业状态
     * @param status
     * @return
     */
    @PutMapping("/{status}")
    public Result updateStatus(@PathVariable("status") Integer status) {
        redisTemplate.opsForValue().set("SHOP_STATUS", status);
        return Result.success();
    }
}

HttpClient

介绍

HttpClient是Apache JakartaCommon下的子项目，可以用来提供高效的、最新的、功能丰富的支持HTTP 协议 的客户端编程工具包，并且它支持HTTP 协议最新的版本和建议。

引入Maven坐标

xxxxxxxxxx
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

核心API:

• HttpCient

• HttpClients

• CloseableHttpClient

• HttpGet

• HttpPost

发送请求步骤：

1. 创建HttpClient对象

2. 创建Http请求对象

3. 调用HttpClient的execute方法发送请求

使用示例

发送Get请求

xxxxxxxxxx
@Test
public void testHttpCilent () throws Exception {

    // 创建HttpCilent对象
    CloseableHttpClient HttpCilent1 = HttpClients.createDefault();
    // 创建请求对象
    HttpGet httpGet = new HttpGet("http://www.baidu.com");
    // 发送请求，接收结果
    CloseableHttpResponse httpResponse =HttpCilent1.execute(httpGet);

    // 获取请求的响应状态码
    System.out.println(httpResponse.getStatusLine().getStatusCode());

    // 获取并输出内容
    HttpEntity entity = httpResponse.getEntity();
    System.out.println(EntityUtils.toString(entity));

    // 关闭资源
    httpResponse.close();
    HttpCilent1.close();

}

发送POST请求

xxxxxxxxxx
public static String doPost(String url, Map<String, String> paramMap) throws IOException {
    // 创建Httpclient对象
    CloseableHttpClient httpClient = HttpClients.createDefault();
    CloseableHttpResponse response = null;
    String resultString = "";

    try {
        // 创建Http Post请求
        HttpPost httpPost = new HttpPost(url);

        // 创建参数列表
        if (paramMap != null) {
            List<NameValuePair> paramList = new ArrayList();
            for (Map.Entry<String, String> param : paramMap.entrySet()) {
                paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
            }
            // 模拟表单
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
            httpPost.setEntity(entity);
        }

        httpPost.setConfig(builderRequestConfig());

        // 执行http请求
        response = httpClient.execute(httpPost);

        resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
    } catch (Exception e) {
        throw e;
    } finally {
        try {
            response.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return resultString;
}

微信小程序开发

介绍

小程序是一种新的开放能力，开发者可以快速地开发一个小程序。小程序可以在微信内被便捷地获取和传播，同时具有出色的使用体验。

微信公众平台-小程序

微信开放文档 / 开发

小程序开发准备工作

• 注册小程序 小程序

• 完善小程序信息

• 下载开发者工具 下载

小程序目录结构

小程序包含一个描述整体程序的app和多个描述各自页面的page。 一个小程序主体部分由三个文件组成，必须放在项目的根目录，如下：

一个小程序页面由四个文件组成：

编写小程序代码

编译小程序

微信登录

• 导入小程序代码 从课程资料中导入小程序代码

• 微信登录流程

• 需求分析和接口设计

• 代码开发

  • 在配置文件中配置小程序ID和密钥信息

    xxxxxxxxxx
    sky:
      jwt:
    
        # 用户令牌配置
        user-secret-key: itheima
        user-ttl: 7200000
        user-token-name: authentication
    
      wechat:
        appid: ${sky.wechat.appid}
        secret: ${sky.wechat.secret}
    

  • 开发业务代码 Controller

    xxxxxxxxxx
    @RestController
    @RequestMapping("/user/user")
    @Api(tags = "C端用户接口")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private JwtProperties jwtProperties;
        /**
         * 微信登录接口
         * @param userLoginDTO
         * @return
         */
        @PostMapping("/login")
        @ApiOperation("微信登陆接口")
        public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO) {
            User user = userService.WXuserLogin(userLoginDTO.getCode());
    
            //生成JSW令牌
            Map usermap = new HashMap();
            usermap.put(JwtClaimsConstant.USER_ID,user.getId());
            String jwt = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), usermap);
    
            // 构造UserVo并返回
            UserLoginVO userLoginVO = new UserLoginVO();
            userLoginVO.setId(user.getId());
            userLoginVO.setOpenid(user.getOpenid());
            userLoginVO.setToken(jwt);
            return Result.success(userLoginVO);
        }
    }
    

    Service

    xxxxxxxxxx
    @Service
    public class UserServiceImpi implements UserService  {
    
        public static final String wxUrl = "https://api.weixin.qq.com/sns/jscode2session";
    
        @Autowired
        private WeChatProperties properties;
    
        @Autowired
        private UserMapper userMapper;
        /**
         * 微信登录逻辑
         * @param code
         */
        public User WXuserLogin(String code) {
            // 调用微信接口，获取用户的oppenID
            Map data = new HashMap();
            data.put("appid", properties.getAppid());
            data.put("secret", properties.getSecret());
            data.put("js_code", code);
            data.put("grant_type", "authorization_code");
            String json = HttpClientUtil.doGet(wxUrl, data);
            JSONObject jsonObject = JSON.parseObject(json);
    
            // 判断openid是否成功
            String openid = jsonObject.getString("openid");
            if (openid==null){
                throw new LoginFailedException("登录失败");
            }
    
            // 检查用户是否是本系统的新用户
            User user =  userMapper.getUserByID(openid);
            // 是新用户，为其注册，反之不注册
            if (user==null){
                 user = User.builder()
                        .openid(openid)
                        .createTime(LocalDateTime.now())
                        .build();
                 userMapper.insertUser(user);
            }
    
    
            // 返回用户对象
            return user;
    
        }
    }
    

    Mapper

    xxxxxxxxxx
    @Mapper
    public interface UserMapper {
    
        @Select("select * from  user where openid = #{openid}")
        User getUserByID(String openid);
    
        void insertUser(User user);
    }
    

     

导入商品浏览功能代码

接口功能

• 查询分类

• 根据分类id查询菜品

• 根据分类id查询套餐

• 根据套餐id查询包含的菜品

数据缓存

缓存菜品

问题 用户端在访问量非常大时，会频繁的操作数据库数据，会造成数据库压力急剧增大，系统响应会变慢，非常影响用户的使用体验

实现方法

通过Redis来缓存菜品数据，减少数据库查询操作。

示例代码

xxxxxxxxxx
@GetMapping("/list")
@ApiOperation("根据分类id查询菜品")
public Result<List<DishVO>> list(Long categoryId) {
    String Dishkey = "dish_"+categoryId;
    // 先查询缓存中是否存在菜品缓存
    List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(Dishkey);
    // 存在，直接返回
    if (list != null) {
        System.out.println("缓存命中");
        return Result.success(list);
    }
    // 不存在从数据库中查询
    System.out.println("未缓存命中");
    Dish dish = new Dish();
    dish.setCategoryId(categoryId);
    dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品

    list = dishService.listWithFlavor(dish);
    redisTemplate.opsForValue().set(Dishkey, list);

    return Result.success(list);
}