深入理解Java Servlet：从基础知识到实战技巧，揭秘JavaWeb开发秘诀


# 摘要
Java Servlet技术是构建动态Web应用的关键组件，提供了Web服务器端程序运行的接口。本文系统性地回顾了Servlet技术的基础知识，包括其生命周期、配置方法以及与HTTP请求和响应的交互机制。文章进一步阐述了Servlet在实际应用中的高级特性，如过滤器、监听器的使用，MVC设计模式的应用，以及Servlet 3.0引入的新特性，如注解配置简化和异步处理。本文旨在为开发者提供一个全面理解Servlet技术的资源，并提供有关安全实践和性能优化的指导。对于期望深入掌握Java Web开发的技术人员来说，本文是一个宝贵的参考资料。

# 关键字
Java Servlet；生命周期；请求与响应处理；会话跟踪；安全实践；性能优化

参考资源链接：[沈泽刚《JavaWeb编程技术》14章习题答案详解：URL、URI与Servlet基础](https://wenku.csdn.net/doc/64812438d12cbe7ec35f94d2?spm=1055.2635.3001.10343)
# 1. Java Servlet技术概述

## 1.1 Servlet技术简介

Java Servlet是Java EE（现在称为Jakarta EE）技术中用于扩展服务器功能的Java类。它提供了一种基于Java的服务器端扩展，可以响应客户端的请求并提供动态内容。与传统的CGI（Common Gateway Interface）脚本相比，Servlet具有更好的性能和更短的响应时间，因为它们在服务器启动时就加载到内存中，并且可以被多个请求复用。

## 1.2 Servlet的作用与优势

Servlet的主要作用是处理客户端发送的HTTP请求，并生成响应。它能够处理HTML表单数据、使用cookie进行会话跟踪、以及其他Web编程任务。Servlet的优势在于它能够在服务器端执行Java代码，提供了强大的接口和协议无关性，而且易于开发和维护。

## 1.3 Servlet技术的发展

自Java Servlet技术发布以来，它已经发展到了3.0版本（即Servlet 3.0）。这一过程中，Servlet技术不仅提高了Web应用的开发效率，还增强了异步处理能力和对注解配置的支持，使得部署和配置更加简化。Servlet 3.0引入了对可插拔式Web组件的支持，如Web Fragments，进一步促进了Web应用模块化和可扩展性的提升。

# 2. Servlet基础与生命周期

### 2.1 Servlet接口与GenericServlet类

#### 2.1.1 Servlet接口方法解析

Java Servlet技术是Java EE平台的核心组件，它允许Java代码在服务器端运行。Servlet接口定义了所有Servlet必须实现的方法。这些方法包括`init()`, `service()`, 和`destroy()`，分别用于初始化Servlet、处理请求、以及在Servlet被卸载前执行清理工作。

代码块展示了一个典型的Servlet实现：

public class HelloServlet extends HttpServlet {
    @Override
    public void init() {
        // 初始化逻辑
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        // 处理GET请求
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        // 处理POST请求
    }

    @Override
    public void destroy() {
        // 清理工作
    }
}

在上面的代码中，`init()`方法在Servlet创建时被调用，`doGet()`和`doPost()`分别处理来自客户端的GET和POST请求，`destroy()`方法则在Servlet生命周期结束前调用。

#### 2.1.2 GenericServlet类的功能扩展

`GenericServlet`是一个通用的、协议无关的Servlet基类，它实现了Servlet接口，并提供了一些便利的方法。它还提供了一个用于初始化Servlet配置的`init(ServletConfig config)`方法。开发者可以重写这个方法以获取初始化参数。

public class MyGenericServlet extends GenericServlet {
    @Override
    public void init(ServletConfig config) {
        super.init(config); // 调用父类的init方法
        // 初始化参数获取
        String myInitParam = config.getInitParameter("myParam");
    }
}

在这里，`init(ServletConfig config)`方法不仅初始化了GenericServlet，还使得开发者可以方便地访问`ServletConfig`对象，进而获取在web.xml中定义的初始化参数。

### 2.2 Servlet生命周期详解

#### 2.2.1 init()方法的作用与时机

Servlet的`init()`方法在Servlet被加载和实例化后调用一次。该方法为Servlet的后续服务提供初始化，如资源的加载、连接池的创建等。如果Servlet实例化失败，则整个Servlet都不会被使用。

#### 2.2.2 service()方法的请求处理机制

`service()`方法是Servlet的核心，它根据请求的类型（如GET或POST）调用相应的`doGet()`、`doPost()`等方法。Servlet容器在接收到请求时，会创建一个新的线程来调用`service()`方法。`service()`方法的默认实现会检查请求类型并分发到正确的do-method。

@Override
public void service(ServletRequest req, ServletResponse res)
    throws ServletException, IOException {
    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) res;
    String method = request.getMethod();
    if ("GET".equals(method)) {
        long lastModified = getLastModified(request);
        if (lastModified == -1) {
            // 调用doGet处理GET请求
            doGet(request, response);
        } else {
            // 设置最后修改时间
            response.setDateHeader("Last-Modified", lastModified);
        }
    } else if ("POST".equals(method)) {
        // 调用doPost处理POST请求
        doPost(request, response);
    } else if ("HEAD".equals(method)) {
        long lastModified = getLastModified(request);
        // 处理HEAD请求
        response.setDateHeader("Last-Modified", lastModified);
    } else if ("PUT".equals(method)) {
        // 处理PUT请求
        doPut(request, response);
    } else if ("DELETE".equals(method)) {
        // 处理DELETE请求
        doDelete(request, response);
    } else if ("OPTIONS".equals(method)) {
        // 处理OPTIONS请求
        doOptions(request, response);
    } else if ("TRACE".equals(method)) {
        // 处理TRACE请求
        doTrace(request, response);
    } else {
        // 处理不支持的HTTP方法
        String message = lStrings.getString("http.method_not_implemented");
        String error = message + ": " + method;
        response.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, error);
    }
}

