springMVC介绍

最新推荐文章于 2023-08-03 08:00:00 发布

崽Ziz

最新推荐文章于 2023-08-03 08:00:00 发布

阅读量689

点赞数

分类专栏：框架文章标签： springmvc web

本文链接：https://blog.csdn.net/loong_/article/details/115698361

版权

框架专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

Spring MVC

Spring MVC

SpringMVC是 Web层 的框架（Spring -> 业务层，Mybatis -> 持久层），SpringMVC是属于Spring的一个模块，两者无需通过中间整合。SpringMVC是一种基于Java，实现了Web MVC设计模式，最大的特点就是使用 请求—响应 模型。
早期的Web开发，存在一些弊端：JSP（页面）和Java Bean之间严重耦合，Java代码和HTML代码耦合；前后端相互依赖，代码难以复用。
发展之后形成了MVC模式，其中 M(模型)：数据，dao，bean；V(视图)：网页，JSP，用来显示模型中的数据；C(控制器)：把不同的数据显示在不同的视图上。

运行原理

在这里插入图片描述
运行步骤：

用户发起请求，URL到达前端控制器。
前端控制器请求处理器映射器查询Handler。
处理器映射器返回给前端控制器，返回处理器执行链(HanderExecutionChain)(包含多个处理拦截器和一个Handler实例)。
前端控制器请求处理器适配器执行Handler。
处理器适配器根据适配规则找到特定的处理器(后端controller层URL所绑定的方法)，由处理器来执行Handler
处理器执行结束后返回给处理器适配器一个 ModelAndView 对象，该对象包含数据（Model）和逻辑视图名
处理器适配器将ModelAndView对象返回给前端控制器。
前端控制器请求视图解析器解析视图地址，找到真正的视图。
视图解析器将真正视图对象返回到前端控制器。
将数据渲染到视图上。
将渲染的页面响应给请求用户。

各组件介绍

前端控制器（DispatcherServlet）
不需要开发，前端控制器是整个用户请求的入口，它用来完成各组件业务转发，所有组件都是直接和前端控制器交互，减少组件间的耦合性。
处理器映射器（HandlerMapping）
不需要开发，来存储URL和Handler之间的映射关系，由前端控制器来判断请求URL是否存在，并返回包含Handler的处理器执行链。
处理器适配器（HadlerAdapter）
不需要开发，按照特定的规则（HandlerAdapter要求的规则）去执行，Handler通过适配器找到真正的执行器，是适配器模式的使用。
处理器（Handler）
按照HandlerAdapter的要求开发，Handler是针对用户具体的业务逻辑做响应的处理，Handler涉及到用户的具体的业务逻辑需要自行开发Handler。
视图解析器（ViewResolver）
不需要开发，解析视图，根据逻辑视图名找到真正的视图，视图解析器负责解析View视图即页面的具体的地址位置，jsp、pdf、freeMark等都能完成解析。
视图（View）
需要开发，View是一个接口，支持不同的View类型（jsp、pdf、freeMark…）,例如 jsp是提供了一个 jstl，视图是展示给用户的页面，不同的业务展示不同的页面。

使用（Demo）

