SpringMVC基础

最新推荐文章于 2024-12-23 15:47:03 发布
原创 最新推荐文章于 2024-12-23 15:47:03 发布 · 152 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

SpringMVC基础

一、MVC 思想 & SpringMVC 框架概念与特点

1.MVC是什么

模型-视图-控制器（MVC）是以设计界⾯应⽤程序为基础的设计思想。

主要通过分离模型、视图及控制器在应⽤程序中的⻆⾊将业务逻辑从界⾯中解耦。

通常，模型负责封装应⽤程序数据在视图层展⽰，视图仅仅只是展⽰这些数据，不包含任何业务逻辑。

控制器负责接收来⾃⽤⼾的请求，并调⽤后台服务（service或者dao）来处理业务逻辑。

处理后，后台业务层可能会返回了⼀些数据在视图层展⽰。

控制器收集这些数据及准备模型在视图层展⽰。

MVC模式的核⼼思想是将业务逻辑从界⾯中分离出来，允许它们单独改变⽽不会相互影响。

2.常⻅MVC框架运⾏性能⽐较

Jsp+servlet > struts1 > spring mvc > struts2+freemarker > struts2,ognl,值栈。

开发效率上,基本正好相反。值得强调的是，spring mvc开发效率和struts2不相上下，但从⽬前来看，spring mvc的流⾏度已远远超过struts2。

3.Spring MVC是什么

​ Spring MVC是Spring家族中的⼀个web成员，它是⼀种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使⽤了MVC架构模式的思想，将web层进⾏职责解耦，基于请求驱动指的就是使⽤请求-响应模型，框架的⽬的就是帮助我们简化开发，Spring MVC也是要简化我们⽇常Web开发的。

​ Spring MVC是服务到⼯作者思想的实现。前端控制器是DispatcherServlet；应⽤控制器拆为处理器映射器(Handler Mapping)进⾏处理器管理和视图解析器(View Resolver)进⾏视图管理；⽀持本地化/国际化（Locale）解析及⽂件上传等；提供了⾮常灵活的数据验证、格式化和数据绑定机制；提供了强⼤的约定⼤于配置（惯例优先原则）的契约式编程⽀持。

4.Spring MVC能帮我们做什么?

  1. 让我们能⾮常简单的设计出⼲净的Web层；
  2. 进⾏更简洁的Web层的开发；
  3. 天⽣与Spring框架集成（如IOC容器、AOP等）；
  4. 提供强⼤的约定⼤于配置的契约式编程⽀持；
  5. 能简单的进⾏Web层的单元测试；
  6. ⽀持灵活的URL到⻚⾯控制器的映射；
  7. ⾮常容易与其他视图技术集成，如jsp、Velocity、FreeMarker等等，因为模型数据不放在特定的API⾥，⽽是放在⼀个Model⾥（Map数据结构实现，因此很容易被其他框架使⽤）；
  8. ⾮常灵活的数据验证、格式化和数据绑定机制，能使⽤任何对象进⾏数据绑定，不必实现特定框架的API；
  9. ⽀持灵活的本地化等解析；
  10. 更加简单的异常处理；
  11. 对静态资源的⽀持；
  12. ⽀持Restful⻛格。

二、SpringMVC 请求流程 & 环境搭建

1.Spring MVC 请求处理流程分析

​ Spring MVC框架也是⼀个基于请求驱动的Web框架，并且使⽤了前端控制器模式（是⽤来提供⼀个集中的请求处理机制，所有的请求都将由⼀个单⼀的处理程序处理来进⾏设计，再根据请求映射规则分发给相应的⻚⾯控制器（动作/处理器）进⾏处理。

  1. ⾸先⽤⼾发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；

  2. 前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调⽤HandlerMapping；

  3. 前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及Handler对象对应的拦截器）；

  4. DispatcherServlet 根据获得的HandlerExecutionChain，选择⼀个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执⾏拦截器的preHandler(…)⽅法）；

  5. HandlerAdapter根据请求的Handler适配并执⾏对应的Handler；HandlerAdapter(提取Request中的模型数据，填充Handler⼊参，开始执⾏Handler（Controller)。 在填充Handler的⼊参过程中，根据配置，Spring将做⼀些额外的⼯作：

​ HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成⼀个对象，将对象转换为指定的响应信息。

