点餐系统-C++实现

最新推荐文章于 2024-08-01 09:34:36 发布
最新推荐文章于 2024-08-01 09:34:36 发布
阅读量5.9k 收藏 73
点赞数 9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43979735/article/details/105387397
版权

整体架构

  1. 服务器
  2. 顾客客户端
  3. 商家客户端

预计实现功能：

  • 顾客扫描餐桌上的二维码进入顾客客户端, 进行点菜
  • 订单提交到服务器上由商家客户端获取到
  • 商家通过商家客户端可以进行订单及菜品的管理

数据库设计

创建数据库
create database if not exists order_system;
use order_system;
创建菜单表

每行记录一个菜品信息， price 单位为分，由商家维护, 由用户浏览

create table if not exists dish_table(dish_id int unsigned not null primary key 
auto_increment,
                               name varchar(50),
                               price int);

插入几个测试数据，可自定义

insert into dish_table values(null, '宫保鸡丁', 1800);
insert into dish_table values(null, '红烧肉', 1800);
insert into dish_table values(null, '土豆丝'，1800）；
创建订单表

每行是一个订单，信息由用户提交，商家进行浏览

create table if not exists order_table(order_id int unsigned not null primary key 
auto_increment,
                               table_id varchar(50),   
                                time varchar(50),       
                               dish_ids varchar(1024),
                               state int);                 // 表示订单状态. 0 表示订单进行中, 
1 表示订单完结
table_id 桌号
time 下单时间, 形如 2019-05-15 12:00
dish_ids 用户点的菜品 id 列表, 为 json 格式字符串, 形如 [1, 2, 3]

插入测试数据

insert into order_table values(null, '1', '2019-05-10 12:00', '[1,2,3]', 1);
insert into order_table values(null, '2', '2019-05-15 13:00', '[1,3]', 0);
使用 MySQL API操作数据库

注意:
MySQL 提供的 API 除了 mysql_real_connect, 其他的都是线程安全的.
创建一个 mysql_test 目录
Makefile 编译选项
// -L /usr/lib64/mysql -lmysqlclient
插入 mysql_insert.cc

#include <cstdio>
#include <cstdlib>
#include <mysql/mysql.h>
int main() {
  // 1. 初始化句柄
  MYSQL* connect_fd = mysql_init(NULL);
  // 2. 建立链接
  // mysql_init 返回的指针
  // 主机地址
  // 用户名
  // 密码
  // 数据库名
  // 端口号
  // unix_socket
  // client_flag
  if (mysql_real_connect(connect_fd, "127.0.0.1", "root", "",
                         "order_system", 3306, NULL, 0) == NULL) {
    printf("连接失败! %s\n", mysql_error(connect_fd));
    return 1;
 }
  // 3. 设置编码格式
  mysql_set_character_set(connect_fd, "utf8");
  // 4. 拼装 SQL 语句
        char sql[1024 * 4] = {0};
  char name[] = "京酱肉丝";
  int price = 2000;
        sprintf(sql, "insert into menu values(null, '%s', %d)", name, price);
  // 5. 执行 SQL 语句
  int ret = mysql_query(connect_fd, sql);
  if (ret < 0) {
    printf("执行 sql 失败! %s\n", mysql_error(connect_fd));
    return 1;
 }
  // 6. 关闭句柄
  mysql_close(connect_fd);
  printf("执行成功!\n");
  return 0; }

查询 mysql_select.cc

#include <cstdio>
#include <cstdlib>
#include <mysql/mysql.h>

int main() {
  // 1. 初始化句柄
  MYSQL* connect_fd = mysql_init(NULL);
  // 2. 建立链接
  // mysql_init 返回的指针
  // 主机地址
  // 用户名
  // 密码
  // 数据库名
  // 端口号
  // unix_socket
  // client_flag
  if (mysql_real_connect(connect_fd, "127.0.0.1", "root", "",
                         "order_system", 3306, NULL, 0) == NULL) {
    printf("连接失败! %s\n", mysql_error(connect_fd));
    return 1;
 }
  // 3. 设置编码格式
  mysql_set_character_set(connect_fd, "utf8");
  // 4. 拼装 SQL 语句
        char sql[1024 * 4] = {0};
  int price = 2000;
        sprintf(sql, "select * from menu");
  // 5. 执行 SQL 语句
  int ret = mysql_query(connect_fd, sql);
  if (ret < 0) {
    printf("执行 sql 失败! %s\n", mysql_error(connect_fd));
    return 1;
 }
  // 6. 遍历查询结果
  MYSQL_RES* result = mysql_store_result(connect_fd);
  if (result == NULL) {
    printf("获取结果失败! %s\n", mysql_error(connect_fd));
    return 1;
 }
  // a) 获取行数和列数
  int rows = mysql_num_rows(result);
  int fields = mysql_num_fields(result);
  printf("rows: %d, fields: %d\n", rows, fields);
  // b) 打印结果
  for (int i; i < rows; ++i) {
    MYSQL_ROW row = mysql_fetch_row(result);
    for (int j = 0; j < fields; ++j) {
      printf("%s\t", row[j]);
   }
    printf("\n");
 }
  // 7. 关闭句柄
  mysql_close(connect_fd);
  printf("执行成功!\n");
  return 0; }

服务器端设计

菜品管理 API 设计

新增菜品(商家)

//请求: 
POST /dish 
{ 
 	"name": "宫保鸡丁", 
 	"price": 1800 
} 
//响应: 
HTTP/1.1 200 OK 
{ 
 	"ok": true, 
 	"dish_id": 1, 
}

查看所有菜品(商家/用户）

//请求: 
GET /dish 
//响应: 
HTTP/1.1 200 OK 
[ 
 { 
 	dish_id: 1, 
	name: "宫保鸡丁", 
 	price: 1800 
 } 
]

删除菜品(商家）

//请求: 
DELETE /dish/:dish_id 
//响应: 
HTTP/1.1 200 OK 
{ 
 	"ok": true 
}

修改菜品(商家)

//请求: 
PUT /dish/:dish_id 
{ 
 	"name": "京酱肉丝", 
 	"price": 1900 
} 
//响应: 
HTTP/1.1 200 OK 
{ 
 	"ok": true 
}
订单管理 API 设计

提交订单(用户)

//请求: 
POST /order 
{ 
 	"table_id": "1", 
 	"time": "2019-05-15 12:00", 
 	"dish_ids": [1, 2] 
} 
//响应: 
HTTP/1.1 200 OK 
{ 
 	"ok": true 
}

修改订单状态(商家)

//请求: 
PUT /order/:order_id 
{ 
 	"state": 0, 
} 
//响应: 
HTTP/1.1 200 OK 
{ 
 	"ok": true 
}

获取订单(商家)

  • 在实际的生活场景中，我们应该补充上相应的过滤功能(例如按时间, 桌号, 显示页数等规则过滤)。
  • 否则由于和 MySQL 的交互量过大就会导致服务器相应速度很慢。
//请求: 
GET /order 
//响应: 
HTTP/1.1 200 OK 
[ 
 { 
 	"order_id": 1, 
 	"table_id": "1", 
 	"time": "2019-05-15 12:00", 
 	"dishes": [ 
 	  { 
 	  	"dish_id": 1, 
 		"name": "宫保鸡丁", 
 		"price": 1800 
 		}, 
 		{ 
 			"dish_id": 2, 
 			"name": "京酱肉丝", 
 			"price": 1900 
 		} 
 	], 
 	"state": 0, 
 	"consume": 3700, // 表示该订单的价格
 	}, 
 	{ 
 		"order_id": 2, 
		"table_id": "2", 
 	"time": "2019-05-16 12:00", 
 	"dishs": [ 
	 {
 		"dish_id": 1, 
 		"name": "宫保鸡丁", 
 		"price": 1800 
 	  }, 
 	], 
 	"state": 1, 
 	"consume": 1800, // 表示该订单的价格
	} 
]

服务端实现（一）

封装数据库操作
基本代码框架

db.hpp

namespace order_system { 
static MYSQL* MySQLInit() { 
 MYSQL* connect_fd = mysql_init(NULL); 
 if (mysql_real_connect(connect_fd, "127.0.0.1", "root", "", 
 "order_system", 3306, NULL, 0) == NULL) { 
 printf("连接失败! %s\n", mysql_error(connect_fd)); 
 return NULL; 
 } 
 mysql_set_character_set(connect_fd, "utf8"); 
 return connect_fd; 
} 
static void MySQLRelease(MYSQL* mysql) { 
 mysql_close(mysql); 
} 
class DishTable { 
public: 
 DishTable(MYSQL* mysql) : mysql_(mysql) { } 
 bool Insert(const Json::Value& dish) { 
 } 
 bool SelectAll(Json::Value* dishes) { 
 } 
 bool SelectOne(int32_t dish_id, Json::Value* dish) { 
 } 
 bool Update(const Json::Value& dish) {
 } 
 bool Delete(int dish_id) { 
 } 
private: 
 MYSQL* mysql_; 
}; 
class OrderTable { 
public: 
 OrderTable(MYSQL* mysql) : mysql_(mysql) { } 
 bool SelectAll(Json::Value* orders) { 
 } 
 bool Insert(const Json::Value& order) { 
 } 
 bool ChangeState(const Json::Value& order) { 
 } 
private: 
 MYSQL* mysql_; 
}; 
} // end order_system
使用 JSON 作为数据交互格式

json 出自 JavaScript, 是一种非常方便的键值对数据组织格式
C++ 中可以使用 jsoncpp这个库来解析和构造json数据
yum install jsoncpp-devel

实现 DishTable 类封装对菜品的数据库操作
class DishTable { 
public: 
 DishTable(MYSQL* mysql) : mysql_(mysql) { } 
 bool Insert(const Json::Value& dish) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "insert into dish_table values(null, '%s', %d)", dish["name"].asCString(), 
dish["price"].asInt()); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! sql=%s, %s\n", sql, mysql_error(mysql_)); 
 return false;
 } 
 return true; 
 } 
 bool SelectAll(Json::Value* dishes) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "select * from dish_table"); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! %s\n", mysql_error(mysql_)); 
 return false; 
 } 
 MYSQL_RES* result = mysql_store_result(mysql_); 
 if (result == NULL) { 
 printf("获取结果失败! %s\n", mysql_error(mysql_)); 
 return false; 
 } 
 int rows = mysql_num_rows(result); 
 for (int i = 0; i < rows; ++i) { 
 MYSQL_ROW row = mysql_fetch_row(result); 
 Json::Value dish; 
 dish["dish_id"] = atoi(row[0]); 
 dish["name"] = row[1]; 
 dish["price"] = atoi(row[2]); 
 // 遍历结果依次加入到 dishes 中
 dishes->append(dish); 
 } 
 return true; 
 } 
 bool SelectOne(int32_t dish_id, Json::Value* dish) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "select * from dish_table where dish_id = %d", dish_id); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! %s\n", mysql_error(mysql_)); 
 return false; 
 } 
 MYSQL_RES* result = mysql_store_result(mysql_); 
 if (result == NULL) { 
 printf("获取结果失败! %s\n", mysql_error(mysql_)); 
 return false; 
 } 
 int rows = mysql_num_rows(result); 
 if (rows != 1) { 
 printf("查找结果不为 1 条. rows = %d!\n", rows); 
 return false; 
 } 
 for (int i = 0; i < rows; ++i) { 
 MYSQL_ROW row = mysql_fetch_row(result); 
 (*dish)["dish_id"] = atoi(row[0]); 
 (*dish)["name"] = row[1]; 
 (*dish)["price"] = atoi(row[2]);
 break; // 只获取一条数据. 按理说数据库中相同 id 的就一个
 } 
 return true; 
 } 
 bool Update(const Json::Value& dish) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "update dish_table SET name='%s', price=%d where dish_id=%d", 
 dish["name"].asCString(), 
 dish["price"].asInt(), dish["dish_id"].asInt()); 
 // DEBUG 用于调试
 // printf("[SQL] %s\n", sql); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! sql=%s, %s\n", sql, mysql_error(mysql_)); 
 return false; 
 } 
 return true; 
 } 
 bool Delete(int dish_id) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "delete from dish_table where dish_id=%d", dish_id); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! sql=%s, %s\n", sql, mysql_error(mysql_)); 
 return false; 
 } 
 return true; 
 } 
