Spring MVC简介和第一个Spring MVC程序和Spring MVC的详细讲解

极具浪漫主义色彩的菜鸟学习之路

已于 2022-10-27 18:33:59 修改

阅读量560

点赞数 1

分类专栏： mybatis SpringBoot 文章标签： spring mvc

于 2022-10-27 18:31:55 首次发布

本文链接：https://blog.csdn.net/muweichang/article/details/127512389

版权

mybatis 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

SpringBoot

2 篇文章 0 订阅

订阅专栏

博主每篇博文的浪漫主义

【我想在勇敢的少年时，去见每一座壮阔的雪山】 https://www.bilibili.com/video/BV1dT411P7Pw/?share_source=copy_web&vd_source=385ba0043075be7c24c4aeb4aaa73352

我想在勇敢的少年时，去见每一座壮阔的雪山

在这里插入图片描述

本片博文的学习笔记参照来源这里这个网站

什么是springmvc

Spring MVC有些地方也叫作Spring Web MVC，看名字就能知道这是一个表现层框架。在没有学习Spring MVC之类的框架的时候，一般会使用JavaEE中的servlet来接收和处理前台发送的请求，这种方式使用起来有一些不方便的地方，比如做一个增删改查，我们需要在servlet中编写判断逻辑来处理相应的增删改查的请求，这样代码显得冗余。

第一个Spring MVC程序

我们来看一下我这个项目的目录结构，

在这里插入图片描述

第一步：

创建一个项目，为了方便后续的操作，我们通过idea创建一个maven项目，通过maven来帮我们管理相关的jar文件，当然你也可以创建一个web项目，不过这样的话，就需要你手动的去下载Spring MVC相关的jar包了（麻烦）。

第二步：

导入相关Jar包，这里使用maven来帮我们管理，下面是pom.xml文件中的内容,目前只是写了一个非常简单的Spring MVC，所以只使用maven导入了spring-webmvc相关的包即可，一步一步的来嘛。

pom.xml文件中properties有什么用：

在标签内可以把版本号作为变量进行声明，后面dependency中用到版本号时可以用${变量名}的形式代替，这样做的好处是：当版本号发生改变时，只有更新properties标签中的变量就行了，不用更新所有依赖的版本号。

在这里插入图片描述

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <!--统一管理版本号-->
    <spring-version>5.2.4.RELEASE</spring-version>
</properties>
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring-version}</version>
    </dependency>
</dependencies>

第三步：

注册Spring MVC的中央控制器DispatcherServlet，打开web.xml文件，在里面加入下面内容（我这里使用的是servlet4.0的版本的web.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
  <!-- 注册spring MVC中央控制器 -->
  <servlet>
    <servlet-name>springMVC</servlet-name>
    <!-- spring MVC中的核心控制器 -->
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

第四步：

maven项目中有个src/main/resources目录，在该目录下创建Spring MVC配置文件springmvc.xml，该xml配置文件可以任意命名，需要跟第三步中的init-param中的param-value保持一致即可。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       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">



</beans>

第五步：

创建一个类去实现org.springframework.web.servlet.mvc.Controller接口，通常我们称这样的类为Controller，它的作用有些类似之前学习的servlet，或者可以认为在Spring MVC里面，就是使用了Controller来代替了servlet，它提供了比servlet更加丰富的功能。

package controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class HelloSpringMVC implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("hello", "hello first spring mvc");
        mv.setViewName("/WEB-INF/jsp/first.jsp");
        return mv;
    }
}

第六步：

在springmvc.xml配置文件中注册第五步创建的Controller，添加下面内容：

<bean id="/hello.do" class="controller.HelloSpringMVC" />

第七步：

在WEB-INF目录中创建一个目录jsp，在这个jsp目录下创建一个first.jsp的文件。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${hello}
</body>
</html>

第八步：

启动tomcat，然后在浏览器地址栏中输入：http://localhost:8080/hello.do
如果你看到网页中显示hello first spring mvc，那就说明第一个Spring MVC程序编写成功啦。

在这里插入图片描述
是不是小有成就感。

第一个Spring MVC程序分析

上面通过编写Controller和配置一些xml文件就实现了一个Spring MVC的程序，下面来分析下这些内容都表示什么意思。
在这里插入图片描述

在第三步中，我们在web.xml中注册了一个中央控制器DispatcherServlet，这个其实就是相当于注册了一个servlet，关于该servlet，我们添加了如下配置：

