SpringMVC框架入门01-19_spring mvc <bean> map-CSDN博客

本文链接：https://blog.csdn.net/qq_43568982/article/details/122576111

课程地址：动力节点SpringMVC
开始时间:2022-01-19

概念

SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的。
理解是servlet的一个升级

SpringMVC能够创建对象，放入到容器中（SpringMVC容器）， springmvc容器中放的是控制器对象
我们要做的是使用@Contorller创建控制器对象，把对象放入到springmvc容器中，把创建的对象作为控制器使用
这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用。

使用@Controller注解创建的是一个普通类的对象，不是Servlet。 springmvc赋予了控制器对象一些额外的功能。

index.jsp-----DispatherServlet(Servlet)----转发，分配给—Controller对象（@Controller注解创建的对象）

SpringMVC中的MVC架构

在这里插入图片描述
Front Controller：中央调度器 DispatcherServlet
发到Controller（我们自己创的controller，里面写对应处理的方法）处理后，创建ModelAndView返回数据
两个controller对应的是C
ModelAndView对应 M
View对应 V的部分
这既是一个MVC架构

第一个例子

需求：用户在页面发起一个请求，请求交给springmvc的控制器对象，
并显示请求的处理结果（在结果页面显示一个欢迎语句）。

实现步骤：

新建web maven工程（选模板的时候选maven-webapp）
加入依赖
spring-webmvc依赖，间接把spring的依赖都加入到项目
jsp，servlet依赖

3.重点：
在web.xml中注册springmvc框架的核心对象DispatcherServlet
1)DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet
2)DispatcherServlet页叫做前端控制器（front controller）
3)DispatcherServlet负责接收用户提交的请求，调用其它的控制器对象，
并把请求的处理结果显示给用户

4.创建一个发起请求的页面 index.jsp

5.创建控制器(处理器)类
1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMapping注解。

6.创建一个作为结果的jsp，显示请求的处理结果。

7.创建springmvc的配置文件（spring的配置文件一样）
1）声明组件扫描器，指定@Contorller注解所在的包名
2）声明视图解析器。帮助处理视图的。

自定义容器配置文件

注册springmvc的核心对象DispatcherServlet
需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。

为什么要创建DispatcherServlet对象的实例呢？因为DispatcherServlet在他的创建过程中，
会同时创建springmvc容器对象，读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起
请求时就可以直接使用对象了。

servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中

{
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key, ctx);
}

springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.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">

    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象
            load-on-startup:表示tomcat启动后创建对象的顺序。如果有多个servlet，就按照值的大小来确定谁先谁后，数值越小，tomcat创建对象的时间越早。 大于等于0的整数。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， url-pattern可以使用两种值
            1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等
               不能使用 *.jsp
               http://localhost:8080/myweb/some.do
               http://localhost:8080/myweb/other.do

            2.使用斜杠 "/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

4.创建一个发起请求的页面 index.jsp


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>第一个springmvc项目</p>
<p><a href="some.do">发起some.do的请求</a> </p>
<p><a href="other.do">发起other.do的请求</a> </p>
</body>
</html>

5.创建控制器(处理器)类

1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMapping注解。

/**
 *  @Controller:创建处理器对象，对象放在springmvc容器中。
 *  位置：在类的上面
 *  和Spring中讲的@Service ,@Component
 *
 *  能处理请求的都是控制器（处理器）： MyController能处理请求，
 *                         叫做后端控制器（back controller）
 *
 *  没有注解之前，需要实现各种不同的接口才能做控制器使用
 */

package BUPT.controller;

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

@Controller
public class MyController {
    /*
       处理用户提交的请求，springmvc中是使用方法来处理的。
       方法是自定义的， 可以有多种返回值， 多种参数，方法名称自定义
     */

    /**
     * 准备使用doSome方法处理some.do请求。
     * @RequestMapping: 请求映射，作用是把一个请求地址和一个方法绑定在一起。
     *                  一个请求指定一个方法处理。
     *       属性： 1. value 是一个String，表示请求的uri地址的（some.do）。
     *                value的值必须是唯一的， 不能重复。 在使用时，推荐地址以“/”
     *       位置：1.在方法的上面，常用的。
     *            2.在类的上面
     *  说明： 使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     *  使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet, doPost
     *
     *  返回值：ModelAndView 表示本次请求的处理结果
     *   Model: 数据，请求处理完成后，要显示给用户的数据
     *   View: 视图， 比如jsp等等。
     */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        //添加数据， 框架在请求的最后把数据放入到request作用域。

        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        mv.setViewName("/show.jsp");
        return mv;
    }

6.创建一个作为结果的jsp，显示请求的处理结果。


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>show.jsp从request作用域获取数据</h3>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3>
</body>
</html>

7.创建springmvc的配置文件（spring的配置文件一样）

1）声明组件扫描器，指定@Contorller注解所在的包名
2）声明视图解析器。帮助处理视图的。

SpringMVC.xml

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--声明组件扫描器-->
    <context:component-scan base-package="BUPT.controller"/>
</beans>

测试一下
在这里插入图片描述
鼠标放在some.do上面，就会显示链接

链接正常

springmvc请求的处理流程

1）发起some.do
2）tomcat(web.xml–url-pattern知道 *.do的请求给DispatcherServlet)
3）DispatcherServlet（根据springmvc.xml配置知道 some.do—doSome()）
4）DispatcherServlet把some.do转发个MyController.doSome()方法
5）框架执行doSome（）把得到ModelAndView进行处理，转发到show.jsp

