Spring MVC 学习总结（一）——MVC概要与环境配置（IDea与Eclipse示例）

当前位置：网站建设 > 技术支持

Spring MVC 学习总结（一）——MVC概要与环境配置（IDea与Eclipse示例）

资料来源：网络整理时间：2023/2/14 0:52:22 共计：3644 浏览

一、MVC概要

二、Spring MVC介绍

三、第一个Spring MVC 项目：Hello World（Eclipse版）

3.1、通过Maven新建一个Web项目

3.2、添加依赖的jar包

3.3、修改web.xml注册中心控制器DispatcherServlet

3.4、添加Spring MVC配置文件

3.5、创建HelloWorld控制器

3.6、创建视图

3.7、测试运行

四、第一个Spring MVC 项目：Hello World（IDEA）

4.1、在IDEA中使用Maven根据WebApp骨架创建一个项目

4.2、添加依赖的jar包

4.3、修改web.xml注册中心控制器DispatcherServlet

4.4、添加Spring MVC配置文件

4.5、创建HelloWorld控制器

4.6、创建视图

4.7、配置TomCat部署项目

4.8、测试运行

五、设置引导页

5.1、方法一

5.2、方法二

六、示例下载

七、视频

八、作业

一、MVC概要

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范，用一种将业务逻辑、数据、显示分离的方法组织代码，MVC主要作用是降低了视图与业务逻辑间的双向偶合。MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

在web早期的开发中，通常采用的都是Model1。Model1中，如图所示主要分为两层，视图层和模型层。Model2把一个项目分成三部分，包括视图、控制、模型。这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。

Model1

Model2

1、Model1适合小型项目开发，结构简单，开发迅速。但是JSP页面相对复杂，不利于维护。

2、Model2适合大型项目开发，职责明确，而且适应变动的需求，目的是可复用、可扩展、可维护。

3、从模型上和时序图上很容易看出，Model2是在Model1的基础上，分离了控制，将业务逻辑处理分离出来。这样Model2相对来说便于维护。

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM。

二、Spring MVC介绍

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。Spring MVC的特点：

1、轻量

2、高效

3、与Spring兼容性好

4、功能强大

RESTful、数据验证、格式化、绑定机制、本地化、主题等

5、简洁灵活

Spring的web框架围绕DispatcherServlet设计。 DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。官网上说Spring的web模块提供了大量独特的功能，包括:

清晰的角色划分：控制器（controller）、验证器（validator）、命令对象（command object）、表单对象（form object）、模型对象（model object）、 Servlet分发器（DispatcherServlet）、处理器映射（handler mapping）、视图解析器（view resolver）等等。每一个角色都可以由一个专门的对象来实现。

强大而直接的配置方式：将框架类和应用程序类都能作为JavaBean配置，支持跨多个context的引用，例如，在web控制器中对业务对象和验证器（validator）的引用。

可适配、非侵入：可以根据不同的应用场景，选择合适的控制器子类（simple型、command型、form型、wizard型、multi-action型或者自定义），而不是从单一控制器（比如Action/ActionForm）继承。

可重用的业务代码：可以使用现有的业务对象作为命令或表单对象，而不需要去扩展某个特定框架的基类。

可定制的绑定（binding）和验证（validation）：比如将类型不匹配作为应用级的验证错误，这可以保存错误的值。再比如本地化的日期和数字绑定等等。在其他某些框架中，你只能使用字符串表单对象，需要手动解析它并转换到业务对象。

可定制的handler mapping和view resolution：Spring提供从最简单的URL映射，到复杂的、专用的定制策略。与某些web MVC框架强制开发人员使用单一特定技术相比，Spring显得更加灵活。

灵活的model转换：在Springweb框架中，使用基于Map的键/值对来达到轻易地与各种视图技术的集成。

可定制的本地化和主题（theme）解析：支持在JSP中可选择地使用Spring标签库、支持JSTL、支持Velocity（不需要额外的中间层）等等。

简单而强大的JSP标签库（Spring Tag Library）：支持包括诸如数据绑定和主题（theme）之类的许多功能。它提供在标记方面的最大灵活性。

JSP表单标签库：在Spring2.0中引入的表单标签库，使得在JSP中编写表单更加容易。

Spring Bean的生命周期可以被限制在当前的HTTP Request或者HTTP Session。准确的说，这并非Spring MVC框架本身特性，而应归属于Sping MVC使用的WebApplicationContext容器。

三、第一个Spring MVC 项目：Hello World（Eclipse版）

3.1、通过Maven新建一个Web项目

在Eclipse中新建Maven项目，选择“Create a simple project”，创建一个简单项目，不选择模板。

修改层面信息，更加详细的内容请参考前面写过的文章：

将webcontent中的所有内容复制到webapp目录下，并删除webContent目录，删除后的结果如下：

修改项目的部署信息，删除测试文件夹，添加webapp为项目根目录：

如果不打算在pom.xml中添加对Server runtime的依赖，则这里必须手动添加依赖，如下图所示：

另外如果pom.xml报错，修改任意位置保存。

3.2、添加依赖的jar包

1、修改pom.xml文件、添加jar包的依赖，主要有：Spring框架核心库、Spring MVC、JSTL等，具体信息如下：

复制代码

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>com.zhangguo</groupId>

<artifactId>SpringMVC01</artifactId>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<spring.version>4.3.0.RELEASE</spring.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

</dependencies>

</project>

复制代码

当依赖成功时，会加载的jar包如下：

3.3、修改web.xml注册中心控制器DispatcherServlet

Spring MVC框架像许多其他MVC框架一样, 请求驱动,围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。如下图所示当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

修改web.xml文件注册该Servlet，修改后的web.xml文件如下：

复制代码

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

id="WebApp_ID" version="3.0">

<servlet-name>springmvc</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath*:springmvc-servlet.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>springmvc</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

</web-app>

复制代码

3.4、添加Spring MVC配置文件

在src/main/java源代码目录下添加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

http://www.springframework.org/schema/context/spring-context-4.3.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">

<context:component-scan base-package="com.zhangguo.springmvc01" />

<mvc:default-servlet-handler />

<mvc:annotation-driven />

<bean

class="org.springframework.web.servlet.view.InternalResourceViewResolver"

id="internalResourceViewResolver">

</bean>

</beans>

复制代码

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

mvc:annotation-driven：

在spring中一般采用@RequestMapping注解来完成映射关系，要想使@RequestMapping注解生效必须向上下文中注册DefaultAnnotationHandlerMapping和一个AnnotationMethodHandlerAdapter实例，这两个实例分别在类级别和方法级别处理。而annotation-driven配置帮助我们自动完成上述两个实例的注入。

3.5、创建HelloWorld控制器

在src/main/java源代码目录下创建包com.zhangguo.springmvc01.controller，在包下创建一个普通的类：HelloWorld，具体代码如下：

