个人主页

温湿度可视化展示

Sun, 12 Jan 2025 00:00:00 +0000

本项目实现了一个从esp32-dht22模块读取温湿度数据发送到flask, 通过echarts显示在页面的效果
仓库地址:
https://github.com/BBBlllack/ESP32_DHT22_TH
https://github.com/BBBlllack/flask_dht22_th

Flask后端部分

本项目后端使用flask + echarts, 其中flask的/recv路由用于接收esp发来的温湿度数据。

/index 可视化页面
/recv?temp=&humid= 分别为温度和湿度
其中cache为列表, 由于本次flask需要部署在pad上, 考虑到性能有限，故未使用数据库, 使用了class序列为json存到文件中, 引入列表作为cache, 每3个或者更多一存
每天的数据存储格式为yyyy-MM-dd.txt

@app.get("/recv")
def recv():
 data_file_name = getDataFileName()
 t = int(time.time())
 temp = float(request.args.get('temp', None))
 humid = float(request.args.get('humid', None))
 data = Data(t, temp, humid)
 cache.append(str(data.__dict__))
 if len(cache) >= 3:
 with open(data_file_name, "a") as f:
 f.write("\n".join(cache) + "\n")
 cache.clear()
 print(data.__dict__)
 if temp and humid:
 return "ok"
 return "err"

ESP32, DHT22硬件部分

本项目使用了DHT22作为数据传感器, 使用的开发平台为platfromio, 使用的依赖为

[env:adafruit_metro_esp32s3]
platform = espressif32
board = adafruit_metro_esp32s3
framework = arduino
board_build.flash_mode = dio
monitor_speed = 115200
lib_deps = adafruit/DHT sensor library@^1.4.6

数据发送函数, 我的server本地地址为192.168.1.150, flask开在5000端口

void sendReq(vector<float> data){
 String api = "http://192.168.1.150:5000/recv?temp=";
 api.concat(String(data[0]));
 api.concat("&humid=");
 api.concat(String(data[1]));
 http.begin(String(api));
 int http_code = http.GET();
 if (http_code == HTTP_CODE_OK)
 {
 api.concat(", ");
 api.concat(http.getString());
 Serial0.println(api);
 }
}

项目效果为

为了测效果我把取暖关闭了, 冻死我了昨晚呜呜呜

SpringBoot笔记文档

Sat, 21 Dec 2024 00:00:00 +0000

1. 配置文件

配置文件的三种格式(加载优先级如下顺序：

application.properties
application.yml
Application.yaml

1.1属性的注入

首先在yml文件中配置属性

user:
 name1: lisi
 age: 18

之后在对应的类中利用value注解进行属性读取

@Controller
@RequestMapping("/dr")
public class DataReadController {

 @Value("${user.name1}")
 private String name1;

 @Value("${user.age}")
 private String age1;

 @GetMapping("/na")
 @ResponseBody
 public String getna(){
 System.out.println("name1 = " + name1);
 System.out.println("age1 = " + age1);
 return name1 + "," + age1;
 }
}

1.2配置文件yml中属性的引用

baseDir: c:/windows
# 利用${}语法格式进引用
tempDir: ${baseDir}/tmp

转义字符也可以生效，但是需要利用引号引起来

1.3一次性读取全部数据

一次性读取配置文件中的全部属性，读取到一个Environment对象中，可以利用getProperty方法进行获取

@Autowired
private Environment env;

@GetMapping("/env")
@ResponseBody
public String getenv(){
 System.out.println(env);
 System.out.println(env.getProperty("user.name1"));
 return "";
}

1.4读取属性到对象中

定义数据模型封装属性
将数据模型交给spring管理，作为一个bean
利用configurationProperties注解进行配置

datasource:
 driver: com.mysql.jdbc.Driver
 url: jdbc:mysql://localhost/springboot_db
 username: root
 password: 12345678

省略了getter和setter方法和tostring方法

@Component
@ConfigurationProperties(prefix = "datasource") // 一定要小写！
public class MyDataSource {
 private String driver;
 private String url;
 private String username;
 private String password;
}

@Autowired
private MyDataSource myDataSource;

@GetMapping("/db")
@ResponseBody
public String getdv(){
 System.out.println(myDataSource);
 return "";
}

2. 整合第三方技术

前言：springboot整合第三方技术都遵循两个步骤：

导入对应的starter
根据提供的配置格式，配置非默认的配置项

2.1整合Junit

无需做很多操作，仅仅需要注意一些事情

注入要测试的对象
执行对应的方法

注意：

测试类一定要在引导类所在包及其子包下
如果不在可以在测试类注解SpringBootTest(classes = xxx.class)指定启动类

@SpringBootTest(classes = ShjApplication.class)
class ShjApplicationTests {

 @Autowired
 private DataReadController dataReadController;

 @Test
 void contextLoads() {
 dataReadController.getna();
 }

}

2.2整合Mybatis

2.2.1整合方法

需要注意的点有：

mybatis版本不要太高，可以用2.2.0的版本
mysql-connector-j手动添加版本号

pom.xml

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>2.2.0</version>
 </dependency>

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

 <dependency>
 <groupId>com.mysql</groupId>
 <artifactId>mysql-connector-j</artifactId>
 <scope>runtime</scope>
<!-- 手动添加版本号-->
 <version>8.0.33</version>
 </dependency>

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 <dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter-test</artifactId>
 <version>2.2.0</version>
 <scope>test</scope>
 </dependency>
 </dependencies>

application.yml配置如下

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot
 username: root
 password: 12345678

测试案例如下

userDao.java

@Mapper
public interface UserDao {
 @Select("select * from users")
 public User[] getUsers();
}

Junit测试方法

@Test
void userDaoTest(){
 System.out.println(Arrays.toString(userDao.getUsers()));
}

2.2.2动态sql

动态sql可以根据一些条件，动态的进行sql拼接

<if> <!-- 此标签用来判断是否拼接标签内的sql语句，如下当属性atr1不为null时才拼接 -->
 <if test = "art1 != null">
 <!-- sql -->
 </if>

<where> <!-- 此标签用来判断，当where后无条件时，会自动去除多余的where关键词，且做多条件动态查询时，会自动去除多余的and关键字 -->
 <where>
 <if test = "art1 != null">
 <!-- condition sql -->
 </if>
 <if test = "art2 != null">
 and <!-- condition sql -->
 </if>
 </where>

<foreach> <!-- 此标签用来遍历传递的参数，例如集合 -->

<set> <!-- 此标签作用类似于where，set用做更新，同样的可以去除多余的set关键词，且做多字段更新时，会自动去除多余的and关键字 -->
 <set>
 <if test = "art1 != null">
 <!-- update sql -->
 </if>
 <if test = "art2 != null">
 and <!-- update sql -->
 </if>
 </set>

<sql id="id1"> <!-- 此标签用来抽取公共部分的sql，id为此sql的唯一标识 -->
<include refid="id1"> <!-- 此标签用来引入公共部分的sql，refid属性指定引入的sql唯一标识 -->

2.3整合MybatisPlus

整合mybatis-plus时，由于spring未收录mp的坐标，故我们需要手动导入，整体步骤如下：

创建springboot项目时，勾选mysql驱动
在application.yml文件中配置datasource
导入mybatis-plus坐标
dao曾继承一个BaseMapper<T>接口，传入要操作的实体类

mybatis-plus 3.4.3版本坐标如下所示：

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

application.yml配置如下：

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot
 username: root
 password: 12345678

dao层书写如下：

@Mapper
public interface BookDao extends BaseMapper<Book> {
}

controller层书写如下：

@Slf4j
@RestController
@RequestMapping("/books")
public class BookController {
 R r = new R();
 @Autowired
 private BookDao bookDao;

 @GetMapping
 private R getAllBooks(){
 List<Book> books = bookDao.selectList(null);
 r.setData(books);
 log.info("mp is running...");
 return r;
 }
}

2.4整合Druid

同样的，springboot未收录druid的坐标，需要去 www.nvmrepository.com 找到druid的坐标，整体步骤如下

导入druid的坐标
在application.yml中配置

druid 1.2.6版本的坐标如下：

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

application.yml配置如下：

spring:
 datasource:
 druid:
 driver-class-name: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot
 username: root
 password: 12345678

3. 异常的统一处理

在springboot中，需要统一在表现层处理异常，可以进行如下操作

定义异常处理类，使用注解配置
在类中写方法，处理对应的异常

// 异常处理类
@RestControllerAdvice
public class ErrorHandler {
// 下面的注解参数中可以指定为处理的对应的异常
 @ExceptionHandler(Exception.class)
// ex对象表示异常对象
 public Result exceptionHandler(Exception ex){
 ex.printStackTrace();
 return new Result(false, null, "error");
 }
}

异常抛出代码

@GetMapping("{id}")
// 当传来的id为0时，会抛出异常
public Result errorTest(@PathVariable Integer id){
 int a = 1 / id;
 return new Result();
}

4. 运维实用指令

4.1打包指令

对springboot工程进行打包

mvn package

利用指令运行项目

java -jar springboot.jar

注意，jar指令的运行一定要依赖于maven中打包插件

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

若无打包插件，运行项目报错如下：

无主清单属性

4.2临时属性

例如临时修改端口为指定的，可以采取本策略，利用–进行临时属性配置，各种临时属性之间利用空格分割

java -jar springboot.jar --server.port = 8080

java -jar springboot.jar --server.port = 8080 --spring.datasource.druid.password = 123

4.3配置文件优先级

与jar同级目录下config/application.yml 最高
与jar同级目录下application.yml
类路径下config/application.yml
类路径下application.yml 最低

4.4多环境开发yml

我们可以在yml中配置很多种环境，在运行环境中指定我们需要使用什么环境进行运行，环境之间利用 — 分隔开

# 公共配置 运行环境
spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot
 username: root
 password: 12345678
 profiles:
 active: dev # 在此选择要使用的环境

---
# 生产环境
spring:
 config:
 activate:
 on-profile: pro # 环境起名
server:
 port: 8000
---
# 开发环境
spring:
 config:
 activate:
 on-profile: dev # 环境起名
server:
 port: 8001
---
# 测试环境
spring:
 config:
 activate:
 on-profile: test # 环境起名
server:
 port: 8002

4.5多环境分组管理

原课程：https://www.bilibili.com/video/BV15b4y1a7yG?p=64&spm_id_from=pageDriver&vd_source=cba09bff3fb893a92d86de5c69b49831

P64

在实际开发中，可能会将不同的配置拆成不同的文件，例如同级目录下有如下四个配置文件：

application.yml
application-dev.yml
application-devDB.yml
application-devMVC.yml

则需要在application.yml文件中需要做如下配置：

spring:
 profiles:
 active: dev
 group:
 "dev": devDB,devMVC # 若属性冲突，后加载的生效
 "pro": proDB,proMVC

4.6日志相关操作

4.6.1日志级别的开启

控制台默认答应的为info级别的日志，要令控制台答应debug级别的应开启debug级别的日志

在application.yml中进行如下配置

# debug: true # 不推荐使用
# 推荐使用如下
logging:
 level:
 root: debug # 日志级别，根路径下为debug（所有的包）

4.6.2日志记录的使用

步骤如下：

新建一个日志记录对象，传进去记录类名的字节码文件
利用logger的方法进行日志记录 debug info warn error

代码如下：

@RestController
@RequestMapping("/logs")
public class logController {

 Result result = new Result();

 // 创建日志记录对象，传入参 数为 为当前类服务的日志记录对象
 private static final Logger LOGGER = LoggerFactory.getLogger(logController.class);

 @GetMapping
 public Result getById(){
// LOGGER.trace("trace..."); // 等级过低，一般不用
 LOGGER.debug("debug...");
 LOGGER.info("info...");
 LOGGER.warn("warn...");
 LOGGER.error("error...");
 return result;
 }
}

如果不手动创建日志记录对象，可以采用lombok提供的@slf4j注解进行开发，代码如下：

@Controller
@ResponseBody
@RequestMapping("/user")
@Slf4j // 此注解提供了log对象进行日志的记录
public class UserController {
 @GetMapping("/users")
 public String getUsers(){
 log.warn("slf4j...");
 System.out.println(Arrays.toString(userDao.getUsers()));
 return "";
 }
}

lombok坐标如下：

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

4.6.3分组设置日志级别

将不同的包归属为不同的组，对组进行日志级别控制，yml配置如下：

logging:
 group:
 # 对包进行分组
 group1: com.package.controller1, com.package.controller2, ...
 group2: com.package.controller3, com.package.controller4, ...
 level:
 # 设置对应分组的日志级别
 group1: warn
 group2: debug

4.6.4日志输出格式控制

首先，日志的格式如下：

![image-20230705011907150](/Users/shj/Library/Application Support/typora-user-images/image-20230705011907150.png)

可以设置日志输出格式如下：

logging:
 pattern:
 console: "%d - %m %n"
# %d 日期 %m 消息 %n 换行 
# %p 级别 %clr(){颜色名} 括号内的属性有颜色 %t 线程名
# %c 类名

4.6.5文件记录日志

我们有时需要将日志文件输出到一个文件中，可以在application.yml中做如下配置：

logging:
 file:
 name: server.log # 此文件在工程同级目录下生成

分文件日志记录，当日志过大时，可以分文件记录，当一个日志达到设置的最大值时，系统自动新建文件继续记录日志

logging:
 file:
 name: server.log # 此文件在工程同级目录下生成
 logback:
 rollingpolicy:
 max-file-size: 4KB # 单个日志文件的最大大小
 file-name-pattern: server.%d.%i.log

5. 开发常用操作

5.1第三方Bean属性注入

除了自定义的一些对象，有些第三方Bean的属性也需要读取yml文件中的值，例如Druid，我们可以进行如下操作

5.2配置文件计量单位

由于yml中无单位，配置文件时常常需要用到单位，例如时间，由此需要配置单位

在配置文件中配置数量
在配置类中利用注解配置单位

servers:
 ipAddress: 192.168.0.1
 port: 2222
 serverTimeOut: 300
 fileSize: 10

下面的示例中，分别利用@DurationUnit注解和@DataSizeUnit注解进行单位配置

@Data
@Component
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
 private String ipAddress;
 private String port;

 @DurationUnit(ChronoUnit.HOURS)
 private Duration serverTimeOut;

 @DataSizeUnit(DataUnit.MEGABYTES)
 private DataSize fileSize;
}

5.3测试环境中启动web环境

5.3.1测试类做成web测试类

// 参数 webEnvironment 的取值为定义的端口
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class WebTest {
 @Test
 void test1(){

 }
}

5.3.2模拟请求发送

分如下几步：

使用注解 @AutoConfigureMockMvc 启动模拟web调用
使用@Autowired MockMvc mockMvc 注入调用对象
构造请求发送对象
发送请求

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
// 启动模拟web请求调用
@AutoConfigureMockMvc
public class WebTest {
 @Test
 // 注入虚拟调用mvc对象
 void test1(@Autowired MockMvc mockMvc) throws Exception {
 // 创建虚拟请求
 // 除了get，还有post，put，delete等
 MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/test/t3");
 mockMvc.perform(builder);
 }
}

5.4随机数据的构造

在实际开发中，常常需要构造一些随机输入存入到数据库，可以在yml中做如下配置

test:
 book:
 bookName: ${random.uuid} # 随机uuid
 b1: ${random.int} # 随机整数
 b2: ${random.int(10)} # 随机正整数，最大为0

javaBean定义如下：

@Data
@Component
@ConfigurationProperties(prefix = "test.book")
public class BookTest {
 private String bookName;
 private Integer b1;
 private Integer b2;
}

之后利用 @Autowired 注解自动装配时就有了随机数据

5.5静态资源的映射处理

在springboot开发中，由于默认的mvc会将请求路径当作controller去寻找，会导致有些静态资源例如页面html，图片image，js，css等访问不到，此时需要进行静态资源的处理，需要新建一个类继承WebMvcConfigurationSupport，使用Configuration注解配置，详细代码如下:

@Slf4j
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
 @Override
 protected void addResourceHandlers(ResourceHandlerRegistry registry) {
 log.info("静态资源映射处理...");
 // 当访问到front目录下所有资源时，去类加载路径下的front寻找
 registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");
 registry.addResourceHandler("/templates/**").addResourceLocations("classpath:/templates/");
 registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
 }
}

5.6拦截器的使用

在springboot中使用拦截器需要做如下处理，创建类继承WebMvcConfigurer，重写addInterceptors方法，利用registry添加拦截器，具体代码如下:

@Slf4j
@Configuration
@EnableWebMvc //此注解必须要有
public class ResponseConfig implements WebMvcConfigurer {

 @Autowired
 public Inter1 inter1;

 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 log.info("拦截器配置...");
 registry.addInterceptor(inter1).addPathPatterns("/front/**");

 }
}

当然，还需要定义拦截器，方法为，定义一个类实现HandlerInterceptor接口，具体代码如下:

@Slf4j
@Component
public class Inter1 implements HandlerInterceptor {
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 log.info("inter1...");
 return true;
 }
}

5.7Springboot中过滤器的使用

在springboot中使用filter首先需要在启动类中加上 @ServletComponentScan 注解，这样才能加载servlet的组建，之后需要定义一个类实现servlet中的Filter接口，具体代码如下:

启动类中

@SpringBootApplication
@ServletComponentScan //此注解打开了servlet组建，例如filter
public class MPspringBootApplication {
 public static void main(String[] args) {
 SpringApplication.run(MPspringBootApplication.class, args);
 }
}

过滤器的定义

