用户续费订单Java微服务后端架构实战

1. 架构概述

用户续费订单系统是电商平台和租赁平台的核心模块，需要支持基于有效订单复制生成新订单，简化用户续费流程。本篇文章将深入讲解如何基于Java微服务架构实现一个高性能、高可用、用户友好的用户续费订单系统。

1.1 系统架构图

1
2
3
4
5
6
7
8
9
10
11
用户端 → 用户网关 → 订单服务 → 数据库
         ↓
    身份认证
         ↓
    判断用户存在有效订单
         ↓
    复制有效订单信息
         ↓
    生成新未支付订单
         ↓
    返回续费结果

1.2 核心组件

  • 用户网关（User Gateway）：负责用户请求的接入、身份认证、请求路由
  • 订单服务（Order Service）：负责订单管理、有效订单查询、订单信息复制、新订单生成
  • 数据库（MySQL）：持久化订单信息
  • 分布式锁（Redisson）：保证订单生成的并发安全
  • 事务管理：保证续费订单生成的原子性和一致性

2. 用户网关服务实现

2.1 用户网关服务核心代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
 * 用户网关服务
 * 负责用户请求的接入、身份认证、请求路由
 */
@RestController
@RequestMapping("/api/user/gateway")
@Slf4j
public class UserGatewayController {

    @Autowired
    private AuthService authService;
    
    @Autowired
    private OrderServiceClient orderServiceClient;

    /**
     * 用户续费订单请求
     * 流程：身份认证 → 判断用户存在有效订单, 复制有效订单信息, 生成新未支付订单 → 返回续费结果
     */
    @PostMapping("/order/renewal")
    public Result<OrderRenewalResult> renewalOrder(
            @RequestHeader("Authorization") String token,
            @RequestBody OrderRenewalRequest request) {
        
        try {
            // 1. 身份认证
            UserInfo userInfo = authService.authenticate(token);
            if (userInfo == null) {
                return Result.error("身份认证失败");
            }
            
            // 2. 设置用户ID
            request.setUserId(userInfo.getUserId());
            
            // 3. 调用订单服务续费订单
            OrderRenewalResult result = orderServiceClient.renewalOrder(request);
            
            if (!result.isSuccess()) {
                return Result.error(result.getMessage());
            }
            
            log.info("用户续费订单成功: userId={}, originalOrderId={}, newOrderId={}, newOrderNo={}", 
                    userInfo.getUserId(), request.getOriginalOrderId(), 
                    result.getNewOrderId(), result.getNewOrderNo());
            
            return Result.success(result);
            
        } catch (Exception e) {
            log.error("用户续费订单失败: originalOrderId={}, error={}", 
                    request.getOriginalOrderId(), e.getMessage(), e);
            return Result.error("续费订单失败: " + e.getMessage());
        }
    }
}

2.2 身份认证服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/**
 * 身份认证服务
 */
@Service
@Slf4j
public class AuthService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private UserServiceClient userServiceClient;
    
    /**
     * 身份认证
     * 验证Token有效性
     */
    public UserInfo authenticate(String token) {
        try {
            // 1. 从Token中解析用户信息
            String userId = parseToken(token);
            if (StringUtils.isEmpty(userId)) {
                return null;
            }
            
            // 2. 从缓存中获取用户信息
            String userCacheKey = "user:info:" + userId;
            UserInfo userInfo = (UserInfo) redisTemplate.opsForValue().get(userCacheKey);
            
            if (userInfo != null) {
                return userInfo;
            }
            
            // 3. 缓存未命中，调用用户服务查询
            userInfo = userServiceClient.getUserInfo(userId);
            
            // 4. 将用户信息写入缓存
            if (userInfo != null) {
                redisTemplate.opsForValue().set(userCacheKey, userInfo, 30, TimeUnit.MINUTES);
            }
            
            return userInfo;
            
        } catch (Exception e) {
            log.error("身份认证失败: token={}, error={}", token, e.getMessage(), e);
            return null;
        }
    }

    /**
     * 解析Token
     */
    private String parseToken(String token) {
        // JWT Token解析逻辑
        if (StringUtils.isEmpty(token) || !token.startsWith("Bearer ")) {
            return null;
        }
        
        String jwtToken = token.substring(7);
        // 解析JWT获取userId
        return extractUserIdFromJWT(jwtToken);
    }

    private String extractUserIdFromJWT(String jwtToken) {
        // JWT解析实现
        // 实际实现需要使用JWT库
        return "user123";
    }
}

