什么是Servlet请求转发
Servlet请求转发（Request Forwarding）是Java Web开发中一种重要的请求处理机制。当Web应用接收到客户端请求时，服务器可以将该请求转发给另一个Servlet或JSP页面进行处理，而客户端并不知道这个过程的发生。这种机制在MVC架构中扮演着核心角色，特别是在控制器与视图之间的协作方面。
请求转发具有以下特点：
服务器端行为
：整个转发过程发生在服务器内部，客户端无感知。
一次请求一次响应
：客户端只发送一次请求，服务器最终只返回一个响应。
数据共享
：转发过程中，请求对象和响应对象保持不变，因此可以在多个组件之间共享数据。
URL不变
：浏览器地址栏中的URL不会改变，始终显示最初请求的URL。
请求转发的工作原理
转发流程图解
客户端请求 → Servlet A → 转发 → Servlet B → 响应客户端
转发过程详解
客户端发起请求
：浏览器向服务器发送HTTP请求，例如访问
/app/servletA
。
Servlet A处理
：Web容器（如Tomcat）根据URL映射找到对应的Servlet A，并调用其
service()
方法。
执行转发操作
：在Servlet A中，通过
RequestDispatcher
对象调用
forward()
方法，将请求转发给另一个资源（Servlet B 或 JSP）。
Servlet B处理
：Web容器调用Servlet B的
service()
方法，处理请求并生成响应内容。
响应返回客户端
：响应内容通过Servlet A的响应对象返回给客户端，浏览器显示最终结果。
转发过程中的对象共享
在转发过程中，以下对象在多个Servlet之间共享：
HttpServletRequest
：包含请求参数、头信息、属性等。
HttpServletResponse
：用于设置响应头、状态码、写入响应内容等。
HttpSession
：会话对象，用于跨请求存储用户数据。
ServletContext
：应用上下文对象，用于全局数据共享。
请求转发的实现方式
1. 使用 RequestDispatcher.forward()
这是最常用的转发方式，通过
HttpServletRequest
获取
RequestDispatcher
对象，然后调用
forward()
方法。
示例代码
// Servlet A
@WebServlet(“/servletA”)
public class ServletA extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 设置请求属性，用于在转发中共享数据
request.setAttribute(“message”, “Hello from ServletA”);
request.setAttribute(“timestamp”, System.currentTimeMillis());

// 获取 RequestDispatcher 对象
// 参数可以是相对路径或绝对路径
RequestDispatcher dispatcher = request.getRequestDispatcher(“/servletB”);

// 执行转发
dispatcher.forward(request, response);
}
}

// Servlet B
@WebServlet(“/servletB”)
public class ServletB extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 获取共享数据
String message = (String) request.getAttribute(“message”);
Long timestamp = (Long) request.getAttribute(“timestamp”);

// 设置响应内容
response.setContentType(“text/html;charset=UTF-8”);
PrintWriter out = response.getWriter();
out.println(““);
out.println(“

Servlet B 接收到的数据：

“);
out.println(“

消息: ” + message + “

“);
out.println(“

时间戳: ” + timestamp + “

“);
out.println(““);
}
}
路径说明
相对路径
：
request.getRequestDispatcher(“servletB”)
或
request.getRequestDispatcher(“subdir/servletB”)
相对于当前Servlet的路径
例如：如果当前Servlet的URL是
/app/servletA
，那么
“servletB”
会被解析为
/app/servletB
绝对路径
：
request.getRequestDispatcher(“/servletB”)
相对于当前Web应用的上下文根（Context Root）
例如：如果应用部署在
http://localhost:8080/myapp
，那么
/servletB
会被解析为
http://localhost:8080/myapp/servletB
2. 使用 ServletContext.getRequestDispatcher()
这种方式获取的RequestDispatcher是相对于应用上下文根的绝对路径。
示例代码
// Servlet A
@WebServlet(“/servletA”)
public class ServletA extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 设置共享数据
request.setAttribute(“user”, “John Doe”);

// 获取 ServletContext 对象
ServletContext context = getServletContext();

// 获取 RequestDispatcher 对象（绝对路径）
RequestDispatcher dispatcher = context.getRequestDispatcher(“/servletB”);

// 执行转发
dispatcher.forward(request, response);
}
}
3. 转发到 JSP 页面
请求转发常用于将处理结果转发到JSP页面进行显示。
示例代码
// Servlet 处理业务逻辑
@WebServlet(“/userProfile”)
public class UserProfileServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 模拟从数据库获取用户信息
User user = new User();
user.setId(1);
user.setName(“张三”);
user.setEmail(“zhangsan@example.com”);

// 将用户对象存储到请求属性中
request.setAttribute(“user”, user);

// 转发到 JSP 页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“/WEB-INF/views/profile.jsp”);
dispatcher.forward(request, response);
}
}