some.do—>DispatcherServlet—>MyController

springmvc执行过程源代码分析

tomcat启动，创建容器的过程
通过load-on-start标签指定的1，创建DisaptcherServlet对象，

DisaptcherServlet它的父类是继承HttpServlet的，它是一个serlvet，在被创建时，会执行init（）方法。
在init（）方法中

   //创建容器，读取配置文件
    WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放入到ServletContext中
    getServletContext().setAttribute(key, ctx);

上面创建容器作用：创建@controller注解所在的类的对象，创建MyController对象，
这个对象放入到 springmvc的容器中，容器是map ，类似 map.put(“myController”,MyController对象)

2.请求的处理过程
1）执行servlet的service()
protected void service(HttpServletRequest request, HttpServletResponse response)

protected void doService(HttpServletRequest request, HttpServletResponse response)

DispatcherServlet.doDispatch(request, response){

调用MyController的.doSome()方法
}

考虑用户恶意登录的情况

之前是用过滤器解决这个问题的
这里我们粗暴一点，将我们跳转界面的jsp，放入web-inf目录下
这样就没办法直接通过输入地址来访问到了
但可以通过链接跳转
在这里插入图片描述
此时指定视图的路径为

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

但如果我有几十个jsp，这样写还是太繁琐了
于是考虑使用视图解析器
SpringMVC.xml中配置

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--        前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--        后缀：视图文件扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

MyController中使用

        //框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完成路径， 这里就是字符连接操作
        ///WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

在一个controller中可以创多个方法

 @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }

对应写好界面都可以做对应功能
其中value里面的多个值，对应的都是执行这一个方法

注解的使用

一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法
所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的
value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在
类之上的@RequestMapping 的 value 属性中。

如下所示，定义在类上面和定义在方法上面所呈现的效果是不同的

@RequestMapping("/test")
public class MyController {

    @RequestMapping(value = {"/some.do", "/first.do"})
    public ModelAndView doSome() {  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg", "欢迎使用springmvc做web开发");
        mv.addObject("fun", "执行的是doSome方法");

        mv.setViewName("show");
        return mv;
    }

}

指定请求方式method

对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method
属性指定的提交方式的请求，才会执行该被注解方法。 Method 属性的取值为 RequestMethod 枚举常量。常用的为
RequestMethod.GET 与 RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。

@RequestMapping("/test")
public class MyController {

    @RequestMapping(value = {"/some.do", "/first.do"})
    public ModelAndView doSome() {  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg", "欢迎使用springmvc做web开发");
        mv.addObject("fun", "执行的是doSome方法");

        mv.setViewName("show");
        return mv;
    }

}

在这里插入图片描述
当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配。即对于
请求的提交方式无要求

处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序
员可在方法内直接使用。
➢ HttpServletRequest
➢ HttpServletResponse
➢ HttpSession
➢ 请求中所携带的请求参数

直接写在方法的参数里

    @RequestMapping(value = "/other.do")
    public ModelAndView doOther(HttpServletRequest request,
                                HttpServletResponse response,
                                HttpSession session) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "====欢迎使用springmvc做web开发====" + request.getParameter("name"));
        mv.addObject("fun", "执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }

此时在浏览器中键入 ?name=zhangsan
就可以拿到数据
在这里插入图片描述

接收参数逐个接收

逐个接收请求参数：
要求：处理器（控制器）方法的形参名和请求中参数名必须一致。
同名的请求参数赋值给同名的形参
框架接收请求参数
1. 使用request对象接收请求参数(传统方法)
String strName = request.getParameter(“name”);
String strAge = request.getParameter(“age”);
2. springmvc框架通过 DispatcherServlet 调用 MyController的doSome()方法
调用方法时，按名称对应，把接收的参数赋值给形参
doSome（strName，Integer.valueOf(strAge)）
框架会提供类型转换的功能（不用手工写），能把String转为 int ，long ， float， double等类型。

创建一个学生类，age和name属性

在MyController里面用

    @RequestMapping(value = "/receiveproperty.do")
    public ModelAndView doSome(String name, Integer age){
        System.out.println("doSome, name="+name+"   age="+age);
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

index里面建一个表单

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

show.jsp中展示数据

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

<h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
<h3>myname数据：${myname}</h3><br/>
<h3>myage数据：${myage}</h3>
<h3>student数据：${mystudent}</h3>
</body>
</html>

过滤器解决post乱码

浏览器以GET方式发送请求,请求参数保存在请求头，在Http请求协议包到达Http服务器之后，第一件事就是进行解码请求头二进制内容由Tomcat负责解码，Tomcat默认使用【utf-8】字符集，可以解释一切国家文字
浏览器以POST方式发送请求，请求参数保存在【请求体】，在Http请求协议包到达Http服务器之后，第一件事就是进行解码请求体二进制内容由当前请求对象（request)负责解码。request默认使用[ISO-8859-1]字符集，一个东欧语系字符集此时如果请求体参数内容是中文，将无法解码只能得到乱码

之前的解决方式

现在考虑加过滤器解决问题
在web.xml中添加

   <!--注册声明过滤器，解决post请求乱码的问题-->
    <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>
        
        <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>

        <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <!--
           /*:表示强制所有的请求先通过过滤器处理。
        -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

结束时间：2022-01-23