Spring MVC请求转发与重定向：深度解析与应用实战

一、前言：为什么需要转发与重定向？

在现代Web应用开发中，页面跳转和请求流转是每个开发者必须掌握的核心技能。Spring MVC作为Java领域最流行的Web框架，提供了优雅且强大的转发（Forward）和重定向（Redirect）机制。正确理解并应用这两种机制，不仅能优化用户体验，还能提升应用的安全性和可维护性。

本文将深入探讨Spring MVC中转发与重定向的实现原理、使用场景、最佳实践以及常见陷阱，帮助你在实际项目中做出正确的技术选择。

二、核心概念：一次请求的生命周期

在深入讨论之前，我们先理解Web请求的基本流程：

客户端请求 → 服务器接收 → 业务处理 → 响应返回

在这个流程中，转发和重定向决定了服务器如何处理请求的流转路径。

三、请求转发（Forward）：服务器内部的无缝衔接

3.1 什么是请求转发？

请求转发是服务器内部的行为，客户端浏览器对此完全无感知。整个过程在服务器端完成，浏览器只收到一次响应。

工作流程示意图：

浏览器 → [请求] /original → DispatcherServlet → Controller A 
                                     ↓ (forward)
                               Controller B / JSP
                                     ↓
浏览器 ← [响应] 最终内容 ← DispatcherServlet

3.2 Spring MVC中的转发实现

3.2.1 基础语法

@Controller
@RequestMapping("/user")
public class UserController {
    
    /**
     * 基础转发示例
     * 在返回值前添加"forward:"前缀
     */
    @GetMapping("/profile")
    public String viewProfile() {
        // 转发到另一个控制器方法
        return "forward:/user/detail";
        
        // 或者转发到JSP视图
        // return "forward:/WEB-INF/views/user/profile.jsp";
    }
    
    @GetMapping("/detail")
    public String userDetail(Model model) {
        model.addAttribute("user", getUserInfo());
        return "user/detailView";
    }
}

3.2.2 转发时携带数据

@Controller
public class DataForwardController {
    
    /**
     * 转发过程中数据传递
     * 转发共享同一个HttpServletRequest对象
     */
    @GetMapping("/process")
    public String processData(HttpServletRequest request) {
        // 方式1：使用HttpServletRequest属性
        request.setAttribute("processingStage", "step1");
        request.setAttribute("data", fetchImportantData());
        
        // 方式2：使用Model（Spring推荐）
        // 在方法参数中添加Model model
        // model.addAttribute("key", "value");
        
        return "forward:/next/step";
    }
    
    @GetMapping("/next/step")
    public String nextStep(HttpServletRequest request) {
        // 可以获取到上一个处理器设置的数据
        String stage = (String) request.getAttribute("processingStage");
        Object data = request.getAttribute("data");
        
        System.out.println("当前阶段：" + stage);
        return "result";
    }
}

3.3 转发的核心应用场景

3.3.1 MVC模式的标准实现

@Controller
public class ProductController {
    
    @GetMapping("/product/{id}")
    public String getProduct(@PathVariable Long id, 
                           Model model,
                           HttpServletRequest request) {
        
        // 1. 执行业务逻辑
        Product product = productService.findById(id);
        
        if (product == null) {
            // 2. 转发到错误页面
            request.setAttribute("errorMsg", "产品不存在");
            return "forward:/error/404";
        }
        
        // 3. 准备视图数据
        model.addAttribute("product", product);
        model.addAttribute("relatedProducts", 
                          productService.findRelated(id));
        
        // 4. 根据设备类型转发到不同视图
        String userAgent = request.getHeader("User-Agent");
        if (isMobileDevice(userAgent)) {
            return "forward:/mobile/product/detail";
        }
        
        // 5. 默认转发到PC视图
        return "product/detail"; // 默认就是转发
    }
}

3.3.2 统一前置处理与权限控制

@Controller
@ControllerAdvice
public class SecurityInterceptor {
    
    /**
     * 使用@ModelAttribute进行统一前置处理
     * 该方法会在每个请求处理前执行
     */
    @ModelAttribute
    public void checkAuth(HttpServletRequest request, 
                         HttpServletResponse response) throws Exception {
        
        String uri = request.getRequestURI();
        
        // 检查需要权限的路径
        if (requiresAuthentication(uri)) {
            HttpSession session = request.getSession(false);
            
            if (session == null || session.getAttribute("user") == null) {
                // 未登录，转发到登录页
                request.setAttribute("originalUrl", uri);
                request.getRequestDispatcher("/login")
                      .forward(request, response);
                return;
            }
            
            // 检查角色权限
            if (!hasPermission(uri, session)) {
                request.getRequestDispatcher("/error/403")
                      .forward(request, response);
                return;
            }
        }
    }
    