#### 2.2.3 destroy()方法的资源回收过程

`destroy()`方法在Servlet被卸载或服务器关闭时调用。在这个方法中，Servlet应释放所有资源，如数据库连接、文件句柄等，并执行任何必要的清理工作。此方法只被调用一次，保证了Servlet的正确退出。

### 2.3 Servlet配置与初始化参数

#### 2.3.1 web.xml中的Servlet配置

在传统的web.xml配置方式中，Servlet的配置涉及指定Servlet类、Servlet名称以及初始化参数。例如：

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.example.HelloServlet</servlet-class>
    <init-param>
        <param-name>myParam</param-name>
        <param-value>MyParamValue</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

这段配置指定了Servlet类`HelloServlet`和它的一个初始化参数`myParam`。

#### 2.3.2 使用注解进行Servlet配置

从Servlet 3.0开始，可以使用注解来配置Servlet，无需在web.xml中声明。例如：

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    // Servlet实现
}

注解`@WebServlet("/hello")`指定了Servlet的URL映射。

#### 2.3.3 初始化参数的设置与获取

初始化参数可以在web.xml中通过`<init-param>`标签设置，或者通过注解`@WebInitParam`设置。在Servlet内部，通过`ServletConfig`对象来获取这些参数：

@Override
public void init(ServletConfig config) {
    super.init(config);
    String paramValue = config.getInitParameter("paramName");
}

初始化参数允许开发者在不修改代码的情况下，配置和调整Servlet的行为。

以上内容展示了Servlet的基础和生命周期相关的重要概念，接下来的内容将继续深入探讨如何处理HTTP请求和响应，以及会话跟踪技术等高级话题。

# 3. Servlet请求与响应处理

## 3.1 HTTP请求深入分析

### 3.1.1 请求行、头部和主体的数据处理

在Web开发中，理解HTTP请求的结构是至关重要的。一个HTTP请求由请求行、请求头（Headers）、空行以及可选的消息体（Body）组成。客户端发送到服务器的请求数据遵循这种格式，并且需要被Servlet正确解析以作出响应。

**请求行**包含请求方法、请求的URI（统一资源标识符）、以及HTTP协议的版本。例如，一个典型的HTTP请求行是这样的：

GET /example/index.html HTTP/1.1

这个请求行表明客户端使用了GET方法，请求的是`/example/index.html`资源，并且使用的是HTTP 1.1协议。

**请求头**提供了关于请求的附加信息，如客户端所支持的内容类型、语言偏好、编码方式等。例如：

Host: www.example.com
User-Agent: Mozilla/5.0 ...
Accept: text/html,application/xhtml+xml,application/xml;q=0.9 ...
Accept-Language: en-us,en;q=0.5 ...

