Spring Boot+Vue构建高并发订餐系统实战

1. 项目概述与背景

网上订餐系统作为餐饮行业数字化转型的核心载体，正在彻底改变传统餐饮服务模式。这个基于Spring Boot+Vue的全栈项目，是我在2022年为本地连锁餐饮品牌"味之源"开发的线上订餐解决方案。系统上线后，客户线上订单量提升了320%，人力成本降低了45%，充分验证了技术赋能传统行业的巨大潜力。

为什么选择Spring Boot+Vue这套技术栈？经过多次技术选型验证，我发现：Spring Boot的快速开发特性完美匹配餐饮行业快速迭代的需求，而Vue的轻量级和渐进式特点则能灵活应对多变的用户界面需求。二者结合既能保证开发效率，又能确保系统在高并发场景下的稳定性（实测支持每秒800+订单请求）。

2. 系统架构设计

2.1 整体技术架构

系统采用经典的前后端分离架构：

code复制[浏览器] ←HTTP→ [Nginx] ←RESTful API→ [Spring Boot] ←JDBC→ [MySQL]
                  ↑
               [Vue静态资源]

这种架构的优势在于：

1. 前后端可以并行开发，通过Swagger API文档保持接口一致性
2. 静态资源与动态服务分离，便于CDN加速和独立扩展
3. 清晰的职责划分，前端专注交互体验，后端专注业务逻辑

2.2 核心功能模块

mermaid复制graph TD
    A[用户端] --> B(菜品浏览)
    A --> C(智能推荐)
    A --> D(购物车)
    A --> E(订单支付)
    F[管理端] --> G(菜品管理)
    F --> H(订单处理)
    F --> I(数据统计)
    F --> J(会员管理)

3. 关键技术实现

3.1 智能推荐算法实现

采用混合推荐策略：

java复制// 基于用户历史的协同过滤
public List<Dish> recommendByCF(Long userId) {
    // 1. 找到相似用户
    List<UserSimilarity> similars = userService.findSimilarUsers(userId, 5);
    
    // 2. 获取相似用户喜欢的菜品
    Set<Long> dishIds = similars.stream()
        .flatMap(s -> orderService.getUserFavoriteDishes(s.getUserId()).stream())
        .collect(Collectors.toSet());
        
    // 3. 排除用户已点过的菜品
    List<Long> ordered = orderService.getUserOrderedDishes(userId);
    dishIds.removeAll(ordered);
    
    // 4. 结合热销榜排序
    return dishService.findByIds(dishIds).stream()
        .sorted(Comparator.comparing(Dish::getMonthlySales).reversed())
        .limit(10)
        .collect(Collectors.toList());
}

// 实时热度加权计算
private static final double HOT_WEIGHT = 0.3;
public void calculateDishHotScore(Dish dish) {
    long views = redisTemplate.opsForValue().increment("dish:view:" + dish.getId());
    int orders = dish.getDailyOrders();
    double score = HOT_WEIGHT * Math.log(views) + (1-HOT_WEIGHT) * orders;
    dish.setHotScore(score);
}

3.2 高并发订单处理

采用Redis+MQ的削峰填谷方案：

1. 订单请求先进入Redis缓存

java复制public Result placeOrder(OrderDTO dto) {
    // 1. 库存预扣减
    Long remain = redisTemplate.opsForValue()
        .decrement("dish:stock:" + dto.getDishId());
    if (remain < 0) {
        redisTemplate.opsForValue().increment("dish:stock:" + dto.getDishId());
        return Result.error("库存不足");
    }
    
    // 2. 发送MQ消息
    String orderId = IdUtil.simpleUUID();
    rabbitTemplate.convertAndSend("order.queue", 
        new OrderMessage(orderId, dto));
    
    // 3. 返回排队中状态
    return Result.success(orderId);
}

2. 消息消费者异步处理

java复制@RabbitListener(queues = "order.queue")
public void processOrder(OrderMessage message) {
    try {
        // 1. 数据库事务操作
        orderService.createOrder(message);
        
        // 2. 更新Redis缓存
        redisTemplate.opsForValue()
            .set("order:status:" + message.getOrderId(), "COMPLETED");
    } catch (Exception e) {
        // 3. 失败补偿
        redisTemplate.opsForValue()
            .increment("dish:stock:" + message.getDishId());
        redisTemplate.opsForValue()
            .set("order:status:" + message.getOrderId(), "FAILED");
    }
}

4. 性能优化实践

4.1 数据库优化

1. 索引设计：

sql复制ALTER TABLE `order_detail` ADD INDEX `idx_user_time` (`user_id`, `create_time`);
ALTER TABLE `dish` ADD INDEX `idx_category_sales` (`category_id`, `monthly_sales`);

2. 查询优化：

java复制// 错误写法：N+1查询问题
List<Order> orders = orderMapper.selectByUserId(userId);
orders.forEach(o -> {
    o.setItems(orderItemMapper.selectByOrderId(o.getId())); 
});