load-on-startup：设置为1，表示该servlet的创建优先级高，并且在web服务器（tomcat）启动的时候就创建其对象，并且调用其init方法，这样就可以保证Spring
MVC的正常工作了。
init-param：因为Spring MVC的配置文件可以任意命名，所以该内容主要告诉SpringMVC我们编写的配置文件的路径和名称，这样在中央控制器中就可以获取该配置文件中的信息了。通过源码可以看到DispatcherServlet继承了FrameworkServlet，在这个类中有个setContextConfigLocation方法，所以在param-name中将其命名为contextConfigLocation。
url-pattern：这里配置的是*.do,即所有以.do结尾的请求都会匹配到Spring
MVC的核心控制器DispatcherServlet中。当然，你可以配置为/，只不过这样写的话会有问题，后面再细说。

在第四步和第六步中我们创建和配置了springmvc.xml的文件，这个文件的命名是随意，所以需要在web.xml中的init-param标签进行配置。我们通过bean标签来注册一个Controller,即当请求的url是hello.do结尾的时候，中央控制器DispatcherServlet就会将请求分发到我们编写的HelloSpringMVC中。

在第五步中，我们编写了一个Controller，里面我们使用了ModelAndView类，分别调用了两个方法：

mv.addObject("hello", "hello first spring mvc");

表示我们向ModelAndView这个对象中添加一条数据，名字是hello，内容是hello first spring mvc,这个跟之前学习的map有些类似，实际上，addObject方法的底层就是一个map。在ModelAndView对象里面添加的数据，可以从jsp中获取，上面是直接使用EL表达式获取的数据。

mv.setViewName("/WEB-INF/jsp/first.jsp");

括号中的内容是要跳转的jsp的路径和文件名。

来看一下Spring MVC执行流程

在这里插入图片描述

由浏览器发送请求localhost:8080/01-first/hello.do，该请求到达web服务器（tomcat）后，会在web.xml文件中查找与之匹配的servlet，我们在web.xml文件中设置的所有以.do结尾的请求都会匹配到SpringMVC的核心控制器DispatcherServlet上。
DispatcherServlet会去我们开发者编写的springmvc.xml配置文件中查找与hello.do请求匹配的Controller，这里配置的是com.monkey1024.controller.HelloSpringMVC。
DispatcherServlet会将请求转到HelloSpringMVC类上，并调用该类中的handleRequest方法来处理这个请求。
在handleRequest方法中执行完成后会将ModelAndView对象返回给DispatcherServlet，然后DispatcherServlet将jsp响应给浏览器，流程结束。

上面的流程只是表面的一个执行流程，通过这个简单的执行流程，我们可以看到大体上Spring MVC的工作方式，它的底层实际上就是一个servlet，主要依赖于其核心的中央控制器DispatcherServlet，请求和响应等一系列的工作都是由这个servlet来完成的，基于这样的原因，我们才会称DispatcherServlet为Spring MVC的中央控制器了。

配置视图解析器

在controller中我们在ModelAndView中的setViewName方法里面传入要跳转的jsp的路径和名字，如果有多个controller的话，需要在每个里面都编写路径和jsp的名字，~~这样的话比较繁琐~~ ，这时可以通过使用Spring MVC给我们提供的一个视图解析器来解决这个问题。

打开springmvc.xml的配置文件，在里面添加一个视图解析器：

<!-- 视图解释类 -->
<bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
</bean>

其中prefix表示前缀，即你的jsp所在的路径。
suffix表示后缀，即文件的后缀名。
之后来修改一下HelloSpringMVC中的内容，因为在springmvc.xml文件中已经配置了文件路径和后缀名了，所以将之前的：

mv.setViewName("/WEB-INF/jsp/first.jsp");

修改为：

mv.setViewName("first");

这样以后就不用再setViewName方法中写路径了，并且也方便日后的维护。

使用注解方式编写第一个Spring MVC

1.使用注解编写Spring MVC程序

第一个注解式Spring MVC程序

在实际开发中，我们会创建很多Controller来满足业务方面的需求，这样就会导致一个问题，需要在springmvc.xml配置文件中配置大量的bean标签，这样就导致该配置文件变的臃肿起来，为了解决这个问题，spring MVC提供了一系列的注解，通过设置注解，可以使springmvc.xml配置文件变的简洁。
在这里插入图片描述
这里只是其中的一个。