private: 
 MYSQL* mysql_; 
};
创建 OrderTable 类封装对订单的数据库操作
class OrderTable { 
public: 
 OrderTable(MYSQL* mysql) : mysql_(mysql) { } 
 bool SelectAll(Json::Value* orders) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "select * from order_table"); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! %s\n", mysql_error(mysql_)); 
 return false; 
 } 
 MYSQL_RES* result = mysql_store_result(mysql_); 
 if (result == NULL) { 
 printf("获取结果失败! %s\n", mysql_error(mysql_));
 return false; 
 } 
 int rows = mysql_num_rows(result); 
 for (int i = 0; i < rows; ++i) { 
 MYSQL_ROW row = mysql_fetch_row(result); 
 Json::Value order; 
 order["order_id"] = atoi(row[0]); // 注意, order_id 是数字, table_id 是字符串
 order["table_id"] = row[1]; 
 order["time"] = row[2]; 
 // [重要] 需要在上层把 dish_ids 替换成 dishes(不光是菜品 ID 还有菜品详细信息) 
 order["dish_ids_str"] = row[3]; 
 order["state"] = row[4]; 
 // 遍历结果依次加入到 dishes 中
 orders->append(order); 
 } 
 return true; 
 } 
 bool Insert(const Json::Value& order) { 
 char sql[1024 * 4] = {0}; 
 // 此处 dish_ids 需要先转成字符串(本来是一个对象, 
 // 形如 [1, 2, 3]. 如果不转, 是无法 asCString) 
 sprintf(sql, "insert into order_table values(null, '%s', '%s', '%s', %d)", 
 order["table_id"].asCString(), order["time"].asCString(), 
 order["dish_ids_str"].asCString(), order["state"].asInt()); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! sql=%s, %s\n", sql, mysql_error(mysql_)); 
 return false; 
 } 
 return true; 
 } 
 bool ChangeState(const Json::Value& order) { 
 char sql[1024 * 4] = {0}; 
 sprintf(sql, "update order_table set state = %d where order_id = %d", 
 order["state"].asInt(), order["order_id"].asInt()); 
 int ret = mysql_query(mysql_, sql); 
 if (ret != 0) { 
 printf("执行 sql 失败! sql=%s, %s\n", sql, mysql_error(mysql_)); 
 return false; 
 } 
 return true; 
 } 