    private boolean requiresAuthentication(String uri) {
        return uri.startsWith("/admin") || 
               uri.startsWith("/dashboard") ||
               uri.startsWith("/api/secure");
    }
}

四、请求重定向（Redirect）：客户端的二次请求

4.1 什么是请求重定向？

重定向是服务器告诉客户端：“你要的资源不在我这里，请去另一个地址重新请求”。客户端浏览器会收到一个特殊的HTTP响应（状态码302），然后自动向新地址发起第二次请求。

工作流程示意图：

浏览器 → [请求1] /original → 服务器
                                     ↓ (响应302 + Location:/new)
浏览器 ← [响应1] 302状态码 + 新地址
                                     ↓
浏览器 → [请求2] /new → 服务器
                                     ↓
浏览器 ← [响应2] 200状态码 + 内容

4.2 HTTP状态码详解

4.3 Spring MVC中的重定向实现

4.3.1 基础语法

@Controller
public class RedirectController {
    
    // 基本重定向
    @GetMapping("/old-url")
    public String redirectBasic() {
        // 重定向到应用内路径
        return "redirect:/new-url";
        
        // 重定向到外部URL
        // return "redirect:https://www.example.com";
    }
    
    // 带路径变量的重定向
    @GetMapping("/user/{userId}/old")
    public String redirectWithPathVar(@PathVariable String userId) {
        // 自动填充路径变量
        return "redirect:/user/{userId}/profile";
        // 实际重定向到：/user/123/profile
    }
}

4.3.2 数据传递策略

@Controller
public class RedirectDataController {
    
    /**
     * 方法1：URL查询参数（适合简单数据）
     */
    @PostMapping("/search")
    public String searchProducts(@RequestParam String keyword,
                                @RequestParam String category,
                                RedirectAttributes attributes) {
        
        // 自动编码并添加到URL
        attributes.addAttribute("keyword", keyword);
        attributes.addAttribute("category", category);
        attributes.addAttribute("sort", "price");  // 额外参数
        
        // 结果：/products?keyword=xxx&category=yyy&sort=price
        return "redirect:/products";
    }
    
    /**
     * 方法2：Flash Attributes（适合复杂对象）
     */
    @PostMapping("/order/create")
    public String createOrder(OrderForm form,
                             RedirectAttributes attributes) {
        
        try {
            Order order = orderService.createOrder(form);
            
            // Flash Attributes存储在Session中，一次性使用
            attributes.addFlashAttribute("successMessage", 
                "订单创建成功！订单号：" + order.getOrderNumber());
            
            attributes.addFlashAttribute("order", order); // 传递对象
            
            // 同时也可以添加URL参数
            attributes.addAttribute("orderId", order.getId());
            
            return "redirect:/order/result";
            
        } catch (Exception e) {
            attributes.addFlashAttribute("errorMessage", 
                "创建失败：" + e.getMessage());
            return "redirect:/order/retry";
        }
    }
    
    @GetMapping("/order/result")
    public String showOrderResult(Model model) {
        // Flash Attributes会自动添加到Model中
        String message = (String) model.getAttribute("successMessage");
        Order order = (Order) model.getAttribute("order");
        
        return "order/result";
    }
}

4.4 重定向的核心应用场景

4.4.1 POST-REDIRECT-GET模式（防重复提交）

@Controller
@RequestMapping("/survey")
public class SurveyController {
    
    /**
     * POST-REDIRECT-GET经典模式
     * 解决表单重复提交问题
     */
    @PostMapping("/submit")
    public String submitSurvey(SurveyResponse response,
                              HttpSession session,
                              RedirectAttributes attributes) {
        
        // 1. 业务处理
        surveyService.saveResponse(response);
        
        // 2. 生成唯一令牌，防止重复提交
        String token = UUID.randomUUID().toString();
        session.setAttribute("lastSubmissionToken", token);
        response.setSubmissionToken(token);
        
        // 3. 设置成功消息（使用Flash Attributes）
        attributes.addFlashAttribute("success", 
            "问卷提交成功！感谢您的参与。");
        
        // 4. 重定向到GET页面
        return "redirect:/survey/thankyou";
    }
    
