9 Spring MVC Implementation 2

• Load restaurant menus
• Add item to customer's cart
• Get customer's cart

Get restaurant and Corresponding menu information

Create MenuInfoDao.java class under dao package to interact with mysql

MenuInfoDao.java:

package com.eve.onlineOrder.dao;
// dao 层用于与数据库进行交互，包括增删改查等操作。
// 例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
// 因此，需要在 dao 层中实现向数据库中插入数据的业务逻辑。
import com.eve.onlineOrder.entity.MenuItem;
import com.eve.onlineOrder.entity.Restaurant;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import java.util.ArrayList;
import java.util.List;

@Repository // @Repository 用于标注数据访问层组件，即 Dao 组件。
// Dao 层用于与数据库进行交互，包括增删改查等操作。
// 例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
// 因此，需要在 Dao 层中实现向数据库中插入数据的业务逻辑。
// Repository 是一个泛型注解，包含了 @Component 注解的功能。
public class MenuInfoDao {
    // @Autowired 用于自动装配，将 SessionFactory 注入到 MenuInfoDao 中。
    @Autowired
    private SessionFactory sessionFactory;
    // SessionFactory 用于创建 Session 对象.
    // Session 对象用于与数据库进行交互，包括增删改查等操作。
    // SessionFactory 是一个接口，包含了创建 Session 对象的方法。
    // SessionFactory 接口的实现类是 org.hibernate.internal.SessionFactoryImpl
    public List<Restaurant> getRestaurants() {
        try (Session session = sessionFactory.openSession()) {
            CriteriaBuilder builder = session.getCriteriaBuilder();
            // CriteriaBuilder 用于创建 CriteriaQuery 对象。
            CriteriaQuery<Restaurant> criteria = builder.createQuery(Restaurant.class);
            // CriteriaQuery 用于创建 Criteria 对象。
            criteria.from(Restaurant.class);
            // from 方法用于指定查询的实体类。
            return session.createQuery(criteria).getResultList();
            // getResultList 方法用于获取查询结果。
        } catch (Exception e) {
            e.printStackTrace();
        }

        return new ArrayList<>();

    }

    public List<MenuItem> getAllMenuItem(int restaurantId){
        try(Session session = sessionFactory.openSession()){
            Restaurant restaurant = session.get(Restaurant.class, restaurantId);
            if (restaurant != null){
                return restaurant.getMenuItemList();
                // getMenuItemList 方法用于获取菜单项列表。
            }
        } catch (Exception e) {
            e.printStackTrace();
            // printStackTrace 方法用于打印异常信息。
        }
        return new ArrayList<>();
    }

    public MenuItem getMenuItem(int menuItemId){
        try(Session session = sessionFactory.openSession()){
            return session.get(MenuItem.class, menuItemId);
            // get 方法用于获取 MenuItem 对象。
        } catch (Exception e) {
            e.printStackTrace();
            // printStackTrace 方法用于打印异常信息。
        }
        return null;
        // 如果获取 MenuItem 对象失败，则返回 null。
    }
}

Create MenuInfoService.java class under service package to handle logic

package com.eve.onlineOrder.service;

import com.eve.onlineOrder.dao.MenuInfoDao;
import com.eve.onlineOrder.entity.MenuItem;
import com.eve.onlineOrder.entity.Restaurant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

// @Service 用于标注业务层组件，即 Service 组件。
// Service 层用于实现业务逻辑，例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
// 因此，需要在 Service 层中实现向数据库中插入数据的业务逻辑。
// Service 是一个泛型注解，包含了 @Component 注解的功能。
@Service
public class MenuInfoService {

    @Autowired // @Autowired 用于自动装配，将 MenuInfoDao 注入到 MenuInfoService 中。
    // MenuInfoDao 用于与数据库进行交互，包括增删改查等操作。
    private MenuInfoDao menuInfoDao;

    public List<Restaurant> getRestaurants() {
        return menuInfoDao.getRestaurants(); // 调用 MenuInfoDao 中的 getRestaurants 方法，获取所有的餐馆信息。
    }

    public List<MenuItem> getAllMenuItem(int restaurantId) {
        return menuInfoDao.getAllMenuItem(restaurantId);
        // 调用 MenuInfoDao 中的 getAllMenuItem 方法，获取所有的菜单项信息。
    }

    public MenuItem getMenuItem(int menuItemId) {
        return menuInfoDao.getMenuItem(menuItemId);
        // 调用 MenuInfoDao 中的 getMenuItem 方法，获取菜单项信息。
        // 例如，当用户点击菜单项时，需要获取菜单项的详细信息。
        // 因此，需要在 Service 层中实现获取菜单项信息的业务逻辑。
    }
}

