16.SpringMVC

LiQingFeng995

已于 2022-12-07 10:09:32 修改

阅读量947

点赞数

文章标签： mvc spring java

于 2021-09-09 13:53:22 首次发布

本文链接：https://blog.csdn.net/liqingfeng123456/article/details/119987758

版权

本文详细介绍了SpringMVC框架的核心概念、优缺点，以及其工作原理和执行流程。从配置版到注解版，逐步展示了如何创建第一个SpringMVC程序，包括配置web.xml、编写Controller、实现请求映射、结果跳转和数据处理。同时，文章还讨论了RESTful风格的使用，以及Ajax、拦截器和文件上传下载等高级特性。

摘要由CSDN通过智能技术生成

SpringMVC

一.概念

官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#spring-web
中文文档：http://c.biancheng.net/spring_mvc/

1、MVC框架要做哪些事情

将url映射到java类或java类的方法 .
获取用户请求数据 .
处理请求–调用相关的业务处理–封装响应数据 .
将响应的数据进行渲染到 jsp / html 等表示层 .

2、Spring MVC是什么

Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。
Spring MVC 是结构最清晰的 Servlet+JSP+JavaBean 的实现，是一个典型的教科书式的 MVC 构架，不像Struts 等其它框架都是变种或者不是完全基于 MVC 系统的框架。
Spring MVC 角色划分清晰，分工明细，并且和 Spring 框架无缝结合。Spring MVC 是当今业界最主流的 Web开发框架，以及最热门的开发技能。
在 Spring MVC 框架中，Controller 替换 Servlet 来担负控制器的职责，用于接收请求，调用相应的 Model 进行处理，处理器完成业务处理后返回处理结果。Controller 调用相应的 View 并对处理结果进行视图渲染，最终客户端得到响应信息。
Spring MVC 框架采用松耦合可插拔的组件结构，具有高度可配置性，比起其它 MVC 框架更具有扩展性和灵活性。
此外，Spring MVC 的注解驱动和对 REST风格的支持，也是它最具特色的功能。无论是在框架设计，还是扩展性、灵活性等方面都全面超越了 Struts2 等 MVC 框架。并且由于Spring MVC 本身就是 Spring 框架的一部分，所以可以说与 Spring 框架是无缝集成，性能方面具有先天的优越性，对于开发者来说，开发效率也高于其它的 Web 框架，在企业中的应用越来越广泛，成为主流的 MVC框架。

3、 Spring MVC优点

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

4、中心控制器

Spring MVC围绕DispatcherServlet设计，DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解@controller的声明方式。
Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
在这里插入图片描述

5、SpringMVC的原理及执行流程

原理
当发起请求时被**前置控制器（DispatcherServlet）**拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器（DispatcherServlet），控制器使用模型与视图渲染视图结果，将结果返回给中心控制器（DispatcherServlet），再将结果返回给请求者。
在这里插入图片描述
执行流程（重点）

图为SpringMVC的一个较完整的流程图，实线(有数字标识的）表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。
我们就只需要实现conroller对请求做怎样的操作（这里面包括调用业务获取数据库数据），然后写jsp（html）去展示。

简要分析执行流程（重点）

用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）；（对应第1步）
由 DispatcherServlet 请求一个或多个HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）；（对应2，3，4步）
DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；（对应第5步）
HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）；（对应第6步）
Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（SpringMVC的底层对象，包括 Model 数据模型和 View 视图信息）；（对应第7步）
HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；（对应第8步）
7.DispatcherServlet 接收到 ModelAndView 对象后，会请求ViewResolver（视图解析器）对视图进行解析；（对应第9步）
ViewResolver 根据 View 信息匹配到相应的视图结果（获取jsp等资源完整路径），并返回给 DispatcherServlet；（对应第10步）
DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View视图中的 request 域，生成最终的 View（视图）；（对应第11步）
视图负责将结果显示到浏览器（客户端）。（对应第12步）

二.第一个springMVC程序

1.配置版（讲原理用的）

1.1、创建普通maven项目（我们采用普通maven项目来创建web项目，记得添加web框架支持）
在这里插入图片描述
1.2、导入spring-webmvc依赖及资源过滤（确保java包下的xml文件也能生成）

	<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

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

1.3、配置web.xml ，注册DispatcherServlet

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

</web-app>

1.4 、SpringMVC的配置文件springmvc-servlet.xml（springmvc-servlet.xml要和上面的web.xml中的配置名一样，因为我们所有的访问都是通过web.xml来找到spring的配置文件，是唯一入口）
SpringMVC的配置文件springmvc-servlet.xml 本质就是spring的配置文件

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

1.5、springmvc-servlet.xml文件中添加处理器映射器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

1.6、springmvc-servlet.xml文件中添加处理器适配器

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

1.7、springmvc-servlet.xml文件中添加视图解析器

<!--视图解析器: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>

1.8、编写我们要操作业务的Controller类，实现Controller接口。需要返回一个ModelAndView，装数据，封视图

package com.liqingfeng.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 HelloController implements Controller {
   

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
   
        //ModelAndView 模型和视图
        ModelAndView modelAndView = new ModelAndView();
        //封装对象，放在ModelAndView中。Model
        modelAndView.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        modelAndView.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return modelAndView;
    }
}

