SpringMVC_02 什么是SpringMVC

蕃茄匠

已于 2023-02-28 19:52:51 修改

阅读量115

点赞数 1

文章标签： java spring servlet mvc

于 2023-01-13 22:23:16 首次发布

原文链接：https://mp.weixin.qq.com/s/yuQqZzAsCefk9Jv_kbh_eA

版权

---SpringMVC02---

1、什么是SpringMVC

1.1、概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC（Servlet）的轻量级Web框架。

查看官方文档：https://docs.spring.io/spring-framework/docs/4.3.24.RELEASE/spring-framework-reference/https://docs.spring.io/spring-framework/docs/4.3.24.RELEASE/spring-framework-reference/

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

轻量级，简单易学
高效 , 基于请求响应的MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活

Spring的web框架围绕DispatcherServlet（分发服务器） [ 调度Servlet ] 设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁。

正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器等等......所以我们要学习。

最重要的一点还是用的人多 , 使用的公司多 .

1.2、中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器（说白了就是不同的方法和类）。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

SpringMVC的原理如下图所示：

当发起请求时被前端控制器（DispatcherServlet）拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器（Controller层），控制器处理请求（Service层），创建数据模型（Dao层），访问数据库，将模型响应给中心控制器，控制器使用模型与视图[ 携带了数据（模型装数据）与视图的情况 ]渲染视图结果，将结果返回给前端控制器（DispatcherServlet），再将结果返回给请求者。

1.3、SpringMVC执行原理

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

1）DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户端发出请求，Tomcat获得这个请求后将其做了一个映射判断（<url-pattern>/</url-pattern>，如果访问地址符合" / "，则交给DisPatcherServlet ），DispatcherServlet接收请求并拦截请求。

我们假设请求的url为：http://localhost:8080/SpringMVC_02-hello/hello

如上url拆分成三部分：

"http://localhost"：8080服务器域名
"SpringMVC_02-hello"：部署在服务器上的web站点
"hello"：表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC_02-hello站点的hello控制器。

2）HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler（可以根据xml配置、注解@RequestMapping进行查找）。

在这里，根据如上的 url 中的"hello"寻找 id 为"hello"的Handeler（此处在xml配置中找到）。

3）HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

4）HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

5）HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

6）Handler让具体的Controller执行，Controller调用业务层Service。

当Handler在完成逻辑处理后，通常会产生一些信息，这些信息就是需要返回给用户并在浏览器上显示的信息，它们被称为模型（Model）。仅仅返回原始的信息时不够的——这些信息需要以用户友好的方式进行格式化，一般会是 HTML，所以，信息需要发送给一个视图（view），通常会是 JSP。

7）Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView。

Handler所做的最后一件事就是将模型数据打包，并且表示出用于渲染输出的视图名(即代码中:mav.setViewName("index")的index，就是逻辑视图名)（逻辑视图名）。它接下来会将请求连同ModelAndView发送回HandlerAdaptor。

8）HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

但是DispatcherServlet不会处理这个ModelAndView，所以将其传给ViewResolver进行解析，ViewResolver根据逻辑视图名称解析真正的视图，并返回给DispatcherServlet。

9）DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

DispatcherServlet给他的ModelAndView都会经过视图解析器(ViewResolver)，视图解析器作用：

获取了ModelAndView的数据；
解析ModelAndView的视图名；
拼接视图名，找到对应的视图名；
将数据渲染到视图上。

10）视图解析器将解析的逻辑视图名传给DispatcherServlet。

11）DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12）最终视图呈现给用户。

在这里先听一遍原理，不理解没有关系，我们马上来写一个对应的代码实现大家就明白了，如果不明白，那就写10遍，没有笨人，只有懒人！

2、第一个MVC程序

2.1、配置版

1、新建一个Maven模块，命名为“SpringMVC_02-hello”。

2、确定导入了SpringMVC的依赖！

pom.xml：

 <packaging>war</packaging>
    <dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--springMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!--Servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--jstl标签表达式-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--jsp-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

        <!--Tomcat-->
        <dependency>
            <groupId>org.opoo.maven</groupId>
            <artifactId>tomcat9-maven-plugin</artifactId>
            <version>3.0.1</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.opoo.maven</groupId>
                <artifactId>tomcat9-maven-plugin</artifactId>
                <version>3.0.1</version>
            </plugin>
        </plugins>
    </build>

3、为模块添加web的支持！【具体参照步骤】https://mp.csdn.net/mp_blog/creation/editor/128439108

4、配置web.xml，注册DispatcherServlet。

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">

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--乱码过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

5、编写SpringMVC的配置文件！在resource包下新建文件，命名为：“springmvc-servlet.xml”:[servletname]-servlet.xml。

说明，这里的名称要求是按照官方来的

springmvc-servlet.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

6、添加处理映射器。

    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

7、添加处理器适配器。

    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

8、添加视图解析器。

    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

9、编写我们要操作业务Controller，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图。

package com.xushilin.controller;

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

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

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

