SpringMVC原理剖析

Posted 2022-12-01 Ferron Zhu

初识SpringMVC

• 概述
• SpringMVC原理剖析
• 回顾Servlet
• 原生态SpringMVC
• 使用注解实现SpringMVC
• 结尾

概述

笔者这段时间在学习SpringMVC，于是突发奇想想写一篇博客来记录学习的过程，希望自己巩固知识的同时，也能帮助到别人。

SpringMVC原理剖析

SpringMVC是基于Java实现MVC的轻量级Web框架。原来的MVC框架是由servlet，javabean，jsp构成。在SpringMVC中，一切的核心是DispatcherServlet。DispatcherServlet的本质也是一个servlet，用户的所有请求都会通过这个核心的DispatcherServlet，进而协调整个MVC框架。
SpringMVC的工作流程如下：

1. 用户的请求首先会通过DispatcherServlet，DispatcherServlet接收到用户请求的url时，调用HandlerMapping查找对应url的handler，并向DispatcherServlet返回对应的HandlerExecution(handler)。
2. DispatcherServlet接收到对应的HandlerExecution，将传递给HandlerAdapter，HandlerAdapter再让具体的控制器(Controller）去执行
3. Controller执行业务代码后，将ModelAndView返回给HanderAdapter，HanderAdapter再传递给DispatcherServlet。
4. DispatcherServlet接收到ModelAndView结果后，会调用ViewResolver去解析视图。
5. DispatcherServlet根据ViewResolver的解析结果，调用具体视图响应给用户。

回顾Servlet

因为SpringMVC的核心终究还是Servlet，因此在实现SpringMVC之前，我们先来回顾一下之前我们是怎么实现Servlet的。

1. 首先新建一个空Maven项目，删掉其src文件夹，作为本篇文章所有项目的父项目，在父项目中导入相关依赖，同时固定jdk的版本。（因为笔者每次新建项目时jdk默认为1.5，目前对于笔者来说直接使用代码固定jdk版本更方便）

<dependencies>
      <!-- Srping依赖 -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.9.RELEASE</version>
      </dependency>
      <!-- junit单元测试-->
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
      </dependency>
      <!-- Servlet依赖 -->
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>4.0.1</version>
      </dependency>
      <!-- JSP依赖 -->
      <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.1</version>
      </dependency>
      <!-- JSTL表达式依赖 -->
      <dependency>
          <groupId>javax.servlet.jsp.jstl</groupId>
          <artifactId>jstl-api</artifactId>
          <version>1.2</version>
      </dependency>
      <!-- Standard标签库 -->
      <dependency>
          <groupId>taglibs</groupId>
          <artifactId>standard</artifactId>
          <version>1.1.2</version>
      </dependency>
  </dependencies>
  <!--固定jdk版本-->
  <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
      <java.version>11</java.version>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
  </properties>

2. 新建一个module，添加Web框架支持。
3. 编写HelloServlet，

public class HelloServlet extends HttpServlet 
   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 

       //业务代码
       String msg = "这个Servlet的结果";
       req.getSession().setAttribute("msg",msg);
       //转发
       req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

   
   @Override
   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
       doGet(req, resp);
   

4. 编写前端页面，前端页面提取msg。
5. 配置Tomcat，测试。
   

原生态SpringMVC

1. 新建一个module，这里建立一个空的Maven项目，同时添加web框架支持。同时在项目结构处新建lib文件夹，手动将依赖导入。（因为不使用模板创建Maven项目有时依赖会无法导入，运行时网页会报404，下面使用注解实现SpringMVC做同样操作）
2. 编写web.xml配置文件。在这里注册了SpringMVC的核心DispatcherServlet。因为SpringMVC已经帮我们写好DispatcherServlet，我们只需要直接在web.xml中注册就好了。注册的同时需要绑定springmvc的核心配置文件springmvc-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>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

3. 编写核心配置文件springmvc-servlet.xml。在该配置文件中注册SpringMVC中的HandlerMapping，HanderAdapter，ViewResolver。因为这三个SpringMVC也已经帮我们写好了，所以只需要直接注册就行~

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    
</beans>

4. 编写一个控制器HelloController。ModelAndView是用来传递业务结果的。

public class HelloController implements Controller 
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception 
        ModelAndView mav = new ModelAndView();

        mav.addObject("msg","这是SpringMVC的结果");
        mav.setViewName("test");

        return mav;
    

5. 编写完控制器之后，别忘了在springmvc-servlet.xml中注册。

<bean id="/t2" class="com.ferron.controller.HelloController"/>

6. 编写前端页面，前端页面提取msg。
7. 配置Tomcat，测试
   

使用注解实现SpringMVC

1. 新建module，添加web框架支持。
2. 编写同上的web.xml配置文件
3. 编写核心配置文件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
        https://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">

    <!--扫描包下的注解，让注解生效-->
    <context:component-scan base-package="com.ferron.controller"/>
    <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>

</beans>

4. 编写一个控制器HelloControllerAnno。使用@Controller注解将其标记为一个控制器，此时就默认注册到springmvc-servlet.xml中了，使用@RequestMapping指定其请求url。

@Controller
public class HelloControllerAnno 

    @RequestMapping("/t3")
    public String test3(Model model)
        model.addAttribute("msg","这是SpringMVC注解的结果");

        return "test";
    

5. 编写前端页面，提取msg。
6. 配置Tomcat，测试
   

结尾

笔者是一个喜欢编程的985理工男，金融科技专业。目前在学习Java全栈技术，过段时间可能会开始接触大数据架构、区块链技术、云计算架构和人工智能等技术的学习，这是我第一次写博客，不足之处希望大家多多谅解。另外对于这篇博客有其他好的想法，以及有提高博客排版的建议，欢迎大家提出~~