此时拦截通配符为/*，和拦截器有些不同

@Slf4j
@WebFilter(filterName = "filter1", urlPatterns = {"/front/*"})
public class filter1 implements Filter {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
 log.info("请求的路径:" + httpServletRequest.getRequestURI());
 filterChain.doFilter(servletRequest, servletResponse);
 }

 @Override
 public void init(FilterConfig filterConfig) throws ServletException {
 log.info("filter1...");
 }

 @Override
 public void destroy() {
 }
}

6. 非关系型数据库

6.1 Redis

有如下几步：

创建工程时勾选redis坐标

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

在application.yml文件中配置redis

spring:
 redis:
 port: 6379
 host: localhost
# client-type: jedis # 默认为 lettuce

测试功能

@SpringBootTest
class NosqlApplicationTests {

 @Autowired // 以对象的形式操作，利用 keys* 在redis-cli中可以查看到
 private RedisTemplate redisTemplate;

 @Autowired // 以字符串的形式操作
 private StringRedisTemplate stringRedisTemplate;

 @Test
 void setTest(){
 ValueOperations ops = redisTemplate.opsForValue();
 ops.set("age",18);
 System.out.println(ops.get("age"));
 }

 @Test
 void getTest(){
 ValueOperations ops = redisTemplate.opsForValue();
 System.out.println(ops.get("aa"));
 }

 @Test
 void setTestStr(){
 ValueOperations<String, String> strops = stringRedisTemplate.opsForValue();
 strops.set("name","zhangsan");
 System.out.println(strops.get("name"));
 }
}

6.2 MongoDB

mongoDB是一种介于关系型和非关系型数据库之间的数据库，springboot使用它步骤如下：

创建工程时导入坐标

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

在application.yml中配置mongoDB

spring:
 data:
 mongodb: # 无需配置 host 和 port
 uri: mongodb://localhost/springboot

测试mongoDB

@SpringBootTest
public class mongoDBTest {

 @Autowired
 private MongoTemplate mongoTemplate;

 @Test
 void saveTest(){
 User user = new User();
 user.setUsername("zhangsan");
 user.setPassword("zhang123");

 mongoTemplate.save(user);
 }

 @Test
 void findTest(){
 List<User> all = mongoTemplate.findAll(User.class);
 System.out.println(all);
 }
}

6.3 ES

7. Spring中的缓存

spring中内置了缓存技术，使用它有如下步骤：

添加缓存坐标

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

开启缓存功能，利用注释 @EnableCaching 在启动类中添加

@SpringBootApplication
@EnableCaching // 此注释开启了缓存
public class NosqlApplication {

 public static void main(String[] args) {
 SpringApplication.run(NosqlApplication.class, args);
 }

}

在需要缓存的方法上添加注释

@RestController
@RequestMapping("/users")
public class UserController {
 @GetMapping
 // value 用来指定缓存的位置，key用来指定查询的键（保证唯一性）
 @Cacheable(value = "cacheSpace", key = "#id")
 public String getUserById(Integer id){
 return "";
 }
}

8. SpringBoot中的定时任务

8.1 Quartz

quartz是springboot支持的一款定时器，使用它有如下几步：

导入quartz的坐标

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

制作定时任务

制作定时任务中，需要创建一个定时任务类，实现 QuartzJobBean , 覆盖executeInternal方法即可

public class TimerTaskApp extends QuartzJobBean {
 @Override // 在此书写要执行的方法
 protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
 System.out.println("quartz run...");
 }
}

创建配置类

需要单独创建一个配置类，并且使用configuration注解，在此需要定义工作明细对象和触发器，并且绑定对应关系

@Configuration
public class QuartzConfig {

 @Bean
 public JobDetail jobDetail(){
 return JobBuilder
 .newJob(TimerTaskApp.class) // 在newjob中需要放入，工作的对象
 .storeDurably()
 .build();
 }

 @Bean
 public Trigger trigger(){
 // 定时时间为 每隔三秒执行一次
 CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule("0/3 * * * * ?");
 return TriggerBuilder
 .newTrigger().
 forJob(jobDetail()) // 在此绑定工作细节对象
 .withSchedule(cronSchedule) // 在此设置定时时间
 .build();
 }

}

8.2 Task

此功能是为了简化quartz开发，使用它有如下步骤：

在引导类中开启定时执行任务的开关 @EnableScheduling

@SpringBootApplication
@EnableCaching // 此注释打开了缓存开关
@EnableScheduling // 此注释打开了定时器开关
public class NosqlApplication {
 public static void main(String[] args) {
 SpringApplication.run(NosqlApplication.class, args);
 }
}

在想要定时执行的任务中指定定时时间 @Scheduled

@Component // 要定义为Bean
public class TaskApp {
 // 在想要定时执行的方法上添加注释，并且指定cron表达式
 @Scheduled(cron = "0/3 * * * * ?")
 public void task(){
 System.out.println("task...");
 }
}

在yml中对定时器有如下配置

spring:
 task:
 scheduling:
 pool:
 # 任务调度线程池的大小
 size: 1
 shutdown:
 # 线程池关闭时等待所有任务执行完毕
 await-termination: false
 # 调度线程关闭前最大等待时间，确保最后一定会关闭
 await-termination-period: 10s

9. 整合javaMail

9.1发送简单邮件

使用javaMail可以实现使用java发送邮件，使用它有如下几步：

导入javaMail坐标

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

在application.yml中进行配置

spring:
 mail:
 host: smtp.qq.com
 username: 1327325289
 password: ktpfhaqbaubdhjgh # 授权码

使用接口进行发送邮件

@Controller
@Slf4j
@RequestMapping("/mail")
public class MailController {
 @Autowired // springboot 已经提供，直接注入即可
 private JavaMailSender javaMailSender;
 // 发送人 接受人 标题 正文
 @GetMapping("/send")
 @ResponseBody
 public String sendMail(){
 // 构造简单邮件
 SimpleMailMessage message = new SimpleMailMessage();
 String from = "1327325289@qq.com";
 String to = "2976551621@qq.com";
 String subject = "测试标题";
 String context = "测试正文";
 message.setFrom(from + "(传说)"); // from后面加上(content)，发送人会变成content
 message.setTo(to);
 message.setSubject(subject);
 message.setText(context);
 javaMailSender.send(message);
 return "";
 }
}

9.2发送多部件邮件

实际中，有些邮件带有图片等其他信息，此时邮件便不再是简单邮件，需要使用多部件邮件发送，需要做如下设置：

@Controller
@Slf4j
@RequestMapping("/mail")
public class MailController {
 @Autowired // springboot 已经提供，直接注入即可
 private JavaMailSender javaMailSender;
 @GetMapping("sendm")
 @ResponseBody
 public String sendMiMeMail(){
 try { // set中会报错，需要异常处理
 MimeMessage message = javaMailSender.createMimeMessage();
 // 第二个参数为true表示允许附件发送
 MimeMessageHelper helper = new MimeMessageHelper(message,true);
 String from = "1327325289@qq.com";
 String to = "2976551621@qq.com";
 String subject = "测试标题";
 String context = "<a href='https://www.baidu.com'>测试正文跳转百度</a>";
 helper.setFrom(from + "(传说)");
 helper.setTo(to);
 // 第二个参数为true表示正文部分支持html语法
 helper.setSubject(subject);
 helper.setText(context,true);

 File file = new File("/Users/shj/IdeaProjects/SpringBoot/springboot1/mail/HELP.md");
 helper.addAttachment(file.getName(),file);// 添加附件

 javaMailSender.send(message);
 } catch (MessagingException e) {
 e.printStackTrace();
 }
 return "";
 }
}

10. 消息处理

10.1 ActiveMQ

activeMQ是一款消息队列的实现软件，使用它需要进入安装目录运行 ./activemq start，默认用户名密码都为admin，之后有如下几步：

导入activeMQ的坐标

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

在application.yml中对它进行配置

spring:
 activemq:
 broker-url: tcp://localhost:61616 # 指定网址和端口
 jms:
 template:
 default-destination: deafultArea # 指定默认对列存储区域，可以不指定

编写api进行使用（分两种方式，手动使用和监听自动使用）

@Slf4j
@Service
public class MessageServiceActivemqImpl implements MessageService {

 @Autowired
 // 默认spring注入的对象，直接使用
 private JmsMessagingTemplate messagingTemplate;

 @Override
 public void sendMessage(String id) {
 System.out.println("已纳入处理队列,id:" + id);
 // 转换和发送，第一个参数为存储对列区域名
 messagingTemplate.convertAndSend("order.queen.id",id);
 }

 @Override
 public String doMessage() {
 // 接受和转换，第一个参数为从哪个队列中取出，第二个参数为，转换后的对象类型
 String id = messagingTemplate.receiveAndConvert("order.queen.id",String.class);
 log.info("已完成处理,id:" + id);
 return id;
 }
}

以上为手动使用

@Slf4j
@Component
public class ActivemqListener {
 // 设置监听器，destination参数为监听的对列名，只要发现对列中有数据自动取出使用
 @JmsListener(destination = "order.queen.id")
 // 处理完之后发送给哪个队列，会将方法返回值发送给此对列
 @SendTo("order.queen.newid")
 public String receive(String id){
 log.info("已完成处理,id:" + id);
 return "new" + id;
 }
 // 处理上一个方法发来的消息
 @JmsListener(destination = "order.queen.newid")
 public void receiveNewId(String id){
 log.info("已完成处理:" + id);
 }
}

10.2 RabbitMQ

11. Spring事务管理

11.1 基本概念和操作

spring中有事务管理，所谓事务，类似于操作系统中的原语，必须同时执行成功或者失败，一旦出现异常，必须进行事务的回滚，在spring中，可以通过注释 @Transactional 进行事务管理

作用于特定方法上，此方法会被当成事务管理
作用于类上，类中所有的方法都会当成事务管理
作用于接口上，该接口所有实现类的方法会被当成事务管理

下面列举注释作用于方法上

public class UserService{
 @Transactional // 此时save方法中的语句同时成功或者失败，抛出异常会进行事务会滚。
 public void save(String username, String password){
 // 代码1
 int i = 1/0; // 抛出异常
 // 代码2
 }
}

11.2 rollbackFor

默认的 @Transactional 注释，只会在抛出运行时异常，即RunTimeException，才会进行事务的回滚，但Exception异常不会进行事务会滚，此时需要用到 rollbackFor 参数。

public class UserService{
 @Transactional(rollbackFor = Exception.class) // 指定出现Exception异常时，进行事务会滚
 public void save(String username, String password){
 // 代码1
 if (true){
 throw new Exception("error info...");
 }
 // 代码2
 }
}

11.3 propagation

此注释用来控制事务的传播行为，它的取值有如下几种：

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务
SUPPORTS	支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY	必须有事务，否则抛异常
NEVER	必须无事务，否则抛异常

例如，现在有一个需求，对于一个删除用户功能，无论操作成功失败与否，都要进行日志记录，此时，如果删除失败抛出异常时，用以前的事务管理，会将日志记录功能一并会滚，无法在日志记录数据表中看到对应的操作，此时需要用到事务传播行为控制。示例代码如下

public class UserService{
 @Transactional
 public void delete(String username){
 // 根据username删除用户
 // 其他代码
 log(username);
 }
 // 此时必须指定 progagation = Propagation.REQUIRES_NEW 在log方法中开启一个新的事务，否则log方法鬼delete事务管控，当delete方法出现异常时，会将log方法一并会滚
 @Transactional(progagation = Propagation.REQUIRES_NEW)
 public void log(String username){
 // 记录操作日志
 newLog(username);
 }
}

12. MybatisPlus使用

首先根据 2.3 节的内容在springboot下整合mybatisplus，之后就可以正常使用了

12.1 分页的使用

在mybatisplus中，如果要对数据进行分页查询，需要创建一个Ipage分页对象，并为之创建分页拦截器，才可以进行使用，代码如下：

java代码

@Test
void MpPageSelect(){
 IPage page = new Page(1,2);
 bookDao.selectPage(page, new Wrapper<Book>() {
 @Override
 public Book getEntity() {
 return null;
 }

 @Override
 public MergeSegments getExpression() {
 return null;
 }

 @Override
 public void clear() {

 }

 @Override
 public String getSqlSegment() {
 return null;
 }
 });
 System.out.println("数据:" + page.getRecords());
 System.out.println("当前页:" + page.getCurrent());
 System.out.println("显示的数据条数:" + page.getSize());
 System.out.println("总页数:" + page.getPages());
 System.out.println("总数据条数:" + page.getTotal());
}

输出结果

数据:[Book(bid=1, bookname=math, description=math is too hard), Book(bid=2, bookname=english, description=english is easy)]
当前页:1
显示的数据条数:2
总页数:2
总数据条数:3

拦截器的创建

@Configuration
public class MpConfig {
 @Bean
 public MybatisPlusInterceptor mybatisPlusInterceptor(){
 // 创建大拦截器
 MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
 // 在大拦截器中添加分页拦截器
 mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
 return mybatisPlusInterceptor;
 }
}

12.2 条件查询

条件查询，mp提供了条件查询类，需要构造，查询方式可以有三种，接下来依次展示：

@Test
void testConditionQuery1(){
 // 方式一: 条件查询
 QueryWrapper wrapper = new QueryWrapper();
 wrapper.lt("price",35);
 List list = bookDao.selectList(wrapper);
 System.out.println(list);
}

此方法使用了QueryWrapper对象进行查询，lt为小于条件，可以查阅文档看更多的条件

@Test
void testConditionQuery2(){
 // 方式二: 条件查询 lambda
 QueryWrapper<Book> wrapper = new QueryWrapper();
 wrapper.lambda().lt(Book::getPrice, 35);
 List<Book> books = bookDao.selectList(wrapper);
 System.out.println(books);
}

此时查询的时候使用了.lambda()方法，可以在后面使用语法糖，减少出错

@Test
void testConditionQuery3(){
 // 方式三: 条件查询 lambda (接口更方便)
 LambdaQueryWrapper<Book> wrapper = new LambdaQueryWrapper<>();
 wrapper.lt(Book::getPrice, 35);
 List<Book> books = bookDao.selectList(wrapper);
 System.out.println(books);
}

此时更换了查询接口使用LambdaQueryWrapper，就可以不使用.lambda()方法

接下来为多条件查询

 @Test
// 多条件查询
void testMultConditionsQuery(){
 LambdaQueryWrapper<Book> wrapper = new LambdaQueryWrapper<>();
 // 条件之间为and关系
// wrapper.lt(Book::getPrice, 35).gt(Book::getPrice, 10);
 // 条件之间为or关系
 wrapper.lt(Book::getPrice, 10).or().gt(Book::getPrice, 30);
 List<Book> books = bookDao.selectList(wrapper);
 System.out.println(books);
}

支持链式编程

12.2.1 条件查询空值处理

在查询中，如果条件出现空值，一般会导致查询失败，mp提供了如下方法：

 @Test
void testNullConditionQuery(){
 Book book = new Book();
 book.setPrice(20);
 LambdaQueryWrapper<Book> wrapper = new LambdaQueryWrapper<>();
 // 当book的price字段不为null时，此条件才进行拼接
 wrapper.lt(book.getPrice() != null,Book::getPrice, 10).
 or().gt(Book::getPrice, 30);
 List<Book> books = bookDao.selectList(wrapper);
 System.out.println(books);
}

12.3 查询投影

13. WebSocket的基本使用

websocket协议实现了服务端和客户端的双向通信, 可以实现在线聊天室，在线客服等需要双向通信的场景, websocket分客户端和服务端, 在此服务端使用springboot集成的websocket, 客户端使用原生js实现服务端和客户端的双向通信

13.1 服务端

首先有一个配置类，采用第三方Bean注入即可

@Configuration
public class WebSocketConfig {
 @Bean
 public ServerEndpointExporter serverEndpointExporter(){
 return new ServerEndpointExporter();
 }
}

服务端代码框架如下：

package com.file.ws;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
@ServerEndpoint(value = "/chat/{username}")
public class MyWebSocket {

 // 日志记录对象
 private static final Logger log = LoggerFactory.getLogger(MyWebSocket.class);

 //用来存储每一个session对象
 private static final Map<String, Session> sessionMap = new ConcurrentHashMap<>();

 @OnOpen // 连接建立调用的方法
 public void opOpen(Session session, @PathParam("username") String username){
 sessionMap.put(username, session);
 log.info("{} 加入了聊天室...", username);
 }

 @OnMessage // 收到客户端消息调用的方法 
 public void opMessage(String message, Session session, @PathParam("username") String username){
 log.info("{} 发送了消息 {}", username, message);
 }

 @OnClose // 关闭连接调用的方法
 public void onClose(Session session, @PathParam("username") String username){
 log.info("{} 关闭了链接...", username);
 }

 // 采用定时任务实现定时向客户端发送消息, 测试使用
 @Scheduled(cron = "0/3 * * * * ?")
 private void sendMsgToAllUser() throws IOException {
 for (String username : sessionMap.keySet()) {
 Session session = sessionMap.get(username);
 session.getBasicRemote().sendText("这是服务端测试消息");
 }
 }
}

13.2 客户端

采用了vue + elementUI进行基本的框架搭建

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>聊天室</title>
 <link rel="stylesheet" href="../css/el.css">
</head>
<body>
 <div id="app">
 <div class="title">
 <h2>
 {{ title }}
 </h2>
 </div>
 <div class="chatBody">
 <div style="width: 500px">
 <el-input v-model="smsg"></el-input>
 <el-button @click="send">发送</el-button>
 </div>
 </div>
 </div>
</body>
</html>
<style>
 .title{
 text-align: center;
 color: #3a8ee6;
 }
 .chatBody{
 text-align: center;
 }
</style>
<script src="../js/vue.js"></script>
<script src="../js/el.js"></script>
<script src="../js/axios-0.18.0.js"></script>
<script lang="javascript">
 var socket;
 new Vue({
 el:"#app",
 data(){
 return {
 title: "在线聊天室(基于websocket)",
 username: "zhangsan",
 smsg: "",
 rmsg: "",
 }
 },
 methods: {
 init(){
 if (typeof(WebSocket) === "undefined"){
 alert("您的浏览器不支持websocket, 功能将无法正常使用!");
 }
 let socketUrl = "ws://localhost/chat/" + this.username;
 console.log("当前用户:",this.username);
 socket = new WebSocket(socketUrl);

 // websocket 创建操作
 socket.onopen = function () {
 console.log("websocket已经打开!");
 }

 // 收到从服务端发来的消息
 socket.onmessage = function (msg) {
 let text = "收到消息: " + msg;
 console.log(text);
 }
 },
 send(){
 // 构造发送的消息 json
 let msg = {
 text: this.smsg
 };
 socket.send(JSON.stringify(msg));
 console.log("消息已发送...");

 },
 },
 mounted(){

 },
 created(){
 this.init();
 }
 })
</script>

14. 监控的意义

SpringCloud学习笔记

Fri, 20 Dec 2024 00:00:00 +0000

1. 版本兼容问题

1.1 cloud和boot

兼容方式如下所示

Spring Cloud 版本	Spring Boot 版本范围
2021.0.1-SNAPSHOT	>=2.6.4-SNAPSHOT and <2.7.0-M1
2021.0.0	>=2.6.1 and <2.6.4-SNAPSHOT
2021.0.0-RC1	>=2.6.0-RC1 and <2.6.1
2021.0.0-M3	>=2.6.0-M3 and <2.6.0-RC1
2021.0.0-M1	>=2.6.0-M1 and <2.6.0-M3
2020.0.5	>=2.4.0.M1 and <2.6.0-M1
Hoxton.SR12	>=2.2.0.RELEASE and <2.4.0.M1
Hoxton.BUILD-SNAPSHOT	>=2.2.0.BUILD-SNAPSHOT
Hoxton.M2	>=2.2.0.M4 and <=2.2.0.M5
Greenwich.BUILD-SNAPSHO	>=2.1.9.BUILD-SNAPSHOT and <2.2.0.M4

2. Eureka注册中心

2.1 Eureka服务端搭建

eureka的搭建分三步走，如下所示：

导入相关依赖

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

编写启动类，添加注解 @EnableEurekaServer

package com.shj.eureka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer // 此注解启动了eureka
public class EurekaApplication {
 public static void main(String[] args) {
 SpringApplication.run(EurekaApplication.class, args);
 }
}

添加配置文件信息

server:
 port: 10086
spring:
 application:
 name: eurekaserver # 应用程序名
eureka:
 client:
 service-url: # eureka 的地址信息
 defaultZone: http://127.0.0.1:10086/eureka

2.2 Eureka 客户端注册

eureka的客户端注册分两边进行，如下所示：

添加依赖信息

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

添加配置文件信息

spring:
 application:
 name: userservice # 配置应用程序名称

eureka:
 client:
 service-url:
 defaultZone: http://127.0.0.1:10086/eureka # 配置注册到的eureka的服务器地址

2.3 服务的拉取

服务拉取是基于服务名称获取服务列表，然后再对服务列表做负载均衡，分如下两步

修改访问的url路径，用服务名代替ip和端口

@RestController
@RequestMapping("order")
public class OrderController {
 @Autowired
 private OrderService orderService;
 @Autowired
 private RestTemplate restTemplate;
 @GetMapping("{orderId}")
 public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
 Order order = orderService.queryOrderById(orderId);
 // 在此使用服务名代替ip和端口
 String url = "http://userservice/user/" + order.getUserId();
 // String url = "http://localhost:8081/user/" + order.getUserId();
 User user = restTemplate.getForObject(url, User.class);
 order.setUser(user);
 // 根据id查询订单并返回
 return order;
 }
}

对RestTemplate使用@LoadBalanced注解做负载均衡

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication // 内含@configuration注解，因此无需单独添加 @configuration
public class OrderApplication {

 public static void main(String[] args) {
 SpringApplication.run(OrderApplication.class, args);
 }

 @Bean
 @LoadBalanced // 此注解完成了负载均衡
 public RestTemplate restTemplate(){
 return new RestTemplate();
 }
}

2.4 负载均衡

3. Naocs 注册中心

3.1 配置方式

不同于eureka，nacos是一个单独的客户端，需要进行安装，默认端口为8848，默认访问地址为 http://localhost:8848/nacos/index.html

配置nacos客户端的方法分如下两步：

添加nacos客户端依赖

<!-- nacos客户端依赖包 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

在yml文件中添加相应的配置

spring:
 cloud:
 nacos: # nacos属于spring的配置
 server-addr: localhost:8848 # 默认地址也是这个

3.2 统一配置管理

统一配置管理是在nacos中读取application.yml文件的方式（nacos中配置文件一般不会这样起名），分成如下步骤：

导入配置坐标依赖

<!-- nacos客户端依赖包 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

<!-- nacos配置管理依赖包 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

引入bootstrap.yml文件，在其配置nacos的配置

spring:
 application:
 name: userservice # 服务名
 profiles:
 active: dev # 开发环境
 cloud:
 nacos:
 server-addr: localhost:8848 # nacos地址
 config:
 file-extension: yaml # nacos中配置文件扩展名

在nacos中配置管理新建配置文件，命名要遵守规则要以name-active.file- extension作为文件名，在其配置需要热更新的配置，而非全部配置

3.3 自动配置刷新

我们希望在nacos中更改了对应模块的配置文件之后，无需重启服务即可感知到文件的变化，此时需要用到自动配置刷新，有两种方法实现。

3.3.1 方法一

在使用@value注解注入属性之后，在对应的类添加注解 @RefreshScope：

@Slf4j
@RestController
@RequestMapping("/user")
@RefreshScope // 此注解即可感知到配置文件的变化
public class UserController {

 @Value("${pattern.dataformat}")
 private String dataformat;

 @GetMapping("/now")
 public String now(){
 return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dataformat));
 }
}

3.3.2 方法二

使用一个类加载所有配置属性，配合注解@ConfigurationProperties

@Data // lombok
@Component // 注册为bean
@ConfigurationProperties(prefix = "pattern") // 此注解实现了配置的自动刷新
public class PatternProprties {
 // 当prefix和属性名拼接在配置文件中能查到对应的，即可注入
 private String dataformat;
}

在controller中的使用

@Slf4j
@RestController
@RequestMapping("/user")
@RefreshScope
public class UserController {

 @Autowired
 private UserService userService;

 @Autowired
 private PatternProprties patternProprties;

 @GetMapping("/now")
 public String now(){
 return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProprties.getDataformat()));
 }
}

3.4 环境共享

配置文件中的重复部分有时写到一个文件中即可，此时会产生环境共享的需求，程序从nacos会读取服务名.yaml，服务名-环境.yaml文件，本地还有application.yml文件，此时优先级为 服务名-环境.yaml > 服务名.yaml > 本地配置，共享的配置佩在 服务名.yaml 文件中即可。

4. http客户端Feign

4.1 基本使用

使用feign时分如下几步：

导入feign的依赖

<!--feign的依赖-->
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

在启动类上使用注解 @EnableFeignClients 打开feign

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
@EnableFeignClients // 此注解打开了feign
public class OrderApplication {
 public static void main(String[] args) {
 SpringApplication.run(OrderApplication.class, args);
 }
}

编写feign类，调用方法既是发送http请求

@Component
@FeignClient("userservice") // 服务名
public interface UserClient {
 @GetMapping("/user/{id}") // 请求的路径
 public User findById(@PathVariable("id") Long id);
}

测试使用

@RestController
@RequestMapping("order")
public class OrderController {

 @Autowired
 private OrderService orderService;

 @Autowired
 private UserClient userClient;

 @GetMapping("/{orderId}")
 public Order queryOrderByUserId(@PathVariable("orderId") Long orderId){
 Order order = orderService.queryOrderById(orderId);
 // 在此调用方法即可发送http请求获取user数据
 User user = userClient.findById(order.getUserId());
 order.setUser(user);
 return order;
 }
}

4.2 性能优化

可以通过设置feign的日志级别和底层http的实现方式（默认为jdk自带的，性能相对较差，不支持连接池技术）来优化性能，步骤如下所示：

日志级别的设置

feign:
 client:
 config:
 default:
 logger-level: full # 全部打印， 一般设为 BASIC比较好

更改底层实现方式

导入feign-httpclient的依赖

<!-- httpClient的依赖-->
<dependency>
 <groupId>io.github.openfeign</groupId>
 <artifactId>feign-httpclient</artifactId>
</dependency>

在application.yml文件中进行相关配置

feign:
 client:
 config:
 default:
 logger-level: basic
 httpclient:
 max-connections: 200 # 最大连接数
 max-connections-per-route: 50 # 每个路径的最大连接数
 enabled: true # 开启feign对httpclient的支持

5. 统一网关Gateway

5.1 基本使用

gateway作为网关，一般用于全部请求到来之前的拦截，之后可以根据访问路径做权限校验，负载均衡等，基本使用方式如下：

添加依赖(注意要添加nacos将gateway注册到nacos)

<!-- nacos客户端依赖包 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- gateway依赖 -->
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

在application.yml中进行配置

spring:
 application:
 name: gateway
 cloud:
 nacos:
 server-addr: localhost:8848
 gateway:
 routes:
 - id: user-service # 路由的唯一标识
 uri: lb://userservice # lb代表复杂均衡
 predicates:
 - Path=/user/** # 代表拦截user/下所有请求
 - id: order-service # 路由的唯一标识
 uri: lb://orderservice
 predicates:
 - Path=/order/** # 代表拦截order/下所有请求

5.2 全局过滤器

gateway提供的过滤器有时无法满足一些开发中的特殊要求，此时需要用到全局过滤器，实现方式如下：

@Component // 注意要定义为bean
public class Filter1 implements GlobalFilter, Ordered {
 @Override
 public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
 ServerHttpRequest request = exchange.getRequest(); // 获取请求对象，注意和servlet的不一样
 MultiValueMap<String, String> queryParams = request.getQueryParams(); // 参数map
 String username = queryParams.getFirst("username");
 if ("zhangsan".equals(username))
 return chain.filter(exchange); // 放行
 exchange.getResponse().setStatusCode(HttpStatus.METHOD_NOT_ALLOWED);
 return exchange.getResponse().setComplete(); // 拦截
 }
 // 此方法为实现了ordered接口之后要实现的，数字越小代表过滤器优先级越高
 @Override
 public int getOrder() {
 return -1;
 }
}

5.3 CORS解决跨域请求

gateway中解决跨域请求的方式是基于cors，只需要在yml文件中添加如下配置即可

spring:
 gateway:
 globalcors:
 add-to-simple-url-handler-mapping: true # 允许options请求
 cors-configurations:
 '[/**]':
 allowed-origins: "*" # 允许跨域网址
 allowed-headers: "*" # 允许跨域请求头
 allowed-methods: "*" # 允许跨域方法

Alist私人云盘

Sat, 26 Oct 2024 00:00:00 +0000

个人搭建的一些资源云盘。如果你需要用的话, 欢迎来找我申请!

Overleaf个人站

Sat, 26 Oct 2024 00:00:00 +0000

个人搭建的overleaf等。如果你需要用的话, 欢迎来找我申请!

🎉 我的大四计划

Mon, 01 Jul 2024 00:00:00 +0000

旨在帮助大家学习Web技术, 大家就是这个框架了, 希望我录的完吧

不定时录制一些知名开源项目的使用教程, 例如Overleaf, Alist, 教大家如何看docs

1. SpringBoot快速入门

Spring Boot基础：快速创建Spring Boot应用，使用Spring Initializr生成项目骨架。
控制器与路由：创建RESTful API，理解@RestController和@RequestMapping的使用。
Spring Boot自动配置：了解Spring Boot如何自动配置常见组件（数据库连接池、消息队列等）。
Spring Data JPA：使用Spring Data JPA操作数据库，理解@Entity、@Repository注解的使用。
Spring Boot Actuator：监控和管理Spring Boot应用的健康状况和指标。

2. Nginx快速入门

Nginx基础配置：安装并配置Nginx，创建虚拟主机并设置不同的Server Block。
反向代理：配置Nginx作为反向代理服务器，将请求转发到后端应用。
负载均衡：实现请求的负载均衡，配置多个后端服务器。
SSL/TLS加密：为Nginx配置SSL证书，支持HTTPS访问。
静态文件服务：配置Nginx作为静态文件服务器，处理图片、CSS、JavaScript等资源。
常见Nginx优化技巧：配置缓存、压缩、限流等，提高性能和可扩展性。

3. MyBatis

基础操作：通过@Mapper和XML映射文件进行CRUD操作。
动态SQL：使用<if>、<choose>等标签生成动态SQL查询。
MyBatis与Spring集成：在Spring Boot中集成MyBatis进行数据库操作。

4. Vue.js基础与进阶

Vue.js基本概念：了解Vue组件、指令（v-if、v-for）、事件处理等基础知识。
Vue Router：配置前端路由，实现单页面应用（SPA）。
Vuex状态管理：使用Vuex进行跨组件状态管理。
组件化开发：编写和复用Vue组件，理解父子组件通信。
Vue 3 Composition API：学习Vue 3的新特性，使用Composition API进行组件逻辑复用。

5. Spring Boot与Vue.js集成

前后端分离架构：在Spring Boot后端提供REST API，Vue.js前端进行数据展示。
跨域问题解决：配置Spring Boot的CORS策略，允许Vue前端跨域访问后端API。
文件上传与下载：使用Spring Boot处理前端文件上传，Vue.js实现文件下载。

6. Spring Cloud微服务架构

服务注册与发现：使用Eureka进行服务注册和发现，理解客户端负载均衡。
API网关：通过Spring Cloud Gateway配置API网关，进行路由转发、过滤等操作。
配置中心：使用Spring Cloud Config管理集中化的配置文件。

7. Redis

缓存与存储：使用Redis作为缓存，提升数据访问速度。
发布/订阅模式：通过Redis实现服务之间的消息传递。
分布式锁：使用Redis的SETNX命令实现分布式锁，防止并发问题。
持久化机制：配置Redis持久化策略（RDB、AOF）以保证数据持久性。

8. Linux基础与运维

Linux命令行操作：掌握常用的Linux命令，进行文件操作、权限管理、进程监控等。
Nginx与Docker部署：在Linux服务器上部署Nginx和Docker，配置Web应用。
日志管理与分析：学习如何配置和分析Linux日志，排查应用问题。

9. 前端技术栈（HTML, CSS, JavaScript, Vue.js, React）

HTML5与CSS3：掌握HTML5标签和CSS3样式，布局和响应式设计。
JavaScript基础：理解JavaScript的基本语法、数据类型、控制结构、函数等。
Vue.js与React框架：深入了解Vue.js与React，学习组件化开发与状态管理。
前端工程化：使用Webpack、Babel等工具进行前端构建和优化。

10. Docker与容器化开发

Docker基础：理解Docker容器的概念，学习如何使用Docker命令构建、运行、管理容器。
Docker Compose：使用Docker Compose来管理多容器应用，简化多服务环境的搭建。
Docker与Spring Boot集成：将Spring Boot应用打包成Docker镜像，实现跨平台部署。
Docker部署生产环境：在生产环境中部署Docker容器，配置日志收集与监控。

Java后端开发学习资料

Sat, 01 Jun 2024 00:00:00 +0000

本文档适用于大一大二想从事java开发的同学使用

JavaSE基础

JavaSE基础 - 视频
如果时间比较紧张的话可以大概看到面向对象之后去看javaweb，如果web中用到了一些se基础例如文件流的知识可以回头来看。

JavaWeb基础1

JavaWeb基础1 - 视频
这个视频讲了数据库的基础和javaweb的初步知识和原理，以及java程序员必须掌握的前端知识。要全部看完并且理解。

JavaWeb基础2

JavaWeb基础2 - 视频
这个课程和javaweb基础1互为补充，这个课程是比较老的一些课程，但是讲的比1深，透彻，并且还介绍了一些linux的相关知识，如果看完javaweb基础1直接跳过这个也没问题，如果想多学一些可以补充着看。

JavaWeb基础3

JavaWeb基础3 - 视频
这个课程是黑马最新的javaweb课程，但是不推荐看，这个课程直接使用了开发框架，会导致web开发变得很简单，因为这个课程学完之后可能不太清楚web的一些原理，除了问题可能也不会自己排查，仅仅停留在会用的阶段。

开发框架1

开发框架1 - 视频
可以看完javaweb基础1之后直接看这个框架1，在做web开发时，会有一些常见的配置项目，和一些依赖比较繁琐，学完框架之后，我们会将更多的精力放在业务逻辑上，简化配置，这里的框架是spring + springmvc + mybatis，spring简化了java开发， springmvc简化了javaweb开发，mybatis简化了数据库中jdbc的操作。最后稍微介绍了一下springboot。要看完，最好理解。

开发框架2

开发框架2 - 视频
这个开发框架就讲了springboot和他的一些组件，springboot进一步简化了ssm的开发，使得web开发更为简洁方便。同时在此，会学习到一些springboot的其他组件，开发中很常用，例如缓存springcache。因为东西太多，大概之后有这个就行，用到了可以现查api。

使用框架开发项目

使用框架开发项目 - 视频
这个使用了springboot+vue+vantui开发的一个小型项目，可以巩固学习到的开发，并且此时就会开始学习项目在linux系统的部署。不用跟着作完，大概看看linux和git还有redis那几块就行。

微服务分布式

微服务分布式 - 视频
单体项目不足以支撑高并发和高可用，所以需要考虑架构的问题，在此会学习分布式开发框架springcloud，和它的一些组件，此时算真正的会做项目了。

前端服务器nginx

前端服务器nginx - 视频
后端有服务器，前端也有服务器，一般开发中和前后端的服务器不会用一个，所以前端项目也要部署在服务器上，常用的就是nginx，nginx在实现分布式系统会起到一个很重要的作用，但是这个课很长，也不用看完，只要需要nginx的知识就可以来这里补，或者网上查询也行，因为如果学到了需要使用nginx的时候，此时也具备了看文档学习的能力。

基础前端知识html，css，js，vue，react，elementui

基础前端知识 - 视频
这个视频会讲一些前端的开发知识，后端程序员也要会一些前端，这里做了一个精简，不太够，哪不够现查就行。

FedSeg论文阅读报告

Mon, 20 May 2024 00:00:00 +0000

《FedSeg: Class-Heterogeneous Federated Learning for Semantic Segmentation》

文献阅读报告

1. 论文摘要

作者的工作主要集中在提出一种新的联邦学习方法FedSeg，用于解决类别异构语义分割任务中的挑战。主要贡献如下：

问题识别：识别并指出了现有联邦学习在语义分割任务中的挑战，特别是在非独立同分布（non-IID）数据和类别异构的情况下。
改进损失函数：提出了一种修改版的交叉熵损失函数BackLoss，以纠正客户端局部优化问题并解决前景-背景不一致的问题。
像素级对比学习：引入像素级对比学习Pixel Contrastive Learning，增强本地像素嵌入与全局语义空间的一致性。
实验验证：在Cityscapes、CamVID、PascalVOC和ADE20k四个语义分割基准上进行了大量实验，验证了FedSeg方法的有效性。

2. 论文引言

首先，语义分割是将给定图像中的每个像素分配唯一的语义标签的任务。这意味着对图像中的每个像素进行分类，以确定其所属的语义类别。语义分割任务中有两个问题。

像素级别的数据很难获取，并且模型的训练需要大量的数据
合作训练有泄漏用户隐私的风险，例如居住照片可能泄漏用户的居住地，车辆行驶图片可能泄漏用户的个人数据等。

基于上述两个问题，在语义分割任务中引入联邦学习是很有必要的。之后来简单介绍一下什么是联邦学习。

联邦学习（Federated Learning，FL）是一种新兴的分布式机器学习方法(之后简称为FL)，其核心理念是通过多个参与方（如智能设备、机构等）在不共享本地数据的情况下，协同训练一个全局模型。联邦学习旨在解决数据隐私、安全性和数据孤岛等问题，使各方能够共同受益于联合模型的优势，而无需交换或集中存储敏感数据，图1是联邦学习的基本流程。

图1 - 联邦学习

联邦学习通常包含四个步骤：

本地训练：本地训练是联邦学习的起点。在这一阶段，每个参与的客户端（例如，个人设备、组织服务器）在本地数据集上训练模型。此时数据不会离开本地设备，保持数据的隐私性和安全性。
模型更新：在本地训练完成后，每个客户端将其训练得到的模型参数发送回中央服务器或协调节点。这样可以确保中央服务器能够获得来自不同客户端的最新模型信息。
模型聚合：中央服务器接收到所有客户端的模型参数后，将这些参数进行聚合，生成一个新的全局模型。这一步是联邦学习的核心步骤，旨在整合各个客户端的训练成果，提升模型的整体性能。
模型部署：在模型聚合完成后，更新后的全局模型被部署到各个客户端，以便在下一个训练周期中使用。这个步骤确保每个客户端都能够从最新的全局模型中受益，从而不断提高模型的性能。

本论文就是在本地训练过程中进行研究。本篇论文聚焦于面向语义分割的类异构联邦学习，然而，先前的大多数FL方法在分类任务上进行评估，而很少有工作专注于更具挑战性的语义分割。相较于分类任务，语义分割具有特定且更为严重的问题。首先，语义分割图像更加复杂，像素级别的注释极其耗时。客户端通常会对频繁出现的类别进行标注，而忽略稀有类别。

之后来看一下联邦学习用于语义分割中的两个基本问题以及作者提出的解决办法。

图2 - 前景后景不一致导致的本地最优化方向不同

首先，由于不同客户端的数据分布是非独立同分布的，一个客户端忽略的类别可能在另一个客户端是前景类别。对于图2中，Person在1中被忽略，但是在2中被识别为主要类。Cat在2中被忽略，但是在3中被识别为主要类。跨客户端的前景-背景不一致性导致了分散的优化方向，并降低了聚合的全局模型的能力。

针对此问题，作者修改了交叉熵损失函数，通过聚合背景类别的概率来校正本地更新中的“客户端漂移”，缓解了前景-背景不一致性问题。

图2 - 无法学习到不同语义类别在像素嵌入空间中的相对位置导致的嵌入空间混乱

其次，对于非独立同分布的情况，复杂的密集预测使得本地优化方向与全局最优点的距离比分类任务更远，导致收敛性较差。从像素嵌入空间的角度来看，每个客户端的本地更新无法学习到不同语义类别在像素嵌入空间中的相对位置，从而在全局聚合后导致混乱的嵌入空间。如图所示，各种不同的语义类别无法在全局空间中被正确的区分开来。

针对此问题，作者进一步引入了一个本地到全局的像素级对比学习损失，强化本地像素嵌入空间与全局语义空间的接近程度，提高了全局模型的收敛性。

总的来说，作者做出来如下贡献：

系统地研究了联邦学习在语义分割任务中应用于多种类别情况下的情况，特别是类异构问题。
提出了一个强有力的基准模型，采用了简单修改的CE损失和局部到全局的度量学习方法，以缓解客户端之间的类别分布漂移问题。
在四个语义分割数据集上提供了基准结果，评估了FedSeg在语义分割联邦学习问题上的表现。希望这项工作能够激励联邦学习社区进一步研究联邦学习问题。

3. FedSeg方法

3.1. FedAvg

作者采用了FedAvg作为基本的联邦学习方法。图3展示了FedAvg的基本流程和方法。

图3 - FedAvg的基本流程和方法

FedAvg（Federated Averaging） 是一种用于联邦学习（Federated Learning, FL）的基本算法。其目标是在保证数据隐私的前提下，通过多个客户端（Clients）协同训练一个共享的全局模型。Avg指的是模型聚合的时候平均所有客户端权重，算法基本流程如下：

参数定义

K ：客户端总数
B ：本地小批量数据的大小
E ：本地训练的轮数
η：学习率
C ：选择客户端的比例（例如图中C=0.1 表示每轮选取10%的客户端）

服务器端执行

初始化全局模型参数
$$w_0$$
进行多轮训练（每轮训练包括以下步骤）：
- 计算参与本轮训练的客户端数量 $$m$$，公式为 $$m \leftarrow \max(C \cdot K, 1)$$
- 随机选取 $$m$$ 个客户端构成集合 $$S_t$$
- 对于每个客户端 $$k \in S_t$$，并行地执行以下步骤：
  - 客户端 $$k$$ 进行本地模型更新 $$w_{t+1}^k \leftarrow \text{ClientUpdate}(k, w_t)$$
- 聚合所有客户端的本地模型参数，更新全局模型参数： $$ w_{t+1} \leftarrow \sum_{k=1}^K \frac{n_k}{n} w_{t+1}^k $$ 其中，$$n_k$$ 是客户端 $$k$$ 的本地数据量，$$n$$ 是所有客户端数据量的总和。

客户端执行

ClientUpdate(k, w) 在客户端

$$k$$

上运行，具体步骤如下：

将客户端的数据集
$$P_k$$
分成大小为
$$B$$
的小批量数据
进行本地训练（每个本地训练轮数为
$$E$$
）：
- 对于每一小批量数据 $$b \in \mathcal{B}$$，执行以下步骤：
  - 使用批量数据 $$b$$ 更新模型参数 $$w$$： $$ w \leftarrow w - \eta \nabla \ell(w; b) $$ 其中，$$\ell(w; b)$$ 是批量数据 $$b$$ 上的损失函数。
将本地更新后的模型参数
$$w$$
返回给服务器。

FedAvg算法特点

数据隐私：数据从不离开客户端，保护了用户的隐私。
分布式训练：多个客户端并行进行本地训练，提高了训练效率。
非独立同分布（Non-IID）数据处理：FedAvg能够处理不同客户端上的非独立同分布的数据，尽管这会对模型收敛带来挑战。

图4 - FedAvg实验评估

上面左边四张图中，横坐标为通信轮次，纵坐标为准确率。可以看到，FedAvg可以用较少的通信轮次达到较高的准确率。右边图中，横坐标为通信轮次，纵坐标为训练损失，可以看到，FedAvg在通信轮次较少的时候可以达到一个相对较低的损失。以上实验证明了FedAvg是可行的。可以用少的通信轮次达到较好的效果。

3.2 初步定义

在这一节中，作者首先定义了他们的方法的基础和目标。他们考虑一个有 N 个客户端的场景，每个客户端有一个本地语义分割数据集 $D_i$。在类别异构的设置中，不同客户端的类别概率分布是不相同的，即 $P_{c\sim D_i} \not～ P_{c\sim D_j}$ 对于$i \not= j$ 。目标是训练一个在组合数据集 $D:= U^N_{i=1}D_i $上的语义分割模型 $w$，且不共享原始数据。目标是最小化全局损失 $L(w)$，定义为：

$$ arg min_{w} L(w) = \sum_{i=1}^{N} \frac{|D_i|}{D_i} L_i(w) $$

其中 $Li(w)=E(x,y)_{∈Di}[li(x,y;w)] $代表客户端 $i$ 的本地目标。使用的框架是 FedAvg，每个训练轮次涉及客户端在各自数据集上优化本地模型。服务器通过取本地模型的加权平均来更新全局模型：

$$ w=\sum_{i=1}^{N}\frac{|D_i|}{|D|}w_i $$

其中 $w_i$ 表示客户端 $i$ 的本地参数。作者提出对本地优化过程进行修改，以在不交换额外信息的情况下提升性能。

3.3. BackCE Loss

在集中学习中，交叉熵（CE）损失是语义分割的标准目标函数。CE 损失定义为：

$$ L_{ce}(x,y)=-\frac{1}{|P|}\sum_{j\in P}logq_x(j,y_i) $$

其中 $y_j$ 是像素 $j$ 的真实标签，$P$ 是标注像素的集合。在联邦学习（FL）中，本地客户端只有总类的一部分，导致本地优化方向不一致，全局收敛性差。

为了解决这个问题，作者修改了 CE 损失，通过聚合本地客户端数据集中不存在的类别的概率来纠正本地优化方向。修改后的 CE 损失是：

$$ L_i^{backce}(x,y)=-\frac{1}{|P|}\sum_{j\in P}log\hat{q_x}(j,y_j) $$

其中 $P$ 是所有像素的集合，$\hat{q}_x(j,c)$ 表示聚合的概率。定义为：

$$ \hat{q}_x(j, y_j) = \begin{cases} q_x(j, y_j) & \text{if } y_j \in C_i, \\ \sum_{c \in C \setminus C_i} q_x(j, c) & \text{if } y_j \notin C_i, \end{cases} $$

其中： $C_i$ 是客户端 $i$ 本地数据集中的类别集合。 $C$ 是全局类别集合。 $q_x(j, c)$ 是像素 $j$ 被预测为类别 $c$ 的概率。

从优化的角度来看，提出的$L_{\text{backce}}$的目的是纠正优化，使其类似于集中式学习。假设像素$j$的类别$c$的预测logit为$z_{jc}$，则$L_{\text{ce}}$关于$z_{jc}$的梯度为：

$$ \frac{\partial L_{\text{ce}}}{\partial z_{c}^{j}} = \begin{cases} p_{c}^{j} - 1 & \text{if } y_j = c \\ p_{c}^{j} & \text{if } y_j \neq c \end{cases} \tag{6} $$

其中，$p_{jc} = \frac{e^{z_c}}{\sum_{k=1}^{K} e^{z_k}}$是像素$j$的类别$c$的预测概率。为了简化公式中的符号，使用$z_c$代替$z_{jc}$。对于集中式语义分割，由于数据集中包含所有类别，因此关于$z_c$的优化考虑了像素标签是否为$c$，包含了正方向和负方向的梯度。

然而，对于去中心化的联邦学习，假设客户端$i$的标注数据只包含类别$l$。对于类别$c \notin C_i$，标准CE损失关于$z_c$的优化仅为正方向，即：$\frac{∂L_{ce}}{∂z_c}=p_c > 0$ 这会使得优化方向远离全局最优。因此，作者通过$L_{backce}$来修正优化方向。对于标签$y_i \notin l$的背景像素，$L_{backce}$相对于$z_c$的梯度如下所示。

$$ \frac{\partial L_{backce}}{\partial z_c} = - \frac{e^{z_c}}{\sum_{k=1}^{K} e^{z_k}} \cdot \frac{e^{z_l}}{\sum_{k \neq l} e^{z_k}} = -p_c \cdot \frac{e^{z_l}}{\sum_{k \neq l} e^{z_k}} \approx -p_c \cdot p_l $$

其中，$p_c$和$p_l$分别表示类别$c$和$l$的预测概率。公式表明对于客户端i中的背景像素（即$y_j \not= l$），$L_{backce}$为类别$c$的$logit \ z_c$提供了负方向的优化，这与两个项$p_c$和$p_l$相关。由于本地模型是从包含所有类别信息的聚合全局模型开始的，预测概率可以提供伪标签信息。如果p_c较大，即像素标签y_j为c的预测概率高，则梯度 $\frac{\partial L_{backce}}{\partial z_c} $相对于类别c更大。如果$p_l$较大，因为标签不是$l$，梯度提供了一个更大的数值，使得优化方向指向类别c并远离类别l。

通过这种方式，修改后的交叉熵损失将本地客户端未包含的类别视为背景类，从而纠正本地优化方向，减轻由于前景-背景不一致而引起的本地更新漂移问题。为了更具体地理解，假设在客户端 $i$ 的数据集中不存在某些类别 $y_j$ ，则这些类别的预测概率会被视为背景类的概率进行聚合。这种处理方法使得本地客户端能够更好地对齐全局优化目标，改善全局模型的收敛性。这种方法不仅简化了模型的训练过程，还通过纠正本地优化方向，有效地解决了类别异构问题，从而提升了语义分割任务的整体性能。

3.4. Local-to-Global Pixel Contrastive Learning

传统的 FL 方法，如 FedProx 和 MOON，通过在本地和全局模型之间应用粗糙的约束来解决非独立同分布（non-IID）问题。然而，这些方法对语义分割的密集预测任务是不够的。

为了改进这一点，作者提出了一种局部到全局像素对比学习方法。在本地更新过程中，从本地和全局模型中提取像素表示。目标是将本地像素表示拉近到同类别的全局表示，同时将它们推离不同类别的表示。这种细粒度的方法有助于对齐本地像素嵌入空间和全局嵌入空间。

局部到全局像素对比损失定义为：

$$ L^{con}_j=\frac{1}{|P_j|}\sum_{v_+\in P_j}-log\frac{exp(v_l·v_+/τ)}{exp(v_l·v_+/τ)+\sum_{v_-\in N_j}exp(v_l·/v_-τ)} $$

公式中的元素含义如下：

$v_l$：局部模型提取的像素表示。

$c$：像素的语义标签。

$v_{g+}$：全局模型提取的属于相同标签 $c$ 的像素表示，作为正样本。

$v_{g-}$：全局模型提取的属于其他类别 $C \setminus c$ 的像素表示，作为负样本。

$L_{\text{con}}$：局部到全局像素对比损失。

$\tau$：温度超参数，用于调整对比损失的尺度。

$P^j$：像素 $j$ 的正样本集合。

$N^j$：像素 $j$ 的负样本集合。

在联合学习（FL）训练中，面对类别异构的问题，局部客户端只包含部分语义标签，而负样本不足。背景像素可能包含其他语义类别。因此，作者提出利用全局模型为背景像素提供伪标签，因为聚合的全局模型能够预测所有语义类别。作者设定了一个阈值 θ，如果像素的预测概率大于 θ，则将其标注为对应类别的伪标签。

综上所述，最终的目标函数为

$$ L = L_{\text{backce}} + \lambda L_{\text{con}} $$

其中 $\lambda$ 是一个超参数，用于控制像素对比损失的权重。

4. 实验验证

4.1 数据设置

作者在四个语义分割数据集上进行了实验，即Cityscapes 、CamVID 、PascalVOC 和 ADE20k ，之后我来简单介绍一下这些数据集。

**Cityscapes 和 CamVID **：这两个数据集包含街景图像，分别具有19个和11个语义类别。不同于分类任务，语义分割数据集中的图像包含许多类别的对象，这些对象很难拆分。为了生成类异质的数据分区，我们将Cityscapes和CamVID划分为K个子集。每个子集保留一到两个语义类别，其他类别设置为背景。对于Cityscapes和CamVID，K分别设置为19和11。在这种设置下，不同客户端之间存在前景-背景不一致的问题。
**PascalVOC **：这是一个图像语义分割数据集，包含2,913张图像、20个前景类别和一个背景类别。PascalVOC中的图像较为简单，大多数图像包含一到两个前景类别。为了生成非独立同分布（non-IID）数据分区，我们将其划分为20个子集，每个子集对应一个前景类别。一个子集的背景不包含其他语义类别。
**ADE20k **：这是一个大规模的语义分割数据集，包含20,210张图像和150个语义类别。语义类别的分布呈长尾分布。为了生成非独立同分布数据分区，我们逐渐将尾部类别拆分为子集，最终生成150个子集。频繁类别的子集不包含尾部类别。一个子集的背景不包含其他类别。

作者采用了两种常用的语义分割评估指标：

mIoU（mean Intersection-over-Union）：表示预测像素与真实像素之间的交并比，平均到所有类别上。
Pixel Accuracy：表示正确分类的像素比例。

4.2 消融实验和对比实验

表1 - 消融实验和对比实验

这张表包含两部分a和b，其中a进行了消融实验，证明了fedseg各个部分的有效性，b进行了对比实验，讲fedseg和目前最先进的方法做对比证明fedseg的优越性。

在表1（a）中，作者展示了FedSeg的主要组成的效果，即$L_{\text{backce}}$和$L_{\text{con}}$的有效性。我们使用FedAvg作为基础的FL框架。表中的FedAvg表示使用标准交叉熵损失的FedAvg方法。FedAvg+$L_{\text{backce}}$表示我们使用修改后的CE损失，而FedAvg + $L_{\text{backce}}+L_{\text{con}}$表示同时使用$L_{\text{backce}}$和$L_{\text{con}}$。我们进行了三次尝试并报告了平均值。实验证明了：

$L_{backce}$的有效性: 表1(a)显示了背景聚合CE损失相比于标准CE损失显著提高了分割性能。这表明背景聚合的优化校正对于类别异构的FL语义分割非常重要。对于Cityscapes、CamVID和PascalVOC，$L_{\text{backce}}$将mIoU提高了20%以上。对于困难的大规模ADE20k，$L_{\text{backce}}$也有1.4%的mIoU改善。
$L_{con}$的有效性: 表1(a)显示添加$L_{\text{con}}$可以将Cityscapes和CamVID的mIoU提高2.5%到5.2%，证明了$L_{\text{con}}$的有效性。对于PascalVOC，$L_{\text{con}}$的有效性有限。这是因为对比损失需要足够的负样本才能获得良好的性能。然而，PascalVOC是一个简单的数据集，每个客户端只包含一个或两个类别，即负类相当有限，$L_{\text{con}}$起作用。对于困难的大规模ADE20k，mIoU略有提高0.3%。

作者在表1(b)中将FedSeg与其他FL方法进行了比较，包括FedAvg 、FedProx 、FedDyn 和MOON 。为了公平比较，它们都在局部更新中使用了$L_{\text{backce}}$，因为$L_{\text{backce}}$可以被视为一个强大的基准线。表1(b)显示了先前用于非IID问题的FL方法（FedProx 、FedDyn 、MOON ）的分割性能与FedAvg 相似甚至更低。这表明，对于密集预测任务，整个模型权重或表示的粗略正则化效果不佳。作者的FedSeg采用了细粒度的像素级对比学习，并有效地提高了mIoU分数。

4.3 IID数据集实验和LOSS对比

表2 - IID数据集实验

作者在表2中报告了FedSeg在IID分布设置下的性能，该设置随机将图像拆分到不同的客户端。结果显示，使用$L_{\text{backce}}$与标准CE损失取得了类似的性能。这是因为$L_{\text{backce}}$旨在纠正优化并解决非IID问题。由于在IID情况下，每个客户端都包含所有类别，因此$L_{\text{backce}}$和标准CE损失（$L_{\text{ce}}$）之间的梯度更新是相似的。添加$L_{\text{con}}$后，性能有所提高，因为它学习了更好的像素嵌入空间。

表3 - 不同的LOSS对比

作者进一步将$L_{\text{backce}}$与常用的语义分割损失进行了比较，包括BCELoss、DiceLoss 和Lova´szLoss 。这些语义分割损失只对前景类别的logits进行梯度计算，从而缓解了FL分割的优化分歧问题。如表3所示，这些结构感知的优化准则的分割性能优于标准CE损失。相比这些损失，我们提出的$L_{\text{backce}}$进一步提高了分割性能，表明$L_{\text{backce}}$在优化方向上更接近于集中训练。具体来说，$L_{\text{backce}}$在Cityscapes（non-IID1）和CamVID（non-IID1）上分别超过了最佳竞争对手DiceLoss 15.7%和16.3%。在PascalVOC上，$L_{\text{backce}}$的提升不如其他数据集显著。这是因为$L_{\text{backce}}$解决了背景不一致的问题，更适用于客户端背景包含其他客户端类别的情况。然而，对于PascalVOC，每个客户端并不包含其他客户端的类别。

表4 - 本地到全局和本地到本地的对比损失比较表5 - 像素到像素和像素到区域的对比损失

表4和表5展示了不同对比损失的效果，基于上述实验现象，作者选取了本地到全局，像素到区域的对比学习损失。

4.4 FedSeg效果

图5 - Cityscapes和CamVID的通信效率比较

图5显示了训练过程中每轮的mIoU分数，由于作者的FedSeg增加了局部到全局的对比损失，以进行细粒度的局部更新校正，从而持续提高了分割性能和通信效率。如图5所示，在Cityscapes（non-IID1和non-IID2）和CamVID（non-IID1和non-IID2）数据集上，FedSeg在开始阶段的mIoU提升速度显著快于FedAvg。

图6 - 不同语义类的像素嵌入的可视化

作者使用t-SNE 对Cityscapes验证数据集中的语义类别像素嵌入进行可视化，如图6所示。作者比较了FedAvg（使用标准CE损失）、FedAvg + $L_{\text{backce}}$和FedAvg + $L_{\text{backce}} + L_{\text{con}}$。图6显示，使用标准CE损失训练的模型学习到的嵌入效果较差，不同语义类别的像素嵌入甚至混杂在一起。使用背景聚合CE损失可以学习到更好的像素嵌入。添加像素对比学习进一步改善了嵌入空间中不同类别的分离度。

从通信效率和最终像素嵌入的可视化来看，FedSeg相对于其他的FL算法，展现出了很好的优越性，通过像素嵌入的可视化，也能看出作者提出的两处修改也确实起到了作用。

4.5 clients的影响

图6 - non-IID数据下参与客户端数量的影响

图6为不同参与客户端的数量对mIoU的影像图。作者评估了不同数量的参与客户端对FedSeg的影响。具体来说，作者随机选择了5、10、15、20个客户端参与每轮的联邦学习。如图7所示，随着客户端数量的增加，使用标准CE损失的FedAvg 的mIoU性能显著提高，因为每轮参与的更多客户端提供了更多数据，缓解了客户端偏移问题。在图7中，随着客户端数量的增加，FedSeg的性能也略有提升。并且不论在client为多少的情况下， FedAvg + $L_{\text{backce}} + L_{\text{con}}$ 的表现总是最好的。

5. 代码复现

图7 - 代码复现-客户端总数60-每次参与5

从github中将代码clone到本地仓库，更改配置文件中的参与客户端总数和每次参与客户端的数量

# 随时输出log: cityscapes
date_now=$(date +"%Y%m%d_%H%M%S")
#python=../envs/torch11/bin/python

#ROOT_DIR='../data/cityscapes'
#ROOT_DIR='../data/cityscapes_split_erase19'
#ROOT_DIR='../data/cityscapes_split_erase19C2'
ROOT_DIR='/root/workspace/voc'
#ROOT_DIR='../data/ade20k_erase_150C1'

LABEL_ONLINE_GEN=False
LOSSTYPE=back #ce,ohem,back,'dice','focal','lovasz','bce'

WARMSTEP=20
FRAC_NUM=5 # 每次参与的客户端数量
LOCAL_EP=2
MIXLABLE=True
FEDPROX_MU=0
##################
DISTILL=False
TEMP_DIST=0.1
LAMB_PI=0.1
LAMB_PA=0
##################
RAND_INIT=False

##################PROTO_NEW
IS_PROTO=True
MOM_UPDATE=False

GLOBALEMA=False
PROTO_START_EPOCH=1
CON_LAMB=0.1
MOMENTUM=0.99
TEMP=0.07
EPOCH_NUM=300
MAX_ANCHOR=4096
KMEAN_NUM=2
PSEUDO_LABLE=True
PSEUDO_LABEL_START_EPOCH=1
LOCALMEM=True
CON_LAMB_LOCAL=1

##################
DATASET=voc #cityscapes #ade20k #camvid
NUM_CLS=20
NUM_USERS=60 # 总共多少个客户端

python -u segmentation/federated_main.py \
--gpu="0" \
--dataset=$DATASET \
--root_dir=$ROOT_DIR \
--USE_ERASE_DATA=True \
--num_classes=$NUM_CLS \
--data="train" \
--num_workers=4 \
--model="bisenetv2" \
--checkpoint="" \
--lr=0.05 \
--lr_scheduler="step" \
--iid=False \
--num_users=$NUM_USERS \
--frac_num=$FRAC_NUM \
--epochs=$EPOCH_NUM \
--local_ep=$LOCAL_EP \
--local_bs=8 \
--is_proto=$IS_PROTO \
--losstype=$LOSSTYPE \
--fedprox_mu=$FEDPROX_MU \
--label_online_gen=$LABEL_ONLINE_GEN \
--distill=$DISTILL \
--distill_lamb_pi=$LAMB_PI \
--distill_lamb_pa=$LAMB_PA \
--rand_init=$RAND_INIT \
--warmstep=$WARMSTEP \
--globalema=$GLOBALEMA \
--temp_dist=$TEMP_DIST \
--mixlabel=$MIXLABLE \
--proto_start_epoch=$PROTO_START_EPOCH \
--con_lamb=$CON_LAMB \
--con_lamb_local=$CON_LAMB_LOCAL \
--momentum=$MOMENTUM \
--temperature=$TEMP \
--max_anchor=$MAX_ANCHOR \
--kmean_num=$KMEAN_NUM \
--pseudo_label=$PSEUDO_LABLE \
--pseudo_label_start_epoch=$PSEUDO_LABEL_START_EPOCH \
--localmem=$LOCALMEM \
--mom_update=$MOM_UPDATE \
--save_frequency=20 \
--local_test_frequency=9999 \
--global_test_frequency=20 \
--USE_WANDB=0 \
--date_now=${date_now} \
| tee -a "save/logs/log-${date_now}.txt"

修改FRAC_NUM和NUM_USERS，设置通信轮次分别为150，250和300，可以看到，FedSeg可以在较少的通信轮次中达到较低的损失。

6. 论文总结

作者研究了用于语义分割的类别异构联邦学习。为了解决局部更新过程中前景-背景不一致和客户端漂移的问题，提出了一种基准方法FedSeg，使用了修改后的CE损失和局部到全局的像素对比损失。在四个语义分割数据集上进行了大量实验，以展示FedSeg的有效性。

7. 学习心得

通过阅读《FedSeg: Class-Heterogeneous Federated Learning for Semantic Segmentation》这篇文章，我学习到了机器学习领域中关于联邦学习和语义分割的前沿知识，加深了我对分布式机器学习系统的理解，在学习FedSeg这篇文章的时候，由于FedSeg采用了FedAvg作为基本的FL框架，我还去阅读了《Communication-Efficient Learning of Deep Networks from Decentralized Data》这篇文章，了解了FedAvg的基本原理和其用于机器学习的效果，汇报中的ppt和本文章中的FedAvg相关的图是从这篇文章中截取的，这篇文章让我了解到了在机器学习领域也可以使用分布式系统，并且对其基本问题给出了基本的解决方案。除此之外，我还掌握了一些关键的技术和方法。具体来说：

学习到了联邦学习的基本概念和挑战：

理解到了联邦学习的基本方法例如Fedavg等。
联邦学习的目标是在保护数据隐私的前提下，通过多个分布式客户端协作训练一个全局模型。
立即到了联邦学习和传统机器学习的异同之处，通过进行实际的代码复现进一步加深了对语义分割任务和联邦学习对传统机器学习的优化的理解。
理解了Non-IID数据（数据分布不均匀）对模型训练的影响，特别是在类异构的场景下，不同客户端的数据包含不同的语义类别，导致训练过程中出现的前景-背景不一致问题。

加深了对语义分割任务的认识：

语义分割是一种密集预测任务，需要对图像中的每个像素进行分类，应用广泛但挑战较大。
语义分割的模型训练需要像素级的标签数据，这种数据很难被获取到，并且在进行和做训练的时候需要进行用户隐私的保护。
通过本论文，我了解了现有的语义分割方法以及它们在联邦学习场景下的局限性。

掌握了改进联邦学习的方法和技术：

修改的交叉熵损失 ($ L_{backce} $)：通过调整损失函数来纠正本地优化方向，从而缓解由数据分布不均匀引起的优化问题。
像素级对比学习 ($L_{con}$)：通过局部到全局的对比学习方法，将本地像素嵌入逼近全局语义空间，提高了全局模型的收敛性和精度。

掌握了实验设计与评估技能：

了解了如何设计实验来验证方法的有效性，包括选择合适的数据集、设定对比实验、分析结果和绘制性能曲线。
学习并掌握了如何使用多种评估指标（如$mIoU$）来衡量模型在不同任务和数据集上的表现。

进行了模型的部署和云服务器的应用：

学会了如何将训练好的模型部署到云服务器上，通过云服务器解决本地配置不足的问题。
学习到了ssh连接云服务器的基本原理和过程，和它的具体使用方法。
熟悉了centos的基本环境和操作指令。
掌握了在云环境中配置和管理服务器的技能，包括服务器的启动与停止、文件权限的设置等。
理解了如何优化模型的部署，提高服务的效率和稳定性，确保模型在实际应用中的有效性和可靠性。

总之，这篇文章不仅拓宽了我在机器学习和计算机视觉领域的知识面，还提供了一些实用的方法和技术，帮助我掌握了应对实际问题的技能。同时，通过模型的部署和云服务器的应用实践，我进一步提升了自己的技术水平，能够将所学知识应用于未来的科研和实际工作中。

Projects

Sun, 19 May 2024 00:00:00 +0000

软件编程综合实践 - 外卖平台设计

Mon, 25 Dec 2023 00:00:00 +0000

一、项目开发计划书

1.概述

1.1项目的目的与目标

项目目的
1. 提升服务效率与便利性：构建一个易于使用的在线订餐平台，使顾客能够快速方便地下单，同时帮助饭店餐厅提升订单处理效率。
2. 促进餐饮业数字化：通过在线平台，促进餐饮业的信息化和网络化，提高整体服务水平。
3. 增强用户体验：通过用户反馈和评价机制，使餐馆能够及时改进，增强顾客的用餐体验。
4. 数据驱动的决策支持：为饭店管理员(老板)提供数据分析工具，以便更好地管理饭馆和制定促销策略。
5. 数据分析与管理：利用数据分析工具，为饭店提供有效的经营决策支持。
项目目标
1. 用户友好的界面设计：设计一个直观、易于操作的用户界面，确保用户能够轻松上手。
2. 高效的订单处理机制：确保订单从下单到配送的全过程高效顺畅。
3. 实现饭店的认证和设置菜品： 通过认证后，饭店可以登陆平台，自行设置菜品种类和菜品价格以及优惠力度。饭店可以根据菜品销量和用户评价进行调整，提供更符合市场需求的菜品选择。
4. 实现顾客的注册、点餐和支付： 顾客可以实名制注册登陆平台，完成菜品的网上点餐和支付，实现方便快捷的外卖订餐服务。
5. 实现外卖配送： 系统能匹配相应外卖快递人员送菜品到顾客家，保证及时的送达服务。
6. 实现用户评价和统计功能： 顾客可以对外卖人员的服务以及饭店的菜品质量进行评价打分，帮助饭店改进和提升服务质量。饭店管理员(老板)可以统计某个时期内平台的收入和销售额，统计某个时期内的销售额和最受欢迎的菜品，顾客可以查询和统计自己的外卖订单，提供数据支持和分析。
7. 提高用户生活质量和餐饮行业的进步： 通过方便的外卖订餐服务，提供更好的用餐体验和生活便利。同时通过用户评价和统计数据的反馈，帮助饭店改进提升，为餐饮行业的长足进步贡献力量。
基本架构设计
- 前端：使用HTML5、Vue.js、ElementUI等技术，构建响应式网页，兼容多种设备。在移动端, 用户也需要登录后使用APP进行点餐
- 后端：采用Node.js、SpringBoot等后端技术，实现数据处理和业务逻辑。
- 数据库：使用MySQL数据库管理系统，存储用户数据、订单数据等。
- API接口：构建RESTful API，实现前后端分离。
- 构建工具：Maven
- 安全性：实施HTTPS、数据加密和用户认证机制，保障用户数据安全。

1.2 系统功能范围及过程规划

1.2.1系统功能范围

管理员模块
- 登陆管理
商家模块
- 登录管理：内部餐厅员工必须登录后,才可以访问系统管理后台。
- 分类管理：主要对当前餐厅经营的菜品分类或套餐分类进行管理维护，包含查询、新增、修改、删除等功能。
- 菜品管理：主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。
- 订单明细：主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。
- 店铺信息设置：上传或修改商铺基本信息。
顾客模块
- 账户注册与登录：在移动端, 用户也需要登录后使用APP进行点餐。
- 查看餐厅：查找餐厅，选择商铺进行选购。
- 点餐下单：查看菜品，选择配送地址，修改购物车后进行下单。
- 查看订单：查看订单记录。
- 设置个人信息：上传或修改个人基本信息。

1.2.2过程规划

需求分析阶段：
- 确定目标用户群（顾客、饭店、管理员）。
- 分析用户需求和市场趋势。
- 制定详细的功能列表和系统需求。
设计阶段：
- 界面设计：构建用户友好的界面，包括布局、颜色和图标等。
- 系统架构设计：确定技术栈、数据库以及所用数据结构、API设计等。
- 安全性设计：制定数据保护和安全协议。
开发阶段：
- 分模块开发：按照功能模块分配开发任务。
- 迭代开发：采用敏捷开发模式，进行快速迭代。
- 持续集成与测试：确保代码质量，进行功能和性能测试。
部署与上线：
- 服务器部署：选择了阿里云服务提供商和服务器配置。
- 上线测试：在模拟实际外卖环境中进行测试，包括负载测试和用户测试。
- 正式上线：发布系统，开放用户注册和使用。
运维与支持：
- 监控系统性能：实时监控服务器和应用性能。
- 用户支持：提供用户帮助和技术支持。
- 持续更新：根据用户反馈和市场变化，定期更新系统功能。
市场推广：
- 制定市场推广计划，包括在线广告、社交媒体营销等。
- 合作伙伴关系建立，如与当地餐厅和配送服务商建立合作。
- 用户反馈收集，以不断优化推广策略和服务。

2 .可行性分析

2.1 社会可行性

市场需求：随着生活节奏的加快，越来越多的人选择外卖作为日常饮食的重要方式。这一趋势表明，外卖订餐系统符合当下社会的需求。
用户接受度：数字化生活方式已深入人心，消费者普遍接受在线订餐的模式，尤其是年轻人群体。
社会影响：提高餐饮业的效率和服务水平，对提升整体生活质量有积极影响。同时，为饭店和个体经营者提供了新的商业机会。
环境适应性：考虑到环保趋势，外卖订餐系统需要鼓励使用环保包装，减少塑料等不可降解材料的使用。

2.2 经济可行性

初期投资：需要资金支持系统的设计、开发和市场推广。这包括人力成本、技术采购、服务器费用等。
运营成本：主要包括服务器维护、客服支持、市场营销和平台升级等。
收益预测：通过平台抽成、广告、合作伙伴关系等多种渠道实现盈利。预计随着用户基数的增加，收益将持续增长。
成本回收期：根据市场响应和用户增长速度预估，初期投资的回收期可以在几年内实现。

2.3 技术可行性

技术成熟度：目前市场上已有许多成熟的技术可供选择，包括前端和后端开发框架、数据库管理系统、支付网关等。
开发能力：开发团队已具备相关的技术知识和经验。
可扩展性和维护性：系统设计考虑了未来的扩展性，能够适应不断增长的用户量和业务需求。同时，系统的维护和更新应当简便高效。
安全性：考虑到了交易安全和个人信息保护，需要采用高标准的安全措施，如数据加密、安全支付等。

3.方案选择

为了实现外卖订餐系统，我们将比较两个主要方案：自主开发方案和第三方服务集成方案。每个方案都有其独特的优势和局限性，需要根据可行性分析进行综合考虑。

3.1自主开发方案

系统架构与技术
- 前端：React或Vue.js，以创建动态和响应式的用户界面。
- 后端：Node.js或Java Spring Boot，提供强大的后台服务。
- 数据库：MySQL，保障数据的稳定存储和高效检索。
- 安全：使用OAuth 2.0标准进行用户认证和授权。
- 云服务：阿里云，提供可靠的服务器和数据存储服务。
构建工具与开发平台
- 构建工具：使用Maven进行项目管理，Git进行版本控制。
- 开发平台：IDEA2022.1
系统检验方案
- 功能测试：采用单元测试和集成测试确保功能正确实现。
- 性能测试：使用LoadRunner等工具进行负载测试。
应对方案
- 技术变化：持续关注技术趋势，定期进行技术栈评估和更新。
- 安全风险：实施定期的安全审计和漏洞扫描。
优势与局限
- 优势：完全自主控制，灵活性和定制性强。
- 局限：开发成本和时间较高，技术风险自担。

3.2第三方服务集成方案

系统架构与技术
- 前端：使用现成的模板和框架快速搭建。
- 后端：集成第三方云服务，如Firebase或AWS Lambda。
- 数据库：使用云数据库服务，如AWS RDS。
- 支付：集成第三方支付服务，如Stripe或PayPal。
CASE工具与开发平台
- CASE工具：利用Trello进行项目协调，GitHub进行代码管理。
- 开发平台：依赖第三方云平台的开发环境。
系统检验方案
- 用户体验测试：重点关注用户界面和交互的流畅度。
- 安全合规性测试：确保集成服务符合行业安全标准。
应对方案
- 服务依赖：定期评估服务供应商的可靠性和性能。
- 成本控制：监控服务费用，避免预算超支。
优势与局限
- 优势：快速部署，成本相对较低，减少技术维护工作。
- 局限：依赖第三方服务，灵活性和自主性受限。

3.3综合比较

功能性：自主开发方案在功能定制方面更为灵活，第三方服务集成方案在快速实现标准功能方面不灵活但有些优势。
技术挑战：自主开发需要更强的技术团队和维护能力，而我们正好有。第三方服务集成降低了技术难度，我们可作为参考。
社会约束：自主开发更容易适应特定市场的需求和法规要求，第三方服务可能在某些区域面临限制。

基于此，我们选择自主开发方案。

4.项目进度计划

4.1任务分解与依赖关系

需求分析与规划：
- 调研市场需求
- 定义功能需求
- 制定初步项目计划
系统设计：
- 界面设计
- 系统架构设计
- 数据库设计
- 安全规划
系统开发：
- 前端开发
- 后端开发
- 数据库实现
- 安全机制实现
测试与部署：
- 功能测试
- 性能测试
- 用户验收测试
- 系统部署
维护与升级：
- 收集用户反馈
- 系统维护
- 功能更新

4.2活动网络图

表1-1 任务表

任务	起始时间	完成时间	持续时间
需求分析与规划	2023.12.16	2023.12.18	3天
系统设计	2023.12.18	2023.12.20	3天
前端开发	2023.12.20	2023.12.23	4天
后端开发	2023.12.20	2023.12.23	4天
数据库实现	2023.12.22	2023.12.24	3天
安全机制实现	2023.12.20	2023.12.24	5天
功能测试	2023.12.24	2023.12.24	1天
性能测试	2023.12.24	2023.12.24	1天
用户验收测试	2023.12.24	2023.12.25	2 天
系统部署	2023.12.24	2023.12.25	2 天
维护与升级	2023.12.25	持续	持续

图1-1. 网络活动图

关键路径：需求分析 → 系统设计 → 系统开发 → 测试与部署

这条路径上的任务是项目成功的关键，任何延误都将直接影响项目整体进度。

4.3甘特图

图1-2. 甘特图

5.人员组织计划

表1-2. 任务分配表

任务模块	负责人	审查人	任务描述
需求分析与规划			负责调研、功能定义、初步计划
系统设计			界面、架构、数据库和安全规划
前端开发			开发用户界面和前端逻辑
后端开发			实现服务器端逻辑和API
数据库实现			设计和实现数据库结构
安全机制实现			开发和实施安全措施
功能测试			执行功能和单元测试
性能测试			进行性能和负载测试
用户验收测试			管理用户测试，收集反馈
系统部署			部署系统至生产环境
维护与升级	整个团队	整个团队	持续的系统维护和更新

二、需求规格说明书

1.系统功能需求

1.1 用户需求描述

1.1.1功能需求

管理员模块
- 登陆管理
商家模块
- 登录管理：内部餐厅员工必须登录后,才可以访问系统管理后台。
- 分类管理：主要对当前餐厅经营的菜品分类或套餐分类进行管理维护，包含查询、新增、修改、删除等功能。
- 菜品管理：主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。
- 订单明细：主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。
- 店铺信息设置：上传或修改商铺基本信息。
顾客模块
- 账户注册与登录：在移动端, 用户也需要登录后使用APP进行点餐。
- 查看餐厅：查找餐厅，选择商铺进行选购。
- 点餐下单：查看菜品，选择配送地址，修改购物车后进行下单。
- 查看订单：查看订单记录。
- 设置个人信息：上传或修改个人基本信息。

1.1.2约束条件

性能约束：
- 系统能承受高峰时段的访问压力，保证快速响应。
- 订单处理和支付系统需实时响应，减少用户等待时间。
安全性与隐私：
- 用户数据（包括个人信息和支付信息）加密存储。
- 系统符合数据保护法规。
可用性：
- 系统具有高可用性，减少停机时间。
- 用户界面友好，易于导航和操作。
可扩展性：
- 系统设计考虑未来扩展，包括用户量增加和功能更新。
法律合规性：
- 系统符合所有相关法律法规，包括食品安全标准和在线支付规定。
维护与支持：
- 系统便于维护和升级。
- 提供用户帮助和技术支持服务。

1.2 初始功能提取

表2-1. 功能需求点列表

编号	功能名称	使用人	功能描述	输入内容	输出内容
1	账户注册与登录	顾客	允许顾客创建账户并登录	用户信息（姓名、密码）	注册成功确认、账户详情
2	查看餐厅	顾客	允许顾客登录到系统并查看餐厅	点击最左角图标	页面进入商家餐厅
3	点餐下单	顾客	进入餐厅，查看菜单，进行点餐下单	餐厅选择，选择菜品	页面返回下单详情
4	查看订单	顾客	顾客能查看历史订单	点击下方中间图标	页面返回订单详情
5	设置个人信息	顾客	顾客可以设置保存个人信息	点击完善个人信息	页面返回信息详情
6	登录管理	商家	允许商家及其员工登录系统	用户信息（姓名、密码）	登录成功确认
7	分类管理	商家	主要对当前餐厅经营的菜品分类或套餐分类进行管理维护，包含查询、新增、修改、删除等功能。	菜品分类信息和套餐分类信息	提交确认、信息详情
8	菜品管理	商家	主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。	菜品信息	提交确认、信息详情
9	订单明细	商家	主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。	订单信息	提交确认、信息详情
10	店铺信息设置	商家	上传或修改商铺基本信息。	上传商铺基本信息。	更新确认
11	登录管理	管理员	管理员登录系统	账号密码	处理状态、信息详情

1.3 系统需求描述

1.3.1用例模型

图2-1. 用例图

用户注册
图2-2. 用户注册活动图 表2-2. 用户注册用例表

项目	描述
用例名称	用户注册
描述	用户打开页面，点击注册
参与者	用户
优先级	基本的
前置条件	用户未注册
触发条件	点击注册
主要流程	1. 用户选择注册。 2. 用户填写必要信息。 3. 系统验证信息。 4. 系统创建用户账户。 5. 系统显示注册成功消息。
后置条件	用户注册成功，可进行登录。
异常流程	用户名已存在或信息无效时，系统显示错误消息。

用户登录
图2-3. 用户登录活动图 表2-3. 用户登录用例表

项目	描述
用例名称	用户登录
描述	用户打开页面，输入账号密码，点击登录
参与者	用户
优先级	基本的
前置条件	用户已注册
触发条件	点击登录
主要流程	1. 用户输入用户名和密码。 2. 系统验证凭证。 3. 登录成功，系统显示用户主页。
后置条件	用户登录系统，可访问个人账户和功能。
异常流程	凭证不正确时，系统显示错误消息。

点餐下单
图2-4. 点餐下单活动图 表2-4. 点餐下单用例表

项目	描述
用例名称	点餐下单
描述	顾客查看菜单，选择菜品，点击下单
参与者	用户
优先级	基本的
前置条件	用户登录浏览菜单并选择菜品
触发条件	点击下单
主要流程	1. 用户浏览菜单选择菜品并添加至购物车。 2. 用户确认订单信息并提交订单。 3. 系统记录订单并生成订单号。 4. 系统通知用户订单成功。
后置条件	用户成功创建订单，等待进一步处理。

查看订单
图2-5. 查看订单活动图 表2-5. 查看订单用例表

项目	描述
用例名称	查看订单
描述	顾客点击查看历史订单
参与者	用户
优先级	基本的
前置条件	用户下单成功
触发条件	点击查看订单
主要流程	1. 用户选择历史订单。 2. 系统处理并验证。 3. 系统显示结果。
后置条件	订单查看完成。

查看餐厅
图2-6. 查看餐厅活动图 表2-6. 查看餐厅用例表

项目	描述
用例名称	查看餐厅
描述	顾客点击查看餐厅商铺
参与者	用户
优先级	基本的
前置条件	用户登录程序
触发条件	点击查看
主要流程	1. 用户点击进入显示餐厅页面。 2. 系统返回当前状态。 3. 用户可实时查看餐厅当前信息。
后置条件	用户进入餐厅或离开页面。

设置个人信息
图2-7. 设置个人信息活动图 表2-7. 设置个人信息用例表

项目	描述
用例名称	设置个人信息
描述	顾客设置完善保存个人信息
参与者	用户
优先级	基本的
前置条件	用户已登录
触发条件	点击修改信息
主要流程	1. 用户选择最右下方图标。 2. 用户提交个人信息。 3. 系统记录信息并展示。
后置条件	用户已完善个人信息。

分类管理
图2-8. 分类管理活动图 表2-8. 分类管理用例表

项目	描述
用例名称	分类管理
描述	商家登录系统，进行菜品分类管理
参与者	饭店商家
优先级	基本的
前置条件	商家已登录系统
触发条件	商家登录，点击分类管理
主要流程	1. 饭店商家登录系统。 2. 点击分类管理。 3. 将需要改动的信息进行增删改查。 4.系统返回信息。
后置条件	商家维护信息成功。

登录管理
图2-9. 登录管理活动图 表2-9. 登录管理用例表

项目	描述
用例名称	登录管理
描述	商家登录
参与者	饭店商家
优先级	基本的
前置条件	饭店已注册
触发条件	商家点击登录
主要流程	1. 饭店输入登录凭证。 2. 系统验证凭证。 3. 登录成功，显示饭店管理界面。
后置条件	饭店可管理饭店信息和订单。

菜品管理
图2-10. 菜品管理活动图 表2-10. 菜品管理用例表

项目	描述
用例名称	菜品管理
描述	商家点击菜品管理，进行完善信息
参与者	饭店商家
优先级	基本的
前置条件	饭店登录成功
触发条件	点击菜品管理
主要流程	1. 饭店添加或编辑菜单项。 2. 系统更新菜单信息。 3. 菜单变更对用户可见。
后置条件	更新后的菜单展示给用户。

订单明细
图2-11. 订单明细活动图 表2-11. 订单明细用例表

项目	描述
用例名称	订单明细
描述	商家可以查看订单明细
参与者	饭店商家
优先级	基本的
前置条件	饭店已接收到用户订单
触发条件	点击查看
主要流程	1. 饭店接收来自用户的订单。 2. 确认订单并处理。 3. 订单状态更新为“正在处理”或“配送中”。
后置条件	订单被处理，进入配送阶段。

店铺信息设置
图2-12. 店铺信息设置活动图 表2-12. 店铺信息设置用例表

项目	描述
用例名称	店铺信息设置
描述	商家可以增加并完善商铺信息
参与者	饭店商家
优先级	基本的
前置条件	饭店已登录系统
触发条件	点击修改信息
主要流程	1. 饭店访问店铺信息页面。 2. 系统展示已有信息。 3. 饭店商家根据已有信息进行信息更新。
后置条件	饭店得到更新信息成功。

1.3.2分析类模型

CRC卡

用户类 (User)

职责 (Responsibilities)	协作 (Collaborations)
注册用户账号	地址类、订单类、购物车类
用户登录	地址类、订单类、购物车类
更新个人信息	地址类
查看购物车	购物车类

地址类 (Address)

职责 (Responsibilities) 协作 (Collaborations)

添加地址用户类

更新地址用户类
订单类 (Orders)

职责 (Responsibilities) 协作 (Collaborations)

创建订单用户类、餐厅类、订单详情类

更新订单状态用户类

查看订单详情订单详情类
餐厅类 (Restaurant)

职责 (Responsibilities) 协作 (Collaborations)

更新餐厅信息类别类、菜品类

管理菜品类别类、菜品类
类别类 (Category)

职责 (Responsibilities) 协作 (Collaborations)

添加类别餐厅类、菜品类

更新类别餐厅类、菜品类
菜品类 (Dish)

职责 (Responsibilities) 协作 (Collaborations)

添加菜品类别类、餐厅类、订单详情类

更新菜品类别类、餐厅类、订单详情类
订单详情类 (Orderdetail)

职责 (Responsibilities) 协作 (Collaborations)

添加订单详情订单类、菜品类

更新订单详情订单类、菜品类

域模型

职责 (Responsibilities)	协作 (Collaborations)
添加地址	用户类
更新地址	用户类

职责 (Responsibilities)	协作 (Collaborations)
创建订单	用户类、餐厅类、订单详情类
更新订单状态	用户类
查看订单详情	订单详情类

职责 (Responsibilities)	协作 (Collaborations)
更新餐厅信息	类别类、菜品类
管理菜品	类别类、菜品类

职责 (Responsibilities)	协作 (Collaborations)
添加类别	餐厅类、菜品类
更新类别	餐厅类、菜品类

职责 (Responsibilities)	协作 (Collaborations)
添加菜品	类别类、餐厅类、订单详情类
更新菜品	类别类、餐厅类、订单详情类

职责 (Responsibilities)	协作 (Collaborations)
添加订单详情	订单类、菜品类
更新订单详情	订单类、菜品类

图2-13. 类图

用户类

属性
- 用户名 : 字符串类型，存储用户的姓名。
- 电话 : 字符串类型，存储用户的联系方式，如电子邮件或电话号码。
- 密码 : 字符串类型，存储用户登录的密码。
- 头像 : 字符串类型，存储用户头像的链接或路径。
- 注册时间 : 时间戳类型，存储用户注册的时间。
方法
- 注册 : 接收用户信息（如姓名、联系方式、地址和登录凭证），在系统中创建新用户。
- 登录 : 接收用户名和密码，验证用户身份。
- 浏览菜单 : 允许用户查看餐厅的菜单和菜品。
- 创建订单 : 允许用户创建新的订单。
- 查看订单 : 允许用户查看自己的订单历史记录。
- 更新个人信息 : 允许用户更新自己的个人信息，如联系方式或地址。
订单类

属性
- 订单号 : 整型或字符串类型，唯一标识一个订单。
- 顾客id : 结构/对象类型，存储下订单的用户信息。
- 地址id : 整型或字符串类型，存储订单的收货地址。
- 总价 : 浮点型，存储订单的总价。
- 创建时间 : 时间戳类型，存储订单的创建时间。
- 评论 : 字符串类型，存储用户对订单的评论或反馈。
- 饭店id : 结构/对象类型，存储订单所属的饭店信息。
- 订单状态 : 字符串类型，表示订单的当前状态（如“待处理”、“配送中”、“已完成”）。
方法
- 创建订单 : 创建新订单，记录顾客信息、饭店信息和菜品列表。
- 更新状态 : 更新订单的当前状态。
餐厅类

属性
- 名称 : 字符串类型，饭店的名称。
- 地址 : 字符串类型，饭店的地址。
- 电话 : 字符串类型，饭店的联系电话或电子邮箱。
- 公告 : 字符串类型，存储饭店的公告或促销信息。
- 封面图片 : 字符串类型，存储饭店封面图片的链接或路径。
- 销量 : 整型，存储饭店的总销量。
- 评分 : 浮点型，存储饭店的平均评分。
- 注册时间 : 时间戳类型，存储饭店注册的时间。
- 状态 : 字符串类型，表示饭店的当前状态（如“营业中”、“休息中”、“已关闭”）。
方法
- 注册 : 接收饭店的基本信息并在系统中注册。
- 登录 : 饭店使用注册信息登录系统。
- 更新信息 : 更新或添加菜单中的菜品。
- 管理菜品 : 接收并处理来自顾客的订单。
菜品类

属性
- 名称 : 字符串类型，菜品的名称。
- 类别id : 整型或字符串类型，存储菜品所属的类别。
- 封面图片 : 字符串类型，存储菜品图片的链接或路径。
- 描述 : 字符串类型，菜品的描述。
- 价格 : 浮点型，菜品的价格。
- 状态 : 字符串类型，表示菜品的当前状态（如“正常销售”、“下架”）。
方法
- 添加菜品 : 将新菜品添加到菜单中。
- 更新菜品信息 : 更新现有菜品的信息，如描述、价格或图片。
- 删除菜品 : 从菜单中删除菜品。
地址类

属性
- 用户id : 整型或字符串类型，存储地址所属的用户。
- 姓名 : 字符串类型，存储收货人的姓名。
- 电话 : 字符串类型，存储收货人的联系电话。
- 详细地址 : 字符串类型，存储收货人的详细地址。
- 状态 : 字符串类型，表示地址的当前状态（如“默认地址”、“备用地址”）。
方法
- 添加地址 : 将新地址添加到用户的地址列表中。
- 更新地址 : 更新现有地址的信息，如收货人姓名、电话或详细地址。
- 删除地址 : 从用户的地址列表中删除地址。
类别类

属性
- 名称 : 字符串类型，类别的名称。
- 餐厅id : 整型或字符串类型，存储类别所属的餐厅。
- 状态 : 字符串类型，表示类别的当前状态（如“正常”、“隐藏”）。
方法
- 添加类别 : 将新类别添加到菜单中。
- 更新类别信息 : 更新现有类别的信息，如名称或状态。
- 删除类别 : 从菜单中删除类别。
订单详情类

属性
- 订单id : 整型或字符串类型，存储订单详情所属的订单。
- 菜品id : 整型或字符串类型，存储订单详情中的菜品。
- 价格 : 浮点型，存储菜品的单价。
- 数量 : 整型，存储菜品的数量。
- 评分 : 浮点型，存储用户对菜品的评分。
方法
- 添加订单详情 : 将新的订单详情添加到订单中。
- 更新订单详情 : 更新现有订单详情的信息，如菜品数量或评分。
- 删除订单详情 : 从订单中删除订单详情。

2.系统性能需求

表2-13. 性能需求点列表

编号	性能名称	使用部门	使用岗位	性能描述	目标	检验指标
1	响应时间	全部	全部用户	系统对用户操作的响应时间	≤ 2秒	用户操作后至界面响应的时间
2	更新处理时间	全部	全部用户	后台数据更新的处理时间	≤ 5秒	后台数据更新操作至完成的时间
3	数据传输时间	全部	全部用户	远程数据传输的时间	≤ 3秒	服务器接收到数据至响应的时间
4	支持的终端数	全部	全部用户	系统能够支持的同时在线终端数量	≥ 10000台	同时在线的用户终端数量
5	并行操作用户数	全部	全部用户	系统支持的同时并行操作的用户数	≥ 1000用户	同时处理的并行用户操作数量
6	处理的记录数	全部	全部用户	系统能处理的最大订单记录数	≥ 100万条	系统存储和处理的订单记录数量
7	数据精度	全部	全部用户	输入和输出数据的精度要求	100%准确	数据处理和传输过程中的精度误差
8	系统安全性	全部	全部用户	系统的数据安全性和防护措施	高安全标准	安全测试结果
9	系统稳定性	全部	全部用户	系统运行的稳定性和故障率	99.9%正常运行	系统故障率和正常运行时间

3.系统界面与接口需求

3.1 界面需求

界面原则要求

方便性：界面设计简单直观，易于新用户理解和操作。
简洁性：避免了复杂或不必要的元素，确保用户能快速找到所需功能。
美观性：采用了现代化的设计风格，提供视觉上的舒适感。
一致性：整个系统的界面风格保持了一致，确保用户体验的连贯性。

系统界面风格定义

风格统一：采用了扁平化设计，使用统一的颜色方案和字体样式。
图标清晰：所有图标简洁、明确，易于理解其功能。
布局合理：界面元素布局合理，确保了信息的层次清晰。

功能模块的特殊界面要求

订单管理界面：
- 显示方式：列表形式展示了订单，包含了订单详情的弹出窗口。
- 特殊要求：提供了搜索和筛选功能，方便用户快速找到特定订单。
用户账户界面：
- 显示方式：清晰展示了用户信息，包括了订单历史和个人资料。
- 特殊要求：确保了个人信息的安全性，提供易于理解的编辑选项。
支付界面：
- 显示方式：简化支付流程，明确显示支付信息和状态。
- 特殊要求：集成多种支付方式，确保支付过程的安全性和稳定性。

硬件支持

输入设备：
- 支持键盘和鼠标操作。
- 移动端优化了触摸屏操作体验。
- 可以集成扫描仪或条码扫描器以便于饭店管理。
输出设备：
- 显示器：界面在多种分辨率下保持清晰。
- 打印机：支持标准的订单打印格式。

显示风格和显示方式

显示风格：
- 主要采用图形界面。
显示方式：
- 适配常见的显示分辨率，确保在不同设备上的可视性和可用性。

输出格式

显示布局：
- 主页和菜单页面便于导航，信息分类清晰。
- 订单和支付页面的布局突出重点信息，如价格、订单状态。
打印格式：
- 订单打印包括所有关键信息，布局清晰，易于阅读。

3.2 接口需求

表2-14. 外部接口需求点列表

编号	接口名称	接口规范	接口标准	入口参数	出口参数	传输频率
1	账户注册与登录	POST	RESTful API	`User` 对象（姓名、密码）	`ApiResponse<Object>`	按需请求
2	查看餐厅	GET	RESTful API	餐厅ID `rid`	`ApiResponse<List<Category>>`	按需请求
3	点餐下单	POST	RESTful API	餐厅选择，菜品选择	`ApiResponse<Object>`	按需请求
4	查看订单	GET	RESTful API	用户ID `uid`	`ApiResponse<IPage>`	按需请求
5	设置个人信息	POST	RESTful API	`User` 对象	`ApiResponse<Boolean>`	按需请求
6	登录管理（商家）	POST	RESTful API	`Restaurant` 对象（姓名、密码）	`ApiResponse<Map<String, String>>`	按需请求
7	分类管理	POST/GET	RESTful API	菜品分类信息	`ApiResponse<Boolean>`	按需请求
8	菜品管理	POST/GET	RESTful API	菜品信息	`ApiResponse<Boolean>`	按需请求
9	订单明细	GET	RESTful API	订单ID `oid`	`ApiResponse<List<OrderDetail>>`	按需请求
10	店铺信息设置	POST	RESTful API	`Restaurant` 对象	`ApiResponse<Boolean>`	按需请求
11	登录管理（管理员）	POST	RESTful API	管理员账号密码	`ApiResponse<Object>`	按需请求
12	购物车内容获取	GET	RESTful API	餐厅ID `rid`	`ApiResponse<List<Map>>`	按需请求
13	更新购物车	POST	RESTful API	`List<ShopCar>` 对象列表	`ApiResponse<Boolean>`	按需请求
14	商户登录	POST	RESTful API	`Restaurant` 对象（手机号、密码）	`ApiResponse<Map<String, String>>`	按需请求
15	更新商户信息	POST	RESTful API	`Restaurant` 对象	`ApiResponse<Boolean>`	按需请求
16	商户分页查询	GET	RESTful API	页码 `page`，数量 `size`，关键字 `key`	`ApiResponse<Object>`	按需请求

4.目标系统假设与约束条件

法律、法规和政策方面的限制
数据保护法规：系统符合当地数据保护法规，特别是在处理个人和支付信息时。
食品安全和卫生法规：系统内的饭店必须遵守当地食品安全和卫生标准。
电子商务法律：系统运营必须符合电子商务相关的法律法规，包括但不限于在线支付、消费者权益保护等。
硬件、软件、运行环境和开发环境方面的条件和限制
硬件限制：系统设计适应多种硬件设备，包括不同性能级别的服务器、多种类型和尺寸的显示设备。
软件限制：系统兼容主流操作系统和浏览器，如Windows、macOS、Linux，以及Chrome、Firefox、Safari等。
开发环境限制：团队需要适应敏捷开发环境和持续集成/持续部署（CI/CD）流程。
运行环境限制：系统能在云环境中稳定运行，需考虑到云服务提供商的可用性和性能限制。
可利用的信息和资源
- 市场调研：系统设计基于详细的市场调研，包括目标用户群的需求和行为模式。
- 技术资源：可利用的技术资源包括开源框架、API、开发工具和云平台服务。
- 财务资源：项目预算应覆盖开发、测试、部署、运营和市场推广的成本。
系统投入使用的最晚日期
- 上线时间：系统最晚于2023.1.5前完成，以便于最后答辩，教师检查。
- 阶段性目标：项目的每个阶段（如，需求分析、设计、开发、测试、部署）已有明确的时间节点，确保了整体项目按时完成。

三、设计规格说明书

1.引言

1.1 命名规则

1.1.1变量对象命名规则

全局变量：
- 使用全大写字母和下划线分隔，例如：GLOBAL_CONFIG。
- 名称反映其功能或用途，例如：MAX_RETRY_COUNT。
- 在声明处附有详细注释说明其用途。
局部变量：
- 使用小写字母，多个单词之间使用驼峰式命名，例如：localCounter。
- 名称具体且有描述性，如：currentPageIndex。
- 对于循环迭代变量，使用简单字符，如i、j。
对象：
- 类名使用大写字母开头的驼峰式命名，例如：OrderDetail。
- 方法名使用小写字母开头的驼峰式命名，例如：calculateTotalPrice。
- 对于私有属性和方法，使用下划线作为前缀，例如：_internalMethod。

1.1.2数据库对象命名规则

数据库表名：
- 使用全小写字母，多个单词之间使用下划线分隔，例如：user_account。
- 名称直观反映表的内容，例如：order_history。
字段名：
- 同样使用全小写字母和下划线分隔，例如：creation_date。
- 精确描述字段含义，避免使用缩写，除非非常通用。
索引名：
- 命名格式为：表名_字段名_idx，例如：user_account_email_idx。
- 清晰表明索引的用途。
视图名：
- 使用全小写字母，多个单词使用下划线分隔，例如：view_user_details。
- 名称清楚地描述视图的内容和用途。

1.2 术语定义

表3-1. 术语定义表

术语	定义
API	Application Programming Interface，应用程序编程接口，允许软件间相互交互。
UI	User Interface，用户界面，是用户与系统交互的界面。
UX	User Experience，用户体验，指用户在使用产品过程中的感受和体验。
数据库	用于存储、管理和检索数据的系统。
CRUD	Create, Read, Update, Delete，创建、读取、更新、删除，是数据库操作的基本功能。
前端	指用户界面和用户直接交互的部分。
后端	指服务器、数据库和应用程序逻辑等不直接面向用户的部分。
MVC	Model-View-Controller，模型-视图-控制器，是一种软件架构模式。
HTTPS	HyperText Transfer Protocol Secure，加密的超文本传输协议。
SSL/TLS	Secure Sockets Layer / Transport Layer Security，用于提升网络安全的加密协议。
响应式设计	指能够自适应不同屏幕大小和设备的网页设计。
云服务	通过互联网提供的各种服务和资源，如服务器、数据库、应用程序等。
OAuth	开放授权标准，允许用户授权第三方应用访问其在另一服务上的信息。
REST API	Representational State Transfer API，表现层状态转化应用程序接口，一种用于网络应用的编程接口风格。

1.3 相关文档

项目需求文档：
- 描述项目的功能需求、性能需求、界面需求、接口需求等。
- 任何功能的增加、删除或修改都需要在此文档中反映。
设计文档：
- 包括系统架构设计、数据库设计、界面设计等。
- 设计文档需根据需求变更进行相应的调整。
技术规范文档：
- 描述技术实现的具体细节，如编码规范、命名规则、开发工具和环境等。
- 需要更新以反映新的技术选择或方法。
测试计划和测试案例：
- 包含测试策略、测试场景、测试用例和测试脚本。
- 任何需求的变更都需要更新测试计划和测试案例，以确保测试覆盖所有功能。
用户手册：
- 提供系统的使用说明，帮助用户理解和使用系统。
- 随着系统功能的变更，用户手册需相应更新。
部署和维护指南：
- 包括系统部署的步骤、配置方法以及维护和故障排除指导。
- 随着系统环境和配置的变更，这些文档需要被更新。
项目进度计划：
- 描述项目的时间线、阶段性目标和关键里程碑。
- 变更可能会影响项目的交付时间和阶段性目标，需要更新进度计划。
风险评估报告：
- 评估项目的潜在风险及其影响。
- 需要根据项目变更重新评估风险。
变更管理文档：
- 记录项目变更的详细信息，包括变更的内容、影响、实施计划和批准信息。
- 每次项目变更都需要更新此文档。

2.系统设计

2.1 体系结构设计

2.1.1逻辑模型 - 包图

图3-1. 包图

2.1.2物理模型 - 部署图

图3-2. 部署图

CDN加速：通过CDN分发静态资源，减少网络延迟，提高用户访问速度。CDN节点遍布多个地理位置，可以根据用户位置提供最近的数据源。
Nginx反向代理：Nginx服务器作为入口，统一处理用户请求。配置反向代理以转发特定前缀（如/api）的请求，同时解决CORS跨域问题。为保证安全，Nginx会添加特定的请求头进行身份校验。
轮询负载均衡：请求通过轮询策略均匀分配到多个Tomcat服务器上，以均衡负载并提高系统的处理能力。
Spring Cloud网关：所有服务请求首先经过Spring Cloud网关，它根据路由规则将请求分发到相应的微服务。网关还负责JWT的权限校验，确保每个请求都是合法和安全的。
缓存策略：使用Spring Cache和Redis来缓存频繁访问的数据，减少数据库查询，提高响应速度。合理的数据淘汰策略确保缓存的数据是最新的，同时减轻MySQL的压力。
RabbitMQ中间件：RabbitMQ用于不同模块间的异步通信，提高系统的响应性和可扩展性。
Spring Boot Admin监控：使用Spring Boot Admin对系统的健康状况和性能指标进行监控，及时发现并解决问题。
MySQL优化：MySQL数据库采用主从复制和读写分离策略。主库处理写操作，从库处理读操作。这不仅提高了数据库的查询效率，还增加了数据的安全性。
Sharding-JDBC分库分表：通过Sharding-JDBC对数据库进行分库分表处理，进一步提高数据处理能力，保证大规模数据操作的效率。

2.2 类设计

1.点餐下单

图3-3. 点餐下单时序图

2.查看订单

图3-4. 查看订单时序图

3.查看餐厅

图3-5. 查看餐厅时序图

4.分类管理

图3-6. 分类管理时序图

5.菜品管理

图3-7. 菜品管理时序图

6.订单明细

图3-8. 订单明细时序图

类之间的关系:

用户类 (User) 与地址类 (Address) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个用户可以有多个地址，但一个地址只属于一个用户)
- 关联方向 (Direction): 双向关联 (用户可以访问其地址列表，地址可以知道所属用户)
- 关联类 (Associated Classes): User 类与 Address 类之间存在关联
用户类 (User) 与订单类 (Orders) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个用户可以有多个订单，但一个订单只属于一个用户)
- 关联方向 (Direction): 双向关联 (用户可以访问其订单列表，订单可以知道所属用户)
- 关联类 (Associated Classes): User 类与 Orders 类之间存在关联
餐厅类 (Restaurant) 与订单类 (Orders)的关联：
- 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个订单项，但一个订单项只属于一个餐厅)
- 关联方向 (Direction): 双向关联 (餐厅可以访问其订单列表，订单项可以知道所属餐厅)
- 关联类 (Associated Classes): Restaurant类与 Orders类之间存在关联
地址类 (Address) 与订单类 (Orders) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个地址可以有多个订单，但一个订单只有一个地址)
- 关联方向 (Direction): 双向关联 (地址可以访问其订单列表，订单可以知道所属地址)
- 关联类 (Associated Classes): Address 类与 Orders 类之间存在关联
餐厅类 (Restaurant) 与类别类 (Category) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个类别，但一个类别只属于一个餐厅)
- 关联方向 (Direction): 双向关联 (餐厅可以访问其类别列表，类别可以知道所属餐厅)
- 关联类 (Associated Classes): Restaurant 类与 Category 类之间存在关联
类别类 (Category) 与菜品类 (Dish) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个类别可以有多个菜品，但一个菜品只属于一个类别)
- 关联方向 (Direction): 双向关联 (类别可以访问其菜品列表，菜品可以知道所属类别)
- 关联类 (Associated Classes): Category 类与 Dish 类之间存在关联
餐厅类 (Restaurant) 与菜品类 (Dish) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个餐厅可以有多个菜品，但一个菜品只属于一个餐厅)
- 关联方向 (Direction): 双向关联 (餐厅可以访问其菜品列表，菜品可以知道所属餐厅)
- 关联类 (Associated Classes): Restaurant 类与 Dish 类之间存在关联
订单类 (Orders) 与订单详情类 (Orderdetail) 的关联：
- 关联重数 (Multiplicity): 1对多 (一个订单可以有多个订单详情，但一个订单详情只属于一个订单)
- 关联方向 (Direction): 双向关联 (订单可以访问其订单详情列表，订单详情可以知道所属订单)
- 关联类 (Associated Classes): Orders 类与 Orderdetail 类之间存在关联

2.3 类说明

用户类
- 属性
  - 用户名 : 字符串类型，存储用户的姓名。
  - 电话 : 字符串类型，存储用户的联系方式，如电子邮件或电话号码。
  - 密码 : 字符串类型，存储用户登录的密码。
  - 头像 : 字符串类型，存储用户头像的链接或路径。
  - 注册时间 : 时间戳类型，存储用户注册的时间。
- 方法
  - 注册 : 接收用户信息（如姓名、联系方式、地址和登录凭证），在系统中创建新用户。
  - 登录 : 接收用户名和密码，验证用户身份。
  - 浏览菜单 : 允许用户查看餐厅的菜单和菜品。
  - 创建订单 : 允许用户创建新的订单。
  - 查看订单 : 允许用户查看自己的订单历史记录。
  - 更新个人信息 : 允许用户更新自己的个人信息，如联系方式或地址。
订单类
- 属性
  - 订单号 : 整型或字符串类型，唯一标识一个订单。
  - 顾客id : 结构/对象类型，存储下订单的用户信息。
  - 地址id : 整型或字符串类型，存储订单的收货地址。
  - 总价 : 浮点型，存储订单的总价。
  - 创建时间 : 时间戳类型，存储订单的创建时间。
  - 评论 : 字符串类型，存储用户对订单的评论或反馈。
  - 饭店id : 结构/对象类型，存储订单所属的饭店信息。
  - 订单状态 : 字符串类型，表示订单的当前状态（如“待处理”、“配送中”、“已完成”）。
- 方法
  - 创建订单 : 创建新订单，记录顾客信息、饭店信息和菜品列表。
  - 更新状态 : 更新订单的当前状态。
餐厅类
- 属性
  - 名称 : 字符串类型，饭店的名称。
  - 地址 : 字符串类型，饭店的地址。
  - 电话 : 字符串类型，饭店的联系电话或电子邮箱。
  - 公告 : 字符串类型，存储饭店的公告或促销信息。
  - 封面图片 : 字符串类型，存储饭店封面图片的链接或路径。
  - 销量 : 整型，存储饭店的总销量。
  - 评分 : 浮点型，存储饭店的平均评分。
  - 注册时间 : 时间戳类型，存储饭店注册的时间。
  - 状态 : 字符串类型，表示饭店的当前状态（如“营业中”、“休息中”、“已关闭”）。
- 方法
  - 注册 : 接收饭店的基本信息并在系统中注册。
  - 登录 : 饭店使用注册信息登录系统。
  - 更新信息 : 更新或添加菜单中的菜品。
  - 管理菜品 : 接收并处理来自顾客的订单。
菜品类
- 属性
  - 名称 : 字符串类型，菜品的名称。
  - 类别id : 整型或字符串类型，存储菜品所属的类别。
  - 封面图片 : 字符串类型，存储菜品图片的链接或路径。
  - 描述 : 字符串类型，菜品的描述。
  - 价格 : 浮点型，菜品的价格。
  - 状态 : 字符串类型，表示菜品的当前状态（如“正常销售”、“下架”）。
- 方法
  - 添加菜品 : 将新菜品添加到菜单中。
  - 更新菜品信息 : 更新现有菜品的信息，如描述、价格或图片。
  - 删除菜品 : 从菜单中删除菜品。
地址类
- 属性
  - 用户id : 整型或字符串类型，存储地址所属的用户。
  - 姓名 : 字符串类型，存储收货人的姓名。
  - 电话 : 字符串类型，存储收货人的联系电话。
  - 详细地址 : 字符串类型，存储收货人的详细地址。
  - 状态 : 字符串类型，表示地址的当前状态（如“默认地址”、“备用地址”）。
- 方法
  - 添加地址 : 将新地址添加到用户的地址列表中。
  - 更新地址 : 更新现有地址的信息，如收货人姓名、电话或详细地址。
  - 删除地址 : 从用户的地址列表中删除地址。
类别类
- 属性
  - 名称 : 字符串类型，类别的名称。
  - 餐厅id : 整型或字符串类型，存储类别所属的餐厅。
  - 状态 : 字符串类型，表示类别的当前状态（如“正常”、“隐藏”）。
- 方法
  - 添加类别 : 将新类别添加到菜单中。
  - 更新类别信息 : 更新现有类别的信息，如名称或状态。
  - 删除类别 : 从菜单中删除类别。
订单详情类
- 属性
  - 订单id : 整型或字符串类型，存储订单详情所属的订单。
  - 菜品id : 整型或字符串类型，存储订单详情中的菜品。
  - 价格 : 浮点型，存储菜品的单价。
  - 数量 : 整型，存储菜品的数量。
  - 评分 : 浮点型，存储用户对菜品的评分。
- 方法
  - 添加订单详情 : 将新的订单详情添加到订单中。
  - 更新订单详情 : 更新现有订单详情的信息，如菜品数量或评分。
  - 删除订单详情 : 从订单中删除订单详情。

3.数据结构设计

3.1持久类分析

Address（地址）：
- 描述：用于存储用户地址信息。
- 属性：ID、用户ID（uid）、姓名、电话、详细地址、状态。
- 数据库映射：映射到一个地址表，每个字段对应一个列。
Category（分类）：
- 描述：代表菜品或商品的类别。
- 属性：ID、餐厅ID（rid）、名称、状态。
- 数据库映射：对应一个分类表，包含各种菜品或商品分类。
Deliver（配送员）：
- 描述：存储配送员的信息。
- 属性：ID、姓名、电话、密码、头像、状态。
- 数据库映射：映射到一个配送员信息表。
Dish（菜品）：
- 描述：代表菜单上的一个菜品。
- 属性：ID、分类ID（cid）、餐厅ID（rid）、名称、描述、价格、折扣、封面图片、状态。
- 数据库映射：映射到一个菜品表，包含各种菜品的详细信息。
OrderDetail（订单详情）：
- 描述：存储关于订单中具体菜品的信息。
- 属性：ID、订单ID（oid）、菜品ID（did）、菜品对象、价格、评分、数量。
- 数据库映射：映射到一个订单详情表，包含订单中每个菜品的信息。
Orders（订单）：
- 描述：代表用户的一个订单。
- 属性：ID、用户ID（uid）、地址ID（aid）、餐厅ID（rid）、总价格、创建时间、评论、状态。
- 数据库映射：映射到一个订单表，记录用户的订单信息。
Restaurant（餐厅）：
- 描述：存储餐厅的信息。
- 属性：ID、名称、电话、密码、公告、地址、封面、销量、评分、评分百分比、注册时间、状态。
- 数据库映射：映射到一个餐厅信息表。
ShopCar（购物车）：
- 描述：用户的购物车信息。
- 属性：ID、用户ID（uid）、菜品ID（did）、餐厅ID（rid）、数量。
- 数据库映射：可能映射到一个购物车表，记录用户添加到购物车的菜品。
User（用户）：
- 描述：存储用户的基本信息。
- 属性：ID、用户名、电话、密码、头像、注册时间、状态。
- 数据库映射：映射到一个用户信息表。

这些类共同构成了此外卖系统的后端数据模型，涵盖了用户、订单、菜品、餐厅等核心功能的数据结构。

3.2 数据库表名清单

表3-2. 数据库表名清单表

序号	中文表名	英文表名	表功能说明
1	地址表	address	存储用户的地址信息
2	类别表	category	存储餐厅提供的食品类别
3	配送员表	deliver	存储配送员的信息
4	菜品表	dish	存储餐厅提供的具体菜品
5	骑手订单表	domap	记录骑手配送订单的信息
6	订单详情表	orderdetail	存储订单的具体细节
7	订单表	orders	存储用户的订单信息
8	餐厅表	restaurant	存储餐厅的信息
9	购物车表	shopcar	存储用户在购物车中的菜品
10	用户表	user	存储用户的个人信息

3.3 数据库表之间关系

graph r(饭店) r --- rid((id)) r --- rphone((电话)) r --- rpasswd((密码)) r --- rname((饭店名)) r --- raddress((位置)) r --- rstatus((状态)) r --- rannounce((通知)) r --- rcover((封面)) r --- rmark((评分)) r --- rsale((销量)) r --- rpercet((抽成)) r --- rregtime((注册时间)) u(用户) u --- uid(id) u --- uname((昵称)) u --- uphone((手机号)) u --- upasswd(密码) u --- uavatar((头像)) u --- uregtime((注册时间)) u --- status((状态)) category(菜品分类) category --- categoryname((名称)) category --- categoryid((id)) category --- categorystatus((状态)) d(菜品) d --- did((id)) d --- dname((名称)) d --- dprice((价格)) d --- ddesc((描述)) d --- dcover((封面)) d --- dstatus((状态)) d --- ddiscount((折扣)) address(地址表) address --- aid((id)) address --- a_name((名称)) address --- aphone((手机号)) address --- adetail((详情)) order(订单) order --- oid((id)) order --- ostatus((状态)) order --- octime((时间)) order --- ototalprice((价格)) order --- ocomment((备注)) order_detail(订单详情) order_detail --- order_detail_id((id)) order_detail --- order_detail_amount((数量)) order_detail --- order_detail_price((价格)) order_detail --- order_detail_mark((评分)) shop_car(购物车) shop_car --- shop_car_id((id)) shop_car --- shop_car_quantity((数量)) deliver(外卖员) deliver --- deliver_id((id)) deliver --- deliver_name((姓名)) deliver --- deliver_phone((电话)) deliver --- |1|deliver_order_belone{派送} ---|n| order category ---|n|category_r_belone{属于} --- |1|r shop_car ---|n|shop_car_u_belone{属于} ---|1|u order --- |1|order_order_detail_belone{属于} ---|n|order_detail order_detail --- |1|order_detail_dish_belone{属于} ---|1|d u --- |1|user_address_belone{属于} --- |n|address order --- |1|order_address_belone{属于} ---|1|address order --- |n|order_u_belone{属于} --- |1|u r --- |1|rd_category{分类} --- |n|d

图3-9. ER图

3.4 数据库表的详细清单

Address 表（地址表）

表3-3. 地址表

序号	字段中文名	字段英文名	类型、宽度、精度	空否	默认值	主键/外键	索引否
1	编号	id	bigint	否		主键	是
2	用户ID	uid	bigint	是		外键	是
3	姓名	name	varchar(255)	是
4	电话	phone	varchar(255)	是
5	详细地址	detail	varchar(255)	是
6	状态	status	bigint	否	‘1’

Category 表（类别表）

表3-4. 类别表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	主键/外键	索引否
1	编号	id	bigint		否	主键	是
2	餐厅ID	rid	bigint		否	外键	是
3	名称	name	varchar(255)		否
4	状态	status	int	0,1,2,3,4,5	是

Deliver 表（配送员表）

表3-5. 配送员表

序号	字段中文名	字段英文名	类型、宽度、精度	空否	主键/外键	索引否
1	编号	id	bigint	否	主键	是
2	姓名	name	varchar(255)	否
3	电话	phone	varchar(255)	否
4	密码	password	varchar(255)	否
5	头像	avatar	varchar(255)	否
6	状态	status	int	否

Dish 表（菜品表）

表3-6. 菜品表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
1	编号	id	bigint		否		主键	是
2	类别ID	cid	bigint		否		外键	是
3	名称	name	varchar(255)		否
4	描述	descr	varchar(255)		是
5	价格	price	decimal(6,2)		否
6	折扣	discount	decimal(4,2)		否	0.00
7	封面图片	cover	varchar(255)		是
8	状态	status	int	0,1,2,3,4,5	是
9	餐厅ID	rid	bigint		是		外键	是

Domap 表（骑手订单表）

表3-7. 骑手订单表

序号	字段中文名	字段英文名	类型、宽度、精度	空否
1	菜品ID	did	bigint	否
2	订单ID	oid	bigint	否
3	评论	comment	varchar(255)	是

Orderdetail 表（订单详情表）

表3-8. 订单详情表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
1	编号	id	bigint		否		主键	是
2	订单ID	oid	bigint		是		外键	是
3	菜品ID	did	bigint		是		外键	是
4	价格	price	decimal(6,2)		是
5	评分	mark	int	0至5	是	‘0’
6	数量	quantity	int		否	‘1’

Orders 表（订单表）

表3-9. 订单表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
1	编号	id	bigint		否		主键	是
2	用户ID	uid	bigint		是		外键	是
3	地址ID	aid	bigint		是		外键	是
4	总价	totalprice	decimal(8,2)		是
5	创建时间	create_time	datetime		否	当前时间
6	评论	comment	varchar(255)		是
7	状态	status	int	0至5	是
8	餐厅ID	rid	bigint		否		外键	是

Restaurant 表（餐厅表）

表3-10. 餐厅表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
1	编号	id	bigint		否		主键	是
2	名称	name	varchar(255)		否
3	电话	phone	varchar(255)		否			是
4	密码	password	varchar(255)		否
5	公告	announce	varchar(255)		是
6	地址	address	varchar(255)		是
7	封面图片	cover	varchar(255)		是
8	销量	sale	bigint		否	‘0’
9	评分	mark	decimal(2,1)	1至5	是
10	抽成比例	percent	decimal(4,2)		否	10.00
11	注册时间	regtime	datetime		是	当前时间
12	状态	status	int	0至5	是	‘0’

Shopcar 表（购物车表）

表3-11. 购物车表

序号	字段中文名	字段英文名	类型、宽度、精度	空否	默认值	主键/外键	索引否
1	编号	id	bigint	否		主键	是
2	用户ID	uid	bigint	否		外键	是
3	菜品ID	did	bigint	否		外键	是
4	数量	quantity	int	否	‘1’
5	餐厅ID	rid	bigint	是			是

User 表（用户表）

表3-12. 用户表

序号	字段中文名	字段英文名	类型、宽度、精度	取值约束	空否	默认值	主键/外键	索引否
1	编号	id	bigint		否		主键	是
2	用户名	username	varchar(255)		否
3	电话	phone	varchar(255)		否			是
4	密码	password	varchar(255)		否
5	头像	avatar	varchar(255)		是
6	注册时间	regtime	datetime		否	当前时间
7	状态	status	int	0至5	否	‘0’

3.5视图设计

视图1: 用户订单详情视图
- 中文名: 用户订单详情
- 英文名: UserOrderDetails
- 列定义
  1. 中文列名: 用户名
    - 英文列名: UserName
    - 类型、宽度、精度: varchar(255)
    - 算法: 直接引用 user 表的 username
    - 基本表名: user
  2. 中文列名: 菜品名称
    - 英文列名: DishName
    - 类型、宽度、精度: varchar(255)
    - 算法: 直接引用 dish 表的 name
    - 基本表名: dish
  3. 中文列名: 订单创建时间
    - 英文列名: OrderCreateTime
    - 类型、宽度、精度: datetime
    - 算法: 直接引用 orders 表的 create_time
    - 基本表名: orders
  4. 中文列名: 总价
    - 英文列名: TotalPrice
    - 类型、宽度、精度: decimal(8,2)
    - 算法: orderdetail 表的 price 乘以 quantity
    - 基本表名: orderdetail
视图2: 餐厅菜品销量视图
- 中文名: 餐厅菜品销量
- 英文名: RestaurantDishSales
- 列定义
  1. 中文列名: 餐厅名称
    - 英文列名: RestaurantName
  - 类型、宽度、精度: varchar(255)
    - 算法: 直接引用 restaurant 表的 name
  - 基本表名: restaurant
  1. 中文列名: 菜品名称
    - 英文列名: DishName
  - 类型、宽度、精度: varchar(255)
    - 算法: 直接引用 dish 表的 name
  - 基本表名: dish
1. 中文列名: 销售数量
  - 英文列名: SalesQuantity
  - 类型、宽度、精度: int
  - 算法: 汇总 orderdetail 表中的 quantity
  - 基本表名: orderdetail
视图3: 用户地址信息视图
- 中文名: 用户地址信息
- 英文名: UserAddressInfo
- 列定义
  1. 中文列名: 用户名
    - 英文列名: UserName
- 类型、宽度、精度: varchar(255)
  - 算法: 直接引用 user 表的 username
- 基本表名: user
1. 中文列名: 地址详情
  - 英文列名: AddressDetail
- 类型、宽度、精度: varchar(255)
  - 算法: 直接引用 address 表的 detail
- 基本表名: address

3.6存储过程与触发器设计

由于springboot提供了完备的业务解决方案，java代码和事务可以完成此工作，为了防止管理混乱，统一使用java代码完成所有业务逻辑

四、系统实现及测试报告

1.系统界面

1.1 商家端页面

登录界面

图4-1. 登录界面
分类管理

图4-2. 分类管理界面

图4-3. 分类管理界面
菜品管理

图4-4. 菜品管理界面

图4-5. 菜品管理界面
订单明细

图4-6. 订单明细界面

图4-7. 订单明细界面
店铺设置

图4-8. 店铺设置界面
数据统计

图4-9. 数据统计界面

1.2 用户端界面

登录
图4-10. 登录界面
浏览餐厅
图4-11. 浏览餐厅界面
搜索餐厅
图4-12. 搜索餐厅界面
选购菜品
图4-13. 选购菜品界面
购物车
图4-14. 购物车界面
选择地址
图4-15. 选择地址界面
添加地址
图4-16. 添加地址界面
订单记录
图4-17. 订单记录界面
用户信息管理
图4-18. 用户管理界面

2.系统实现模块说明

2.1 用户登录注册

描述
- 用户登录和自动注册: 在用户登录时，首先根据手机号查询用户是否已注册。如果未注册，则自动为用户生成一个用户名，并进行注册。如果已注册，则验证密码。无论是自动注册还是登录，最终都会生成一个包含用户ID、手机号和token的信息返回给客户端。
- 用户登出: 提供用户登出的接口，但目前实际执行的操作尚未完成，仅打印了当前用户的ID和手机号。

主要代码

/**
 * 用户注册, 无则注册, 有则登陆
 *
 * @param user
 * @return
 */
