企业官网建设流程全解析

Plain Text
com.order
├── domain/ # 内核：领域层（纯业务，无任何外部依赖）
│ ├── entity/ # 领域实体
│ └── service/ # 领域服务（核心业务规则）
├── application/ # 内核：应用层（流程编排）
│ └── service/ # 应用服务
├── port/ # 端口：抽象接口（业务定义能力）
│ ├── inbound/ # 入站端口：外部调用系统
│ └── outbound/ # 出站端口：系统调用外部
├── adapter/ # 适配器：具体实现（技术细节）
│ ├── inbound/ # 入站适配器：Controller、RPC、Job
│ └── outbound/ # 出站适配器：DB、Redis、第三方接口
└── OrderApplication.java # 启动类

java
package com.order.domain.entity;

import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
* 领域实体：只包含业务属性与业务行为
* 无任何框架注解、无DB注解、无第三方依赖
*/
@Data
public class Order {
private String orderId;
private String userId;
private BigDecimal amount;
private LocalDateTime createTime;

// 领域行为：订单创建规则
public void create() {
if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
throw new RuntimeException("订单金额必须大于0");
}
this.createTime = LocalDateTime.now();
}
}

java
package com.order.domain.service;

import com.order.domain.entity.Order;
import org.springframework.stereotype.Service;

/**
* 领域服务：处理跨实体的核心业务规则
* 纯业务逻辑，不处理技术、不操作DB
*/
@Service
public class OrderDomainService {

public void createOrder(Order order) {
// 执行业务行为
order.create();
// 可继续添加：库存校验、价格计算、风控规则等纯业务逻辑
}
}

java
package com.order.port.inbound;

import com.order.domain.entity.Order;

public interface CreateOrderUseCase {
Order createOrder(Order order);
}

java
package com.order.port.outbound;

import com.order.domain.entity.Order;

// 订单仓储端口（抽象）
public interface OrderRepositoryPort {
Order save(Order order);
}

java
package com.order.port.outbound;

// 通知端口（抽象）
public interface NotifyPort {
void sendNotify(String orderId);
}

java
package com.order.application.service;

import com.order.domain.entity.Order;
import com.order.domain.service.OrderDomainService;
import com.order.port.inbound.CreateOrderUseCase;
import com.order.port.outbound.NotifyPort;
import com.order.port.outbound.OrderRepositoryPort;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
* 应用服务：只做流程编排，不写核心业务规则
* 依赖：领域服务 + 出站端口（抽象接口）
*/
@Service
@RequiredArgsConstructor
public class OrderApplicationService implements CreateOrderUseCase {

private final OrderDomainService orderDomainService;
private final OrderRepositoryPort orderRepositoryPort;
private final NotifyPort notifyPort;

@Override
@Transactional(rollbackFor = Exception.class)
public Order createOrder(Order order) {
// 1. 领域层执行业务规则
orderDomainService.createOrder(order);

// 2. 调用出站端口（保存订单，具体实现由适配器完成）
Order savedOrder = orderRepositoryPort.save(order);

// 3. 调用出站端口（发送通知）
notifyPort.sendNotify(savedOrder.getOrderId());

return savedOrder;
}
}

java
package com.order.adapter.inbound;

import com.order.domain.entity.Order;
import com.order.port.inbound.CreateOrderUseCase;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
@RequiredArgsConstructor
public classOrderController {

private final CreateOrderUseCase createOrderUseCase;

@PostMapping("/create")
public ResponseEntity<Order> createOrder(@RequestBody Order order) {
return ResponseEntity.ok(createOrderUseCase.createOrder(order));
}
}

java
package com.order.adapter.outbound;

import com.order.domain.entity.Order;
import com.order.port.outbound.OrderRepositoryPort;
import com.order.infra.mapper.OrderMapper;
import com.order.infra.po.OrderPO;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

/**
* DB 适配器：实现端口接口
* 领域层完全不知道DB是什么
*/
@Component
@RequiredArgsConstructor
public class OrderRepositoryAdapter implements OrderRepositoryPort {

private final OrderMapper orderMapper;

@Override
public Order save(Order order) {
// 领域实体 → 持久化对象
OrderPO orderPO = convert(order);
orderMapper.insert(orderPO);
return order;
}

private OrderPO convert(Order order) {
// 省略转换逻辑
OrderPO po = new OrderPO();
po.setOrderId(order.getOrderId());
po.setUserId(order.getUserId());
po.setAmount(order.getAmount());
return po;
}
}

java
package com.order.adapter.outbound;

import com.order.port.outbound.NotifyPort;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

/**
* 通知适配器：可随时替换为短信、邮件、MQ
* 领域/应用层完全无感
*/
@Component
@RequiredArgsConstructor
public class NotifyAdapter implements NotifyPort {
@Override
public void sendNotify(String orderId) {
System.out.println("【适配器】发送订单通知：" + orderId);
}
}

java
@MockBean
private OrderRepositoryPort orderRepositoryPort;

@MockBean
private NotifyPort notifyPort;