【Spring MVC学习笔记 二】构建第一个Spring MVC框架程序

于 2021-08-31 20:41:11 发布
阅读量286 收藏 1
点赞数
分类专栏： # Spring MVC 文章标签： mvc spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33087001/article/details/120009979
版权
本文详细介绍了如何使用SpringMVC基于配置文件和注解两种方式创建前端控制器，包括步骤、配置文件编写、Controller实现、视图页面设计以及DispatcherServlet的整合。通过对比，展示了注解方式的灵活性和解耦优势。
摘要由CSDN通过智能技术生成

了解了基本的Spring MVC工作原理后，我们来构建第一个Spring MVC框架程序，用来做我们的前端控制器，管理Servlet。我们知道，无论是Spring还是MyBatis这种框架，都可以基于不同的形式构建，例如基于配置文件构建和基于注解构建，今天这篇Blog我们就两种方式都尝试一下，看看Spring MVC框架程序如何构建，我们接下来的实现针对框架部分来进行：
在这里插入图片描述

创建项目并导入Maven依赖

首先我们创建一个新项目，同以往一样我们创建一个Java Web项目然后通过pom.xml引入框架依赖：
在这里插入图片描述
然后我们导入相关需要使用到的依赖坐标：

<!--https://mvnrepository.com/仓库获取的最新包 20210831-->
    <dependencies>
        <!--Spring MVC框架依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!--JSP相关依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--servlet相关依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!--单元测试相关依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

基于配置构建

首先我们来基于配置文件进行构建，也就是基于配置构建。

1 新建一个Moudle

在总项目spring-mvc下我们新构建一个Moudle：base-config
在这里插入图片描述

2 编写控制器Controller

当然我们要编写处理业务逻辑的Controller，也就相当于之前的Servlet，我们新增一个文件夹controller，然后在里面新增一个HelloController ：

package com.example.base_config.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中
        modelAndView.setViewName("welcome"); //: /WEB-INF/jsp/welcome.jsp
        //封装对象，放在ModelAndView中Model
        modelAndView.addObject("msg","Welcome to tml first SpringMVC!");
        return modelAndView;
    }
}

其实查看Controller的源码也可以看的出，其本质上是个Servlet

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.web.servlet.mvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.ModelAndView;

@FunctionalInterface
public interface Controller {
    @Nullable
    ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

3 编写视图页

有了控制器，当然就需要有视图展示逻辑，我们在webapp下的/WEB-INF/jsp/目录中新增一个jsp文件：welcome.jsp

<%--
  Created by IntelliJ IDEA.
  User: 13304
  Date: 2021/8/31
  Time: 10:11
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

4 注册DispatcherServlet

真实的业务处理逻辑后端Controller以及视图展示逻辑都有了之后，我们再来开始Spring MVC的核心配置，首先就是在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">

    <!--配置前端控制器-->
    <servlet>
        <!--1.注册DispatcherServlet-->
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--关联一个springMVC的配置文件:【servlet-name】-servlet.xml-->
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1,在Tomcat启动时就初始化Spring容器-->
        <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>

5 编写springmvc-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">

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

    <!--配置2:处理器适配器-->
    <!--通过处理器适配器找到特定的Handler去执行-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--配置3:映射处理器-->
    <!--通过处理器映射器在url中寻找id为hello的Controller-->
    <bean id="/hello" class="com.example.base_config.controller.HelloController"/>

    <!--配置4:视图解析器-->
    <!--通过视图解析器解析处理器返回的逻辑视图名并传递给DispatcherServlet-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

5-1 添加处理映射器

添加处理映射器，作用是选择哪一个处理器(Controller)来处理当前请求，BeanNameUrlHandlerMapping表示：根据请求的URL去寻找对应的bean, 根据bean的id/name：

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

5-2 添加处理适配器

添加处理适配器，作用是 调用处理器(Controller)的处理请求的方法，所有的适配器都实现了HandlerAdapter接口
处理器(Controller)类必须实现org.springframework.web.servlet.mvc.Controller接口：

<!--配置2:处理器适配器-->
<!--通过处理器适配器找到特定的Handler去执行-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

5-3 配置映射处理器

配置映射处理器，作用是选择哪一个处理器(Controller)来处理当前请求，如果没有bean的id或者name和处理映射器匹配，那么依据这个自定义的映射规则查找处理器：

     <!--配置3:映射处理器-->
     <!--通过处理器映射器在url中寻找id为hello的Controller-->
    <bean id="/hello" class="com.example.base_config.controller.HelloController"/>

5-4 添加视图解析器

添加处理适配器，作用是处理dispatcherServlet(前端控制器)给它的ModelAndView

    <!--配置4:视图解析器-->
    <!--通过视图解析器解析处理器返回的逻辑视图名并传递给DispatcherServlet-->
    <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/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问

6 配置Tomcat服务器

配置文件编写好后，我们需要为我们的Module配置Tomcat服务器：
在这里插入图片描述
重新选择要打的包，选择我们自己的Moudle项目：
在这里插入图片描述

7 运行站点测试

启动Tomcat后访问站点，可以看到站点访问成功：
在这里插入图片描述

基于注解构建

基于注解构建和基于配置构建方式大同小异。

1 新建一个Moudle

在总项目spring-mvc下我们新构建一个Moudle：base-config
在这里插入图片描述
重新选择要打的包，选择我们自己的Moudle项目：

2 编写控制器Controller

控制器编写和基于配置的大不相同，因为我们是基于注解去实现的，所以不需要实现Controller接口：

package com.example.base_annotation.controller;

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

import java.time.LocalDate;

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

对于其中出现的几个注解介绍如下：

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

可以看到用注解去实现更贴近我们的业务逻辑一些，更加解耦，让我们理解上不掺杂框架的内容。

3 编写视图页

有了控制器，当然就需要有视图展示逻辑，我们在webapp下的/WEB-INF/jsp/目录中新增一个jsp文件：userInfo.jsp

<%--
  Created by IntelliJ IDEA.
  User: 13304
  Date: 2021/8/31
  Time: 11:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${userInfo}
</body>
</html>

4 注册DispatcherServlet

真实的业务处理逻辑后端Controller以及视图展示逻辑都有了之后，我们再来开始Spring MVC的核心配置，首先就是在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">

