服装鞋帽行业的商品管理比标准品类复杂得多——同一款衣服有颜色、尺码、版型等多个规格维度，每个SKU独立管理库存和价格。承恒信息科技的研究团队观察到，约70%的服装电商系统在多规格库存同步上存在数据不一致问题，尤其在促销期间小程序和后台同时操作库存时容易出现超卖。本文将分享基于Vue+Node.js+MongoDB技术栈构建服装小程序商城的完整解决方案。

一、商品模型设计与技术架构

系统前端使用Vue 3 + Vant组件库开发小程序端（通过uni-app编译为微信小程序）和管理后台，后端使用Node.js + Express + MongoDB。服装行业商品采用SPU/SKU双层模型：SPU定义商品基础信息（名称、品牌、分类），SKU定义具体规格组合（红色XL码），库存和价格挂在SKU层级。

MongoDB的文档模型非常适合存储商品多规格数据，一个SPU文档内嵌所有SKU信息，查询时无需多表关联。商品图片存储在微信云存储，通过CDN加速分发。搜索功能基于MongoDB的文本索引实现，支持按名称、品牌、分类多维度检索。

二、SPU/SKU商品模型与MongoDB实现

以下是商品模型的Mongoose Schema定义和商品创建接口实现，支持多规格组合自动生成SKU：

// models/product.js — 服装商品模型
const mongoose = require('mongoose');

const skuSchema = new mongoose.Schema({
  skuCode: { type: String, required: true, unique: true },
  specs: [{
    name: { type: String, required: true },     // 规格名：颜色/尺码
    value: { type: String, required: true }      // 规格值：红色/XL
  }],
  price: { type: Number, required: true },
  originalPrice: { type: Number },
  stock: { type: Number, default: 0 },
  lockedStock: { type: Number, default: 0 },     // 锁定库存（下单未支付）
  soldStock: { type: Number, default: 0 },        // 已售数量
  images: [String],                                // SKU专属图片
  barcode: String,
  weight: { type: Number, default: 0 },           // 重量（用于运费计算）
  status: { type: String, enum: ['active', 'inactive'], default: 'active' }
}, { _id: false });

const productSchema = new mongoose.Schema({
  spuCode: { type: String, required: true, unique: true },
  name: { type: String, required: true },
  brand: { type: String, index: true },
  category: { type: mongoose.Schema.Types.ObjectId, ref: 'Category', index: true },
  season: { type: String, enum: ['spring', 'summer', 'autumn', 'winter'] },
  gender: { type: String, enum: ['male', 'female', 'unisex'] },
  material: String,
  description: String,
  mainImages: [String],                            // 主图列表
  detailImages: [String],                          // 详情页图片
  specTemplate: [{                                 // 规格模板
    name: String,
    values: [String]
  }],
  skus: [skuSchema],                               // 内嵌SKU列表
  status: { type: String, enum: ['draft', 'on_sale', 'off_sale'], default: 'draft' },
  createdAt: { type: Date, default: Date.now },
  updatedAt: { type: Date, default: Date.now }
});

// 文本索引（支持商品搜索）
productSchema.index({ 
  name: 'text', brand: 'text', description: 'text' 
}, { weights: { name: 10, brand: 5, description: 1 } });

// 复合索引（分类+状态查询优化）
productSchema.index({ category: 1, status: 1, createdAt: -1 });

module.exports = mongoose.model('Product', productSchema);

// services/productService.js — 商品创建（自动生成SKU组合）
class ProductService {
  /**
   * 创建商品并根据规格模板自动生成所有SKU组合
   * 例如颜色[红,蓝] × 尺码[S,M,L] = 6个SKU
   */
  async createProduct(productData) {
    const { specTemplate, basePrice, baseStock } = productData;

    // 笛卡尔积生成SKU组合
    const skuCombinations = this.generateSkuCombinations(specTemplate);

    const skus = skuCombinations.map((specs, index) => ({
      skuCode: `${productData.spuCode}-${String(index + 1).padStart(3, '0')}`,
      specs,
      price: basePrice,
      stock: baseStock,
      images: [],
      status: 'active'
    }));

    const product = new Product({
      ...productData,
      skus,
      status: 'draft'
    });

    await product.save();
    return product;
  }