3. 订单服务实现

3.1 订单服务核心代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/**
 * 订单服务
 * 负责订单管理、有效订单查询、订单信息复制、新订单生成
 */
@Service
@Slf4j
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private RedissonClient redissonClient;

    /**
     * 判断用户存在有效订单, 复制有效订单信息, 生成新未支付订单
     */
    @Transactional(rollbackFor = Exception.class)
    public OrderRenewalResult renewalOrder(OrderRenewalRequest request) {
        String lockKey = "order:renewal:lock:" + request.getUserId();
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            if (lock.tryLock(10, TimeUnit.SECONDS)) {
                // 1. 判断用户存在有效订单
                Order originalOrder = null;
                
                if (request.getOriginalOrderId() != null) {
                    // 如果指定了原订单ID，直接查询
                    originalOrder = orderMapper.selectById(request.getOriginalOrderId());
                    if (originalOrder == null) {
                        return OrderRenewalResult.failed("原订单不存在");
                    }
                    
                    // 检查订单归属
                    if (!originalOrder.getUserId().equals(request.getUserId())) {
                        return OrderRenewalResult.failed("无权限续费该订单");
                    }
                } else {
                    // 如果没有指定原订单ID，查询用户的有效订单
                    List<Order> validOrders = getValidOrders(request.getUserId(), request.getProductId());
                    if (validOrders.isEmpty()) {
                        return OrderRenewalResult.failed("用户不存在有效订单，无法续费");
                    }
                    
                    // 使用最新的有效订单
                    originalOrder = validOrders.get(0);
                }
                
                // 2. 检查原订单状态
                if (!isValidOrderForRenewal(originalOrder)) {
                    return OrderRenewalResult.failed("原订单状态不允许续费，当前状态: " + originalOrder.getStatus());
                }
                
                // 3. 复制有效订单信息
                Order newOrder = copyOrderInfo(originalOrder);
                
                // 4. 生成新未支付订单
                newOrder.setOrderNo(generateOrderNo());
                newOrder.setStatus(OrderStatus.UNPAID.getCode());
                newOrder.setOriginalOrderId(originalOrder.getId());
                newOrder.setOriginalOrderNo(originalOrder.getOrderNo());
                newOrder.setRenewalType("MANUAL"); // 手动续费
                newOrder.setCreateTime(new Date());
                newOrder.setUpdateTime(new Date());
                
                // 清空支付相关字段
                newOrder.setPayTime(null);
                newOrder.setTransactionNo(null);
                
                orderMapper.insert(newOrder);
                
                log.info("续费订单生成成功: originalOrderId={}, originalOrderNo={}, newOrderId={}, newOrderNo={}, userId={}", 
                        originalOrder.getId(), originalOrder.getOrderNo(), 
                        newOrder.getId(), newOrder.getOrderNo(), request.getUserId());
                
                // 5. 构建返回结果
                OrderRenewalResult result = new OrderRenewalResult();
                result.setSuccess(true);
                result.setOriginalOrderId(originalOrder.getId());
                result.setOriginalOrderNo(originalOrder.getOrderNo());
                result.setNewOrderId(newOrder.getId());
                result.setNewOrderNo(newOrder.getOrderNo());
                result.setAmount(newOrder.getFinalAmount());
                result.setProductId(newOrder.getProductId());
                result.setProductName(newOrder.getProductName());
                result.setMessage("续费订单生成成功");
                
                return result;
                
            } else {
                return OrderRenewalResult.failed("续费订单操作超时，请稍后再试");
            }
        } catch (Exception e) {
            log.error("续费订单失败: userId={}, originalOrderId={}, error={}", 
                    request.getUserId(), request.getOriginalOrderId(), e.getMessage(), e);
            return OrderRenewalResult.failed("续费订单失败: " + e.getMessage());
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    /**
     * 获取用户有效订单
     */
    private List<Order> getValidOrders(Long userId, Long productId) {
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        
        if (productId != null) {
            queryWrapper.eq("product_id", productId);
        }
        
        // 有效订单状态：已支付、已完成
        queryWrapper.in("status", 
                OrderStatus.PAID.getCode(), 
                OrderStatus.COMPLETED.getCode());
        
        queryWrapper.eq("deleted", 0);
        queryWrapper.orderByDesc("create_time");
        
        return orderMapper.selectList(queryWrapper);
    }

    /**
     * 检查订单是否允许续费
     */
    private boolean isValidOrderForRenewal(Order order) {
        // 只有已支付或已完成的订单可以续费
        String status = order.getStatus();
        return OrderStatus.PAID.getCode().equals(status) || 
               OrderStatus.COMPLETED.getCode().equals(status);
    }

    /**
     * 复制有效订单信息
     */
    private Order copyOrderInfo(Order originalOrder) {
        Order newOrder = new Order();
        
        // 复制基本信息
        newOrder.setUserId(originalOrder.getUserId());
        newOrder.setProductId(originalOrder.getProductId());
        newOrder.setProductName(originalOrder.getProductName());
        newOrder.setQuantity(originalOrder.getQuantity());
        
        // 复制金额信息
        newOrder.setOriginalAmount(originalOrder.getOriginalAmount());
        newOrder.setDiscountAmount(originalOrder.getDiscountAmount());
        newOrder.setFinalAmount(originalOrder.getFinalAmount());
        newOrder.setDepositAmount(originalOrder.getDepositAmount());
        
        // 复制优惠券信息
        newOrder.setCouponIds(originalOrder.getCouponIds());
        
        // 复制其他信息
        newOrder.setProductType(originalOrder.getProductType());
        newOrder.setProductCode(originalOrder.getProductCode());
        newOrder.setRemark("续费订单，原订单号: " + originalOrder.getOrderNo());
        
        return newOrder;
    }

    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return "ORD" + System.currentTimeMillis() + RandomUtils.nextInt(10000, 99999);
    }

    /**
     * 查询用户续费订单列表
     */
    public List<Order> getUserRenewalOrders(Long userId, Long originalOrderId) {
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        queryWrapper.eq("original_order_id", originalOrderId);
        queryWrapper.eq("deleted", 0);
        queryWrapper.orderByDesc("create_time");
        
        return orderMapper.selectList(queryWrapper);
    }
}

