高效的并发管理：房间预订 API 的乐观锁和消息队列-51CTO.COM

想象一下这样一个场景：多名旅行者同时尝试预订热门目的地的最后一个可用房间。如果没有适当的并发控制机制，这种情况很快就会变成竞争状态，导致房间超额预订和客户沮丧。

我们将深入研究用于应对这些挑战的两种关键策略的复杂性：乐观锁定和消息队列。

想象一下您正在使用一个在线酒店预订平台，类似于 Booking.com 或 Expedia 等知名平台。以下是同步和异步流程如何发挥作用：

同步流程：

预订房间（同步）：

您访问酒店预订网站并选择您的目的地、入住和退房日期以及其他偏好。
您点击“立即预订”按钮即可预订房间。
该网站使用基于 HTTP 的同步协议（如 REST 或 SOAP）将您的请求发送到酒店的预订系统。
酒店的系统会立即同步处理您的请求。它检查房间可用性，为您预订房间，并生成预订号码。
预订号码将发送回您的浏览器，并在几秒钟内显示在网站上。
您可以立即获得预订号码，然后可以放心地继续您的旅行计划。

创建房间实体

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;


@Entity
public class Room {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String roomType;
    private boolean isAvailable;


    // getters and setters
}

创建房间存储库

import org.springframework.data.jpa.repository.JpaRepository;


public interface RoomRepository extends JpaRepository<Room, Long> {
    Room findByRoomType(String roomType);
}

创建客房预订请求 DTO

import java.time.LocalDate;


public class RoomBookingRequest {
    private String roomType;
    private LocalDate checkInDate;
    private LocalDate checkOutDate;


    // getters and setters
}

创建客房预订响应 DTO

public class RoomBookingResponse {
    private String reservationNumber;


    // getters and setters
}

创建客房服务

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.util.UUID;


@Service
public class RoomService {


    @Autowired
    private RoomRepository roomRepository;


    public RoomBookingResponse bookRoom(RoomBookingRequest bookingRequest) {
        String roomType = bookingRequest.getRoomType();
        LocalDate checkInDate = bookingRequest.getCheckInDate();
        LocalDate checkOutDate = bookingRequest.getCheckOutDate();


        Room room = roomRepository.findByRoomType(roomType);


        if (room != null && room.isAvailable()) {
            // Add validation to check availability based on check-in and check-out dates here.


            // For simplicity, we'll assume the room is available.
            room.setAvailable(false);
            roomRepository.save(room);


            // Generate a reservation number (you can implement your logic here).
            String reservationNumber = generateReservationNumber();


            return new RoomBookingResponse(reservationNumber);
        } else {
            throw new RoomNotAvailableException();
        }
    }


    private String generateReservationNumber() {
        // Generate a unique reservation number (you can implement your logic here).
        return UUID.randomUUID().toString();
    }
}

创建房间控制器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping("/api/rooms")
public class RoomController {


    @Autowired
    private RoomService roomService;


    // Book a room
    @PostMapping("/book")
    public RoomBookingResponse bookRoom(@RequestBody RoomBookingRequest bookingRequest) {
        return roomService.bookRoom(bookingRequest);
    }
}

定义自定义异常

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;


@ResponseStatus(HttpStatus.BAD_REQUEST)
public class RoomNotAvailableException extends RuntimeException {
    public RoomNotAvailableException() {
        super("The requested room is not available.");
    }
}

测试API

您可以使用 Postman 或 cURL 等工具来测试您的 API。要预订房间，请http://localhost:8080/api/rooms/book使用包含房间类型、入住日期和退房日期的 JSON 正文发出 POST 请求：

{ 
  "roomType" :  "Standard" , 
  "checkInDate" :  "2023-10-01" , 
  "checkOutDate" :  "2023-10-05" 
}

如果房间可用，API 将返回带有预订编号的 JSON 响应。您可以根据您的课堂需求自定义预订逻辑和预订号码生成RoomService。

