• 顾客点餐系统-----后端代码编写(基于SSM)

    restful风格设计API的特点:

    1)使用JSON来进行传递数据

    2)使用不同的HTTP方法来进行描述不同的操作

    3)使用HTTP状态码来进行表示返回结果是否正确

    4)使用路径表示要进行操作的资源是什么

    1)创建一个SpringBoot项目

    2)编写对应的配置文件，数据库的配置文件

    3)编写对应的SQL语句:

    当时我们工大有一家店叫做吉祥馄沌，老板还是使用手工记账的方式来进行记账，我就和老板商量了一下要做一个点餐系统出来

    1. drop database if exists OrderDish;
    2. create database if not exists OrderDish;
    3. use OrderDish;
    4. drop table if exists User;
    5. create table User(
    6. userID int primary key auto_increment,
    7. userName varchar(50),
    8. passWord varchar(100),
    9. isAdmin int default 0
    10. );
    11. drop table if exists Dish;
    12. create table Dish(
    13. dishID int primary key auto_increment,
    14. dishName varchar(50),
    15. dishMoney int
    16. );
    17. drop table if exists Order_User;
    18. create table Order_User(
    19. orderID int primary key auto_increment,
    20. userID int,
    21. isDown int,
    22. orderTime timeStamp,
    23. foreign key Order_User(userID) references User(userID)
    24. );
    25. drop table if exists Order_Dish;
    26. create table order_Dish(
    27. orderID int,
    28. dishID int,
    29. foreign key(orderID) references Order_User(orderID),
    30. foreign key(dishID) references Dish(dishID)
    31. );

    4)创建对应的实体类

    1. @Data
    2. public class Dish {
    3.     private int dishID;
    4.     private String dishName;
    5.     private String dishMoney;
    6. }
    7.  
    8. @Data
    9. public class Order {
    10.    private int orderID;
    11.    private int userID;
    12.    private List dishList;
    13.    private int isDown;
    14.    private Timestamp timestamp;
    15. }
    16.  
    17. @Data
    18. public class User {
    19.     private int userID;
    20.     private String userName;
    21.     private String passWord;
    22.     private int isAdmin;
    23. }

    约定前后端交互的接口:

    1){}表示一个JSON对象，他是一个键值对结构，里面包含了若干个键值对，键值对之间使用，进行分割，键和值之间使用：来进行分割，这里面的键必须是字符串

    2.[]用来表示一个数组，里面包含了若干个元素，每一个元素可以是整数，字符串，或者是JSON对象

    我们在这里面要用到11个API，需要约定前后端的接口;

    1)用户管理:注册，登录，检测登陆状态，注销

    2)菜品管理:新增菜品，查看菜品，删除菜品

    3)订单管理:新增订单(用户在这里面点菜)，查看指定订单，查看所有订单，修改状态 

    1)实现注册功能:

    1. 约定前后端交互的接口:
    2. POST /resigter HTTP/1.1
    3. contentType:application/json;
    4.  
    5. {
    6.     "userName":"李佳伟",
    7.     "passWord":"778896",
    8.     "isAdmin":"0"
    9. }
    10.  
    11. 注册成功的时候:
    12. {
    13.     "data": 1,
    14.     "message": "注册成功"
    15. }
    16. 注册失败的时候:
    17. {
    18.     "data": -1,
    19.     "message": "当前前段传递的用户名重复"
    20. }

     2)后端代码:

    1. @RestController
    2. @RequestMapping("/Java100")
    3. public class XMLController {
    4.     @Autowired
    5.     XMLMapper mapper;
    6.     Logger logger= LoggerFactory.getLogger(XMLController.class);
    7.     @RequestMapping("/resigter")
    8.     public HashMap AddUser(@RequestBody User RequestUser){
    9. //1.进行前端校验参数
    10.         String username=RequestUser.getUserName();
    11.         System.out.println(username);
    12.         String password=RequestUser.getPassWord();
    13.         System.out.println(password);
    14.         HashMap result=new HashMap<>();
    15.         int data=0;
    16.         String message="";
    17.         if(username==null||username.equals("")||password==null||password.equals("")){
    18.             data=0;
    19.             message="当前前端传递的用户名和密码有一个为空";
    20.         }else {
    21. //2.进行判断用户名是否重复
    22.             User user = mapper.selectUserByUserName(username);
    23.             if (user!=null){
    24.                 data=-1;
    25.                 message="当前前段传递的用户名重复";
    26.             }else {
    27. //3.进行密码加密操作;
    28.                 String finalPassword = encrypt.AddPassword(password);
    29. //4将加密之后的密码和用户名传入到数据库里面
    30.                 RequestUser.setPassWord(finalPassword);
    31.                 int len = mapper.addUser(RequestUser);
    32.                 if (len == 1) {
    33.                     message = "注册成功";
    34.                     data = 1;
    35.                 } else {
    36.                     message = "注册失败";
    37.                     data = -1;
    38.                 }
    39.             }
    40.         }
    41.         result.put("data",data);
    42.         result.put("message",message);
    43.         return result;
    44.     }
    45. }

    2)实现登陆功能:必须只有管理员才可以进行登录，这个是在后端根据用户名来进行查询的；

    进行密码加密操作:

    1. public class encrypt {
    2.     public static String AddPassword(String password){
    3.         //进行参数校验
    4.         if(!StringUtils.hasLength(password)){
    5.             return "";
    6.         }
    7.         //1.先得到盐值
    8.         String salt= IdUtil.simpleUUID();
    9.         //2.对密码进行加密
    10.         String finalPassWord= SecureUtil.md5(salt+password);
    11.         //3.进行最终密码拼装
    12.         return salt+"@"+finalPassWord;
    13.  
    14.     }
    15.     public static boolean SubPassword(String password,String finalPassword){
    16.         String[] strings=finalPassword.split("@");
    17.         System.out.println(finalPassword);
    18.         String salt=strings[0];
    19.         String extPassWord=strings[1];
    20.         String linPassword=SecureUtil.md5(salt+password);
    21.         System.out.println(linPassword);
    22.         if(linPassword.equals(extPassWord)) return true;
    23.         return false;
    24.     }
    25. }

    进行登录操作:

    1.   @RequestMapping("/login")
    2.     public HashMap login(@RequestBody User user, HttpServletRequest req){
    3.         //1.进行用户名和密码的校验
    4.         String username=user.getUserName();
    5.         String password=user.getPassWord();
    6.         int data=-1;
    7.         String message="";
    8.         //2.进行密码解迷和判断当前是否是管理员
    9.         User loginUser= mapper.selectUserByUserName(username);
    10.         if(loginUser==null||loginUser.equals("")){
    11.             data=-1;
    12.             message="当前没有这个用户";
    13.         }else{
    14.             //判断当前是不是管理员
    15.             if(loginUser.getIsAdmin()==0){
    16.                 data=-1;
    17.                 message="您不是管理员";
    18.             }else{
    19.                 //进行密码解密操作
    20.                 boolean flag=encrypt.SubPassword(user.getPassWord(),loginUser.getPassWord());
    21.                 if(flag==true){
    22.                     data=1;
    23.                     message="登陆成功";
    24.                     HttpSession httpSession=req.getSession(true);
    25.                     httpSession.setAttribute("user",loginUser);
    26.                 }else{
    27.                     data=-1;
    28.                     message="登陆失败";
    29.                 }
    30.             }
    31.         }
    32.         HashMap result=new HashMap<>();
    33.         result.put("data",data);
    34.         result.put("message",message);
    35.         return result;
    36.     }
    37.  
    38. }

    3)监测登录状态(通过拦截器已经进行实现)

    4)实现注销功能:

    1. @RequestMapping("/logout")
    2.     public void logout(HttpServletRequest req){
    3.         //1.进行注销
    4.         HttpSession httpSession=req.getSession(false);
    5.         //2.删除session对象
    6.         httpSession.removeAttribute("user");
    7.     }

    5)新增菜品:只有管理员才可以进行新增菜品，普通用户不可以进行新增菜品

    约定前后端交互的接口:

    1. 前端传递:
    2. {
    3.     "dishMoney":"90",
    4.     "dishName":"红烧茄子"
    5. }
    6. 后端接收:
    7. {
    8.     "data": 1,
    9.     "message": "新增菜品成功"
    10. }

    6)菜品管理:删除菜品:还是只有管理员才可以进行删除菜品，普通用户不可以进行删除菜品

    1. 前端:POST 127.0.0.1:8080/Java100/deleteDish?dishID=1 HTTP/1.1
    2.  
    3. 删除成功的时候:
    4. {
    5.     "data": 1,
    6.     "message": "删除菜品成功"
    7. }
    8. 删除失败的时候:
    9. {
    10.     "data": -1,
    11.     "message": "删除菜品失败"
    12. }
    1.     @RequestMapping("/deleteDish")
    2.     public HashMap deleteDish(Integer dishID,HttpServletRequest req){
    3.         //1.进行前端参数校验
    4.         int data=-1;
    5.         String message="";
    6.         if(dishID==null||dishID.equals("")){
    7.             data=-1;
    8.             message="当前前段传递的message为空";
    9.         }else{
    10.             //判断当前登录的人是否是管理员
    11.             HttpSession httpSession=req.getSession(false);
    12.             User user= (User) httpSession.getAttribute("user");
    13.             if(user.getIsAdmin()==0){
    14.                 data=-1;
    15.                 message="您当前不是管理员,无法进行删除菜品操作";
    16.             }else{
    17.                 int len= mapper.deleteDish(dishID);
    18.                 if(len==1){
    19.                     data=1;
    20.                     message="删除菜品成功";
    21.                 }else {
    22.                     data = -1;
    23.                     message = "删除菜品失败";
    24.                 }
    25.             }
    26.         }
    27.         HashMap hashMap=new HashMap<>();
    28.         hashMap.put("data",data);
    29.         hashMap.put("message",message);
    30.         return hashMap;
    31.     }

    7)查看菜品:普通用户和管理员都可以查看所有菜品

    约定前后端交互的接口:

    1. GET 127.0.0.1:8080/Java100/getAllDish HTTP/1.1
    2. [
    3.     {
    4.         "dishID": 2,
    5.         "dishName": "红烧茄子",
    6.         "dishMoney": "90"
    7.     },
    8.     {
    9.         "dishID": 3,
    10.         "dishName": "红烧里脊",
    11.         "dishMoney": "100"
    12.     }
    13. ]
    1.  @RequestMapping("/getAllDish")
    2.     public List GetAllDish(){
    3.        return mapper.SelectAllDish();
    4.     }

    之前用户表和菜品表的所有XML:

    1.   
    2.     <insert id="addUser">
    3.         insert into User values(null,#{userName},#{passWord},#{isAdmin});
    4.     insert>
    5.     <select id="selectUserByUserName" resultType="com.example.demo.Model.User">
    6.         select * from User where userName=#{userName};
    7.     select>
    8.     <select id="SelectByUserID" resultType="com.example.demo.Model.User">
    9.         select * from User where userID=#{userID}
    10.     select>
    12.     <insert id="addDish">
    13.         insert into Dish values(null,#{dishName},#{dishMoney});
    14.     insert>
    15.     <delete id="deleteDish">
    16.         delete from Dish where dishID=#{dishID}
    17.     delete>
    18.     <select id="SelectAllDish" resultType="com.example.demo.Model.Dish">
    19.         select * from Dish
    20.     select>
    21.     <select id="SelectOne" resultType="com.example.demo.Model.Dish">
    22.         select * from Dish where dishID=#{dishID}
    23.     select>
    24.     <update id="UpdateDish">
    25.         update set dishMoney=#{dishMoney} where dishID=#{dishID}
    26.     update>

    8)新增订单:

    1. 约定前后端交互的接口:
    2. 前端用户是要进行点菜的,肯定要进行选中菜品,所以前端给后端传递过来的肯定是一大堆的菜品ID
    3. 我们的后端要根据这些菜品ID生成一个订单
    4. 前段传递的参数:
    5. {
    6.     "list":"2,3,4,5"
    7. }
    8.  
    9. {
    10.     "data": 1,
    11.     "message": "订单插入成功"
    12. }

     后端代码:

    1.    @RequestMapping("/addOrder")
    2.     @Transactional
    3.     public HashMap addOrder(@RequestBody HashMap hashMap,HttpServletRequest req){
    4. //将前端传递的字符串转化成JSON数组
    5.       List dishIDList=new ArrayList<>();
    6.       String list=hashMap.get("list");
    7.         System.out.println(list);
    8.         String[] strings=list.split(",");
    9.       for(String string:strings){
    10.           dishIDList.add(Integer.parseInt(string));
    11.       }
    12.         //1.先进行插入订单用户表,拿到生成的订单ID
    13.         HttpSession httpSession=req.getSession(false);
    14.         User loginUser= (User) httpSession.getAttribute("user");
    15.         Order order=new Order();
    16.         order.setDishList(dishIDList);
    17.         order.setIsDown(0);
    18.         order.setTimeStamp(new Timestamp(System.currentTimeMillis()));
    19.         order.setUserID(loginUser.getUserID());
    20.         mapper.addOrderUser(order);
    21.         //2.再继续进行插入订单-菜品表
    22.         //我们在这里面要进行循环插入,因为有多个菜品
    23.         mapper.addOrderDish(dishIDList,order.getOrderID());
    24.         int data=1;
    25.         String message="订单插入成功";
    26.         HashMap result=new HashMap<>();
    27.         result.put("data",data);
    28.         result.put("message",message);
    29.         return result;
    30.     }

    对应的XML的代码:

    2.  
    4.  
    6.     <insert id="addOrderUser" useGeneratedKeys="true" keyProperty="orderID" keyColumn="orderID">
    7.         insert into order_user values(null,#{userID},#{timeStamp});
    8.     insert>
    9.  
    11.     <insert id="addOrderDish" >
    12.         insert into order_dish
    13.         <foreach collection="list" item="dishID" separator="," open="values" >
    14.             (#{orderID},#{dishID})
    15.         foreach>
    16.     insert>

    9)查看订单(管理员可以查看所有订单，用户可以查看指定用户的订单)，但是从这方面来说无论是管理员和用户，看到的都是多个订单)

    我们在这里面查询订单，只是看一下订单的大致信息，比如说订单下单时间，订单的是否完成状态，订单的ID，订单的UserID

    约定前后端交互的接口:

    1. GET 127.0.0.1:8080/Java100/SelectAllOrder HTTP/1.1
    2.  
    3. 响应:
    4. [
    5.     {
    6.         "orderID": 7,
    7.         "userID": 1,
    8.         "dishList": null,
    9.         "isDown": 0,
    10.         "timeStamp": null
    11.     },
    12.     {
    13.         "orderID": 8,
    14.         "userID": 1,
    15.         "dishList": null,
    16.         "isDown": 0,
    17.         "timeStamp": null
    18.     }
    19. ]

    1. //1)如果是管理员,那么可以看到所有用户的订单
    2. //2)如果是普通用户,那么只能看到自己的订单
    3. //3)我们可以根据HttpSession中的User对象,也就是里面的isAdmin来进行判断
    4.  @RequestMapping("/SelectAllOrder")
    5.     public List SelectAllOrder(HttpServletRequest req){
    6.         //1.进行判断当前用户是管理员,还是普通用户,因为最终返回的肯定是一个订单列表
    7.         HttpSession httpSession=req.getSession(false);
    8.         User user= (User) httpSession.getAttribute("user");
    9.         List list=null;
    10.         if(user.getIsAdmin()==0){
    11.             list= mapper.SelectAllOrder();
    12.         }else{
    13.             list=mapper.SelectOneAllOrder(user.getUserID());
    14.         }
    15.         //2.返回数据
    16.         return list;
    17.     }

    10)查看指定订单详情:我们之前给用户显示的是一个一个的订单列表，当我们想看某一个订单的时候，就会给后端传递一个订单ID

    1. 约定前后端交互的接口:
    2. GET 127.0.0.1:8080/Java100/GetDetailOrder?orderID=7 HTTP/1.1
    3.  
    4. 返回响应:
    5. {
    6.     "data": 1,
    7.     "returnResult": [
    8.         {
    9.             "dishID": 2,
    10.             "dishName": "红烧茄子",
    11.             "dishMoney": "90"
    12.         },
    13.         {
    14.             "dishID": 3,
    15.             "dishName": "红烧里脊",
    16.             "dishMoney": "100"
    17.         },
    18.         {
    19.             "dishID": 4,
    20.             "dishName": "红烧牛肉",
    21.             "dishMoney": "700"
    22.         },
    23.         {
    24.             "dishID": 5,
    25.             "dishName": "牛肉干",
    26.             "dishMoney": "70"
    27.         }
    28.     ],
    29.     "message": "当前用户查询所有订单成功"
    30. }
    1. @RequestMapping("/GetDetailOrder")
    2.     public HashMap GetDetailOrder(Integer orderID){
    3.         //1.进行前端参数校验
    4.       HashMap result = new HashMap<>();
    5.       int data=-1;
    6.       String message="";
    7.       List list=null;
    8.       List dishList=null;
    9.       if(orderID==null||orderID.equals("")){
    10.           data=-1;
    11.       }else {
    12.           //2.进行数据库查询
    13.           //2.1先根据orderID来进行查询到所有的菜品信息
    14.           list = mapper.SelectAllDishIDs(orderID);
    15.           //2.2再根据里面所有的dishID查询所有的Dish
    16.            dishList = mapper.SelectAllDishByDishIDTwo(list);
    17.           //3.统一返回数据封装结果
    18.           data=1;
    19.           message="当前用户查询所有订单成功";
    20.       }
    21.       result.put("data",data);
    22.       result.put("message",message);
    23.       result.put("returnResult",dishList);
    24.       return result;
    25.   }
    26. }

    11)修改订单状态:我们在这里面约定只有管理员才可以进行修改订单状态

    约定前后端交互的接口:我们要给后端传递一个orderID和isDone，后端根据这个来进行修改

    1. 前端:GET /UpdateState?orderID=1?isDone=1
    2. 响应:
    3. {
    4.   "OK":1,
    5.   "message":"修改订单状态成功"
    6. }
    1.   @RequestMapping("/UpdateState")
    2.     public HashMap UpdateState(@RequestBody HashMap hashMap,HttpServletRequest req){
    3.      //1.先进行获取到前端的参数并进行校验
    4.         int data=1;
    5.         String message="";
    6.         HashMap result=new HashMap<>();
    7.         Integer isDone=hashMap.get("isDone");
    8.         Integer orderID=hashMap.get("orderID");
    9.         if(isDone==null||isDone.equals("")||orderID==null||orderID.equals("")){
    10.             data=-1;
    11.             message="前端传低参数有问题";
    12.         }else {
    13.             //2.判断当前登录的人是不是管理员
    14.             HttpSession httpSession = req.getSession(false);
    15.             User user = (User) httpSession.getAttribute("user");
    16.             if (user.getIsAdmin() == 0) {
    17.                 data = -1;
    18.                 message = "您当前并不是管理员请进行登录";
    19.             } else {
    20.                 int len = mapper.UpdateState(isDone, orderID);
    21.                 if (len == 1) {
    22.                     data = 1;
    23.                     message = "修改成功";
    24.                 } else {
    25.                     data = -1;
    26.                     message = "修改失败";
    27.                 }
    28.             }
    29.         }
    30.         result.put("data",data);
    31.         result.put("message",message);
    32.         return result;
    33.    }
    34. }

  • 相关阅读:
    牛客网《剑指offer》专栏刷题练习之二叉树合集
    华为设备IPSG配置命令
    2022牛客暑期多校训练营3(总结+补题)
    order by注入与limit注入
    C和C++的区别(4) C++支持函数重载
    WSL Ubuntu 22.04.2 LTS 安装paddlepaddle-gpu==2.5.1踩坑日记
    http 和 https
    树与堆（详解）
    开发一款教育app需要具备哪些功能
    Postgresql实验系列（4）SIMD提升线性搜索性能24.5%（附带PG SIMD完整用例）
  • 原文地址：https://blog.csdn.net/weixin_61518137/article/details/127985879