1
@RestController
2
@RequestMapping("/api/users")
3
public class UserController {
4

5
    @Autowired
6
    private UserService userService;
7

8
    @PostMapping("/register")
9
    public ResponseEntity<UserRegistrationResponse> register(
10
            @Valid @RequestBody UserRegistrationRequest request) {
11

12
        UserRegistrationResponse response = userService.registerUser(request);
13
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
14
    }
15

16
    @GetMapping("/{userId}")
17
    public ResponseEntity<UserDetailResponse> getUserDetail(@PathVariable Long userId) {
18
        UserDetailResponse response = userService.getUserDetail(userId);
19
        return ResponseEntity.ok(response);
20
    }
21

22
    @PutMapping("/{userId}/profile")
23
    public ResponseEntity<Void> updateProfile(@PathVariable Long userId,
24
                                            @Valid @RequestBody UpdateProfileRequest request) {
25
        userService.updateProfile(userId, request);
26
        return ResponseEntity.ok().build();
27
    }
28
}
29

30
@Service
31
@Transactional
32
public class UserService {
33

34
    @Autowired
35
    private UserRepository userRepository;
36

37
    @Autowired
38
    private PasswordEncoder passwordEncoder;
39

40
    @Autowired
41
    private ApplicationEventPublisher eventPublisher;
42

43
    public UserRegistrationResponse registerUser(UserRegistrationRequest request) {
44
        // 验证用户名是否已存在
45
        if (userRepository.existsByUsername(request.getUsername())) {
46
            throw new UserAlreadyExistsException("用户名已存在");
47
        }
48

49
        // 创建新用户
50
        User user = User.builder()
51
                .username(request.getUsername())
52
                .email(request.getEmail())
53
                .passwordHash(passwordEncoder.encode(request.getPassword()))
54
                .status(UserStatus.ACTIVE)
55
                .createdAt(LocalDateTime.now())
56
                .build();
57

58
        User savedUser = userRepository.save(user);
59

60
        // 发布用户注册事件
61
        eventPublisher.publishEvent(new UserRegisteredEvent(savedUser.getId(), savedUser.getEmail()));
62

63
        return UserRegistrationResponse.from(savedUser);
64
    }
65
}

1
@RestController
2
@RequestMapping("/api/orders")
3
public class OrderController {
4

5
    @Autowired
6
    private OrderService orderService;
7

8
    @PostMapping
9
    public ResponseEntity<CreateOrderResponse> createOrder(
10
            @Valid @RequestBody CreateOrderRequest request,
11
            @RequestHeader("X-User-Id") Long userId) {
12

13
        CreateOrderResponse response = orderService.createOrder(request, userId);
14
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
15
    }
16

17
    @GetMapping("/{orderId}")
18
    public ResponseEntity<OrderDetailResponse> getOrderDetail(@PathVariable String orderId) {
19
        OrderDetailResponse response = orderService.getOrderDetail(orderId);
20
        return ResponseEntity.ok(response);
21
    }
22
}
23

24
@Service
25
@Transactional
26
public class OrderService {
27

28
    @Autowired
29
    private OrderRepository orderRepository;
30

31
    @Autowired
32
    private InventoryServiceClient inventoryServiceClient;
33

34
    @Autowired
35
    private PaymentServiceClient paymentServiceClient;
36

37
    @Autowired
38
    private RabbitTemplate rabbitTemplate;
39

40
    public CreateOrderResponse createOrder(CreateOrderRequest request, Long userId) {
41
        // 1. 验证库存
42
        List<InventoryCheckResult> inventoryResults =
43
            inventoryServiceClient.checkInventory(request.getItems());
44

45
        if (!inventoryResults.stream().allMatch(InventoryCheckResult::isAvailable)) {
46
            throw new InsufficientInventoryException("库存不足");
47
        }
48

49
        // 2. 创建订单
50
        Order order = Order.builder()
51
                .orderId(generateOrderId())
52
                .userId(userId)
53
                .items(request.getItems())
54
                .totalAmount(calculateTotalAmount(request.getItems()))
55
                .status(OrderStatus.PENDING_PAYMENT)
56
                .createdAt(LocalDateTime.now())
57
                .build();
58

59
        Order savedOrder = orderRepository.save(order);
60

61
        // 3. 预留库存
62
        inventoryServiceClient.reserveInventory(savedOrder.getOrderId(), request.getItems());
63

64
        // 4. 发送订单创建事件
65
        OrderCreatedEvent event = new OrderCreatedEvent(savedOrder.getOrderId(), userId, savedOrder.getTotalAmount());
66
        rabbitTemplate.convertAndSend("order.exchange", "order.created", event);
67

68
        return CreateOrderResponse.from(savedOrder);
69
    }
70
}

1
@FeignClient(name = "inventory-service", fallback = InventoryServiceFallback.class)
2
public interface InventoryServiceClient {
3

4
    @PostMapping("/api/inventory/check")
5
    List<InventoryCheckResult> checkInventory(@RequestBody List<OrderItem> items);
6

7
    @PostMapping("/api/inventory/reserve")
8
    void reserveInventory(@RequestParam String orderId, @RequestBody List<OrderItem> items);
9

10
    @PostMapping("/api/inventory/release")
11
    void releaseInventory(@RequestParam String orderId);
12
}
13

14
@Component
15
public class InventoryServiceFallback implements InventoryServiceClient {
16

17
    @Override
18
    public List<InventoryCheckResult> checkInventory(List<OrderItem> items) {
19
        // 降级策略：假设库存充足
20
        return items.stream()
21
                .map(item -> InventoryCheckResult.builder()
22
                        .productId(item.getProductId())
23
                        .available(true)
24
                        .availableQuantity(item.getQuantity())
25
                        .build())
26
                .collect(Collectors.toList());
27
    }
28

29
    @Override
30
    public void reserveInventory(String orderId, List<OrderItem> items) {
31
        log.warn("库存服务不可用，订单 {} 的库存预留操作已降级", orderId);
32
    }
33

34
    @Override
35
    public void releaseInventory(String orderId) {
36
        log.warn("库存服务不可用，订单 {} 的库存释放操作已降级", orderId);
37
    }
38
}

1
@Component
2
public class OrderEventListener {
3

4
    @Autowired
5
    private InventoryService inventoryService;
6

7
    @Autowired
8
    private NotificationService notificationService;
9

10
    @RabbitListener(queues = "order.payment.success.queue")
11
    public void handlePaymentSuccess(PaymentSuccessEvent event) {
12
        try {
13
            // 确认库存扣减
14
            inventoryService.confirmInventoryDeduction(event.getOrderId());
15

16
            // 发送订单成功通知
17
            notificationService.sendOrderSuccessNotification(event.getUserId(), event.getOrderId());
18

19
        } catch (Exception e) {
20
            log.error("处理支付成功事件失败: orderId={}, error={}", event.getOrderId(), e.getMessage());
21
            // 重试机制或死信队列处理
22
            throw new RuntimeException(e);
23
        }
24
    }
25

26
    @RabbitListener(queues = "order.payment.failed.queue")
27
    public void handlePaymentFailed(PaymentFailedEvent event) {
28
        try {
29
            // 释放预留库存
30
            inventoryService.releaseReservedInventory(event.getOrderId());
31

32
            // 更新订单状态
33
            orderService.updateOrderStatus(event.getOrderId(), OrderStatus.PAYMENT_FAILED);
34

35
        } catch (Exception e) {
36
            log.error("处理支付失败事件失败: orderId={}, error={}", event.getOrderId(), e.getMessage());
37
        }
38
    }
39
}