4. 数据模型定义

4.1 订单续费请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 订单续费请求
 */
@Data
public class OrderRenewalRequest {
    /**
     * 用户ID
     */
    private Long userId;
    
    /**
     * 原订单ID（可选，如果不指定则查询用户最新有效订单）
     */
    private Long originalOrderId;
    
    /**
     * 商品ID（可选，用于筛选有效订单）
     */
    private Long productId;
}

4.2 订单续费结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
 * 订单续费结果
 */
@Data
public class OrderRenewalResult {
    /**
     * 是否成功
     */
    private Boolean success;
    
    /**
     * 原订单ID
     */
    private Long originalOrderId;
    
    /**
     * 原订单号
     */
    private String originalOrderNo;
    
    /**
     * 新订单ID
     */
    private Long newOrderId;
    
    /**
     * 新订单号
     */
    private String newOrderNo;
    
    /**
     * 订单金额
     */
    private BigDecimal amount;
    
    /**
     * 商品ID
     */
    private Long productId;
    
    /**
     * 商品名称
     */
    private String productName;
    
    /**
     * 消息
     */
    private String message;
    
    public static OrderRenewalResult failed(String message) {
        OrderRenewalResult result = new OrderRenewalResult();
        result.setSuccess(false);
        result.setMessage(message);
        return result;
    }
}