例：展示用户列表页面(开发的是处理器（获取用户信息）视图列表页面(JSP)）

引入依赖（在所建项目的 pom.xml文件中引入）：

<!--spring核心依赖-->
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-core</artifactId>      
  <version>4.1.7.RELEASE</version>          
</dependency>                               
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-beans</artifactId>     
  <version>4.1.7.RELEASE</version>          
</dependency>                               
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-context</artifactId>   
  <version>4.1.7.RELEASE</version>          
</dependency>                               
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-expression</artifactId>
  <version>4.1.7.RELEASE</version>          
</dependency>                               

<!--web依赖-->                                
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-webmvc</artifactId>    
  <version>4.1.7.RELEASE</version>          
</dependency>                               
<dependency>                                
  <groupId>org.springframework</groupId>    
  <artifactId>spring-web</artifactId>       
  <version>4.1.7.RELEASE</version>          
</dependency>                               
<dependency>                                
  <groupId>javax.servlet</groupId>          
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>                  
</dependency>

配置前端控制器（在web.xml配置文件下引入前端控制器的配置）

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <!--前端控制器-->
    <servlet>
        <servlet-name>springmvc211</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc211</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

url匹配规则：

<servlet-mapping>
      <!--
      三种写法：
      1. "*.action" 或者 "*.do"，访问形式以 .action 或 .do结尾的 url由 前端控制器（DispatcherServlet）进行解析
      2. "/" ,所有访问的 url都有 DispatcherServlet进行解析，对于静态文件（css，js）的解析是配置不让 DispatcherServlet进行解析实现 RESTFul风格的 url
      3. "/*",使用这个配置，会转发到 jsp的页面，DispatcherServlet任然会解析 jsp地址，不能根据 jsp找到 Handler，会抛出异常
       -->
    <servlet-name>springmvc211</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

url 找到前端控制器的过程：

将 SpringMVC 的配置添加在 web.xml文件中
需要在web.xml配置文件中引入前端控制器的实现类：org.springframework.web.servlet.DispatcherServlet

    <!--前端控制器-->
    <servlet>
        <servlet-name>springmvc211</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
        <!--将springMVC的配置文件进行配置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
    </servlet>

配置文件问题：

配置映射器、处理器等
需要给定SpringMVC特定的配置文件（spring-mvc.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 http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
    <!--SPringMVC需要扫描注解-->
    <context:component-scan base-package="com.tulun.controller"/>
    
    <!--配置处理器映射器、处理器适配器-->
    <mvc:annotation-driven/>
    
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    </bean>
</beans>

开发视图（userlist.jsp）

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <title>数据展示</title>
    </head>
    <body>
    <table align="center" border="1">
    <thead>
    <tr>
    <td>用户id</td>
    <td>用户名</td>
    </tr>
    </thead>
    <tbody>
    <c:forEach items="${users}" var="user">
        <tr>
        <td>${user.id}</td>
        <td>${user.name}</td>
        </tr>
    </c:forEach>
    </tbody>
    </table>
    </form>
    </body>
    </html>

开发Handler

@Controller
public class UserController {
    /**
     * 执行器
     * @return
     */
    @RequestMapping("/userlist")
    public ModelAndView userList(){
        //返回用户列表
        ArrayList <User> users = new ArrayList<>();
        User ce = new User(1, "ce");
        User hy = new User(2, "hy");
        User zbj = new User(3, "zbj");
        users.add(ce);
        users.add(hy);
        users.add(zbj);

        //封装 ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        //封装数据
        modelAndView.addObject("users",users);
        //封装逻辑视图名
        modelAndView.setViewName("/WEB-INF/jsp/userlist.jsp");
        return modelAndView;
    }
}

视图解析器前后缀简写：

在资源文件spring-mvc.xml中添加

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

UserController中视图名的全缀路径就可以省略前后缀，简写成名称。

前后缀简写，可以让我们在封装逻辑视图名时更加方便。（注意：当使用前后缀简写时，如果在写的时候没有简写，就会报错。）

jetty将服务部署到容器

容器有Tomcat、jetty等，这里使用 jetty插件方式来引入容器

<!--Jetty福服务器插件-->                                                                   
<plugin>                                                                             
    <groupId>org.mortbay.jetty</groupId>                                             
    <artifactId>maven-jetty-plugin</artifactId>                                      
    <version>6.1.24</version>                                                        
    <configuration>                                                                  
        <connectors>                                                                 
            <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                <port>8080</port>                                                    
                <maxIdleTime>30000</maxIdleTime>                                     
            </connector>                                                             
        </connectors>                                                                
        <contextPath>/</contextPath>                                                 
    </configuration>                                                                 
</plugin>

配置和启动结果如下：
在这里插入图片描述

在网页上输入 http://localhost:8080/userlist，访问过程如下（注意：不是url直接访问）：

网页显示：

web系统必须借助容器，将系统代码部署(jar、war指将代码编译生成的class文件)到容器。

前端控制器源码分析

前端控制器的实现类
org.springframework.web.servlet.DispatcherServlet 执行过程：

//所有 url的请求都会请求到doService方法上：
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
       //省略部分代码
        try {
        	//doDispatch方法是实现的核心
            doDispatch(request, response);
        }
        finally {
            //
        }
    }

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        //mappedHandler是处理器映射器返回的 HandlerExecutionChain类型的对象
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        try {
            ModelAndView mv = null;
            Exception dispatchException = null;
            try {
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);
                
                //第二步：前端控制器调用处理器查找 Handler
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (logger.isDebugEnabled()) {
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }
                //调用处理器是噢诶器执行 Handler，得到执行结果 ModelAndViewView
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
                applyDefaultViewName(request, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            //视图渲染，将数据渲染到视图中
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Error err) {
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

崽Ziz

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
springMVC介绍

文章目录Spring MVC运行原理各组件介绍SpringMVC的使用Demo开发视图（UserList.jsp）Spring MVC运行原理运行步骤：1、用户发起恩恩请求URL到达前端控制器2、前端控制器请求处理器映射器查询Handler3、处理器映射器返回给前端控制器，返回处理器执行链(HanderExecutionChain)(包含多个处理拦截器和一个Handler实例)4、前端控制器请求处理器适配器执行Handler。5、处理器适配器根据适配规则找到特定的处理器(后端controlle
复制链接

扫一扫