**请求主体**通常用于发送数据到服务器，例如在POST请求中提交表单数据。它位于请求头和一个空行之后。

在Java Servlet中处理请求行和头部信息的代码示例如下：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String requestURI = request.getRequestURI(); // 获取请求URI
    String method = request.getMethod(); // 获取请求方法
    String protocol = request.getProtocol(); // 获取使用的HTTP协议版本
    Enumeration<String> headerNames = request.getHeaderNames(); // 枚举所有的头部名称
    // 遍历头部名称
    while(headerNames.hasMoreElements()) {
        String headerName = headerNames.nextElement();
        String headerValue = request.getHeader(headerName);
        // 处理每个头部信息...
    }
    // 处理请求主体数据
    // 对于GET请求，请求主体通常为空，对于POST请求，可以使用request.getReader()或request.getInputStream()读取
}

### 3.1.2 请求参数的获取与解析

HTTP请求参数通常指的是通过GET请求的URL参数或是通过POST请求在请求主体中的表单数据。Servlet API提供了解析这些参数的工具。对于GET请求，可以通过`request.getParameter(String name)`方法直接获取特定的参数值。对于POST请求，如果提交的是表单数据，同样可以使用此方法。

对于包含多个值的参数，可以通过`request.getParameterValues(String name)`方法来获取一个字符串数组。此方法在处理复选框等多值表单元素时非常有用。

// 获取单个参数值
String username = request.getParameter("username");

// 获取多个参数值
String[] interests = request.getParameterValues("interest");

// 解析请求体中的数据
if ("POST".equalsIgnoreCase(request.getMethod())) {
    // 调用request.getReader()获取字符流读取请求体
    BufferedReader reader = request.getReader();
    String body = "";
    String inputLine;
    while ((inputLine = reader.readLine()) != null) {
        body += inputLine;
    }
    // body变量现在包含请求体中的数据，可以进一步解析
}

解析请求体通常需要根据请求的`Content-Type`来决定如何读取。对于`application/x-www-form-urlencoded`和`multipart/form-data`，可以使用`request.getParameter`和`request.getParameterMap`方法。对于JSON或XML格式的数据，可能需要使用专门的库如Jackson或JAXB进行解析。

## 3.2 HTTP响应机制

### 3.2.1 响应状态码的设置与含义

HTTP响应状态码是服务器向客户端传达操作结果的一种方式。状态码位于响应的第一行，并且由一个三位数字组成，分为五个类别：

- 1xx：信息性状态码，表示收到请求，继续处理。
- 2xx：成功状态码，表示请求正常处理完毕。
- 3xx：重定向状态码，需要后续操作才能完成这一请求。
- 4xx：客户端错误状态码，请求包含语法错误或无法完成请求。
- 5xx：服务器错误状态码，服务器在处理请求的过程中发生了错误。

Servlet通过`HttpServletResponse`对象来设置状态码。以下是一些常用的响应状态码的使用示例：

// 200 OK：请求正常处理完毕
response.setStatus(HttpServletResponse.SC_OK);

// 301 Moved Permanently：资源的URI被更新
response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);

// 404 Not Found：未找到资源
response.sendError(HttpServletResponse.SC_NOT_FOUND);

// 500 Internal Server Error：服务器内部错误
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

### 3.2.2 响应头的设置与作用

响应头提供了有关服务器响应的额外信息，比如内容类型、内容长度、服务器类型、日期等。Servlet API允许开发者通过`HttpServletResponse`对象来设置自定义的响应头：

// 设置自定义响应头
response.setHeader("Custom-Header", "CustomValue");

// 设置内容类型
response.setContentType("text/html; charset=UTF-8");

// 设置内容长度
response.setContentLength(1024);

// 设置重定向位置
response.setHeader("Location", "http://www.example.com");

设置`Content-Type`响应头尤为重要，因为它告诉客户端返回的内容是什么类型（如文本、JSON、HTML或PDF文件），以及字符编码是什么，从而帮助客户端正确地处理内容。

## 3.3 会话跟踪技术

### 3.3.1 Cookie与Session的使用场景

在Web应用中，跟踪用户的状态是非常常见的需求，例如用户登录验证、购物车维护等。HTTP是无状态的协议，因此需要使用会话跟踪技术来维护用户状态。最常见的两种会话跟踪技术是Cookie和Session。

