基础设施层设计

基础设施层设计

数据访问 (Data)

架构设计

┌─────────────────────────────────────────┐
│          Application Layer               │
│   ┌──────────┐  ┌──────────┐           │
│   │ Service  │  │Repository│           │
│   └─────┬────┘  └─────┬────┘           │
│         │             │                 │
│         ↓             ↓                 │
├─────────────────────────────────────────┤
│       Data Access Layer (Nebula)        │
│   ┌──────────────────────────────┐     │
│   │    Data Access Abstraction    │     │
│   │  ┌────────┐  ┌────────┐      │     │
│   │  │Persistence│ │ Cache │      │     │
│   │  └────────┘  └────────┘      │     │
│   └───────┬──────────┬────────────┘     │
│           │          │                  │
├───────────┼──────────┼──────────────────┤
│           ↓          ↓                  │
│   ┌────────┐    ┌─────────┐           │
│   │ MySQL  │    │  Redis  │  MongoDB  │
│   └────────┘    └─────────┘           │
└─────────────────────────────────────────┘

nebula-data-persistence

特性： - MyBatis-Plus 集成 - 读写分离 - 分库分表 - 多数据源

核心组件：

// 1. 基础 Mapper
public interface BaseMapper<T> extends 
    com.baomidou.mybatisplus.core.mapper.BaseMapper<T> {
    // 扩展方法
}

// 2. 基础 Service
public interface BaseService<T> extends 
    IService<T> {
    // 扩展方法
}

// 3. 数据源配置
@Configuration
public class DataSourceConfig {
    @Bean
    public DataSource masterDataSource() { }

    @Bean
    public DataSource slaveDataSource() { }
}

nebula-data-cache

多级缓存架构：

请求
  ↓
L1: Caffeine 本地缓存 (1-10ms)
  ↓ 未命中
L2: Redis 分布式缓存 (10-50ms)
  ↓ 未命中
L3: 数据库 (50-200ms)
  ↓
响应

核心接口：

public interface CacheService {
    // 基础操作
    void set(String key, Object value, int ttl);
    <T> T get(String key, Class<T> type);
    void delete(String key);

    // 批量操作
    void multiSet(Map<String, Object> map, int ttl);
    <T> Map<String, T> multiGet(List<String> keys, Class<T> type);

    // 高级操作
    <T> T getOrLoad(String key, Supplier<T> loader, int ttl);
}

票务场景应用：

// 票务信息缓存（热点数据）
@Cacheable(value = "ticket", key = "#id")
public Ticket getTicketById(Long id) {
    return ticketMapper.selectById(id);
}

// 座位状态缓存（实时数据）
String key = "showtime:seats:" + showtimeId;
List<Seat> seats = cacheService.get(key, List.class);
if (seats == null) {
    seats = seatService.getAvailableSeats(showtimeId);
    cacheService.set(key, seats, 10); // 10秒过期
}

消息传递 (Messaging)

架构设计

┌──────────────────────────────────────────┐
│         Application Layer                 │
│   ┌────────────┐    ┌─────────────┐     │
│   │  Producer  │    │  Consumer   │     │
│   └──────┬─────┘    └──────┬──────┘     │
│          │                 │             │
├──────────┼─────────────────┼─────────────┤
│          ↓                 ↓             │
│   ┌─────────────────────────────────┐   │
│   │  Messaging Abstraction Layer    │   │
│   │  (nebula-messaging-core)        │   │
│   └─────────────┬───────────────────┘   │
│                 │                        │
├─────────────────┼────────────────────────┤
│                 ↓                        │
│   ┌────────────────────────┐           │
│   │  RabbitMQ / Kafka      │           │
│   └────────────────────────┘           │
└──────────────────────────────────────────┘

核心接口：

// 消息生产者
public interface MessageProducer {
    void send(String topic, Object message);
    void sendAsync(String topic, Object message);
    void sendDelayed(String topic, Object message, long delayMs);
}

// 消息消费者
@MessageHandler(topic = "order.created")
public void handleOrderCreated(OrderMessage message) {
    // 处理订单创建消息
}

票务场景应用：

// 1. 订单创建后发送消息
Order order = orderService.create(orderDto);
messageProducer.send("order.created", order);

// 2. 异步处理订单
@MessageHandler(topic = "order.created")
public void handleOrderCreated(Order order) {
    // 生成电子票
    ticketService.generateETicket(order);

    // 发送通知
    notificationService.sendOrderNotification(order);
}

// 3. 延时取消订单
messageProducer.sendDelayed("order.timeout", orderId, 15 * 60 * 1000); // 15分钟后

RPC 通信 (RPC)

架构设计

┌──────────────────────────────────────────┐
│         Application Layer                 │
│   ┌────────────┐    ┌─────────────┐     │
│   │  RPC Client │    │ RPC Server  │     │
│   └──────┬─────┘    └──────┬──────┘     │
│          │                 │             │
├──────────┼─────────────────┼─────────────┤
│          ↓                 ↓             │
│   ┌─────────────────────────────────┐   │
│   │    RPC Abstraction Layer        │   │
│   │    (nebula-rpc-core)            │   │
│   └─────┬───────────────┬───────────┘   │
│         │               │                │
│         ↓               ↓                │
│   ┌──────────┐    ┌──────────┐         │
│   │   HTTP   │    │   gRPC   │         │
│   └──────────┘    └──────────┘         │
└──────────────────────────────────────────┘

协议选择：

票务场景应用：

// gRPC 服务定义
service UserService {
    rpc GetUser(UserIdRequest) returns (UserResponse);
}

// gRPC 客户端调用
@GrpcClient("user-service")
private UserServiceStub userService;

public User getUserInfo(Long userId) {
    UserIdRequest request = UserIdRequest.newBuilder()
        .setUserId(userId)
        .build();
    UserResponse response = userService.getUser(request);
    return convert(response);
}

服务发现 (Discovery)

架构设计

┌────────────────────────────────────────┐
│         Service Instances               │
│  ┌──────┐  ┌──────┐  ┌──────┐        │
│  │Service│  │Service│  │Service│        │
│  │  A   │  │  B   │  │  C   │        │
│  └──┬───┘  └──┬───┘  └──┬───┘        │
│     │  注册   │  注册   │  注册        │
├─────┼────────┼────────┼───────────────┤
│     ↓        ↓        ↓               │
│  ┌────────────────────────────┐      │
│  │    Nacos Server            │      │
│  │  - 服务注册                 │      │
│  │  - 服务发现                 │      │
│  │  - 健康检查                 │      │
│  │  - 配置管理                 │      │
│  └────────────────────────────┘      │
└────────────────────────────────────────┘

核心功能： - 服务注册 - 服务发现 - 健康检查 - 负载均衡 - 配置管理

票务场景应用：

```yaml