Update MenuInfoController.java

package com.eve.onlineOrder.controller;


import com.eve.onlineOrder.entity.MenuItem;
import com.eve.onlineOrder.entity.Restaurant;
import com.eve.onlineOrder.service.MenuInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;

// @Controller 用于标注控制层组件，即 Controller 组件。
// Controller 层用于接收请求，调用 Service 层的方法，将数据返回给前端页面。
@Controller
public class MenuInfoController {
    @Autowired // @Autowired 用于自动装配，将 MenuInfoService 注入到 MenuInfoController 中。
    private MenuInfoService menuInfoService;    //here


    @RequestMapping(value="/restaurant/{restaurantId}/menu", method = RequestMethod.GET)
    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/restaurant/{restaurantId}/menu
    // 表示请求的 URL 为 http://localhost:8080/restaurant/{restaurantId}/menu。
    // method 属性用于指定请求的方法。例如，RequestMethod.GET 表示请求的方法为 GET。
    // RequestMethod 是一个枚举类，包含了所有的请求方法。
    @ResponseBody
    // @ResponseBody 用于将返回的数据放到响应体中。
    // 例如，当用户访问 http://localhost:8080/restaurant/{restaurantId}/menu 时，需要将菜单信息返回给前端页面。
    // 因此，需要将菜单信息放到响应体中，然后返回给前端页面。
    public List<MenuItem> getMenus(@PathVariable("restaurantId") int restaurantId){
        return menuInfoService.getAllMenuItem(restaurantId); //here
        // 调用 MenuInfoService 中的 getAllMenuItem 方法，获取所有的菜单项信息。
    }

    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/restaurants
    //  表示请求的 URL 为 http://localhost:8080/restaurants。
    // method 属性用于指定请求的方法。例如，RequestMethod.GET 表示请求的方法为 GET。
    @RequestMapping(value="/restaurants", method = RequestMethod.GET)
    @ResponseBody
    public List<Restaurant> getRestaurants(){
        // getRestaurants 方法用于获取所有的餐馆信息
        return menuInfoService.getRestaurants(); // here
        // 调用 MenuInfoService 中的 getRestaurants 方法，获取所有的餐馆信息。
    }
}

Using postman to get restaurants info

Get menu for a specific restaurant

Add menu item to cart

Create OrderItemDao.java class under dao package

package com.eve.onlineOrder.dao;

import com.eve.onlineOrder.entity.OrderItem;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository // @Repository 用于标注数据访问层组件，即 Dao 组件。
// Dao 层用于与数据库进行交互，包括增删改查等操作。
// 例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
public class OrderItemDao {
    @Autowired // @Autowired 用于自动装配，将 SessionFactory 注入到 OrderItemDao 中。
    // SessionFactory 用于创建 Session 对象.
    private SessionFactory sessionFactory;