异步流程

当多个用户同时调用Booking API时

当多个并发呼叫在系统中搜索同一房间时，可能存在潜在的缺点和挑战：

竞争条件：当多个请求尝试同时预订同一房间时，可能会出现竞争条件。如果处理不当，这可能会导致超额预订，即系统允许的预订数量超过了可用房间的数量。

如何解决并发问题？

乐观锁定是一种数据库级技术，可防止多个用户同时尝试更新同一资源时发生数据冲突。

另一方面，消息队列是异步通信工具，可确保请求的有序、可靠处理，使其成为分布式系统中处理并发请求的理想选择。

方法一：实现消息队列响应并发请求

消息队列确保请求按照接收顺序进行处理，从而防止竞争条件和超量预订。

多个客户端向端点发出 POST 请求/api/rooms/book以同时预订酒店房间。
处理RoomController传入的预订请求。
该roomService.bookRoom方法接收预订请求。
它使用该方法将预订请求发送到名为“room-booking”的 RabbitMQ 消息队列rabbitTemplate.convertAndSend。
它向客户端返回初步响应，其中包含一条消息，表明预订请求已发送，客户端应等待确认。
预订请求被放入“房间预订”队列中。消息队列系统（在本例中为 RabbitMQ）确保每个预订请求都按照收到的顺序进行处理，以防止竞争情况。
监听RoomBookingMessageConsumer“房间预订”队列。
processBookingRequest当预订请求出队时，将调用消费者的方法。在该方法中，您通常会实现以下逻辑：
根据请求的房型、入住日期和退房日期检查客房供应情况。
如果房间可用，则生成预订号码。
更新数据库中的房间可用性，将其标记为不可用，以防止重复预订。
通过RabbitMQ向客户端发送包含预约号的响应消息

8. 在中RoomBookingMessageConsumer，处理预订请求并生成预订号码后，您可以使用传统的 HTTP 客户端（例如RestTemplate、HttpClient）将确认响应直接发送到客户端的回调 URL 端点（该端点在请求中发送）。

执行：

创建客房预订请求和响应 DTO

import java.time.LocalDate;


public class RoomBookingRequest {
    private String roomType;
    private LocalDate checkInDate;
    private LocalDate checkOutDate;
    private String clientCallbackUrl; // Added to specify the client's callback URL


    // getters and setters
}


public class RoomBookingResponse {
    private String reservationNumber;


    // getters and setters
}

修改控制器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping("/api/rooms")
public class RoomController {


    @Autowired
    private RoomService roomService;


    @PostMapping("/book")
    public RoomBookingResponse bookRoom(@RequestBody RoomBookingRequest bookingRequest) {
        return roomService.bookRoom(bookingRequest);
    }
}

创建客房预订服务（生产者）

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;


@Service
public class RoomService {


    @Autowired
    private RoomRepository roomRepository;


    @Autowired
    private RabbitTemplate rabbitTemplate;


    private RestTemplate restTemplate = new RestTemplate();


    public RoomBookingResponse bookRoom(RoomBookingRequest bookingRequest) {
        String roomType = bookingRequest.getRoomType();


        // Send the booking request to the message queue
        rabbitTemplate.convertAndSend("room-booking-exchange", "room-booking", bookingRequest);


        return new RoomBookingResponse("Booking request sent. Please wait for confirmation.");
    }


    // This method sends the response to the client's callback URL
    public void sendResponseToClient(RoomBookingResponse response, String clientCallbackUrl) {
        ResponseEntity<Void> result = restTemplate.postForEntity(clientCallbackUrl, response, Void.class);
        if (result.getStatusCode().is2xxSuccessful()) {
            // Handle a successful response sent to the client
        } else {
            // Handle the case when the response to the client failed
        }
    }
}