@PostMapping("/login")
public ApiResponse<Map<String, String>> login(@RequestBody User user) {
 System.out.println("用户请求登录: " + user);
 // 最终返回的数据
 Map<String, String> infoMap = new HashMap<>();
 // 判断用户名和密码是否正确
 LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
 wrapper.eq(User::getPhone, user.getPhone());
 if (userService.getOne(wrapper) == null) {
 // 用户未注册
 // 组装username
 user.setUsername("用户_" + StringUtil.generateRandomString(5));
 user.setStatus(EntityStatus.NORMAL.intValue());
 userService.save(user);
 HashMap<String, Object> map = new HashMap<>();
 map.put("id", user.getId());
 map.put("phone", user.getPhone());
 infoMap.put("id", user.getId().toString());
 infoMap.put("phone", user.getPhone());
 infoMap.put("token", JwtUtil.generateToken(map));
 log.info("用户注册: {}", user.getId());
 return ApiResponse.success(infoMap, "初次登陆,自动注册!");
 }
 LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(User::getPhone, user.getPhone()).eq(User::getPassword, user.getPassword());
 User one = userService.getOne(queryWrapper);
 if (one == null) {
 // 账号或密码错误
 return ApiResponse.error(200, "用户账号或密码错误");
 }
 // 登录成功
 HashMap<String, Object> map = new HashMap<>();
 map.put("id", one.getId());
 map.put("phone", one.getPhone());
 log.info("用户登陆: {}", one.getId());

 infoMap.put("id", one.getId().toString());
 infoMap.put("phone", one.getPhone());
 infoMap.put("token", JwtUtil.generateToken(map));
 return ApiResponse.success(infoMap, "用户登录成功!");
}