使用注解编写spring MVC程序整体的步骤跟之前的差不多（不要忘记在web.xml文件中添加DispatherServlet），只不过有一些地方需要修改，在之前的spring MVC程序中添加下面内容。

大家可以新建一个springmvc项目，也可以在现在的项目上改一下，进行比较。

注册扫描器

在配置文件中我们只需要注册一个组件扫描器即可，其中base-package写上你的包名即可，下面这种写法表示会扫描controller下的所有类，该组件扫描器是spring中的内容，具体咱在spring中再讲解。

<!-- 注册组件扫描器 -->
<context:component-scan base-package="controller"/>

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

注意：如果在你的springmvc.xml文件中配置了静态资源即使用了

mvc:resources

标签的话，那么需要在你的配置文件中配置注解驱动，添加下面内容：

<mvc:annotation-driven/>

如果没有添加注解驱动的话，你访问controller的时候会出现404错误。

1.定义处理器controller

在Java下的，controller包下创建一个AnnotationController类。

package controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Controller
public class AnnotationController {
    @RequestMapping("/test1")
    public ModelAndView test1(HttpServletRequest request, HttpServletResponse response) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("hello", "hello annotation");
        mv.setViewName("annotation1");
        return mv;
    }
}

jsp的创建

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${hello}
</body>
</html>

在这里插入图片描述
处理器中的注解：

在上面的示例中，我们创建了一个AnnotationController类，这类没有实现任何接口，只是在类名和方法上添加了两个注解：

@Controller：表示当前类为一个Controller
@RequestMapping：表示当前方法为Controller中的方法，该方法会处理请求，被注解的方法的名称是可以随意命名的。当有多个请求可以匹配该方法时，可以写上一个String类型的数组，如下示例中的test2方法。
@RequestMapping注解还可以定义在类上面，在上面的示例中，test1方法和test2方法中的url路径中都包含了/test，此时我们把这些相同的url抽取出来，放到类上的注解@RequestMapping中，此时可以称之为命名空间。

package controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Controller
@RequestMapping("/test")//类名上的注解，命名空间namespace
public class TestController02 {

    @RequestMapping("/test1")
    public ModelAndView test1(HttpServletRequest request, HttpServletResponse response) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("hello", "hello annotation");
        mv.setViewName("annotation1");
        return mv;
    }


    @RequestMapping({"/test2", "/test3"})
    public ModelAndView test2(HttpServletRequest request, HttpServletResponse response) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("name", "monkey1024");
        mv.setViewName("annotation2");
        return mv;
    }

}

相关jsp代码如下，
在这里插入图片描述

RequestMapping中常用的属性

通配符

在这里插入图片描述

请求的提交方式

在@RequestMapping中有一个method属性，改属性可以设置接收请求的提交方式：

@RequestMapping(value="/test",method = RequestMethod.POST)
public ModelAndView test(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ModelAndView mv = new ModelAndView();
    mv.addObject("hello", "test");
    mv.setViewName("test1");
    return mv;
}

上面的注解表示，只有当/test的请求的方式是post的时候才会执行当前方法，对于其他请求方式不进行处理。如果不写method属性的话，无论你是使用get或者post或者其他方式，它都会进行处理。
上面的RequestMethod是一个枚举类型，里面包含了大部分的提交方式。

示例，创建一个Controller，里面添加连个方法分别只处理get和post方式的请求：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@Controller//表示当前类是一个controller
@RequestMapping("/test")//表示是一个命名空间namespace
public class TestController03 {


    @RequestMapping(value="/requestGet",method = RequestMethod.GET)
    public ModelAndView reqGet(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("method", "get请求");
        mv.setViewName("get");
        return mv;
    }


    @RequestMapping(value="/requestPost",method = RequestMethod.POST)
    public ModelAndView reqPost(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("hello", "post请求");
        mv.setViewName("post");
        return mv;
    }

}

页面中的内容:

<html>
<body>
<form action="/test/requestGet" method="get">

    <input type="submit" value="get请求">
</form>
<br>
<form action="/test/requestPost" method="post">

    <input type="submit" value="post请求">
</form>
</body>
</html>

请求中携带的参数

在这里插入图片描述

在springmvc中单个接收表单提交的数据