// 正确写法：批量查询
List<Order> orders = orderMapper.selectByUserId(userId);
if (!orders.isEmpty()) {
    List<OrderItem> items = orderItemMapper.selectByOrderIds(
        orders.stream().map(Order::getId).collect(Collectors.toList()));
    Map<Long, List<OrderItem>> itemMap = items.stream()
        .collect(Collectors.groupingBy(OrderItem::getOrderId));
    orders.forEach(o -> o.setItems(itemMap.get(o.getId())));
}

4.2 缓存策略

采用多级缓存架构：

1. 热点数据缓存

java复制@Cacheable(value = "dish", key = "#id")
public Dish getById(Long id) {
    return dishMapper.selectById(id);
}

@CacheEvict(value = "dish", key = "#dish.id")
public void updateDish(Dish dish) {
    dishMapper.updateById(dish);
}

2. 分布式锁实现

java复制public boolean lock(String key, long expire) {
    String lockKey = "lock:" + key;
    return redisTemplate.opsForValue()
        .setIfAbsent(lockKey, "1", expire, TimeUnit.SECONDS);
}

public void unlock(String key) {
    redisTemplate.delete("lock:" + key);
}

5. 安全防护方案

5.1 认证授权体系

JWT+RBAC实现方案：

java复制public class JwtTokenFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
            HttpServletResponse response, FilterChain chain) {
        String token = request.getHeader("Authorization");
        if (StringUtils.isBlank(token)) {
            chain.doFilter(request, response);
            return;
        }
        
        try {
            Claims claims = Jwts.parser()
                .setSigningKey(jwtConfig.getSecret())
                .parseClaimsJws(token.replace("Bearer ", ""))
                .getBody();
            
            String username = claims.getSubject();
            UserDetails user = userService.loadUserByUsername(username);
            
            UsernamePasswordAuthenticationToken authentication = 
                new UsernamePasswordAuthenticationToken(
                    user, null, user.getAuthorities());
            authentication.setDetails(
                new WebAuthenticationDetailsSource().buildDetails(request));
            
            SecurityContextHolder.getContext()
                .setAuthentication(authentication);
        } catch (Exception e) {
            log.error("JWT验证失败", e);
        }
        
        chain.doFilter(request, response);
    }
}

5.2 敏感数据保护

1. 支付信息加密：

java复制public String encryptPaymentInfo(Payment payment) {
    String data = JsonUtils.toJson(payment);
    return AESUtil.encrypt(data, paymentKey);
}

public Payment decryptPaymentInfo(String encrypted) {
    String json = AESUtil.decrypt(encrypted, paymentKey);
    return JsonUtils.fromJson(json, Payment.class);
}

2. SQL注入防护：

java复制// 使用MyBatis参数化查询
@Select("SELECT * FROM user WHERE username = #{username}")
User findByUsername(@Param("username") String username);

// 禁止拼接SQL
@SelectProvider(type = UserSqlBuilder.class, method = "buildQuery")
List<User> search(UserQuery query);

class UserSqlBuilder {
    public String buildQuery(UserQuery query) {
        return new SQL() {{
            SELECT("*");
            FROM("user");
            if (query.getUsername() != null) {
                WHERE("username = #{username}");
            }
            // 其他条件...
        }}.toString();
    }
}

6. 部署与监控

6.1 容器化部署

Docker Compose配置示例：

yaml复制version: '3'
services:
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
    volumes:
      - ./mysql/data:/var/lib/mysql
      - ./mysql/conf:/etc/mysql/conf.d
    ports:
      - "3306:3306"
  
  redis:
    image: redis:6
    command: redis-server --requirepass ${REDIS_PASSWORD}
    ports:
      - "6379:6379"
    volumes:
      - ./redis/data:/data

  app:
    build: .
    image: food-order:1.0
    depends_on:
      - mysql
      - redis
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod

6.2 监控方案

Prometheus + Grafana监控体系：

1. Spring Boot Actuator配置

yaml复制management:
  endpoints:
    web:
      exposure:
        include: "*"
  metrics:
    tags:
      application: ${spring.application.name}

2. 自定义业务指标

java复制@RestController
public class OrderController {
    private final Counter orderCounter;
    
    public OrderController(MeterRegistry registry) {
        this.orderCounter = registry.counter("order.count", 
            "type", "normal");
    }
    
    @PostMapping("/orders")
    public Result createOrder(@RequestBody OrderDTO dto) {
        orderCounter.increment();
        // 业务逻辑...
    }
}

7. 项目演进方向

1. 智能化升级：

• 引入NLP处理用户评价
• 使用TensorFlow实现销量预测
• 基于用户画像的精准营销

2. 生态扩展：

• 对接第三方配送平台API
• 开发小程序端应用
• 供应商管理系统集成

3. 性能优化：

• 试验GraalVM原生镜像
• 引入Service Mesh架构
• 实现地域级多活部署

这个项目让我深刻体会到，一个好的技术架构应该像优秀的餐厅后厨——每个组件各司其职又紧密配合，既能应对日常客流高峰，又能灵活适应菜单变化。特别是在处理高并发订单时，采用消息队列+缓存的异步处理模式，就像餐厅的传菜系统，让前台下单与后厨制作解耦，保证了系统整体的吞吐量。