SpringMVC

SpringMVC

SpringMVC使用流程

  • 创建普通Maven项目并导入WEB相关组件

  • 添加SpringMVC依赖

    • <dependencies>
    <!-- Spring MVC 核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.23</version> <!-- 根据实际情况选择版本 -->
    </dependency>

    <!-- Servlet API 依赖 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope> <!-- 由 Servlet 容器提供 -->
    </dependency>
</dependencies>

  • 配置SpringMVC的**DispatcherServlet **和Spring容器

  • 编写代码启动应用进行测试

版本对应关系

Spring MVC 版本 JDK 版本 IDEA 版本 说明
Spring 5.3.x JDK 11 或 17 IDEA 2023.x 主流搭配，支持最新的 Java 和 Spring 特性。
Spring 5.2.x JDK 8 或 11 IDEA 2022.x 稳定搭配，适合生产环境。
Spring 4.x JDK 8 IDEA 2021.x 旧版本搭配，不推荐使用。
Spring Framework 版本 最低 JDK 版本要求 说明
Spring 5.x JDK 8 Spring 5.x 支持 JDK 8 及以上版本，推荐使用 JDK 11 或 JDK 17。
Spring 4.x JDK 6 Spring 4.x 支持 JDK 6 及以上版本，但已停止维护，不推荐使用。
Spring 3.x JDK 5 Spring 3.x 支持 JDK 5 及以上版本，已停止维护，不推荐使用。
IDEA 版本 支持的 JDK 版本范围 说明
IDEA 2023.x JDK 8 到 JDK 20 支持最新的 JDK 版本（如 JDK 17、JDK 20）。
IDEA 2022.x JDK 8 到 JDK 19 支持 JDK 17 和 JDK 19。
IDEA 2021.x JDK 8 到 JDK 17 支持 JDK 11 和 JDK 17。
IDEA 2020.x JDK 8 到 JDK 15 支持 JDK 11 和 JDK 15。

MVC架构模式

  • MVC（Model-View-Controller）是一种常见的软件设计模式，广泛应用于用户界面和应用程序的开发中。它将应用程序分为三个核心部分：Model（模型）、View（视图）和Controller（控制器），以实现关注点分离，提升代码的可维护性和可扩展性

MVC 的核心组件

  • Model（模型）

    • 职责：负责管理应用程序的核心数据和业务逻辑。
    • 功能：
      • 存储数据（如数据库、文件等）。
      • 处理数据的增删改查（CRUD）操作。
      • 实现业务规则和逻辑。
    • 特点：
      • 独立于用户界面，不直接与用户交互。
      • 通常通过事件或通知机制与View和Controller通信。

  • View（视图）

    • 职责：负责数据的展示和用户界面的呈现。
    • 功能：
      • 从Model获取数据并展示给用户。
      • 提供用户交互界面（如按钮、表单等）。
    • 特点：
      • 不直接处理业务逻辑。
      • 通常是被动的，依赖Model或Controller更新数据。

  • Controller（控制器）

    • 职责：作为Model和View之间的桥梁，处理用户输入并更新Model和View。
    • 功能：
      • 接收用户输入（如点击、表单提交等）。
      • 调用Model处理业务逻辑。
      • 更新View以反映Model的变化。
    • 特点：
      • 处理用户交互和应用程序逻辑。
      • 通常包含事件处理逻辑。

SpringMVC概念

  • Spring MVC 是 Spring 框架中的一个模块，用于构建基于 MVC（Model-View-Controller）设计模式的 Web 应用程序。它提供了强大的功能来开发灵活、松耦合的 Web 应用。
  • Spring MVC 的核心是基于 MVC 设计模式，将应用程序分为三个部分：
    • Model（模型）：负责封装应用程序的数据和业务逻辑。
    • View（视图）：负责渲染模型数据，生成用户界面（如 JSP、Thymeleaf 等）。
    • Controller（控制器）：负责处理用户请求，调用业务逻辑，并返回合适的视图。