private: 
 MYSQL* mysql_; 
};
测试数据库操作

db_test.cc 测试上述数据库操作是否封装正确

void TestDishTable() { 
 bool ret = false; 
 // 更友好的格式化显示 Json 
 Json::StyledWriter writer; 
 MYSQL* mysql = MySQLInit(); 
 Json::Value dish; 
 dish["name"] = "红烧肉"; 
 dish["price"] = 2300; 
 std::cout << "==============测试插入=====================" << std::endl; 
 DishTable dish_table(mysql); 
 ret = dish_table.Insert(dish); 
 std::cout << "Insert: " << ret << std::endl; 
 std::cout << "==============测试查找=====================" << std::endl; 
 Json::Value dishes; 
 ret = dish_table.SelectAll(&dishes); 
 std::cout << "SelectAll: " << ret << std::endl 
 << writer.write(dishes) << std::endl; 
 std::cout << "==============测试更新=====================" << std::endl; 
 dish["dish_id"] = 5; 
 dish["name"] = "毛家红烧肉"; 
 dish["price"] = 2700; 
 Json::Value dish_out; 
 ret = dish_table.Update(dish); 
 std::cout << "Update: " << ret << std::endl; 
 ret = dish_table.SelectOne(5, &dish_out); 
 std::cout << "SelectOne: " << ret << std::endl 
 << writer.write(dish_out) << std::endl; 
 std::cout << "==============测试删除=====================" << std::endl; 
 int dish_id = 6; 
 ret = dish_table.Delete(dish_id); 
 std::cout << "Delete: " << ret << std::endl; 
 MySQLRelease(mysql); 
} 
void TestOrderTable() { 
 bool ret = false; 
 Json::StyledWriter writer; 
 MYSQL* mysql = MySQLInit(); 
 OrderTable order_table(mysql); 
 std::cout << "==============测试插入=====================" << std::endl; 
 Json::Value order; 
 order["table_id"] = "忠义堂"; 
 order["time"] = "2019-05-17 12:00"; 
 order["dish_ids"] = "1,2,3"; 
 order["state"] = 0; 
 ret = order_table.Insert(order);
 std::cout << "Insert: " << ret << std::endl; 
 std::cout << "==============测试查看=====================" << std::endl; 
 Json::Value orders; 
 ret = order_table.SelectAll(&orders); 
 std::cout << "SelectAll: " << ret << std::endl 
 << writer.write(orders) << std::endl; 
 std::cout << "==============测试修改状态=====================" << std::endl; 
 Json::Value state; 
 state["order_id"] = 3; 
 state["state"] = 1; 
 ret = order_table.ChangeState(state); 
 std::cout << "ChangeState ret:" << ret << std::endl; 
 MySQLRelease(mysql); 
} 
int main() { 
 // TestDishTable(); 
 TestOrderTable(); 
 return 0; 
}