创建消息消费者

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class RoomBookingMessageConsumer {


    @Autowired
    private RoomService roomService;


    @RabbitListener(queues = "room-booking-queue")
    public void processBookingRequest(RoomBookingRequest bookingRequest) {
        // Process the booking request
        RoomBookingResponse response = processBookingLogic(bookingRequest);


        // Send the confirmation response to the client's callback URL
        roomService.sendResponseToClient(response, bookingRequest.getClientCallbackUrl());
    }


    private RoomBookingResponse processBookingLogic(RoomBookingRequest bookingRequest) {
        // Implement your booking logic here, e.g., checking room availability and generating a reservation number
        // Update room availability in the database
        // Send a response message to confirm the booking or indicate unavailability


        // For simplicity, we'll assume the room is available and generate a reservation number.
        String reservationNumber = generateReservationNumber();


        return new RoomBookingResponse(reservationNumber);
    }


    private String generateReservationNumber() {
        // Generate a unique reservation number (you can implement your logic here).
        return "RES-" + System.currentTimeMillis();
    }
}

方法二：实现乐观锁来处理并发请求

您可以修改代码以使用同步方法和 JPA 乐观锁定。

步骤1：修改Room实体：@Version向实体添加一个字段Room以启用乐观锁定：

import javax.persistence.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Entity
public class Room {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String roomType;
    private boolean isAvailable;
    
    @Version
    private Long version;


    // getters and setters
}

步骤2：修改客房服务对每个房间使用ReentrantLock来同步访问房间预订操作

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class RoomService {


    @Autowired
    private RoomRepository roomRepository;


    private final ConcurrentHashMap<Long, Lock> roomLocks = new ConcurrentHashMap<>();


    public RoomBookingResponse bookRoom(RoomBookingRequest bookingRequest) {
        String roomType = bookingRequest.getRoomType();
        LocalDate checkInDate = bookingRequest.getCheckInDate();
        LocalDate checkOutDate = bookingRequest.getCheckOutDate();


        Room room = roomRepository.findByRoomType(roomType);


        if (room != null) {
            Lock roomLock = roomLocks.computeIfAbsent(room.getId(), id -> new ReentrantLock());


            roomLock.lock();
            try {
                if (room.isAvailable()) {
                    // Add validation to check availability based on check-in and check-out dates here.


                    // For simplicity, we'll assume the room is available.
                    room.setAvailable(false);
                    roomRepository.save(room);


                    // Generate a reservation number (you can implement your logic here).
                    String reservationNumber = generateReservationNumber();


                    return new RoomBookingResponse(reservationNumber);
                }
            } finally {
                roomLock.unlock();
            }
        }


        throw new RoomNotAvailableException();
    }


    private String generateReservationNumber() {
        // Generate a unique reservation number (you can implement your logic here).
        return UUID.randomUUID().toString();
    }
}

详细工作原理：

并发请求&ConcurrentHashMap:当同一房间收到多个并发预订请求时，它们可能同时到达并可能导致竞争条件。的引入ConcurrentHashMap确保每个房间都有自己的锁。这ConcurrentHashMap是一个线程安全的映射，可以由多个线程同时安全地访问。

通过锁定并发更新房间可用性：如果两个线程同时尝试预订同一个房间，则只有其中一个线程会使用成功获取锁roomLock.lock()，而另一个线程将暂时阻塞，直到第一个线程释放锁。

释放锁以供其他线程更新：一旦线程获取了锁并成功修改了房间的可用性，它就会使用释放锁roomLock.unlock()，从而允许其他线程继续预订其他房间。

乐观锁防止数据库级别的竞争条件：在代码中，实体中的字段启用数据库级别的乐观锁。更新房间时，JPA 在允许更新之前会根据实体中的版本字段检查数据库中的版本字段。@VersionRoom

如果两个事务同时尝试更新同一个房间，根据版本号的比较，只有其中一个会成功，从而防止数据库级别的数据冲突。
因此 2 个不同的事务无法同时更新数据库中的一个房间