1 简介

面向对象（OO）方法中的“封装” 和 信息工程中的“数据完整性约束” 实现商品买卖管理和订单状态管理功能。我们将展示如何通过封装保证服务接口的易用性和可靠性，以及如何通过数据完整性约束保证业务逻辑的正确性。

2. 场景描述

• 封装：

将商品库存管理、订单创建和状态更新等功能封装为独立的业务逻辑模块，隐藏实现细节，暴露安全的接口。
通过封装避免外部直接修改商品库存或订单状态，从而保证数据一致性。

• 数据完整性约束：

商品库存不能为负数。

订单的状态必须遵循合法的流转规则：

	Created → Paid → Shipped → Completed
	或 Created → Cancelled。

3. 数据模型设计和代码实现

实体设计：

	Product：表示商品，包括库存信息。
	Order：表示订单，包括状态和购买的商品数量。

约束设计：

	Product 的库存减少时，必须保证库存非负。
	Order 的状态流转必须符合约定规则。

• 实现代码

    package main
  
    import (
    	"encoding/json"
    	"fmt"
    	"net/http"
    	"sync"
    )
  
    // Product 表示商品实体
    type Product struct {
    	ID       int    `json:"id"`
    	Name     string `json:"name"`
    	Stock    int    `json:"stock"` // 库存
    	Price    float64 `json:"price"`
    }
  
    // Order 表示订单实体
    type Order struct {
    	ID        int    `json:"id"`
    	ProductID int    `json:"product_id"`
    	Quantity  int    `json:"quantity"`
    	Status    string `json:"status"` // Created, Paid, Shipped, Completed, Cancelled
    }
  
    // 模拟数据库
    var (
    	products = struct {
    		sync.Mutex
    		data map[int]*Product
    	}{data: make(map[int]*Product)}
  
    	orders = struct {
    		sync.Mutex
    		data map[int]*Order
    	}{data: make(map[int]*Order)}
    )
  
    // 创建商品
    func createProductHandler(w http.ResponseWriter, r *http.Request) {
    	var product Product
    	if err := json.NewDecoder(r.Body).Decode(&product); err != nil {
    		http.Error(w, "Invalid input", http.StatusBadRequest)
    		return
    	}
  
    	products.Lock()
    	defer products.Unlock()
    	product.ID = len(products.data) + 1
    	products.data[product.ID] = &product
  
    	w.WriteHeader(http.StatusCreated)
    	json.NewEncoder(w).Encode(product)
    }
  
    // 创建订单
    func createOrderHandler(w http.ResponseWriter, r *http.Request) {
    	var order Order
    	if err := json.NewDecoder(r.Body).Decode(&order); err != nil {
    		http.Error(w, "Invalid input", http.StatusBadRequest)
    		return
    	}
  
    	products.Lock()
    	defer products.Unlock()
    	orders.Lock()
    	defer orders.Unlock()
  
    	// 检查商品是否存在
    	product, exists := products.data[order.ProductID]
    	if !exists {
    		http.Error(w, "Product not found", http.StatusNotFound)
    		return
    	}
  
    	// 检查库存是否足够
    	if product.Stock < order.Quantity {
    		http.Error(w, "Not enough stock", http.StatusConflict)
    		return
    	}
  
    	// 减少库存并创建订单
    	product.Stock -= order.Quantity
    	order.ID = len(orders.data) + 1
    	order.Status = "Created"
    	orders.data[order.ID] = &order
  
    	w.WriteHeader(http.StatusCreated)
    	json.NewEncoder(w).Encode(order)
    }
  
    // 更新订单状态
    func updateOrderStatusHandler(w http.ResponseWriter, r *http.Request) {
    	var input struct {
    		OrderID int    `json:"order_id"`
    		Action  string `json:"action"` // Pay, Ship, Complete, Cancel
    	}
    	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
    		http.Error(w, "Invalid input", http.StatusBadRequest)
    		return
    	}
  
    	orders.Lock()
    	defer orders.Unlock()
    	products.Lock()
    	defer products.Unlock()
  
    	// 检查订单是否存在
    	order, exists := orders.data[input.OrderID]
    	if !exists {
    		http.Error(w, "Order not found", http.StatusNotFound)
    		return
    	}
  
    	// 根据动作更新订单状态
    	switch input.Action {
    	case "Pay":
    		if order.Status != "Created" {
    			http.Error(w, "Order cannot be paid", http.StatusConflict)
    			return
    		}
    		order.Status = "Paid"
  
    	case "Ship":
    		if order.Status != "Paid" {
    			http.Error(w, "Order cannot be shipped", http.StatusConflict)
    			return
    		}
    		order.Status = "Shipped"
  
    	case "Complete":
    		if order.Status != "Shipped" {
    			http.Error(w, "Order cannot be completed", http.StatusConflict)
    			return
    		}
    		order.Status = "Completed"
  
    	case "Cancel":
    		if order.Status != "Created" {
    			http.Error(w, "Only created orders can be cancelled", http.StatusConflict)
    			return
    		}
    		order.Status = "Cancelled"
  
    		// 取消订单时恢复库存
    		product, productExists := products.data[order.ProductID]
    		if productExists {
    			product.Stock += order.Quantity
    		}
  
    	default:
    		http.Error(w, "Invalid action", http.StatusBadRequest)
    		return
    	}
  
    	w.WriteHeader(http.StatusOK)
    	json.NewEncoder(w).Encode(order)
    }
  
    // 查询商品列表
    func listProductsHandler(w http.ResponseWriter, r *http.Request) {
    	products.Lock()
    	defer products.Unlock()
  
    	var productList []Product
    	for _, product := range products.data {
    		productList = append(productList, *product)
    	}
  
    	json.NewEncoder(w).Encode(productList)
    }
  
    // 查询订单列表
    func listOrdersHandler(w http.ResponseWriter, r *http.Request) {
    	orders.Lock()
    	defer orders.Unlock()
  
    	var orderList []Order
    	for _, order := range orders.data {
    		orderList = append(orderList, *order)
    	}
  
    	json.NewEncoder(w).Encode(orderList)
    }
  
    func main() {
    	// 路由配置
    	http.HandleFunc("/products", createProductHandler)         // 创建商品
    	http.HandleFunc("/orders", createOrderHandler)             // 创建订单
    	http.HandleFunc("/orders/update", updateOrderStatusHandler) // 更新订单状态
    	http.HandleFunc("/products/list", listProductsHandler)      // 查询商品列表
    	http.HandleFunc("/orders/list", listOrdersHandler)          // 查询订单列表
  
    	// 启动服务器
    	fmt.Println("Server is running at http://localhost:8080")
    	http.ListenAndServe(":8080", nil)
    }
  