1.9、将自己的类交给SpringIOC容器（springmvc-servlet.xml），注册bean

<!--Handler-->
    <bean id="/helloController" class="com.liqingfeng.controller.HelloController"/>

1.10、写要跳转的hello.jsp页面

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

1.11、配置Tomcat，启动测试！
这里配置时打包war包时的类型如果是Web Application：Exploded则实际运行环境在当前项目的out文件夹里，如果为Web Application：Archive则实际运行环境在tomcat的webapps里的项目。
在这里插入图片描述

在这里插入图片描述

可能遇到的问题：访问出现404，解决办法： 在项目结构中如图创建lib文件夹，添加所有的依赖包进来
在这里插入图片描述

2.注解版（正片）

1、新建一个普通maven项目工程（添加web框架支持
2、在pom.xml文件引入相关的依赖：

	<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

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

3、配置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.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!-- 启动顺序，数字越小，启动越早 -->
       <load-on-startup>1</load-on-startup>
   </servlet>

   <!--所有请求都会被springmvc拦截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

</web-app>

注意点：
/ 和 /* 的区别：< url-pattern > / </ url-pattern > 不会匹配到.jsp，只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类。< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。

注意web.xml版本问题，要最新4.0版！
注册DispatcherServlet
关联SpringMVC的配置文件
启动级别为1
映射路径为 / 【不要用/*，会404】

4、添加Spring MVC配置文件springmvc-servlet.xml
在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：

<?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.liqingfeng.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

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

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

让IOC的注解生效
静态资源过滤：HTML . JS . CSS . 图片，视频 …
<context:component-scan base-package=“…”/>是为了使指定报下的类注解生效
<mvc:default-servlet-handler />是为了忽略jsp、html、图片等资源
<mvc:annotation-driven />，省去了映射器和适配器的配置
配置视图解析器

5、创建Controller

package com.liqingfeng.controller;

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

@Controller
@RequestMapping("/HelloController")
public class HelloController {
   
    //真实访问地址 : 项目名/HelloController/hello
    @RequestMapping("/hello")
    public String sayHello(Model model){
   
        //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        //web-inf/jsp/hello.jsp
        return "hello";
    }
}

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

6、创建视图层

在WEB-INF/ jsp目录中创建hello.jsp ，视图可以直接取出并展示从Controller带回的信息；
可以通过EL表达式取出Model中存放的值，或者对象；

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

7、配置Tomcat，测试运行
这里配置时打包war包时的类型如果是Web Application：Exploded则实际运行环境在当前项目的out文件夹里，如果为Web Application：Archive则实际运行环境在tomcat的webapps里的项目。
在这里插入图片描述
配置Tomcat ，开启服务器，访问对应的请求路径！（记得项目结构添加lib导入所以依赖包）

小结，springMVC实现步骤：

新建一个web项目
导入相关jar包
编写web.xml , 注册DispatcherServlet
编写springmvc配置文件
接下来就是去创建对应的控制类 , controller
最后完善前端视图和controller之间的对应
测试运行调试.

使用springMVC必须配置的三大件：处理器映射器、处理器适配器、视图解析器。通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

三.控制器Controller

控制器提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
控制器负责解析用户的请求并将其转换为一个模型。

1.实现Controller接口来定义控制器

比如ControllerTest1 类实现Controller 接口，即为一个控制器

public class ControllerTest1 implements Controller {
   
   public ModelAndView handleRequest(HttpServletRequest httpServ

最低0.47元/天解锁文章

LiQingFeng995

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