Makefile

FLAGS=-std=c++11 -L/usr/lib64/mysql -lmysqlclient -ljsoncpp -lpthread -g 
.PHONY:all 
all:db_test 
db_test:db_test.cc db.hpp 
 g++ db_test.cc -o db_test $(FLAGS) 
.PHONY:clean 
clean: 
 rm db_test

服务器端实现（二）

使用 httplib搭建服务器框架

使用 cpp-httplib实现一个 “hello world”

#include "httplib.h" 
int main() { 
 	using namespace httplib; 
 	Server server; 
 	server.Get("/", [](const Request& req,Response& resp) { 
 		(void)req; 
 		resp.set_content("<html>hello</html>", "	text/html"); 
 	}); 
 	server.set_base_dir("./wwwroot"); 
 	server.listen("0.0.0.0", 9092); 
 	return 0; 
}

编译选项
g++ main.cc -lpthread -std=c++11

整体 API 框架
MYSQL* mysql = NULL; 
int main() { 
 using namespace httplib; 
 using namespace order_system; 
 Server server; 
 // 1. 数据库客户端初始化和释放
 mysql = MySQLInit(); 
 signal(SIGINT, [](int) { MySQLRelease(mysql); exit(0);}); 
 DishTable dish_table(mysql); 
 OrderTable order_table(mysql); 
 // 2. 设置路由
 // 新增菜品
 server.Post("/dish", [&dish_table](const Request& req, Response& resp) { 
 
 }); 
 // 查看所有菜品
 server.Get("/dish", [&dish_table](const Request& req, Response& resp) { 
 
 }); 
 // 删除菜品
 // raw string(c++ 11), 转义字符不生效. 用来表示正则表达式正好合适
 // 关于正则表达式, 只介绍最基础概念即可. \d+ 表示匹配一个数字
 // http://help.locoy.com/Document/Learn_Regex_For_30_Minutes.htm 
 server.Delete(R"(/dish/(\d+))", [&dish_table](const Request& req, Response& resp) { 
 
 }); 
 // 修改菜品
 server.Put(R"(/dish/(\d+))", [&dish_table](const Request& req, Response& resp) { 
 
 });
 // 新增订单
 server.Post("/order", [&order_table](const Request& req, Response& resp) { 
 
 }); 
 // 修改订单状态
 server.Put(R"(/order/(\d+))", [&order_table](const Request& req, Response& resp) { 
 
 }); 
 // 获取订单
 server.Get("/order", [&order_table, &dish_table](const Request& req, Response& resp) { 
 
 }); 
 // 获取用户客户端, 匹配桌子 id 
 server.Get(R"(/client/table/(\S+))", [](const Request& req, Response& resp) { 
 }); 
 // 设置静态文件目录
 server.set_base_dir("./wwwroot"); 
 server.listen("0.0.0.0", 9092); 
 return 0; 
}

