Spring Boot中如何使用R2DBC驱动处理实体关系？

R2DBC本身不提供JPA式的自动ORM关联支持，需要手动通过查询组合、反应式操作符或有限的注解来处理实体关联。以下是几种可行的实现方案：

方案1：服务层手动组装关联实体 #

通过拆分查询（先查主实体，再批量查关联子实体），利用Reactor的反应式操作符在服务层组装关联关系，这是最通用的方案，能避免N+1查询问题。

示例：一对多（Order -> OrderItem） #

实体定义

public class Order {
    private Long id;
    private String orderNo;
    private List<OrderItem> items;
    // Getters & Setters
}

public class OrderItem {
    private Long id;
    private Long orderId;
    private String productName;
    // Getters & Setters
}

Repository层

public interface OrderRepository extends R2dbcRepository<Order, Long> {
    Mono<Order> findById(Long id);
    Flux<Order> findAll();
}

public interface OrderItemRepository extends R2dbcRepository<OrderItem, Long> {
    Flux<OrderItem> findByOrderIdIn(List<Long> orderIds);
}

服务层组装逻辑

@Service
public class OrderService {
    private final OrderRepository orderRepo;
    private final OrderItemRepository itemRepo;

    public OrderService(OrderRepository orderRepo, OrderItemRepository itemRepo) {
        this.orderRepo = orderRepo;
        this.itemRepo = itemRepo;
    }

    // 查询单个订单及关联商品
    public Mono<Order> getOrderWithItems(Long orderId) {
        return orderRepo.findById(orderId)
                .flatMap(order -> 
                    itemRepo.findByOrderIdIn(List.of(order.getId()))
                            .collectList()
                            .map(items -> {
                                order.setItems(items);
                                return order;
                            })
                );
    }

    // 查询所有订单及关联商品（批量查询优化）
    public Flux<Order> getAllOrdersWithItems() {
        return orderRepo.findAll()
                .collectList()
                .flatMapMany(orders -> {
                    List<Long> orderIds = orders.stream().map(Order::getId).toList();
                    return itemRepo.findByOrderIdIn(orderIds)
                            .collectMultimap(OrderItem::getOrderId)
                            .map(itemMap -> {
                                orders.forEach(order -> 
                                    order.setItems(itemMap.getOrDefault(order.getId(), List.of()))
                                );
                                return orders;
                            })
                            .flatMapMany(Flux::fromIterable);
                });
    }
}

多对一场景（Order -> User） #

通过JOIN查询获取关联数据，映射到临时DTO后转换为带关联的实体：

// 临时DTO接收JOIN查询结果
public class OrderUserDto {
    private Long orderId;
    private String orderNo;
    private Long userId;
    private String username;

    // 转换为带User的Order实体
    public Order toOrder() {
        Order order = new Order();
        order.setId(orderId);
        order.setOrderNo(orderNo);
        User user = new User();
        user.setId(userId);
        user.setUsername(username);
        order.setUser(user);
        return order;
    }
}

// Repository层查询
public interface OrderRepository extends R2dbcRepository<Order, Long> {
    @Query("SELECT o.id as order_id, o.order_no, u.id as user_id, u.username FROM orders o JOIN users u ON o.user_id = u.id WHERE o.id = :id")
    Mono<OrderUserDto> findOrderWithUserDto(Long id);
}

// 服务层转换
public Mono<Order> getOrderWithUser(Long orderId) {
    return orderRepo.findOrderWithUserDto(orderId).map(OrderUserDto::toOrder);
}

方案2：使用Spring Data R2DBC的@Relation注解（有限支持） #

Spring Data R2DBC提供@Relation注解辅助关联映射，但仅用于查询结果的组装，不支持级联保存/删除，仍需配合手动查询。

示例 #

public class Order {
    private Long id;
    private String orderNo;

    // collectionRelation指定关联子实体的映射关系
    @Relation(collectionRelation = "items", embedded = false)
    private List<OrderItem> items;
    // Getters & Setters
}

public class OrderItem {
    private Long id;
    private Long orderId;
    private String productName;
    // Getters & Setters
}

使用时需确保查询返回关联数据（如JOIN或批量查询），注解会自动将子实体集合映射到items字段。

方案3：DTO层封装关联数据 #

避免在实体层定义关联，通过专门的DTO封装带关联的业务数据，Repository层直接查询并映射到DTO，适合复杂关联场景。

示例 #

// 业务DTO
public class OrderDto {
    private Long orderId;
    private String orderNo;
    private List<OrderItemDto> items;
    // Getters & Setters
}

public class OrderItemDto {
    private Long itemId;
    private String productName;
    // Getters & Setters
}

// Repository层自定义查询与映射
public interface OrderRepository extends R2dbcRepository<Order, Long> {
    @Query("SELECT o.id as order_id, o.order_no, i.id as item_id, i.product_name FROM orders o LEFT JOIN order_items i ON o.id = i.order_id WHERE o.id = :id")
    Flux<Map<String, Object>> findOrderWithItemsRaw(Long id);

    default Mono<OrderDto> getOrderDto(Long id) {
        return findOrderWithItemsRaw(id)
                .collectList()
                .map(rows -> {
                    OrderDto dto = new OrderDto();
                    List<OrderItemDto> items = new ArrayList<>();
                    for (Map<String, Object> row : rows) {
                        if (dto.getOrderId() == null) {
                            dto.setOrderId((Long) row.get("order_id"));
                            dto.setOrderNo((String) row.get("order_no"));
                        }
                        if (row.get("item_id") != null) {
                            OrderItemDto itemDto = new OrderItemDto();
                            itemDto.setItemId((Long) row.get("item_id"));
                            itemDto.setProductName((String) row.get("product_name"));
                            items.add(itemDto);
                        }
                    }
                    dto.setItems(items);
                    return dto;
                });
    }
}

方案4：利用反应式操作符优化关联查询 #

通过Reactor的collectMap、collectMultimap等操作符，批量查询关联实体并在内存中映射，减少数据库交互次数，提升性能（本质是方案1的优化实现）。

多对一批量查询示例 #

public Flux<Order> getOrdersWithUsers() {
    return orderRepo.findAll()
            .collectList()
            .flatMapMany(orders -> {
                // 提取所有唯一用户ID，批量查询
                List<Long> userIds = orders.stream().map(Order::getUserId).distinct().toList();
                return userRepo.findAllById(userIds)
                        .collectMap(User::getId)
                        .map(userMap -> {
                            // 内存中映射用户到订单
                            orders.forEach(order -> order.setUser(userMap.get(order.getUserId())));
                            return orders;
                        })
                        .flatMapMany(Flux::fromIterable);
            });
}

内容的提问来源于stack exchange，提问作者Punith Kumar P R