  /**
   * 生成规格笛卡尔积
   * 输入: [{name:'颜色', values:['红','蓝']}, {name:'尺码', values:['S','M','L']}]
   * 输出: [[{name:'颜色',value:'红'},{name:'尺码',value:'S'}], ...]
   */
  generateSkuCombinations(specTemplate) {
    if (!specTemplate || specTemplate.length === 0) return [[]];

    return specTemplate.reduce((acc, spec) => {
      const result = [];
      acc.forEach(existing => {
        spec.values.forEach(value => {
          result.push([...existing, { name: spec.name, value }]);
        });
      });
      return result;
    }, [[]]);
  }

  /**
   * 商品全文搜索（MongoDB文本索引）
   */
  async searchProducts(keyword, page = 1, limit = 20, filters = {}) {
    const query = { status: 'on_sale' };

    if (keyword) {
      query.$text = { $search: keyword };
    }
    if (filters.brand) query.brand = filters.brand;
    if (filters.category) query.category = filters.category;
    if (filters.season) query.season = filters.season;
    if (filters.priceRange) {
      query['skus.price'] = { 
        $gte: filters.priceRange.min, 
        $lte: filters.priceRange.max 
      };
    }

    const skip = (page - 1) * limit;
    const [products, total] = await Promise.all([
      Product.find(query, { score: { $meta: 'textScore' } })
        .sort({ score: { $meta: 'textScore' } })
        .skip(skip)
        .limit(limit)
        .populate('category', 'name'),
      Product.countDocuments(query)
    ]);

    return { products, total, page, limit };
  }
}

module.exports = new ProductService();

商品模型通过内嵌SKU避免了关联查询，一个SPU文档包含所有规格信息，读取性能远优于关系型数据库的多表JOIN。规格模板通过笛卡尔积自动生成SKU，例如2种颜色×3种尺码自动生成6个SKU。全文搜索使用MongoDB的text索引，按字段权重排序，搜索响应时间<50ms。

三、多规格库存同步与并发控制

服装促销期间，小程序端用户下单和管理后台补货可能同时操作同一SKU库存，需要并发控制防止超卖。MongoDB通过findAndModify原子操作和乐观锁实现并发安全的库存扣减：

// services/inventoryService.js — 库存同步服务
const mongoose = require('mongoose');
const Product = require('../models/product');
const redis = require('../config/redis');

