Spring Web on Servlet Stack 深度解析 🚀

概述

Spring Web on Servlet Stack 是 Spring Framework 中专门用于构建传统 Servlet 容器 Web 应用程序的核心模块。它基于成熟的 Servlet API，为开发者提供了一套完整的 Web 开发解决方案。

NOTE

Servlet Stack 是相对于 Reactive Stack 而言的概念。Servlet Stack 基于传统的阻塞 I/O 模型，而 Reactive Stack 则基于非阻塞的响应式编程模型。

技术背景与设计哲学 🎯

为什么需要 Spring Web on Servlet Stack？

在 Spring Web on Servlet Stack 出现之前，Java Web 开发面临着诸多痛点：

传统 Servlet 开发方式Spring MVC 方式

java

// 传统的 Servlet 开发方式 - 繁琐且难以维护
@WebServlet("/user")
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        // 手动处理参数解析
        String id = request.getParameter("id");
        if (id == null || id.isEmpty()) {
            response.setStatus(400);
            return;
        }
        
        // 手动处理业务逻辑
        UserService userService = new UserService();
        User user = userService.findById(Long.parseLong(id));
        
        // 手动处理响应格式化
        response.setContentType("application/json");
        ObjectMapper mapper = new ObjectMapper();
        response.getWriter().write(mapper.writeValueAsString(user));
    }
}

kotlin

// Spring MVC 方式 - 简洁且易于维护
@RestController
@RequestMapping("/api/users")
class UserController(
    private val userService: UserService
) {
    @GetMapping("/{id}")
    fun getUser(@PathVariable id: Long): User { 
        return userService.findById(id) 
    } 
}

核心设计哲学

Spring Web on Servlet Stack 的设计哲学可以概括为以下几个方面：

约定优于配置：通过注解和约定减少样板代码
依赖注入：松耦合的组件设计
面向切面编程：横切关注点的统一处理
模块化架构：清晰的职责分离

核心架构组件 🏗️

Spring Web on Servlet Stack 主要包含以下核心组件：

1. Spring MVC

Spring MVC 是整个 Servlet Stack 的核心，采用了经典的 MVC（Model-View-Controller）设计模式。

TIP

MVC 模式的核心思想是将应用程序分为三个相互独立但又相互协作的组件：

Model：数据和业务逻辑
View：用户界面
Controller：处理用户输入和协调 Model 与 View

kotlin

// 一个完整的 Spring MVC 示例
@RestController
@RequestMapping("/api/products")
@Validated
class ProductController(
    private val productService: ProductService
) {
    
    @GetMapping
    fun getAllProducts(
        @RequestParam(defaultValue = "0") page: Int,
        @RequestParam(defaultValue = "10") size: Int
    ): Page<Product> {
        return productService.findAll(PageRequest.of(page, size)) 
    }
    
    @PostMapping
    fun createProduct(@Valid @RequestBody product: Product): Product {
        return productService.save(product) 
    }
    
    @GetMapping("/{id}")
    fun getProduct(@PathVariable id: Long): Product {
        return productService.findById(id) 
            ?: throw ProductNotFoundException("Product not found with id: $id") 
    }
}

2. REST Clients

Spring 提供了多种 REST 客户端工具，用于与外部服务进行通信：

RestTemplate (传统方式)WebClient (推荐方式)

kotlin

@Service
class ExternalApiService {
    
    private val restTemplate = RestTemplate()
    
    fun fetchUserData(userId: Long): UserDto? {
        val url = "https://api.example.com/users/$userId"
        return try {
            restTemplate.getForObject(url, UserDto::class.java) 
        } catch (e: RestClientException) {
            logger.error("Failed to fetch user data", e) 
            null
        }
    }
}

kotlin

@Service
class ExternalApiService {
    
    private val webClient = WebClient.builder()
        .baseUrl("https://api.example.com")
        .build()
    
    fun fetchUserData(userId: Long): Mono<UserDto> {
        return webClient.get() 
            .uri("/users/{id}", userId) 
            .retrieve() 
            .bodyToMono(UserDto::class.java) 
            .onErrorResume { error ->
                logger.error("Failed to fetch user data", error)
                Mono.empty()
            }
    }
}

3. Testing

Spring 提供了强大的测试支持，让 Web 应用程序的测试变得简单高效：

kotlin

@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@TestPropertySource(locations = ["classpath:application-test.properties"])
class ProductControllerIntegrationTest {
    
    @Autowired
    private lateinit var mockMvc: MockMvc
    
    @Autowired
    private lateinit var objectMapper: ObjectMapper
    
