SpringMVC简介

SpringMVC ：是基于spring的一个框架， 实际上就是spring的一个模块， 专门是做 web 开发的。可以理解是servlet的一个升级。 web 开发底层是servlet ， 框架是在servlet基础上面加入一些功能，让你做 web 开发方便。

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

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

web开发底层是servlet， Springmvc中有一个对象是Servlet ： DispatherServlet(中央调度器)

DispatherServlet: 负责接收用户的所有请求， 用户把请求给了DispatherServlet， 之后DispatherServlet把请求转发给我们的Controller对象， 最后是Controller对象处理请求。

创建第一个项目

所谓 SpringMVC 的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在 SpringMVC 容器的注册。注解式开发是重点。

1. 新建web maven工程

新建一个express项目_servlet

2. 引入依赖：
<!--servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--springmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
3. 注册DispatcherServlet
  1. DispatcherServlet叫做中央调度器，是一个servlet ,它的父类是继承HttpServlet
  2. DispatcherServlet页叫做前端控制器( front controller)
  3. DispatcherServlet负责接收用户提交的请求，调用其它的控制器对象，并把请求的处理结果显示给用户

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

为什么要创建 DispatcherServlet 对象的实例呢?

因为DispatcherServlet在他的创建过程中，会同时创建 Springmvc 容器对象，读取 Springmvc 的配置文件，把这个配置文件中的对象都创建好，当用户发起请求时就可以值接使用对象了。启动 tomcat 报错,读取这个文件/WEB-INF/springmvc-servlet.xml（这里的 springmvc 是 servlet-name 的名字）

web.xml文件

<servlet>
        <servlet-name>springmvc</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启动后创建对象的顺序。
            它的值是个整数，越小表示创建越早。大于等于0，其实0也很少用
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
        使用框架的时候,url-pattern可以使用两种值
        1，使用扩展名方式，语法*.xXXX , xxxx是自定义的扩展名。常用的方式*.do，*.action，*.mvc等等
        http://localhost:8080/springmvc/some.do
        http://localhost:8080/springmvc/other.do
        2.使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern><!--这里我们先使用*.do的方式-->
    </servlet-mapping>
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>

</body>
</html>
5. 创建控制器类

@Controller：创建处理器对象，对象放在 Springmvc 容器中。
能处理请求的都是控制器（处理器）: MyController 能处理请求，叫做后端控制器 (back controller)

准备使用dosome方法处理some.do请求。
@ RequestMapping: 请求映射，作用是把一个请求地址和一个方法绑定在一起。一个请求指定一个方法处理。

属性: value是一个 String，表示请求的 uri 地址的 (some.do)。value的值必须是唯一的，不能重复。在使用时以“/”

说明: 使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
使用@RequestMapping修饰的方法可以处理请求的，类似 Servlet 中的doGet, doPost

返回值:ModelAndView表示本次请求的处理结果
ModeL : 数据，请求处理完成后，要显示给用户的数据
View : 视图，比如 jsp 等等。

@Controller
public class MyController {
   
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){//doGet--service请求处理
        //处理some.do请求
        ModelAndView mv=new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域。
        // request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图，指定视图的完整路怪
        //框架对视图执行的forward操作，request.getRequestDispatcher("/show.jsp).forward(...);
        mv.setViewName("/show.jsp");

        //当配置了视图解析器后，可以使用逻辑名称（文件名）,指定视图
        //框架会使用视图解析器的前缀＋逻辑名称＋后缀组成完成路径，这里就是字符连接操作
        // /WEB-INF/view/ + show + .jsp
        //mv.setViewName("show");

        return mv;
    }
}
6. 创建一个作为结果的jsp

show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp</h3><br/>
    <h3>msg信息：${msg}</h3><br/>
    <h3>fun数据：${fun}</h3>

</body>
</html>
7. 创建Springmvc的配置文件

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="com.controller"/>

    <!--声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路怪-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

SpringMVC的执行流程

新建一个express项目_servlet_02


Springmvc执行过程源代码分析

1.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对象)