　　2026年，餐饮行业的数字化早已不是"要不要做"的选择题，而是"怎么做才能活下来"的必答题。调研数据显示，超5成餐饮企业认为数字化可以带动客流增长，近3成认为数字化能直接增加利润。海底捞、西贝、呷哺等头部品牌均已加大数字化布局，欲通过技术实现降本增效。而当大模型技术浪潮席卷而来，点餐系统不再只是一个"下单工具"——它正在进化为餐厅的智能中枢。本文将从架构设计、核心模块源码、大模型接入策略三个维度，拆解一套可落地的点餐系统小程序方案。

　　 为什么点餐系统必须接入大模型？

　　传统点餐系统解决的是"能点餐"的问题，而大模型接入后解决的是"点得好"的问题。

源码及演示：s.ymzan.top

　　核心价值体现在三个层面：

　　场景传统方案大模型方案

　　菜品推荐人工设置"热销榜"基于用户历史订单的语义理解，个性化推荐

　　客服应答固定FAQ natural language交互，处理"有没有不辣的""适合小孩吃的"等模糊需求

　　经营分析简单报表自动生成经营洞察："本周川菜销量下降12%，建议调整促销策略"

　　据行业数据，使用智能推荐的餐厅，客单价平均提升15%-20%。这不是锦上添花，而是实实在在的利润引擎。

　　 系统架构设计：微服务+跨端+AI三层融合

　　整套系统采用前后端分离的微服务架构，前端基于UniApp 3.0实现多端编译（微信小程序/支付宝小程序/H5/App），后端基于Spring Boot 3.x+Spring Cloud Gateway构建API网关，数据库采用MySQL 8.0+Redis 7.0混合存储。

　　1.整体架构图

┌─────────────────────────────────────────────┐
│                  客户端层                      │
│   UniApp(微信/支付宝/H5/App) + Vant Weapp     │
├─────────────────────────────────────────────┤
│                 API网关层                      │
│   Spring Cloud Gateway (JWT鉴权+限流)          │
├──────────┬──────────┬───────────┬────────────┤
│ 用户服务  │ 订单服务  │  菜品服务   │ AI推荐服务  │
│ Spring   │ Spring   │  Spring    │ Python      │
│ Boot     │ Boot     │  Boot      │ FastAPI     │
├──────────┴──────────┴───────────┴────────────┤
│                 数据层                         │
│  MySQL 8.0(主从) + Redis 7.0 + MongoDB        │
└─────────────────────────────────────────────┘

　　2.技术栈选型依据

　　 核心模块源码实现

　　1.微信小程序端：扫码点餐页面

　　这是用户接触的第一界面，采用WXML原生语法编写，通过条件编译适配多端。

<!-- pages/scanOrder/scanOrder.wxml -->
<view class="container">
  <!-- 菜品分类导航 -->
  <scroll-view class="category-scroll" scroll-x>
    <view wx:for="{{categoryList}}" wx:key="categoryId" 
          class="category-item {{currentCategory === item.categoryId ? 'active' : ''}}" 
          bindtap="switchCategory" data-categoryid="{{item.categoryId}}">
      {{item.categoryName}}
    </view>
  </scroll-view>
  <!-- 菜品列表 -->
  <view class="dish-list">
    <view wx:for="{{dishList}}" wx:key="dishId" class="dish-item">
      <image src="{{dish.imageUrl}}" mode="widthFix" class="dish-img" />
      <view class="dish-info">
        <view class="dish-name">{{dish.dishName}}</view>
        <view class="dish-price">¥{{dish.price.toFixed(2)}}</view>
        <view class="dish-desc">{{dish.description}}</view>
      </view>
      <view class="dish-action">
        <button class="add-btn" bindtap="addCart" data-dishid="{{dish.dishId}}" 
                disabled="{{dish.stock <= 0}}">
          {{dish.stock <= 0 ? '已售罄' : '加入购物车'}}
        </button>
      </view>
    </view>
  </view>
  <!-- 购物车悬浮按钮 -->
  <view class="cart-btn" bindtap="goToCart">
    <image src="/images/cart.png" mode="widthFix" class="cart-icon" />
    <view class="cart-count" wx:if="{{cartCount > 0}}">{{cartCount}}</view>
  </view>