**Cookie**是一种存储在客户端的文本文件，服务器可以创建并发送到用户的浏览器上。之后，用户的浏览器会把Cookie信息随请求一起发送到服务器，从而可以识别用户。

// 在Servlet中设置Cookie
Cookie cookie = new Cookie("user", "username");
cookie.setMaxAge(3600); // 设置Cookie有效期为1小时
response.addCookie(cookie);

// 获取客户端发送的Cookie
Cookie[] cookies = request.getCookies();
for(Cookie cookie : cookies) {
    if("user".equals(cookie.getName())) {
        String username = cookie.getValue();
        // 使用获取到的用户名信息...
    }
}

**Session**机制则是在服务器端创建一个唯一的会话标识，通常称为Session ID，并在客户端与服务器之间的每次交互中传递。服务器根据Session ID将每个请求关联到特定的用户。

// 获取HttpSession对象
HttpSession session = request.getSession();

// 使用session保存用户数据
session.setAttribute("user", "username");

// 获取保存的用户数据
String username = (String) session.getAttribute("user");

### 3.3.2 Session管理与失效处理

Session管理通常涉及以下几个方面：

- 创建和获取Session对象。
- Session超时设置，自动无效化。
- 显式使Session无效。

通过设置`setMaxInactiveInterval`方法或在web.xml中设置`<session-config>`元素，可以控制Session的超时时间。例如：

// 设置Session超时时间为30分钟
session.setMaxInactiveInterval(30 * 60);

// 或者在web.xml中配置
<session-config>
    <session-timeout>30</session-timeout>
</session-config>

显式使Session无效，可以调用`invalidate()`方法：

// 使当前用户会话失效
session.invalidate();

在Servlet中，Session管理是一个重要环节。开发者需要合理设置Session的生命周期以优化用户体验和系统性能。

# 4. Servlet实战应用技巧

## 4.1 Servlet与JSP的整合使用
在Web应用开发中，Servlet与JSP的整合使用是一种常见的模式，尤其是在MVC架构下。下面将深入探讨如何将Servlet与JSP协同工作，以及它们之间的生命周期联系。

### 4.1.1 JSP的生命周期与Servlet的联系
JSP(JavaServer Pages)是Servlet技术的一种扩展，它允许开发者在HTML页面中嵌入Java代码。JSP的生命周期包括转换、编译和实例化三个阶段，其最终被转换为Servlet执行。我们可以通过一个简单的例子来了解JSP与Servlet的联系。

假设我们有一个简单的JSP页面 `hello.jsp`，内容如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello World</title>
</head>
<body>
    <% out.println("Hello World from JSP!"); %>
</body>
</html>

当用户第一次访问这个JSP页面时，容器会执行以下操作：

1. **转换阶段**：将JSP文件转换为一个Servlet源文件（`.jsp` 到 `.java`）。
2. **编译阶段**：将生成的Servlet源文件编译成一个Servlet类文件（`.java` 到 `.class`）。
3. **实例化阶段**：容器加载并实例化Servlet类，调用其 `init()` 方法进行初始化。

**执行阶段**：每当有请求到达时，Servlet的 `service()` 方法会被调用，处理请求并生成响应。在这个阶段，`out` 对象将 "Hello World from JSP!" 输出到客户端。

从以上生命周期可以看出，JSP最终会被容器转换并编译成Servlet，这意味着JSP的处理实际上是由Servlet来完成的。了解这一点对于理解如何在Servlet中处理JSP输出是至关重要的。

### 4.1.2 模型2架构下的Servlet与JSP协同
在MVC架构中，模型2（Model 2）是Java Web应用中常用的设计模式，其中Servlet通常扮演控制器的角色，而JSP则承担视图的责任。这种模式下，Servlet负责接收用户请求，处理业务逻辑，并选择合适的视图来显示结果。

模型2的工作流程可以总结如下：

1. 用户通过浏览器发送请求到Servlet控制器。
2. Servlet控制器处理请求，调用业务逻辑组件（模型）。
3. 业务逻辑组件执行业务处理并返回数据（模型数据）给Servlet控制器。
4. Servlet控制器决定下一步操作，通常是一个JSP页面。
5. Servlet将模型数据传递给JSP。
6. JSP生成HTML页面，展示数据。
7. JSP将生成的页面发送回客户端浏览器。

在这个模式中，Servlet与JSP通过MVC模式紧密协作，共同完成用户请求的响应。每个组件都承担着明确的职责，有助于提高代码的可维护性和可扩展性。