    <!--配置前端控制器-->
    <servlet>
        <!--1.注册DispatcherServlet-->
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--关联一个springMVC的配置文件:【servlet-name】-servlet.xml-->
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1,在Tomcat启动时就初始化Spring容器-->
        <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>

5 编写springmvc-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"
       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
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.example.base_annotation.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

    <!--视图解析器-->
    <!--通过视图解析器解析处理器返回的逻辑视图名并传递给DispatcherServlet-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

注意我们要应用如下的命名空间：

xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"

6 配置Tomcat服务器

配置文件编写好后，我们需要为我们的Module配置Tomcat服务器，注意不要和别的Moudle的端口冲突
在这里插入图片描述
重新选择要打的包，选择我们自己的Moudle项目：
在这里插入图片描述

7 运行站点测试

启动Tomcat后访问站点，可以看到站点访问成功：
在这里插入图片描述

回顾Spring MVC执行原理

实践完之后我们再来回顾下Spring MVC的原理，理解起来就更加深刻了：
在这里插入图片描述
如上图拆解的整体请求流程如下：其中DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。

  1. 用户发出请求，DispatcherServlet接收请求并拦截请求
  2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler
  3. HandlerExecution表示具体的Handler，其主要作用是根据url查找控制器，如上url被查找控制器为：hello
  4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等
  5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler
  6. Handler让具体的Controller执行
  7. Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView
  8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet
  9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
  10. 视图解析器将解析的逻辑视图名传给DispatcherServlet
  11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图
  12. 最终视图呈现给用户

上述流程中涉及到的组件释义如下：

  • DispatcherServlet：前端控制器，核心
    作用：接收请求，响应结果，相当于转发器，中央处理器，降低了组件之间的耦合性。
    用户发送请求交给DispatcherServlet，DispatcherServlet是整个流程控制的中心，由它调用其他组件处理用户请求，分发到具体的对应Controller，从而获取到需要的业务数据Model，Model再通过DispatcherServlet传递给View完成页面呈现；DispatcherServlet的存在降低了组件的之间的耦合性。
  • HandlerMapping：处理器映射器
    作用：根据请求的URL，找到对应的Handler，帮助DispatcherServlet找到对应的Controller
    HandlerMapping负责根据用户请求找到Handler即处理器，SpringMVC提供了多种不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。HandlerMapping返回给DispatcherServlet的不止Handler，还有上图中未出现的其它概念
    • HandlerInterceptor：Handler执行前后拦截器，其实这个可以通过AOP实现
      HandlerInterceptor是个接口，里面包含三个方法：preHandle、postHandle、afterCompletion
      分别在Handler执行前、执行中、执行完成后执行的三个方法
    • HandlerExecutionChain：HandlerMapping返回给DispatcherServlet的执行链
      HandlerMapping返回给DispatcherServlet的不光有Handler，还有HandlerInterceptorpreHandle——>ControllerMethod——>postHandle——>afterCompletion，这个链如何实现的呢？使用了Java的反射机制reflection
  • HandlerAdapter：处理器适配器
    作用：将各种Controller适配成DispatcherServlet可以使用的Handler，通过特定规则（HandlerAdapter要求的规则）去执行Handler，通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
  • Handler（Controller）：处理器（需要工程师开发）
    注意：编写Handler时需要HandlerAdapter的要求去做，这样HandlerAdapter才可以正确执行Handler
    Handler是继DispatcherServlet前端控制器的后台控制器，在DispatcherServlet控制下对用户请求进行处理，Handler涉及业务需求，所以需要工程师针对用户需求进行开发，最终返回业务数据
  • ModelAndView：SpringMVC中对Model的一种表示形式
    SpringMVC中有Model、Map，但是SpringMVC都会将其转化为ModelAndView，Model、Map都是ModelAndView的具体表现
  • ViewResolver：视图解析器
    作用：进行视图解析，根据逻辑视图名解析成真正的视图View
    ViewResolver负责将处理结果生成View视图，ViewResolver首先根据逻辑视图名解析成具体的页面地址，然后对View进行渲染，将处理结果通过页面展示给用户；SpringMVC提供了很多类型View视图，包括：jstlView、freemarkerView、pdfView、jsp、html等。
  • View：视图（需要工程师开发jsp、html）
    View是一个接口，实现类支持不同的类型（jsp、html、freemarker、pdf等）

以上就是整体的一个执行原理。整体项目架构如下：
在这里插入图片描述

总结一下

总的来说，Spring MVC就是一个大拦截器，所有请求都先被前端控制器拦截了，处理完一些通用的操作后，再被分发给各个对应的处理器进行处理和返回，通过配置大大简化了我们Servlet里的调度逻辑，将我们从复杂的需要理解Servlet协议的理论中剥离出来，只从业务的角度去分析和实现业务需求，换言之把我们从底层实现抽了出来，将代码变的更加像伪代码，像是描述文字，而不掺杂底层实现，这种感觉很奇妙，你知道了配置这个就能实现，底层怎么工作的，你不需要关心，这是好事还是坏事呢？对于知道原理的人是好事，对于不care原理的人其实是坏事。

存在morning
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

存在morning

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值