复制代码

package com.zhangguo.springmvc01.controller;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

@Controller

@RequestMapping("/Hello")

public class HelloWorld {

@RequestMapping("/Sayhi")

public String SayHi(Model model) {

model.addAttribute("message", "Hello Spring MVC!");

return "sayhi";

}

复制代码

注解为@Controller是为了让Spring IOC容器初始化时自动扫描到；@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/Hello/Sayhi；方法中声明Model类型的参数是为了把Action中的数据带到视图中；方法返回的结果是视图的名称sayhi。

3.6、创建视图

在WEB-INF/view目录中创建视图，视图将从Action中带回的信息展示，具体内容如下：

复制代码

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<!DOCTYPE html>

<html>

<head>

<title>Hello Spring MVC!</title>

</head>

<body>

<h2>${message}</h2>

</body>

</html>

复制代码

3.7、测试运行

启动Tomcat运行项目，请注意查看启动信息，如果有异常应该先解决异常信息，运行成功后的结果如下所示：

四、第一个Spring MVC 项目：Hello World（IDEA）

4.1、在IDEA中使用Maven根据WebApp骨架创建一个项目

在Idea中新建Maven项目，选择“org.apache.maven.archetypes:maven-archetype-webapp”骨架（模板），创建一个Web项目：

输入项目的坐标：

选择仓库位置与配置信息，建议使用默认设置（先使用IDEA的默认设置将Maven配置好）

设置项目位置，完成即可

初始化的项目如下：

根据Maven规范，需要创建源代码、资源与测试目录：

在main上右键创建java目录、resources目录，创建与main平级的test测试目录：

设置目录的特殊属性：

设置完成后的结果：

4.2、添加依赖的jar包

1、修改pom.xml文件、添加jar包的依赖，主要有：Spring框架核心库、Spring MVC、JSTL等，具体信息如下：

复制代码

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>com.zhangguo.springmvc01</groupId>

<artifactId>SpringMVC01</artifactId>

<version>1.0-SNAPSHOT</version>

<name>SpringMVC01 Maven Webapp</name>

<url>http://www.example.com</url>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<maven.compiler.source>1.7</maven.compiler.source>

<maven.compiler.target>1.7</maven.compiler.target>

<spring.version>4.3.0.RELEASE</spring.version>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>javax.servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

</dependencies>

<build>

<finalName>SpringMVC01</finalName>

<artifactId>maven-clean-plugin</artifactId>

</plugin>

<artifactId>maven-resources-plugin</artifactId>

</plugin>

<artifactId>maven-compiler-plugin</artifactId>

</plugin>

<artifactId>maven-surefire-plugin</artifactId>

</plugin>

<artifactId>maven-war-plugin</artifactId>

</plugin>

<artifactId>maven-install-plugin</artifactId>

</plugin>

<artifactId>maven-deploy-plugin</artifactId>

</plugin>

</plugins>

</pluginManagement>

</build>

</project>

复制代码

当依赖成功时，会加载的jar包如下：

4.3、修改web.xml注册中心控制器DispatcherServlet

Spring MVC中心控制器的源码如下：

/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.springframework.web.servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.i18n.LocaleContext;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.ui.context.ThemeSource;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.async.WebAsyncManager;
import org.springframework.web.context.request.async.WebAsyncUtils;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.util.NestedServletException;
import org.springframework.web.util.WebUtils;

/**
* Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers
* or HTTP-based remote service exporters. Dispatches to registered handlers for processing
* a web request, providing convenient mapping and exception handling facilities.
*
* This servlet is very flexible: It can be used with just about any workflow, with the
* installation of the appropriate adapter classes. It offers the following functionality
* that distinguishes it from other request-driven web MVC frameworks:
*
* <ul>
* <li>It is based around a JavaBeans configuration mechanism.
*
* <li>It can use any {@link HandlerMapping} implementation - pre-built or provided as part
* of an application - to control the routing of requests to handler objects. Default is
* {@link org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping} and
* {@link org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping}.
* HandlerMapping objects can be defined as beans in the servlet's application context,
* implementing the HandlerMapping interface, overriding the default HandlerMapping if
* present. HandlerMappings can be given any bean name (they are tested by type).
*
* <li>It can use any {@link HandlerAdapter}; this allows for using any handler interface.
* Default adapters are {@link org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter},
* {@link org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter}, for Spring's
* {@link org.springframework.web.HttpRequestHandler} and
* {@link org.springframework.web.servlet.mvc.Controller} interfaces, respectively. A default
* {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter}
* will be registered as well. HandlerAdapter objects can be added as beans in the
* application context, overriding the default HandlerAdapters. Like HandlerMappings,
* HandlerAdapters can be given any bean name (they are tested by type).
*
* <li>The dispatcher's exception resolution strategy can be specified via a
* {@link HandlerExceptionResolver}, for example mapping certain exceptions to error pages.
* Default are
* {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver},
* {@link org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver}, and
* {@link org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver}.
* These HandlerExceptionResolvers can be overridden through the application context.
* HandlerExceptionResolver can be given any bean name (they are tested by type).
*
* <li>Its view resolution strategy can be specified via a {@link ViewResolver}
* implementation, resolving symbolic view names into View objects. Default is
* {@link org.springframework.web.servlet.view.InternalResourceViewResolver}.
* ViewResolver objects can be added as beans in the application context, overriding the
* default ViewResolver. ViewResolvers can be given any bean name (they are tested by type).
*
* <li>If a {@link View} or view name is not supplied by the user, then the configured
* {@link RequestToViewNameTranslator} will translate the current request into a view name.
* The corresponding bean name is "viewNameTranslator"; the default is
* {@link org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator}.
*
* <li>The dispatcher's strategy for resolving multipart requests is determined by a
* {@link org.springframework.web.multipart.MultipartResolver} implementation.
* Implementations for Apache Commons FileUpload and Servlet 3 are included; the typical
* choice is {@link org.springframework.web.multipart.commons.CommonsMultipartResolver}.
* The MultipartResolver bean name is "multipartResolver"; default is none.
*
* <li>Its locale resolution strategy is determined by a {@link LocaleResolver}.
* Out-of-the-box implementations work via HTTP accept header, cookie, or session.
* The LocaleResolver bean name is "localeResolver"; default is
* {@link org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver}.
*
* <li>Its theme resolution strategy is determined by a {@link ThemeResolver}.
* Implementations for a fixed theme and for cookie and session storage are included.
* The ThemeResolver bean name is "themeResolver"; default is
* {@link org.springframework.web.servlet.theme.FixedThemeResolver}.
* </ul>
*
* NOTE: The {@code @RequestMapping} annotation will only be processed if a
* corresponding {@code HandlerMapping} (for type-level annotations) and/or
* {@code HandlerAdapter} (for method-level annotations) is present in the dispatcher.
* This is the case by default. However, if you are defining custom {@code HandlerMappings}
* or {@code HandlerAdapters}, then you need to make sure that a corresponding custom
* {@code DefaultAnnotationHandlerMapping} and/or {@code AnnotationMethodHandlerAdapter}
* is defined as well - provided that you intend to use {@code @RequestMapping}.
*
* A web application can define any number of DispatcherServlets.
* Each servlet will operate in its own namespace, loading its own application context
* with mappings, handlers, etc. Only the root application context as loaded by
* {@link org.springframework.web.context.ContextLoaderListener}, if any, will be shared.
*
* As of Spring 3.1, {@code DispatcherServlet} may now be injected with a web
* application context, rather than creating its own internally. This is useful in Servlet
* 3.0+ environments, which support programmatic registration of servlet instances.
* See the {@link #DispatcherServlet(WebApplicationContext)} javadoc for details.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Rob Harrop
* @author Chris Beams
* @author Rossen Stoyanchev
* @see org.springframework.web.HttpRequestHandler
* @see org.springframework.web.servlet.mvc.Controller
* @see org.springframework.web.context.ContextLoaderListener
*/
@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {

 /** Well-known name for the MultipartResolver object in the bean factory for this namespace. */
 public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";

 /** Well-known name for the LocaleResolver object in the bean factory for this namespace. */
 public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";

 /** Well-known name for the ThemeResolver object in the bean factory for this namespace. */
 public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";

 /**
 * Well-known name for the HandlerMapping object in the bean factory for this namespace.
 * Only used when "detectAllHandlerMappings" is turned off.
 * @see #setDetectAllHandlerMappings
 */
 public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";

 /**
 * Well-known name for the HandlerAdapter object in the bean factory for this namespace.
 * Only used when "detectAllHandlerAdapters" is turned off.
 * @see #setDetectAllHandlerAdapters
 */
 public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";

 /**
 * Well-known name for the HandlerExceptionResolver object in the bean factory for this namespace.
 * Only used when "detectAllHandlerExceptionResolvers" is turned off.
 * @see #setDetectAllHandlerExceptionResolvers
 */
 public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";

 /**
 * Well-known name for the RequestToViewNameTranslator object in the bean factory for this namespace.
 */
 public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";

 /**
 * Well-known name for the ViewResolver object in the bean factory for this namespace.
 * Only used when "detectAllViewResolvers" is turned off.
 * @see #setDetectAllViewResolvers
 */
 public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";

 /**
 * Well-known name for the FlashMapManager object in the bean factory for this namespace.
 */
 public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";

 /**
 * Request attribute to hold the current web application context.
 * Otherwise only the global web app context is obtainable by tags etc.
 * @see org.springframework.web.servlet.support.RequestContextUtils#findWebApplicationContext
 */
 public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";

 /**
 * Request attribute to hold the current LocaleResolver, retrievable by views.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getLocaleResolver
 */
 public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";

 /**
 * Request attribute to hold the current ThemeResolver, retrievable by views.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getThemeResolver
 */
 public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";

 /**
 * Request attribute to hold the current ThemeSource, retrievable by views.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getThemeSource
 */
 public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";

 /**
 * Name of request attribute that holds a read-only {@code Map<String,?>}
 * with "input" flash attributes saved by a previous request, if any.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getInputFlashMap(HttpServletRequest)
 */
 public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";

 /**
 * Name of request attribute that holds the "output" {@link FlashMap} with
 * attributes to save for a subsequent request.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getOutputFlashMap(HttpServletRequest)
 */
 public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";

 /**
 * Name of request attribute that holds the {@link FlashMapManager}.
 * @see org.springframework.web.servlet.support.RequestContextUtils#getFlashMapManager(HttpServletRequest)
 */
 public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";

 /**
 * Name of request attribute that exposes an Exception resolved with an
 * {@link HandlerExceptionResolver} but where no view was rendered
 * (e.g. setting the status code).
 */
 public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";

 /** Log category to use when no mapped handler is found for a request. */
 public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";

 /**
 * Name of the class path resource (relative to the DispatcherServlet class)
 * that defines DispatcherServlet's default strategy names.
 */
 private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";

 /** Additional logger to use when no mapped handler is found for a request. */
 protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);