Spring MVC 的工作流程

  • 用户发送请求：
    • 用户通过浏览器发送 HTTP 请求到服务器。
  • DispatcherServlet 接收请求：
    • Spring MVC 的核心是 DispatcherServlet，它充当前端控制器，接收所有请求。
  • HandlerMapping 查找处理器：
    • DispatcherServlet 通过 HandlerMapping 查找适合处理当前请求的控制器（Controller）。
  • Controller 处理请求：
    • 控制器调用业务逻辑，处理请求，并返回一个 ModelAndView 对象（包含模型数据和视图名称）。
  • ViewResolver 解析视图：
    • DispatcherServlet 通过 ViewResolver 解析视图名称，找到具体的视图（如 JSP 文件）。
  • 视图渲染：
    • 视图使用模型数据渲染用户界面，并将结果返回给客户端。

Spring MVC的核心组件

  • DispatcherServlet

    • 前端控制器，负责接收所有请求并将其分发给合适的处理器。

  • HandlerMapping

    • 负责将请求映射到对应的控制器（Controller）。

  • HandlerInterceptor

    • 拦截器，用于在请求处理前后执行额外的逻辑（如权限检查、日志记录等）。

  • Controller

    • 处理用户请求，调用业务逻辑，并返回 ModelAndView。

  • ModelAndView

    • 包含模型数据（Model）和视图名称（View）。

  • ViewResolver

    • 负责将视图名称解析为具体的视图（如 JSP 文件）。

  • View

    • 负责渲染模型数据，生成用户界面。

SpringMVCBean的作用域

作用域类型 说明
singleton 默认作用域，每个 Spring 容器中只有一个 Bean 实例。
prototype 每次请求时都会创建一个新的 Bean 实例。
request 每个 HTTP 请求都会创建一个新的 Bean 实例，仅适用于 Web 应用。
session 每个 HTTP Session 都会创建一个新的 Bean 实例，仅适用于 Web 应用。
application 每个 ServletContext 生命周期内只有一个 Bean 实例，仅适用于 Web 应用。
websocket 每个 WebSocket 会话内只有一个 Bean 实例，仅适用于 WebSocket 应用。

  • Spring容器指定作用域

    • @Component
@Scope("singleton") // 默认作用域，可省略
public class MySingletonBean {
    // Bean 内容
}

@Component
@Scope("prototype")
public class MyPrototypeBean {
    // Bean 内容
}

  • SpringMVC指定作用域

    • @Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyRequestBean {
    // Bean 内容
}

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MySessionBean {
    // Bean 内容
}

@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyApplicationBean {
    // Bean 内容
}

SpringMVC的配置

  • SpringMVC是基于Spring容器的，通过DispatcherServlet接收该应用内所有请求并通过映射器在Spring容器中寻找对应的Servlet
  • 所以SpringMVC中的DispatcherServlet需要知道Spring容器的位置
  • SpringMVC需要的视图解析器等对象配置在Spring容器中即可

XML配置

  • 首先配置DispatcherServlet

    • 由于DispatcherServlet需要接收所有请求，所以在应用内的 web.xml 中配置 DispatcherServlet

    • <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-mvc-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

    • 这其中的初始化参数就是Spring容器配置文件的位置

  • 配置Spring容器

    • Spring容器中一般不使用xml配置Servlet相关的Bean，而直接使用Spring注解配置相应的Bean，所以配置包扫描和其他的一些总体配置信息即可

    • SpringMVC中的视图渲染等对象可以在Spring容器中进行配置

    • <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 启用组件扫描，扫描控制器 -->
    <context:component-scan base-package="com.example.controller" />

    <!-- 启用注解驱动 -->
    <mvc:annotation-driven />

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 配置静态资源处理 -->
    <mvc:resources mapping="/static/**" location="/static/" />

    <!-- 配置拦截器 -->
    <mvc:interceptors>
        <bean class="com.example.interceptor.CustomInterceptor" />
    </mvc:interceptors>