实现菜品管理 API

实现新增菜品
 server.Post("/dish", [&dish_table](const Request& req, Response& resp) { 
 LOG(INFO) << "新增菜品: " << req.body << std::endl; 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value req_json; 
 Json::Value resp_json; 
 // 1. 请求解析成 Json 格式
 bool ret = reader.parse(req.body, req_json); 
 if (!ret) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "parse Request failed!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 2. 进行参数校验
 if (req_json["name"].empty() || req_json["price"].empty()) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "Request has no name or price field!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 }
 // 3. 调用数据库接口进行操作数据
 ret = dish_table.Insert(req_json); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "Insert failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 4. 封装正确的返回结果
 resp_json["ok"] = true; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 })
实现获取所有菜品
 server.Get("/dish", [&dish_table](const Request& req, Response& resp) { 
 LOG(INFO) << "查看所有菜品: " << req.body << std::endl; 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value resp_json; 
 // 对于查看菜品来说 API 没有请求参数, 不需要解析参数和校验了, 直接构造结果即可
 // 1. 调用数据库接口查询数据
 Json::Value dishes; 
 bool ret = dish_table.SelectAll(&dishes); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "SelectAll failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 2. 构造响应结果
 resp.set_content(writer.write(dishes), "application/json"); 
 return; 
 });
实现删除菜品
// 删除菜品
 // raw string(c++ 11), 转义字符不生效. 用来表示正则表达式正好合适
 // 关于正则表达式, 只介绍最基础概念即可. \d+ 表示匹配一个数字
 // http://help.locoy.com/Document/Learn_Regex_For_30_Minutes.htm 
 server.Delete(R"(/dish/(\d+))", [&dish_table](const Request& req, Response& resp) { 
 Json::Value resp_json; 
 Json::FastWriter writer; 
 // 1. 解析获取 dish_id 
 // 使用 matches[1] 就能获取到 dish_id 
 // LOG(INFO) << req.matches[0] << "," << req.matches[1] << "\n"; 
 int dish_id = std::stoi(req.matches[1]); 
 LOG(INFO) << "删除指定菜品: " << dish_id << std::endl;
 // 2. 调用数据库接口删除菜品
 bool ret = dish_table.Delete(dish_id); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "SelectAll failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 } 
 // 3. 包装正确的响应
 resp_json["ok"] = true; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 });