4 实现说明

封装，模块化实现：

createProductHandler 封装了商品创建逻辑，外部无法直接修改库存。
updateOrderStatusHandler 封装了订单状态更新逻辑，只允许合法的状态流转。

隐藏细节：

内部通过锁机制保护共享数据，外部调用者无需关心。
数据完整性约束

库存约束：

在 createOrderHandler 中，库存必须足够才能创建订单。
在订单取消时（Cancel），库存恢复，确保一致性。

状态约束：

订单状态必须按照规定顺序流转，避免非法状态。

5. 小结和测试

• 创建商品

    curl -X POST -H "Content-Type: application/json" -d '{"name": "Laptop", "stock": 10, "price": 1200.50}' http://localhost:8080/products
  

• 创建订单

    curl -X POST -H "Content-Type: application/json" -d '{"product_id": 1, "quantity": 2}' http://localhost:8080/orders
  

• 更新订单状态支付订单：

    curl -X POST -H "Content-Type: application/json" -d '{"order_id": 1, "action": "Pay"}' http://localhost:8080/orders/update
  

• 发货订单：

    curl -X POST -H "Content-Type: application/json" -d '{"order_id": 1, "action": "Ship"}' http://localhost:8080/orders/update
  

• 完成订单：

    curl -X POST -H "Content-Type: application/json" -d '{"order_id": 1, "action": "Complete"}' http://localhost:8080/orders/update
  

• 小结

封装：模块化逻辑，隐藏数据操作细节，保证接口简洁和安全。
数据完整性约束：通过库存约束和状态流转规则，确保系统数据的一致性和正确性。