## 4.2 Web应用的安全实践
Web应用的安全是开发过程中不可忽视的部分。对于使用Servlet技术的Java Web应用来说，了解常见的安全威胁及采取相应的防范措施是十分必要的。

### 4.2.1 Servlet安全威胁与防范措施
Servlet应用可能面临多种安全威胁，其中包括但不限于：

- **跨站脚本攻击（XSS）**：攻击者在用户的浏览器中执行恶意脚本。
- **跨站请求伪造（CSRF）**：利用用户身份向应用发起恶意请求。
- **SQL注入**：通过在输入字段中插入恶意SQL代码来攻击数据库。
- **会话劫持**：攻击者获取用户会话信息并冒充用户。

为防范这些安全威胁，可以采取以下措施：

- 对所有用户输入进行验证和过滤，防止XSS和SQL注入攻击。
- 实现CSRF令牌机制，确保请求是用户自愿发起的。
- 使用HTTPS来加密数据传输，防止会话信息在传输过程中被截取。
- 设置会话超时，并在用户登出时销毁会话。

### 4.2.2 使用安全机制保护Web应用
Java提供了一套丰富的安全机制，帮助开发者保护Web应用。其中最重要的是安全API，如Java Authentication and Authorization Service (JAAS) 和 Java Secure Socket Extension (JSSE)。

- **JAAS** 提供了一种灵活的机制来验证用户身份，并授权用户访问系统资源。开发者可以通过配置 JAAS 来定义安全策略文件，并使用它来控制不同用户或角色对应用资源的访问权限。
- **JSSE** 提供了SSL/TLS协议的支持，帮助开发者在客户端和服务器之间建立安全连接。通过使用 JSSE，可以确保数据传输的安全性，防止数据在传输过程中被截获或篡改。

## 4.3 Servlet性能优化策略
随着Web应用用户数量的增长，性能优化成为提升用户体验的关键。优化Servlet应用可以提高响应速度，减少资源消耗，并提高应用的可扩展性。

### 4.3.1 异步处理与非阻塞IO的使用
Servlet 3.1 引入了异步处理的能力，使得开发者可以在处理耗时操作时，不会阻塞主线程。这允许Servlet立即返回响应给客户端，而继续在后台线程处理业务逻辑。

@WebServlet(value="/async", asyncSupported = true)
public class AsyncServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        AsyncContext ctx = request.startAsync();
        new Thread(new Runnable() {
            public void run() {
                try {
                    // 模拟耗时操作
                    Thread.sleep(5000);
                    response.getWriter().print("处理完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ctx.complete();
            }
        }).start();
    }
}

上例展示了如何使用异步处理和 `AsyncContext` 实现非阻塞响应。在这个例子中，主线程会立即返回一个响应，同时后台线程继续执行业务逻辑。

### 4.3.2 Servlet线程安全与资源管理
在多线程环境下，确保线程安全是Servlet开发时必须考虑的问题。开发者应该避免共享可变状态，或者确保共享资源的同步访问。

@WebServlet("/counter")
public class CounterServlet extends HttpServlet {
    private int count = 0;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        synchronized(this) {
            count++;
            response.getWriter().print("<h1>访问次数: " + count + "</h1>");
        }
    }
}

此Servlet通过使用 `synchronized` 关键字确保了对 `count` 变量的线程安全访问。同时，务必注意合理管理资源，例如数据库连接、网络连接等，避免因资源泄露导致的性能问题。

以上章节内容，让我们深入理解了Servlet与JSP整合使用的方法、Web应用的安全实践以及性能优化策略，为读者提供了有价值的实战技巧和优化方法。

# 5. Servlet高级应用

## 5.1 使用过滤器与监听器

### 5.1.1 过滤器的实现与应用场景

过滤器（Filter）是Java Servlet技术中一个重要的概念，它可以在请求到达Servlet之前或响应从Servlet发出之前对它们进行预处理或后处理。过滤器实现了`javax.servlet.Filter`接口，包含三个核心方法：`init`, `doFilter`, `destroy`。

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {
        // 在初始化时执行一次
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        // 对请求和响应进行预处理，然后通过chain.doFilter(request, response)传递给下一个过滤器或Servlet
    }

    public void destroy() {
        // 在销毁过滤器实例之前执行一次
    }
}