 private static final Properties defaultStrategies;

 static {
 // Load default strategy implementations from properties file.
 // This is currently strictly internal and not meant to be customized
 // by application developers.
 try {
 ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
 defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
 }
 catch (IOException ex) {
 throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
 }
 }

 /** Detect all HandlerMappings or just expect "handlerMapping" bean? */
 private boolean detectAllHandlerMappings = true;

 /** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
 private boolean detectAllHandlerAdapters = true;

 /** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
 private boolean detectAllHandlerExceptionResolvers = true;

 /** Detect all ViewResolvers or just expect "viewResolver" bean? */
 private boolean detectAllViewResolvers = true;

 /** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
 private boolean throwExceptionIfNoHandlerFound = false;

 /** Perform cleanup of request attributes after include request? */
 private boolean cleanupAfterInclude = true;

 /** MultipartResolver used by this servlet */
 private MultipartResolver multipartResolver;

 /** LocaleResolver used by this servlet */
 private LocaleResolver localeResolver;

 /** ThemeResolver used by this servlet */
 private ThemeResolver themeResolver;

 /** List of HandlerMappings used by this servlet */
 private List<HandlerMapping> handlerMappings;

 /** List of HandlerAdapters used by this servlet */
 private List<HandlerAdapter> handlerAdapters;

 /** List of HandlerExceptionResolvers used by this servlet */
 private List<HandlerExceptionResolver> handlerExceptionResolvers;

 /** RequestToViewNameTranslator used by this servlet */
 private RequestToViewNameTranslator viewNameTranslator;

 /** FlashMapManager used by this servlet */
 private FlashMapManager flashMapManager;

 /** List of ViewResolvers used by this servlet */
 private List<ViewResolver> viewResolvers;

 /**
 * Create a new {@code DispatcherServlet} that will create its own internal web
 * application context based on defaults and values provided through servlet
 * init-params. Typically used in Servlet 2.5 or earlier environments, where the only
 * option for servlet registration is through {@code web.xml} which requires the use
 * of a no-arg constructor.
 * Calling {@link #setContextConfigLocation} (init-param 'contextConfigLocation')
 * will dictate which XML files will be loaded by the
 * {@linkplain #DEFAULT_CONTEXT_CLASS default XmlWebApplicationContext}
 * Calling {@link #setContextClass} (init-param 'contextClass') overrides the
 * default {@code XmlWebApplicationContext} and allows for specifying an alternative class,
 * such as {@code AnnotationConfigWebApplicationContext}.
 * Calling {@link #setContextInitializerClasses} (init-param 'contextInitializerClasses')
 * indicates which {@code ApplicationContextInitializer} classes should be used to
 * further configure the internal application context prior to refresh().
 * @see #DispatcherServlet(WebApplicationContext)
 */
 public DispatcherServlet() {
 super();
 setDispatchOptionsRequest(true);
 }

