Springmvc简介（一）

最新推荐文章于 2019-01-24 17:23:39 发布

caoyue_new

最新推荐文章于 2019-01-24 17:23:39 发布

阅读量291

点赞数

本文链接：https://blog.csdn.net/caoyue_new/article/details/75530497

版权

Spring 框架专栏收录该内容

24 篇文章 0 订阅

订阅专栏

参考：springmvc官方文档

一、概述

Spring mvc 是 spring 为展现层提供的基于 MVC 设计理念的一个优秀的web框架，是目前最流行的 MVC 框架之一。

优点：

Spring mvc 通过一套 MVC 注解让 POJO 成为处理请求控制器，而无需实现任何的接口。
支持 REST 风格的 URL 请求
采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性

1.1 Spring MVC处理请求的流程

这里写图片描述
1、首先用户发送请求–>前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；上图中的1、2步骤；
2、页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，这个对象在Spring Web MVC中叫命令对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；上图中的3、4、5步骤；
3、前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；上图中的步骤6、7；
4、前端控制器再次收回控制权，将响应返回给用户，上图中的步骤8；

1.2 Spring MVC核心架构

这里写图片描述

//前端控制器分派方法
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
int interceptorIndex = -1;

    try {
        ModelAndView mv;
        boolean errorView = false;

        try {
                  //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析
            processedRequest = checkMultipart(request);
                  //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射
            mappedHandler = getHandler(processedRequest, false);
            if (mappedHandler == null || mappedHandler.getHandler() == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
                  //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                 // 304 Not Modified缓存支持
            //此处省略具体代码

            // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）
            //此处省略具体代码

            // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            // Do we need view name translation?
            if (mv != null && !mv.hasView()) {
                mv.setViewName(getDefaultViewName(request));
            }

            // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）
            //此处省略具体代码
        }
        catch (ModelAndViewDefiningException ex) {
            logger.debug("ModelAndViewDefiningException encountered", ex);
            mv = ex.getModelAndView();
        }
        catch (Exception ex) {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(processedRequest, response, handler, ex);
            errorView = (mv != null);
        }

        //步骤5 步骤6、解析视图并进行视图的渲染
//步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）
//步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）
        if (mv != null && !mv.wasCleared()) {
            render(mv, processedRequest, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                        "': assuming HandlerAdapter completed request handling");
            }
        }

        // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）
        //此处省略具体代码


    catch (Exception ex) {
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    }
    catch (Error err) {
        ServletException ex = new NestedServletException("Handler processing failed", err);
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    }

    finally {
        // Clean up any resources used by a multipart request.
        if (processedRequest != request) {
            cleanupMultipart(processedRequest);
        }
    }
}

1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
2、 DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、 DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
4、 HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
5、 ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、 View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

此处我们只是讲了核心流程，没有考虑拦截器、本地解析、文件上传解析等，后边再细述。

二、HelloWorld

基本学习任何语言、框架都是从helloworld开始，这里我们也不例外。

使用maven管理项目。

2.1 引入包

<dependency>
<groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
    <!-- spring 相关 -->
      <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
      <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${org.springframework-version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${org.springframework-version}</version>
</dependency>

2.2 配置web.xml

<!-- 配置DispatchServlet -->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置Spring mvc下的配置文件的位置和名称 -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param> 
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

DispatcherServlet默认加载/WEB-INF/<servletName-servlet>.xml的Spring配置文件，可以通过contextConfigLocation初始化参数自定义配置文件的路径和名称。

2.3 配置spring-mvc.xml

 <!-- 配置自动扫描的包 -->
<context:component-scan base-package="com.crystal.springmvc"></context:component-scan>

<!-- 配置视图解析器 如何把handler 方法返回值解析为实际的物理视图 (这里解析成/WEB-INF/jsp/<viewName>.jsp)-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name = "prefix" value="/WEB-INF/jsp/"></property>
    <property name = "suffix" value = ".jsp"></property>
</bean>

2.4 创建请求处理类

@Controller
public class HelloWorld {

    @RequestMapping("/helloworld")
    public String helloworld() {
        System.out.println("helloworld mvc");
        return "success";
    }
}

2.5 创建success.jsp

在/WEB-INF/jsp目录下面创建请求成功响应页面。

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    hello world mvc
</body>
</html>

caoyue_new

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Springmvc简介（一）

参考：springmvc官方文档一、概述Spring mvc 是 spring 为展现层提供的基于 MVC 设计理念的一个优秀的web框架，是目前最流行的 MVC 框架之一。优点：Spring mvc 通过一套 MVC 注解让 POJO 成为处理请求控制器，而无需实现任何的接口。支持 REST 风格的 URL 请求采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性
复制链接

扫一扫