引言

在数字经济蓬勃发展的今天，卡密交易系统已成为数字商品交易的重要基础设施。无论是软件授权码、在线课程密钥、还是各类会员服务，卡密系统都提供了安全便捷的交易解决方案。本文将深入解析一款最新开源的通用型卡密交易系统，从架构设计、核心代码实现到部署应用，全面剖析其技术细节。

源码及演示：fakaysw.top

一、系统架构与技术栈

1.1 整体架构设计

本系统采用前后端分离的微服务架构，核心模块包括：

发卡网系统架构：
├── 前端展示层 (Vue.js 3 + Element Plus)
├── API网关层 (Nginx + JWT鉴权)
├── 业务服务层
│   ├── 用户服务
│   ├── 商品服务
│   ├── 订单服务
│   ├── 卡密服务
│   └── 支付服务
├── 数据存储层
│   ├── MySQL (业务数据)
│   ├── Redis (缓存/会话)
│   └── Elasticsearch (日志/搜索)
└── 基础设施层
    ├── Docker容器化
    ├── 监控告警
    └── 日志收集

1.2 技术栈选型

• 后端核心：Spring Boot 2.7 + MyBatis Plus
• 数据库：MySQL 8.0 主从复制
• 缓存：Redis 7.0 Cluster
• 消息队列：RabbitMQ
• 支付集成：支付宝、微信、PayPal等多渠道
• 安全机制：JWT + OAuth2.0 + 风控系统

二、数据库设计与核心表结构

2.1 核心表关系设计

-- 用户表
CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `email` varchar(100) NOT NULL COMMENT '邮箱',
  `password_hash` varchar(255) NOT NULL COMMENT '加密密码',
  `balance` decimal(15,2) DEFAULT '0.00' COMMENT '余额',
  `is_seller` tinyint(1) DEFAULT '0' COMMENT '是否为商家',
  `api_token` varchar(64) DEFAULT NULL COMMENT 'API令牌',
  `status` tinyint(1) DEFAULT '1' COMMENT '状态',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`),
  UNIQUE KEY `uk_email` (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 商品表
CREATE TABLE `product` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) NOT NULL COMMENT '商家ID',
  `category_id` int(11) NOT NULL COMMENT '分类ID',
  `name` varchar(200) NOT NULL COMMENT '商品名称',
  `description` text COMMENT '商品描述',
  `price` decimal(10,2) NOT NULL COMMENT '价格',
  `stock_type` tinyint(1) DEFAULT '1' COMMENT '库存类型：1-自动 2-手动',
  `stock_total` int(11) DEFAULT '0' COMMENT '总库存',
  `stock_sold` int(11) DEFAULT '0' COMMENT '已售',
  `is_auto_delivery` tinyint(1) DEFAULT '1' COMMENT '是否自动发货',
  `delivery_template` text COMMENT '发货模板',
  `status` tinyint(1) DEFAULT '1' COMMENT '状态',
  `sort_order` int(11) DEFAULT '0' COMMENT '排序',
  PRIMARY KEY (`id`),
  KEY `idx_user_id` (`user_id`),
  KEY `idx_category_id` (`category_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 卡密库存表
