重构 Controller 的 7 个黄金法则
技术小馆专注AI与Java领域的前沿技术知识库 点击进入
重构 Controller 的 7 个黄金法则
你是否曾经面对过一个臃肿不堪的 Controller？方法堆积如山，业务逻辑混乱，测试困难，维护噩梦。当新需求来临时，你不得不在这个"巨无霸"中继续添加代码，让问题雪上加霜。一个优雅的 Controller 应该是轻量级的、职责单一的、易于测试和维护的。它就像一位优雅的舞者，动作简洁而有力，每个转身都恰到好处。
1. Controller 设计的核心原则
单一职责原则（SRP）
一个 Controller 应该只负责处理 HTTP 请求和响应，而不是承载业务逻辑。让我们看一个反例：
@RestController
@RequestMapping("/api/users")
public class UserController {
@PostMapping("/register")
public ResponseEntity<?> registerUser(@RequestBody UserRegistrationDto dto) {
// 验证邮箱格式
if (!isValidEmail(dto.getEmail())) {
return ResponseEntity.badRequest().body("Invalid email format");
}
// 检查密码强度
if (!isPasswordStrong(dto.getPassword())) {
return ResponseEntity.badRequest().body("Password too weak");
}
// 检查用户是否已存在
if (userRepository.existsByEmail(dto.getEmail())) {
return ResponseEntity.badRequest().body("User already exists");
}
// 加密密码
String encryptedPassword = passwordEncoder.encode(dto.getPassword());
// 创建用户
User user = new User();
user.setEmail(dto.getEmail());
user.setPassword(encryptedPassword);
user.setName(dto.getName());
// 保存用户
User savedUser = userRepository.save(user);
// 发送欢迎邮件
emailService.sendWelcomeEmail(savedUser.getEmail());
return ResponseEntity.ok(savedUser);
}
// 其他验证方法...
}
这个 Controller 违反了单一职责原则，包含了太多业务逻辑。重构后应该是这样：
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@PostMapping("/register")
public ResponseEntity<?> registerUser(@RequestBody UserRegistrationDto dto) {
try {
User user = userService.registerUser(dto);
return ResponseEntity.ok(user);
} catch (UserRegistrationException e) {
return ResponseEntity.badRequest().body(e.getMessage());
}
}
}
依赖注入与解耦
通过构造函数注入依赖，而不是直接实例化，这样便于测试和替换实现：
@Service
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
private final EmailService emailService;
private final UserValidator userValidator;
public UserService(UserRepository userRepository,
PasswordEncoder passwordEncoder,
EmailService emailService,
UserValidator userValidator) {
this.userRepository = userRepository;
this.passwordEncoder = passwordEncoder;
this.emailService = emailService;
this.userValidator = userValidator;
}
}
接口隔离原则
为不同的功能定义专门的接口，避免一个接口承担过多职责：
public interface UserRegistrationService {
User registerUser(UserRegistrationDto dto);
}
public interface UserQueryService {
User findById(Long id);
List<User> findAll();
User findByEmail(String email);
}
public interface UserUpdateService {
User updateUser(Long id, UserUpdateDto dto);
void deleteUser(Long id);
}
2. 代码结构优化策略
方法提取与重构
将长方法拆分为多个小方法，每个方法只做一件事：
@RestController
@RequestMapping("/api/orders")
public class OrderController {
@PostMapping
public ResponseEntity<?> createOrder(@RequestBody CreateOrderDto dto) {
// 验证请求
validateCreateOrderRequest(dto);
// 检查库存
checkInventoryAvailability(dto);
// 创建订单
Order order = createOrderFromDto(dto);
// 保存订单
Order savedOrder = orderService.save(order);
// 发送确认邮件
sendOrderConfirmation(savedOrder);
return ResponseEntity.ok(savedOrder);
}
private void validateCreateOrderRequest(CreateOrderDto dto) {
if (dto.getItems() == null || dto.getItems().isEmpty()) {
throw new InvalidOrderException("Order must contain at least one item");
}
// 其他验证逻辑...
}
private void checkInventoryAvailability(CreateOrderDto dto) {
for (OrderItemDto item : dto.getItems()) {
if (!inventoryService.isAvailable(item.getProductId(), item.getQuantity())) {
throw new InsufficientInventoryException("Insufficient inventory for product: " + item.getProductId());
}
}
}
private Order createOrderFromDto(CreateOrderDto dto) {
Order order = new Order();
order.setCustomerId(dto.getCustomerId());
order.setItems(dto.getItems().stream()
.map(this::createOrderItem)
.collect(Collectors.toList()));
order.setTotalAmount(calculateTotal(dto.getItems()));
return order;
}
}
参数验证与异常处理
使用统一的异常处理机制和参数验证：
@RestController
@RequestMapping("/api/products")
public class ProductController {
@PostMapping
public ResponseEntity<?> createProduct(@Valid @RequestBody CreateProductDto dto) {
Product product = productService.createProduct(dto);
return ResponseEntity.ok(product);
}
@PutMapping("/{id}")
public ResponseEntity<?> updateProduct(@PathVariable Long id,
@Valid @RequestBody UpdateProductDto dto) {
try {
Product product = productService.updateProduct(id, dto);
return ResponseEntity.ok(product);
} catch (ProductNotFoundException e) {
return ResponseEntity.notFound().build();
}
}
}
// 全局异常处理
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<?> handleValidationErrors(MethodArgumentNotValidException ex) {
List<String> errors = ex.getBindingResult()
.getFieldErrors()
.stream()
.map(FieldError::getDefaultMessage)
.collect(Collectors.toList());
return ResponseEntity.badRequest()
.body(new ErrorResponse("Validation failed", errors));
}
@ExceptionHandler(BusinessException.class)
public ResponseEntity<?> handleBusinessException(BusinessException ex) {
return ResponseEntity.badRequest()
.body(new ErrorResponse(ex.getMessage()));
}
}
响应格式标准化
定义统一的响应格式，提高 API 的一致性：
public class ApiResponse<T> {
private boolean success;
private String message;
private T data;
private long timestamp;
public static <T> ApiResponse<T> success(T data) {
ApiResponse<T> response = new ApiResponse<>();
response.setSuccess(true);
response.setData(data);
response.setTimestamp(System.currentTimeMillis());
return response;
}
public static <T> ApiResponse<T> error(String message) {
ApiResponse<T> response = new ApiResponse<>();
response.setSuccess(false);
response.setMessage(message);
response.setTimestamp(System.currentTimeMillis());
return response;
}
}
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping("/{id}")
public ResponseEntity<ApiResponse<User>> getUser(@PathVariable Long id) {
try {
User user = userService.findById(id);
return ResponseEntity.ok(ApiResponse.success(user));
} catch (UserNotFoundException e) {
return ResponseEntity.ok(ApiResponse.error("User not found"));
}
}
}
3. 业务逻辑分离技巧
Service 层职责划分
将业务逻辑从 Controller 中提取到 Service 层：
@Service
@Transactional
public class OrderService {
private final OrderRepository orderRepository;
private final ProductService productService;
private final CustomerService customerService;
private final PaymentService paymentService;
public Order createOrder(CreateOrderDto dto) {
// 验证客户
Customer customer = customerService.findById(dto.getCustomerId());
// 验证产品
List<Product> products = validateProducts(dto.getItems());
// 计算价格
BigDecimal totalAmount = calculateTotalAmount(dto.getItems());
// 创建订单
Order order = new Order();
order.setCustomer(customer);
order.setItems(createOrderItems(dto.getItems()));
order.setTotalAmount(totalAmount);
order.setStatus(OrderStatus.PENDING);
// 保存订单
Order savedOrder = orderRepository.save(order);
// 处理支付
paymentService.processPayment(savedOrder);
return savedOrder;
}
private List<Product> validateProducts(List<OrderItemDto> items) {
return items.stream()
.map(item -> productService.findById(item.getProductId()))
.collect(Collectors.toList());
}
private BigDecimal calculateTotalAmount(List<OrderItemDto> items) {
return items.stream()
.map(item -> {
Product product = productService.findById(item.getProductId());
return product.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()));
})
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
}
数据转换与映射
使用 DTO 和 Mapper 来处理数据传输：
public class UserMapper {
public static UserDto toDto(User user) {
UserDto dto = new UserDto();
dto.setId(user.getId());
dto.setEmail(user.getEmail());
dto.setName(user.getName());
dto.setCreatedAt(user.getCreatedAt());
return dto;
}
public static User toEntity(CreateUserDto dto) {
User user = new User();
user.setEmail(dto.getEmail());
user.setName(dto.getName());
user.setCreatedAt(LocalDateTime.now());
return user;
}
public static List<UserDto> toDtoList(List<User> users) {
return users.stream()
.map(UserMapper::toDto)
.collect(Collectors.toList());
}
}
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping
public ResponseEntity<ApiResponse<List<UserDto>>> getAllUsers() {
List<User> users = userService.findAll();
List<UserDto> userDtos = UserMapper.toDtoList(users);
return ResponseEntity.ok(ApiResponse.success(userDtos));
}
}
事务管理策略
在 Service 层使用事务注解，确保数据一致性：
@Service
@Transactional
public class OrderService {
@Transactional(readOnly = true)
public Order findById(Long id) {
return orderRepository.findById(id)
.orElseThrow(() -> new OrderNotFoundException("Order not found: " + id));
}
@Transactional
public Order createOrder(CreateOrderDto dto) {
// 创建订单逻辑
Order order = buildOrder(dto);
// 保存订单
Order savedOrder = orderRepository.save(order);
// 更新库存
updateInventory(dto.getItems());
// 发送通知
notificationService.sendOrderCreatedNotification(savedOrder);
return savedOrder;
}
@Transactional
public void cancelOrder(Long orderId) {
Order order = findById(orderId);
if (order.getStatus() != OrderStatus.PENDING) {
throw new InvalidOrderStatusException("Cannot cancel order in status: " + order.getStatus());
}
order.setStatus(OrderStatus.CANCELLED);
orderRepository.save(order);
// 恢复库存
restoreInventory(order.getItems());
// 发送取消通知
notificationService.sendOrderCancelledNotification(order);
}
}
4. 测试友好性设计
单元测试编写
为 Controller 编写单元测试，确保每个方法都能正确工作：
@ExtendWith(MockitoExtension.class)
class UserControllerTest {
@Mock
private UserService userService;
@Mock
private UserValidator userValidator;
@InjectMocks
private UserController userController;
@Test
void createUser_WithValidData_ReturnsCreatedUser() {
// Arrange
CreateUserDto dto = new CreateUserDto();
dto.setEmail("test@example.com");
dto.setName("Test User");
User user = new User();
user.setId(1L);
user.setEmail(dto.getEmail());
user.setName(dto.getName());
when(userService.createUser(dto)).thenReturn(user);
// Act
ResponseEntity<ApiResponse<User>> response = userController.createUser(dto);
// Assert
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody().isSuccess()).isTrue();
assertThat(response.getBody().getData().getEmail()).isEqualTo(dto.getEmail());
verify(userService).createUser(dto);
}
@Test
void createUser_WithInvalidData_ReturnsBadRequest() {
// Arrange
CreateUserDto dto = new CreateUserDto();
dto.setEmail("invalid-email");
when(userService.createUser(dto))
.thenThrow(new ValidationException("Invalid email format"));
// Act
ResponseEntity<ApiResponse<User>> response = userController.createUser(dto);
// Assert
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody().isSuccess()).isFalse();
assertThat(response.getBody().getMessage()).contains("Invalid email format");
}
}
Mock 策略选择
选择合适的 Mock 策略来隔离依赖：
@WebMvcTest(UserController.class)
class UserControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserService userService;
@Test
void getUser_WithValidId_ReturnsUser() throws Exception {
// Arrange
User user = new User();
user.setId(1L);
user.setEmail("test@example.com");
user.setName("Test User");
when(userService.findById(1L)).thenReturn(user);
// Act & Assert
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.success").value(true))
.andExpect(jsonPath("$.data.email").value("test@example.com"))
.andExpect(jsonPath("$.data.name").value("Test User"));
}
@Test
void getUser_WithInvalidId_ReturnsNotFound() throws Exception {
// Arrange
when(userService.findById(999L))
.thenThrow(new UserNotFoundException("User not found"));
// Act & Assert
mockMvc.perform(get("/api/users/999"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.success").value(false))
.andExpect(jsonPath("$.message").value("User not found"));
}
}
集成测试设计
设计端到端的集成测试，验证整个流程：
@SpringBootTest
@AutoConfigureTestDatabase
@Transactional
class UserControllerIntegrationTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private UserRepository userRepository;
@Test
void createAndRetrieveUser_CompleteFlow_Success() {
// Arrange
CreateUserDto createDto = new CreateUserDto();
createDto.setEmail("integration@example.com");
createDto.setName("Integration User");
// Act - Create user
ResponseEntity<ApiResponse> createResponse = restTemplate.postForEntity(
"/api/users", createDto, ApiResponse.class);
// Assert - User created
assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(createResponse.getBody().isSuccess()).isTrue();
// Act - Retrieve user
ResponseEntity<ApiResponse> getResponse = restTemplate.getForEntity(
"/api/users/1", ApiResponse.class);
// Assert - User retrieved
assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(getResponse.getBody().isSuccess()).isTrue();
// Verify database
User savedUser = userRepository.findById(1L).orElse(null);
assertThat(savedUser).isNotNull();
assertThat(savedUser.getEmail()).isEqualTo("integration@example.com");
}
}
5. 性能优化与缓存
响应时间优化
通过异步处理和缓存来提升响应速度：
@RestController
@RequestMapping("/api/products")
public class ProductController {
@GetMapping("/{id}")
@Cacheable(value = "products", key = "#id")
public ResponseEntity<ApiResponse<Product>> getProduct(@PathVariable Long id) {
Product product = productService.findById(id);
return ResponseEntity.ok(ApiResponse.success(product));
}
@GetMapping("/search")
public ResponseEntity<ApiResponse<List<Product>>> searchProducts(
@RequestParam String keyword,
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "20") int size) {
Pageable pageable = PageRequest.of(page, size);
Page<Product> products = productService.searchByKeyword(keyword, pageable);
return ResponseEntity.ok(ApiResponse.success(products.getContent()));
}
@PostMapping("/{id}/view")
@Async
public void incrementViewCount(@PathVariable Long id) {
productService.incrementViewCount(id);
}
}
@Service
public class ProductService {
@Cacheable(value = "products", key = "#id")
public Product findById(Long id) {
return productRepository.findById(id)
.orElseThrow(() -> new ProductNotFoundException("Product not found: " + id));
}
@CacheEvict(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
return productRepository.save(product);
}
@Async
public void incrementViewCount(Long productId) {
productRepository.incrementViewCount(productId);
}
}
缓存策略实施
实现多层次的缓存策略：
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public CacheManager cacheManager() {
SimpleCacheManager cacheManager = new SimpleCacheManager();
ConcurrentMapCache productsCache = new ConcurrentMapCache("products");
ConcurrentMapCache usersCache = new ConcurrentMapCache("users");
ConcurrentMapCache ordersCache = new ConcurrentMapCache("orders");
cacheManager.setCaches(Arrays.asList(productsCache, usersCache, ordersCache));
return cacheManager;
}
}
@Service
public class ProductService {
@Cacheable(value = "products", key = "#id", unless = "#result == null")
public Product findById(Long id) {
return productRepository.findById(id).orElse(null);
}
@Cacheable(value = "products", key = "'search_' + #keyword + '_' + #pageable.pageNumber + '_' + #pageable.pageSize")
public Page<Product> searchByKeyword(String keyword, Pageable pageable) {
return productRepository.findByNameContainingIgnoreCase(keyword, pageable);
}
@CacheEvict(value = "products", allEntries = true)
public void clearAllCaches() {
// 清除所有产品相关缓存
}
}
异步处理机制
使用异步处理来处理耗时操作：
@RestController
@RequestMapping("/api/orders")
public class OrderController {
@PostMapping("/{id}/process")
public ResponseEntity<ApiResponse<String>> processOrder(@PathVariable Long id) {
// 立即返回处理中的状态
orderService.processOrderAsync(id);
return ResponseEntity.ok(ApiResponse.success("Order processing started"));
}
@GetMapping("/{id}/status")
public ResponseEntity<ApiResponse<OrderStatus>> getOrderStatus(@PathVariable Long id) {
OrderStatus status = orderService.getOrderStatus(id);
return ResponseEntity.ok(ApiResponse.success(status));
}
}
@Service
public class OrderService {
@Async
public void processOrderAsync(Long orderId) {
try {
// 模拟耗时处理
Thread.sleep(5000);
// 更新订单状态
Order order = findById(orderId);
order.setStatus(OrderStatus.PROCESSING);
orderRepository.save(order);
// 继续处理...
processPayment(order);
updateInventory(order);
sendNotifications(order);
order.setStatus(OrderStatus.COMPLETED);
orderRepository.save(order);
} catch (Exception e) {
// 处理异常，更新订单状态为失败
Order order = findById(orderId);
order.setStatus(OrderStatus.FAILED);
orderRepository.save(order);
log.error("Failed to process order: " + orderId, e);
}
}
}
6. 代码规范与文档
命名规范制定
建立清晰的命名约定：
// Controller 命名：以 Controller 结尾，使用复数形式
@RestController
@RequestMapping("/api/users")
public class UserController { }
@RestController
@RequestMapping("/api/orders")
public class OrderController { }
// 方法命名：使用动词开头，清晰表达意图
@GetMapping("/{id}")
public ResponseEntity<ApiResponse<User>> getUserById(@PathVariable Long id) { }
@PostMapping
public ResponseEntity<ApiResponse<User>> createNewUser(@RequestBody CreateUserDto dto) { }
@PutMapping("/{id}")
public ResponseEntity<ApiResponse<User>> updateExistingUser(@PathVariable Long id,
@RequestBody UpdateUserDto dto) { }
@DeleteMapping("/{id}")
public ResponseEntity<ApiResponse<Void>> removeUser(@PathVariable Long id) { }
// DTO 命名：以 Dto 结尾，使用描述性名称
public class CreateUserDto { }
public class UpdateUserDto { }
public class UserResponseDto { }
// 异常命名：以 Exception 结尾
public class UserNotFoundException extends RuntimeException { }
public class InvalidUserDataException extends RuntimeException { }
API 文档生成
使用 Swagger 或 OpenAPI 生成 API 文档：
@RestController
@RequestMapping("/api/users")
@Tag(name = "User Management", description = "APIs for managing users")
public class UserController {
@Operation(summary = "Create a new user", description = "Creates a new user with the provided information")
@ApiResponses(value = {
@ApiResponse(responseCode = "200", description = "User created successfully",
content = @Content(schema = @Schema(implementation = User.class))),
@ApiResponse(responseCode = "400", description = "Invalid input data"),
@ApiResponse(responseCode = "409", description = "User already exists")
})
@PostMapping
public ResponseEntity<ApiResponse<User>> createUser(
@Parameter(description = "User information", required = true)
@Valid @RequestBody CreateUserDto dto) {
User user = userService.createUser(dto);
return ResponseEntity.ok(ApiResponse.success(user));
}
@Operation(summary = "Get user by ID", description = "Retrieves a user by their unique identifier")
@ApiResponses(value = {
@ApiResponse(responseCode = "200", description = "User found successfully"),
@ApiResponse(responseCode = "404", description = "User not found")
})
@GetMapping("/{id}")
public ResponseEntity<ApiResponse<User>> getUserById(
@Parameter(description = "User ID", required = true)
@PathVariable Long id) {
User user = userService.findById(id);
return ResponseEntity.ok(ApiResponse.success(user));
}
}
代码审查要点
建立代码审查检查清单：
// 代码审查检查清单示例
/*
□ Controller 是否只负责 HTTP 请求处理？
□ 业务逻辑是否已提取到 Service 层？
□ 是否使用了适当的 HTTP 状态码？
□ 异常处理是否统一？
□ 参数验证是否完整？
□ 响应格式是否一致？
□ 是否添加了适当的日志？
□ 方法是否过于复杂（超过 20 行）？
□ 是否遵循了命名约定？
□ 是否添加了必要的注释？
□ 是否考虑了性能问题？
□ 是否添加了单元测试？
*/
@RestController
@RequestMapping("/api/users")
@Slf4j
public class UserController {
@PostMapping
public ResponseEntity<ApiResponse<User>> createUser(@Valid @RequestBody CreateUserDto dto) {
log.info("Creating new user with email: {}", dto.getEmail());
try {
User user = userService.createUser(dto);
log.info("User created successfully with ID: {}", user.getId());
return ResponseEntity.ok(ApiResponse.success(user));
} catch (UserAlreadyExistsException e) {
log.warn("Failed to create user: {}", e.getMessage());
return ResponseEntity.ok(ApiResponse.error(e.getMessage()));
} catch (Exception e) {
log.error("Unexpected error while creating user", e);
return ResponseEntity.ok(ApiResponse.error("Internal server error"));
}
}
}
7. 重构实战案例
遗留代码分析
分析一个典型的"巨无霸" Controller：
// 重构前的混乱 Controller
@RestController
@RequestMapping("/api/orders")
public class OrderController {
@Autowired
private OrderRepository orderRepository;
@Autowired
private ProductRepository productRepository;
@Autowired
private UserRepository userRepository;
@Autowired
private EmailService emailService;
@Autowired
private PaymentService paymentService;
@PostMapping
public ResponseEntity<?> createOrder(@RequestBody Map<String, Object> request) {
try {
// 验证用户
Long userId = Long.valueOf(request.get("userId").toString());
User user = userRepository.findById(userId).orElse(null);
if (user == null) {
return ResponseEntity.badRequest().body("User not found");
}
// 验证产品
List<Map<String, Object>> items = (List<Map<String, Object>>) request.get("items");
List<OrderItem> orderItems = new ArrayList<>();
BigDecimal totalAmount = BigDecimal.ZERO;
for (Map<String, Object> item : items) {
Long productId = Long.valueOf(item.get("productId").toString());
Integer quantity = Integer.valueOf(item.get("quantity").toString());
Product product = productRepository.findById(productId).orElse(null);
if (product == null) {
return ResponseEntity.badRequest().body("Product not found: " + productId);
}
if (product.getStock() < quantity) {
return ResponseEntity.badRequest().body("Insufficient stock for product: " + productId);
}
OrderItem orderItem = new OrderItem();
orderItem.setProduct(product);
orderItem.setQuantity(quantity);
orderItem.setPrice(product.getPrice());
orderItems.add(orderItem);
totalAmount = totalAmount.add(product.getPrice().multiply(BigDecimal.valueOf(quantity)));
// 更新库存
product.setStock(product.getStock() - quantity);
productRepository.save(product);
}
// 创建订单
Order order = new Order();
order.setUser(user);
order.setItems(orderItems);
order.setTotalAmount(totalAmount);
order.setStatus("PENDING");
order.setCreatedAt(new Date());
Order savedOrder = orderRepository.save(order);
// 处理支付
String paymentResult = paymentService.processPayment(savedOrder);
if (!"SUCCESS".equals(paymentResult)) {
// 回滚库存
for (OrderItem item : orderItems) {
Product product = item.getProduct();
product.setStock(product.getStock() + item.getQuantity());
productRepository.save(product);
}
orderRepository.delete(savedOrder);
return ResponseEntity.badRequest().body("Payment failed");
}
// 发送确认邮件
emailService.sendOrderConfirmation(user.getEmail(), savedOrder);
return ResponseEntity.ok(savedOrder);
} catch (Exception e) {
return ResponseEntity.status(500).body("Internal server error: " + e.getMessage());
}
}
// 其他混乱的方法...
}
重构计划制定
制定分步骤的重构计划：
// 第一步：提取 DTO 和验证
public class CreateOrderDto {
@NotNull
private Long userId;
@NotEmpty
@Valid
private List<OrderItemDto> items;
// getters and setters
}
public class OrderItemDto {
@NotNull
private Long productId;
@Min
private Integer quantity;
// getters and setters
}
// 第二步：创建专门的 Service
@Service
@Transactional
public class OrderService {
private final OrderRepository orderRepository;
private final ProductService productService;
private final UserService userService;
private final PaymentService paymentService;
private final EmailService emailService;
public Order createOrder(CreateOrderDto dto) {
// 验证用户
User user = userService.findById(dto.getUserId());
// 验证产品并创建订单项
List<OrderItem> orderItems = createOrderItems(dto.getItems());
// 计算总金额
BigDecimal totalAmount = calculateTotalAmount(orderItems);
// 创建订单
Order order = buildOrder(user, orderItems, totalAmount);
// 保存订单
Order savedOrder = orderRepository.save(order);
// 处理支付
processPayment(savedOrder);
// 发送确认邮件
emailService.sendOrderConfirmation(user.getEmail(), savedOrder);
return savedOrder;
}
private List<OrderItem> createOrderItems(List<OrderItemDto> itemDtos) {
return itemDtos.stream()
.map(this::createOrderItem)
.collect(Collectors.toList());
}
private OrderItem createOrderItem(OrderItemDto dto) {
Product product = productService.findById(dto.getProductId());
productService.checkStockAvailability(product, dto.getQuantity());
OrderItem item = new OrderItem();
item.setProduct(product);
item.setQuantity(dto.getQuantity());
item.setPrice(product.getPrice());
return item;
}
}
// 第三步：重构 Controller
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderService orderService;
public OrderController(OrderService orderService) {
this.orderService = orderService;
}
@PostMapping
public ResponseEntity<ApiResponse<Order>> createOrder(@Valid @RequestBody CreateOrderDto dto) {
try {
Order order = orderService.createOrder(dto);
return ResponseEntity.ok(ApiResponse.success(order));
} catch (BusinessException e) {
return ResponseEntity.ok(ApiResponse.error(e.getMessage()));
}
}
}
重构后效果评估
评估重构的效果和改进：
// 重构后的效果对比
/*
重构前的问题：
- Controller 方法超过 80 行
- 混合了业务逻辑、数据访问、验证等职责
- 异常处理不统一
- 难以测试和维护
- 代码重复严重
重构后的改进：
- Controller 方法只有 10 行左右
- 职责分离清晰
- 统一的异常处理
- 易于测试和维护
- 代码复用性高
- 符合 SOLID 原则
*/
// 重构后的测试覆盖
@ExtendWith(MockitoExtension.class)
class OrderControllerTest {
@Mock
private OrderService orderService;
@InjectMocks
private OrderController orderController;
@Test
void createOrder_WithValidData_ReturnsSuccess() {
// Arrange
CreateOrderDto dto = new CreateOrderDto();
dto.setUserId(1L);
dto.setItems(Arrays.asList(new OrderItemDto(1L, 2)));
Order order = new Order();
order.setId(1L);
when(orderService.createOrder(dto)).thenReturn(order);
// Act
ResponseEntity<ApiResponse<Order>> response = orderController.createOrder(dto);
// Assert
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody().isSuccess()).isTrue();
assertThat(response.getBody().getData().getId()).isEqualTo(1L);
}
}
// 重构后的性能指标
/*
- 响应时间：从平均 500ms 降低到 200ms
- 代码行数：从 200+ 行减少到 50 行
- 测试覆盖率：从 30% 提升到 85%
- 维护成本：降低 60%
- 代码质量评分：从 C 提升到 A
*/
查看8道真题和解析
投递字节跳动等公司10个岗位