</beans>

注解配置

  • 配置DispatcherServlet

    • 在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。

    • 当你创建一个类并继承 AbstractAnnotationConfigDispatcherServletInitializer，并将其部署到支持 Servlet 3.0 的容器（如 Tomcat 7+）时，Servlet 容器会自动检测到这个类，并使用它来配置 Spring MVC 的 DispatcherServlet 和 Spring 的根应用上下文。

      • 替代传统的 web.xml 文件，通过 Java 代码配置 DispatcherServlet 和 Spring 上下文。
      • 自动注册 DispatcherServlet 并将其映射到指定的 URL 模式。
    • package com.example.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    // 配置根应用上下文（非 Web 相关的 Bean，如服务层、数据层）
    //这个就是配置Spring容器，指定为配置Spring容器的配置类即可
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { RootConfig.class };
    }

    // 配置 Web 应用上下文（Web 相关的 Bean，如控制器、视图解析器等）
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebConfig.class };
    }

    // 配置 DispatcherServlet 的映射路径
    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }
}

  • 配置Spring容器

    • 将服务层等非web相关组件放到Spring容器的注解类中，配置在根方法中

      • @Configuration
@ComponentScan(basePackages = "com.example.service")
public class SpringConfig {
    // 配置数据源、事务管理器等
}

    • 将web相关组件如视图解析器、拦截器等放到实现WebMvcConfigurer的webConfig类中

      • 将class文件信息配置在dispatcherServlet相关方法中
      • 注意在该配置类中开启MVC的注解驱动
    • package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.controller")
public class WebConfig implements WebMvcConfigurer {

    // 配置视图解析器
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }

    // 配置静态资源处理
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("/static/");
    }

    // 配置拦截器（可选）
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CustomInterceptor());
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer 	configurer) {
        configurer.enable(); // 启用 DefaultServlet
    }
    
}

SpringMVC的相关注解

核心注解

  • @Controller

    • 作用：标记一个类为 Spring MVC 的控制器。

    • 说明：被 @Controller 标记的类会被 Spring 扫描并注册为 Bean，用于处理 HTTP 请求。

    • @Controller
public class HelloController {
    // 处理方法
}

    • @Controller本身没有属性，它只是一个标记注解。

    • @Controller的value属性是从@Component继承而来的，用于指定Bean的名称（默认通常为类名的首字母小写）

    • 如果指定类级别的URL路径在类上使用RequestMapping注解即可

    • @Controller
@RequestMapping("/user")
public class UserController {
	// 处理方法
}

  • @RestController

    • 作用：组合了 @Controller 和 @ResponseBody，用于开发 RESTful Web 服务。

    • 说明：被 @RestController 标记的类中的所有方法都会将返回值直接写入 HTTP 响应体，而不是跳转到视图。

    • @RestController
