后端分层架构

  @PostMapping("/register")
public Result register(@RequestBody User user) {
    // 1. 检查用户名是否重复
    if (userRepository.findByUsername(user.getUsername()) != null) {
        return Result.error("用户名已存在");
    }
    // 2. 加密密码
    user.setPassword(encrypt(user.getPassword()));
    // 3. 保存用户
    userRepository.save(user);
    // 4. 发送欢迎邮件
    emailService.sendWelcome(user.getEmail());
    // 5. 记录日志
    log.info("User registered: {}", user.getUsername());
    return Result.success();
}
  

  ┌─────────────────────────────────────┐
│  接收请求 ← Controller              │  只负责"接单"
├─────────────────────────────────────┤
│  业务编排 ← Service                 │  只负责"做菜"
├─────────────────────────────────────┤
│  数据存取 ← Repository              │  只负责"取食材"
├─────────────────────────────────────┤
│  业务定义 ← Domain                  │  只负责"菜谱标准"
└─────────────────────────────────────┘
  

  ┌─────────────────────────────────────────────────────┐
│  前端请求                                            │
└────────────────────┬────────────────────────────────┘
                     │ HTTP Request
                     ▼
┌─────────────────────────────────────────────────────┐
│  Controller (控制器层)                               │
│  - 接收请求、参数校验                                 │
│  - DTO 转换                                          │
│  - 调用 Service                                      │
│  - 返回响应                                          │
└────────────────────┬────────────────────────────────┘
                     │ 业务调用
                     ▼
┌─────────────────────────────────────────────────────┐
│  Service (业务逻辑层)                                │
│  - 业务逻辑编排                                      │
│  - 事务管理                                          │
│  - 协调多个 Repository                               │
│  - 跨模块协调                                        │
└────────────────────┬────────────────────────────────┘
                     │ 数据访问
                     ▼
┌─────────────────────────────────────────────────────┐
│  Repository (数据访问层)                             │
│  - 数据库 CRUD                                       │
│  - 查询封装                                          │
│  - ORM 映射                                          │
└────────────────────┬────────────────────────────────┘
                     │ 领域对象
                     ▼
┌─────────────────────────────────────────────────────┐
│  Domain (领域模型层)                                 │
│  - 实体 (Entity)                                     │
│  - 值对象 (Value Object)                             │
│  - 业务规则                                          │
└─────────────────────────────────────────────────────┘
  

  @RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    @PostMapping
    public UserResponse createUser(
            @RequestBody @Valid UserRequest request) {
        
        // 1. Request DTO → Param DTO
        UserParam param = UserParam.builder()
                .username(request.getUsername())
                .password(encrypt(request.getPassword()))
                .email(request.getEmail())
                .build();

        // 2. 调用 Service
        User user = userService.createUser(param);

        // 3. Entity → Response DTO
        return UserResponse.from(user);
    }
}
  

  @Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final EmailService emailService;

    @Transactional
    public User createUser(UserParam param) {
        // 1. 业务规则:检查用户名是否重复
        if (userRepository.existsByUsername(param.getUsername())) {
            throw new UserAlreadyExistsException();
        }

        // 2. 创建用户实体
        User user = new User();
        user.setUsername(param.getUsername());
        user.setPassword(param.getPassword());
        user.setEmail(param.getEmail());

        // 3. 保存到数据库
        userRepository.save(user);

        // 4. 发送欢迎邮件(跨模块协调)
        emailService.sendWelcomeEmail(user);

        return user;
    }
}
  

  @Repository
public interface UserRepository extends JpaRepository<User, Long> {

    // Spring Data JPA 自动实现
    Optional<User> findByUsername(String username);
    boolean existsByUsername(String username);

    // 自定义复杂查询
    @Query("SELECT u FROM User u WHERE u.email = :email AND u.deleted = false")
    Optional<User> findActiveByEmail(@Param("email") String email);
}
  

  @Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String password;

    // ✅ 业务方法:封装业务规则
    public boolean isPasswordCorrect(String rawPassword) {
        return BCrypt.checkpw(rawPassword, this.password);
    }

    public void changePassword(String oldPassword, String newPassword) {
        if (!isPasswordCorrect(oldPassword)) {
            throw new IncorrectPasswordException();
        }
        this.password = BCrypt.hashpw(newPassword);
    }
}
  

  // ❌ 错误:直接返回 Entity
@Entity
public class User {
    private Long id;
    private String username;
    private String password;        // 敏感信息!
    private Boolean isDeleted;      // 内部字段!
}
  

  数据库 Entity → Service Param/Result → Controller Request/Response → 前端
  

  Controller → UserServiceImpl → UserDaoImpl → UserEntity
  

  Controller → UserService(接口) → UserRepository(接口) → UserEntity
  

  // ✅ 正确:依赖接口