    @GetMapping("/thankyou")
    public String thankYouPage(HttpSession session, Model model) {
        // 可以检查提交令牌
        String token = (String) session.getAttribute("lastSubmissionToken");
        if (token != null) {
            model.addAttribute("submissionToken", token);
            session.removeAttribute("lastSubmissionToken");
        }
        
        return "survey/thankyou";
    }
    
    /**
     * 防止重复提交的拦截器
     */
    @PostMapping("/submit")
    public String submitWithDuplicateCheck(@ModelAttribute SurveyResponse response,
                                          @RequestParam String submissionToken,
                                          HttpSession session,
                                          RedirectAttributes attributes) {
        
        String lastToken = (String) session.getAttribute("lastSubmissionToken");
        
        if (lastToken != null && lastToken.equals(submissionToken)) {
            // 重复提交
            attributes.addFlashAttribute("error", 
                "请不要重复提交！");
            return "redirect:/survey/form";
        }
        
        // 正常处理...
        return "redirect:/survey/thankyou";
    }
}

4.4.2 用户认证与授权流程

@Controller
public class AuthenticationController {
    
    /**
     * 完整的登录-重定向流程
     */
    @PostMapping("/login")
    public String processLogin(@RequestParam String username,
                              @RequestParam String password,
                              @RequestParam(required = false) String redirectUrl,
                              HttpServletRequest request,
                              RedirectAttributes attributes) {
        
        // 1. 验证用户凭据
        User user = authService.authenticate(username, password);
        
        if (user == null) {
            // 登录失败，重定向回登录页
            attributes.addFlashAttribute("error", 
                "用户名或密码错误");
            return "redirect:/login";
        }
        
        // 2. 创建会话
        HttpSession session = request.getSession();
        session.setAttribute("currentUser", user);
        session.setAttribute("loginTime", LocalDateTime.now());
        
        // 3. 记录登录日志
        logLoginAttempt(user, request.getRemoteAddr(), true);
        
        // 4. 处理重定向URL
        String targetUrl = determineRedirectUrl(redirectUrl, user);
        
        // 5. 重定向到目标页面
        return "redirect:" + targetUrl;
    }
    
    private String determineRedirectUrl(String requestedUrl, User user) {
        // 安全检查：防止开放重定向漏洞
        if (requestedUrl != null && isSafeRedirect(requestedUrl)) {
            return requestedUrl;
        }
        
        // 根据用户角色重定向到不同页面
        if (user.hasRole("ADMIN")) {
            return "/admin/dashboard";
        } else if (user.hasRole("MANAGER")) {
            return "/manager/console";
        } else {
            return "/user/home";
        }
    }
    
    /**
     * 防止开放重定向攻击
     */
    private boolean isSafeRedirect(String url) {
        // 只允许重定向到内部地址
        return url.startsWith("/") && !url.contains("://");
    }
}

4.4.3 支付与第三方集成

@Controller
@RequestMapping("/payment")
public class PaymentController {
    
    /**
     * 支付流程中的重定向链
     */
    @PostMapping("/initiate")
    public String initiatePayment(@Valid PaymentRequest request,
                                 BindingResult bindingResult,
                                 RedirectAttributes attributes) {
        
        if (bindingResult.hasErrors()) {
            attributes.addFlashAttribute("errors", 
                bindingResult.getAllErrors());
            return "redirect:/payment/error";
        }
        
        try {
            // 1. 创建支付订单
            PaymentOrder order = paymentService.createOrder(request);
            
            // 2. 根据支付方式重定向
            switch (request.getPaymentMethod()) {
                case "alipay":
                    String alipayUrl = alipayService
                        .createPaymentUrl(order);
                    return "redirect:" + alipayUrl;
                    
                case "wechat":
                    String wechatUrl = wechatPayService
                        .createNativeUrl(order);
                    // 重定向到二维码展示页
                    attributes.addFlashAttribute("qrCodeUrl", wechatUrl);
                    return "redirect:/payment/qrcode";
                    
                case "credit_card":
                    // 重定向到信用卡支付页
                    attributes.addFlashAttribute("order", order);
                    return "redirect:/payment/credit-card";
                    
                default:
                    throw new IllegalArgumentException("不支持的支付方式");
            }
            
        } catch (Exception e) {
            attributes.addFlashAttribute("error", 
                "支付初始化失败：" + e.getMessage());
            return "redirect:/payment/failed";
        }
    }
    