过滤器的应用场景非常广泛，包括但不限于：

- **安全控制**：对用户请求进行身份验证，拒绝未授权的访问。
- **日志记录**：记录请求和响应的内容，用于审计或监控。
- **数据压缩**：对响应数据进行压缩，减少传输时间。
- **字符编码处理**：确保请求和响应使用统一的字符编码，防止乱码问题。

### 5.1.2 监听器的类型与作用

监听器（Listener）是一个实现了特定接口的Servlet组件，它可以监听Web应用中的各种事件，如：会话创建、属性更改、请求开始等。监听器的类型包括：`ServletContextListener`, `HttpSessionListener`, `ServletRequestListener`等。

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletContextListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent sce) {
        // Servlet上下文初始化时执行
    }

    public void contextDestroyed(ServletContextEvent sce) {
        // Servlet上下文销毁时执行
    }
}

监听器的作用包括但不限于：

- **应用生命周期管理**：监听整个Web应用的启动和关闭过程。
- **会话管理**：监听用户会话的创建和销毁，方便进行会话跟踪。
- **属性变化监控**：监听应用范围对象或会话范围对象的属性添加、移除或更改事件。

## 5.2 深入理解MVC设计模式

### 5.2.1 MVC模式在Web开发中的角色

MVC（Model-View-Controller）是一种广泛使用的软件设计模式，其核心思想是将应用程序分为三个核心组件：

- **Model（模型）**：代表数据和业务逻辑。
- **View（视图）**：展示数据给用户。
- **Controller（控制器）**：处理用户输入，调用模型并选择视图。

在Servlet技术中，Servlet通常扮演Controller的角色，负责接收请求、调用模型处理业务逻辑，并选择合适的视图进行展示。

### 5.2.2 Servlet作为控制器的角色分析

Servlet作为控制器的核心职责包括：

- **请求分发**：接收来自客户端的请求，并根据请求类型、数据等决定下一步的动作。
- **数据处理**：调用模型层处理数据，获取处理结果。
- **视图选择**：根据业务逻辑的处理结果选择合适的视图（如JSP页面）进行数据展示。

例如，一个典型的Servlet控制器可能如下所示：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 根据请求参数选择处理方式
    String action = request.getParameter("action");
    switch (action) {
        case "login":
            login(request, response);
            break;
        case "logout":
            logout(request, response);
            break;
        // 其他case...
    }
}

private void login(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 处理登录逻辑，调用模型处理数据
    // ...
    // 根据处理结果选择视图
    RequestDispatcher dispatcher = request.getRequestDispatcher("login.jsp");
    dispatcher.forward(request, response);
}

private void logout(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 处理登出逻辑，调用模型处理数据
    // ...
    // 根据处理结果选择视图
    RequestDispatcher dispatcher = request.getRequestDispatcher("logout.jsp");
    dispatcher.forward(request, response);
}

## 5.3 Servlet 3.0新特性探索

### 5.3.1 注解配置的简化

Servlet 3.0引入了注解配置，让开发者可以不再依赖web.xml文件来配置Servlet。通过使用`@WebServlet`注解，可以非常方便地定义Servlet的URL映射、名称等。

@WebServlet(name = "myServlet", urlPatterns = {"/myServlet"})
public class MyServlet extends HttpServlet {
    // ...
}

### 5.3.2 异步处理支持的增强

异步处理在Servlet 3.0中得到了增强，允许在不使用额外线程的情况下，通过`AsyncContext`进行长时间运行的请求处理。

@WebServlet(urlPatterns = {"/async"}, asyncSupported = true)
public class AsyncServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        final AsyncContext ctx = request.startAsync();
        new Thread(new Runnable() {
            public void run() {
                try {
                    // 模拟长时间操作
                    Thread.sleep(5000);
                    response.getWriter().write("Operation complete");
                } catch (Exception e) {
                    // ...
                }
                ctx.complete();
            }
        }).start();
    }
}

### 5.3.3 可插拔式Web组件的实现

Servlet 3.0规范引入了可插拔式Web组件的概念，允许开发者更加灵活地部署Web应用。这些组件包括Servlet、过滤器、监听器等，它们可以被打包在任何JAR文件中，并通过注解或XML配置的方式进行配置。

通过使用注解和Servlet 3.0提供的API，开发者可以轻松地创建可移植的Web应用，并在不同的应用服务器之间进行无缝迁移。