实现修改菜品
 // 修改菜品
 server.Put(R"(/dish/(\d+))", [&dish_table](const Request& req, Response& resp) { 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value req_json; 
 Json::Value resp_json; 
 // 1. 获取到菜品 id 
 int dish_id = std::stoi(req.matches[1]); 
 LOG(INFO) << "修改菜品 " << dish_id << "|" << req.body << std::endl; 
 // 2. 解析菜品信息
 bool ret = reader.parse(req.body, req_json); 
 if (!ret) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "parse Request failed!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // [注意!!] 一定要记得补充上 dish_id 
 req_json["dish_id"] = dish_id; 
 // 3. 校验菜品信息
 if (req_json["name"].empty() || req_json["price"].empty()) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "Request has no name or price!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 4. 调用数据库接口进行修改
 ret = dish_table.Update(req_json); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "Update failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json");
 return; 
 } 
 // 5. 封装正确的数据
 resp_json["ok"] = true; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 })

实现订单管理 API

实现新增订单
 server.Post("/order", [&order_table](const Request& req, Response& resp) { 
 LOG(INFO) << "新增订单: " << req.body << std::endl; 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value req_json; 
 Json::Value resp_json; 
 // 1. 请求解析成 Json 格式
 bool ret = reader.parse(req.body, req_json); 
 if (!ret) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "parse Request failed!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 2. 校验订单格式
 if (req_json["table_id"].empty() || req_json["time"].empty() 
 || req_json["dish_ids"].empty()) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "Request has no table_id or time or dish_ids!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 3. 转换接口, 把 dish_ids 先转成字符串, 存到 dish_ids_str 中. 
 // 后续的数据库插入拿着这个 dish_ids_str 来进行插入
 const Json::Value& dish_ids = req_json["dish_ids"]; 
 req_json["dish_ids_str"] = writer.write(dish_ids); 
 // 4. 调用数据库接口, 插入订单数据
 ret = order_table.Insert(req_json); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "OrderTable Insert failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 5. 返回正确的结果
 resp_json["ok"] = true; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 })