​ 数据转换：对请求消息进⾏数据转换。如String转换成Integer、Double等数据格式化：数据格式化。 如将字符串转换成格式化数字或格式化⽇期等

​ 数据验证： 验证数据的有效性（⻓度、格式等），验证结果存储到BindingResult或Error中）

  1. Handler执⾏完毕，返回⼀个ModelAndView(即模型和视图)给HandlerAdaptor

  2. HandlerAdaptor适配器将执⾏结果ModelAndView返回给前端控制器。

  3. 前端控制器接收到ModelAndView后，请求对应的视图解析器。

  4. 视图解析器解析ModelAndView后返回对应View;

  5. 渲染视图并返回渲染后的视图给前端控制器。

  6. 最终前端控制器将渲染后的⻚⾯响应给⽤⼾或客⼾端

2.Spring MVC 优势

  1. 清晰的⻆⾊划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或⻚⾯控制器（Controller）、验证器（Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供
    给表单展⽰和提交到的对象就叫表单对象）。
  2. 分⼯明确，⽽且扩展点相当灵活，可以很容易扩展，虽然⼏乎不需要；
  3. 和Spring 其他框架⽆缝集成，是其它Web框架所不具备的；
  4. 可适配，通过HandlerAdapter可以⽀持任意的类作为处理器；
  5. 可定制性，HandlerMapping、ViewResolver等能够⾮常简单的定制；
  6. 功能强⼤的数据验证、格式化、绑定机制；
  7. 利⽤Spring提供的Mock对象能够⾮常简单的进⾏Web层单元测试；
  8. 本地化、主题的解析的⽀持，使我们更容易进⾏国际化和主题的切换。
  9. 强⼤的JSP标签库，使JSP编写更容易。

​ 还有⽐如RESTful（⼀种软件架构⻛格，设计⻛格⽽不是标准，只是提供了⼀组设计原则和约束条件。它主要⽤于客⼾端和服务器交互类的软件，⽬前了解即可）⻛格的⽀持、简单的⽂件上传、约定⼤于配置的契约式编程⽀持、基于注解的零配置⽀持等等。

3.Spring MVC 环境搭建

开发环境

Idea + Maven + Jdk1.8 + Jetty

pom.xml 坐标添加
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- spring web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring mvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- web servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 添加json 依赖jar包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.0</version>
    </dependency>


  </dependencies>

  <build>
    <finalName>springmvc01</finalName>

    <plugins>
      <!-- 编译环境插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <!-- jetty插件 -->
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>9.4.27.v20200227</version>
        <configuration>
          <scanIntervalSeconds>10</scanIntervalSeconds>
          <!-- 设置端口 -->
          <httpConnector>
            <port>8080</port>
          </httpConnector>
          <!-- 设置项目路径 -->
          <webAppConfig>
            <contextPath>/springmvc01</contextPath>
          </webAppConfig>
        </configuration>
      </plugin>
    </plugins>

  </build>
配置 web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <!-- 编码过滤 utf-8 -->
  <filter>
    <description>char encoding filter</description>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- servlet请求分发器 -->
  <servlet>
    <servlet-name>springMvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:servlet-context.xml</param-value>
    </init-param>
    <!-- 表示启动容器时初始化该Servlet -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMvc</servlet-name>
    <!-- 这是拦截请求， "/"代表拦截所有请求，"*.do"拦截所有.do请求 -->
     <url-pattern>/</url-pattern>
    <!--<url-pattern>*.do</url-pattern>-->
  </servlet-mapping>
</web-app>
servlet-context.xml 配置
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        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">

    <!-- 开启扫描器 -->
    <context:component-scan base-package="com.xxxx.springmvc.controller"/>

    <!-- 使用默认的 Servlet 来响应静态文件 -->
    <mvc:default-servlet-handler/>

    <!-- 开启注解驱动-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter" />
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀：在WEB-INF目录下的jsp目录下 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：以.jsp结尾的资源 -->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>
页面控制器的编写
/**
 * 页面控制器
 */
@Controller
public class HelloController {

    /**
     * 请求地址映射
     *      /hello.do
     * @return
     */
    @RequestMapping("/hello")
    public ModelAndView hello(){

        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","Hello SpringMVC");
        // 设置视图名称
        modelAndView.setViewName("hello");
        // 返回
        return modelAndView;
    }


}
添加视图页面