    @Test
    fun `should create product successfully`() {
        val product = Product(name = "Test Product", price = BigDecimal("99.99"))
        
        mockMvc.perform(
            post("/api/products") 
                .contentType(MediaType.APPLICATION_JSON) 
                .content(objectMapper.writeValueAsString(product)) 
        )
        .andExpect(status().isOk) 
        .andExpect(jsonPath("$.name").value("Test Product")) 
        .andExpect(jsonPath("$.price").value(99.99)) 
    }
}

4. WebSockets

WebSocket 支持实现了服务器与客户端之间的双向实时通信：

kotlin

@Configuration
@EnableWebSocket
class WebSocketConfig : WebSocketConfigurer {
    
    override fun registerWebSocketHandlers(registry: WebSocketHandlerRegistry) {
        registry.addHandler(ChatWebSocketHandler(), "/chat") 
            .setAllowedOrigins("*") 
    }
}

@Component
class ChatWebSocketHandler : TextWebSocketHandler() {
    
    private val sessions = mutableSetOf<WebSocketSession>()
    
    override fun afterConnectionEstablished(session: WebSocketSession) {
        sessions.add(session) 
        logger.info("WebSocket connection established: ${session.id}")
    }
    
    override fun handleTextMessage(session: WebSocketSession, message: TextMessage) {
        // 广播消息给所有连接的客户端
        sessions.forEach { s ->
            if (s.isOpen) {
                s.sendMessage(message) 
            }
        }
    }
    
    override fun afterConnectionClosed(session: WebSocketSession, status: CloseStatus) {
        sessions.remove(session) 
        logger.info("WebSocket connection closed: ${session.id}")
    }
}

实际业务场景应用 💼

场景一：电商系统的订单管理

kotlin

@RestController
@RequestMapping("/api/orders")
@Transactional
class OrderController(
    private val orderService: OrderService,
    private val paymentService: PaymentService,
    private val inventoryService: InventoryService
) {
    
    @PostMapping
    fun createOrder(@Valid @RequestBody orderRequest: OrderRequest): ResponseEntity<OrderResponse> {
        return try {
            // 1. 验证库存
            inventoryService.validateStock(orderRequest.items) 
            
            // 2. 创建订单
            val order = orderService.createOrder(orderRequest) 
            
            // 3. 处理支付
            val payment = paymentService.processPayment(order) 
            
            ResponseEntity.ok(OrderResponse.from(order, payment))
        } catch (e: InsufficientStockException) {
            ResponseEntity.badRequest().body(ErrorResponse("库存不足")) 
        } catch (e: PaymentException) {
            ResponseEntity.badRequest().body(ErrorResponse("支付失败")) 
        }
    }
}

场景二：实时通知系统

kotlin

@Controller
class NotificationController(
    private val notificationService: NotificationService
) {
    
    @MessageMapping("/notification.send")
    @SendTo("/topic/notifications")
    fun sendNotification(notification: NotificationMessage): NotificationMessage {
        // 处理通知逻辑
        notificationService.processNotification(notification) 
        return notification
    }
}

@Configuration
@EnableWebSocketMessageBroker
class WebSocketMessageConfig : WebSocketMessageBrokerConfigurer {
    
    override fun configureMessageBroker(config: MessageBrokerRegistry) {
        config.enableSimpleBroker("/topic") 
        config.setApplicationDestinationPrefixes("/app") 
    }
    
    override fun registerStompEndpoints(registry: StompEndpointRegistry) {
        registry.addEndpoint("/ws").withSockJS() 
    }
}

与 Reactive Stack 的对比 ⚖️

特性	Servlet Stack	Reactive Stack
编程模型	阻塞式，一个请求一个线程	非阻塞式，事件驱动
性能特点	适合 CPU 密集型任务	适合 I/O 密集型任务
学习曲线	相对平缓，概念直观	较陡峭，需要理解响应式编程
生态成熟度	非常成熟，大量第三方支持	相对较新，生态在快速发展
适用场景	传统企业应用，CRUD 操作	高并发、实时数据处理

IMPORTANT

选择 Servlet Stack 还是 Reactive Stack 应该基于具体的业务需求和团队技术栈。对于大多数传统企业应用，Servlet Stack 仍然是最佳选择。

最佳实践建议 ✅

1. 控制器设计原则

kotlin