    public void save(OrderItem orderItem) {// save 方法用于向数据库中插入数据。
        Session session = null; // Session 对象用于与数据库进行交互，包括增删改查等操作。
        try{
            session = sessionFactory.openSession(); 
            // openSession 方法用于创建 Session 对象。
            session.beginTransaction();
            // beginTransaction 方法用于开启事务。
            session.save(orderItem);
            // save 方法用于向数据库中插入数据。
            session.getTransaction().commit();
            // getTransaction 方法用于获取事务。
            // commit 方法用于提交事务。
        } catch (Exception e) {
            e.printStackTrace();
            if (session != null) {
                session.getTransaction().rollback();
                // rollback 方法用于回滚事务。
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

Create OrderItemService.java class under service package to deal with business logic.

package com.eve.onlineOrder.service;

import com.eve.onlineOrder.dao.OrderItemDao;
import com.eve.onlineOrder.entity.Customer;
import com.eve.onlineOrder.entity.MenuItem;
import com.eve.onlineOrder.entity.OrderItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

@Service// @Service 用于标注业务层组件，即 Service 组件。
public class OrderItemService {
    @Autowired // @Autowired 用于自动装配，将 MenuInfoService 注入到 MenuInfoController 中。
    private MenuInfoService menuInfoService;

    @Autowired // @Autowired 用于自动装配，将 CustomerService 注入到 MenuInfoController 中。
    private CustomerService customerService;

    @Autowired // @Autowired 用于自动装配，将 OrderItemDao 注入到 MenuInfoController 中。
    private OrderItemDao orderItemDao;

    public void saveOrderItem(int menuId) {
        // saveOrderItem 方法用于向数据库中插入数据。
        final OrderItem orderItem = new OrderItem();
        // OrderItem 对象用于封装订单项信息。
        // 例如，当用户点击菜单项时，需要向数据库中的 order_item 表中插入数据。
        // 因此，需要在 OrderItem 对象中封装订单项信息，然后将 OrderItem 对象插入到数据库中。
        // OrderItem 对象中封装的订单项信息包括：菜单项信息、购物车信息、数量、价格等。
        final MenuItem menuItem = menuInfoService.getMenuItem(menuId);
        // 调用 MenuInfoService 中的 getMenuItem 方法，获取菜单项信息。
        // 例如，当用户点击菜单项时，需要获取菜单项的详细信息。
        // 因此，需要在 Service 层中实现获取菜单项信息的业务逻辑。
        // 菜单项信息包括：菜单项的名称、描述、价格等。

        Authentication loggedInUser = SecurityContextHolder.getContext().getAuthentication();
        // Authentication 对象用于封装认证信息。
        // 例如，当用户登录时，需要向数据库中的 customer 表和 authorities 表中插入数据。
        // 因此，需要在 Authentication 对象中封装认证信息，然后将 Authentication 对象插入到数据库中。
        // Authentication 对象中封装的认证信息包括：用户名、密码、权限等。
        // SecurityContextHolder.getContext() 用于获取 Authentication 对象。
        String username = loggedInUser.getName();
        // getName 方法用于获取用户名。
        // 例如，当用户登录时，需要获取用户名。
        // 因此，需要在 Service 层中实现获取用户名的业务逻辑。
        // 例如，String username = loggedInUser.getName();
        // 表示获取用户名，并将用户名赋值给 username 变量。
        // 因此，需要在 Service 层中实现获取用户名的业务逻辑。
        Customer customer = customerService.getCustomer(username);
        // 调用 CustomerService 中的 getCustomer 方法，获取用户信息。
        // 例如，当用户登录时，需要获取用户信息。
        // 因此，需要在 Service 层中实现获取用户信息的业务逻辑。
        // 例如，Customer customer = customerService.getCustomer(username);
        // 表示获取用户信息，并将用户信息赋值给 customer 变量。
        // 因此，需要在 Service 层中实现获取用户信息的业务逻辑。


        orderItem.setMenuItem(menuItem);// setMenuItem 方法用于设置菜单项信息。
        orderItem.setCart(customer.getCart()); // setCart 方法用于设置购物车信息。
        orderItem.setQuantity(1);// setQuantity 方法用于设置数量。
        orderItem.setPrice(menuItem.getPrice());// setPrice 方法用于设置价格。
        orderItemDao.save(orderItem);// 调用 OrderItemDao 中的 save 方法，向数据库中插入数据。
    }
}

Update ItemOrderController.java

package com.eve.onlineOrder.controller;

import com.eve.onlineOrder.service.OrderItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;

@Controller // @Controller 用于标注控制层组件，即 Controller 组件。
public class ItemOrderController {
    @Autowired // @Autowired 用于自动装配，将 OrderItemService 注入到 ItemOrderController 中。
    private OrderItemService orderItemService;


    @RequestMapping(value = "/order/{menuId}", method = RequestMethod.POST)
    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/order/{menuId}
    // 表示请求的 URL 为 http://localhost:8080/order/{menuId}。
    // method 属性用于指定请求的方法。例如，RequestMethod.POST 表示请求的方法为 POST。
    // RequestMethod 是一个枚举类，包含了所有的请求方法。
    // 例如，当用户点击菜单中的某个菜品时，需要将该菜品添加到购物车中。
    // 因此，需要向数据库中的 cart_item 表中插入数据。
    @ResponseStatus(value = HttpStatus.CREATED)
    // @ResponseStatus 用于指定响应的状态码。
    // value 属性用于指定响应的状态码。例如，HttpStatus.CREATED 表示响应的状态码为 201。
    //  HttpStatus 是一个枚举类，包含了所有的状态码。
    public void addMenuItemToCart(@PathVariable("menuId") int menuId) {
        // addMenuItemToCart 方法用于向数据库中插入数据。
        // 例如，当用户点击菜单中的某个菜品时，需要将该菜品添加到购物车中。
        // 因此，需要向数据库中的 cart_item 表中插入数据。
        // @PathVariable 用于获取请求 URL 中的参数。
        // 例如，/order/{menuId} 表示请求的 URL 为 http://localhost:8080/order/{menuId}。
        // 因此，需要在 @PathVariable 中指定 menuId 参数。
        orderItemService.saveOrderItem(menuId);
        // 调用 OrderItemService 中的 saveOrderItem 方法，向数据库中插入数据。
    }
}

Make sure login before add an item to the cart.

Get user's cart

Crate CartService.java under service package

package com.eve.onlineOrder.service;

import com.eve.onlineOrder.entity.Cart;
import com.eve.onlineOrder.entity.Customer;
import com.eve.onlineOrder.entity.OrderItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

@Service // @Service 用于标注业务层组件，即 Service 组件。
// Service 层用于实现业务逻辑，例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
public class CartService {
    @Autowired // @Autowired 用于自动装配，将 CustomerService 注入到 MenuInfoController 中。
    private CustomerService customerService;

    public Cart getCart(){ // getCart 方法用于获取购物车信息。
        Authentication loggedInUser = SecurityContextHolder.getContext().getAuthentication();
        // Authentication 对象用于封装认证信息。
        // 例如，当用户登录时，需要向数据库中的 customer 表和 authorities 表中插入数据。
        String username = loggedInUser.getName();
        // getName 方法用于获取用户名。
        // 例如，当用户登录时，需要获取用户名。
        Customer customer = customerService.getCustomer(username);
        // 调用 CustomerService 中的 getCustomer 方法，获取用户信息。
        // 例如，当用户登录时，需要获取用户信息。


        if (customer != null){
            // 如果用户信息不为空，则获取购物车信息。
            Cart cart = customer.getCart();
            // Cart 对象用于封装购物车信息。
            double totalPrice = 0;
            // totalPrice 用于封装购物车中所有菜品的总价格。
            for (OrderItem item : cart.getOrderItemList()){
                // 遍历购物车中的所有菜品。
                totalPrice += item.getQuantity() * item.getMenuItem().getPrice();
                // 计算购物车中所有菜品的总价格。
            }

            cart.setTotalPrice(totalPrice);
            // setTotalPrice 方法用于设置购物车中所有菜品的总价格。
            return cart; // 返回购物车信息。
        }
        return new Cart(); // 如果用户信息为空，则返回一个空的购物车信息。

    }
}

Update CartController.java

package com.eve.onlineOrder.controller;

import com.eve.onlineOrder.entity.Cart;
import com.eve.onlineOrder.service.CartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller // @Controller 用于标注控制层组件，即 Controller 组件。
// Controller 层用于接收请求，调用 Service 层的方法，将数据返回给前端页面。
// 例如，当用户访问 http://localhost:8080/cart 时，需要将购物车信息返回给前端页面。
//  因此，需要在 Controller 层中实现将购物车信息返回给前端页面的业务逻辑。
public class CartController {
    @Autowired
    private CartService cartService;
    // @Autowired 用于自动装配，将 CartService 注入到 CartController 中。


    @RequestMapping(value="/cart", method = RequestMethod.GET)
    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/cart
    // 表示请求的 URL 为 http://localhost:8080/cart。
    // method 属性用于指定请求的方法。例如，RequestMethod.GET 表示请求的方法为 GET。
    // RequestMethod 是一个枚举类，包含了所有的请求方法。
    @ResponseBody // @ResponseBody 用于将返回的数据放到响应体中。
    // 例如，当用户访问 http://localhost:8080/cart 时，需要将购物车信息返回给前端页面。
    // 因此，需要将购物车信息放到响应体中，然后返回给前端页面。
    public Cart getCart() {
        return cartService.getCart(); // 调用 CartService 中的 getCart 方法，获取购物车信息。
    }


}

Checkout

Create CartDao.java class under dao package

CartDao.java:

package com.eve.onlineOrder.dao;

import com.eve.onlineOrder.entity.Cart;
import com.eve.onlineOrder.entity.OrderItem;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository // @Repository 用于标注数据访问层组件，即 Dao 组件。
// Dao 层用于与数据库进行交互，包括增删改查等操作。
// Repository 是一个泛型注解，包含了 @Component 注解的功能。
// 例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
public class Cartdao {
    // 因此，需要在 Dao 层中实现向数据库中插入数据的业务逻辑。
    // 例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
    @Autowired // @Autowired 用于自动装配，将 SessionFactory 注入到 Cartdao 中。
    // SessionFactory 用于创建 Session 对象。
    private SessionFactory sessionFactory; // SessionFactory 用于创建 Session 对象。

    public void removeCartItem(int orderItemId){
        // removeCartItem 方法用于删除购物车项。
        Session session = null; // Session 对象用于封装与数据库的连接。

        try {
            session = sessionFactory.openSession();
            // openSession 方法用于创建 Session 对象。
            OrderItem cartItem = session.get(OrderItem.class, orderItemId);
            // get 方法用于获取数据库中的数据。
            Cart cart = cartItem.getCart();
            // getCart 方法用于获取购物车信息。
            cart.getOrderItemList().remove(cartItem);
            // getOrderItemList 方法用于获取购物车中的所有菜品。

            session.beginTransaction();
            // beginTransaction 方法用于开启事务。
            session.delete(cartItem);
            // delete 方法用于删除数据库中的数据。
            session.getTransaction().commit();
            // commit 方法用于提交事务。
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
            // rollback 方法用于回滚事务。
        } finally {
            if(session != null){
                session.close();
            }
        }
    }

    public void removeAllCartItems(Cart cart){
        // removeAllCartItems 方法用于删除购物车中的所有菜品。
        for (OrderItem item : cart.getOrderItemList()){
            removeCartItem(item.getId());
        }

    }

}

Add cleanCart method to the CartService.java

package com.eve.onlineOrder.service;

import com.eve.onlineOrder.dao.CartDao;
import com.eve.onlineOrder.entity.Cart;
import com.eve.onlineOrder.entity.Customer;
import com.eve.onlineOrder.entity.OrderItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

@Service // @Service 用于标注业务层组件，即 Service 组件。
// Service 层用于实现业务逻辑，例如，当用户注册时，需要向数据库中的 customer 表和 authorities 表中插入数据。
public class CartService {
    @Autowired // @Autowired 用于自动装配，将 CustomerService 注入到 MenuInfoController 中。
    private CustomerService customerService;

    @Autowired
    private CartDao cartDao;

    public Cart getCart(){ // getCart 方法用于获取购物车信息。
        Authentication loggedInUser = SecurityContextHolder.getContext().getAuthentication();
        // Authentication 对象用于封装认证信息。
        // 例如，当用户登录时，需要向数据库中的 customer 表和 authorities 表中插入数据。
        String username = loggedInUser.getName();
        // getName 方法用于获取用户名。
        // 例如，当用户登录时，需要获取用户名。
        Customer customer = customerService.getCustomer(username);
        // 调用 CustomerService 中的 getCustomer 方法，获取用户信息。
        // 例如，当用户登录时，需要获取用户信息。


        if (customer != null){
            // 如果用户信息不为空，则获取购物车信息。
            Cart cart = customer.getCart();
            // Cart 对象用于封装购物车信息。
            double totalPrice = 0;
            // totalPrice 用于封装购物车中所有菜品的总价格。
            for (OrderItem item : cart.getOrderItemList()){
                // 遍历购物车中的所有菜品。
                totalPrice += item.getQuantity() * item.getMenuItem().getPrice();
                // 计算购物车中所有菜品的总价格。
            }

            cart.setTotalPrice(totalPrice);
            // setTotalPrice 方法用于设置购物车中所有菜品的总价格。
            return cart; // 返回购物车信息。
        }
        return new Cart(); // 如果用户信息为空，则返回一个空的购物车信息。

    }

    public void cleanCart(){
        Authentication loggedInUser = SecurityContextHolder.getContext().getAuthentication();
        String username = loggedInUser.getName();
        Customer customer = customerService.getCustomer(username);
        if (customer != null){
            Cart cart = customer.getCart();
            cartDao.removeAllCartItems(cart);
        }

    }
}

Update CheckoutController.java

package com.eve.onlineOrder.controller;

import com.eve.onlineOrder.service.CartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;

@Controller // @Controller 用于标注控制层组件，即 Controller 组件。
// Controller 层用于接收请求，调用 Service 层的方法，将数据返回给前端页面。
public class CheckoutController {
    @Autowired
    private CartService cartService;

    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/checkout
    // 表示请求的 URL 为 http://localhost:8080/checkout。
    @RequestMapping(value = "/checkout", method = RequestMethod.GET)
    // @RequestMapping 用于映射请求，即指定请求的 URL。
    // value 属性用于指定请求的 URL。例如，/checkout
    // 表示请求的 URL 为 http://localhost:8080/checkout。
    @ResponseStatus(value = HttpStatus.OK)
    // @ResponseStatus 用于指定响应的状态码。
    // value 属性用于指定响应的状态码。例如，HttpStatus.OK 表示响应的状态码为 200。
    // HttpStatus 是一个枚举类，包含了所有的状态码
    public void checkout() { // checkout 方法用于实现结账的业务逻辑
    }
}