    /**
     * 支付回调处理
     */
    @GetMapping("/callback/{gateway}")
    public String handleCallback(@PathVariable String gateway,
                                @RequestParam Map<String, String> params,
                                RedirectAttributes attributes) {
        
        PaymentResult result;
        
        try {
            // 验证回调签名
            if (!paymentService.verifyCallback(gateway, params)) {
                throw new SecurityException("回调签名验证失败");
            }
            
            // 处理支付结果
            result = paymentService.processCallback(gateway, params);
            
            if (result.isSuccess()) {
                attributes.addFlashAttribute("success", 
                    "支付成功！订单号：" + result.getOrderId());
                return "redirect:/order/" + result.getOrderId() + "/success";
            } else {
                attributes.addFlashAttribute("error", 
                    "支付失败：" + result.getMessage());
                return "redirect:/payment/retry?orderId=" + result.getOrderId();
            }
            
        } catch (Exception e) {
            logger.error("支付回调处理失败", e);
            attributes.addFlashAttribute("error", 
                "系统错误：" + e.getMessage());
            return "redirect:/payment/error";
        }
    }
}

五、转发 vs 重定向：如何选择？

5.1 核心区别对比表

5.2 决策流程图

5.3 场景化选择指南

场景1：展示用户个人资料

// ✅ 使用转发：URL保持/profile，用户体验更好
@GetMapping("/profile")
public String showProfile(Model model) {
    User user = userService.getCurrentUser();
    model.addAttribute("user", user);
    return "user/profile"; // 隐式转发
}

场景2：用户提交评论

// ✅ 使用重定向：防止刷新重复提交
@PostMapping("/comment")
public String addComment(Comment comment, RedirectAttributes attributes) {
    commentService.save(comment);
    attributes.addFlashAttribute("message", "评论成功！");
    return "redirect:/article/" + comment.getArticleId();
}

场景3：需要SEO友好的URL

// ✅ 使用重定向：将动态URL重定向到静态URL
@GetMapping("/product.php")
public String legacyProduct(@RequestParam Long id) {
    Product product = productService.getById(id);
    // 301永久重定向，利于SEO
    return "redirect:/product/" + product.getSlug();
}

六、高级技巧与最佳实践

6.1 统一重定向配置管理

@Component
public class RedirectConfig {
    
    /**
     * 重定向URL配置类
     * 集中管理所有重定向规则
     */
    @Configuration
    public static class RedirectConfiguration {
        
        @Bean
        public RedirectViewResolver redirectViewResolver() {
            RedirectViewResolver resolver = new RedirectViewResolver();
            resolver.setRedirectContextRelative(false);
            resolver.setRedirectHttp10Compatible(false);
            return resolver;
        }
    }
    
    /**
     * 重定向策略接口
     */
    public interface RedirectStrategy {
        String getRedirectUrl(HttpServletRequest request, 
                             Object result);
    }
    
    /**
     * 智能重定向策略
     */
    @Component
    public class SmartRedirectStrategy implements RedirectStrategy {
        
        @Override
        public String getRedirectUrl(HttpServletRequest request, 
                                   Object result) {
            
            String userAgent = request.getHeader("User-Agent");
            String accept = request.getHeader("Accept");
            
            // 移动端重定向到移动版
            if (isMobile(userAgent)) {
                return buildMobileRedirectUrl(request, result);
            }
            
            // API请求返回特定格式
            if (accept != null && accept.contains("application/json")) {
                return buildApiRedirectUrl(request, result);
            }
            
            // 默认重定向
            return buildDefaultRedirectUrl(request, result);
        }
        
        private boolean isMobile(String userAgent) {
            return userAgent != null && 
                  (userAgent.contains("Mobile") || 
                   userAgent.contains("Android") ||
                   userAgent.contains("iPhone"));
        }
    }
}

6.2 重定向链的安全处理

@Controller
public class SecureRedirectController {
    
    /**
     * 安全的开放重定向
     * 防止重定向攻击
     */
    @GetMapping("/redirect")
    public RedirectView safeRedirect(@RequestParam String url,
                                    HttpServletRequest request) {
        
        RedirectView redirectView = new RedirectView();
        
        // 1. 验证URL安全性
        if (!isUrlSafe(url)) {
            redirectView.setUrl("/error/invalid-redirect");
            return redirectView;
        }
        
        // 2. 设置安全属性
        redirectView.setUrl(url);
        redirectView.setContextRelative(false);
        redirectView.setHttp10Compatible(false);
        
        // 3. 添加安全头
        redirectView.addStaticAttribute("secure", "true");
        
        // 4. 记录重定向日志
        logRedirect(request.getRemoteAddr(), url);
        
        return redirectView;
    }
    