/**
 * 用户登出
 *
 * @return
 */
@PostMapping("/logout")
public ApiResponse<Boolean> logout() {
 Map<String, Object> map = ThreadLocalUtil.get();
 System.out.println(map.get("id"));
 System.out.println(map.get("phone"));
 return null;
}

2.2 查找餐厅

分页查询商户:根据页码、每页数量和查询关键字，分页查询商户信息。

/**
 * 分页查询商户
 *
 * @param page 页码
 * @param size 每页的数量
 * @param key 查询关键字
 * @return 查询出来的商户
 */
@GetMapping("/page")
public ApiResponse<Object> getAllRests(@RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer size,
 @RequestParam(value = "key", required = false) String key) {
 LambdaQueryWrapper<Restaurant> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.like(Restaurant::getName, key == null ? "" : key);
 if (page == null || size == null) {
 return ApiResponse.success(restaurantService.list(queryWrapper), "关键字查询");
 }
 IPage iPage = new Page(page, size);
 return ApiResponse.success(restaurantService.page(iPage, queryWrapper), "分页查询");
}

获取商户信息:根据商户ID获取商户的详细信息。

 @GetMapping("/info")
 public ApiResponse<Restaurant> getRestaurantById(@RequestParam(value = "id", required = false) Long id) {
 return ApiResponse.success(restaurantService.getById(id == null ? ThreadLocalUtil.getId() : id), "获取成功" + id);
 }