@Service
public class OrderService {
    private final OrderRepository orderRepository;  // 接口
    private final PaymentService paymentService;    // 接口
}

// ✅ 实现类通过 Spring 自动注入
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    // 实现细节
}
  

  @Entity
public class Order {
    @Id
    private Long id;
    private Long userId;
    private List<OrderItem> items;
    private Money totalAmount;
    private OrderStatus status;

    public void calculateTotal() {
        Money total = Money.zero();
        for (OrderItem item : items) {
            total = total.add(item.getSubTotal());
        }
        this.totalAmount = total;
    }

    public void cancel() {
        if (this.status != OrderStatus.PENDING_PAYMENT) {
            throw new IllegalStateException("只有待支付订单可以取消");
        }
        this.status = OrderStatus.CANCELLED;
    }
}
  

  @Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByUserIdOrderByCreatedAtDesc(Long userId);
}
  

  @Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;

    @Transactional
    public OrderDTO createOrder(OrderParam param) {
        // 1. 验证商品并扣减库存
        for (OrderItemParam item : param.getItems()) {
            inventoryService.reserveStock(item.getProductId(), item.getQuantity());
        }

        // 2. 创建订单
        Order order = new Order();
        order.setUserId(param.getUserId());
        order.calculateTotal();

        // 3. 保存订单
        orderRepository.save(order);

        return OrderDTO.from(order);
    }
}
  

  @RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService;

    @PostMapping
    public OrderResponse createOrder(@RequestBody @Valid OrderRequest request) {
        OrderParam param = OrderParam.builder()
                .userId(request.getUserId())
                .items(request.getItems())
                .build();

        OrderDTO order = orderService.createOrder(param);

        return OrderResponse.from(order);
    }
}
  

  ┌──────────────────────────────┐
│         单体应用              │
│  ┌────┐ ┌────┐ ┌────┐       │
│  │用户│ │订单│ │支付│ ...    │
│  └──┬─┘ └──┬─┘ └──┬─┘       │
│     └──────┼──────┘          │
│         共享数据库            │
└──────────────────────────────┘
  

  ┌────────┐  ┌────────┐  ┌────────┐
│用户服务 │  │订单服务 │  │支付服务 │
│  DB-1  │  │  DB-2  │  │  DB-3  │
└───┬────┘  └───┬────┘  └───┬────┘
    └───────────┼───────────┘
          API Gateway
  

  生产者 ──→ [事件总线/消息队列] ──→ 消费者A
                               ──→ 消费者B
                               ──→ 消费者C
  

  ┌─────────────────────────────────────┐
│  Frameworks & Drivers (框架和驱动)   │
│  ┌─────────────────────────────┐    │
│  │  Interface Adapters (适配器) │    │
│  │  ┌─────────────────────┐    │    │
│  │  │  Use Cases (用例)    │    │    │
│  │  │  ┌─────────────┐    │    │    │
│  │  │  │  Entities    │    │    │    │
│  │  │  │  (实体/领域)  │    │    │    │
│  │  │  └─────────────┘    │    │    │
│  │  └─────────────────────┘    │    │
│  └─────────────────────────────┘    │
└─────────────────────────────────────┘
         依赖方向: 外 → 内
  

          ┌─────────────┐
  HTTP ──→ Port      │
  CLI  ──→ (入端口)   │  核心业务逻辑  │  (出端口) ──→ 数据库
  MQ   ──→           │               │  Port    ──→ 外部API
        └─────────────┘
  

  ┌──────────────────────────────┐
│  Infrastructure (基础设施)    │
│  ┌────────────────────────┐  │
│  │  Application Services  │  │
│  │  ┌──────────────────┐  │  │
│  │  │  Domain Services  │  │  │
│  │  │  ┌────────────┐   │  │  │
│  │  │  │Domain Model│   │  │  │
│  │  │  └────────────┘   │  │  │
│  │  └──────────────────┘  │  │
│  └────────────────────────┘  │
└──────────────────────────────┘
  

  传统分层架构 (N-Layered)
  │  问题: 层间耦合、难以替换外部依赖
  ▼
六边形架构 (Ports & Adapters)
  │  改进: 用端口和适配器隔离外部系统
  ▼
洋葱架构 (Onion)
  │  改进: 明确同心圆分层,领域模型居中
  ▼
整洁架构 (Clean Architecture)
  │  改进: 统一依赖规则,明确四层职责
  ▼
根据业务需要选择合适的架构
  

  用户量 < 1k, 代码量 < 5000 行
    ↓
单体架构 + 简单分层
    ↓
用户量 1k-100k, 需要多团队协作
    ↓
分层架构 (本文介绍)
    ↓
用户量 > 100k, 业务复杂度高
    ↓
微服务架构 / 事件驱动架构