    /**
     * 白名单验证URL安全性
     */
    private boolean isUrlSafe(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }
        
        try {
            URI uri = new URI(url);
            
            // 不允许javascript协议
            if ("javascript".equalsIgnoreCase(uri.getScheme())) {
                return false;
            }
            
            // 白名单检查
            List<String> allowedDomains = Arrays.asList(
                "example.com",
                "trusted-partner.com",
                "localhost"
            );
            
            String host = uri.getHost();
            if (host != null) {
                for (String domain : allowedDomains) {
                    if (host.endsWith(domain)) {
                        return true;
                    }
                }
            }
            
            // 允许相对路径
            return uri.getHost() == null && uri.getPath() != null;
            
        } catch (URISyntaxException e) {
            return false;
        }
    }
}

6.3 性能优化策略

@Controller
public class OptimizedRedirectController {
    
    /**
     * 异步重定向处理
     * 适合耗时操作后的重定向
     */
    @PostMapping("/async-process")
    public CompletableFuture<String> asyncProcess(
            @RequestBody ProcessRequest request,
            RedirectAttributes attributes) {
        
        return CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            ProcessResult result = heavyProcessingService
                .process(request);
            
            // 在异步线程中设置Flash Attributes
            // 需要特殊处理，因为RedirectAttributes不是线程安全的
            String redirectKey = UUID.randomUUID().toString();
            cacheService.store(redirectKey, result);
            
            // 重定向到结果页面
            return "redirect:/process/result?key=" + redirectKey;
        });
    }
    
    /**
     * 批量操作的重定向优化
     */
    @PostMapping("/batch/operation")
    public String batchOperation(@RequestParam List<Long> ids,
                                RedirectAttributes attributes,
                                HttpSession session) {
        
        if (ids.size() > 100) {
            // 大数据量，使用异步处理+进度条
            String taskId = batchService.startBatchTask(ids);
            session.setAttribute("batchTaskId", taskId);
            return "redirect:/batch/progress?taskId=" + taskId;
        } else {
            // 小数据量，同步处理
            BatchResult result = batchService.process(ids);
            attributes.addFlashAttribute("result", result);
            return "redirect:/batch/result";
        }
    }
}

七、常见问题与解决方案

7.1 问题1：重定向后Flash Attributes丢失

解决方案：

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    
    /**
     * 配置Flash Attributes管理器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 确保FlashMapManager正确配置
        registry.addInterceptor(new HandlerInterceptor() {
            @Override
            public void postHandle(HttpServletRequest request, 
                                 HttpServletResponse response, 
                                 Object handler, 
                                 ModelAndView modelAndView) {
                // 确保Flash Attributes被保存
                if (modelAndView != null && 
                    modelAndView.getViewName() != null &&
                    modelAndView.getViewName().startsWith("redirect:")) {
                    
                    FlashMap flashMap = RequestContextUtils
                        .getOutputFlashMap(request);
                    if (flashMap != null && !flashMap.isEmpty()) {
                        RequestContextUtils.saveOutputFlashMap(
                            flashMap, request, response);
                    }
                }
            }
        });
    }
}

7.2 问题2：转发与重定向的URL解析差异

解决方案：

public class UrlResolutionUtil {
    
    /**
     * 统一URL解析工具
     */
    public static String resolveUrl(String url, 
                                   HttpServletRequest request,
                                   boolean isRedirect) {
        
        if (url == null) {
            return null;
        }
        
        if (isRedirect) {
            // 重定向URL处理
            return resolveRedirectUrl(url, request);
        } else {
            // 转发URL处理
            return resolveForwardUrl(url, request);
        }
    }
    
    private static String resolveRedirectUrl(String url, 
                                            HttpServletRequest request) {
        // 重定向URL需要完整路径
        if (url.startsWith("/")) {
            String contextPath = request.getContextPath();
            return contextPath + url;
        }
        return url;
    }
    
    private static String resolveForwardUrl(String url, 
                                           HttpServletRequest request) {
        // 转发URL使用服务器路径
        return request.getServletPath() + url;
    }
}

7.3 问题3：重定向循环检测

@Component
public class RedirectCycleDetector {
    
    private static final int MAX_REDIRECT_COUNT = 5;
    private static final String REDIRECT_COUNT_KEY = "redirectCount";
    