2.3 点餐下单

**查看菜品分类列表：**用户根据餐厅ID获取该餐厅的分类列表。只返回状态为NORMAL的分类，即过滤掉已删除或非活动的分类。

/**
 * 用户获取餐厅分类列表
 *
 * @param rid 餐厅id
 * @return
 */
@GetMapping("/user/list")
public ApiResponse<List<Category>> getCategoryListUser(@RequestParam("rid") Long rid) {
 LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
 // 返回启用的分类
 queryWrapper.eq(Category::getRid, rid)
 .eq(Category::getStatus, EntityStatus.NORMAL);
 return ApiResponse.success(categoryService.list(queryWrapper), "用户获取饭店分类列表成功!");
}

**查看菜品列表：**允许用户根据餐厅ID和分类ID获取菜品列表，同时支持分页功能。

 @GetMapping("/user/list")
 public ApiResponse<IPage> getDishListUser(@RequestParam(value = "rid", required = false) Long rid, @RequestParam("cid") Long cid,
 @RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer size) {
 IPage iPage;
 if (page == null || size == null) {
 iPage = new Page(1, 10000);
 } else {
 iPage = new Page(page, size);
 }
 LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
 // 返回正常的菜品
 dishWrapper.eq(Dish::getCid, cid);
 return ApiResponse.success(dishService.page(iPage, dishWrapper), "用户获取分页菜品成功!");
 }

获取用户购物车内容:根据用户ID和餐厅ID获取用户在当前餐厅的购物车内容。

/**
 * 获取用户在当前餐厅中购物车内容
 *
 * @param rid 当前餐厅
 * @return
 */