在 WEB-INF 下新建 jsp ⽂件夹 ，并在⽂件夹下新建 hello.jsp

<%@page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML>
<html>
<head>
    <base href="<%=basePath %>">
    <title>My JSP 'hello.jsp' starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
</head>
<body>
    <!-- el表达式接收参数值 -->
    ${hello}
</body>
</html>

三、URL 地址映射配置 & 参数绑定

1.URL 地址映射配置之 @RequestMapping

通过注解 @RequestMapping 将请求地址与⽅法进⾏绑定，可以在类级别和⽅法级别声明。类级别的注解负责将⼀个特定的请求路径映射到⼀个控制器上，将 url 和类绑定；通过⽅法级别的注解可以细化映射，能够将⼀个特定的请求路径映射到某个具体的⽅法上，将 url 和类的⽅法绑定。

映射单个 URL
 /**
     * 声明在方法上，映射单个 URL
     *      使用方式：
     *          1.  @RequestMapping("/test01")
     *          2.  @RequestMapping(value = "/test01")
     *      访问地址：（如果类上声明了注解，需要在方法路径前添加类路径）
     *          http://localhost:8080/springmvc01/test01
     * @return
     */
    // @RequestMapping("/test01")
    @RequestMapping(value = "/test01")
    public ModelAndView test01(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test01");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

    /**
     * 路径开头是否添加 斜杆"/" 均可
     *      @RequestMapping("请求路径") 或  @RequestMapping("/请求路径") 均可
     *      建议加上，如：@RequestMapping("/test02")
     *      访问地址：（如果类上声明了注解，需要在方法路径前添加类路径）
     *          http://localhost:8080/springmvc01/test02
     *
     * @return
     */
    @RequestMapping("test02")
    public ModelAndView test02(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test02");
        modelAndView.setViewName("hello");
        return modelAndView;
    }
映射多个 URL
/**
     * 声明在方法上，映射多个 URL
     *      支持一个方法绑定多个URL的操作
     *      使用方式：
     *          1.  @RequestMapping({"/test03_01","test03_02"})
     *          2.  @RequestMapping(value = {"/test03_01","test03_02"})
     *      访问地址：（如果类上声明了注解，需要在方法路径前添加类路径）
     *          http://localhost:8080/springmvc01/test03_01
     *          http://localhost:8080/springmvc01/test03_02
     * @return
     */
    // @RequestMapping({"/test03_01","test03_02"})
    @RequestMapping(value = {"/test03_01","test03_02"})
    public ModelAndView test03(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test03");
        modelAndView.setViewName("hello");
        return modelAndView;
    }
映射 URL 在控制器上

⽤于类上，表⽰类中的所有响应请求的⽅法都是以该地址作为⽗路径。

/**
 * @RequestMapping
 *      通过注解 @RequestMapping 将请求路径与方法进行绑定，可以声明在方法级别和类级别。
 *      使用方式：
 *          @RequestMapping("/请求路径")
 *      声明级别：
 *          1. 方法级别
 *          2. 类级别 + 方法级别
 */
@Controller
@RequestMapping("/url")
public class UrlController {
    /**
     * 声明在类上，类中的方法都要以该路径作为父路径
     *      声明级别：
     *          类级别 + 方法级别  （/类路径/方法路径）
     *      访问地址：
     *          http://localhost:8080/springmvc01/url/test04
     * @return
     */
    @RequestMapping("/test04")
    public ModelAndView test04(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test04");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

}
设置 URL 映射的请求⽅式

默认没有设置请求⽅式，在HTTP 请求中最常⽤的请求⽅法是 GET、POST，还有其他的⼀些⽅法，如：DELET、PUT、HEAD 等。

可以通过 method 属性设置⽀持的请求⽅式，如 method=RequestMethod.POST；如设置多种请求⽅式，以⼤括号包围，逗号隔开即可。

 /**
     * 设置请求方式
     *      通过method属性设置请求方式，默认 GET和POST等请求方式都支持。
     *      如果设置了请求方式，则必须通过指定请求方式访问。
     *      访问地址：（只能通过POST请求访问）
     *          http://localhost:8080/springmvc01/url/test06
     * @return
     */
    @RequestMapping(value = "test06",method = RequestMethod.POST)
    public ModelAndView test06(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test06");
        modelAndView.setViewName("hello");
        return modelAndView;
    }
通过参数名称映射 URL
    /**
     * 通过参数名称访问
     *      通过参数的形式访问
     *      访问地址：
     *         http://localhost:8080/springmvc01/url?test05
     * @return
     */
    @RequestMapping(params = "test05")
    public ModelAndView test05(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("hello","test05");
        modelAndView.setViewName("hello");
        return modelAndView;
    }

2.参数绑定

客⼾端请求的参数到控制器功能处理⽅法上的参数的绑定，对于参数绑定⾮常灵活。

参数绑定：

​ 1. 基本类型 （包装类型）

​ 2. 字符串类型

​ 3. 数组类型

​ 4. JavaBean

​ 5. 集合 List/Set/Map （了解）

基本数据类型
 /**
     * 基本类型数据绑定
     *      参数值必须存在。如果参数值不存在，也没有设置默认值，则会报500异常
     * @param age
     * @param money
     */
    @RequestMapping("/data01")
    public void data01(int age, double money){
        System.out.println("age:" + age + "，money:" + money);
    }

    /**
     * 基本类型数据绑定
     *      通过注解 @RequestParam 标记一个形参作为请求参数。（注解声明在形参前面）
     *      可以通过注解的属性设置相关内容
     *          设置参数的默认值  defaultValue属性 （避免基本类型的数据为空时的500异常！）
     * @param age
     * @param money
     */
    @RequestMapping("/data02")
    public void data02(@RequestParam(defaultValue = "18") int age,
                       @RequestParam(defaultValue = "20.0") double money){
        System.out.println("age:" + age + "，money:" + money);
    }

    /**
     * 基本类型数据绑定
     *      通过注解 @RequestParam 标记一个形参作为请求参数。（注解声明在形参前面）
     *      可以通过注解的属性设置相关内容
     *          设置参数的默认值  defaultValue属性 （避免基本类型的数据为空时的500异常！）
     *          设置参数的参数名（参数的别名）   name属性 （如果设置了别名，客户端传递的参数名 要与别名保持一致）
     * @param age
     * @param money
     */
    @RequestMapping("/data03")
    public void data03(@RequestParam(defaultValue = "18", name = "userAge") int age,
                       @RequestParam(defaultValue = "20.0", name = "userMoney") double money){
        System.out.println("age:" + age + "，money:" + money);
    }
包装类型
 /**
     * 包装类型数据绑定
     *      请求的参数名要与方法的形参名保持一致（在未设置别名的情况下），默认值为null
     *      可以通过注解 @RequestParam 的属性设置 默认值 和 别名
     * @param age
     * @param money
     */
    @RequestMapping("/data04")
    public void data04(Integer age, Double money){
        System.out.println("age:" + age + "，money:" + money);
    }
字符串类型
/**
     * 字符串类型数据绑定
     *      请求的参数名要与方法的形参名保持一致（在未设置别名的情况下），默认值为 null
     *      可以通过注解 @RequestParam 的属性设置 默认值 和 别名
     * @param userName
     * @param userPwd
     */
    @RequestMapping("/data05")
    public void data05(String userName, String userPwd){
        System.out.println("userName:" + userName + "，userPwd:" + userPwd);
    }
数组类型
/**
     * 数组类型数据绑定
     *      客户端传递参数形式：hobbys=sing&hobbys=dance&hobbys=rap
     * @param hobbys
     */
    @RequestMapping("/data06")
    public void data06(String[] hobbys){
        for (String hobby: hobbys ) {
            System.out.println(hobby);
        }
    }
JavaBean 类型
/**
     * JavaBean类型 数据绑定
     *      客户端请求的参数名与javabean对象中属性字段名保持一致
     * @param user
     */
    @RequestMapping("/data07")
    public void data07(User user){
        System.out.println(user);
    }

User.java

   private Integer id;
    private String userName;
    private String userPwd;
List 类型/Set 类型/Map 类型

此时 User 实体需要定义对应 list 属性。（对于集合的参数绑定，⼀般需要使⽤ JavaBean 对象进⾏包装）

Set 和 List 类似，也需要绑定在对象上，⽽不能直接写在 Controller ⽅法的参数中。但是，绑定Set数据时，必须先在Set对象中add相应的数量的模型对象。

Map最为灵活，它也需要绑定在对象上，⽽不能直接写在Controller⽅法的参数中。

private Integer id;
    private String userName;
    private String userPwd;

    // 添加List集合属性
    private List<Integer> ids;
    private List<Phone> phoneList;

    // 添加Map类型属性
    private Map<String,String> map;

Phone实体

public class Phone {

    private String num;

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "num='" + num + '\'' +
                '}';
    }
}

Jsp ⻚⾯定义

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>List集合类型数据绑定</title>
</head>
<body>
    <form action="data08" method="post">
        <%-- List集合 --%>
        <%--<input name="ids" value="123456" />
        <input name="ids" value="4576" />--%>
        <input name="ids[0]" value="123456" />
        <input name="ids[1]" value="4576" />
        <input name="phoneList[0].num" value="123321" />
        <input name="phoneList[1].num" value="789987" />
        <%-- Map --%>
        <input name="map['sh']" value="东方明珠" >
        <input name="map['hz']" value="西湖" >
        <button type="submit"> 提交</button>
    </form>
</body>
</html>

   /**
     * List集合类型 数据绑定
     *      注：集合类型的数据，使用JavaBean对象进行包装
     * @param user
     */
    @RequestMapping("/data08")
    public void data08(User user){
        System.out.println(user);
    }


/**
*map
*/
@RequestMapping("/data10")
public void data10(User user){
Set<Entry<String, Phone>> set = user.getMap().entrySet();
for(Entry<String, Phone> entry:set){
System.out.println(entry.getKey()+"--"+entry.getValue().getNum());
}
}

四、请求转发与重定向的问题

SpringMVC 默认采⽤服务器内部转发的形式展⽰⻚⾯信息。同样也⽀持重定向⻚⾯。

1.重定向

重定向是发⼀个302的状态码给浏览器，浏览器⾃⼰去请求跳转的⽹⻚。地址栏会发⽣改变。

重定向以 redirect: 开头
    /**
     * 重定向到JSP页面
     * @return
     */
    @RequestMapping("/view01")
    public String view01(Model model){
        // 设置请求域对象
        model.addAttribute("name","admin");
        return "redirect:view.jsp";
    }


    /**
     * 重定向到JSP页面
     *      传递参数
     * @return
     */
    @RequestMapping("/view02")
    public String view02(){
        return "redirect:view.jsp?uname=zhangsan&upwd=123456";
    }

    /**
     * 重定向到JSP页面
     *      传递中文参数 （传递中文参数会出现乱码）
     * @return
     */
    @RequestMapping("/view03")
    public String view03(){
        return "redirect:view.jsp?uname=张三&upwd=123456";
    }


    /**
     * 重定向到JSP页面
     *      传递参数 （通过 RedirectAttributes 对象设置重定向的参数，避免中文乱码问题）
     * @param attributes
     * @return
     */
    @RequestMapping("/view04")
    public String view04(RedirectAttributes attributes){
        // 设置参数
        attributes.addAttribute("uname","张三");
        attributes.addAttribute("upwd","123");

        return "redirect:view.jsp";
    }

    /**
     * 重定向到JSP页面
     *      返回的是 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view05")
    public ModelAndView view05(ModelAndView modelAndView){

        // 设置模型数据
        modelAndView.addObject("uname","李四");
        modelAndView.addObject("upwd","admin");
        // 设置视图
        modelAndView.setViewName("redirect:view.jsp");

        return modelAndView;
    }

    /**
     * 重定向到Controller
     *      返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view06")
    public ModelAndView view06(ModelAndView modelAndView){

        // 设置模型数据
        modelAndView.addObject("uname","王五");
        modelAndView.addObject("upwd","123321");
        // 设置视图
        modelAndView.setViewName("redirect:test");

        return modelAndView;
    }
页面中获取参数值
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>请求转发与重定向</title>
</head>
<body>
    <h2>页面测试</h2>
    <h3>
        获取传递的参数：${param.uname} -- ${param.upwd}
    </h3>
    <h3>
        获取请求域的数据：${name}
    </h3>
</body>
</html>

2.请求转发

请求转发，直接调⽤跳转的⻚⾯，让它返回。对于浏览器来说，它⽆法感觉服务器有没有forward。地址栏不发⽣改变。可以获取请求域中的数据。

请求转发以 forward: 开头
    /**
     * 请求转发到JSP页面
     * @return
     */
    @RequestMapping("/view07")
    public String view07(){
        return "forward:view.jsp";
    }

    /**
     * 请求转发到JSP页面
     *      传递参数 （中文不乱码）
     * @return
     */
    @RequestMapping("/view08")
    public String view08(){
        return "forward:view.jsp?uname=张三&upwd=123";
    }


    /**
     * 请求转发到JSP页面
     *      设置请求域
     * @param model
     * @return
     */
    @RequestMapping("/view09")
    public String view09(Model model){
        // 设置请求域
        model.addAttribute("name","管理员");
        return "forward:view.jsp?uname=张三&upwd=123";
    }

    /**
     * 请求转发到JSP页面（默认）
     *      默认会去指定的目录下查找JSP页面 （配置文件中设置的）
     * @param model
     * @return
     */
    @RequestMapping("/view10")
    public String view10(Model model){
        // 设置请求域
        model.addAttribute("name","管理员");
        return "/../../view";
    }


    /**
     * 请求转发到Controller
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view11")
    public ModelAndView view11(ModelAndView modelAndView) {
        modelAndView.setViewName("forward:test");
        return modelAndView;
    }


    /**
     * 请求转发到Controller
     *      传递参数
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view12")
    public ModelAndView view12(ModelAndView modelAndView) {
        modelAndView.setViewName("forward:test?uname=admin&upwd=123");
        return modelAndView;
    }

五、SpringMVC 之 JSON 数据开发

Json 在企业开发中已经作为通⽤的接⼝参数类型，在⻚⾯（客⼾端）解析很⽅便。SpringMVC 对于json 提供了良好的⽀持，这⾥需要修改相关配置，添加 json 数据⽀持功能

@ResponseBody

该注解⽤于将 Controller 的⽅法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式后，写⼊到Response 对象的 body 数据区。

返回的数据不是 html 标签的⻚⾯，⽽是其他某种格式的数据时（如 json、xml 等）使⽤（通常⽤于ajax 请求）。

@RequestBody

该注解⽤于读取 Request 请求的 body 部分数据，使⽤系统默认配置的 HttpMessageConverter 进⾏解析，然后把相应的数据绑定到要返回的对象上 ，再把 HttpMessageConverter 返回的对象数据绑定到 controller 中⽅法的参数上。

1.使用配置

pom.xml 添加 json相关坐标
    <!-- 添加json 依赖jar包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.0</version>
    </dependency>
修改servlet-context.xml
   <!-- 开启注解驱动-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter" />
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
        </mvc:message-converters>
    </mvc:annotation-driven>
注解使⽤
@ResponseBody
@Controller
@RequestMapping("/user")
public class UserController {

    /**
     * @ResponseBody 返回的数据是JSON格式（返回JavaBean对象）
     *      注解设置在方法体上
     * @return
     */
    @RequestMapping("/query01")
    @ResponseBody
    public User queryUser01(){
        User user = new User();
        user.setId(1);
        user.setUserName("zhangsan");
        user.setUserPwd("123456");
        // 返回user对象
        return user;
    }


    /**
     * @ResponseBody 返回的数据是JSON格式（返回JavaBean对象）
     *      注解设置在方法返回对象前，修饰符后
     * @return
     */
    @RequestMapping("/query02")
    public @ResponseBody User queryUser02(){
        User user = new User();
        user.setId(2);
        user.setUserName("lisi");
        user.setUserPwd("123321");
        // 返回user对象
        return user;
    }


    @RequestMapping("/query03")
    @ResponseBody
    public List<User> queryUser03(){

        List<User> list = new ArrayList<>();

        User user = new User();
        user.setId(1);
        user.setUserName("zhangsan");
        user.setUserPwd("123456");

        User user02 = new User();
        user02.setId(2);
        user02.setUserName("lisi");
        user02.setUserPwd("123321");

        list.add(user);
        list.add(user02);

        // 返回集合
        return list;
    }
}
@RequestBody