// JSP 页面 (profile.jsp)
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

用户资料页面

利用请求转发实现页面跳转与数据共享
1. 基本数据共享机制
请求转发通过
HttpServletRequest
的
setAttribute()
和
getAttribute()
方法实现数据共享。
示例：表单处理流程
// 显示表单的 Servlet
@WebServlet(“/showForm”)
public class ShowFormServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 设置表单默认值
request.setAttribute(“defaultName”, “请输入姓名”);
request.setAttribute(“defaultEmail”, “请输入邮箱”);

// 转发到表单页面
request.getRequestDispatcher(“/form.jsp”).forward(request, response);
}
}

// 处理表单提交的 Servlet
@WebServlet(“/processForm”)
public class ProcessFormServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 获取表单参数
String name = request.getParameter(“name”);
String email = request.getParameter(“email”);

// 验证数据
List errors = new ArrayList<>();
if (name == null || name.trim().isEmpty()) {
errors.add(“姓名不能为空”);
}
if (email == null || !email.contains(“@”)) {
errors.add(“邮箱格式不正确”);
}

// 如果有错误，转发回表单页面并显示错误信息
if (!errors.isEmpty()) {
request.setAttribute(“errors”, errors);
request.setAttribute(“submittedName”, name);
request.setAttribute(“submittedEmail”, email);
request.getRequestDispatcher(“/form.jsp”).forward(request, response);
return;
}

// 数据验证通过，转发到成功页面
request.setAttribute(“successMessage”, “数据提交成功！”);
request.getRequestDispatcher(“/success.jsp”).forward(request, response);
}
}

// form.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

用户注册表单

姓名:
邮箱:

2. 复杂对象共享
不仅可以共享基本数据类型，还可以共享自定义对象、集合等复杂数据。
示例：商品列表展示
// 商品实体类
public class Product {
private int id;
private String name;
private double price;

// 构造函数、getter/setter 省略
}

// 商品查询 Servlet
@WebServlet(“/productList”)
public class ProductListServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 模拟从数据库查询商品列表
List products = new ArrayList<>();
products.add(new Product(1, “笔记本电脑”, 5999.00));
products.add(new Product(2, “智能手机”, 2999.00));
products.add(new Product(3, “平板电脑”, 1999.00));

// 将商品列表存储到请求属性中
request.setAttribute(“productList”, products);
request.setAttribute(“totalProducts”, products.size());

// 转发到商品列表页面
request.getRequestDispatcher(“/WEB-INF/views/products.jsp”).forward(request, response);
}
}

// products.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

商品列表 (共 ${totalProducts} 件商品)

ID	名称	价格
${product.id}	${product.name}	¥${product.price}

3. 分层架构中的数据共享
在MVC架构中，请求转发是连接控制器、模型和视图的桥梁。
示例：用户管理模块
// 用户模型类
public class User {
private int id;
private String username;
private String email;
// getter/setter 省略
}

// 用户服务类（业务逻辑层）
public class UserService {
public List getAllUsers() {
// 模拟数据库查询
List users = new ArrayList<>();
users.add(new User(1, “admin”, “admin@example.com”));
users.add(new User(2, “user1”, “user1@example.com”));
return users;
}

public User getUserById(int id) {
// 模拟根据ID查询用户
return new User(id, “user” + id, “user” + id + “@example.com”);
}
}