 /**
 * Create a new {@code DispatcherServlet} with the given web application context. This
 * constructor is useful in Servlet 3.0+ environments where instance-based registration
 * of servlets is possible through the {@link ServletContext#addServlet} API.
 * Using this constructor indicates that the following properties / init-params
 * will be ignored:
 * <ul>
 * <li>{@link #setContextClass(Class)} / 'contextClass'</li>
 * <li>{@link #setContextConfigLocation(String)} / 'contextConfigLocation'</li>
 * <li>{@link #setContextAttribute(String)} / 'contextAttribute'</li>
 * <li>{@link #setNamespace(String)} / 'namespace'</li>
 * </ul>
 * The given web application context may or may not yet be {@linkplain
 * ConfigurableApplicationContext#refresh() refreshed}. If it has not
 * already been refreshed (the recommended approach), then the following will occur:
 * <ul>
 * <li>If the given context does not already have a {@linkplain
 * ConfigurableApplicationContext#setParent parent}, the root application context
 * will be set as the parent.</li>
 * <li>If the given context has not already been assigned an {@linkplain
 * ConfigurableApplicationContext#setId id}, one will be assigned to it</li>
 * <li>{@code ServletContext} and {@code ServletConfig} objects will be delegated to
 * the application context</li>
 * <li>{@link #postProcessWebApplicationContext} will be called</li>
 * <li>Any {@code ApplicationContextInitializer}s specified through the
 * "contextInitializerClasses" init-param or through the {@link
 * #setContextInitializers} property will be applied.</li>
 * <li>{@link ConfigurableApplicationContext#refresh refresh()} will be called if the
 * context implements {@link ConfigurableApplicationContext}</li>
 * </ul>
 * If the context has already been refreshed, none of the above will occur, under the
 * assumption that the user has performed these actions (or not) per their specific
 * needs.
 * See {@link org.springframework.web.WebApplicationInitializer} for usage examples.
 * @param webApplicationContext the context to use
 * @see #initWebApplicationContext
 * @see #configureAndRefreshWebApplicationContext
 * @see org.springframework.web.WebApplicationInitializer
 */
 public DispatcherServlet(WebApplicationContext webApplicationContext) {
 super(webApplicationContext);
 setDispatchOptionsRequest(true);
 }

 /**
 * Set whether to detect all HandlerMapping beans in this servlet's context. Otherwise,
 * just a single bean with name "handlerMapping" will be expected.
 * Default is "true". Turn this off if you want this servlet to use a single
 * HandlerMapping, despite multiple HandlerMapping beans being defined in the context.
 */
 public void setDetectAllHandlerMappings(boolean detectAllHandlerMappings) {
 this.detectAllHandlerMappings = detectAllHandlerMappings;
 }

 /**
 * Set whether to detect all HandlerAdapter beans in this servlet's context. Otherwise,
 * just a single bean with name "handlerAdapter" will be expected.
 * Default is "true". Turn this off if you want this servlet to use a single
 * HandlerAdapter, despite multiple HandlerAdapter beans being defined in the context.
 */
 public void setDetectAllHandlerAdapters(boolean detectAllHandlerAdapters) {
 this.detectAllHandlerAdapters = detectAllHandlerAdapters;
 }

 /**
 * Set whether to detect all HandlerExceptionResolver beans in this servlet's context. Otherwise,
 * just a single bean with name "handlerExceptionResolver" will be expected.
 * Default is "true". Turn this off if you want this servlet to use a single
 * HandlerExceptionResolver, despite multiple HandlerExceptionResolver beans being defined in the context.
 */
 public void setDetectAllHandlerExceptionResolvers(boolean detectAllHandlerExceptionResolvers) {
 this.detectAllHandlerExceptionResolvers = detectAllHandlerExceptionResolvers;
 }

 /**
 * Set whether to detect all ViewResolver beans in this servlet's context. Otherwise,
 * just a single bean with name "viewResolver" will be expected.
 * Default is "true". Turn this off if you want this servlet to use a single
 * ViewResolver, despite multiple ViewResolver beans being defined in the context.
 */
 public void setDetectAllViewResolvers(boolean detectAllViewResolvers) {
 this.detectAllViewResolvers = detectAllViewResolvers;
 }

 /**
 * Set whether to throw a NoHandlerFoundException when no Handler was found for this request.
 * This exception can then be caught with a HandlerExceptionResolver or an
 * {@code @ExceptionHandler} controller method.
 * Note that if {@link org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler}
 * is used, then requests will always be forwarded to the default servlet and a
 * NoHandlerFoundException would never be thrown in that case.
 * Default is "false", meaning the DispatcherServlet sends a NOT_FOUND error through the
 * Servlet response.
 * @since 4.0
 */
 public void setThrowExceptionIfNoHandlerFound(boolean throwExceptionIfNoHandlerFound) {
 this.throwExceptionIfNoHandlerFound = throwExceptionIfNoHandlerFound;
 }

 /**
 * Set whether to perform cleanup of request attributes after an include request, that is,
 * whether to reset the original state of all request attributes after the DispatcherServlet
 * has processed within an include request. Otherwise, just the DispatcherServlet's own
 * request attributes will be reset, but not model attributes for JSPs or special attributes
 * set by views (for example, JSTL's).
 * Default is "true", which is strongly recommended. Views should not rely on request attributes
 * having been set by (dynamic) includes. This allows JSP views rendered by an included controller
 * to use any model attributes, even with the same names as in the main JSP, without causing side
 * effects. Only turn this off for special needs, for example to deliberately allow main JSPs to
 * access attributes from JSP views rendered by an included controller.
 */
 public void setCleanupAfterInclude(boolean cleanupAfterInclude) {
 this.cleanupAfterInclude = cleanupAfterInclude;
 }

 /**
 * This implementation calls {@link #initStrategies}.
 */
 @Override
 protected void onRefresh(ApplicationContext context) {
 initStrategies(context);
 }

 /**
 * Initialize the strategy objects that this servlet uses.
 * May be overridden in subclasses in order to initialize further strategy objects.
 */
 protected void initStrategies(ApplicationContext context) {
 initMultipartResolver(context);
 initLocaleResolver(context);
 initThemeResolver(context);
 initHandlerMappings(context);
 initHandlerAdapters(context);
 initHandlerExceptionResolvers(context);
 initRequestToViewNameTranslator(context);
 initViewResolvers(context);
 initFlashMapManager(context);
 }