10、将自己的类交给SpringIOC容器，注册bean。

    <!--Handler-->
    <bean id="/hello" class="com.xushilin.controller.HelloController"/>

11、写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面。

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

${msg}

</body>
</html>

运行结果：

异常处理： org.slf4j.impl.StaticLoggerBinder

解决方法——导入以下依赖：

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>

小结：我们实际开发才不会使用配置版写，不然过程太过繁琐。下面，我们来看个注解版实现，这才是SpringMVC的精髓，到底有多么简单，看这个图就知道了。

2.2、注解版

1、新建一个模块，并将该模块命名为："springmvc-03-hello-annotation"。然后在pom.xml中添加依赖项，再把"springmvc-03-hello-annotation"变成web模块！

【说明】由于Maven可能存在资源过滤的问题，我们将配置完善。

pom.xml:

<packaging>war</packaging>
    <dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--springMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.23</version>
        </dependency>

        <!--Servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--jstl标签表达式-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--jsp-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

        <!--Tomcat-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>

        <!--Tomcat-->
        <dependency>
            <groupId>org.opoo.maven</groupId>
            <artifactId>tomcat9-maven-plugin</artifactId>
            <version>3.0.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>maven-core</artifactId>
                    <groupId>org.apache.maven</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>slf4j-jdk14</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.opoo.maven</groupId>
                <artifactId>tomcat9-maven-plugin</artifactId>
                <version>3.0.1</version>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

2、配置web.xml。

注册DispatcherServlet。
关联SpringMVC的配置文件。
启动级别为1。
映射路径为 / 【不要用/*，会404】。

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">
<servlet>
    <!--SpringMVC的核心：搭建DispatchServlet（请求分发器/前端控制器）-->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--DispatchServlet要绑定的配置文件-->
    <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!--启动级别：1,数字越小，启动越早-->
    <load-on-startup>1</load-on-startup>
</servlet>
<!--所有请求都会被springmvc拦截-->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

--- SpringMvc中/和/*的区别 ---

当我们配置springMvc时，在url-pattern中有时会配置/有时是/*，那么这两者又有什么区别呢？我们来看一下：

/：代表拦截除后缀名以外的路径，即它只拦截路径，不拦截带后缀的url，若请求为/user/login.jsp，jsp不会进入DispatcherServlet类，即不会被过滤。
/*：代表拦截所有路径和后缀，会匹配所有的url，若请求为/user/login.jsp，会出现jsp进入DispatcherServlet类，导致找不到对应的controller，所以报404错误。

当然尽管写成了"/"，也不一定访问得到静态资源，如jsp、html、css等，要在springmvc.xml配置文件中加入<mvc:default-servlet-handler>标签，使静态页面能够访问，不被DispatcherServlet过滤，当然也有其他方法，这里指明最简单的方法，感兴趣可查其他文章。

综上所述：在配置springDispatcherServlet时，尽量使用"\"作为url-pattern的值。

3、添加Spring MVC配置文件。

在resource目录下添加springmvc-servlet.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"
       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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.xushilin.controller"/>
    <!-- 让Spring MVC不处理静态资源 .css .js .html等-->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <!--后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>
    
</beans>

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

4、创建Controller。

编写一个Java控制类：com.xushilin.controller.HelloController , 注意编码规范。

HelloController.java:

package com.xushilin.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/HelloController")
public class HelloController{
    @RequestMapping("/hello") //真实访问地址 : 项目名/HelloController/hello
    public String hello(Model model){
        String result = "Hello SpringMVC Annotation";
        //封装数据
        //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg",result);
        //这个方法需要返回一个字符串，这个字符串就是我们需要返回视图的名字
        return "hello"; //return的结果会被视图解析器处理成"/web-inf/jsp/hello.jsp"
    }
}

@Controller是为了让Spring IOC容器初始化时自动扫描到；
@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
方法中声明Model类型的参数是为了把Action中的数据带到视图中；
方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

5、创建视图层。

在WEB-INF/ jsp目录中创建hello.jsp ，视图可以直接取出并展示从Controller带回的信息。

可以通过EL表示取出Model中存放的值，或者对象。

hello.jsp:

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

运行结果：

【小结】

使用springMVC必须配置的三大件：

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而~~处理器映射器~~和~~处理器适配器~~只需要开启注解驱动即可省去大段的xml配置。

【声明】本文是“狂神说”公众号内容与个人学习过程中所思所想相结合而成。本博客仅供个人学习使用，如作商业用途，请联系原文作者，如有侵权，请联系本人删除！

【原文链接】https://mp.weixin.qq.com/s/yuQqZzAsCefk9Jv_kbh_eA

蕃茄匠

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC_02 什么是SpringMVC

Spring Web 模型-视图-控制器（MVC）框架是围绕一个将请求分派给处理程序，具有可配置的处理程序映射、视图分辨率、区域设置、时区和主题分辨率以及对上传文件。默认处理程序基于和注释，提供了多种灵活的处理方法。随着介绍 Spring 3.0，该机制还允许您创建RESTful网站和应用程序，通过注释和其他功能。
复制链接

扫一扫