@GetMapping("/list")
public ApiResponse<List<Map>> getUserShopCar(@RequestParam("rid") Long rid) {
 Long uid = ThreadLocalUtil.getId();
 log.info("请求购物车,用户uid: {}", uid);
 List<Map> dataMaps = new ArrayList<>();
 LambdaQueryWrapper<ShopCar> queryWrapper = new LambdaQueryWrapper<>();
 // 获取用户在当前餐厅的购物车
 queryWrapper.eq(ShopCar::getUid, uid)
 .eq(ShopCar::getRid, rid);
 List<ShopCar> shopCars = shopCarService.list(queryWrapper);
 for (ShopCar shopCar : shopCars) {
 LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
 Map<String, Object> dataMap = new HashMap<>();
 dishWrapper.eq(Dish::getId, shopCar.getDid());
 // 组装数据
 Dish dish = dishService.getOne(dishWrapper);
 dataMap.put("id", shopCar.getId());
 dataMap.put("name", dish.getName());
 dataMap.put("quantity", shopCar.getQuantity());
 dataMap.put("cover", dish.getCover());
 dataMap.put("price", dish.getPrice());
 dataMap.put("discount", dish.getDiscount());
 dataMap.put("descr", dish.getDescr());
 dataMap.put("dish", dish);
 dataMaps.add(dataMap);
 }
 return ApiResponse.success(dataMaps, "获取用户购物车成功!");
}

更新用户购物车:根据用户ID更新购物车信息，包括添加、删除和更新购物车中的菜品。

 /**
 * 更新用户购物车
 *
 * @param shopCars
 * @return
 */
 @PostMapping("/update")
 @Transactional
 public ApiResponse<Boolean> addShopCar(@RequestBody List<ShopCar> shopCars) {
 Long uid = ThreadLocalUtil.getId();
 for (ShopCar shopCar : shopCars) {
 shopCar.setUid(uid);
 log.info("更新购物车信息: {}", shopCar);
 if (shopCar.getQuantity() == null || shopCar.getQuantity() == 0) {
 // 删除此记录
 boolean remove = shopCarService.removeById(shopCar.getId());
 }
 // 无则添加
 if (shopCar.getId() == null) {
 boolean save = shopCarService.save(shopCar);
// return save ? ApiResponse.success(Boolean.TRUE, "添加成功!") : ApiResponse.error(ResponseStatus.ERROR, "添加失败");
 }
 // 有则更新
 boolean update = shopCarService.updateById(shopCar);
// return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error("保存失败!");
 }
 return ApiResponse.success(Boolean.TRUE, "操作成功");
 }

用户提交订单：用户从购物车中创建新订单，并生成相应的订单详情。

 /**
 * 用户下单, 从购物车查询出, 创建新订单, 创建对应的订单详情
 *
 * @return
 */
 @PostMapping("/submit")
 @Transactional
 public ApiResponse<Boolean> submitOrder(@RequestBody SubmitOrder submitOrder) {
 if (submitOrder == null || submitOrder.getCart() == null || submitOrder.getCart().size() == 0) {
 return ApiResponse.error(0, "数据体异常!");
 }
 Long uid = ThreadLocalUtil.getId();
 Long[] scids = submitOrder.getCart().toArray(new Long[0]);
 Long aid = submitOrder.getAid();
 Long rid = submitOrder.getRid();
 String comment = submitOrder.getComment();
 if (scids == null || scids.length == 0) {
 return ApiResponse.error(ResponseStatus.ERROR, "购物车id为空!");
 }
// LambdaQueryWrapper<ShopCar> shopCarWrapper = new LambdaQueryWrapper<>();
// shopCarWrapper.eq(ShopCar::getUid, uid);
 List<ShopCar> shopCars = shopCarService.listByIds(Arrays.asList(scids));
 if (shopCars.size() == 0) {
 return ApiResponse.error(0, "购物车为空!");
 }
 // 创建新订单
 Orders orders = new Orders();
 orders.setStatus(0L);
 orders.setAid(aid);
 orders.setUid(uid);
 orders.setRid(rid);
 orders.setComment(comment);
 ordersService.save(orders);
 List<OrderDetail> details = new ArrayList<>();
 for (ShopCar shopCar : shopCars) {
 // 创建每一个订单详情
 OrderDetail orderDetail = new OrderDetail();
 orderDetail.setOid(orders.getId());
 orderDetail.setDid(shopCar.getDid());
 orderDetail.setQuantity(shopCar.getQuantity().intValue());
 log.error("did: {}, quantity: {}", orderDetail.getDid(), orderDetail.getQuantity());
 // 创建dish查询
 LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
 dishWrapper.eq(Dish::getId, orderDetail.getDid());
 Dish dish = dishService.getOne(dishWrapper);
 // 计算订单详情价格
 orderDetail.setPrice(BigDecimal.valueOf((dish.getPrice().doubleValue() * (1 - dish.getDiscount().doubleValue() / 10)) * shopCar.getQuantity()));
 details.add(orderDetail);
 }
 // 保存orderDetail
 boolean orderDetailFlag = orderDetailService.saveBatch(details);
 // 清空购物车
// boolean removeFlag = shopCarService.remove(shopCarWrapper);
 boolean removeFlag = shopCarService.removeByIds(Arrays.asList(scids));
 return orderDetailFlag && removeFlag ? ApiResponse.success(Boolean.TRUE, "提交成功!") : ApiResponse.error(0, "提交失败!");
 }

更新订单状态:根据传入的订单对象更新订单状态，例如支付、发货、完成或退款。

/**
 * 更新订单
 *
 * @param order 传入的订单
 * @return
 */
@PostMapping("/rest/update")
public ApiResponse<Boolean> update(@RequestBody Orders order) {
 // 留作扩展，根据订单状态执行对应的逻辑
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_PAY) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_DELIVER) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_COMPLETE) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_REFUND) {

 }
 boolean update = ordersService.updateById(order);
 return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error(0, "更新失败");
}

2.4 地址管理

获取用户地址列表：

@GetMapping("/list")
public ApiResponse<List<Address>> getUserAddress() {
 Long uid = ThreadLocalUtil.getId();
 LambdaQueryWrapper<Address> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(Address::getUid, uid)
 .eq(Address::getStatus, EntityStatus.NORMAL);
 return ApiResponse.success(addressService.list(queryWrapper), "用户获取地址成功!");
}

新增或更新地址：

 /**
 * 新增或更新地址, 有则更新, 无则添加
 *
 * @param address
 * @return
 */
 @PostMapping("/update")
 public ApiResponse<Boolean> addAddress(@RequestBody Address address) {
 Long uid = ThreadLocalUtil.getId();
 address.setUid(uid);
 if (address.getId() == null) {
 // 新增地址
 log.info("新增地址信息: {}", address);
 boolean save = addressService.save(address);
 return save ? ApiResponse.success(save, "新增地址成功") : ApiResponse.error(0, "新增地址失败!");

 }
 // 更新地址
 boolean update = addressService.updateById(address);
 return update ? ApiResponse.success(update, "更新地址成功!") : ApiResponse.error(0, "更新地址失败");
 }

2.5 查看订单记录

获取用户的订单（分页功能）:允许用户获取自己的订单列表，支持分页功能。

@GetMapping("/user")
public ApiResponse<IPage> getUserOrders(@RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer size,
 @RequestParam(value = "status", required = false) String status) {
 Map map = ThreadLocalUtil.get();
 Long uid = (Long) map.get("id");
 log.info("请求订单,用户uid: {}", uid);
 LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(Orders::getUid, uid);
 if (page == null || size == null) {
 // 返回全部订单
 return ApiResponse.success(ordersService.page(new Page<>(1, 100000), queryWrapper), "返回用户全部订单");
 }
 IPage iPage = new Page(page, size);
 return ApiResponse.success(ordersService.page(iPage, queryWrapper), "返回用户订单" + page + "," + size);
}

获取用户的订单列表并展示订单详情:显示用户订单列表的详细信息，包括订单中的餐厅、地址、用户信息等。

/**
 * 获取用户订单列表
 * @param page
 * @param size
 * @return
 */
@GetMapping("/user/list")
public ApiResponse<IPage> getUserOrders(@RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer size) {
 // 存放结果的ipage
 IPage<Map<String, Object>> resultIPage = new Page();
 // 存放拼装好的map结果
 List<Map<String, Object>> resultInfos = new ArrayList<>();
 // 获取用户uid
 Long uid = ThreadLocalUtil.getId();
 // 根据用户uid查询订单
 LambdaQueryWrapper<Orders> ordersWrapper = new LambdaQueryWrapper<>();
 ordersWrapper.eq(Orders::getUid, uid);
 // 判断分页
 IPage<Orders> iPage;
 if (page == null || size == null) {
 iPage = new Page<>(1, 10000);
 } else {
 iPage = new Page<>(page, size);
 }
 // 执行分页查询
 IPage<Orders> ordersIPage = ordersService.page(iPage, ordersWrapper);
 for (Orders orders : ordersIPage.getRecords()) {
 // 查询对应的餐厅
 LambdaQueryWrapper<Restaurant> restaurantLambdaQueryWrapper = new LambdaQueryWrapper<>();
 restaurantLambdaQueryWrapper.eq(Restaurant::getId, orders.getRid());
 Restaurant restaurant = restaurantService.getOne(restaurantLambdaQueryWrapper);
 // 查询对应的地址信息
 LambdaQueryWrapper<Address> addressLambdaQueryWrapper = new LambdaQueryWrapper<>();
 addressLambdaQueryWrapper.eq(Address::getId, orders.getAid());
 Address address = addressService.getOne(addressLambdaQueryWrapper);
 // 查询对应的用户信息
 LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
 userLambdaQueryWrapper.eq(User::getId, orders.getUid());
 User user = userService.getOne(userLambdaQueryWrapper);
 // 组装数据
 Map resultInfo = new HashMap();
 resultInfo.put("id", orders.getId());
 resultInfo.put("restaurant", restaurant);
 resultInfo.put("address", address);
 resultInfo.put("user", user);
 resultInfo.put("status", orders.getStatus());
 resultInfo.put("totalprice", orders.getTotalprice());
 resultInfo.put("create_time", orders.getCreateTime());
 resultInfo.put("comment", orders.getComment());
 resultInfos.add(resultInfo);
 }
 // 组装ipage
 resultIPage.setRecords(resultInfos);
 resultIPage.setTotal(iPage.getTotal());
 resultIPage.setSize(iPage.getSize());
 resultIPage.setCurrent(iPage.getCurrent());
 resultIPage.setPages(iPage.getPages());
 return ApiResponse.success(resultIPage, "用户获取订单列表成功!");
}

评价订单详情:允许用户对订单详情进行评分。用户提供订单详情的ID（odid）和评分（mark），然后系统会更新对应的订单详情记录。

/**
 * 对订单详情进行评分
 *
 * @param odid 要评价的orderDetail id
 * @param mark 给出的评分
 * @return
 */
@GetMapping("/evaluate")
public ApiResponse<Boolean> evaluate(@RequestParam("odid") Long odid, @RequestParam("mark") Double mark) {
 OrderDetail orderDetail = orderDetailService.getById(odid);
 orderDetail.setMark(mark);
 boolean update = orderDetailService.updateById(orderDetail);
 return update ? ApiResponse.success(Boolean.TRUE, "评价成功!") : ApiResponse.error("评价失败!");
}

2.6 用户信息管理

获取个人信息:获取当前用户的个人信息，但不包括敏感信息如密码。

/**
 * 更新个人信息
 *
 * @param user
 * @return
 */
@PostMapping("/update")
public ApiResponse<Boolean> updateInfo(@RequestBody User user) {
 return userService.updateById(user) ? ApiResponse.success(Boolean.TRUE, "更新个人信息成功!") : ApiResponse.error(0, "更新个人信息失败");
}

更新个人信息:用户可以更新个人信息，例如用户名、密码等。、

/**
 * 获取个人信息
 *
 * @return
 */
@GetMapping("/info")
public ApiResponse<User> getUserInfo() {
 User user = userService.getById(ThreadLocalUtil.getId());
 user.setPassword(null);
 return ApiResponse.success(user, "获取个人信息成功!");
}

2.7 商户登录注销

**商户登录：**允许商户使用手机号和密码登录系统。如果登录成功，将返回包含商户信息和令牌的响应。

/**
 * 商户登录
 *
 * @param restaurant
 * @return
 */
@PostMapping("/login")
public ApiResponse<Map<String, String>> login(@RequestBody Restaurant restaurant, HttpServletResponse response) {
 LambdaQueryWrapper<Restaurant> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(Restaurant::getPhone, restaurant.getPhone())
 .eq(Restaurant::getPassword, restaurant.getPassword());
 Restaurant one = restaurantService.getOne(queryWrapper);
 if (one != null) {
 // 登录成功
 Map<String, Object> map = new HashMap<>();
 map.put("id", one.getId());
 map.put("phone", one.getPhone());
 one.setPassword(null);
 Map<String, String> infoMap = new HashMap<>();
 infoMap.put("id", one.getId().toString());
 infoMap.put("phone", one.getPhone());
 infoMap.put("name", one.getName());
 infoMap.put("token", JwtUtil.generateToken(map));
 return ApiResponse.success(infoMap, "登录成功");
 }
 response.setStatus(HttpStatus.UNAUTHORIZED.value());
 return ApiResponse.error(401, "登录失败,用户名或密码错误!");
}

**商户注销：**商户注销登录。

@PostMapping("/logout")
public ApiResponse<Boolean> logout() {
 Long rid = ThreadLocalUtil.getId();
 log.info("当前商户: {}", rid);
 return null;
}

2.8 分类管理

餐厅获取自己的分类列表（分页功能）:餐厅可以获取自己的分类列表，支持分页功能，允许餐厅指定页数和每页的大小。

@GetMapping("/rest/list")
private ApiResponse<IPage> getCategoryList(@RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer pageSize) {
 Long rid = ThreadLocalUtil.getId();
 LambdaQueryWrapper<Category> categoryWrapper = new LambdaQueryWrapper<>();
 categoryWrapper.eq(Category::getRid, rid);
 IPage iPage = (page == null || pageSize == null) ? new Page(1, 10000) : new Page(page, pageSize);
 IPage<Category> page1 = categoryService.page(iPage, categoryWrapper);
 return ApiResponse.success(page1, "获取分页分类成功!");
}

新增、更新或逻辑删除分类:根据传入的分类对象进行新增或更新操作。如果分类对象的ID为null，则视为新增分类。如果分类的名称或状态为null，则视为逻辑删除（即更新分类状态为DELETED）。否则，执行更新现有分类的操作。

@PostMapping("/update")
public ApiResponse<Boolean> updateCategory(@RequestBody Category category) {
 category.setRid(ThreadLocalUtil.getId());
 if (category.getId() == null) {
 boolean save = categoryService.save(category);
 return save ? ApiResponse.success(save, "保存成功") : ApiResponse.error(999, "保存失败!");
 } else if (category.getName() == null || category.getStatus() == null) {
 category.setStatus(EntityStatus.DELETED);
 boolean deletedLogic = categoryService.updateById(category);
 return deletedLogic ? ApiResponse.success(deletedLogic, "删除成功") : ApiResponse.error(999, "删除失败!");
 }
 boolean update = categoryService.updateById(category);
 return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error(999, "更新失败!");
}

2.9 菜品管理

获取餐厅菜品列表（分页功能）:允许餐厅获取自己的菜品列表，支持分页功能，使餐厅可以指定页数和每页的大小。

/**
 * 获取菜品全部列表，给rest用
 *
 * @param page
 * @param size
 * @return
 */
@GetMapping("/rest/list")
public ApiResponse<IPage> getDishListRest(@RequestParam(value = "page", required = false) Integer page,
 @RequestParam(value = "size", required = false) Integer size) {
 IPage iPage;
 if (page == null || size == null) {
 iPage = new Page(1, 10000);
 } else {
 iPage = new Page(page, size);
 }
 LambdaQueryWrapper<Dish> dishWrapper = new LambdaQueryWrapper<>();
 // 返回正常或者停售的菜品
 dishWrapper.eq(Dish::getRid, ThreadLocalUtil.getId())
 .eq(Dish::getStatus, EntityStatus.NORMAL)
 .or().eq(Dish::getStatus, EntityStatus.STOP_SALE);
 return ApiResponse.success(dishService.page(iPage, dishWrapper), "后端获取全部菜品成功!");
}

根据分类获取菜品列表:允许获取特定分类下的菜品列表。

@GetMapping("/category")
private ApiResponse<List<Dish>> getDishByCategory(@RequestParam("cid") Long cid) {
 LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(Dish::getCid, cid);
 queryWrapper.eq(Dish::getStatus, EntityStatus.NORMAL);
 return ApiResponse.success(dishService.list(queryWrapper), "获取菜品列表成功!");
}

新增或更新菜品:根据传入的菜品对象进行新增或更新操作。如果菜品对象的ID为null，则视为新增菜品；否则，更新现有菜品的信息。

/**
 * 新增或更新菜品, 有则更新, 无则添加
 *
 * @param dish
 * @return
 */
@PostMapping("/update")
public ApiResponse<Boolean> updateDish(@RequestBody Dish dish) {
 if (dish.getId() == null) {
 // 新增菜品
 dish.setRid(ThreadLocalUtil.getId());
 boolean save = dishService.save(dish);
 return save ? ApiResponse.success(save, "新增菜品成功") : ApiResponse.error(999, "新增菜品失败!");
 }
 // 更新菜品
 boolean update = dishService.updateById(dish);
 return update ? ApiResponse.success(update, "更新成功!") : ApiResponse.error(0, "更新失败");
}

批量停售、起售和删除菜品:实现菜品的批量停售、起售和逻辑删除（仅更新状态为DELETED）。

/**
 * 批量停售菜品
 *
 * @param ids 菜品id列表
 * @return
 */
@PostMapping("/disable")
@Transactional
public ApiResponse<Boolean> disableDish(@RequestBody List<Long> ids) {
 log.info(ids.toString());
 List<Dish> dishes = new LinkedList<>();
 for (Long id : ids) {
 Dish dish = new Dish();
 dish.setId(id);
 dish.setStatus(EntityStatus.STOP_SALE);
 dishes.add(dish);
 }
 boolean update = dishService.updateBatchById(dishes);
 return update ? ApiResponse.success(update, "停售成功") : ApiResponse.error(0, "停售失败!");

}

/**
 * 批量起售菜品
 *
 * @param ids 菜品id列表
 * @return
 */
@PostMapping("/enable")
@Transactional
public ApiResponse<Boolean> enableDish(@RequestBody List<Long> ids) {
 List<Dish> dishes = new LinkedList<>();
 for (Long id : ids) {
 Dish dish = new Dish();
 dish.setId(id);
 dish.setStatus(EntityStatus.NORMAL);
 dishes.add(dish);
 }
 boolean update = dishService.updateBatchById(dishes);
 return update ? ApiResponse.success(update, "起售成功") : ApiResponse.error(0, "起售失败!");
}

/**
 * 批量删除菜品, 删除仅仅是标记status为 EntityStatus.DELETED (2)
 *
 * @param ids
 * @return
 */
@PostMapping("/delete")
@Transactional
public ApiResponse<Boolean> deleteDish(@RequestBody List<Long> ids) {
 List<Dish> dishes = new LinkedList<>();
 for (Long id : ids) {
 Dish dish = new Dish();
 dish.setId(id);
 dish.setStatus(EntityStatus.DELETED);
 dishes.add(dish);
 }
 boolean update = dishService.updateBatchById(dishes);
 return update ? ApiResponse.success(update, "删除成功") : ApiResponse.error(999, "删除失败!");
}

2.10 订单明细管理

获取餐厅的订单列表（分页和筛选功能）:允许餐厅获取自己的订单列表，支持分页和按条件筛选。

 @GetMapping("/rest/list")
 public ApiResponse<IPage> getRestaurantOrders(@RequestParam(value = "page", required = false) Integer page, @RequestParam(value = "size", required = false) Integer size,
 @RequestParam(value = "key", required = false) String key, @RequestParam(value = "begin", required = false) String begin,
 @RequestParam(value = "end", required = false) String end) {
// IPage<Orders> ordersPage = new Page<>();
// ordersPage.setRecords(ordersService.getRestOrder(page, size, key, startDate, endDate));
// ordersPage.setCurrent(page);
// ordersPage.setSize(size);
 Long rid = ThreadLocalUtil.getId(); // 获取商家编号
 log.info("请求订单,商家编号: {}", rid);
 LambdaQueryWrapper<Orders> ordersWrapper = new LambdaQueryWrapper<>();
 ordersWrapper.eq(Orders::getRid, rid);
 // 存储返回结果
 IPage dataPage = new Page();
 // 存放record, 最终结果拼装在map中
 List<Map> recordsMap = new ArrayList<>();
 IPage<Orders> iPage = new Page<>(1, 10000);
 // 动态拼接查询条件
 if (page != null && size != null) {
 iPage = new Page(page, size);
 }
 if (key != null) {
 ordersWrapper.like(Orders::getId, key);
 }
 if (begin != null) {
 LocalDateTime startDate = StringUtil.GtStringToLocalDateTime(begin);
 LocalDateTime endDate;
 if (startDate != null) {
 if (end == null) {
 // 结束日期为空默认当前
 endDate = LocalDateTime.now();
 } else {
 endDate = StringUtil.LtStringToLocalDateTime(end);
 }
 ordersWrapper.ge(Orders::getCreateTime, startDate).le(Orders::getCreateTime, endDate);
 }
 }
 IPage<Orders> ordersIPage = ordersService.page(iPage, ordersWrapper);
 List<Orders> records = ordersIPage.getRecords();
 for (Orders record : records) {
 Map<String, Object> recordMap = new HashMap<>();
 LambdaQueryWrapper<User> userWrapper = new LambdaQueryWrapper<>();
 LambdaQueryWrapper<Address> addressWrapper = new LambdaQueryWrapper<>();
 userWrapper.eq(User::getId, record.getUid());
 addressWrapper.eq(Address::getId, record.getAid());
 User user = userService.getOne(userWrapper);
 Address address = addressService.getOne(addressWrapper);
 recordMap.put("id", record.getId()); // 订单号
 recordMap.put("user", user); // 用户名
 recordMap.put("address", address); // 下单地址
 recordMap.put("phone", address.getPhone()); // 下单手机号
 recordMap.put("status", record.getStatus()); // 订单状态
 recordMap.put("create_time", record.getCreateTime()); // 订单创建时间
 recordMap.put("totalprice", record.getTotalprice() == null ? 0.00 : record.getTotalprice());
 recordMap.put("comment", record.getComment());
 recordsMap.add(recordMap);
 }
 dataPage.setRecords(recordsMap);
 dataPage.setSize(ordersIPage.getSize());
 dataPage.setCurrent(ordersIPage.getCurrent());
 dataPage.setTotal(ordersIPage.getTotal());
 dataPage.setPages(ordersIPage.getPages());

 return ApiResponse.success(dataPage, "查询餐厅订单成功!");
 }

更新订单状态:根据传入的订单对象更新订单状态，例如支付、发货、完成或退款。

/**
 * 更新订单
 *
 * @param order 传入的订单
 * @return
 */
@PostMapping("/rest/update")
public ApiResponse<Boolean> update(@RequestBody Orders order) {
 // 留作扩展，根据订单状态执行对应的逻辑
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_PAY) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_DELIVER) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_COMPLETE) {

 }
 if (order.getStatus() == OrdersStatus.ORDER_STATUS_REFUND) {

 }
 boolean update = ordersService.updateById(order);
 return update ? ApiResponse.success(update, "更新成功") : ApiResponse.error(0, "更新失败");
}

获取特定订单的详细信息:根据给定的订单ID（oid），返回该订单的所有详情。对于每个订单详情，还会查询并包含相关联的菜品信息。

/**
 * 根据传来的订单id列表返回对应的订单详情
 *
 * @param oid
 * @return orderdeatil:{
 * de...
 * dish: {
 * dish..
 * }
 * }
 */
@GetMapping("/rest/byoid")
@Transactional //
public ApiResponse<List<OrderDetail>> getOrderDetailByOid(Long oid) {
 List<OrderDetail> list = new LinkedList<>();
 LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
 queryWrapper.eq(OrderDetail::getOid, oid);
 List<OrderDetail> details = orderDetailService.list(queryWrapper);
 for (OrderDetail detail : details) {
 LambdaQueryWrapper<Dish> wrapper = new LambdaQueryWrapper<>();
 wrapper.eq(Dish::getId, detail.getDid());
 detail.setDish(dishService.getOne(wrapper));
 list.add(detail);
 }
 return ApiResponse.success(list, "获取订单详情成功!");
}

2.11 商户信息管理

更新商户信息:允许商户更新其个人信息，包括名称、联系电话等。

/**
 * 更新商户信息
 *
 * @param restaurant 要更新的商户信息
 * @return
 */
@PostMapping("/update")
public ApiResponse<Boolean> updateRestaurant(@RequestBody Restaurant restaurant) {
 restaurant.setId(ThreadLocalUtil.getId());
 boolean update = restaurantService.updateById(restaurant);
 if (update) {
 return ApiResponse.success(update, "更新成功");
 }
 return ApiResponse.error(999, "更新失败!");
}

3.系统测试

测试方案说明

测试阶段划分：
- 单元测试：针对系统中的最小可测试单元（如函数、方法）。
- 集成测试：测试多个单元或模块协同工作的情况。
- 系统测试：测试整个系统的功能是否符合需求。
- 验收测试：确保系统满足最终用户的需求。
测试计划：
- 确定测试目标和范围。
- 识别测试所需资源和工具。
- 制定测试时间表和里程碑。
- 分配测试任务给团队成员。
测试方法：
- 单元测试：使用工具如JUnit或pytest对单独的函数和方法进行测试。
- 集成测试：使用工具如TestNG或Postman测试模块间的接口和交互。
- 系统测试：测试整个应用的工作流程，包括功能测试、性能测试、安全测试等。
- 验收测试：基于用户的实际场景进行测试，可能包括用户参与的UAT（用户接受测试）。
测试工具：
- 自动化测试：Selenium、Appium等用于UI测试。
- 性能测试：JMeter、LoadRunner用于性能和负载测试。
- 安全测试：OWASP ZAP、Nessus等用于安全漏洞扫描。

每个阶段的测试活动

单元测试：
- 目标：确保代码的每个部分按预期工作。
- 活动：编写和执行针对单个函数或方法的测试案例。
集成测试：
- 目标：确保多个单元或模块能够协同工作。
- 活动：测试模块间接口和数据流，识别任何集成错误。
系统测试：
- 目标：验证系统整体功能和性能。
- 活动：进行全面的功能测试，性能测试，以及安全测试。
验收测试：
- 目标：确保系统满足用户的实际需求。
- 活动：让最终用户测试系统，收集反馈，进行调整。

3.1 模块测试

商家:

登陆管理:

图4-19. 登录管理测试图 表4-1. 登录管理测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2、4、6、8、9	账号:admin 密码:admin	进入首页	进入首页	无	success	2023/12/25
2	1、2、3	账号: 密码:admin	不发生跳转	不发生跳转	无	success	2023/12/25
3	1、2、4、5	账号:admin密码:	不发生跳转	不发生跳转	无	success	2023/12/25
4	1、2、4、6、7	账号：密码:	不发生跳转	不发生跳转	无	success	2023/12/25

菜品管理

图4-20. 菜品管理测试图 表4-2. 菜品管理测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2、3、7、8、9	进入页面，点击新增菜品	进行操作	进入首页	无	success	2023/12/25
2	1、2、4，7，8，9	进入页面，点击修改菜品	进行操作	进入首页	无	success	2023/12/25
3	1、2、5，7，8，9	进入页面，点击删除菜品	进行操作	进入首页	无	success	2023/12/25
4	1、2、6、7，8，9	进入页面，点击查看菜品	进行操作	进入首页	无	success	2023/12/25

分类管理

图4-21. 分类管理测试图 表4-3. 分类管理测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2、3、7，9，11	进入页面，点击新增菜单类别信息	进行操作	进行操作	无	success	2023/12/25
2	1、2、4、7，9，11	进入页面，点击修改套餐类别信息	进行操作	进行操作	无	success	2023/12/25
3	1、2、5、7，9，11	进入页面，点击删除不同类别套餐	进行操作	进行操作	无	success	2023/12/25
4	1、2、6、7，9，11	进入页面，点击查看已有类别套餐	进行操作	进行操作	无	success	2023/12/25
5	1、2、3、7，8，10，11	进入页面，点击新增菜单类别信息，但有非法操作	返回页面	返回页面	无	success	2023/12/25
6	1、2、4、7，9，11	进入页面，点击修改套餐类别信息，但有非法操作	返回页面	返回页面	无	success	2023/12/25
7	1、2、5、7，9，11	进入页面，点击删除不同类别套餐，但有非法操作	返回页面	返回页面	无	success	2023/12/25
8	1、2、6、7，9，11	进入页面，点击查看已有类别套餐，但有非法操作	返回页面	返回页面	无	success	2023/12/25

订单明细

