服务端开发

Appearance

Spring MVC DispatcherServlet 深度解析 🚀 ​

什么是 DispatcherServlet？为什么需要它？ ​

想象一下，你正在经营一家繁忙的餐厅。如果每个顾客都直接找厨师点菜，厨房会乱成一团糟！这时候你需要一个前台接待员来统一接待顾客、分配订单、协调各个部门。

在 Spring MVC 中，DispatcherServlet 就是这个"前台接待员"！它是整个 Web 应用的前端控制器（Front Controller），负责接收所有的 HTTP 请求，然后将这些请求分发给合适的处理器。

IMPORTANT

DispatcherServlet 是 Spring MVC 框架的核心组件，它实现了前端控制器模式，为所有请求提供统一的处理算法，同时将具体的业务逻辑委托给可配置的组件来完成。

前端控制器模式的设计哲学 🎯 ​

没有 DispatcherServlet 会怎样？ ​

让我们先看看传统的 Servlet 开发方式：

kotlin
// 用户相关的Servlet
class UserServlet : HttpServlet() {
    override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) {
        // 处理用户相关请求
        val action = req.getParameter("action") 
        when (action) { 
            "list" -> listUsers(req, resp) 
            "detail" -> getUserDetail(req, resp) 
            else -> resp.sendError(404) 
        } 
    }
}

// 订单相关的Servlet
class OrderServlet : HttpServlet() {
    override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) {
        // 又要重复相同的路由逻辑...
        val action = req.getParameter("action") 
        // 重复的异常处理、权限检查等...
    }
}
kotlin
// 统一的前端控制器
@RestController
@RequestMapping("/api/users")
class UserController {
    
    @GetMapping
    fun listUsers(): List<User> { 
        // 专注于业务逻辑，无需关心请求路由
        return userService.findAll() 
    } 
    
    @GetMapping("/{id}") 
    fun getUserDetail(@PathVariable id: Long): User { 
        return userService.findById(id) 
    } 
}

DispatcherServlet 解决的核心问题 ​

TIP

这种设计让我们可以：

  • 统一处理：所有请求都经过同一个入口点
  • 灵活配置：通过可配置的组件处理不同类型的请求
  • 关注分离：业务逻辑与请求处理逻辑分离
  • 易于扩展：添加新功能无需修改核心流程

DispatcherServlet 的配置方式 ⚙️ ​

方式一：Java 配置（推荐） ​

kotlin
class MyWebApplicationInitializer : WebApplicationInitializer {

    override fun onStartup(servletContext: ServletContext) {
        
        // 1. 创建 Spring Web 应用上下文
        val context = AnnotationConfigWebApplicationContext()
        context.register(AppConfig::class.java) 

        // 2. 创建并注册 DispatcherServlet
        val servlet = DispatcherServlet(context)
        val registration = servletContext.addServlet("app", servlet)
        
        // 3. 配置启动参数
        registration.setLoadOnStartup(1) // 应用启动时立即加载
        registration.addMapping("/app/*") // 处理 /app/* 路径的请求
    }
}

配置说明

  • setLoadOnStartup(1)：确保 DispatcherServlet 在应用启动时就被初始化，而不是等到第一个请求到达
  • addMapping("/app/*")：定义 URL 映射模式，所有以 /app/ 开头的请求都会被这个 DispatcherServlet 处理

方式二：继承抽象类（更简洁） ​

kotlin
class WebAppInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {

    // 根应用上下文配置（通常包含服务层、数据层等）
    override fun getRootConfigClasses(): Array<Class<*>>? {
        return arrayOf(RootConfig::class.java) 
    }

    // Servlet应用上下文配置（通常包含Web层配置）
    override fun getServletConfigClasses(): Array<Class<*>> {
        return arrayOf(WebConfig::class.java) 
    }

    // DispatcherServlet 的映射路径
    override fun getServletMappings(): Array<String> {
        return arrayOf("/") 
    }
}

方式三：传统的 web.xml 配置 ​

点击查看 web.xml 配置示例
xml
<web-app>
    <!-- 根应用上下文监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 根应用上下文配置文件位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <!-- DispatcherServlet 配置 -->
    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value> <!-- 使用默认位置 -->
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>
</web-app>

Spring Boot 中的 DispatcherServlet 🌟 ​

在 Spring Boot 中，DispatcherServlet 的配置变得更加简单：

kotlin
@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) 
    // Spring Boot 自动配置了 DispatcherServlet！
}

@RestController
class HelloController {
    
    @GetMapping("/hello")
    fun hello(): String {
        return "Hello, World!"
    }
}

NOTE

Spring Boot 采用了不同的初始化序列：

  • 不依赖 Servlet 容器的生命周期钩子
  • 使用 Spring 配置来引导自身和嵌入式 Servlet 容器
  • 自动检测并注册 Filter 和 Servlet 声明

实际应用场景示例 💼 ​

让我们看一个完整的电商系统示例：

kotlin
// 应用配置类
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = ["com.example.ecommerce"])
class WebConfig : WebMvcConfigurer {
    
    // 配置视图解析器
    @Bean
    fun viewResolver(): ViewResolver {
        val resolver = InternalResourceViewResolver()
        resolver.setPrefix("/WEB-INF/views/")
        resolver.setSuffix(".jsp")
        return resolver
    }
    
    // 配置静态资源处理
    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("/static/")
    }
}

// 产品控制器
@RestController
@RequestMapping("/api/products")
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)) 
    }
    
    @GetMapping("/{id}")
    fun getProduct(@PathVariable id: Long): Product {
        return productService.findById(id) 
            ?: throw ProductNotFoundException("Product not found: $id")
    }
    
    @PostMapping
    fun createProduct(@RequestBody @Valid product: Product): Product {
        return productService.save(product) 
    }
}

// 全局异常处理器
@ControllerAdvice
class GlobalExceptionHandler {
    
    @ExceptionHandler(ProductNotFoundException::class)
    fun handleProductNotFound(ex: ProductNotFoundException): ResponseEntity<ErrorResponse> {
        val error = ErrorResponse("PRODUCT_NOT_FOUND", ex.message ?: "Product not found")
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error) 
    }
}

DispatcherServlet 的工作流程 🔄 ​

关键优势总结 ✅ ​

DispatcherServlet 的核心价值

  1. 统一入口：所有 Web 请求都通过一个统一的入口点处理
  2. 灵活配置：通过 Spring 配置发现和管理各种委托组件
  3. 关注分离：将请求处理、视图解析、异常处理等关注点分离
  4. 易于测试：组件化的设计使得单元测试和集成测试更容易
  5. 扩展性强：可以轻松添加新的处理器、拦截器、视图解析器等

TIP

记住这个比喻：DispatcherServlet 就像一个智能的交通指挥中心，它知道每个请求应该去哪里，如何处理，以及如何返回结果。这种设计让我们的 Web 应用既有序又高效！

通过 DispatcherServlet，Spring MVC 实现了一个优雅、灵活且强大的 Web 框架架构，让开发者可以专注于业务逻辑的实现，而不用担心底层的请求处理细节。这就是为什么 Spring MVC 能够成为 Java Web 开发的首选框架之一！ 🎉