在实际开发中通过会在spring MVC的Controller里面接收表单提交过来的参数，这块代码该怎么去编写呢？
就是把前端的值传到后端？

<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/regist1.do" method="post">
        姓名：<input type="text" name="username"><br>
        年龄：<input type="text" name="age"><br>
        <input type="submit" value="提交">
    </form>
</body>
</html>

之后创建一个controller来接收这个表单提交的值：


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class RegistController {

    @RequestMapping("/regist1.do")
    public ModelAndView regist1(String username, int age) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("username", username);
        mv.addObject("age", age);
        mv.setViewName("result");
        return mv;
    }
}

创建result.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

用户名：${username}
<br>
年龄：${age}
</body>
</html>

在上面的controller中，我们在regist1方法后面的参数列表中写上了两个参数username和age，因为这两个参数与表单中input中的name一致，所以spring MVC会自动为其赋值，通过这种方式就可以在controller中获取表单提价的数据了。

此时你可能会发现一个问题，在之前我们写的controller中的方法参数列表里面我们都写上了request和response，而这里却没有写，其实这不会影响spring mvc的工作，也就是说在controller的方法里面，我们可以写多个参数，也可以一个都不写，不过spring mvc只会自动为以下五个参数进行自动赋值：

HttpServletRequest
HttpServletResponse
HttpSession
请求携带的参数
用于承载数据的Model

当前示例其实就是spring mvc将请求携带参数进行赋值，这样子我就可以直接获取表单提交的数据了。

获取请求参数乱码

在上面的示例中，倘若你输入了中文，那很有可能出现乱码问题，我们可以使用spring MVC为开发者提供的CharacterEncodingFilter来解决乱码问题，这个其实就是一个过滤器。我们需要在web.xml文件中进行配置，最好将其设置在其他过滤器之前，因为过滤器是按照web.xml中的顺序执行的：

<!--字符编码过滤器-->
<filter>
    <filter-name>characterEncodingFilter</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>

    <!--强制指定字符编码，即如果在request中指定了字符编码，那么也会为其强制指定当前设置的字符编码-->
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>

</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

这里可以通过springmvc的源码中看到forceEncoding如果设置为true的话，那么不论你是否在request中设置了字符编码，spring mvc都会强制将其字符编码设置为我们在web.xml文件中写的字符编码。

当参数不一致的时候，我们该怎么做

在实际开发中有可能会有这样的问题，就是表单中input的name和spring mvc方法中的参数名不一致，这时可以使用@RequestParam()注解来解决这个问题，这个注解中有三个属性：

value：指定请求参数的名称，即表单中input的name值。
name：同value，两者只能使用一个
required：指定该参数是否是必须传入的，boolean类型。若为 true，则表示请求中所携带的参数中必须包含当前参数。若为 false，则表示有没有均可。
defaultValue：指定当前参数的默认值。如果请求中没有该参数，则当前方法参数将取该默认值。

我们来看一下代码示例：

<form action="/regist1.do" method="post">
    姓名：<input type="text" name="username"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>

在controller的方法中的参数名与表单中的参数名不一致,使用@RequestParam：

@RequestMapping("/regist.do")
public ModelAndView regist(@RequestParam(name="username") String t_username, @RequestParam(name="age") int t_age) throws Exception{

    ModelAndView mv = new ModelAndView();
    mv.addObject("username", t_username);
    mv.addObject("age", t_age);
    mv.setViewName("result");
    return mv;
}

设置defaultValue属性，当在jsp中没有填写年龄时，spring mvc会默认将其赋值为18

@RequestMapping("/regist.do")
public ModelAndView regist(@RequestParam(name="username") String t_username, @RequestParam(name="age",defaultValue = "18") int t_age) throws Exception{

    ModelAndView mv = new ModelAndView();
    mv.addObject("username", t_username);
    mv.addObject("age", t_age);
    mv.setViewName("result");
    return mv;
}

设置required=true，此时系统会报出400的错误，因为请求参数中没有sex。

@RequestMapping("/regist.do")
public ModelAndView regist(@RequestParam(name="username") String t_username, @RequestParam(name="age",defaultValue = "18") int t_age, @RequestParam(required = true) String sex) throws Exception{

    ModelAndView mv = new ModelAndView();
    mv.addObject("username", t_username);
    mv.addObject("age", t_age);
    mv.setViewName("result");
    return mv;
}

使用对象来接收表单数据