图4-22. 订单明细测试图 表4-4. 订单明细测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2、3、11	进入页面，点击订单明细，为空。	返回页面信息	返回页面信息	无	success	2023/12/25
2	1、2、4、6，9，11	进入页面，点击订单明细，不删除，不更改。	返回页面信息	返回页面信息	无	success	2023/12/25
3	1、2，4、5、7，9，11	进入页面，点击订单明细，删除，不更改。	返回页面信息	返回页面信息	无	success	2023/12/25
4	1、2、4，5、7，8，10，11	进入页面，点击订单明细，删除，更改。	返回页面信息	返回页面信息	无	success	2023/12/25
5	1、2、4，6，8，10，11	进入页面，点击订单明细，不删除，更改。	返回页面信息	返回页面信息	无	success	2023/12/25

店铺信息设置

图4-23. 店铺信息设置测试图 表4-5. 店铺信息设置测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，4、7，9，11	进入页面，不为空，不删除，不保存	返回页面信息	返回页面信息	无	success	2023/12/25
2	1、2，4、7，8,10，11	进入页面，不为空，不删除，保存	返回页面信息	返回页面信息	无	success	2023/12/25
3	1、2，3，4、7，9，11	进入页面，为空，不删除，不保存	返回页面信息	返回页面信息	无	success	2023/12/25
4	1、2、4，5、6	进入页面，不为空，删除。	返回页面信息	返回页面信息	无	success	2023/12/25
5	1,2,3	进入页面，为空。	返回页面信息	返回页面信息	无	success	2023/12/25

顾客:

账户注册与登录

图4-24. 注册登录测试图 表4-6. 注册登录测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，3，5、7，9	进入页面，已注册，不为空，输入正确	进入页面	进入页面	无	success	2023/12/25
2	1、2，3，5、8	进入页面，已注册，不为空，输入不正确	进入页面	进入页面	无	success	2023/12/25
3	1、2，3，6	进入页面，已注册，为空	进入页面	进入页面	无	success	2023/12/25
4	1、2、4，10，11	进入页面，未注册	进入页面	进入页面	无	success	2023/12/25

查看餐厅

图4-25. 查看餐厅测试图 表4-7. 查看餐厅测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，6、7	进入页面，进行选择	显示页面	显示页面	无	success	2023/12/25
2	1、3，4	进入页面，点击输入框，输入为空	不显示页面	不显示页面	无	success	2023/12/25
3	1、3，5，7	进入页面，点击输入框，输入不为空	显示页面	显示页面	无	success	2023/12/25

设置个人信息

图4-26. 设置个人信息测试图 表4-8. 设置个人信息测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，3，12，13	进入页面，信息已完善。	不进入页面	不进入页面	无	success	2023/12/25
2	1、2，4，5，6	进入页面，信息不完善，输入为空	再次输入	再次输入	无	success	2023/12/25
3	1、2，4，5，7，8	进入页面，信息不完善，输入不为空，但删除	再次输入	再次输入	无	success	2023/12/25
4	1、2、4，5，7，9，10	进入页面，信息不完善，输入不为空，不删除，但不保存	再次输入	再次输入	无	success	2023/12/25
5	1，2，4，5，7，9，11，12，13	进入页面，信息不完善，输入不为空，不删除，保存	返回页面信息	返回页面信息	无	success	2023/12/25

点餐下单

图4-27. 点餐下单测试图 表4-9. 点餐下单测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，3，4，5	进入页面，选择为空	继续选择	继续选择	无	success	2023/12/25
2	1、2，3，4，6，7，8	进入页面，选择不为空，但要删除	继续选择	继续选择	无	success	2023/12/25
3	1、2，3，4，7，9，10	进入页面，选择不为空，不删除，但不结算	继续选择	继续选择	无	success	2023/12/25
4	1、2、4，5，6，7，9，11，12，14，15	进入页面，选择不为空，不删除，结算并确定	返回页面信息	返回页面信息	无	success	2023/12/25
5	1、2、4，5，6，7，9，11，12，13	进入页面，选择不为空，不删除，结算并不确定	返回已选信息	返回已选信息	无	success	2023/12/25

查看订单

图4-28. 查看订单测试图 表4-10. 查看订单测试表

编号	路径标识	输入	期望输出	输出内容	发现问题	测试结果	测试时间
1	1、2，3，9，10	进入页面，显示可查看为空	返回查看信息	返回查看信息	无	success	2023/12/25
2	1、2，4，5，6，7，9，10	进入页面，显示可查看不为空，不删除	返回查看信息	返回查看信息	无	success	2023/12/25
3	1、2，4，5，6，8，10	进入页面，显示可查看不为空，删除	显示页面	显示页面	无	success	2023/12/25

3.2 功能测试

3.2.1 系统功能需求

表4-11. 系统功能需求点列表

编号	功能名称	使用人	功能描述	输入内容	输出内容
1	账户注册与登录	顾客	允许顾客创建账户并登录	用户信息（姓名、密码）	注册成功确认、账户详情
2	查看餐厅	顾客	允许顾客登录到系统并查看餐厅	点击最左角图标	页面进入商家餐厅
3	点餐下单	顾客	进入餐厅，查看菜单，进行点餐下单	餐厅选择，选择菜品	页面返回下单详情
4	查看订单	顾客	顾客能查看历史订单	点击下方中间图标	页面返回订单详情
5	设置个人信息	顾客	顾客可以设置保存个人信息	点击完善个人信息	页面返回信息详情
6	登录管理	商家	允许商家及其员工登录系统	用户信息（姓名、密码）	登录成功确认
7	分类管理	商家	主要对当前餐厅经营的菜品分类或套餐分类进行管理维护，包含查询、新增、修改、删除等功能。	菜品分类信息和套餐分类信息	提交确认、信息详情
8	菜品管理	商家	主要维护各个分类下的菜品信息，包含查询、新增、修改、删除、启售、停售等功能。	菜品信息	提交确认、信息详情
9	订单明细	商家	主要维护用户在移动端下的订单信息，包含查询、取消、派送、完成，以及订单报表下载等功能。	订单信息	提交确认、信息详情
10	店铺信息设置	商家	上传或修改商铺基本信息。	上传商铺基本信息。	更新确认
11	登录管理	管理员	管理员登录系统	账号密码	处理状态、信息详情

3.2.2 功能测试报告

表4-12. 功能测试记录表

编号	功能名称	输入内容	期望输出	输出内容	发现问题	测试结果	测试时间
1	账户注册与登录	正确的用户信息（姓名、密码）	注册成功确认、账户详情	注册成功、账户详情	无	通过	2023-12-25
2	查看餐厅	点击最左角图标	页面进入商家餐厅	成功进入餐厅页面	页面加载稍有缓慢	通过	2023-12-25
3	点餐下单	选择餐厅和菜品	页面返回下单详情	显示下单成功	无	通过	2023-12-25
4	查看订单	点击下方中间图标	页面返回订单详情	显示订单详情	无	通过	2023-12-25
5	设置个人信息	完善个人信息	页面返回信息详情	信息更新成功	无	通过	2023-12-25
6	登录管理	商家登录信息（姓名、密码）	登录成功确认	登录成功	无	通过	2023-12-25
7	分类管理	菜品分类信息	提交确认、信息详情	分类更新确认	无	通过	2023-12-25
8	菜品管理	菜品信息	提交确认、信息详情	菜品更新确认	无	通过	2023-12-25
9	订单明细	订单信息	提交确认、信息详情	显示订单明细	无	通过	2023-12-25
10	店铺信息设置	商铺基本信息	更新确认	店铺信息更新成功	无	通过	2023-12-25
11	登录管理	管理员账号密码	处理状态、信息详情	登录成功	无	通过	2023-12-25

3.3.其它测试

3.3.1 性能测试方案

1. 测试准备

测试环境：确保测试环境与生产环境尽可能一致。
测试数据：准备充足的测试数据，包括用户账户、餐厅信息、菜品信息等。
性能测试工具：选择合适的工具，如 Apache JMeter、Gatling。

2. 测试执行

基准测试：在正常负载下运行系统，收集基准性能数据（如响应时间、系统吞吐量）。
负载测试：
- 模拟不同级别的用户负载（例如：100、500、1000 并发用户）。
- 关注页面加载时间、API 响应时间等。
压力测试：
- 逐渐增加负载，直到系统达到崩溃点。
- 记录系统性能下降的具体点和表现。
容量测试：
- 确定系统能够同时处理的最大用户数量和交易数量。
- 观察资源利用率（CPU、内存、数据库）。

3. 性能指标

响应时间：页面和API的平均和最长响应时间。
系统吞吐量：每秒处理的请求和交易数。
资源利用率：服务器CPU、内存、磁盘I/O和网络I/O的利用率。
错误率：请求错误和失败率。

3.3.2 安全测试方案

1. 测试准备

安全测试工具：选择如 OWASP ZAP、Burp Suite 的工具。
安全测试团队：组建经验丰富的安全测试团队。

2. 测试执行

静态应用安全测试（SAST）：
- 分析源代码以识别潜在的安全漏洞。
- 重点关注SQL注入、XSS、CSRF等常见漏洞。
动态应用安全测试（DAST）：
- 在运行中的应用上执行测试。
- 模拟常见的网络攻击，如SQL注入、XSS。
渗透测试：
- 模拟黑客攻击以识别安全弱点。
- 包括身份验证系统、数据加密和服务器配置的测试。
API安全测试：
- 测试API的安全性，包括授权、访问控制和数据传输。

3. 安全指标

身份验证和授权：确保正确实施并且无法绕过。
数据加密：传输和存储中的数据是否加密。
安全漏洞：识别和记录所有安全漏洞。
错误处理和日志记录：检查系统的错误处理是否适当，日志记录是否完整。

4. 报告和修复

对于发现的每个问题，编写详细报告。
与开发团队合作，及时修复安全漏洞。
对修复后的系统进行再次测试以验证问题已解决。

3.4测试结论(Test Verdict)

在整个测试过程中，我们对系统进行了全面而深入的测试，覆盖了功能性、性能、安全性等多个方面。以下是对测试结果的综合结论：

测试信息说明如下：

测试完成日期：2023/12/25

测试地点：实验楼/宿舍/教学楼

测试环境：IntelliJ IDEA 2022.2.1, postman等

**系统强项：**界面简洁美观，使得用户商家无需经过培训即可直接上手使用。功能齐全，角色分工明确，顾客，商家，管理员可以看到和操作的权限界限分明，且系统安全性高。同时本系统具有多种异常处理方式，保证系统的稳定性和可靠性。

**系统弱项：**受限于实际功能需求，有些不好确定的字段未做合适的正则校验，使得可以输入一些非法数据。

**优化建议：**针对学校的具体信息，设计合理的正则表达式，在前端发送数据和后端接受数据时做好校验，同时在数据库进行数据增删改的时候也要做好校验，防止非法数据的进入。

不符合项统计结果：暂无

测试人员签字：

五、实验工作记录和总结

1. 小组实验总结（Group Summary）

在本次软件设计与编程实践中，我们小组紧密协作，完成了一项全面的小型项目，经历了需求分析、设计、开发和测试等多个关键阶段。首先，通过拆解项目为顾客模块、饭店商家模块和管理员模块三个子模块，我们在需求分析阶段明确了项目的基本框架。使用用例图、用例表和活动图等UML建模方法，为项目需求建立了清晰的图形化表示，提供了明确的功能和交互要求。

在设计阶段，团队成员分工负责各个子模块的序列图和逻辑框架设计。通过这一过程，我们总结出了实现类清单，明确了系统的逻辑结构和物理架构。在开发阶段，团队将设计图转化为实际可运行的代码，其中包括前端交互界面和后端功能实现。各成员积极贡献，从而形成一个紧密协作的团队。

在测试阶段，团队对各个模块进行了全面的测试，包括组件测试和功能测试。采用基本路径法等测试方法，保证了系统的稳定性和可靠性。最终，我们成功地将项目部署至服务器运行，并撰写了详细的测试报告。整个实验过程使得团队成员对软件设计与编程实践的实际应用有了更深刻的认识，不仅提高了对前后端框架的理解，还培养了团队协作和问题解决的能力。这次实验不仅是对理论知识的实践，也是对团队协作和软件工程实践的重要锻炼，为我们今后的学习和工作奠定了坚实的基础。

2. 组员实验总结（Personal Summary）

2.1

在本次软件设计与编程实践中,我担任小组的组长,参加了软件的需求分析,设计以及开发测试过程,协调组内各成员的合作,将任务合理的分配给每一个团队成员,并将小组内每个小组成员完成的工作进行归纳汇总.在分析阶段,我们首先对项目进行拆解,将项目分解成三个子模块,包括顾客模块、饭店商家模块和管理员模块,绘制出了各个模块用例的用例图,用例表,以及活动图.然后,我们据此设计出了UI界面的原型,并总结出了非功能需求.在设计阶段,我们分工设计并绘制了每个模块的序列图，总结了实现类清单，选择了系统逻辑框架以及系统物理架构.在开发阶段, 我主要负责多个前端交互界面的设计和实现，并为后端功能实现提供接口.在项目开发完成后,我还负责将项目部署至服务器运行.在项目测试阶段，我们分别对组内其他成员编写的模块进行测试,测试完成后,我们分工撰写了测试报告.并由我进行最后的汇总以及归纳. 本次实践,是我们第二次合作完成一个小型的项目的开发,这次软件设计与编程实践,不仅极大的提升了我的编程能力,学会熟练的使用框架完成项目的开发,也让我懂得了团队协作的重要性,明白了1+1>2的道理,更让我理解了软件设计与编程实践这门课程的重要性,加深了我对用例图、鲁棒图、序列图、部署图等UML建模方法的理解，并可以做到熟练应用.

2.2

在本次软件设计与编程实践中，我全程积极参与了整个项目从需求分析，设计，开发以及测试的过程.并完成了相关部分报告的撰写.在需求分析阶段,我和其他成员一起按要求进行了需求的提取,并按照规则填写了用例表，绘制了全部的用例图、活动图，并参与了界面的设计以及域模型的绘制.在设计阶段,我设计并绘制了顾客用户相关部分的序列图和逻辑图并填写了实现类，并使用mybatis框架进行了持久层代码的编写,并与其他相应功能完成了接口实现，并运用等价类结合需求功能阶段的功能点列图进行功能测试并完成了测试结论的总结.在开发阶段中，我负责了顾客模块的前后端实现.在测试阶段,运用基本路径法进行了组件测试并进行总结，并完成了测试报告的撰写. 通过这次软件设计与编程实践，我加深了对软件开发整个流程的认识，并能够更加熟练地运用课上所学来对一个项目需求进行分析，开发阶段提高了我对前后端框架的认识，能够熟练使用各种API及其他辅助工具，并对前后端之间的通信逻辑有了更深的理解。

2.3

在本次软件设计与编程实践中,我作为团队成员,积极的参与了整个项目分析、设计、开发及测试部分,并主要负责饭店商家模块的实现.在需求分析阶段,我主要负责绘制饭店商家模块的用例图以及用力表,并和其他成员共同总结非功能需求, 并参与设计了主界面的原型.在设计阶段,我负责绘制饭店商家模块的序列图,并和其他成员一起总结了实现类清单，选择了系统逻辑框架以及系统物理架构, 填写了饭店商家模块的实现类清单，完成了相关功能的逻辑设计.在开发阶段,在前端上我负责饭店商家模块页面，以及在业务逻辑上进行了许多功能与相关交互。在此次软件设计与编程实践中,我提升了使用UML进行建模的能力并学习了一些基本测试方法，加深了对团队项目的开发过程的理解.在开发过程中学会了使用vue与springboot框架,提升了编程能力.并认识了到团队间协作在实际开发过程中的重要性.

2.4

在本次软件设计与编程实践过程中，我与其他组内成员积极协作,共同完成了整个分析、设计、开发及测试部分.在需求分析阶段，我按照要求进行了需求的提取并填写了相应的用例表，并绘制了多个相关的用例图、活动图，参与绘制了域模型。在设计阶段，我设计并绘制了部署图，参与了数据库的设计、绘制数据库了ER图并和其他成员一起建立了数据库表。在开发阶段中，我负责了菜品信息增删改查的前端页面的架构，我还负责编写实现了分类管理进行增添功能的后端代码。在项目测试阶段，我负责对顾客用户的各项功能进行组件测试,负责使用设计阶段的关键程序逻辑设计图,利用等价类划分的方式进行测试,在测试结束后,完成了相关部分测试报告的编写. 在这次软件设计与编程实践中,我对软件项目的开发有了更深刻的认识,对各种图表的建立也更加熟练,提升了我解决分析问题的能力,与此同时,我的编程水平也得到了很大的提升,并学会了一些团队间协作开发的工具,例如分布式版本控制工具.并深刻认识到了团队间协作的重要性.

3. 组内互评（Mutual evaluation within the group）

表5-1. 组内互评表

					合计
需求分析	25	25	25	25	100
系统设计	26	24	25	25	100
系统实现	25	26	24	25	100
系统测试	24	25	26	25	100
个人总体贡献系数	1	1	1	1	人均贡献系数为1

Mysql数据库设计

Mon, 20 Nov 2023 00:00:00 +0000

1. 实验目的

掌握数据库设计的过程和方法。

2. 实验内容和要求

每人请从下面的题目当中选择一个，进行数据库设计，通过网络平台或图书馆查找相关文献进行需求分析，按照下面的实验步骤完成设计要求。

选题为：(10)网上超市购物系统的设计

3. 实验步骤

(1)根据所选题目进行系统需求分析和系统设计，画出系统的 E-R 图，给出实体或联系的属性，标明联系的种类;

3.1 需求分析设计

3.1.1 需求分析

随着网络的不断普及，日益忙碌的人们开始追求足不出户地利用互联网这一强大的平台来实现网上购物，网上超市购物应运而生。网上超市购物系统是一种具有交互功能的商业信息系统，它在网络上建立了一个虚拟的购物商城，使购物过程变得轻松、快捷、方便。本课题要求针对某个超市设计并实现一个集个性化推荐与在线超市于一体的专业型电子商务网站。

3.1.2 系统设计

前端设计：

用户界面

主页： 展示热门商品、促销信息等。
商品列表页： 显示各类商品，支持分类、搜索。
商品详情页： 包括商品详细信息、用户评价、相关推荐等。
用户个人中心： 提供订单管理、个人信息管理等功能。
购物车页面： 显示用户已选商品，支持编辑和结算。

交互体验

用户注册和登录： 提供注册和登录功能，使用安全的身份验证。
购物流程： 流畅的购物车、结算流程，包括支付选项和订单确认。
个性化推荐： 根据用户历史行为和购买记录实现个性化推荐。
后端设计：

业务逻辑

用户管理： 处理用户注册、登录、个人信息修改等请求。
商品管理： 处理商品的添加、编辑、删除等请求。
购物车和订单： 管理用户购物车内容和处理订单生成、支付等操作。
推荐引擎： 实现个性化推荐算法。

数据存储

用户信息数据库： 存储用户账号信息、个人信息。
商品数据库： 存储商品信息、库存等。
订单数据库： 记录用户订单信息和支付状态。
推荐数据： 存储个性化推荐所需的用户行为数据

3.1.3 E-R图

(2)把 E-R 图转换为关系模式;

3.2 关系模式

下划线为主键，括号为联合主键

用户表：用户编号，用户名，密码，邮箱，用户类型，注册日期，vip过期日期
地址表：地址编号，收货人，电话，省份，城市，区号，详细地址
购物车记录表：购物车记录编号，(用户编号，商品编号)，数量
商品表：商品编号，商品名称，商品售价，批发价格，商品材质，商品库存，商品图片地址，商品备注
订单表：订单编号，用户编号，订单总价格，订单日期，订单状态，订单备注，订单地址
订单明细表：订单明细编号，(商品编号，订单编号)，数量，价格，折扣，税率，退货编辑，订单明细备注
商品类别表：类别编号，类别名称，类别备注
vip记录表：记录编号，用户编号，支付日期，支付金额

日志记录表(会使用存储过程实现)

订单信息变更表
用户信息变更表

(3)根据关系规范理论进行数据库的逻辑设计，给出数据库表的设计，数据库表设计格式参照下面:

表 1 学生表(student)

字段名	中文含义	类型	约束	备注
uid	学号	char(6)	主键
Username	姓名	Varchar(255)	not null, unique
password	出生日期	varchar(255)	not null	应经过md5加密
usertype	专业	int	Check(0,1,2)	普通用户0 vip用户1 管理员2
regdate	注册日期	datetime	not null	注册日期，默认当前
expirationdate	vip过期日期	datetime	null	仅对vip用户有效

3.3 数据库设计

表 1 用户表(users)

字段名	中文含义	类型	约束	备注
uid	学号	char(6)	主键
Username	姓名	Varchar(255)	not null, unique
password	出生日期	varchar(255)	not null	应经过md5加密
usertype	专业	int	Check(0,1,2)	普通用户0 vip用户1 管理员2
regdate	注册日期	datetime	not null	注册日期，默认当前
expirationdate	vip过期日期	datetime	null	仅对vip用户有效

表 2 地址表(address)

字段名	中文含义	类型	约束	备注
Aid	地址编号	int	主键
uid	用户编号	int	FOREIGN KEY	参考表users(did)
name	收货人姓名	Varchar(255)	not null
Tel	电话	varchar(255)	not null
Province	省份	varchar(255)	not null
City	城市	varchar(255)	not null
county	地区	varchar(255)	not null
Detail	详细地址	varchar(255)	not null
Comment	备注	varchar(255)	Null

表 3 购物车记录表(shopcar)

字段名	中文含义	类型	约束	备注
scid	地址编号	int	主键
uid	用户编号	int	FOREIGN KEY	参考表users(did)
iid	商品编号	Varchar(255)	FOREIGN KEY	参考表items(iid)
quantity	数量		not null	默认为1

表 4 商品表(items)

字段名	中文含义	类型	约束	备注
iid	商品编号	int	主键
name	商品名	varchar(255)	not null
price	商品售价	decimal(8,2)	not null
wholesale	商品进价	decimal(8,2)	not null
material	商品材质	varchar(255)	null
comment	商品备注	varchar(255)	null
img	商品url	varchar(255)	null	后端开发时需要此字段

表 5 订单表(orders)

字段名	中文含义	类型	约束	备注
oid	订单编号	int	主键
uid	用户编号	int	FOREIGN KEY	参考表users(uid)
orderdate	订单日期	datetime	not null	默认当前
aid	地址编号	int	FOREIGN KEY	参考表address(aid)
totalprice	总价格	decimal(8,2)	null
status	订单状态	int	Check(0,1,2)	已提交0 已支付1 已完成2
comment	备注	varchar(255)	Null

表 6 订单明细表(orderitems)

字段名	中文含义	类型	约束	备注
oid	订单编号	int	主键
uid	用户编号	int	FOREIGN KEY	参考表users(uid)
orderdate	订单日期	datetime	not null	默认当前
aid	地址编号	int	FOREIGN KEY	参考表address(aid)
totalprice	总价格	decimal(8,2)	null
status	订单状态	int	Check(0,1,2)	已提交0 已支付1 已发货2 已完成3
comment	备注	varchar(255)	Null

表 7 商品类别表(itemclass)

字段名	中文含义	类型	约束
cid	类别编号	int	主键
classname	类别名称	varchar(255)	not null,unique
comment	备注	varchar(255)	null

表 8 vip记录表(vippayment)

字段名	中文含义	类型	约束	备注
vpid	vip记录编号	int	主键
uid	用户编号类别名称	intvarchar(255)	FOREIGN KEY	参考表users(uid)
paydate	支付日期	datetime	not null	默认当前
payprice	支付价格	decimal(8,2)	not null
comment	备注	varchar(255)	null

表 9 商品分类表(icsmapping)

字段名	中文含义	类型	约束	备注
icid	分类映射id	int	主键
iid	商品编号	Varchar(255)	FOREIGN KEY	参考表items(iid)
cid	类别编号	int	FOREIGN KEY	参考表itemclass(cid)

表 10 订单信息变更表(icsmapping)

字段名	中文含义	类型	约束	备注
loid	记录编号	int	主键
oid	订单编号	int	not null	不能用外键约束，如果使用会触发订单删除异常
logtime	记录时间	int	datetime	默认当前
comment	详细信息	varchar(255)	null

表 11 用户信息变更表(icsmapping)

字段名	中文含义	类型	约束	备注
luid	记录编号	int	主键
uid	用户编号	int	not null	不能用外键约束，如果使用会触发用户删除异常
logtime	记录时间	int	datetime	默认当前
type	操作类型	int	check(0,1,2)	0,1,2 分别对应用户的新增删除和修改
comment	详细信息	varchar(255)	null

(4)对给定的逻辑数据模型选取一个最适合应用环境的物理结构，进行数据库的物理设计，考虑不同的 DBMS 选型，进行设计方案对比，对物理结构进行评价，评价的重点是时间和空间效率;

3.4 物理设计评价

数据库的物理设计：

①本实验中，对于网状、层次数据模型来看，首先选择关系数据模型作为基石，其具有以下优势：

1、容易理解：二维表结构是非常贴近逻辑世界一个概念，关系模型相对网状、层次等其他模型来说更容易理解；

2、使用方便：通用的SQL语言使得操作关系型数据库非常方便，其他模型的学习使用成本相对较高；

3、易于维护：丰富的完整性(实体完整性、参照完整性和用户定义的完整性)大大减低了数据冗余和数据不一致的概率；

4、支持SQL，可用于复杂的查询；

②关系模式中存取方式的选择：B+树索引存取方法

常用存取方式有B+树索引存取方法、Hash索引存取方法，下面进行两种方法的对比：

1、B+树索引存取方法：

选择索引存取方法的一般规则有：

如果一个(或一组)属性经常在查询条件中出现，则考虑在这个(或这组)属性上建立索引(或组合索引)。

如果一个属性经常作为最大值或最小值等聚集函数的参数，则考虑在这个属性上建立索引。

如果一个(或一组)属性经常在连接操作的连接条件中出现，则考虑在这个(或这组)属性上建立索引。

2、Hash索引存取方法：

选择Hash存取方法的一般规则有：

如果一个关系的属性主要出现在等值连接条件中或相等比较选择条件中，并且满足下列两个条件之一时，则此关系可以选择HASH存取方法。

一个关系的大小可预知，并且不变；

该关系的大小动态变化，但所选用的数据库管理系统提供了动态Hash存取方法。

两者对比如下：

1）Hash索引只包含哈希值和行指针,而不存储字段值,所以不能使用索引中的值来避免读取行。

2）Hash索引中存放的是经过Hash计算之后的Hash值，不是按照索引值顺序存储的，而且Hash值的大小关系并不一定和Hash运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算。B+tree 索引的叶子节点形成有序链表，可用于排序。

3）Hash索引只有精确匹配索引所有列的查询才有效，不支持部分索引列匹配查找，所以其无法做 like‘xxx%’这样的部分模糊查询，因为需要对完整 key 做 Hash 计算，定位bucket。而 B+tree 索引具有最左前缀匹配，可以进行部分模糊查询。

4）Hash 索引只支持等值比较查询（包括=、in0、<=>）、无法索成范围查询检索，而B+tree索引的叶子节点形成有序链表，便于范围查询。

5）因为存在Hash碰撞问题，在有大量重复键值情况下，Hash索引的效率极低，索引维护操作的代价也会很高。B+tree 所有查询都要找到叶子节点，性能稳定。

对于专业建设管理系统来说，需要经常对学号、工号等查询得到学生、教师信息，存在大量组合查询，范围查询、排序、分组、模糊查询等查询特征，Hash 索引无法满足要求，所以选择B+树索引存取方法。

③DBMS的选择：MySQL数据库

常见的关系数据库有MySQL数据库、Microsoft SQL Server数据库、Oracle数据库、Postgresql数据库、Sybase数据库、DB2数据库、Access数据库等，我选择MySQL数据库与Oracle数据库进行对比：

特性	MySQL	Oracle	SQL Server
开发公司	Oracle Corporation	Oracle Corporation	Microsoft Corporation
数据类型	支持多种数据类型，但相较 Oracle 较少	支持丰富的数据类型	支持丰富的数据类型
存储过程和触发器	支持存储过程和触发器	支持存储过程和触发器	支持存储过程和触发器
支持的编程语言	支持多种编程语言，如SQL、Python、C++等	支持 PL/SQL（过程化SQL）	支持 T-SQL（Transact-SQL）
开源/商业	开源	商业	商业
跨平台	支持多个平台，包括 Windows、Linux、macOS等	支持多个平台	仅限于 Windows 和 Linux
分区表	支持	支持	支持
执行计划优化	依赖于存储引擎（如 InnoDB）	使用 Cost-Based Optimizer（CBO）	使用查询优化器（Query Optimizer）
备份和恢复	支持	支持	支持
事务管理	支持	支持	支持
数据复制	支持主从复制和集群复制	支持主从复制和多节点复制	支持主从复制和 Always On 可用性组
视图和索引	支持	支持	支持
安全性	支持基于角色的访问控制	支持 RBAC（基于角色的访问控制）	支持基于角色的访问控制

1、MySQL操作简单、部署方便，用户可以根据应用的需求去定制数据库，而Oracle学习和使用难度较大，学习成本高；

2、Oracle获得最高认证级别的ISO标准认证，而MySQL的安全性较差；

3、MySQL和Oracle的写入性能差别比较小；

4、索引会极大降低Oracle的写入性能，对MySQL写入性能影响极小，同数据量下，可能MySQL的索引会快一点。

经过对时间、空间利用率等因素的综合考量，我选择MySQL数据库，版本选用8.0.32。

mysql Ver 8.0.32 for macos13 on arm64 (MySQL Community Server - GPL)