@RequestBody 注解常⽤来处理 content-type 不是默认的 application/x-www-form-urlcoded 类型的内容，⽐如说：application/json 或者是application/xml 等。⼀般情况下来说常⽤其来处理 application/json 类型。@RequestBody接受的是⼀个 json 格式的字符串，⼀定是⼀个字符串。

通过 @RequestBody 可以将请求体中的 JSON 字符串绑定到相应的 bean 上，当然，也可以将其分别绑定到对应的字符串上。

    /**
     * @RequestBody 规定请求的参数必须是JSON格式的字符串
     *      注解设置在形参前面
     *
     *      1. @RequestBody 处理不是默认的类型（application/x-www-form-urlcoded）的内容
     *      2. 请求的参数一定是JSON格式的字符串，一定是字符串
     * @param user
     * @return
     */
    @RequestMapping("/query05")
    @ResponseBody
    public User queryUser05(@RequestBody User user) {
        System.out.println(user);
        return user;
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSON处理</title>
    <%-- 引入Jquery的核心js文件 --%>
    <script type="text/javascript" src="js/jquery-3.4.1.js"></script>
</head>
<body>
    <input type="button" value="响应JSON数据" οnclick="test01()">
    <input type="button" value="设置请求JSON" οnclick="test02()">

    <script type="text/javascript">

        /**
         * 通过ajax访问后台的方法，获取返回的数据
         */
        function test01(){
            // 发送ajax请求
            $.ajax({
                // 请求方式 GET|POST
                type: "post",
                // 请求路径
                url: "user/query04",
                // 设置参数
                data: {
                    "userName":"zhangsan",
                    "userPwd":"123456"
                },
                // 回调函数，接收服务端返回的结果 (函数中的形参用来接收返回的数据)
                success: function (data) {
                    console.log(data);
                }
            });
        }


        /**
         * 传递JSON格式的参数
         */
        function test02(){
            // 发送ajax请求
            $.ajax({
                // 请求方式 GET|POST
                type: "post",
                // 请求路径
                url: "user/query05",
                // 设置服务器请求参数的类型为 application/json
                contentType:"application/json",
                // 设置参数
                data: '{"userName":"zhangsan", "userPwd":"123456"}',
                // 回调函数，接收服务端返回的结果 (函数中的形参用来接收返回的数据)
                success: function (data) {
                    console.log(data);
                }
            });
        }

    </script>
</body>
</html>
地球魔
关注
SpringMVC系列（一）（介绍，简单应用以及路径位置通配符）
小林学编程的博客
06-15 699
作者正在学习SpringMVC相关内容，学到了一些知识，希望分享给需要短时间想要了解SpringMVC的读者朋友们，想用通俗的语言以及代码讲述其中的知识，希望与诸位共勉，共同进步！
关于SpringMVC的路径问题
qq_36074062的博客
08-15 666
SpringMVC经典四句话：      最好配成*.do      不能配置/*      也不能配置成/      不得不配成/ 解决配置成/静态资源访问不到的解决方案：    第一种：在web.xml配置                         第二种：在applicationContext.xml配置                      第三种：也是在ap
SpringMVC路径配置
owen_william的博客
06-05 1249
我们希望文件要上传到的路径是可配置，这样我们就可以方便更改文件所放置的地方。这一节里，我们主要就是来解决这个问题.首先，我们需要在config的包下创建PicturesUploadProperties类。 package masterSpringMvc.config; import org.springframework.boot.context.properties. Configurati
springmvc的路径问题
weixin_44125034的博客
02-29 709
首先可以参考下面的这篇博客： https://blog.youkuaiyun.com/qq_41933149/article/details/101847293
springmvc路径问题
TwentySeventh的博客
03-31 724
很奇怪的路径。图片是这种格式。jsp中这么写：${pageContext.request.contextPath }${book.resource.url }js中：向前台解析这么写：&lt;img src='/bookproject/"+item.resource+"'/&gt;手动添加路径……向后台解析时这么写：url : 'system/category'不用写路径……...
SpringMVC：请求路径问题
weixin_41113108的博客
03-18 3128
前台路径解决方案：1、使用${pageContext.request.contextPath }，这种方案后面是加"/"的。（提倡使用这种方式）例如：2、针对不加"/"的问题，使用base标签（不提倡）：使用base标签可以为不加"/"开头的相对路径自动添加上base标签所代表的路径，不过该方式具有浏览器兼容问题，不建议使用。后台路径解决方案：相对路径前都加上"/"但是，有个特例，Response...
SpringMVC 基础知识
12-20
【SpringMVC基础知识详解】 SpringMVC是Spring框架的一个核心模块，主要负责处理Web应用程序的请求和响应。它遵循Model-View-Controller（MVC）设计模式，将业务逻辑、数据处理和用户界面分离，提高了代码的可维护...
纯springMVC基础框架
03-04
**SpringMVC基础框架详解** SpringMVC是Spring框架的一个模块，主要负责处理Web应用程序的请求和响应。它提供了一种模型-视图-控制器（MVC）的架构模式，帮助开发者将业务逻辑、数据访问和用户界面有效地解耦。在...
关于spring mvc的访问路径风格
u011709128的专栏
04-07 202
&lt;!--如果你的DispatcherServlet拦截"/"，为了实现REST风格，拦截了所有的请求，那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。 --&gt; &lt;!--方案一：激活Tomcat的defaultServlet来处理静态文件 --&gt; &lt;!--要写在DispatcherServlet的前面， 让 defaultServlet先拦截请求，这样请...
一文了解SpringMVC的请求路径设置
qq_52951579的博客
01-11 1104
SpringMVC路径支持ANT风格路径 ANT 通配符有以下三种： ？：表示任意的单个字符，但是不能表示 "/"、"?" 等路径中的特殊符号 //表示诸如 "/a1a/testAnt"、"/a2a/testAnt"、"/aba/testAnt"等格式的请求都可以匹配到下面的控制器方法 @RequestMapping("/a?a/testAnt") public String testAnt(){ return "success"; } *：表示任意
SpringMVC修改配置文件路径+给界面传递数据
06-25
SpringMVC修改配置文件路径 给页面端传递数据（String类型、Map类型）
springMVC的配置文件路径问题
weixin_30338743的博客
11-16 240
今天在路径问题上又迷糊了，看以前的笔记一时没明白，所以重新编辑一下，使得思路更清晰一些。 第一：加载web.xml之后，读哪个配置文件问题？即是applicationContext.xml还是xxx-servlet.xml？ 　　解答：①在web.xml中配置DispatcherServlet时，看下面代码红色 　　　　　　<servlet> 　　　　　　<...
【Java】SpringMVC路径写法
m0_64921476的博客
01-24 687
多个对多个属性赋值,需要写上属性名只有一个属性时,且属性名为value,可以省略。@RequestMapping这个前缀对post和get方法都有效。注解里,双引号的值会赋给"value"这个属性。再次使用post报错，指定方法成功。我们在参数中规定一下，来限制方法。类路径和方法路径都可以写成多级。其中，类路径写在方法路径前面。
SpringMVC--01--了解 SpringMVC、利用 SpringMVC 指定接受前端参数的路径、类型
m0_46671240的博客
01-15 1510
SpringMVC--01--了解 SpringMVC、利用 SpringMVC 指定接受前端参数的路径、类型
在 Spring Boot 的 MVC 框架中 路径匹配的实现 详解
最新发布
goTsHgo的博客
12-23 1760
在 Spring Boot 的 MVC 框架中，路径匹配是由处理的。它负责将传入的 HTTP 请求映射到合适的控制器方法上。
SpringMVC中的配置文件存放路径
violin256的博客
05-03 1993
SpringMVC中的配置文件一定要放在要放到WEB-INF文件夹里吗？ No! SpringMVC中的配置文件默认是放在要放到WEB-INF文件夹里，但是你可以在web.xml文件中配置“初始化时加载的配置文件”路径。 假设springMVC的配置文件是springmvc-config.xml，放在了src的根目录中，则web.xml添加如下代码 <servlet> <!--初...
Spring-MVC的配置文件及路径问题
weixin_30736301的博客
06-25 257
第一：加载web.xml之后，读哪个配置文件问题？即是applicationContext.xml还是xxx-servlet.xml？ 　　解答：①在web.xml中配置DispatcherServlet时，看下面代码红色 　　　　　　<servlet> 　　　　　　<servlet-name>dispatch</servlet-name> 　　...
SpringMVC的默认配置文件位置
w727655308的博客
10-17 2381
Spring SpringWeb SpringMVC SpringMVC的默认配置文件位置
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值