</view>

　　购物车状态通过Pinia管理，支持本地持久化：

// stores/cart.ts
import { defineStore } from 'pinia'
import type { CartItem } from '@/types'
export const useCartStore = defineStore('cart', {
  state: () => ({
    items: [] as CartItem[],
    totalPrice: 0
  }),
  actions: {
    addItem(item: CartItem) {
      const exist = this.items.find(i => i.id === item.id)
      if (exist) {
        exist.count++
      } else {
        this.items.push({ ...item, count: 1 })
      }
      this.calcTotal()
      this.persist()
    },
    persist() {
      uni.setStorageSync('cart', JSON.stringify(this.items))
    }
  },
  persist: {
    enabled: true,
    strategies: [{
      storage: {
        getItem: (key) => uni.getStorageSync(key),
        setItem: (key, value) => uni.setStorageSync(key, value)
      }
    }]
  }
})

　　2.后端：订单创建与支付流程

　　订单服务采用Spring Boot 3.x开发，通过Redis分布式锁保证购物车并发安全。

// OrderService.java
@Service
public class OrderService {
    
    @Autowired private OrderRepository orderRepository;
    @Autowired private RedisLock redisLock;
    
    public Order placeOrder(Long userId, List<Long> dishIds) {
        String lockKey = "order:lock:" + userId;
        
        try {
            if (!redisLock.tryLock(lockKey, 10)) {
                throw new RuntimeException("系统繁忙，请稍后重试");
            }
            
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new RuntimeException("用户不存在"));
            
            List<Dish> dishes = dishRepository.findByIds(dishIds);
            BigDecimal totalPrice = dishes.stream()
                .map(Dish::getPrice)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
            
            Order order = new Order();
            order.setUser(user);
            order.setDishes(dishes);
            order.setTotalPrice(totalPrice);
            order.setStatus(OrderStatus.UNPAID);
            
            return orderRepository.save(order);
            
        } finally {
            redisLock.releaseLock(lockKey);
        }
    }
}

Redis分布式锁实现：

// RedisLock.java
@Component
public class RedisLock {
    
    @Autowired private StringRedisTemplate stringRedisTemplate;
    
    public boolean tryLock(String lockKey, long expireTime) {
        String lockValue = UUID.randomUUID().toString();
        Boolean success = stringRedisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, expireTime, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }
    
    public boolean releaseLock(String lockKey, String lockValue) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                       "return redis.call('del', KEYS[1]) else return 0 end";
        Long result = stringRedisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Arrays.asList(lockKey), lockValue
        );
        return result != null && result == 1;
    }
}

　　支付接口集成微信支付SDK：

// PaymentController.java
@RestController
@RequestMapping("/api/payment")
public class PaymentController {
    
    @Autowired private PaymentService paymentService;
    
    @PostMapping("/create")
    public ResponseEntity<PaymentResponse> createPayment(
            @RequestBody PaymentRequest request) {
        PaymentResponse response = paymentService.createPayment(request);
        return ResponseEntity.ok(response);
    }
}
// 小程序端调用支付
wx.request({
  url: 'https://api.example.com/api/payment/create',
  method: 'POST',
  data: { dishIds: [1, 2, 3], addressId: 101 },
  success(res) {
    const paymentData = res.data;
    wx.requestPayment(paymentData);
  }
});

　　3.大模型接入：AI智能推荐服务

　　这是整套系统的核心差异化模块。AI推荐服务基于Python FastAPI独立部署，通过gRPC与Java订单服务通信。