// 用户控制器 Servlet
@WebServlet(“/users/*”)
public class UserServlet extends HttpServlet {
private UserService userService = new UserService();

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String pathInfo = request.getPathInfo();

if (pathInfo == null || pathInfo.equals(“/”)) {
// 显示用户列表
List users = userService.getAllUsers();
request.setAttribute(“users”, users);
request.getRequestDispatcher(“/WEB-INF/views/userList.jsp”).forward(request, response);
} else if (pathInfo.matches(“/\\d+”)) {
// 显示单个用户详情
int userId = Integer.parseInt(pathInfo.substring(1));
User user = userService.getUserById(userId);
request.setAttribute(“user”, user);
request.getRequestDispatcher(“/WEB-INF/views/userDetail.jsp”).forward(request, response);
} else {
response.sendError(HttpServletResponse.SC_NOT_FOUND);
}
}
}
4. 使用过滤器配合转发
过滤器可以在转发前后进行预处理和后处理。
示例：日志记录过滤器
// 日志记录过滤器
@WebFilter(“/*”)
public class LoggingFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {

long startTime = System.currentTimeMillis();
HttpServletRequest httpRequest = (HttpServletRequest) request;

// 记录请求信息
System.out.println(“请求开始: ” + httpRequest.getRequestURI() + ” – ” + new Date());

// 继续执行过滤器链（包括后续的Servlet）
chain.doFilter(request, response);

long endTime = System.currentTimeMillis();
System.out.println(“请求结束: ” + httpRequest.getRequestURI() + ” – 耗时: ” + (endTime – startTime) + “ms”);
}
}
转发过程中的常见问题与解决方案
1. 路径问题
问题描述
相对路径和绝对路径混淆导致转发失败
JSP页面中的资源路径（CSS、JS、图片）无法正确加载
解决方案
路径最佳实践：
// 正确使用绝对路径（推荐）
request.getRequestDispatcher(“/WEB-INF/views/page.jsp”).forward(request, response);

// 避免使用相对路径
// 错误示例：request.getRequestDispatcher(“page.jsp”).forward(request, response);
JSP资源路径处理：
<%-- 在JSP中使用绝对路径引用资源 --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<% String contextPath = request.getContextPath(); %>


/js/app.js">

3. 使用异步处理提高性能
示例：异步转发处理
@WebServlet(urlPatterns = “/async”, asyncSupported = true)
public class AsyncServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 启动异步上下文
AsyncContext asyncContext = request.startAsync();

// 在新线程中处理
asyncContext.start(() -> {
try {
// 模拟耗时操作
Thread.sleep(1000);

// 设置属性
request.setAttribute(“result”, “异步处理完成”);

// 转发到结果页面
asyncContext.dispatch(“/WEB-INF/views/asyncResult.jsp”);
} catch (Exception e) {
e.printStackTrace();
}
});
}
}
4. 缓存优化
示例：使用缓存减少重复计算
@WebServlet(“/cached”)
public class CachedServlet extends HttpServlet {
private Map cache = new ConcurrentHashMap<>();

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String cacheKey = “pageData”;
Object data = cache.get(cacheKey);

if (data == null) {
// 计算数据（耗时操作）
data = calculateExpensiveData();
cache.put(cacheKey, data);

// 设置缓存过期时间（例如5分钟）
scheduleCacheEviction(cacheKey, 5 * 60 * 1000);
}

request.setAttribute(“data”, data);
request.getRequestDispatcher(“/result.jsp”).forward(request, response);
}

private Object calculateExpensiveData() {
// 模拟耗时计算
return “Expensive Data”;
}

private void scheduleCacheEviction(String key, long delay) {
// 定时清除缓存
new Timer().schedule(new TimerTask() {
@Override
public void run() {
cache.remove(key);
}
}, delay);
}
}
5. 性能监控与优化
示例：监控转发性能
@WebFilter(“/*”)
public class PerformanceMonitorFilter implements Filter {
private static final Logger logger = Logger.getLogger(PerformanceMonitorFilter.class.getName());

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {

long start = System.currentTimeMillis();
HttpServletRequest httpRequest = (HttpServletRequest) request;

// 记录请求信息
String requestURI = httpRequest.getRequestURI();

chain.doFilter(request, response);

long duration = System.currentTimeMillis() – start;

// 记录耗时超过阈值的请求
if (duration > 1000) { // 1秒
logger.warning(“慢请求: ” + requestURI + ” – 耗时: ” + duration + “ms”);
}
}
}
6. 使用设计模式优化
示例：前端控制器模式
// 前端控制器 – 统一处理所有请求
@WebServlet(“/*”)
public class FrontController extends HttpServlet {
private Map commands = new HashMap<>();

@Override
public void init() throws ServletException {
// 注册命令
commands.put(“list”, new ListCommand());
commands.put(“detail”, new DetailCommand());
commands.put(“edit”, new EditCommand());
}

protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String action = request.getParameter(“action”);

// 查找对应的命令
Command command = commands.get(action);
if (command != null) {
command.execute(request, response);
} else {
// 默认转发到首页
request.getRequestDispatcher(“/index.jsp”).forward(request, response);
}
}
}

// 命令接口
interface Command {
void execute(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException;
}

// 具体命令实现
class ListCommand implements Command {
@Override
public void execute(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

// 业务逻辑
List items = Arrays.asList(“Item1”, “Item2”, “Item3”);
request.setAttribute(“items”, items);

// 转发到列表页面
request.getRequestDispatcher(“/WEB-INF/views/list.jsp”).forward(request, response);
}
}
总结
Servlet请求转发是Java Web开发中不可或缺的技术，它通过服务器内部的请求传递机制，实现了高效的页面跳转和数据共享。掌握其原理和优化技巧，能够帮助开发者构建更加健壮、高效的Web应用。
关键要点回顾：
原理清晰
：理解转发是一次请求、一次响应，数据在请求对象中共享。
路径规范
：使用绝对路径避免路径问题。
数据管理
：合理使用
setAttribute()
和
getAttribute()
进行数据传递。
异常处理
：通过过滤器统一处理异常和错误。
性能优化
：使用缓存、异步处理、监控等手段提升性能。
设计模式
：采用前端控制器等模式优化架构。
通过合理运用这些技巧，可以有效解决转发过程中的常见问题，提升应用的可维护性和用户体验。