@RestController
@RequestMapping("/api/users")
@Validated
class UserController(
    private val userService: UserService
) {
    
    // ✅ 好的实践：职责单一，参数验证
    @GetMapping("/{id}")
    fun getUser(@PathVariable @Min(1) id: Long): ResponseEntity<UserDto> {
        val user = userService.findById(id) 
        return ResponseEntity.ok(UserDto.from(user))
    }
    
    // ❌ 避免：在控制器中处理复杂业务逻辑
    @PostMapping
    fun createUser(@Valid @RequestBody request: CreateUserRequest): ResponseEntity<UserDto> {
        // 不要在这里写复杂的业务逻辑
        val user = userService.createUser(request) 
        return ResponseEntity.status(HttpStatus.CREATED).body(UserDto.from(user))
    }
}

2. 异常处理

kotlin

@ControllerAdvice
class GlobalExceptionHandler {
    
    @ExceptionHandler(ValidationException::class)
    fun handleValidationException(e: ValidationException): ResponseEntity<ErrorResponse> {
        return ResponseEntity.badRequest() 
            .body(ErrorResponse("参数验证失败", e.message))
    }
    
    @ExceptionHandler(ResourceNotFoundException::class)
    fun handleResourceNotFound(e: ResourceNotFoundException): ResponseEntity<ErrorResponse> {
        return ResponseEntity.notFound() 
            .build()
    }
}

3. 配置管理

完整的 Spring Boot 配置示例

kotlin

@Configuration
@EnableWebMvc
@EnableTransactionManagement
class WebConfig : WebMvcConfigurer {
    
    override fun addCorsMappings(registry: CorsRegistry) {
        registry.addMapping("/api/**") 
            .allowedOrigins("http://localhost:3000")
            .allowedMethods("GET", "POST", "PUT", "DELETE")
            .allowCredentials(true)
    }
    
    override fun addInterceptors(registry: InterceptorRegistry) {
        registry.addInterceptor(LoggingInterceptor()) 
            .addPathPatterns("/api/**")
    }
    
    @Bean
    fun restTemplate(): RestTemplate {
        return RestTemplateBuilder() 
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .build()
    }
}

总结 🎉

Spring Web on Servlet Stack 为 Java/Kotlin 开发者提供了一个成熟、稳定且功能丰富的 Web 开发框架。它通过以下方式解决了传统 Web 开发的痛点：

简化开发：通过注解和约定减少样板代码
提高可维护性：清晰的架构分层和依赖注入
增强测试能力：完善的测试支持和工具
扩展性强：模块化设计，易于扩展和定制

TIP

对于初学者，建议从 Spring MVC 开始学习，掌握基本的 Web 开发概念后，再逐步探索其他高级特性如 WebSocket、REST Clients 等。

无论是构建传统的企业级应用，还是现代的微服务架构，Spring Web on Servlet Stack 都能提供强大而灵活的解决方案。它不仅是技术工具，更是一套完整的开发哲学和最佳实践的体现。

依赖注入

注解配置

Java

语言参考

ataspectj

declarative

mvc-servlet

mvc-controller

ann-methods

mvc-config

stomp

controller

ann-methods

ctx-management

hamcrest

assertj

htmlunit

integration-spring

Spring Web on Servlet Stack 深度解析 🚀

概述

技术背景与设计哲学 🎯

为什么需要 Spring Web on Servlet Stack？

核心设计哲学

核心架构组件 🏗️

1. Spring MVC

2. REST Clients

3. Testing

4. WebSockets

实际业务场景应用 💼

场景一：电商系统的订单管理

场景二：实时通知系统

与 Reactive Stack 的对比 ⚖️

最佳实践建议 ✅

1. 控制器设计原则

2. 异常处理

3. 配置管理

总结 🎉

ann-methods

ann-methods

Spring Web on Servlet Stack 深度解析 🚀 ​

概述 ​

技术背景与设计哲学 🎯 ​

为什么需要 Spring Web on Servlet Stack？ ​

核心设计哲学 ​

核心架构组件 🏗️ ​

1. Spring MVC ​

2. REST Clients ​

3. Testing ​

4. WebSockets ​

实际业务场景应用 💼 ​

场景一：电商系统的订单管理 ​

场景二：实时通知系统 ​

与 Reactive Stack 的对比 ⚖️ ​

最佳实践建议 ✅ ​

1. 控制器设计原则 ​

2. 异常处理 ​

3. 配置管理 ​

总结 🎉 ​

Spring Web on Servlet Stack 深度解析 🚀

概述

技术背景与设计哲学 🎯

为什么需要 Spring Web on Servlet Stack？

核心设计哲学

核心架构组件 🏗️

1. Spring MVC

2. REST Clients

3. Testing

4. WebSockets

实际业务场景应用 💼

场景一：电商系统的订单管理

场景二：实时通知系统

与 Reactive Stack 的对比 ⚖️

最佳实践建议 ✅

1. 控制器设计原则

2. 异常处理

3. 配置管理

总结 🎉