(5)在 My SQL 数据库中创建数据库并使用 SQL 语句创建相应的数据库表;

3.5 数据库和表的创建

用户表：用户编号，用户名，密码，邮箱，用户类型，注册日期，vip过期日期

CREATE TABLE `users`
(
 `uid` int NOT NULL AUTO_INCREMENT,
 `username` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin NOT NULL,
 `password` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin NOT NULL,
 `email` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin NOT NULL,
 `usertype` int DEFAULT '0',
 `regdate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
 `expirationdate` datetime DEFAULT NULL,
 PRIMARY KEY (`uid`),
 UNIQUE KEY `username` (`username`),
 UNIQUE KEY `password` (`password`),
 CONSTRAINT `users_chk_1` CHECK ((`usertype` IN (0, 1, 2)))
) ENGINE = InnoDB
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

地址表：地址编号，收货人，电话，省份，城市，区号，详细地址

CREATE TABLE `address`
(
 `aid` int NOT NULL AUTO_INCREMENT,
 `uid` int NOT NULL,
 `name` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `tel` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `province` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `city` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `county` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `detail` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `comment` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 PRIMARY KEY (`aid`),
 KEY `fk_address_uid` (`uid`),
 CONSTRAINT `fk_address_uid` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`)
) ENGINE = InnoDB
 AUTO_INCREMENT = 9
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

购物车记录表：购物车记录编号，(用户编号，商品编号)，数量

CREATE TABLE `shopcar`
(
 `scid` int NOT NULL AUTO_INCREMENT,
 `uid` int NOT NULL,
 `iid` int NOT NULL,
 `quantity` int DEFAULT NULL,
 PRIMARY KEY (`scid`),
 KEY `fk_shopcar_iid` (`iid`),
 KEY `fk_shopcar_uid` (`uid`),
 CONSTRAINT `fk_shopcar_iid` FOREIGN KEY (`iid`) REFERENCES `items` (`iid`),
 CONSTRAINT `fk_shopcar_uid` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`)
) ENGINE = InnoDB
 AUTO_INCREMENT = 12
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

商品表：商品编号，商品名称，商品价格，商品材质，商品库存，商品图片地址，商品备注

CREATE TABLE `items`
(
 `iid` int NOT NULL AUTO_INCREMENT,
 `name` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin NOT NULL,
 `price` decimal(8, 2) NOT NULL,
 `material` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `quantity` int NOT NULL,
 `comment` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `img` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL, -- 图片url地址
 PRIMARY KEY (`iid`)
) ENGINE = InnoDB
 AUTO_INCREMENT = 58
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

订单表：订单编号，用户编号，订单总价格，订单日期，订单状态，订单备注，订单地址

CREATE TABLE `orders`
(
 `oid` int NOT NULL AUTO_INCREMENT,
 `uid` int NOT NULL,
 `orderdate` datetime NOT NULL,
 `comment` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `aid` int NOT NULL,
 `totalprice` decimal(8, 2) DEFAULT NULL,
 `status` int DEFAULT NULL,
 PRIMARY KEY (`oid`),
 KEY `fk_orders_uid` (`uid`),
 KEY `fk_order_aid` (`aid`),
 CONSTRAINT `fk_order_aid` FOREIGN KEY (`aid`) REFERENCES `address` (`aid`),
 CONSTRAINT `fk_orders_uid` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`),
 CONSTRAINT `orders_chk_1` CHECK ((`totalprice` >= 0)),
 CONSTRAINT `orders_chk_2` CHECK ((`status` IN (0, 1, 2, 3)))
) ENGINE = InnoDB
 AUTO_INCREMENT = 19
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

订单明细表：订单明细编号，(商品编号，订单编号)，数量，价格，折扣，税率，退货编辑，订单明细备注

CREATE TABLE orderitems
(
 oiid int PRIMARY KEY AUTO_INCREMENT,
 iid int NOT NULL, -- 物品号
 oid int NOT NULL, -- 此物品属于的订单号
 quantity int,
 extendprice decimal(8, 2), -- 此订单中此物品的价格
 discount decimal(3, 2), -- 折扣, 针对vip来说
 tax decimal(3, 2), -- 税率
 returnflag int CHECK ( returnflag IN (0, 1)) DEFAULT 0, -- 退货标记
 comment varchar(255),
 CONSTRAINT fk_orderitems_iid FOREIGN KEY (iid) REFERENCES items (iid),
 CONSTRAINT fk_orderitems_oid FOREIGN KEY (oid) REFERENCES orders (oid)
);

商品类别表：类别编号，类别名称，类别备注

CREATE TABLE `itemclass`
(
 `cid` int NOT NULL AUTO_INCREMENT,
 `classname` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 `comment` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_bin DEFAULT NULL,
 PRIMARY KEY (`cid`)
) ENGINE = InnoDB
 AUTO_INCREMENT = 5
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

vip记录表：记录编号，用户编号，支付日期，支付金额

CREATE TABLE `vippayment`
(
 `vpid` int NOT NULL AUTO_INCREMENT,
 `uid` int NOT NULL,
 `paydate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
 `payprice` decimal(8, 2) DEFAULT NULL,
 PRIMARY KEY (`vpid`),
 KEY `fk_vippayment_uid` (`uid`),
 CONSTRAINT `fk_vippayment_uid` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`)
) ENGINE = InnoDB
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

商品分类表

CREATE TABLE `icsmapping`
(
 `icid` int NOT NULL AUTO_INCREMENT,
 `iid` int NOT NULL,
 `cid` int NOT NULL,
 PRIMARY KEY (`icid`),
 UNIQUE KEY `uq_iid_cid` (`iid`, `cid`),
 KEY `fk_itemclass_cid` (`cid`),
 CONSTRAINT `fk_item_iid` FOREIGN KEY (`iid`) REFERENCES `items` (`iid`),
 CONSTRAINT `fk_itemclass_cid` FOREIGN KEY (`cid`) REFERENCES `itemclass` (`cid`)
) ENGINE = InnoDB
 AUTO_INCREMENT = 16
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

订单信息变更表

CREATE TABLE `log_orders`
(
 `loid` int NOT NULL AUTO_INCREMENT,
 `logtime` datetime NOT NULL,
 `comment` varchar(255) COLLATE utf8mb3_bin DEFAULT NULL,
 `oid` int NOT NULL,
 PRIMARY KEY (`loid`)
) ENGINE = InnoDB
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

用户信息变更表

CREATE TABLE `log_users`
(
 `luid` int NOT NULL AUTO_INCREMENT,
 `logtime` datetime NOT NULL,
 `uid` int NOT NULL,
 `type` int DEFAULT NULL,
 `comment` varchar(255) COLLATE utf8mb3_bin DEFAULT NULL,
 PRIMARY KEY (`luid`),
 CONSTRAINT `log_users_chk_1` CHECK ((`type` IN (0, 1, 2)))
) ENGINE = InnoDB
 AUTO_INCREMENT = 8
 DEFAULT CHARSET = utf8mb3
 COLLATE = utf8mb3_bin;

(6)通过导入文件的方式在数据库表中输入若干条测试数据，也可以直接插入若干条测试数据;

3.6 测试数据生成

在数据生成时我使用java中的mybatis操作数据库，配合java中的编程语句进行数据的生成，同时也使用了一些update和存储过程语句，生成商品进价和售价，折扣和税率等信息，sql语句，java代码如下

# 假设税率 tax位于3% - 10%, 对每笔订单明细随机生成tax,
DROP PROCEDURE updateTaxRandom;
DELIMITER //
CREATE PROCEDURE updateTaxRandom()
BEGIN
 DECLARE done INT DEFAULT FALSE;
 DECLARE row_id INT;
 DECLARE random_tax DECIMAL(5, 2);
 -- 定义一个游标，选择所有的行
 DECLARE cur CURSOR FOR SELECT oiid, tax FROM orderitems;
 -- 设置终止条件
 DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
 OPEN cur;
 read_loop:
 LOOP
 -- 读取下一行
 FETCH cur INTO row_id, random_tax;
 IF done THEN
 LEAVE read_loop;
 END IF;
 -- 更新每行的 tax 为随机3-10的小数
 UPDATE orderitems SET tax = ROUND(3 + RAND() * (10 - 3), 2) WHERE oiid = row_id;
 END LOOP;
 CLOSE cur;
END //
DELIMITER ;

CALL updateTaxRandom();

UPDATE items SET price = price + 20;

UPDATE orderitems,items
SET extendprice = price * (1 + tax / 100) * (discount / 10)
WHERE orderitems.iid = items.iid
 AND discount <> 0;

UPDATE orderitems,items
SET extendprice = price * (1 + tax / 100)
WHERE orderitems.iid = items.iid
 AND discount = 0;

@SpringBootTest
class SqlexamApplicationTests {

 public static int getIntegerBetween(int v1, int v2) {
 // 生成位于 v1 和 v2 之间的随机整数
 int minValue = Math.min(v1, v2);
 int maxValue = Math.max(v1, v2);
 return (int) (Math.random() * (maxValue - minValue + 1) + minValue);
 }

 @Autowired
 private UserMapper userMapper;

 @Autowired
 private ItemMapper itemMapper;

 @Test
 void contextLoads() {
 List<User> users = userMapper.getUsers();
 System.out.println(users);
 }

 @Test
 void insertUser() {
 int n = 3;
 for (int i = 0; i < n; i++) {
 User user = new User();
 user.setUsername("user" + i);
 user.setPassword("userpass" + i);
 user.setEmail("user" + i + "@sql.com");
 user.setRegdate(LocalDateTime.now().toString());
 user.setUsertype(0);
 user.setExpirationdate(null);

 userMapper.insertUser(
 user.getUsername(),
 user.getPassword(),
 user.getEmail(),
 user.getUsertype(),
 user.getRegdate(),
 user.getExpirationdate()
 );
 }
 }

 @Test
 void insertItem() {
 int n = 20;
 for (int i = 0; i < n; i++) {
 Item item = new Item();
 item.setName("name" + i);
 item.setPrice(String.valueOf(getIntegerBetween(10, 200)));
 item.setQuantity(getIntegerBetween(20, 50));
 item.setComment("comment" + i);
 item.setImg("img" + i);

 itemMapper.insertItem(item.getName(), item.getPrice(), item.getQuantity(), item.getComment(), item.getImg());
 }
 }

 @Test
 void insertAddress() {
 int n = 20;
 for (int i = 0; i < n; i++) {
 Address address = new Address();
 address.setUid(getIntegerBetween(1, 6));
 address.setName("收货人" + i);
 address.setTel(generatePhoneNumber());
 address.setProvince("province" + i + i);
 address.setCity("city" + i);
 address.setCounty("county" + i);
 address.setDetail("detail" + i);
 address.setComment("comment" + i + i + i);

 userMapper.insertAddress(address);
 }
 }

 @Test
 void insertOrder() {
 int n = 50;
 for (int i = 0; i < n; i++) {
 Order order = new Order();
 int uid = getIntegerBetween(1, 6);
 List<Address> addressByUid = userMapper.getAddressByUid(uid);
 Address address = addressByUid.get(getIntegerBetween(0, addressByUid.size() - 1));
 int aid = address.getAid();

 order.setUid(uid);
 order.setAid(aid);
 order.setOrderdate(generateDateBetweenYears(2022,2023));
 order.setStatus(getIntegerBetween(0, 2));
 order.setComment("comment" + uid + aid);

 userMapper.insertOrder(order);
 }
 }

 @Test
 void insertOrderItems(){
 // item 20 orders 50
 int n = 150;
 int itemIndex = 1;
 int orderIndex = 1;
 for (int i = 0; i < n; i++) {
 itemIndex = itemIndex % 20 + 1;
 orderIndex = orderIndex % 50 + 1;
 Orderitem orderitem = new Orderitem();
 orderitem.setIid(itemIndex);
 orderitem.setOid(orderIndex);
 orderitem.setReturnflag(0); // 默认不退货
 orderitem.setQuantity(getIntegerBetween(1,3));
 orderitem.setComment("comment" + orderIndex + itemIndex);
 userMapper.insertOrderitem(orderitem);
 itemIndex++;
 orderIndex++;
 }
 }

 @Test
 void testJAVASE(){
 int a = 21;
 a %= 21;
 System.out.println(a);
 }


 public static LocalDateTime generateDateBetweenYears(int year1, int year2) {
 // 获取指定年份的第一秒
 LocalDateTime startDateTime = LocalDateTime.of(year1, 1, 1, 0, 0, 0);
 // 获取指定年份的最后一秒
 LocalDateTime endDateTime = LocalDateTime.of(year2, 12, 31, 23, 59, 59);
 // 生成介于两个年份之间的随机秒数
 long randomSecond = ThreadLocalRandom.current().nextLong(
 startDateTime.toEpochSecond(ZoneOffset.UTC),
 endDateTime.toEpochSecond(ZoneOffset.UTC)
 );
 // 构建最终的LocalDateTime
 return LocalDateTime.ofEpochSecond(randomSecond, 0, ZoneOffset.UTC);
 }

 public static String generatePhoneNumber() {
 Random random = new Random();
 StringBuilder phoneNumber = new StringBuilder("1"); // 国内手机号以1开头
 for (int i = 0; i < 10; i++) {
 phoneNumber.append(random.nextInt(10));
 }
 return phoneNumber.toString();
 }

}

(7)自行设计若干问题并编写 SQL 语句完成对所提问题的实现，SQL 语句要求至少 12 条，自定义功能要求，并对SQL语句运行，要求包括下面的语句:

create table(要求包含实体完整性、参照完整性和用户自定义完整性的定义)、create index、 create view、 select 语句 (至少 5 条，要求把 from、where、group by、having、order by 等子句用上，并实现多表查询)、insert、 delete、update、grant、revoke 语句

3.7 问题设计与SQL实现

3.7.1 create table语句

创建表orders1定义实体完整性、参照完整性和用户自定义完整性，要求orderdate不为空，uid和aid分别参考users中uid和address中aid，status必须在0，1，2间取值。

CREATE TABLE orders1
(
 oid int PRIMARY KEY AUTO_INCREMENT,
 uid int NOT NULL,
 totalprice decimal(8, 2),
 orderdate datetime NOT NULL,
 comment varchar(255),
 aid int NOT NULL,
 status int CHECK ( status IN (0, 1, 2)),
 CONSTRAINT fk_order1_uid FOREIGN KEY (uid) REFERENCES users (uid),
 CONSTRAINT fk_order1_aid FOREIGN KEY (aid) REFERENCES address (aid)
);
DESC orders1;

3.7.2 create index语句

为订单orders编织索引，加快查询速度，先按照uid生序，在按照aid降序。

CREATE INDEX orders_index ON orders (uid ASC, aid DESC);

3.7.3 create view 语句

创建一个视图，通过多表联查，显示用户购买的所有商品信息。

CREATE OR REPLACE VIEW userbuys AS
SELECT DISTINCT users.uid '用户编号',
 username '用户名',
 extendprice '价格',
 items.name '商品名',
 orderitems.quantity '数量',
 orderdate '日期',
 detail '详细地址'
FROM users,
 orders,
 orderitems,
 items,
 address
WHERE orders.uid = users.uid
 AND orders.oid = orderitems.oid
 AND orders.aid = address.aid
 AND orderitems.iid = items.iid;

SELECT *
FROM userbuys;

select结果截图均在 3.8 SELECT语句截图 中

管理员根据销售量统计商品销售情况

-- 查询销售额最大的商品
CREATE VIEW maxSale AS
SELECT items.iid AS '商品编号',
 name AS '商品名',
 items.wholesale AS '商品进价',
 price AS '商品售价',
 SUM(orderitems.quantity) AS '本单数量',
 SUM(price - orderitems.extendprice) AS '本单利润'
FROM orderitems,
 items
WHERE orderitems.iid = items.iid
GROUP BY items.iid
ORDER BY SUM(orderitems.quantity) DESC;

查询视图

SELECT * FROM maxSale;

结果如下

管理员根据销售利润统计商品销售情况

CREATE VIEW maxProfit AS
SELECT items.iid AS '商品编号',
 name AS '商品名',
 items.wholesale AS '商品进价',
 price AS '商品售价',
 SUM(orderitems.quantity) AS '本单数量',
 SUM(price - orderitems.extendprice) AS '本单利润'
FROM orderitems,
 items
WHERE orderitems.iid = items.iid
GROUP BY items.iid
ORDER BY sum(price - orderitems.extendprice) DESC;

查询视图

SELECT * FROM maxProfit;

结果如下

可以看到，name3商品销量和利润最高，故管理者应该多放置name3商品来获取更多利润

3.7.4 select 语句

查询用户和对应的地址信息

# 查询用户和对应的地址信息
SELECT users.uid AS '用户编号',
 username AS '用户名',
 users.regdate AS '注册日期',
 name AS '收货人姓名',
 province AS '省份',
 city AS '城市',
 county AS '区域',
 detail AS '详细'
FROM users,
 address
WHERE address.uid = users.uid;

查询已完成(status = 2)订单和其详细信息

# 查询已完成(status = 2)订单和其详细信息
SELECT orders.oid '订单编号',
 name '商品名',
 orderitems.quantity '购买数量',
 price '商品原价',
 extendprice '购买价格',
 orderdate '订单日期'
FROM orders,
 orderitems,
 items
WHERE orders.oid = orderitems.oid
 AND orderitems.iid = items.iid
 AND orders.status = 2;

查询每个用户的购买总金额

SELECT users.uid AS '用户编号',
 username AS '用户名',
 CASE users.usertype
 WHEN 0 THEN '普通用户'
 WHEN 1 THEN 'VIP用户'
 ELSE '管理员'
 END AS '用户类型',
 SUM(extendprice) AS '累计花费'
FROM users,
 orders,
 orderitems
WHERE orders.uid = users.uid
 AND orders.oid = orderitems.oid
GROUP BY users.uid
ORDER BY SUM(extendprice) DESC;

3.7.5 insert语句

新增订单信息，验证完整性约束是否起作用。

正确新增

INSERT INTO orders
VALUES (NULL, 1, now(), 'comment-new1', 15, NULL, 0);

错误新增1，uid不满足外键约束

INSERT INTO orders
VALUES (NULL, 999, now(), 'comment-new2', 15, NULL, 0);

错误新增2，status不满足用户自定义约束

INSERT INTO orders
VALUES (NULL, 1, NOW(), 'comment-new3', 15, NULL, 4);

3.7.5 delete语句

删除关于用户admin的所有日志记录

首先查询关于admin的日期记录

SELECT *
FROM log_users,
 users
WHERE users.uid = log_users.uid
 AND username = 'admin';

结果

删除语句

DELETE
FROM log_users
WHERE uid = (SELECT uid FROM users WHERE username = 'admin');

删除后

3.7.5 update语句

更新vip用户的所有订单明细中的折扣discount为7.5%，其余用户为0

首先查看所有vip用户的所有订单明细

SELECT *
FROM orderitems
WHERE oid IN (SELECT oid FROM orders WHERE uid IN (SELECT uid FROM users WHERE usertype = 1));

结果如下

更新discount

UPDATE orderitems
SET discount = 7.50
WHERE oid IN (SELECT oid FROM orders WHERE uid IN (SELECT uid FROM users WHERE usertype = 1));
UPDATE orderitems
SET discount = 0
WHERE oid IN (SELECT oid FROM orders WHERE uid IN (SELECT uid FROM users WHERE usertype IN (0,2)));

再次查询结果如下

更新所有订单明细的extendprice字段，公式为 extendprice = (items.pirce * (1 + tax/100) * (1 - discount/100))

UPDATE orderitems,items
SET extendprice = price * (1 + tax / 100) * (1 - discount / 100)
WHERE orderitems.iid = items.iid;

SELECT *
FROM orderitems;

更新后的结果为

更新所有订单的totalprice字段, 公式为 totalprice = sum(orderitems.extendprice)

UPDATE orders,orderitems
SET totalprice = (SELECT SUM(extendprice) FROM orderitems WHERE orders.oid = orderitems.oid)
WHERE orders.oid = orderitems.oid;

SELECT *
FROM orders;

更新后的结果为

3.7.5 grant语句

创建一个专门管理用户相关信息的管理员角色, 拥有对users, address, vippayment表的新增,修改和查看

CREATE ROLE 'admin_user';
GRANT SELECT,UPDATE,INSERT ON TABLE users TO 'admin_user';
GRANT SELECT,UPDATE,INSERT ON TABLE address TO 'admin_user';
GRANT SELECT,UPDATE,INSERT ON TABLE vippayment TO 'admin_user';

3.7.5 revoke语句

为了防止权限滥用，收回管理员角色的update和insert权限

REVOKE UPDATE, INSERT ON TABLE users FROM 'admin_user';
REVOKE UPDATE, INSERT ON TABLE address FROM 'admin_user';
REVOKE UPDATE, INSERT ON TABLE vippayment FROM 'admin_user';

(8)对于 select 语句，需要给出相应的数据查询结果的截图。

3.8 SELECT语句截图

全部select语句结果都在3.7中给出

(9)对自定义的复杂的查询要求或复杂报表生成要求，以及复杂的自定义完整性要求，使用存储过程和触发器来实现，并进行实验验证，给出验证结果截图。

3.9 存储过程与触发器

3.9.1 存储过程设计

存储过程-用户支付成为vip

业务流程:

声明变量： 声明用于存储目标用户ID、目标用户类型等信息的变量。
获取目标用户ID： 根据传入的用户名获取目标用户ID。
检查用户是否存在： 检查目标用户是否存在。
获取用户类型： 获取目标用户当前的用户类型。
检查用户是否已经是VIP： 如果目标用户已经是VIP，返回相应信息。
更新用户信息： 如果目标用户不是VIP，更新用户的到期日期和用户类型，并插入VIP支付记录。
用户不存在处理： 如果目标用户不存在，返回相应信息。

DELIMITER $$ -- 作用，username用户支付费用成为vip
DROP PROCEDURE IF EXISTS tovip;
CREATE PROCEDURE tovip(IN destuser varchar(255), IN payprice decimal(8, 2), IN expirdate datetime)
BEGIN
 DECLARE destuid int DEFAULT NULL; -- 目标用户是否存在
 DECLARE destusertype int DEFAULT NULL; -- 用户是否已经是vip
 SELECT uid INTO destuid FROM users WHERE username = destuser;
 IF destuid IS NOT NULL
 THEN
 SELECT usertype INTO destusertype FROM users WHERE uid = destuid;
 IF destusertype = 1 THEN
 SELECT 'USER IS VIP!'; -- 用户已经是VIP
 ELSE
 UPDATE users SET expirationdate = expirdate, usertype = 1 WHERE username = destuser;
 INSERT INTO vippayment VALUES (NULL, destuid, now(), payprice);
 END IF;
 ELSE
 SELECT 'USER NOT EXIST!'; -- 用户不存在
 END IF;
END $$;

存储过程测试

CALL tovip('zhangsan', 100.00, DATE_ADD(CURDATE(), INTERVAL 1 YEAR));

此时zhangsan已经是vip，返回对应的信息。

之后我们重置用户zhangsan的usertype字段为0，再次运行触发器。

可以看到，zhangsan已经被设为vip，并且过期日期为明年此时。

存储过程-用户下单

业务流程:

用户下单，如果是多个物品，则一定来自于购物车
声明变量： 声明用于存储商品ID、商品数量、新订单ID、用户折扣等信息的变量。
错误处理： 设置一个错误处理程序，以便在发生错误时能够关闭游标。
开启游标： 打开用于遍历购物车的游标。
生成订单： 创建一个新的订单，并获取新订单的ID。
判断用户折扣： 根据用户类型判断是否给予折扣。
遍历购物车： 使用循环遍历购物车中的商品。
检查商品库存： 检查商品库存是否足够。
生成订单明细： 为订单添加商品明细。
删除购物车商品： 从购物车中删除已生成订单的商品。
更新商品库存： 减少商品库存。
结束循环： 结束购物车遍历循环。

具体sql语句如下

DELIMITER $$
DROP PROCEDURE IF EXISTS makeOrderFromShopCar;
CREATE PROCEDURE IF NOT EXISTS makeOrderFromShopCar(IN destuid int, IN destaid int)
BEGIN
 DECLARE destiid int DEFAULT NULL;
 DECLARE destquantity int DEFAULT NULL;
 DECLARE newoid int DEFAULT NULL;
 DECLARE destdiscount decimal(3, 2) DEFAULT 0.0;
 DECLARE destusertype int DEFAULT 0;
 DECLARE cur CURSOR FOR SELECT iid, quantity FROM shopcar WHERE uid = destuid;
 -- 定义错误处理
 DECLARE EXIT HANDLER FOR SQLSTATE '02000' CLOSE cur;
 -- 开启游标
 OPEN cur;
 -- 创建一个order存储所有orderitems
 SELECT (MAX(oid) + 1) INTO newoid FROM orders;
 INSERT INTO orders VALUES (newoid, destuid, now(), NULL, destaid, NULL, 0);
 -- 判断用户类型, 是否给予折扣
 SELECT usertype INTO destusertype FROM users WHERE uid = destuid;
 IF destusertype <> 0 THEN
 SELECT 7.5 INTO destdiscount;
 END IF;
 -- 进入循环, 遍历购物车, 生成订单明细, 删除购物车内商品, 商品对应库存减少
 loop1:
 LOOP
 -- 遍历购物车
 FETCH cur INTO destiid,destquantity;
 -- 判断商品库存是否充足
 IF destquantity <= (SELECT quantity FROM items WHERE iid = destiid) THEN
 -- 生成订单明细
 INSERT INTO orderitems
 VALUES (NULL, destiid, newoid, destquantity, NULL, destdiscount, 4.5, 0,
 concat('comment', destiid, newoid));
 -- 删除购物车内商品
 DELETE FROM shopcar WHERE uid = destuid AND iid = destiid;
 -- 商品对应库存减少
 UPDATE items SET quantity = quantity - destquantity WHERE iid = destiid;
 ELSE
 SELECT 'ITEMS QUANTITY IS NOT ENOUGH!';
 -- error
 SIGNAL SQLSTATE '45000'
 SET MESSAGE_TEXT = 'ITEMS QUANTITY IS NOT ENOUGH!';
 END IF;
 END LOOP;
END $$

存储过程测试

CALL makeOrderFromShopCar(2, 10);

用户zhangsan的购物车中的物品和数量如下

张三的信息如下，是vip用户，故应有折扣

原items中商品的库存信息如下

执行存储过程之后的结果

商品库存正确的被减少

购物车物品成功被删除

orders成功新增一条订单记录

orderitems成功新增三条记录

3.9.2 触发器设计

触发器-记录用户信息的变更

在log_users表，记录关于用户操作的一些信息，其中type表示标识了本次操作类型，0新增，1删除，2更新。

新增用户触发器

DROP TRIGGER IF EXISTS trigger_log_users_insert;
CREATE TRIGGER IF NOT EXISTS trigger_log_users -- after 触发器
 AFTER INSERT
 ON users
 FOR EACH ROW
BEGIN
 INSERT INTO log_users
 VALUES (NULL, now(), NEW.uid, 0,
 concat_ws('', 'INSERT USER INFO (', NEW.username, ',', NEW.email, ')'));
END;

删除用户触发器

DROP TRIGGER IF EXISTS trigger_log_users_delete;
CREATE TRIGGER IF NOT EXISTS trigger_log_users_delete -- after 触发器
 AFTER DELETE
 ON users
 FOR EACH ROW
BEGIN
 INSERT INTO log_users
 VALUES (NULL, now(), OLD.uid, 1,
 concat_ws(',', 'DELETE USER INFO (', OLD.username, OLD.email, ')'));
END;

更新用户触发器

DROP TRIGGER IF EXISTS trigger_log_users_update;
CREATE TRIGGER IF NOT EXISTS trigger_log_users_update -- after 触发器
 AFTER UPDATE
 ON users
 FOR EACH ROW
BEGIN
 INSERT INTO log_users
 VALUES (NULL, now(), NEW.uid, 2,
 concat(',', 'UPDATE USER INFO ( email OLD:', OLD.email, ', NEW:', NEW.email, ' | ', 'password OLD:',
 OLD.password, ', NEW:', NEW.password, ')'));
END;

触发器测试

新增用户触发器测试

INSERT INTO users
VALUES (NULL, 'zhangsan11', 'zhang12113', 'zhang@qq.com',0,now(),NULL);

更新用户触发器测试

UPDATE users
SET password = '1111'
WHERE username = 'zhangsan11';

结果如下

触发器- 商品库存随订单支付而减少

此触发器和用户下单存储过程有相似之处，当orderitems有项目新增时，此时证明订单已经被提交, 此时需要修改商品库存。

CREATE TRIGGER IF NOT EXISTS updateItemQuantity
 AFTER INSERT
 ON orderitems
 FOR EACH ROW
BEGIN
 UPDATE items SET quantity = quantity - NEW.quantity WHERE iid = NEW.iid;
END;

触发器测试

为orderitems中的56号订单新增一个iid为7的物品, 数量为3

-- 为orderitems中的56号订单新增一个iid为7的物品, 数量为3
INSERT INTO orderitems VALUES (NULL,7,56,3,NULL,NULL,NULL,0,'comment-trigger');

原物品数量

可以看到新增一条orderitems之后物品数量成功减3

河北工业大学文创

Thu, 26 Oct 2023 00:00:00 +0000

为母校文创搭建的一个小型展览, 耗时三天

Experience

Tue, 24 Oct 2023 00:00:00 +0000