实现修改订单状态
server.Put(R"(/order/(\d+))", [&order_table](const Request& req, Response& resp) { 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value req_json; 
 Json::Value resp_json; 
 // 1. 获取到订单 id 
 int order_id = std::stoi(req.matches[1]); 
 LOG(INFO) << "修改菜品 " << order_id << "|" << req.body << std::endl; 
 // 2. 解析菜品信息
 bool ret = reader.parse(req.body, req_json); 
 if (!ret) { 
 // 请求解析出错, 返回一个400响应
 resp_json["ok"] = false; 
 resp_json["reason"] = "parse Request failed!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // [注意!!] 一定要记得补充上 order_id 
 req_json["order_id"] = order_id; 
 // 3. 校验请求格式
 if (req_json["order_id"].empty() || req_json["state"].empty()) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "Request has no order_id or state!\n"; 
 resp.status = 400; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 // 4. 调用数据库接口进行修改
 ret = order_table.ChangeState(req_json); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "ChangeState failed\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 resp_json["ok"] = true; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 })
实现获取订单
server.Get("/order", [&order_table, &dish_table](const Request& req, Response& resp) { 
 // [重要!!] orders 中包含很多 order. 每个 order 又包含若干个 dish
 LOG(INFO) << "查看所有订单: " << req.body << std::endl; 
 Json::Reader reader; 
 Json::FastWriter writer; 
 Json::Value resp_json; 
 // 对于查看菜品来说 API 没有请求参数, 不需要解析参数和校验了, 直接构造结果即可
 // 1. 调用数据库接口查询数据
 Json::Value orders; 
 bool ret = order_table.SelectAll(&orders); 
 if (!ret) { 
 resp_json["ok"] = false; 
 resp_json["reason"] = "SelectAll failed!\n"; 
 resp.status = 500; 
 resp.set_content(writer.write(resp_json), "application/json"); 
 return; 
 } 
 for (uint32_t order_index = 0; order_index < orders.size(); ++order_index) { 
 LOG(INFO) << "处理第 " << order_index << " 个订单 ing" << std::endl; 
 // 循环一次, 处理一个订单
 Json::Value& order = orders[order_index]; 
 // 2. 转换格式
 Json::Value dish_ids; 
 ret = reader.parse(order["dish_ids_str"].asString(), dish_ids); 
 if (!ret) { 
 // 用宽松一点的方式处理. 此处不要因为一个订单的错误就影响大部分
 LOG(ERROR) << "order_id: " << order["order_id"].asInt() 
 << " has error dish_ids_str!" << std::endl; 
 continue; 
 } 
 // 3. 将 order 中的 dish_ids 构造成 dishes (再次查询数据库, 获取到每个菜品的详细信息) 
 GetDishes(dish_ids, &order["dishes"], dish_table); 
 // 4. 构造 consume 字段, 求这个订单的总价
 order["consume"] = GetConsume(order["dishes"]); 
 } 
 // 5. 构造响应结果
 resp.set_content(writer.write(orders), "application/json"); 
 return; 
 })

实现辅助函数

// 把一个订单中的 dish_ids 转换成详细信息 dishes 
// order 作为输入输出参数
bool GetDishes(const Json::Value& dish_ids, Json::Value* dishes, 
 order_system::DishTable& dish_table) { 
 for (uint32_t i = 0; i < dish_ids.size(); ++i) { 
 LOG(INFO) << "处理第 " << i << " 个菜品" << std::endl; 
 int dish_id = dish_ids[i].asInt(); 
 Json::Value dish_info; 
 bool ret = dish_table.SelectOne(dish_id, &dish_info); 
 if (!ret) { 
 LOG(ERROR) << "dish_id = " << dish_id << " not found!\n"; 
 continue;
 } 
 dishes->append(dish_info); 
 } 
 return true; 
} 
int GetConsume(const Json::Value& dishes) { 
 int consume = 0; 
 for (uint32_t i = 0; i < dishes.size(); ++i) { 
 consume += dishes[i]["price"].asInt(); 
 } 
 return consume; 
}
使用 Postman 测试

在 Postman 中构造请求, 并验证即可

夏之前
关注
C++ 酒店餐饮管理系统
10-27
这是我们小组用C++编写的一个酒店餐饮管理系统，功能还算完整，包括源程序与相关文档，共20多兆
C++餐厅订餐管理系统
程序设计
01-06 4318
结算时，只能对“已出菜”菜品进行结算，收银员还需要对当天的结算进行统计，当天结束后，还需要统计当天“待做”菜品和“已做”菜品。5、服务员可以查看小票并完成线下服务，也可以根据客户的要求加点菜肴或酒水，加点的菜肴或酒水由服务员录入系统，当出菜时按照正常点菜方式进行勾单，结算时（加点菜肴或酒水以“已出菜”为标准)与客户初始小票合并结算。4、厨师可以按序查看每个小票并做菜，当做完一个菜时需要更改该菜的状态（菜的初始状态均为“待做”，已出菜的菜品应改为“已做”)，厨师也可以查看当天已完成的所有菜品。
微信小程序自助点餐系统springboot
最新发布
qiufangtaowvnyyidtf的博客
08-01 888
通过移动互联网这几年的发展，单独的开发某些APP已经到了日暮西山的地步，原因不在于单个的APP功能丰富与否，而是因为用户生态体系的问题。使用智能手机的用户经过多年的使用习惯，已经越来越不喜欢安装各种的APP，除了正常生活和工作所必须的APP，不喜欢因为喜欢某些内容而被强制安装APP软件了。最近几年，随着微信生态的布局，通过开发微信小程序接口，让广大用户可以通过微信直接访问小程序，不需要去专门安装那些APP，这一点让很多用户喜爱，基本上只要能转向微信生态的业务，许多企业都已经开始拥抱微信小程序。
【C++】使用函数指针制作菜单管理…
lothome的博客
01-05 1096
#include"iostream" using namespace std; struct MENU { char* Name; void (*func)();      //func为指向函数的指针变量，该函数没有参数，不返回值  }; //菜单功能函数 void FileFunc();   //文件菜单  void EditFunc(); //编辑菜单   void ViewFunc()
【C++面向对象】C++餐厅点餐管理系统【独一无二】
测试开发自动化
07-06 5686
这段代码实现了一个餐厅管理系统，具有客户点餐和管理后台两种模式。通过使用std::map容器存储菜单和订单信息，代码实现了添加菜品、删除菜品、查看菜品、修改菜品、查看订单和客户点餐等功能。代码的设计思路主要采用了面向过程的编程范式，将不同的功能封装为独立的函数，实现了模块化的设计。通过主循环和条件判断，代码能够根据用户的选择执行相应的操作，并通过输入和输出处理用户的数据和系统的信息。尽管代码实现了基本的功能，但它仍然可以进一步改进。
c++课程设计自助点餐系统
热门推荐
weixin_44203971的博客
07-03 2万+
【题目】自助点餐系统 【目的】 通过设计一个小型的自助点餐系统，训练综合运用所学知识处理实际问题的能力，强化面向对象的程序设计理念，使自己的程序设计与调试水平有一个明显的提高。 【要求】 1、每个学生必须独立完成； 2、课程设计时间为1周； 3、设计语言采用C++； 4、学生有事离校必须请假。课程设计期间，无故缺席按旷课处理；缺席时间达四分之一以上者，未按规定上交实验报告的学生，其成绩按不及格处理。 【内容简介】 有一个小型餐厅，现在这个餐厅打算使用自助点餐系统，方便顾客自己点餐，并提供对餐厅销售情况的统计
C++实现KFC点餐系统
12-17
在本项目中，我们将开发一个C++实现的KFC点餐系统，该系统模拟了肯德基快餐店的收银流程。系统需具备多种功能，包括处理正常餐品、基本套餐、优惠券以及店内活动，并能模拟打印小票。为了实现这些功能，我们需要考虑...
基于Linux、QT、C++的点餐系统
03-08
一、功能实现 管理员及收银员的注册登录、人员信息管理、账单查看、餐品信息管理、顾客点餐、厨房上菜、收银结账。 二、项目描述 1、项目采用 C/S 架构，利用 TCP 协议进行通信，采用了多线程的方法解决服务端与多...
基于C++&Qt实现的在线点餐系统（客户端+服务端——.zip
08-10
计算机类毕业设计源码
微信点餐系统-SpringBoot开发WeChatOrderSystem.zip
05-14
该项目利用了基于springboot + vue + mysql的开发模式框架实现的课设系统，包括了项目的源码资源、sql文件、相关指引文档等等。 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理...
C语言实现点餐系统，大学期末作业，计算机科学与技术，课程设计
q643344的博客
07-09 2676
本文实例为大家分享了C语言实现餐厅点餐系统的具体代码，供大家参考，具体内容如下这应该是比较简单的c语言程序了，因为学校c语言结课结的早，我当时才学到结构体指针，所以我就把我当时能运用的知识点全用在这个程序上了。虽说这个程序对当时的我来说是天花板，但是当我继续学习，我逐渐发现这个程序能升级的点实在是太多了。但我也一直没去完善。所以就硬着头皮把他发出来了。顺序结构，选择分支结构，循环结构，数组，自定义函数，指针和结构体。
订餐系统（自带数据库）
01-02
直接可用的订餐系统程序，数据库安在D盘即可运行，不需要任何修改
C/C++餐厅自动化点餐系统
2301_76817904的博客
06-11 1888
【代码】C/C++餐厅自动化点餐系统。
C++编程 点菜系统项目框架设计
m0_56051805的博客
04-25 1488
C++点菜系统项目，数据类准备充分，UI底层封装，控件监听，按键驱动响应等基础界面运行所需要的底层代码均已封装完成
智能点餐系统
hjvft的博客
10-10 1770
基于使用c++封装类来实现智能点餐系统
新鲜出炉的点菜系统（附源码）
村雨遥
07-31 2033
前言 继上次写了一个 Java SE 版本的 学生成绩管理系统 之后，发现大家反响还不错，所以今天我有带来了差不多一样的点菜系统，希望利用我们所学的 Java SE 知识，实现我们的点菜系统。 而在上次文章的评论中，我也看到了大家的一些建议，可能没有及时回复大家，但是在这次文章中，我会尽量满足大家提的一些好的建议，向着更好的方向前进！ 需求分析 此次可以，我们需要设计一个点菜系统，我们就需要对我们的系统进行分析，面向的对象是谁？对象常用的操作又有哪些？ 既然是点菜系统，那我们的餐馆一般都是有一个固定的菜单，
用C编写酒店点餐管理系统
会挖坑的小石头的博客
05-31 946
用C语言编写的微型小项目！
c++点餐系统（C++、多态、sqlite数据库）
qq_45570844的博客
07-29 5404
技术路线效果展示程序主体main.cpp技术路线C++、sqlite3数据库、多态（动态）通过该程序，使用者可学习C++中的动态多态的使用，以及C++对sqlite3数据库的封装、调用。使用C++程序设计，使用C++程序调用sqlite3数据库，并通过数据库的操作对菜单进行管理，包括菜单中菜品的增删改查，还通过数据库对订单总金额进行统计，每次顾客购买后都会实时对数据库中的销售金额进行实时的更新。...
C++酒店点菜管理系统[2022-12-31]
程序设计
12-31 1590
题目25 “酒店点菜管理系统设计” 1 问题描述： 为了适应现代信息时代点餐的需求，采用新信息技术，研究设计了一个计算机点餐系统。能够完成权限管理、点餐管理、订单管理、结账管理、菜谱评分等功能。 2 功能要求： 一款具有如下功能的可以提供消息传送和人机交互的实用性服务系统，具有如下功能: (1) 权限管理：包括用户的注册、登录、用户信息管理。 (2) 点餐功能：包括餐单的增加、修改、删除、查看。 (3) 订单管理：包括生成订单、修改、删除、查找。 (4) 结账管理：统计消费的总额。 (5) 查看历史：查
C++实现点餐系统课程设计
"点餐系统课程设计文档是一个基于C++编程语言的项目，旨在实现一个基本的点餐系统的功能。这个系统可能包含了食物类（Food1）的定义，包括食物的序列号、价格、数量、时间和分类等属性，并提供了设置和获取这些属性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值