# ai_recommend_service.py
from fastapi import FastAPI
from openai import OpenAI
import redis
app = FastAPI()
client = OpenAI(api_key="your-api-key")
redis_client = redis.Redis(host='localhost', port=6379, db=0)
@app.post("/api/recommend")
async def recommend_dishes(user_id: int, history_orders: list):
    """基于用户历史订单，调用大模型生成个性化推荐"""
    
    # 构建prompt
    prompt = f"""
    你是一位资深餐饮顾问。根据以下用户的历史订单数据，
    推荐3道他可能喜欢的菜品，并给出推荐理由。
    
    历史订单：{history_orders}
    
    请以JSON格式返回：
    {{"recommendations": [{{"dish_name": "", "reason": ""}}]}}
    """
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    
    result = response.choices[0].message.content
    return {"recommendations": parse_json(result)}
@app.post("/api/chat")
async def ai_chat(question: str, context: dict):
    """自然语言点餐助手"""
    prompt = f"""
    用户问题：{question}
    当前可用菜品：{context['dishes']}
    用户偏好：{context.get('preferences', '无特殊偏好')}
    
    请用友好的语气回答，并推荐合适的菜品。
    """
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    return {"answer": response.choices[0].message.content}

　　前端调用AI推荐接口：

// pages/menu/menu.ts
Page({
  data: { dishes: [], aiRecommendations: [] },
  
  onLoad() {
    this.loadDishes();
    this.loadAIRecommendations();
  },
  
  async loadAIRecommendations() {
    const res = await wx.request({
      url: 'https://ai-api.example.com/api/recommend',
      method: 'POST',
      data: {
        userId: getApp().globalData.userId,
        historyOrders: getApp().globalData.orderHistory
      }
    });
    this.setData({ aiRecommendations: res.data.recommendations });
  },
  
  async askAI(question: string) {
    const res = await wx.request({
      url: 'https://ai-api.example.com/api/chat',
      method: 'POST',
      data: {
        question,
        context: {
          dishes: this.data.dishes,
          preferences: '微辣，不吃香菜'
        }
      }
    });
    wx.showModal({ title: 'AI推荐', content: res.data.answer, showCancel: false });
  }
});

　　 数据库设计与部署方案

　　核心表结构

-- 用户表
CREATE TABLE `users` (
  `id` INT AUTO_INCREMENT PRIMARY KEY,
  `phone` VARCHAR(11) NOT NULL UNIQUE,
  `nickname` VARCHAR(50),
  `preferences` JSON COMMENT '口味偏好，JSON存储'
);
-- 订单表（按月份分片）
CREATE TABLE `orders_202606` (
  `order_id` VARCHAR(32) PRIMARY KEY,
  `user_id` INT,
  `total_price` DECIMAL(10,2),
  `status` ENUM('pending','paid','cooking','delivered') DEFAULT 'pending',
  `ai_recommendations` JSON COMMENT 'AI推荐的菜品快照',
  `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP,
  INDEX `idx_user_time` (`user_id`, `created_at`)
) ENGINE=InnoDB;
-- 菜品表
CREATE TABLE `dishes` (
  `dish_id` INT AUTO_INCREMENT PRIMARY KEY,
  `name` VARCHAR(100),
  `price` DECIMAL(8,2),
  `category_id` INT,
  `stock` INT DEFAULT 0,
  `sales_count` INT DEFAULT 0,
  INDEX `idx_category` (`category_id`)
);

　　部署配置

　　结语

　　餐饮数字化的竞争，本质上是效率与体验的竞争。这套点餐系统源码的核心逻辑很简单：用成熟的微服务架构解决"稳不稳"的问题，用大模型接入解决"聪不聪明"的问题。两者结合，才能让餐厅真正实现从"等客上门"到"懂客留客"的转变。但也要清醒看到，技术只是杠杆，不是答案。源码能跑通，不代表业务能跑通。接入大模型后，真正的挑战在于数据质量——你的历史订单够不够丰富？菜品标签够不够细？这些才决定AI推荐是"精准"还是"鸡肋"。

　　建议中小餐厅分两步走：第一步先跑通基础点餐和支付，第二步再叠加AI模块。别一上来就追求"全智能"，先让系统活下来，再让它聪明起来。数字化这条路，走得稳比走得快更重要。

ITPub博客

接入大模型的点餐系统小程序源码：餐厅数字化新标配