然后接下来我们使用对象来接收表单数据，这也是我们后面经常用到的。

在之前的接收表单提交参数的示例中有个问题，倘若表单中的参数较多的话，需要在controller的方法里面把这些参数都写上，这样就不太方便了，我们可以定义一个javabean，将表单中的参数都写到javabean的属性里面，然后将这个bean作为参数写到controller的方法中。

示例：

定义一个Student类，里面的属性名跟表单的name保持一致

对象里面包含属性

public class Student {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

然后我们再来写一下controller

定义Controller，在方法中将Student作为参数传入：

import com.monkey1024.bean.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class RegistController02 {

    @RequestMapping("/regist")
    public ModelAndView regist(Student student) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("name", student.getName());
        mv.addObject("age", student.getAge());
        mv.setViewName("result");
        return mv;
    }
}

通过这种方式，我们可以更方便的接收表单提交的数据了。

对象属性参数的接收

当请求中的参数是一个对象属性中的属性时，我们可以在表单中的name中写上对象属性.属性的方式进行处理。

定义一个School类：

package com.monkey1024.bean;

public class School {

    private String schoolName;

    private String address;

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

定义一个Student类，里面添加School对象属性：

package com.monkey1024.bean;

public class Student {

    private String name;

    private int age;

    private School school;

    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

修改前台:

 <form action="/regist" method="post">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    学校名称：<input type="text" name="school.schoolName"><br>
    学校地址：<input type="text" name="school.address"><br>
    <input type="submit" value="提交">
</form>

我们在修改一下RegistController02中的代码

import com.monkey1024.bean.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class RegistController02 {

    @RequestMapping("/regist")
    public ModelAndView regist(Student student) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("name", student.getName());
        mv.addObject("age", student.getAge());
        mv.addObject("schoolName", student.getSchool().getSchoolName());
        mv.addObject("address", student.getSchool().getAddress());
        mv.setViewName("result");
        return mv;
    }
}

我们来看一下result.jsp中的代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

用户名：${name}
<br>
年龄：${age}
<br>
密码：${password}
<br>
学校名称：${schoolName}
<br>
学校地址：${address}
</body>
</html>

路径变量PathVariable

Controller除了可以接收表单提交的数据之外，还可以获取url中携带的变量，即路径变量，此时需要使用@PathVariable注解来设置，其中包含下面几个属性。

value：指定请求参数的名称，即url中的值，当url中的名称和方法参数名称不一致时，可以使用该属性解决。
name：同value，两者只能使用一个
required：指定该参数是否是必须传入的，boolean类型。若为 true，则表示请求中所携带的参数中必须包含当前参数。若为
false，则表示有没有均可。

创建Controller，注意@RequestMapping注解中的写法

import com.monkey1024.bean.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class RegistController03 {

    @RequestMapping("/{username}/{age}/regist")
    public ModelAndView regist(@PathVariable("username") String name,@PathVariable int age) throws Exception{

        ModelAndView mv = new ModelAndView();
        mv.addObject("name", name);
        mv.addObject("age", age);
        mv.setViewName("result");
        return mv;
    }
}

之后，在浏览器的地址栏里面直接输入：

localhost:8080/jack/19/regist

此时可以直接获取url中的jack和19的值。

这种方式在restful风格的url中使用较多，作者是这样说的。我感觉我太菜了。

救救就学到这里，博主的文章为什么没人看，虽然是抄作业吧，但我也是仔仔细细过了一遍的
提示：对于这篇学习笔记就暂时到这了，兄弟们加油
对于这篇学习笔记就暂时到这了，兄弟们加油

从现在做起，坚持下去，一天进步一小点，不久的将来，你会感谢曾经努力的你！

如果又出错的，请各位友友指正。

请添加图片描述

新人报到，各位友友们，给我个三联（点赞，关注，收藏）

极具浪漫主义色彩的菜鸟学习之路

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring MVC简介和第一个Spring MVC程序和Spring MVC的详细讲解

Spring MVC有些地方也叫作Spring Web MVC，看名字就能知道这是一个表现层框架。在没有学习Spring MVC之类的框架的时候，一般会使用JavaEE中的servlet来接收和处理前台发送的请求，这种方式使用起来有一些不方便的地方，比如做一个增删改查，我们需要在servlet中编写判断逻辑来处理相应的增删改查的请求，这样代码显得冗余。
复制链接

扫一扫