class InventoryService {
  /**
   * 扣减SKU库存（MongoDB原子操作 + Redis缓存）
   * @param {string} spuCode - 商品编码
   * @param {string} skuCode - SKU编码
   * @param {number} quantity - 扣减数量
   */
  async deductStock(spuCode, skuCode, quantity) {
    const session = await mongoose.startSession();
    session.startTransaction();

    try {
      // 原子操作：检查库存并扣减
      const result = await Product.findOneAndUpdate(
        {
          spuCode,
          'skus.skuCode': skuCode,
          'skus.stock': { $gte: quantity },
          'skus.status': 'active'
        },
        {
          $inc: { 
            'skus.$.stock': -quantity,
            'skus.$.soldStock': quantity
          },
          $set: { updatedAt: new Date() }
        },
        { 
          session,
          new: true,
          fields: { 'skus.$': 1 }
        }
      );

      if (!result) {
        // 检查是库存不足还是商品不存在
        const product = await Product.findOne(
          { spuCode, 'skus.skuCode': skuCode },
          { 'skus.$': 1 }
        ).session(session);

        if (!product) {
          throw new Error('商品不存在');
        }
        throw new Error(`库存不足: 可用${product.skus[0].stock}, 需要${quantity}`);
      }

      await session.commitTransaction();

      // 更新Redis缓存（异步）
      const cacheKey = `sku:stock:${spuCode}:${skuCode}`;
      await redis.hset(cacheKey, {
        stock: result.skus[0].stock,
        updatedAt: Date.now()
      });
      await redis.expire(cacheKey, 3600);

      return { 
        success: true, 
        remaining: result.skus[0].stock 
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      session.endSession();
    }
  }

  /**
   * 批量库存预热到Redis
   * 小程序启动时调用，加速库存查询
   */
  async preloadStockToRedis(spuCodes) {
    const pipeline = redis.pipeline();

    for (const spuCode of spuCodes) {
      const product = await Product.findOne(
        { spuCode, status: 'on_sale' },
        { 'skus.skuCode': 1, 'skus.stock': 1 }
      );

      if (product) {
        product.skus.forEach(sku => {
          const cacheKey = `sku:stock:${spuCode}:${sku.skuCode}`;
          pipeline.hset(cacheKey, {
            stock: sku.stock,
            updatedAt: Date.now()
          });
          pipeline.expire(cacheKey, 3600);
        });
      }
    }

    await pipeline.exec();
    console.log(`[库存预热] 完成 ${spuCodes.length} 个商品`);
  }

  /**
   * 锁定库存（下单未支付时锁定，超时自动释放）
   */
  async lockStock(spuCode, skuCode, quantity, orderId, ttlSeconds = 900) {
    const session = await mongoose.startSession();
    session.startTransaction();

    try {
      // 扣减可用库存，增加锁定库存
      const result = await Product.findOneAndUpdate(
        {
          spuCode,
          'skus.skuCode': skuCode,
          'skus.stock': { $gte: quantity }
        },
        {
          $inc: {
            'skus.$.stock': -quantity,
            'skus.$.lockedStock': quantity
          }
        },
        { session, new: true, fields: { 'skus.$': 1 } }
      );

      if (!result) throw new Error('库存不足，无法锁定');

      // Redis记录锁定信息，超时自动释放
      const lockKey = `stock:lock:${orderId}`;
      await redis.setex(lockKey, ttlSeconds, JSON.stringify({
        spuCode, skuCode, quantity
      }));

      await session.commitTransaction();
      return true;
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      session.endSession();
    }
  }
}

module.exports = new InventoryService();

库存扣减使用MongoDB的findOneAndUpdate原子操作，条件查询中包含`stock: {$gte: quantity}`确保不会超卖。锁定库存机制在用户下单时锁定、支付成功后转为已售、超时未支付则释放回可用库存。压测数据显示，单SKU 200并发扣减无超卖，平均响应时间15ms，Redis缓存使小程序端库存查询响应时间<5ms。

四、图片管理与搜索性能优化

服装商品图片数量多（主图+详情图+SKU图），通过微信云存储+CDN分发优化加载速度。搜索性能通过复合索引和聚合管道优化，以下是Docker部署配置和性能数据：

# Dockerfile — Node.js 后端
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/server.js"]

# docker-compose.yml — 服装小程序商城部署
version: '3.8'
services:
  api:
    build: .
    ports: ["3000:3000"]
    environment:
      - MONGODB_URI=mongodb://mongo:27017/fashion_mall
      - REDIS_URL=redis://redis:6379/2
      - JWT_SECRET=${JWT_SECRET}
      - WX_CLOUD_ENV=${WX_CLOUD_ENV}
    depends_on: [mongo, redis]
    deploy:
      replicas: 2
      resources:
        limits: { cpus: '1.5', memory: 768M }

  mongo:
    image: mongo:7
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD}
    volumes: [mongo_data:/data/db]
    command: --wiredTigerCacheSizeGB 2 --maxConns 500

  redis:
    image: redis:7-alpine
    command: redis-server --maxmemory 512mb --maxmemory-policy allkeys-lru
    volumes: [redis_data:/data]

  nginx:
    image: nginx:alpine
    ports: ["80:80", "443:443"]
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on: [api]

volumes:
  mongo_data:
  redis_data:

# MongoDB 索引优化脚本
# db.products.createIndex({ spuCode: 1 }, { unique: true })
# db.products.createIndex({ brand: 1, status: 1 })
# db.products.createIndex({ category: 1, status: 1, createdAt: -1 })
# db.products.createIndex({ "skus.skuCode": 1 }, { unique: true })
# db.products.createIndex({ name: "text", brand: "text" }, { weights: { name: 10, brand: 5 } })

系统部署2个API副本+MongoDB单实例+Redis缓存，MongoDB分配2GB WiredTiger缓存。生产环境性能指标：商品列表查询平均响应时间35ms（索引命中），全文搜索响应时间50ms，库存扣减QPS 500+，小程序首屏加载时间1.5秒（CDN加速后图片加载<200ms）。系统已支撑某服装品牌上线3000+款商品，日均处理订单2000+，促销期间峰值QPS 800稳定运行。

关于承恒信息科技

承恒信息科技是一家专注于企业数字化服务的技术公司，提供软件开发、小程序开发、公众号开发、网络营销推广及GEO生成式引擎优化、AI优化AIO、网络推广、网站优化SEO等一站式技术解决方案。技术栈涵盖Java、.NET Core、Python、Node.js、React、Vue等主流技术，专注为各行业企业提供高性能、高可用的系统架构设计与开发服务。