 /**
 * Initialize the MultipartResolver used by this class.
 * If no bean is defined with the given name in the BeanFactory for this namespace,
 * no multipart handling is provided.
 */
 private void initMultipartResolver(ApplicationContext context) {
 try {
 this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
 }
 }
 catch (NoSuchBeanDefinitionException ex) {
 // Default is no multipart resolver.
 this.multipartResolver = null;
 if (logger.isDebugEnabled()) {
 logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
 "': no multipart request handling provided");
 }
 }
 }

 /**
 * Initialize the LocaleResolver used by this class.
 * If no bean is defined with the given name in the BeanFactory for this namespace,
 * we default to AcceptHeaderLocaleResolver.
 */
 private void initLocaleResolver(ApplicationContext context) {
 try {
 this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Using LocaleResolver [" + this.localeResolver + "]");
 }
 }
 catch (NoSuchBeanDefinitionException ex) {
 // We need to use the default.
 this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Unable to locate LocaleResolver with name '" + LOCALE_RESOLVER_BEAN_NAME +
 "': using default [" + this.localeResolver + "]");
 }
 }
 }

 /**
 * Initialize the ThemeResolver used by this class.
 * If no bean is defined with the given name in the BeanFactory for this namespace,
 * we default to a FixedThemeResolver.
 */
 private void initThemeResolver(ApplicationContext context) {
 try {
 this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Using ThemeResolver [" + this.themeResolver + "]");
 }
 }
 catch (NoSuchBeanDefinitionException ex) {
 // We need to use the default.
 this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Unable to locate ThemeResolver with name '" + THEME_RESOLVER_BEAN_NAME +
 "': using default [" + this.themeResolver + "]");
 }
 }
 }

 /**
 * Initialize the HandlerMappings used by this class.
 * If no HandlerMapping beans are defined in the BeanFactory for this namespace,
 * we default to BeanNameUrlHandlerMapping.
 */
 private void initHandlerMappings(ApplicationContext context) {
 this.handlerMappings = null;

 if (this.detectAllHandlerMappings) {
 // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
 Map<String, HandlerMapping> matchingBeans =
 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
 if (!matchingBeans.isEmpty()) {
 this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
 // We keep HandlerMappings in sorted order.
 AnnotationAwareOrderComparator.sort(this.handlerMappings);
 }
 }
 else {
 try {
 HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
 this.handlerMappings = Collections.singletonList(hm);
 }
 catch (NoSuchBeanDefinitionException ex) {
 // Ignore, we'll add a default HandlerMapping later.
 }
 }

 // Ensure we have at least one HandlerMapping, by registering
 // a default HandlerMapping if no other mappings are found.
 if (this.handlerMappings == null) {
 this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
 if (logger.isDebugEnabled()) {
 logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
 }
 }
 }

 /**
 * Initialize the HandlerAdapters used by this class.
 * If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
 * we default to SimpleControllerHandlerAdapter.
 */
 private void initHandlerAdapters(ApplicationContext context) {
 this.handlerAdapters = null;

 if (this.detectAllHandlerAdapters) {
 // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
 Map<String, HandlerAdapter> matchingBeans =
 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
 if (!matchingBeans.isEmpty()) {
 this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
 // We keep HandlerAdapters in sorted order.
 AnnotationAwareOrderComparator.sort(this.handlerAdapters);
 }
 }
 else {
 try {
 HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
 this.handlerAdapters = Collections.singletonList(ha);
 }
 catch (NoSuchBeanDefinitionException ex) {
 // Ignore, we'll add a default HandlerAdapter later.
 }
 }

 // Ensure we have at least some HandlerAdapters, by registering
 // default HandlerAdapters if no other adapters are found.
 if (this.handlerAdapters == null) {
 this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
 if (logger.isDebugEnabled()) {
 logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
 }
 }
 }

 /**
 * Initialize the HandlerExceptionResolver used by this class.
 * If no bean is defined with the given name in the BeanFactory for this namespace,
 * we default to no exception resolver.
 */
 private void initHandlerExceptionResolvers(ApplicationContext context) {
 this.handlerExceptionResolvers = null;

 if (this.detectAllHandlerExceptionResolvers) {
 // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
 Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
 .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
 if (!matchingBeans.isEmpty()) {
 this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
 // We keep HandlerExceptionResolvers in sorted order.
 AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
 }
 }
 else {
 try {
 HandlerExceptionResolver her =
 context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
 this.handlerExceptionResolvers = Collections.singletonList(her);
 }
 catch (NoSuchBeanDefinitionException ex) {
 // Ignore, no HandlerExceptionResolver is fine too.
 }
 }

 // Ensure we have at least some HandlerExceptionResolvers, by registering
 // default HandlerExceptionResolvers if no other resolvers are found.
 if (this.handlerExceptionResolvers == null) {
 this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("No HandlerExceptionResolvers found in servlet '" + getServletName() + "': using default");
 }
 }
 }

 /**
 * Initialize the RequestToViewNameTranslator used by this servlet instance.
 * If no implementation is configured then we default to DefaultRequestToViewNameTranslator.
 */
 private void initRequestToViewNameTranslator(ApplicationContext context) {
 try {
 this.viewNameTranslator =
 context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Using RequestToViewNameTranslator [" + this.viewNameTranslator + "]");
 }
 }
 catch (NoSuchBeanDefinitionException ex) {
 // We need to use the default.
 this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Unable to locate RequestToViewNameTranslator with name '" +
 REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME + "': using default [" + this.viewNameTranslator +
 "]");
 }
 }
 }

 /**
 * Initialize the ViewResolvers used by this class.
 * If no ViewResolver beans are defined in the BeanFactory for this
 * namespace, we default to InternalResourceViewResolver.
 */
 private void initViewResolvers(ApplicationContext context) {
 this.viewResolvers = null;

 if (this.detectAllViewResolvers) {
 // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
 Map<String, ViewResolver> matchingBeans =
 BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
 if (!matchingBeans.isEmpty()) {
 this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());
 // We keep ViewResolvers in sorted order.
 AnnotationAwareOrderComparator.sort(this.viewResolvers);
 }
 }
 else {
 try {
 ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
 this.viewResolvers = Collections.singletonList(vr);
 }
 catch (NoSuchBeanDefinitionException ex) {
 // Ignore, we'll add a default ViewResolver later.
 }
 }

 // Ensure we have at least one ViewResolver, by registering
 // a default ViewResolver if no other resolvers are found.
 if (this.viewResolvers == null) {
 this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
 if (logger.isDebugEnabled()) {
 logger.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default");
 }
 }
 }

 /**
 * Initialize the {@link FlashMapManager} used by this servlet instance.
 * If no implementation is configured then we default to
 * {@code org.springframework.web.servlet.support.DefaultFlashMapManager}.
 */
 private void initFlashMapManager(ApplicationContext context) {
 try {
 this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Using FlashMapManager [" + this.flashMapManager + "]");
 }
 }
 catch (NoSuchBeanDefinitionException ex) {
 // We need to use the default.
 this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
 if (logger.isDebugEnabled()) {
 logger.debug("Unable to locate FlashMapManager with name '" +
 FLASH_MAP_MANAGER_BEAN_NAME + "': using default [" + this.flashMapManager + "]");
 }
 }
 }

 /**
 * Return this servlet's ThemeSource, if any; else return {@code null}.
 * Default is to return the WebApplicationContext as ThemeSource,
 * provided that it implements the ThemeSource interface.
 * @return the ThemeSource, if any
 * @see #getWebApplicationContext()
 */
 public final ThemeSource getThemeSource() {
 if (getWebApplicationContext() instanceof ThemeSource) {
 return (ThemeSource) getWebApplicationContext();
 }
 else {
 return null;
 }
 }

 /**
 * Obtain this servlet's MultipartResolver, if any.
 * @return the MultipartResolver used by this servlet, or {@code null} if none
 * (indicating that no multipart support is available)
 */
 public final MultipartResolver getMultipartResolver() {
 return this.multipartResolver;
 }

 /**
 * Return the default strategy object for the given strategy interface.
 * The default implementation delegates to {@link #getDefaultStrategies},
 * expecting a single object in the list.
 * @param context the current WebApplicationContext
 * @param strategyInterface the strategy interface
 * @return the corresponding strategy object
 * @see #getDefaultStrategies
 */
 protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
 List<T> strategies = getDefaultStrategies(context, strategyInterface);
 if (strategies.size() != 1) {
 throw new BeanInitializationException(
 "DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
 }
 return strategies.get(0);
 }

 /**
 * Create a List of default strategy objects for the given strategy interface.
 * The default implementation uses the "DispatcherServlet.properties" file (in the same
 * package as the DispatcherServlet class) to determine the class names. It instantiates
 * the strategy objects through the context's BeanFactory.
 * @param context the current WebApplicationContext
 * @param strategyInterface the strategy interface
 * @return the List of corresponding strategy objects
 */
 @SuppressWarnings("unchecked")
 protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
 String key = strategyInterface.getName();
 String value = defaultStrategies.getProperty(key);
 if (value != null) {
 String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
 List<T> strategies = new ArrayList<T>(classNames.length);
 for (String className : classNames) {
 try {
 Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
 Object strategy = createDefaultStrategy(context, clazz);
 strategies.add((T) strategy);
 }
 catch (ClassNotFoundException ex) {
 throw new BeanInitializationException(
 "Could not find DispatcherServlet's default strategy class [" + className +
 "] for interface [" + key + "]", ex);
 }
 catch (LinkageError err) {
 throw new BeanInitializationException(
 "Error loading DispatcherServlet's default strategy class [" + className +
 "] for interface [" + key + "]: problem with class file or dependent class", err);
 }
 }
 return strategies;
 }
 else {
 return new LinkedList<T>();
 }
 }

 /**
 * Create a default strategy.
 * The default implementation uses
 * {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean}.
 * @param context the current WebApplicationContext
 * @param clazz the strategy implementation class to instantiate
 * @return the fully configured strategy instance
 * @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
 * @see org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean
 */
 protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
 return context.getAutowireCapableBeanFactory().createBean(clazz);
 }

 /**
 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
 * for the actual dispatching.
 */
 @Override
 protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
 if (logger.isDebugEnabled()) {
 String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
 logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
 " processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
 }

 // Keep a snapshot of the request attributes in case of an include,
 // to be able to restore the original attributes after the include.
 Map<String, Object> attributesSnapshot = null;
 if (WebUtils.isIncludeRequest(request)) {
 attributesSnapshot = new HashMap<String, Object>();
 Enumeration<?> attrNames = request.getAttributeNames();
 while (attrNames.hasMoreElements()) {
 String attrName = (String) attrNames.nextElement();
 if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
 attributesSnapshot.put(attrName, request.getAttribute(attrName));
 }
 }
 }

 // Make framework objects available to handlers and view objects.
 request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
 request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
 request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
 request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

 FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
 if (inputFlashMap != null) {
 request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
 }
 request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
 request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

 try {
 doDispatch(request, response);
 }
 finally {
 if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
 // Restore the original attribute snapshot, in case of an include.
 if (attributesSnapshot != null) {
 restoreAttributesAfterInclude(request, attributesSnapshot);
 }
 }
 }
 }

 /**
 * Process the actual dispatching to the handler.
 * The handler will be obtained by applying the servlet's HandlerMappings in order.
 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
 * to find the first that supports the handler class.
 * All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
 * themselves to decide which methods are acceptable.
 * @param request current HTTP request
 * @param response current HTTP response
 * @throws Exception in case of any kind of processing failure
 */
 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
 HttpServletRequest processedRequest = request;
 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);

 // Determine handler for the current request.
 mappedHandler = getHandler(processedRequest);
 if (mappedHandler == null || mappedHandler.getHandler() == null) {
 noHandlerFound(processedRequest, response);
 return;
 }

 // Determine handler adapter for the current request.
 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

 // Process last-modified header, if supported by the handler.
 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;
 }

 // Actually invoke the handler.
 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

 if (asyncManager.isConcurrentHandlingStarted()) {
 return;
 }

 applyDefaultViewName(processedRequest, mv);
 mappedHandler.applyPostHandle(processedRequest, response, mv);
 }
 catch (Exception ex) {
 dispatchException = ex;
 }
 catch (Throwable err) {
 // As of 4.3, we're processing Errors thrown from handler methods as well,
 // making them available for @ExceptionHandler methods and other scenarios.
 dispatchException = new NestedServletException("Handler dispatch failed", err);
 }
 processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
 }
 catch (Exception ex) {
 triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
 }
 catch (Throwable err) {
 triggerAfterCompletion(processedRequest, response, mappedHandler,
 new NestedServletException("Handler processing failed", err));
 }
 finally {
 if (asyncManager.isConcurrentHandlingStarted()) {
 // Instead of postHandle and afterCompletion
 if (mappedHandler != null) {
 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
 }
 }
 else {
 // Clean up any resources used by a multipart request.
 if (multipartRequestParsed) {
 cleanupMultipart(processedRequest);
 }
 }
 }
 }

 /**
 * Do we need view name translation?
 */
 private void applyDefaultViewName(HttpServletRequest request, ModelAndView mv) throws Exception {
 if (mv != null && !mv.hasView()) {
 mv.setViewName(getDefaultViewName(request));
 }
 }

 /**
 * Handle the result of handler selection and handler invocation, which is
 * either a ModelAndView or an Exception to be resolved to a ModelAndView.
 */
 private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
 HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {

 boolean errorView = false;

 if (exception != null) {
 if (exception instanceof ModelAndViewDefiningException) {
 logger.debug("ModelAndViewDefiningException encountered", exception);
 mv = ((ModelAndViewDefiningException) exception).getModelAndView();
 }
 else {
 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
 mv = processHandlerException(request, response, handler, exception);
 errorView = (mv != null);
 }
 }

 // Did the handler return a view to render?
 if (mv != null && !mv.wasCleared()) {
 render(mv, request, 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");
 }
 }

 if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
 // Concurrent handling started during a forward
 return;
 }

 if (mappedHandler != null) {
 mappedHandler.triggerAfterCompletion(request, response, null);
 }
 }

 /**
 * Build a LocaleContext for the given request, exposing the request's primary locale as current locale.
 * The default implementation uses the dispatcher's LocaleResolver to obtain the current locale,
 * which might change during a request.
 * @param request current HTTP request
 * @return the corresponding LocaleContext
 */
 @Override
 protected LocaleContext buildLocaleContext(final HttpServletRequest request) {
 if (this.localeResolver instanceof LocaleContextResolver) {
 return ((LocaleContextResolver) this.localeResolver).resolveLocaleContext(request);
 }
 else {
 return new LocaleContext() {
 @Override
 public Locale getLocale() {
 return localeResolver.resolveLocale(request);
 }
 };
 }
 }

 /**
 * Convert the request into a multipart request, and make multipart resolver available.
 * If no multipart resolver is set, simply use the existing request.
 * @param request current HTTP request
 * @return the processed request (multipart wrapper if necessary)
 * @see MultipartResolver#resolveMultipart
 */
 protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
 if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
 if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {
 logger.debug("Request is already a MultipartHttpServletRequest - if not in a forward, " +
 "this typically results from an additional MultipartFilter in web.xml");
 }
 else if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) instanceof MultipartException) {
 logger.debug("Multipart resolution failed for current request before - " +
 "skipping re-resolution for undisturbed error rendering");
 }
 else {
 return this.multipartResolver.resolveMultipart(request);
 }
 }
 // If not returned before: return original request.
 return request;
 }

 /**
 * Clean up any resources used by the given multipart request (if any).
 * @param request current HTTP request
 * @see MultipartResolver#cleanupMultipart
 */
 protected void cleanupMultipart(HttpServletRequest request) {
 MultipartHttpServletRequest multipartRequest =
 WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
 if (multipartRequest != null) {
 this.multipartResolver.cleanupMultipart(multipartRequest);
 }
 }

 /**
 * Return the HandlerExecutionChain for this request.
 * Tries all handler mappings in order.
 * @param request current HTTP request
 * @return the HandlerExecutionChain, or {@code null} if no handler could be found
 */
 protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
 for (HandlerMapping hm : this.handlerMappings) {
 if (logger.isTraceEnabled()) {
 logger.trace(
 "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
 }
 HandlerExecutionChain handler = hm.getHandler(request);
 if (handler != null) {
 return handler;
 }
 }
 return null;
 }

 /**
 * No handler found -> set appropriate HTTP response status.
 * @param request current HTTP request
 * @param response current HTTP response
 * @throws Exception if preparing the response failed
 */
 protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception {
 if (pageNotFoundLogger.isWarnEnabled()) {
 pageNotFoundLogger.warn("No mapping found for HTTP request with URI [" + getRequestUri(request) +
 "] in DispatcherServlet with name '" + getServletName() + "'");
 }
 if (this.throwExceptionIfNoHandlerFound) {
 throw new NoHandlerFoundException(request.getMethod(), getRequestUri(request),
 new ServletServerHttpRequest(request).getHeaders());
 }
 else {
 response.sendError(HttpServletResponse.SC_NOT_FOUND);
 }
 }

 /**
 * Return the HandlerAdapter for this handler object.
 * @param handler the handler object to find an adapter for
 * @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
 */
 protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
 for (HandlerAdapter ha : this.handlerAdapters) {
 if (logger.isTraceEnabled()) {
 logger.trace("Testing handler adapter [" + ha + "]");
 }
 if (ha.supports(handler)) {
 return ha;
 }
 }
 throw new ServletException("No adapter for handler [" + handler +
 "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
 }

 /**
 * Determine an error ModelAndView via the registered HandlerExceptionResolvers.
 * @param request current HTTP request
 * @param response current HTTP response
 * @param handler the executed handler, or {@code null} if none chosen at the time of the exception
 * (for example, if multipart resolution failed)
 * @param ex the exception that got thrown during handler execution
 * @return a corresponding ModelAndView to forward to
 * @throws Exception if no error ModelAndView found
 */
 protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
 Object handler, Exception ex) throws Exception {

 // Check registered HandlerExceptionResolvers...
 ModelAndView exMv = null;
 for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
 exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
 if (exMv != null) {
 break;
 }
 }
 if (exMv != null) {
 if (exMv.isEmpty()) {
 request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
 return null;
 }
 // We might still need view name translation for a plain error model...
 if (!exMv.hasView()) {
 exMv.setViewName(getDefaultViewName(request));
 }
 if (logger.isDebugEnabled()) {
 logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);
 }
 WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
 return exMv;
 }

 throw ex;
 }

 /**
 * Render the given ModelAndView.
 * This is the last stage in handling a request. It may involve resolving the view by name.
 * @param mv the ModelAndView to render
 * @param request current HTTP servlet request
 * @param response current HTTP servlet response
 * @throws ServletException if view is missing or cannot be resolved
 * @throws Exception if there's a problem rendering the view
 */
 protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
 // Determine locale for request and apply it to the response.
 Locale locale = this.localeResolver.resolveLocale(request);
 response.setLocale(locale);

 View view;
 if (mv.isReference()) {
 // We need to resolve the view name.
 view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
 if (view == null) {
 throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
 "' in servlet with name '" + getServletName() + "'");
 }
 }
 else {
 // No need to lookup: the ModelAndView object contains the actual View object.
 view = mv.getView();
 if (view == null) {
 throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
 "View object in servlet with name '" + getServletName() + "'");
 }
 }

 // Delegate to the View object for rendering.
 if (logger.isDebugEnabled()) {
 logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
 }
 try {
 if (mv.getStatus() != null) {
 response.setStatus(mv.getStatus().value());
 }
 view.render(mv.getModelInternal(), request, response);
 }
 catch (Exception ex) {
 if (logger.isDebugEnabled()) {
 logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" +
 getServletName() + "'", ex);
 }
 throw ex;
 }
 }

 /**
 * Translate the supplied request into a default view name.
 * @param request current HTTP servlet request
 * @return the view name (or {@code null} if no default found)
 * @throws Exception if view name translation failed
 */
 protected String getDefaultViewName(HttpServletRequest request) throws Exception {
 return this.viewNameTranslator.getViewName(request);
 }

 /**
 * Resolve the given view name into a View object (to be rendered).
 * The default implementations asks all ViewResolvers of this dispatcher.
 * Can be overridden for custom resolution strategies, potentially based on
 * specific model attributes or request parameters.
 * @param viewName the name of the view to resolve
 * @param model the model to be passed to the view
 * @param locale the current locale
 * @param request current HTTP servlet request
 * @return the View object, or {@code null} if none found
 * @throws Exception if the view cannot be resolved
 * (typically in case of problems creating an actual View object)
 * @see ViewResolver#resolveViewName
 */
 protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,
 HttpServletRequest request) throws Exception {

 for (ViewResolver viewResolver : this.viewResolvers) {
 View view = viewResolver.resolveViewName(viewName, locale);
 if (view != null) {
 return view;
 }
 }
 return null;
 }

 private void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response,
 HandlerExecutionChain mappedHandler, Exception ex) throws Exception {

 if (mappedHandler != null) {
 mappedHandler.triggerAfterCompletion(request, response, ex);
 }
 throw ex;
 }

 /**
 * Restore the request attributes after an include.
 * @param request current HTTP request
 * @param attributesSnapshot the snapshot of the request attributes before the include
 */
 @SuppressWarnings("unchecked")
 private void restoreAttributesAfterInclude(HttpServletRequest request, Map<?,?> attributesSnapshot) {
 // Need to copy into separate Collection here, to avoid side effects
 // on the Enumeration when removing attributes.
 Set<String> attrsToCheck = new HashSet<String>();
 Enumeration<?> attrNames = request.getAttributeNames();
 while (attrNames.hasMoreElements()) {
 String attrName = (String) attrNames.nextElement();
 if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
 attrsToCheck.add(attrName);
 }
 }

 // Add attributes that may have been removed
 attrsToCheck.addAll((Set<String>) attributesSnapshot.keySet());

 // Iterate over the attributes to check, restoring the original value
 // or removing the attribute, respectively, if appropriate.
 for (String attrName : attrsToCheck) {
 Object attrValue = attributesSnapshot.get(attrName);
 if (attrValue == null){
 request.removeAttribute(attrName);
 }
 else if (attrValue != request.getAttribute(attrName)) {
 request.setAttribute(attrName, attrValue);
 }
 }
 }

 private static String getRequestUri(HttpServletRequest request) {
 String uri = (String) request.getAttribute(WebUtils.INCLUDE_REQUEST_URI_ATTRIBUTE);
 if (uri == null) {
 uri = request.getRequestURI();
 }
 return uri;
 }

}