4.3 订单（更新字段）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/**
 * 订单
 */
@Data
@TableName("order")
public class Order {
    /**
     * 主键ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    
    /**
     * 订单号
     */
    private String orderNo;
    
    /**
     * 用户ID
     */
    private Long userId;
    
    /**
     * 商品ID
     */
    private Long productId;
    
    /**
     * 商品名称
     */
    private String productName;
    
    /**
     * 商品类型
     */
    private String productType;
    
    /**
     * 商品编码
     */
    private String productCode;
    
    /**
     * 商品数量
     */
    private Integer quantity;
    
    /**
     * 原价金额
     */
    private BigDecimal originalAmount;
    
    /**
     * 优惠金额
     */
    private BigDecimal discountAmount;
    
    /**
     * 最终金额
     */
    private BigDecimal finalAmount;
    
    /**
     * 押金金额
     */
    private BigDecimal depositAmount;
    
    /**
     * 优惠券IDs（逗号分隔）
     */
    private String couponIds;
    
    /**
     * 订单状态：UNPAID-未支付, PAID-已支付, CANCELLED-已取消等
     */
    private String status;
    
    /**
     * 原订单ID（续费订单关联的原订单）
     */
    private Long originalOrderId;
    
    /**
     * 原订单号（续费订单关联的原订单号）
     */
    private String originalOrderNo;
    
    /**
     * 续费类型：MANUAL-手动续费, AUTO-自动续费
     */
    private String renewalType;
    
    /**
     * 交易号
     */
    private String transactionNo;
    
    /**
     * 支付时间
     */
    private Date payTime;
    
    /**
     * 备注
     */
    private String remark;
    
    /**
     * 创建时间
     */
    private Date createTime;
    
    /**
     * 更新时间
     */
    private Date updateTime;
}

4.4 订单状态枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * 订单状态枚举
 */
public enum OrderStatus {
    UNPAID("UNPAID", "未支付"),
    PAID("PAID", "已支付"),
    CANCELLED("CANCELLED", "已取消"),
    COMPLETED("COMPLETED", "已完成"),
    REFUNDED("REFUNDED", "已退款");
    
    private final String code;
    private final String name;
    
    OrderStatus(String code, String name) {
        this.code = code;
        this.name = name;
    }
    
    public String getCode() {
        return code;
    }
    
    public String getName() {
        return name;
    }
}

5. 数据库Mapper实现

5.1 OrderMapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
 * 订单Mapper
 */
@Mapper
public interface OrderMapper extends BaseMapper<Order> {

    /**
     * 根据订单号查询订单
     */
    @Select("SELECT * FROM `order` WHERE order_no = #{orderNo} AND deleted = 0")
    Order selectByOrderNo(@Param("orderNo") String orderNo);

    /**
     * 查询用户的有效订单（已支付、已完成）
     */
    @Select("SELECT * FROM `order` " +
            "WHERE user_id = #{userId} " +
            "AND product_id = #{productId} " +
            "AND status IN ('PAID', 'COMPLETED') " +
            "AND deleted = 0 " +
            "ORDER BY create_time DESC")
    List<Order> selectValidOrdersByUserIdAndProductId(
            @Param("userId") Long userId, 
            @Param("productId") Long productId);

    /**
     * 查询续费订单列表
     */
    @Select("SELECT * FROM `order` " +
            "WHERE user_id = #{userId} " +
            "AND original_order_id = #{originalOrderId} " +
            "AND deleted = 0 " +
            "ORDER BY create_time DESC")
    List<Order> selectRenewalOrdersByOriginalOrderId(
            @Param("userId") Long userId,
            @Param("originalOrderId") Long originalOrderId);
}

6. 数据库表设计

6.1 订单表（更新字段）