    /**
     * 检测和防止重定向循环
     */
    public boolean isRedirectCycle(HttpServletRequest request, 
                                  String targetUrl) {
        
        HttpSession session = request.getSession(false);
        if (session == null) {
            return false;
        }
        
        Integer redirectCount = (Integer) session
            .getAttribute(REDIRECT_COUNT_KEY);
        
        if (redirectCount == null) {
            redirectCount = 0;
        }
        
        // 检查是否超过最大重定向次数
        if (redirectCount >= MAX_REDIRECT_COUNT) {
            return true;
        }
        
        // 检查URL是否重复
        String lastRedirect = (String) session
            .getAttribute("lastRedirectUrl");
        
        if (targetUrl.equals(lastRedirect)) {
            return true;
        }
        
        // 更新计数和URL
        session.setAttribute(REDIRECT_COUNT_KEY, redirectCount + 1);
        session.setAttribute("lastRedirectUrl", targetUrl);
        
        return false;
    }
    
    /**
     * 重定向拦截器
     */
    @Component
    public class RedirectCycleInterceptor implements HandlerInterceptor {
        
        @Autowired
        private RedirectCycleDetector detector;
        
        @Override
        public boolean preHandle(HttpServletRequest request,
                               HttpServletResponse response,
                               Object handler) throws Exception {
            
            String requestUrl = request.getRequestURI();
            
            if (detector.isRedirectCycle(request, requestUrl)) {
                // 检测到循环，重定向到错误页
                response.sendRedirect("/error/redirect-loop");
                return false;
            }
            
            return true;
        }
    }
}

八、测试策略

8.1 转发测试

@SpringBootTest
@AutoConfigureMockMvc
class ForwardControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void testForward() throws Exception {
        mockMvc.perform(get("/forward/source"))
            .andExpect(status().isOk())
            .andExpect(forwardedUrl("/forward/target"))
            .andExpect(model().attributeExists("data"))
            .andExpect(view().name("forward:/forward/target"));
    }
}

8.2 重定向测试

@SpringBootTest
@AutoConfigureMockMvc
class RedirectControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void testRedirect() throws Exception {
        mockMvc.perform(post("/form/submit")
                .param("name", "test")
                .param("email", "test@example.com"))
            .andExpect(status().is3xxRedirection())
            .andExpect(redirectedUrl("/form/success"))
            .andExpect(flash().attributeExists("message"))
            .andExpect(flash().attribute("message", "提交成功"));
    }
    
    @Test
    void testRedirectWithMockSession() throws Exception {
        MockHttpSession session = new MockHttpSession();
        
        mockMvc.perform(get("/secure/content")
                .session(session))
            .andExpect(status().is3xxRedirection())
            .andExpect(redirectedUrlPattern("/login**"))
            .andExpect(request().sessionAttribute(
                "originalUrl", "/secure/content"));
    }
}

九、总结与最佳实践

9.1 核心要点回顾

1. 转发是服务器内部行为，重定向需要客户端参与
2. 转发保持URL不变，重定向改变浏览器地址
3. 转发共享Request对象，重定向需要额外传递数据
4. POST操作后必须使用重定向（PRG模式）
5. 外部跳转只能使用重定向

9.2 黄金法则

1. 展示用转发，提交用重定向
2. 内部流转用转发，外部跳转用重定向
3. 数据复杂用转发，简单传递用重定向
4. 保持URL用转发，改变地址用重定向

9.3 性能建议

1. 尽量减少重定向链的长度
2. 对高频转发路径进行缓存优化
3. 使用301代替302进行永久重定向
4. 避免在重定向URL中传递大量数据

9.4 安全建议

1. 始终验证重定向URL的安全性
2. 避免开放重定向漏洞
3. 敏感数据不要通过URL传递
4. 使用HTTPS进行安全重定向

十、总结

转发和重定向是Spring MVC中看似简单却蕴含深度的功能。正确使用它们不仅能提升用户体验，还能增强应用的安全性和可维护性。记住，没有绝对的好坏，只有适合的场景。在实际开发中，要根据具体需求选择最合适的方式。

随着Spring Framework的不断发展，这些机制也在不断进化。建议持续关注Spring官方文档和社区最佳实践，让你的应用始终保持最佳状态。

如需获取更多关于Spring MVC高级注解应用、处理器详情、视图解析策略及最佳实践技巧的深度解析，请持续关注本专栏《SpringMVC核心技术深度剖析》系列文章。