继承与依赖关系如下：

修改web.xml文件注册该Servlet，修改后的web.xml文件如下：

复制代码

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

id="WebApp_ID" version="3.0">

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

复制代码

4.4、添加Spring MVC配置文件

在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

http://www.springframework.org/schema/context/spring-context-4.3.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">

<context:component-scan base-package="com.zhangguo.springmvc01" />

<mvc:default-servlet-handler />

<!--在spring中一般采用@RequestMapping注解来完成映射关系，

要想使@RequestMapping注解生效必须向上下文中注册DefaultAnnotationHandlerMapping和一个AnnotationMethodHandlerAdapter

实例，这两个实例分别在类级别和方法级别处理。而annotation-driven配置帮助我们自动完成上述两个实例的注入。-->

<mvc:annotation-driven />

<bean

class="org.springframework.web.servlet.view.InternalResourceViewResolver"

id="internalResourceViewResolver">

</bean>

</beans>

复制代码

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

4.5、创建HelloWorld控制器

在src/main/java源代码目录下创建包com.zhangguo.springmvc01.controller，在包下创建一个普通的类：HelloWorld，具体代码如下：

复制代码

package com.zhangguo.springmvc01.controller;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

/**控制器*/

@Controller

@RequestMapping("/hello")

public class HelloController {

/**动作，action*/

@RequestMapping("/hi")

public String hi(Model model){

//向模型中添加属性msg与值，将与页面模板渲染后输出

model.addAttribute("msg","Hello Spring MVC!");

return "hi";

}

复制代码

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

4.6、创建视图

在WEB-INF/view目录中创建视图，hi.jsp视图将从Action中带回的信息展示，具体内容如下：

复制代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<html>

<head>

</head>

<body>

</body>

</html>

复制代码

4.7、配置TomCat部署项目

点击右上角的Edit Configurations添加对tomcat的配置：

添加对tomcat的配置，设置名称，添加Deployment

可以设置context也可以没有，类似虚拟目录

4.8、测试运行

启动Tomcat运行项目，请注意查看启动信息，如果有异常应该先解决异常信息，运行成功后的结果如下所示：

五、设置引导页

使用了spring mvc如果想直接访问控制器下的某个action为引导页，可以通过如下方式实现：

5.1、方法一

删除index.jsp默认引导文件

定义一下Home控制器，如下所示：

复制代码

package com.zhangguo.springmvc01.controller;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

/**控制器*/

@Controller

@RequestMapping("/")

public class HomeController {

/**动作，action*/

@RequestMapping("")

public String index(Model model){

//向模型中添加属性msg与值，将与页面模板渲染后输出

model.addAttribute("msg","Welcome my website!");

return "hi";

}

复制代码

结果：

5.2、方法二

修改Spring MVC配置文件，增加如下配置：

<mvc:view-controller path="/" view-name="redirect:/hello/"></mvc:view-controller>

action如下：

复制代码

package com.zhangguo.springmvc01.controller;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestMapping;

/**控制器*/

@Controller

@RequestMapping("/hello")

public class HelloController {

/**动作，action*/

@RequestMapping("/hi")

public String hi(Model model){

//向模型中添加属性msg与值，将与页面模板渲染后输出

model.addAttribute("msg","Hello Spring MVC!");

return "hi";

}

/**动作，action*/

@RequestMapping("")

public String index(Model model){

//向模型中添加属性msg与值，将与页面模板渲染后输出

model.addAttribute("msg","Index Page!");

return "hi";

}

复制代码

访问结果：

注意这种方法是使用的重定向方式，需发起两次请求，尽量转发。

六、示例下载

点击下载示例

七、视频

八、作业

版权说明：
本网站凡注明“广州京杭原创”的皆为本站原创文章，如需转载请注明出处！
本网转载皆注明出处，遵循行业规范，如发现作品内容版权或其它问题的，请与我们联系处理！
欢迎扫描右侧微信二维码与我们联系。

·上一条：SpringMVC -- 三层架构和MVC | ·下一条：eclipse无法识别javax.servlet.*的问题