1
2
3
4
5
6
7
-- 订单表增加续费相关字段
ALTER TABLE `order` 
ADD COLUMN `original_order_id` bigint(20) DEFAULT NULL COMMENT '原订单ID（续费订单关联的原订单）' AFTER `status`,
ADD COLUMN `original_order_no` varchar(64) DEFAULT NULL COMMENT '原订单号（续费订单关联的原订单号）' AFTER `original_order_id`,
ADD COLUMN `renewal_type` varchar(20) DEFAULT NULL COMMENT '续费类型：MANUAL-手动续费, AUTO-自动续费' AFTER `original_order_no`,
ADD KEY `idx_original_order_id` (`original_order_id`),
ADD KEY `idx_user_id_product_id` (`user_id`, `product_id`);

7. 续费订单查询服务

7.1 续费订单查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/**
 * 续费订单查询服务
 */
@Service
@Slf4j
public class OrderRenewalQueryService {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 查询用户的有效订单（用于续费）
     */
    public List<Order> getValidOrdersForRenewal(Long userId, Long productId) {
        try {
            List<Order> validOrders = orderMapper.selectValidOrdersByUserIdAndProductId(
                    userId, productId);
            
            return validOrders;
            
        } catch (Exception e) {
            log.error("查询用户有效订单失败: userId={}, productId={}, error={}", 
                    userId, productId, e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * 查询续费订单列表
     */
    public List<Order> getRenewalOrders(Long userId, Long originalOrderId) {
        try {
            List<Order> renewalOrders = orderMapper.selectRenewalOrdersByOriginalOrderId(
                    userId, originalOrderId);
            
            return renewalOrders;
            
        } catch (Exception e) {
            log.error("查询续费订单列表失败: userId={}, originalOrderId={}, error={}", 
                    userId, originalOrderId, e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * 查询订单续费历史
     */
    public OrderRenewalHistory getOrderRenewalHistory(Long originalOrderId) {
        try {
            // 1. 查询原订单
            Order originalOrder = orderMapper.selectById(originalOrderId);
            if (originalOrder == null) {
                return null;
            }
            
            // 2. 查询所有续费订单
            List<Order> renewalOrders = orderMapper.selectRenewalOrdersByOriginalOrderId(
                    originalOrder.getUserId(), originalOrderId);
            
            // 3. 构建续费历史
            OrderRenewalHistory history = new OrderRenewalHistory();
            history.setOriginalOrder(originalOrder);
            history.setRenewalOrders(renewalOrders);
            history.setRenewalCount(renewalOrders.size());
            
            return history;
            
        } catch (Exception e) {
            log.error("查询订单续费历史失败: originalOrderId={}, error={}", 
                    originalOrderId, e.getMessage(), e);
            return null;
        }
    }
}

7.2 续费历史数据模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 订单续费历史
 */
@Data
public class OrderRenewalHistory {
    /**
     * 原订单
     */
    private Order originalOrder;
    
    /**
     * 续费订单列表
     */
    private List<Order> renewalOrders;
    
    /**
     * 续费次数
     */
    private Integer renewalCount;
}

8. 性能优化策略

8.1 有效订单缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * 有效订单缓存服务
 */
@Service
@Slf4j
public class ValidOrderCacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 获取用户有效订单（带缓存）
     */
    public List<Order> getValidOrders(Long userId, Long productId) {
        String cacheKey = "user:valid:orders:" + userId + ":" + productId;
        List<Order> orders = (List<Order>) redisTemplate.opsForValue().get(cacheKey);
        
        if (orders != null) {
            return orders;
        }
        
        // 缓存未命中，查询数据库
        orders = orderMapper.selectValidOrdersByUserIdAndProductId(userId, productId);
        
        // 写入缓存，过期时间5分钟
        if (orders != null && !orders.isEmpty()) {
            redisTemplate.opsForValue().set(cacheKey, orders, 5, TimeUnit.MINUTES);
        }
        
        return orders != null ? orders : new ArrayList<>();
    }

    /**
     * 更新有效订单缓存
     */
    public void updateValidOrderCache(Long userId, Long productId) {
        String cacheKey = "user:valid:orders:" + userId + ":" + productId;
        redisTemplate.delete(cacheKey);
    }

    /**
     * 删除有效订单缓存
     */
    public void deleteValidOrderCache(Long userId, Long productId) {
        String cacheKey = "user:valid:orders:" + userId + ":" + productId;
        redisTemplate.delete(cacheKey);
    }
}

9. 续费订单扩展功能

9.1 自动续费功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
 * 自动续费服务
 */
@Service
@Slf4j
public class AutoRenewalService {

    @Autowired
    private OrderService orderService;
    
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 自动续费订单
     * 定时任务调用，自动为即将到期的订单生成续费订单
     */
    @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行
    public void autoRenewalOrders() {
        try {
            // 1. 查询即将到期的订单（提前3天）
            Date expiryDate = DateUtils.addDays(new Date(), 3);
            List<Order> expiringOrders = orderMapper.selectExpiringOrders(expiryDate);
            
            log.info("查询到即将到期的订单数量: {}", expiringOrders.size());
            
            // 2. 为每个订单生成续费订单
            for (Order order : expiringOrders) {
                try {
                    OrderRenewalRequest request = new OrderRenewalRequest();
                    request.setUserId(order.getUserId());
                    request.setOriginalOrderId(order.getId());
                    
                    OrderRenewalResult result = orderService.renewalOrder(request);
                    
                    if (result.isSuccess()) {
                        log.info("自动续费订单生成成功: originalOrderId={}, newOrderId={}", 
                                order.getId(), result.getNewOrderId());
                    } else {
                        log.warn("自动续费订单生成失败: originalOrderId={}, error={}", 
                                order.getId(), result.getMessage());
                    }
                    
                } catch (Exception e) {
                    log.error("自动续费订单处理失败: orderId={}, error={}", 
                            order.getId(), e.getMessage(), e);
                }
            }
            
        } catch (Exception e) {
            log.error("自动续费订单任务执行失败: error={}", e.getMessage(), e);
        }
    }
}

9.2 续费订单统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * 续费订单统计服务
 */
@Service
@Slf4j
public class OrderRenewalStatisticsService {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 统计用户续费次数
     */
    public Integer countUserRenewalTimes(Long userId, Long originalOrderId) {
        List<Order> renewalOrders = orderMapper.selectRenewalOrdersByOriginalOrderId(
                userId, originalOrderId);
        return renewalOrders.size();
    }

    /**
     * 统计用户续费订单总金额
     */
    public BigDecimal calculateUserRenewalTotalAmount(Long userId, Long originalOrderId) {
        List<Order> renewalOrders = orderMapper.selectRenewalOrdersByOriginalOrderId(
                userId, originalOrderId);
        
        return renewalOrders.stream()
                .map(Order::getFinalAmount)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

10. 总结

本文详细介绍了用户续费订单的Java微服务架构实现，包括：

  1. 用户网关服务：负责用户请求接入、身份认证、请求路由
  2. 订单服务：负责订单管理、有效订单查询、订单信息复制、新订单生成
  3. 续费流程：
    • 用户续费订单请求
    • 身份认证
    • 判断用户存在有效订单
    • 复制有效订单信息
    • 生成新未支付订单
    • 返回续费结果
  4. 订单复制：完整复制原订单的商品信息、金额信息、优惠券信息
  5. 有效订单查询：支持按用户ID和商品ID查询有效订单
  6. 续费历史：支持查询订单续费历史记录
  7. 自动续费：支持定时任务自动续费
  8. 性能优化：有效订单缓存，提升查询性能

该架构具有以下优势：

  • 用户友好：简化续费流程，一键续费
  • 数据一致性：事务管理保证续费订单生成的原子性
  • 高性能：分布式锁保证并发安全，有效订单缓存提升性能
  • 高可用：数据库持久化，支持数据恢复
  • 可扩展：微服务架构，支持水平扩展
  • 完整性：完整的续费订单管理和历史记录

通过本文的实战代码，可以快速搭建一个高性能、高可用、用户友好的用户续费订单系统。