CREATE TABLE `card_key` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `product_id` bigint(20) NOT NULL COMMENT '商品ID',
  `card_no` varchar(100) NOT NULL COMMENT '卡号',
  `card_key` varchar(255) NOT NULL COMMENT '卡密',
  `secret_key` varchar(64) DEFAULT NULL COMMENT '加密密钥',
  `status` tinyint(1) DEFAULT '0' COMMENT '状态：0-未售 1-已售 2-已使用',
  `sold_time` datetime DEFAULT NULL COMMENT '售出时间',
  `use_time` datetime DEFAULT NULL COMMENT '使用时间',
  `order_id` bigint(20) DEFAULT NULL COMMENT '订单ID',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_card_no` (`card_no`),
  KEY `idx_product_id` (`product_id`),
  KEY `idx_status` (`status`),
  KEY `idx_order_id` (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='卡密库存';

-- 订单表
CREATE TABLE `trade_order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `order_no` varchar(32) NOT NULL COMMENT '订单号',
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户ID',
  `product_id` bigint(20) NOT NULL COMMENT '商品ID',
  `product_name` varchar(200) NOT NULL COMMENT '商品名称',
  `quantity` int(11) DEFAULT '1' COMMENT '购买数量',
  `unit_price` decimal(10,2) NOT NULL COMMENT '单价',
  `total_amount` decimal(10,2) NOT NULL COMMENT '总金额',
  `pay_amount` decimal(10,2) NOT NULL COMMENT '实付金额',
  `contact_info` varchar(500) DEFAULT NULL COMMENT '联系方式',
  `pay_type` varchar(20) DEFAULT NULL COMMENT '支付方式',
  `pay_status` tinyint(1) DEFAULT '0' COMMENT '支付状态',
  `pay_time` datetime DEFAULT NULL COMMENT '支付时间',
  `delivery_status` tinyint(1) DEFAULT '0' COMMENT '发货状态',
  `delivery_data` text COMMENT '发货数据(卡密)',
  `delivery_time` datetime DEFAULT NULL COMMENT '发货时间',
  `status` tinyint(1) DEFAULT '1' COMMENT '订单状态',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_order_no` (`order_no`),
  KEY `idx_user_id` (`user_id`),
  KEY `idx_product_id` (`product_id`),
  KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

三、核心业务逻辑实现

3.1 卡密生成与加密模块

/**
 * 卡密生成服务
 */
@Service
@Slf4j
public class CardKeyGeneratorService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 批量生成卡密
     */
    public List<CardKey> generateCardKeys(Long productId, 
                                        Integer quantity, 
                                        String prefix, 
                                        Integer length) {
        
        List<CardKey> cardKeys = new ArrayList<>();
        String lockKey = "card_gen:lock:" + productId;
        
        // 分布式锁保证并发安全
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            lock.lock(10, TimeUnit.SECONDS);
            
            for (int i = 0; i < quantity; i++) {
                CardKey cardKey = new CardKey();
                cardKey.setProductId(productId);
                
                // 生成唯一卡号
                String cardNo = generateUniqueCardNo(prefix, length);
                cardKey.setCardNo(cardNo);
                
                // 生成随机卡密
                String cardKeyValue = generateSecureCardKey();
                cardKey.setCardKey(encryptCardKey(cardKeyValue));
                
                // 生成加密密钥
                String secretKey = generateSecretKey();
                cardKey.setSecretKey(secretKey);
                
                cardKey.setStatus(0);
                cardKey.setCreateTime(new Date());
                
                cardKeys.add(cardKey);
            }
            
            // 批量插入数据库
            if (!cardKeys.isEmpty()) {
                cardKeyMapper.batchInsert(cardKeys);
                
                // 更新商品库存
                updateProductStock(productId, quantity);
                
                // 记录操作日志
                log.info("成功生成{}张卡密，商品ID：{}", quantity, productId);
            }
            
        } finally {
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        
        return cardKeys;
    }
    
    /**
     * 生成唯一卡号
     */
    private String generateUniqueCardNo(String prefix, Integer length) {
        String cardNo;
        int retryCount = 0;
        
        do {
            // 时间戳 + 随机数
            String timestamp = String.valueOf(System.currentTimeMillis());
            String randomStr = RandomStringUtils.randomNumeric(6);
            
            cardNo = prefix + randomStr + 
                    timestamp.substring(timestamp.length() - 8);
            
            if (length > 0 && cardNo.length() > length) {
                cardNo = cardNo.substring(0, length);
            }
            
            // 检查是否重复
            boolean exists = checkCardNoExists(cardNo);
            
            if (!exists) {
                break;
            }
            
            retryCount++;
            if (retryCount > 10) {
                throw new BusinessException("生成唯一卡号失败，请重试");
            }
            
        } while (true);
        
        return cardNo;
    }
    
    /**
     * 生成安全卡密
     */
    private String generateSecureCardKey() {
        // 使用安全的随机数生成器
        SecureRandom random = new SecureRandom();
        byte[] bytes = new byte[16];
        random.nextBytes(bytes);
        
        // 转换为Base64，移除特殊字符
        String base64 = Base64.getEncoder().encodeToString(bytes);
        return base64.replaceAll("[+/=]", "").substring(0, 16);
    }
    
    /**
     * 加密卡密
     */
    private String encryptCardKey(String cardKey) {
        try {
            // 使用AES加密
            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
            SecretKeySpec keySpec = new SecretKeySpec(
                SystemConfig.getEncryptKey().getBytes(), "AES");
            
            byte[] iv = new byte[12];
            new SecureRandom().nextBytes(iv);
            
            GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmSpec);
            
            byte[] encrypted = cipher.doFinal(cardKey.getBytes());
            byte[] combined = new byte[iv.length + encrypted.length];
            
            System.arraycopy(iv, 0, combined, 0, iv.length);
            System.arraycopy(encrypted, 0, combined, iv.length, encrypted.length);
            
            return Base64.getEncoder().encodeToString(combined);
            
        } catch (Exception e) {
            log.error("加密卡密失败", e);
            throw new BusinessException("加密失败");
        }
    }
}

3.2 订单处理与自动发货

/**
 * 订单服务核心逻辑
 */
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private CardKeyMapper cardKeyMapper;
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    /**
     * 创建订单
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public OrderCreateResult createOrder(OrderCreateRequest request) {
        
        // 1. 验证商品
        Product product = validateProduct(request.getProductId());
        
        // 2. 检查库存
        checkStock(product, request.getQuantity());
        
        // 3. 生成订单号
        String orderNo = generateOrderNo();
        
        // 4. 创建订单
        TradeOrder order = new TradeOrder();
        order.setOrderNo(orderNo);
        order.setUserId(request.getUserId());
        order.setProductId(product.getId());
        order.setProductName(product.getName());
        order.setQuantity(request.getQuantity());
        order.setUnitPrice(product.getPrice());
        order.setTotalAmount(product.getPrice().multiply(
            new BigDecimal(request.getQuantity())));
        order.setPayAmount(order.getTotalAmount()); // 实际支付金额
        order.setContactInfo(request.getContactInfo());
        order.setPayStatus(0);
        order.setDeliveryStatus(0);
        order.setStatus(1);
        
        orderMapper.insert(order);
        
        // 5. 扣减库存
        deductStock(product.getId(), request.getQuantity());
        
        // 6. 记录订单日志
        logOrderAction(order.getId(), "ORDER_CREATED", "订单创建成功");
        
        // 7. 发送延迟消息，处理未支付订单
        sendOrderTimeoutMessage(order.getId());
        
        return OrderCreateResult.builder()
                .orderId(order.getId())
                .orderNo(order.getOrderNo())
                .payAmount(order.getPayAmount())
                .productName(order.getProductName())
                .build();
    }
    
    /**
     * 支付成功回调处理
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handlePaySuccess(String orderNo, String payType, 
                               String transactionId) {
        
        TradeOrder order = orderMapper.selectByOrderNo(orderNo);
        if (order == null || order.getPayStatus() == 1) {
            return;
        }
        
        // 更新支付状态
        order.setPayStatus(1);
        order.setPayType(payType);
        order.setPayTime(new Date());
        orderMapper.updateById(order);
        
        // 如果是自动发货商品，立即发货
        Product product = productMapper.selectById(order.getProductId());
        if (product.getIsAutoDelivery() == 1) {
            deliverOrder(order);
        }
        
        // 发送支付成功通知
        sendPaySuccessNotification(order);
        
        // 记录订单日志
        logOrderAction(order.getId(), "PAY_SUCCESS", "支付成功");
    }
    
    /**
     * 订单发货
     */
    private void deliverOrder(TradeOrder order) {
        try {
            // 获取卡密
            List<CardKey> cardKeys = allocateCardKeys(
                order.getProductId(), 
                order.getQuantity(), 
                order.getId()
            );
            
            if (cardKeys.isEmpty()) {
                throw new BusinessException("库存不足，发货失败");
            }
            
            // 构建发货数据
            String deliveryData = buildDeliveryData(cardKeys, order);
            
            // 更新订单发货状态
            order.setDeliveryStatus(1);
            order.setDeliveryData(deliveryData);
            order.setDeliveryTime(new Date());
            orderMapper.updateById(order);
            
            // 更新卡密状态
            updateCardKeysStatus(cardKeys, order.getId());
            
            // 发送发货通知
            sendDeliveryNotification(order, deliveryData);
            
            // 记录发货日志
            logOrderAction(order.getId(), "DELIVERY_SUCCESS", "发货成功");
            
        } catch (Exception e) {
            log.error("订单发货失败，订单ID：{}", order.getId(), e);
            logOrderAction(order.getId(), "DELIVERY_FAILED", "发货失败：" + e.getMessage());
            throw new BusinessException("发货失败：" + e.getMessage());
        }
    }
    
    /**
     * 分配卡密
     */
    private List<CardKey> allocateCardKeys(Long productId, 
                                          Integer quantity, 
                                          Long orderId) {
        
        // 使用悲观锁保证并发安全
        List<CardKey> cardKeys = cardKeyMapper.selectForUpdate(
            productId, quantity);
        
        if (cardKeys.size() < quantity) {
            return Collections.emptyList();
        }
        
        // 批量更新卡密状态
        List<Long> cardKeyIds = cardKeys.stream()
            .map(CardKey::getId)
            .collect(Collectors.toList());
        
        cardKeyMapper.batchUpdateStatus(cardKeyIds, 1, orderId);
        
        return cardKeys;
    }
}

3.3 支付网关集成

/**
 * 支付网关服务
 */
@Service
public class PaymentGatewayService {
    
    @Autowired
    private AlipayClient alipayClient;
    
    @Autowired
    private WxPayService wxPayService;
    
    /**
     * 创建支付订单
     */
    public PayOrderResponse createPayOrder(PayOrderRequest request) {
        
        // 根据支付类型选择支付网关
        switch (request.getPayType()) {
            case "alipay":
                return createAlipayOrder(request);
                
            case "wxpay":
                return createWxpayOrder(request);
                
            case "paypal":
                return createPaypalOrder(request);
                
            default:
                throw new BusinessException("不支持的支付方式");
        }
    }
    
    /**
     * 支付宝支付
     */
    private PayOrderResponse createAlipayOrder(PayOrderRequest request) {
        try {
            AlipayTradePagePayRequest alipayRequest = 
                new AlipayTradePagePayRequest();
            
            // 设置异步通知和同步返回地址
            alipayRequest.setReturnUrl(request.getReturnUrl());
            alipayRequest.setNotifyUrl(request.getNotifyUrl());
            
            // 创建业务参数
            AlipayTradePagePayModel model = new AlipayTradePagePayModel();
            model.setOutTradeNo(request.getOrderNo());
            model.setTotalAmount(request.getAmount().toString());
            model.setSubject(request.getSubject());
            model.setBody(request.getBody());
            model.setProductCode("FAST_INSTANT_TRADE_PAY");
            
            alipayRequest.setBizModel(model);
            
            // 调用SDK生成表单
            AlipayTradePagePayResponse response = 
                alipayClient.pageExecute(alipayRequest);
            
            return PayOrderResponse.builder()
                    .success(true)
                    .payData(response.getBody())
                    .orderNo(request.getOrderNo())
                    .build();
                    
        } catch (AlipayApiException e) {
            log.error("支付宝支付创建失败", e);
            throw new BusinessException("支付创建失败");
        }
    }
    
    /**
     * 微信支付
     */
    private PayOrderResponse createWxpayOrder(PayOrderRequest request) {
        try {
            WxPayUnifiedOrderRequest wxRequest = 
                new WxPayUnifiedOrderRequest();
            
            wxRequest.setOutTradeNo(request.getOrderNo());
            wxRequest.setTotalFee(request.getAmount()
                .multiply(new BigDecimal("100")).intValue());
            wxRequest.setBody(request.getSubject());
            wxRequest.setSpbillCreateIp(request.getClientIp());
            wxRequest.setNotifyUrl(request.getNotifyUrl());
            wxRequest.setTradeType("NATIVE");
            
            WxPayUnifiedOrderResult result = 
                wxPayService.unifiedOrder(wxRequest);
            
            return PayOrderResponse.builder()
                    .success(true)
                    .payData(result.getCodeURL())
                    .orderNo(request.getOrderNo())
                    .build();
                    
        } catch (WxPayException e) {
            log.error("微信支付创建失败", e);
            throw new BusinessException("支付创建失败");
        }
    }
    
    /**
     * 支付回调验证
     */
    public boolean verifyPaymentNotify(String payType, 
                                     Map<String, String> params) {
        
        switch (payType) {
            case "alipay":
                return verifyAlipayNotify(params);
                
            case "wxpay":
                return verifyWxpayNotify(params);
                
            default:
                return false;
        }
    }
    
    /**
     * 验证支付宝回调
     */
    private boolean verifyAlipayNotify(Map<String, String> params) {
        try {
            return AlipaySignature.rsaCheckV1(
                params,
                alipayConfig.getAlipayPublicKey(),
                "UTF-8",
                "RSA2"
            );
        } catch (AlipayApiException e) {
            log.error("支付宝回调验证失败", e);
            return false;
        }
    }
}

四、安全防护机制

4.1 防刷与限流

/**
 * 安全防护服务
 */
@Component
public class SecurityProtectionService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private SystemConfigService configService;
    
    /**
     * 请求频率限制
     */
    public boolean checkRateLimit(String key, int limit, int period) {
        String redisKey = "rate_limit:" + key;
        
        Long count = redisTemplate.opsForValue().increment(redisKey, 1);
        
        if (count != null && count == 1) {
            redisTemplate.expire(redisKey, period, TimeUnit.SECONDS);
        }
        
        return count != null && count <= limit;
    }
    
    /**
     * IP黑名单检查
     */
    public boolean isIpBlacklisted(String ip) {
        String key = "ip_blacklist:" + ip;
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }
    
    /**
     * 订单重复提交检查
     */
    public boolean checkDuplicateOrder(String orderKey, int expireSeconds) {
        String key = "order_duplicate:" + orderKey;
        
        Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(key, "1", expireSeconds, TimeUnit.SECONDS);
        
        return Boolean.TRUE.equals(result);
    }
    
    /**
     * 验证码校验
     */
    public boolean verifyCaptcha(String captchaKey, String userInput) {
        String storedCaptcha = (String) redisTemplate.opsForValue()
            .get("captcha:" + captchaKey);
        
        if (storedCaptcha == null) {
            return false;
        }
        
        boolean verified = storedCaptcha.equalsIgnoreCase(userInput);
        
        if (verified) {
            redisTemplate.delete("captcha:" + captchaKey);
        }
        
        return verified;
    }
    
    /**
     * 敏感操作验证
     */
    public boolean verifySensitiveOperation(Long userId, 
                                          String operationType) {
        
        // 检查操作频率
        String rateKey = "sensitive_op:" + userId + ":" + operationType;
        if (!checkRateLimit(rateKey, 5, 300)) {
            return false;
        }
        
        // 检查设备指纹
        String deviceKey = "device_check:" + userId;
        // 实现设备指纹验证逻辑
        
        return true;
    }
}

五、API接口设计

5.1 RESTful API 示例

/**
 * 商品API控制器
 */
@RestController
@RequestMapping("/api/v1/products")
@Validated
@Api(tags = "商品管理")
public class ProductController {
    
    @Autowired
    private ProductService productService;
    
    /**
     * 获取商品列表
     */
    @GetMapping("")
    @ApiOperation("获取商品列表")
    public ApiResult<PageResult<ProductVO>> getProductList(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer size,
            @RequestParam(required = false) Integer categoryId,
            @RequestParam(required = false) Integer status) {
        
        ProductQuery query = ProductQuery.builder()
                .page(page)
                .size(size)
                .categoryId(categoryId)
                .status(status)
                .build();
        
        PageResult<ProductVO> result = productService.getProductList(query);
        return ApiResult.success(result);
    }
    
    /**
     * 获取商品详情
     */
    @GetMapping("/{id}")
    @ApiOperation("获取商品详情")
    public ApiResult<ProductDetailVO> getProductDetail(
            @PathVariable Long id) {
        
        ProductDetailVO detail = productService.getProductDetail(id);
        return ApiResult.success(detail);
    }
    
    /**
     * 创建订单
     */
    @PostMapping("/{id}/order")
    @ApiOperation("创建订单")
    public ApiResult<OrderCreateResult> createOrder(
            @PathVariable Long id,
            @Valid @RequestBody OrderCreateRequest request) {
        
        request.setProductId(id);
        OrderCreateResult result = orderService.createOrder(request);
        return ApiResult.success(result);
    }
    
    /**
     * 查询订单状态
     */
    @GetMapping("/order/{orderNo}")
    @ApiOperation("查询订单状态")
    public ApiResult<OrderStatusResult> getOrderStatus(
            @PathVariable String orderNo) {
        
        OrderStatusResult result = orderService.getOrderStatus(orderNo);
        return ApiResult.success(result);
    }
}

六、部署与运维

6.1 Docker 部署配置

# docker-compose.yml
version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: card_mysql
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: card_system
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - card_network

  redis:
    image: redis:7.0-alpine
    container_name: card_redis
    command: redis-server --appendonly yes
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - card_network

  backend:
    build: 
      context: ./backend
      dockerfile: Dockerfile
    container_name: card_backend
    depends_on:
      - mysql
      - redis
    environment:
      SPRING_PROFILES_ACTIVE: prod
      DB_HOST: mysql
      DB_PORT: 3306
      REDIS_HOST: redis
      REDIS_PORT: 6379
    ports:
      - "8080:8080"
    networks:
      - card_network
    restart: unless-stopped

  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: card_frontend
    depends_on:
      - backend
    ports:
      - "80:80"
    networks:
      - card_network
    restart: unless-stopped

  nginx:
    image: nginx:1.23-alpine
    container_name: card_nginx
    depends_on:
      - backend
      - frontend
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    ports:
      - "443:443"
      - "80:80"
    networks:
      - card_network
    restart: unless-stopped

networks:
  card_network:
    driver: bridge

volumes:
  mysql_data:
  redis_data:

七、监控与告警

7.1 系统监控配置

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

rule_files:
  - "alerts.yml"

scrape_configs:
  - job_name: 'card-system'
    static_configs:
      - targets: ['backend:8080']
    metrics_path: '/actuator/prometheus'
    
  - job_name: 'mysql'
    static_configs:
      - targets: ['mysqld-exporter:9104']
      
  - job_name: 'redis'
    static_configs:
      - targets: ['redis-exporter:9121']

# alerts.yml
groups:
  - name: card_alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_server_requests_seconds_count{status=~"5.."}[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "高错误率报警"
          description: "错误率超过10%"
          
      - alert: LowStockAlert
        expr: product_stock_available < 10
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "库存不足报警"
          description: "商品 {{ $labels.product_name }} 库存不足10件"

结语

本文详细解析了一套完整的企业/个人通用型卡密交易系统的源码实现。系统采用现代化的技术架构，具备高可用、高并发的处理能力，同时提供了完善的安全防护机制。从数据库设计、核心业务逻辑到部署运维，系统每个环节都经过精心设计和优化。开源版本提供了完整的基础功能，企业用户可以根据自身需求进行二次开发。个人用户也可以快速部署使用，无需复杂配置。系统具有良好的扩展性，支持插件化开发，可以方便地集成新的支付渠道、增加新的功能模块。在数字商品交易日益普及的今天，这样一个稳定可靠的卡密交易系统，将为各类数字商品提供安全、高效的交易解决方案，帮助商家和个人更好地开展在线业务。