public class ApiController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

  • @RequestMapping

    • 作用：将 HTTP 请求映射到控制器方法。

    • 属性：

      • value：指定请求的 URL 路径。

        • @RequestMapping("/")仅匹配根路径 /，不会匹配子路径
        • 匹配优先级
          • 精确匹配优先：
            • 如果请求路径与某个 @RequestMapping 完全匹配，则优先调用该方法。
          • 通配符匹配：
            • 如果没有精确匹配，Spring MVC 会尝试匹配通配符路径（如 /**）。
            • 请求 /user/123 可能会匹配到 @RequestMapping("/user/**")。
          • 根路径匹配：
            • 如果没有其他匹配，请求 / 会匹配到 @RequestMapping("/")。

      • method：指定请求的 HTTP 方法（如 GET、POST 等）。

      • @Controller
public class HelloController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String hello() {
        return "hello";
    }
}

      • @RequestMapping 的 value 或 path 属性可以接受一个字符串数组，从而映射多个路径

      • @Controller
public class MultiPathController {

    @RequestMapping(value = {"/home", "/index", "/"})
    public String home() {
        return "home";
    }
}

      • 路径通配符

        • * 通配符，匹配任意数量的字符（不包括路径分隔符 /）单级目录
        • ** 通配符，匹配任意数量的字符，包括路径分隔符 /。多级目录

        • ? 通配符，匹配单个字符。

        • {variable} 路径变量

          • 匹配路径中的某一部分，并将其作为变量传递给方法。

          • @RequestMapping(value = "/user/{userId}")
public String getUser(@PathVariable String userId) {
    return "userProfile";
}

        • {variable:regex} 带正则表达式的路径变量

          • 匹配路径中的某一部分，并使用正则表达式进行约束。

          • @RequestMapping(value = "/user/{userId:\\d+}")
public String getUser(@PathVariable String userId) {
    return "userProfile";
}

    • @RequestMapping 中的常用属性

      • value 或 path

        • 指定请求的 URL 路径。
        • 可以是一个字符串或字符串数组。
        • 如果映射多个路径，可以使用数组形式。

      • method

        • 指定处理的 HTTP 方法（如 GET、POST、PUT、DELETE 等）
        • 默认情况下，@RequestMapping 支持所有 HTTP 方法。
        • 可以通过 RequestMethod 枚举指定具体的 HTTP 方法。

      • params

        • 指定请求必须包含的参数。

        • 支持简单的表达式（如 paramName、!paramName、paramName=value）。

        • 如果请求不满足参数条件，Spring MVC 会返回 400 错误（Bad Request）。

        • 可以绑定多个条件

        • //请求中必须包含指定的参数，但参数值可以是任意值。
@RequestMapping(value = "/user", params = "id")
public String getUserById(@RequestParam("id") int id) {
    return "user";
}

//请求中必须不包含指定的参数。
@RequestMapping(value = "/user", params = "!id")
public String getUserWithoutId() {
    return "user";
}

//请求中必须包含指定的参数，并且参数值必须等于指定的值。
@RequestMapping(value = "/user", params = "id=123")
public String getUserWithSpecificId() {
    return "user";
}

      • headers

        • 指定请求必须包含的 HTTP 头。

        • 支持简单的表达式（如 headerName、!headerName、headerName=value）。

        • 如果请求不满足头条件，Spring MVC 会返回 404 错误（Not Found）。

        • @RequestMapping(value = "/header", headers = "content-type=text/*")
public String header() {
    return "header";
}

@RequestMapping(value = "/header", headers = "!content-type")
public String headerWithoutContentType() {
    return "header";
}

      • consumes

        • 指定请求的媒体类型（Content-Type）。

        • 通常用于限制请求体的格式（如 application/json、application/xml）。

        • 如果请求的 Content-Type 不匹配，Spring MVC 会返回 415 错误（Unsupported Media Type）。

        • @RequestMapping(value = "/consume", consumes = "application/json")
public String consumeJson() {
    return "consume";
}

@RequestMapping(value = "/consume", consumes = {"application/json", "application/xml"})
public String consumeJsonOrXml() {
    return "consume";
}

  • @GetMapping、@PostMapping、@PutMapping、@DeleteMapping

    • 作用：@RequestMapping 的简化版本，分别用于处理 GET、POST、PUT、DELETE 请求。

    • @RestController
public class ApiController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, GET!";
    }

    @PostMapping("/hello")
    public String helloPost() {
        return "Hello, POST!";
    }
}

获取传递参数

使用 @RequestParam

  1. 将 URL 中的查询参数绑定到方法参数。

    • 常用属性：

      • value 或 name：参数名称。
      • required：是否必须（默认 true）。
      • defaultValue：默认值。
    • @GetMapping("/user")
public String getUser(@RequestParam("id") int id) {
    return "User ID: " + id;
}

    • 访问路径：/user?id=123，id 参数会被绑定到方法参数。

  2. 将所有查询参数绑定到一个 Map 或 MultiValueMap。

    • @GetMapping("/user")
public String getUser(@RequestParam Map<String, String> params) {
    return "Params: " + params.toString();
}

    • 访问路径：/user?id=123&name=John，所有参数会被绑定到 params。

  3. 获取表单参数（Form Data）

    • 将表单字段绑定到方法参数。

    • @PostMapping("/user")
public String addUser(@RequestParam("name") String name, @RequestParam("age") int age) {
    return "User Name: " + name + ", Age: " + age;
}

    • 表单数据：name=John&age=30，name 和 age 参数会被绑定到方法参数。

使用 @PathVariable

  • 将 URL 路径中的变量绑定到方法参数。

    • @GetMapping("/user/{id}")
public String getUser(@PathVariable("id") int id) {
    return "User ID: " + id;
}

    • 访问路径：/user/123，id 参数会被绑定到方法参数。

  • 获取多个路径变量

    • @GetMapping("/user/{id}/name/{name}")
public String getUser(@PathVariable("id") int id, @PathVariable("name") String name) {
    return "User ID: " + id + ", Name: " + name;
}

    • 访问路径：/user/123/name/John，id 和 name 参数会被绑定到方法参数。

  • 绑定到对象(隐式绑定)

    • Spring 会自动将表单字段映射到对象的属性。

    • public class User {
    private String name;
    private int age;
    // getters and setters
}

@PostMapping("/user")
public String createUser(User user) {
    return "User created: " + user.getName() + ", " + user.getAge();
}

使用 @ModelAttribute

  • 将表单字段绑定到一个对象。（显示绑定）

    • @PostMapping("/user")
public String addUser(@ModelAttribute User user) {
    return "User: " + user.toString();
}

    • 表单数据：name=John&age=30，User 对象的 name 和 age 属性会被自动填充。

获取一些特殊值

获取 JSON 或 XML 数据（Request Body）

  • 使用 @RequestBody

    • 将请求体中的数据绑定到一个对象。

    • @PostMapping("/user")
public String addUser(@RequestBody User user) {
    return "User: " + user.toString();
}

    • 请求体：{"name": "John", "age": 30}，User 对象会被自动反序列化。

获取请求头（Request Headers）

  • 使用 @RequestHeader

    • 将请求头绑定到方法参数。

    • @GetMapping("/header")
public String getHeader(@RequestHeader("User-Agent") String userAgent) {
    return "User-Agent: " + userAgent;
}

    • 请求头：User-Agent: Mozilla/5.0，userAgent 参数会被绑定到方法参数。

获取Cookie值

  • 使用 @CookieValue

    • 将 Cookie 值绑定到方法参数。

    • @GetMapping("/cookie")
public String getCookie(@CookieValue("JSESSIONID") String sessionId) {
    return "Session ID: " + sessionId;
}
@CookieValue(name = "JSESSIONID", required = false) String sessionId

    • Cookie：JSESSIONID=12345，sessionId 参数会被绑定到方法参数。

      • @CookieValue 用于从请求中获取指定名称的 Cookie 值。
      • 如果 Cookie 不存在，会抛出异常。
      • 可以通过 required = false 设置为非必需：

获取文件上传数据

  • 使用 @RequestParam 和 MultipartFile

    • 将上传的文件绑定到 MultipartFile 对象。

    • @PostMapping("/upload")
public String uploadFile(@RequestParam("file") MultipartFile file) {
    return "File Name: " + file.getOriginalFilename();
}

获取 Servlet 原生对象

  • 使用 HttpServletRequest 和 HttpServletResponse

    • 直接获取 HttpServletRequest 或 HttpServletResponse 对象。

    • @GetMapping("/request")
public String getRequestInfo(HttpServletRequest request, HttpServletResponse response) {
    return "Request URI: " + request.getRequestURI();
}

获取Session数据

  • 通过 @SessionAttribute 获取 Session 数据

    • @SessionAttribute 注解可以直接将 Session 中的数据绑定到控制器方法的参数中。

    • @GetMapping("/user")
public String getUser(@SessionAttribute("username") String username) {
    return "Username: " + username;
}

@SessionAttribute(name = "username", required = false) String username
      • @SessionAttribute 用于从 Session 中获取指定键的值。
      • 如果 Session 中不存在指定的键，会抛出异常。
      • 可以通过 required = false 设置为非必需：

  • 使用 HttpSession

    • 直接获取 HttpSession 对象。

    • @GetMapping("/session")
public String getSessionInfo(HttpSession session) {
    session.setAttribute("user", "John");
    return "Session User: " + session.getAttribute("user");
}

返回数据

  • 直接返回字符串，默认为视图名称

  • 返回带模型数据的视图名称

    • 返回视图名称的同时，向视图传递模型数据。

    • @GetMapping("/user")
public String getUser(Model model) {
    model.addAttribute("name", "John");
    return "user"; // 返回视图名称 "user"，并传递模型数据
}

  • 返回模型和视图

    • 返回一个 ModelAndView 对象，包含视图名称和模型数据。

    • @GetMapping("/user")
public ModelAndView getUser() {
    ModelAndView modelAndView = new ModelAndView("user"); // 视图名称
    modelAndView.addObject("name", "John"); // 模型数据
    return modelAndView;
}

返回JSON数据

  • 使用 @ResponseBody

    • 将方法的返回值直接写入 HTTP 响应体，通常用于返回 JSON 或 XML 数据。

    • 明确返回了一个 User 对象，Spring MVC 会使用默认的 HttpMessageConverter（通常是 MappingJackson2HttpMessageConverter）将 User 对象转换为 JSON 格式。

    • Jackson依赖对象的Getter方法来序列化对象。如果类中没有公共的Getter方法，Jackson将无法正确序列化对象。

      • <mvc:annotation-driven />：这个注解会自动注册消息转换器，但不会引入 Jackson 依赖。
      • Jackson 依赖：需要手动添加到 pom.xml 中。
      • 消息转换器机制：Spring MVC 检测到 Jackson 依赖后，会自动注册 MappingJackson2HttpMessageConverter。
    • @GetMapping("/user")
@ResponseBody
public User getUser() {
    return new User(1, "John"); // 返回 User 对象，Spring 会自动转换为 JSON
}

  • 使用 @RestController

    • @RestController 是 @Controller 和 @ResponseBody 的组合，所有方法的返回值都会直接写入响应体。

    • @RestController
public class UserController {
    @GetMapping("/user")
    public User getUser() {
        return new User(1, "John");
    }
}

请求转发

  • 使用 forward: 前缀

    • 客户端浏览器地址栏不会改变。

    • 转发后的目标方法可以访问原始请求的数据。

    • @GetMapping("/forward")
public String forward() {
    return "forward:/target"; // 转发到 /target
}

@GetMapping("/target")
public String target() {
    return "target"; // 返回视图名称 "target"
}

重定向

  • 使用 redirect: 前缀

    • 返回一个重定向 URL，客户端会重新请求该 URL。

    • @GetMapping("/redirect")
public String redirect() {
    return "redirect:/home"; // 重定向到 /home
}

  • 使用 RedirectAttributes

    • 在重定向时传递数据。

    • @GetMapping("/redirect")
public String redirect(RedirectAttributes redirectAttributes) {
    redirectAttributes.addAttribute("name", "John"); // 添加到 URL 参数
    redirectAttributes.addFlashAttribute("message", "Success"); // 添加到 Flash 属性
    return "redirect:/home";
}
posted @ 2025-03-18 15:29  QAQ001  阅读(36)  评论(0)    收藏  举报