Springmvc 简明教程

Spring MVC - Quick Guide

Spring - MVC Framework Overview

Spring Web MVC框架提供了一个模型-视图-控制器架构和可以用来开发灵活且松散耦合的web应用程序的准备组件。MVC模式导致应用程序的不同方面（输入逻辑、业务逻辑和界面逻辑）分离，同时在这些元素之间提供松散耦合。

Model 封装了应用程序数据，而且一般来讲，它们将由 POJO 组成。
View 负责渲染模型数据，而且一般来讲，它生成 HTML 输出，客户端的浏览器可以解释这些输出。
Controller 负责处理 User Requests 和 Building Appropriate Model 将其传递给视图进行渲染。

The DispatcherServlet

Spring Web模型-视图-控制器(MVC)框架是围绕一个DispatcherServlet设计的，它处理所有的HTTP请求和响应。Spring Web MVC DispatcherServlet的请求处理工作流显示在下图中。

以下为响应发送到 DispatcherServlet 的入站 HTTP 请求的事件序列 -

收到HTTP请求后，DispatcherServlet咨询 HandlerMapping 来调用适当的控制器。
控制器接收请求并基于所使用的 GET 或 POST method 调用适当的服务方法。服务方法将基于已定义的业务逻辑设置模型数据，并将视图名称返回给DispatcherServlet。
DispatcherServlet将借助 ViewResolver 来为该请求挑选已定义的视图。
一经最终确定视图，DispatcherServlet将模型数据传递给视图，该视图最终会在浏览器上渲染。

所有以上提到的组件，比如HandlerMapping、Controller和ViewResolver都是 WebApplicationContext 的一部分，它扩展了平实的 ApplicationContext ，其中有一些web应用程序所必需的额外功能。

Required Configuration

我们需要映射DispatcherServlet需要处理的请求，通过在 web.xml 文件中使用URL映射来实现。以下示例显示了 HelloWeb DispatcherServlet的声明和映射——

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

   <display-name>Spring MVC Application</display-name>

   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>
</web-app>

web.xml 文件将被保留在你的web应用程序的 WebContent/WEB-INF 目录中。初始化DispatcherServlet时，框架将尝试从一个名为 [servlet-name]-servlet.xml 的文件中加载应用程序上下文，该文件位于应用程序的WebContent/WEB-INF目录中。在本例中，我们的文件将是 HelloWeb-servlet.xml 。

接下来， <servlet-mapping> 标签指出了哪些URL将由哪个DispatcherServlet处理。在这里，所有以.jsp结尾的HTTP请求都将由 HelloWeb DispatcherServlet处理。

如果你不想使用默认的文件名 [servlet-name]-servlet.xml 和默认位置WebContent/WEB-INF，你可以通过在你的web.xml文件中添加 ContextLoaderListener servlet监听器，来自定义这个文件名和位置，如下所示——

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
</web-app>

现在，让我们查看放置在你的web应用程序的WebContent/WEB-INF目录中的 HelloWeb-servlet.xml 文件的所需配置。

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

以下是有关 HelloWeb-servlet.xml 文件的部分重点：

[servlet-name]-servlet.xml 文件将用于创建定义的 bean，覆盖在全局范围中使用相同名称定义的任何 bean 的定义。
<context:component-scan…> 标记将用于激活 Spring MVC 注解扫描功能，该功能允许使用诸如 @Controller 和 @RequestMapping 等注解。
InternalResourceViewResolver 将具有定义的规则来解析视图名称。根据上述定义的规则，名为 hello 的逻辑视图被委派给了位于 /WEB-INF/jsp/hello.jsp 的视图实现。

现在让我们了解如何创建实际组件，即控制器、模型和视图。

Defining a Controller

DispatcherServlet 将请求委托给 controller 以执行特定于该请求的功能。 @Controller 注解表明特定的类扮演 controller 的角色。 @RequestMapping 注解用于将 URL 映射到整个类或特定的处理方法。

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }

}

@Controller 注解将类定义为 Spring MVC 控制器。在此，第一个 @RequestMapping 用法表示该控制器上的所有处理方法都与 /hello 路径相关。

下一个注解 @RequestMapping (method = RequestMethod.GET) 用于将 printHello() 方法声明为控制器的默认服务方法来处理 HTTP GET 请求。我们可以在同一 URL 上定义另一个方法来处理任何 POST 请求。

我们还可以用另一种形式编写上述控制器，其中我们可以按照如下方式在 @RequestMapping 中添加其他属性：

@Controller
public class HelloController{

   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }

}

value 属性指示处理程序方法映射到的 URL， method 属性定义了处理 HTTP GET 请求的服务方法。

以下是有关上述控制器定义的部分重点：

您将在服务方法中定义所需的业务逻辑。您可以根据要求在此方法中调用另一个方法。
基于定义的业务逻辑，您将在该方法内创建一个模型。您可以设置不同的模型属性，视图将访问这些属性以显示结果。此示例创建了一个属性为 "message" 的模型。
已定义的服务方法可以返回一个 String，它包含用于呈现模型的 view 的名称。此示例将 "hello" 作为逻辑视图名称返回。

Creating JSP Views

Spring MVC 支持许多不同展现技术的视图类型。这些包括 JSPs, HTML, PDF, Excel Worksheets, XML, Velocity Templates, XSLT, JSON, Atom 和 RSS 数据源、 JasperReports 等等。然而，最常见的是使用 JSTL 编写的 JSP 模板。所以，让我们在 /WEB-INF/hello/hello.jsp 中编写一个简单的问候视图：

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

此处， ${message} 是我们在控制器中设置的属性。您可以在视图中显示多个属性。

Spring MVC - Environment Setup

本章将在您开始使用 Spring 框架时，指导您如何准备开发环境。它还将教您在设置 Spring 框架之前如何在您的机器上设置 JDK、Maven 和 Eclipse −

Setup Java Development Kit (JDK)

你可以从 Oracle 的 Java 站点下载 SDK 的最新版本 − Java SE Downloads. 你在下载文件中可以找到安装 JDK 的说明，按照给定的说明进行安装和配置。最后设置 PATH 和 JAVA_HOME 环境变量以引用包含 java 和 javac 的目录，通常分别为 java_install_dir/bin 和 java_install_dir。

如果您运行的是 Windows 且在 C:\jdk-11.0.11 中安装了 JDK，那么您将不得不把以下代码行放入您的 C:\autoexec.bat 文件中。

set PATH=C:\jdk-11.0.11;%PATH%
set JAVA_HOME=C:\jdk-11.0.11

或者，在 Windows NT/2000/XP 中，你必须右键单击我的电脑，选择属性 → 高级 → 环境变量。然后，你将不得不更新 PATH 值并单击确定按钮。

在 Unix（Solaris、Linux 等）中，如果 SDK 安装在 /usr/local/jdk-11.0.11 且您使用 C shell，那么您将不得不把以下代码行放入您的 .cshrc 文件中。

setenv PATH /usr/local/jdk-11.0.11/bin:$PATH
setenv JAVA_HOME /usr/local/jdk-11.0.11

或者，如果你使用诸如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio 这样的集成开发环境 (IDE)，则必须编译并运行一个简单程序来确认 IDE 知道你在何处安装了 Java。否则，你必须按照 IDE 文档中给出的内容执行正确的设置。

Setup Eclipse IDE

本教程中的所有示例都是使用 Eclipse IDE 编写的。因此，我们建议你应该在你机器上安装 Eclipse 的最新版本。

要安装 Eclipse IDE，请从 www.eclipse.org/downloads 下载最新的 Eclipse 二进制文件。下载安装文件后，将二进制分发包解压到方便的位置。例如，在 Windows 上的 C:\eclipse 中，或 Linux/Unix 上的 /usr/local/eclipse 中，最后相应地设置 PATH 变量。

可以通过在 Windows 机器上执行以下命令启动 Eclipse，或者你只需双击 eclipse.exe

%C:\eclipse\eclipse.exe

可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令启动 Eclipse −

$/usr/local/eclipse/eclipse

成功启动后，如果一切正常，它应该显示以下结果 −

Install Apache Common Logging API

你可以从 https://commons.apache.org/logging/ 下载最新版的 Apache Commons Logging API。下载安装程序后，将二进制发行版解压缩到一个方便的位置。

例如 - Windows 上的 C:\commons-logging-1.1.1，或 Linux/Unix 上的 /usr/local/commons-logging1.1.1。此目录将包含以下 jar 文件和其他支持文档等。

确保在此目录上正确设置你的 CLASSPATH 变量，否则在运行你的应用程序时你会遇到问题。

Setup Spring Framework Libraries

现在，如果一切正常，那么我们可以继续设置 Spring Framework。以下是在机器上下载和安装框架的步骤。

选择是想要在 Windows 上安装 Spring 还是在 UNIX 上安装，然后继续下一步为 Windows 下载 .zip file ，为 Unix 下载 .tz 文件。
从中链接下载 Spring framework 二进制文件的最新版本： https://repo.spring.io/release/org/springframework/spring 。
我们在 Windows 机器上下载了 spring-5.3.14-dist.zip ，当我们解压下载的文件时，它将给出以下目录结构 – E:\spring。

你将在此目录中找到所有 Spring 库 E:\spring\libs 。确保在此目录上正确设置你的 CLASSPATH 变量；否则，我们在运行应用程序时会遇到问题。如果我们使用 Eclipse，则不需要设置 CLASSPATH，因为所有设置都将通过 Eclipse 完成。

完成最后一步后，您可以准备进行第一个 Spring 示例了，您将在下一章中看到。

Spring MVC - Hello World Example

以下示例展示了如何使用 Spring MVC 框架编写简单基于 web 的 Hello World 应用程序。首先，我们准备一个可用的 Eclipse IDE，然后遵循以下步骤使用 Spring Web 框架开发一个动态 Web 应用程序。

Step	Description
1	使用名称 HelloWeb 创建一个动态 Web 项目，并在创建的项目的 src 文件夹下创建包 com.tutorialspoint。
2	将以下 Spring 和其他库拖放到文件夹 WebContent/WEB-INF/lib 中。
3	在 com.tutorialspoint 包下创建 Java 类 HelloController 。
4	在 WebContent/WEB-INF 文件夹下创建 Spring 配置 files web.xml 和 HelloWeb-servlet.xml 。
5	在 WebContent/WEB-INF 文件夹下创建一个名为 jsp 的子文件夹。在此子文件夹下创建一个视图文件 hello.jsp 。
6	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }

}

web.xml

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

   <display-name>Spring MVC Application</display-name>

   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>/</url-pattern>
   </servlet-mapping>

</web-app>

HelloWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

以下是包含在 Web 应用程序中的 Spring 及其他库的列表。我们可以直接将这些文件拖放到 WebContent/WEB-INF/lib 文件夹中。

servlet-api-x.y.z.jar
commons-logging-x.y.z.jar
spring-aop-x.y.z.jar
spring-beans-x.y.z.jar
spring-context-x.y.z.jar
spring-core-x.y.z.jar
spring-expression-x.y.z.jar
spring-webmvc-x.y.z.jar
spring-web-x.y.z.jar

完成后创建源代码和配置文件，导出你的应用程序。右键单击你的应用程序，使用 Export → WAR File 选项并保存 HelloWeb.war 文件到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器并确保你可以使用标准浏览器访问 webapps 文件夹中的其他网页。然后，尝试访问 URL − http://localhost:8080/HelloWeb/hello 。如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

你应该注意，在给定的 URL 中， HelloWeb 是应用程序名称，hello 是虚拟子文件夹，我们使用 @RequestMapping("/hello") 在控制器中已经提到了该文件夹。你可以使用 @RequestMapping("/") 将你的 URL 直接映射到根目录，在这种情况下，你可以使用缩写 URL http://localhost:8080/HelloWeb/ 访问同一个页面，但建议在不同的文件夹下有不同的功能。

Spring MVC - Form Handling Example

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建 Java 类 Student、StudentController。
3	在 jsp 子文件夹下创建视图文件 student.jsp、result.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

Student.java

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class StudentController {

   @RequestMapping(value = "/student", method = RequestMethod.GET)
   public ModelAndView student() {
      return new ModelAndView("student", "command", new Student());
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.POST)
   public String addStudent(@ModelAttribute("SpringWeb")Student student,
   ModelMap model) {
      model.addAttribute("name", student.getName());
      model.addAttribute("age", student.getAge());
      model.addAttribute("id", student.getId());

      return "result";
   }
}

这里，在第一个 service 方法 student() 中，我们已经在具有名称“command”的 ModelAndView 对象中传递了一个空白的 Student 对象。我们之所以这么做，是因为如果我们在 JSP 文件中使用 <form:form> 标记，Spring 框架便希望有一个名为 “command” 的对象。因此，在调用 student() 方法时，它将返回 student.jsp 视图。

第二个 service 方法 addStudent() 将针对 HelloWeb/addStudent 网址上的 POST 方法进行调用。您将基于已提交信息准备您的模型对象。最后，将从 service 方法返回一个 “result” 视图，这将导致呈现 result.jsp。

student.jsp

<%@taglib uri="http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>

   <body>
      <h2>Student Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addStudent">
         <table>
            <tr>
               <td><form:label path = "name">Name</form:label></td>
               <td><form:input path = "name" /></td>
            </tr>
            <tr>
               <td><form:label path = "age">Age</form:label></td>
               <td><form:input path = "age" /></td>
            </tr>
            <tr>
               <td><form:label path = "id">id</form:label></td>
               <td><form:input path = "id" /></td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

result.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted Student Information</h2>
      <table>
         <tr>
            <td>Name</td>
            <td>${name}</td>
         </tr>
         <tr>
            <td>Age</td>
            <td>${age}</td>
         </tr>
         <tr>
            <td>ID</td>
            <td>${id}</td>
         </tr>
      </table>
   </body>
</html>

在完成源文件和配置文件的创建后，导出您的应用程序。右键单击您的应用程序，使用导出 → WAR 文件选项，然后将 SpringWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器，并确保可以使用标准浏览器访问 webapps 文件夹中的其他网页。现在，尝试一个网址 – [role="bare"] [role="bare"]http://localhost:8080/SpringWeb/student ，如果 Spring Web 应用程序一切正常，您应该会看到以下屏幕。

在提交所需的信息后，单击提交按钮以提交表单。如果 Spring Web 应用程序一切正常，你应该会看到以下屏幕。

Spring MVC - Page Redirection Example

以下示例演示了如何编写一个简单的基于 web 的应用程序，该应用程序使用重定向将一个 http 请求传输到另一个页面。首先，让我们准备一个可用的 Eclipse IDE，并考虑按照以下步骤使用 Spring Web Framework 开发一个基于动态表单的 Web 应用程序 −

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建一个 Java 类 WebController。
3	在 jsp 子文件夹下创建视图文件 index.jsp、final.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

WebController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class WebController {

   @RequestMapping(value = "/index", method = RequestMethod.GET)
   public String index() {
	   return "index";
   }

   @RequestMapping(value = "/redirect", method = RequestMethod.GET)
   public String redirect() {

      return "redirect:finalPage";
   }

   @RequestMapping(value = "/finalPage", method = RequestMethod.GET)
   public String finalPage() {

      return "final";
   }
}

以下是 Spring 视图文件中的内容 index.jsp 。这将是一个着陆页，此页面将向 access-redirect 服务方法发送一个请求，该方法将此请求重定向到另一个服务方法，最后将显示一个 final.jsp 页面。

index.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring Page Redirection</title>
   </head>
   <body>
      <h2>Spring Page Redirection</h2>
      <p>Click below button to redirect the result to new page</p>
      <form:form method = "GET" action = "/HelloWeb/redirect">
         <table>
            <tr>
               <td>
                  <input type = "submit" value = "Redirect Page"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

final.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>

   <head>
      <title>Spring Page Redirection</title>
   </head>

   <body>
      <h2>Redirected Page</h2>
   </body>

</html>

一旦你完成了创建源文件和配置文件，导出你的应用程序。右键单击你的应用程序，使用“导出 → WAR 文件”选项并将你的 HelloWeb.war 文件保存到 Tomcat 的 Webapps 文件夹中。

现在，启动你的 Tomcat 服务器并确保你能够使用标准浏览器访问 Webapps 文件夹中的其他网页。尝试一个 URL -http://localhost:8080/HelloWeb/index，如果 Spring Web 应用程序一切正常，你应该会看到以下屏幕。

现在单击“重定向页面”按钮以提交表单并转到最终重定向页面。如果我们的 Spring Web 应用程序一切正常，我们应该会看到以下屏幕 −

Spring MVC - Static Pages Example

以下示例展示了如何使用 Spring MVC 框架编写一个简单的基于 Web 的应用程序，它可以通过 <mvc:resources> 标记访问静态页面和动态页面。

首先，让我们有一个正在工作的 Eclipse IDE，并遵循以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建一个 Java 类 WebController。
3	在 jsp 子文件夹下创建一个静态文件 final.htm 。
4	更新 WebContent/WEB-INF 文件夹下的 Spring 配置文件 HelloWeb-servlet.xml，如下所示。
5	最后一步是创建源代码和配置文件的内容并导出应用程序，如下所述。

WebController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class WebController {

   @RequestMapping(value = "/index", method = RequestMethod.GET)
   public String index() {
	   return "index";
   }

   @RequestMapping(value = "/staticPage", method = RequestMethod.GET)
   public String redirect() {

      return "redirect:/pages/final.htm";
   }
}

HelloWeb-servlet.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "  http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean id = "viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">

      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>
   <mvc:resources mapping = "/pages/**" location = "/WEB-INF/pages/" />
   <mvc:annotation-driven/>
</beans>

此处， <mvc:resources…./> 标记用于映射静态页面。mapping 属性必须是一个 Ant pattern ，它指定 http 请求的 URL 模式。location 属性必须指定一个或多个有效的资源目录位置，其中包含静态页面，包括图像、样式表、JavaScript 和其他静态内容。可以使用逗号分隔的值列表指定多个资源位置。

以下是 Spring 视图文件 WEB-INF/jsp/index.jsp 的内容。这将是一个登陆页面；此页面将发送一个请求来访问 staticPage service method ，该请求将重定向到 WEB-INF/pages 文件夹中可用的静态页面。

index.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring Landing Page</title>
   </head>
   <body>
      <h2>Spring Landing Pag</h2>
      <p>Click below button to get a simple HTML page</p>
      <form:form method = "GET" action = "/HelloWeb/staticPage">
         <table>
            <tr>
               <td>
                  <input type = "submit" value = "Get HTML Page"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

final.htm

<html>
   <head>
      <title>Spring Static Page</title>
   </head>
   <body>
      <h2>A simple HTML page</h2>
   </body>
</html>

现在，启动 Tomcat 服务器并确保你可以使用标准浏览器访问 webapps 文件夹中的其他网页。然后尝试访问该 URL – [role="bare"] [role="bare"]http://localhost:8080/HelloWeb/index 。如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

单击“获取 HTML 页面”按钮以访问 staticPage 服务方法中提到的静态页面。如果你的 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Text Box Example

以下示例演示了如何在表单中使用文本框，使用 Spring Web MVC 框架。首先，让我们准备一个能正常工作的 Eclipse IDE，然后按照以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序−

Step	Description
1	在包 com.tutorialspoint 下按照 Spring MVC - Hello World 示例章节中的说明，创建名称 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建 Java 类 Student、StudentController。
3	在 jsp 子文件夹下创建视图文件 student.jsp、result.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

Student.java

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class StudentController {

   @RequestMapping(value = "/student", method = RequestMethod.GET)
   public ModelAndView student() {
      return new ModelAndView("student", "command", new Student());
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.POST)
   public String addStudent(@ModelAttribute("SpringWeb")Student student,
      ModelMap model) {
      model.addAttribute("name", student.getName());
      model.addAttribute("age", student.getAge());
      model.addAttribute("id", student.getId());

      return "result";
   }
}

这里第一个服务方法 student() ，我们在 ModelAndView 对象中传递了一个空白 Student 对象，名称为“command”，因为如果您在 JSP 文件中使用 <form:form> 标记，Spring 框架需要名称为“command”的对象。所以当调用 student() 方法时，它会返回 student.jsp view 。

第二个服务方法 addStudent() 将针对 HelloWeb/addStudent URL 中的 POST 方法调用。您将根据已提交的信息准备模型对象。最后，将从服务方法返回一个“result”视图，此视图将导致呈现 result.jsp。

student.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Student Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addStudent">
         <table>
            <tr>
               <td><form:label path = "name">Name</form:label></td>
               <td><form:input path = "name" /></td>
            </tr>
            <tr>
               <td><form:label path = "age">Age</form:label></td>
               <td><form:input path = "age" /></td>
            </tr>
            <tr>
               <td><form:label path = "id">id</form:label></td>
               <td><form:input path = "id" /></td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

这里我们使用 <form:input /> 标记来呈现 HTML 文本框。例如 −

<form:input path = "name" />

它会呈现以下 HTML 内容。

<input id = "name" name = "name" type = "text" value = ""/>

result.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted Student Information</h2>
      <table>
         <tr>
            <td>Name</td>
            <td>${name}</td>
         </tr>
         <tr>
            <td>Age</td>
            <td>${age}</td>
         </tr>
         <tr>
            <td>ID</td>
            <td>${id}</td>
         </tr>
      </table>
   </body>
</html>

一旦创建完源文件和配置文件，导出您的应用程序。右键单击应用程序，使用 Export → WAR File 选项，并将 HelloWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器，确保您能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试一个 URL – http://localhost:8080/HelloWeb/student ，如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

在提交所需信息后，单击“submit”按钮提交表单。如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - Password Example

以下示例介绍了如何在表单中使用密码以及 Spring Web MVC 框架。首先，让我们有一个正在工作的 Eclipse IDE，并遵循以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp、users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
}

UserController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      return new ModelAndView("user", "command", new User());
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());

      return "users";
   }
}

这里，第一个服务方法 user() ，我们在 ModelAndView 对象中传递了一个空用户对象，名称为“command”，因为 Spring 框架期望一个名为“command”的对象，如果你在 JSP 文件中使用 <form:form> 标记。因此，当调用 user() 方法时，它返回 user.jsp 视图。

第二个服务方法 addUser() 将针对 HelloWeb/addUser URL 上的 POST 方法进行调用。你将根据提交的信息准备模型对象。最后，从服务方法返回“users”视图，这将导致呈现 users.jsp。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在此处，我们使用 <form:password /> 标记来呈现一个 HTML 密码框。例如 −

<form:password path = "password" />

它将呈现以下 HTML 内容。

<input id = "password" name = "password" type = "password" value = ""/>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>
      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
      </table>
   </body>
</html>

完成源代码和配置文件的创建后，导出应用程序。右键单击应用程序，使用“导出 → WAR 文件”选项，并将 HelloWeb.war 文件保存在 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器，并确保能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试一个 URL –http://localhost:8080/HelloWeb/user，如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

在提交所需信息后，单击“submit”按钮提交表单。如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - TextArea Example

以下示例介绍了如何在表单中使用 TextArea，方法是使用 Spring Web MVC 框架。首先，让我们提供一个可用的 Eclipse IDE，并按照后续步骤使用 Spring Web 框架开发基于动态表单的 Web 应用程序。

Step	Description
1	在程序包 com.tutorialspoint 下创建一个名称为 HelloWeb 的项目，如 Spring MVC - Hello World 章节中所述。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp、users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
}

UserController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      return new ModelAndView("user", "command", new User());
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());

      return "users";
   }
}

在这里，对于第一个服务方法 user()，我们在 ModelAndView 对象中传递了一个空白 User 对象，名称为“command”，这是因为如果你在 JSP 文件中使用 <form:form> 标记，则 Spring 框架需要一个名为“command”的对象。因此，当调用 user() 方法时，它将返回 user.jsp 视图。

第二个服务方法 addUser() 将相对于 HelloWeb/addUser URL 上的 POST 方法调用。你将根据提交的信息准备模型对象。最后，“users”视图将从服务方法返回，这将导致呈现 users.jsp。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

   <h2>User Information</h2>
   <form:form method = "POST" action = "/HelloWeb/addUser">
      <table>
         <tr>
            <td><form:label path = "username">User Name</form:label></td>
            <td><form:input path = "username" /></td>
         </tr>
         <tr>
            <td><form:label path = "password">Age</form:label></td>
            <td><form:password path = "password" /></td>
         </tr>
         <tr>
            <td><form:label path = "address">Address</form:label></td>
            <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
         </tr>
         <tr>
            <td colspan = "2">
               <input type = "submit" value = "Submit"/>
            </td>
         </tr>
      </table>
   </form:form>
   </body>
</html>

在这里，我们使用 <form:textarea /> 标记来呈现 HTML textarea 框。例如：

<form:textarea path = "address" rows = "5" cols = "30" />

它将呈现以下 HTML 内容。

<textarea id = "address" name = "address" rows = "5" cols = "30"></textarea>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
      </table>
   </body>
</html>

在提交所需信息后，单击“submit”按钮提交表单。如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - Checkbox Example

以下示例介绍了如何在表单中使用单个复选框，方法是使用 Spring Web MVC 框架。首先，让我们提供一个可用的 Eclipse IDE，并考虑以下步骤使用 Spring Web 框架开发基于动态表单的 Web 应用程序。

Step	Description
1	在程序包 com.tutorialspoint 下创建一个名称为 HelloWeb 的项目，如 Spring MVC - Hello World 示例章节中所述。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp、users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
}

UserController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      return new ModelAndView("user", "command", new User());
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
      return "users";
   }
}

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:checkboxes /> 标记来呈现 HTML 复选框。

例如 -

<form:checkbox path="receivePaper" />

它会呈现以下 HTML 内容。

<input id="receivePaper1" name = "receivePaper" type = "checkbox" value = "true"/>
<input type = "hidden" name = "_receivePaper" value = "on"/>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>
      </table>
   </body>
</html>

现在，启动 Tomcat 服务器，并确保能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试一个 URL – [role="bare"] [role="bare"]http://localhost:8080/HelloWeb/user ，如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

提交所需信息后，单击“提交”按钮以提交表单。如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Checkboxes Example

以下示例介绍了如何在表单中使用多个复选框，方法是使用 Spring Web MVC 框架。首先，让我们提供一个可用的 Eclipse IDE，并严格按照以下步骤使用 Spring Web 框架开发基于动态表单的 Web 应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp 和 users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;
   private String [] favoriteFrameworks;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
   public String[] getFavoriteFrameworks() {
      return favoriteFrameworks;
   }
   public void setFavoriteFrameworks(String[] favoriteFrameworks) {
      this.favoriteFrameworks = favoriteFrameworks;
   }
}

UserController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      User user = new User();
	  user.setFavoriteFrameworks((new String []{"Spring MVC","Struts 2"}));
	  ModelAndView modelAndView = new ModelAndView("user", "command", user);
	  return modelAndView;
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
	  model.addAttribute("favoriteFrameworks", user.getFavoriteFrameworks());
      return "users";
   }

   @ModelAttribute("webFrameworkList")
   public List<String> getWebFrameworkList() {
      List<String> webFrameworkList = new ArrayList<String>();
      webFrameworkList.add("Spring MVC");
      webFrameworkList.add("Struts 1");
      webFrameworkList.add("Struts 2");
      webFrameworkList.add("Apache Wicket");
      return webFrameworkList;
   }
}

在这里，对于第一个服务方法 user() ，我们在 ModelAndView 对象中传递了一个空白 User 对象，名称为“command”，这是因为如果你在 JSP 文件中使用 <form:form> 标记，则 Spring 框架需要一个名为“command”的对象。因此，当调用 user() 方法时，它将返回 user.jsp 视图。

第二个服务方法 addUser() 将相对于 HelloWeb/addUser URL 上的 POST 方法调用。你将根据提交的信息准备模型对象。最后，“users”视图将从服务方法返回，这将导致呈现 users.jsp。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td><form:label path = "favoriteFrameworks">Favorite Web Frameworks</form:label></td>
               <td><form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" /></td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:checkboxes /> 标记呈现 HTML 复选框。

<form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" />

它会呈现以下 HTML 内容。

<span>
   <input id = "favoriteFrameworks1" name = "favoriteFrameworks" type = "checkbox" value = "Spring MVC" checked = "checked"/>
   <label for = "favoriteFrameworks1">Spring MVC</label>
</span>
<span>
   <input id = "favoriteFrameworks2" name = "favoriteFrameworks" type = "checkbox" value = "Struts 1"/>
   <label for = "favoriteFrameworks2">Struts 1</label>
</span>
<span>
   <input id = "favoriteFrameworks3" name = "favoriteFrameworks" type = "checkbox" value = "Struts 2" checked = "checked"/>
   <label for = "favoriteFrameworks3">Struts 2</label>
</span>
<span>
   <input id = "favoriteFrameworks4" name = "favoriteFrameworks" type = "checkbox" value = "Apache Wicket"/>
   <label for = "favoriteFrameworks4">Apache Wicket</label>
</span>
<input type = "hidden" name = "_favoriteFrameworks" value = "on"/>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>
         <tr>
            <td>Favorite Web Frameworks</td>
            <td> <% String[] favoriteFrameworks = (String[])request.getAttribute("favoriteFrameworks");
            for(String framework: favoriteFrameworks) {
               out.println(framework);
            }
            %></td>
         </tr>
      </table>
   </body>
</html>

在您创建了源文件和配置文件以后，导出您的应用程序。右键单击您的应用程序，使用 Export → WAR File 选项，并保存在Tomcat的webapps文件夹中。

现在，启动Tomcat服务器，并确保您能通过标准浏览器访问webapps文件夹中的其它网页。尝试一个URL http://localhost:8080/HelloWeb/user ，如果Spring Web应用程序正常，我们将看到以下屏幕。

提交所需信息后，单击提交按钮来提交表单。如果你的 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - RadioButton Example

以下示例演示了如何在使用 Spring Web MVC 框架的表单中使用单选按钮。首先，我们提供一个正在运行的 Eclipse IDE，并按照以下步骤使用 Spring Web 框架开发基于动态表单的 Web 应用程序 −

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp 和 users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;
   private String [] favoriteFrameworks;
   private String gender;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
   public String[] getFavoriteFrameworks() {
      return favoriteFrameworks;
   }
   public void setFavoriteFrameworks(String[] favoriteFrameworks) {
      this.favoriteFrameworks = favoriteFrameworks;
   }
   public String getGender() {
      return gender;
   }
   public void setGender(String gender) {
      this.gender = gender;
   }
}

UserController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      User user = new User();
	  user.setFavoriteFrameworks((new String []{"Spring MVC","Struts 2"}));
      user.setGender("M");
	  ModelAndView modelAndView = new ModelAndView("user", "command", user);
	  return modelAndView;
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
	  model.addAttribute("favoriteFrameworks", user.getFavoriteFrameworks());
      model.addAttribute("gender", user.getGender());
      return "users";
   }

   @ModelAttribute("webFrameworkList")
   public List<String> getWebFrameworkList() {
      List<String> webFrameworkList = new ArrayList<String>();
      webFrameworkList.add("Spring MVC");
      webFrameworkList.add("Struts 1");
      webFrameworkList.add("Struts 2");
      webFrameworkList.add("Apache Wicket");
      return webFrameworkList;
   }
}

这里第一个服务方法 user() ，我们在 ModelAndView 对象中传递了一个空白 User 对象，名称为“command”，因为如果您在 JSP 文件中使用 <form:form> 标记，Spring 框架需要名称为“command”的对象。所以当调用 user() 方法时，它会返回 user.jsp 视图。

第二个服务方法 addUser() 将针对 HelloWeb/addUser URL 上的 POST 方法进行调用。你将根据提交的信息准备你的模型对象。最后，将在服务方法中返回“users”视图，这会导致呈现 users.jsp。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td><form:label path = "favoriteFrameworks">Favorite Web Frameworks</form:label></td>
               <td><form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" /></td>
            </tr>
            <tr>
               <td><form:label path = "gender">Gender</form:label></td>
               <td>
                  <form:radiobutton path = "gender" value = "M" label = "Male" />
                  <form:radiobutton path = "gender" value = "F" label = "Female" />
               </td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

这里我们使用 <form:radiobutton /> 标记来呈现 HTML 单选按钮。

<form:radiobutton path = "gender" value = "M" label = "Male" />
<form:radiobutton path = "gender" value = "F" label = "Female" />

它会呈现以下 HTML 内容。

<input id = "gender1" name = "gender" type = "radio" value = "M" checked = "checked"/><label for = "gender1">Male</label>
<input id = "gender2" name = "gender" type = "radio" value = "F"/><label for = "gender2">Female</label>

users.jsp

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<html>
<head>
    <title>Spring MVC Form Handling</title>
</head>
   <body>

      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>

         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>

         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>

         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>

         <tr>
            <td>Favorite Web Frameworks</td>
            <td> <% String[] favoriteFrameworks = (String[])request.getAttribute("favoriteFrameworks");
               for(String framework: favoriteFrameworks) {
                  out.println(framework);
               }
            %></td>
         </tr>

         <tr>
            <td>Gender</td>
            <td>${(gender=="M"? "Male" : "Female")}</td>
         </tr>
      </table>
   </body>
</html>

现在，启动 Tomcat 服务器，确保您能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试一个 URL – http://localhost:8080/HelloWeb/user ，如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

在提交所需信息后，单击“submit”按钮提交表单。如果 Spring Web 应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - RadioButtons Example

以下示例解释了如何在表单中使用 Spring Web MVC 框架中的单选按钮。首先，让我们准备一个能正常工作的 Eclipse IDE，然后按照以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp 和 users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;
   private String [] favoriteFrameworks;
   private String gender;
   private String favoriteNumber;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
   public String[] getFavoriteFrameworks() {
      return favoriteFrameworks;
   }
   public void setFavoriteFrameworks(String[] favoriteFrameworks) {
      this.favoriteFrameworks = favoriteFrameworks;
   }
   public String getGender() {
      return gender;
   }
   public void setGender(String gender) {
      this.gender = gender;
   }
   public String getFavoriteNumber() {
      return favoriteNumber;
   }
   public void setFavoriteNumber(String favoriteNumber) {
      this.favoriteNumber = favoriteNumber;
   }
}

UserController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      User user = new User();
	  user.setFavoriteFrameworks((new String []{"Spring MVC","Struts 2"}));
      user.setGender("M");
	  ModelAndView modelAndView = new ModelAndView("user", "command", user);
	  return modelAndView;
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
      model.addAttribute("favoriteFrameworks", user.getFavoriteFrameworks());
      model.addAttribute("gender", user.getGender());
      model.addAttribute("favoriteNumber", user.getFavoriteNumber());
      return "users";
   }

   @ModelAttribute("webFrameworkList")
   public List<String> getWebFrameworkList() {
      List<String> webFrameworkList = new ArrayList<String>();
      webFrameworkList.add("Spring MVC");
      webFrameworkList.add("Struts 1");
      webFrameworkList.add("Struts 2");
      webFrameworkList.add("Apache Wicket");
      return webFrameworkList;
   }

   @ModelAttribute("numbersList")
   public List<String> getNumbersList() {
      List<String> numbersList = new ArrayList<String>();
      numbersList.add("1");
      numbersList.add("2");
      numbersList.add("3");
      numbersList.add("4");
      return numbersList;
   }
}

在这里，对于第一个服务方法 user()，我们在 ModelAndView 对象中传递了一个名称为“command”的空白 User 对象，因为如果你在 JSP 文件中使用 <form:form> 标记，Spring 框架会期望一个名称为“command”的对象。因此，当调用 user() 方法时，它会返回 user.jsp 视图。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td><form:label path = "favoriteFrameworks">Favorite Web Frameworks</form:label></td>
               <td><form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" /></td>
            </tr>
            <tr>
               <td><form:label path = "gender">Gender</form:label></td>
               <td>
                  <form:radiobutton path = "gender" value = "M" label = "Male" />
                  <form:radiobutton path = "gender" value = "F" label = "Female" />
               </td>
            </tr>
            <tr>
               <td><form:label path = "favoriteNumber">Favorite Number</form:label></td>
               <td>
                  <form:radiobuttons path = "favoriteNumber" items = "${numbersList}" />
               </td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:radiobuttons /> 标记来呈现 HTML 单选按钮。例如 −

<form:radiobuttons path = "favoriteNumber" items="${numbersList}" />

它将呈现以下 HTML 内容。

<span>
   <input id = "favoriteNumber1" name = "favoriteNumber" type = "radio" value = "1"/>
   <label for = "favoriteNumber1">1</label>
</span>
<span>
   <input id = "favoriteNumber2" name = "favoriteNumber" type = "radio" value = "2"/>
   <label for = "favoriteNumber2">2</label>
</span>
<span>
   <input id = "favoriteNumber3" name = "favoriteNumber" type = "radio" value = "3"/>
   <label for = "favoriteNumber3">3</label>
</span>
<span>
   <input id = "favoriteNumber4" name = "favoriteNumber" type = "radio" value = "4"/>
   <label for = "favoriteNumber4">4</label>
</span>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>
      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>
         <tr>
            <td>Favorite Web Frameworks</td>
            <td> <% String[] favoriteFrameworks = (String[])request.getAttribute("favoriteFrameworks");
               for(String framework: favoriteFrameworks) {
                  out.println(framework);
               }
            %></td>
         </tr>
         <tr>
            <td>Gender</td>
            <td>${(gender=="M"? "Male" : "Female")}</td>
         </tr>
         <tr>
            <td>Favourite Number</td>
            <td>${favoriteNumber}</td>
         </tr>
      </table>
   </body>
</html>

创建源文件和配置文件后，导出应用程序。右键单击应用程序，然后单击 Export → WAR File 选项，并通过 Tomcat 的 webapps 文件夹保存 HelloWeb.war 文件。

现在，启动 Tomcat 服务器，确保你可以使用标准浏览器从 webapps 文件夹访问其他网页。尝试以下 URL – http://localhost:8080/HelloWeb/user ，如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

提交所需信息后，单击提交按钮来提交表单。如果你的 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Dropdown Example

以下示例描述了如何使用Spring Web MVC框架在表单中使用下拉菜单。首先，我们得准备一个Eclipse IDE并按照以下步骤，使用Spring Web框架开发一个基于动态表单的Web应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp 和 users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;
   private String [] favoriteFrameworks;
   private String gender;
   private String favoriteNumber;
   private String country;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
   public String[] getFavoriteFrameworks() {
      return favoriteFrameworks;
   }
   public void setFavoriteFrameworks(String[] favoriteFrameworks) {
      this.favoriteFrameworks = favoriteFrameworks;
   }
   public String getGender() {
      return gender;
   }
   public void setGender(String gender) {
      this.gender = gender;
   }
   public String getFavoriteNumber() {
      return favoriteNumber;
   }
   public void setFavoriteNumber(String favoriteNumber) {
      this.favoriteNumber = favoriteNumber;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
}

UserController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      User user = new User();
	  user.setFavoriteFrameworks((new String []{"Spring MVC","Struts 2"}));
      user.setGender("M");
	  ModelAndView modelAndView = new ModelAndView("user", "command", user);
	  return modelAndView;
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
	  model.addAttribute("favoriteFrameworks", user.getFavoriteFrameworks());
      model.addAttribute("gender", user.getGender());
      model.addAttribute("favoriteNumber", user.getFavoriteNumber());
      model.addAttribute("country", user.getCountry());
      return "users";
   }

   @ModelAttribute("webFrameworkList")
   public List<String> getWebFrameworkList() {
      List<String> webFrameworkList = new ArrayList<String>();
      webFrameworkList.add("Spring MVC");
      webFrameworkList.add("Struts 1");
      webFrameworkList.add("Struts 2");
      webFrameworkList.add("Apache Wicket");
      return webFrameworkList;
   }

   @ModelAttribute("numbersList")
   public List<String> getNumbersList() {
      List<String> numbersList = new ArrayList<String>();
      numbersList.add("1");
      numbersList.add("2");
      numbersList.add("3");
      numbersList.add("4");
      return numbersList;
   }

   @ModelAttribute("countryList")
   public Map<String, String> getCountryList() {
      Map<String, String> countryList = new HashMap<String, String>();
      countryList.put("US", "United States");
      countryList.put("CH", "China");
      countryList.put("SG", "Singapore");
      countryList.put("MY", "Malaysia");
      return countryList;
   }
}

这里，对于第一个服务方法 user() 来说，我们在“command”名称的ModelAndView对象中传递了一个空 User 对象，因为如果你的JSP文件里使用<form:form>标签的话，Spring框架期望一个名称为“command”的对象。因此当 user() 被调用时，它返回 user.jsp 视图。

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

   <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td><form:label path = "favoriteFrameworks">Favorite Web Frameworks</form:label></td>
               <td><form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" /></td>
            </tr>
            <tr>
               <td><form:label path = "gender">Gender</form:label></td>
               <td>
                  <form:radiobutton path = "gender" value = "M" label = "Male" />
                  <form:radiobutton path = "gender" value = "F" label = "Female" />
               </td>
            </tr>
            <tr>
               <td><form:label path = "favoriteNumber">Favorite Number</form:label></td>
               <td>
                  <form:radiobuttons path = "favoriteNumber" items = "${numbersList}" />
               </td>
            </tr>
            <tr>
               <td><form:label path = "country">Country</form:label></td>
               <td>
                  <form:select path = "country">
                     <form:option value = "NONE" label = "Select"/>
                     <form:options items = "${countryList}" />
                  </form:select>
               </td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

这里，我们使用 <form:select /> , <form:option /> 和 <form:options /> 标签来呈现 HTML 选择。例如 −

<form:select path = "country">
   <form:option value = "NONE" label = "Select"/>
   <form:options items = "${countryList}" />
</form:select>

它会呈现以下 HTML 内容。

<select id = "country" name = "country">
   <option value = "NONE">Select</option>
   <option value = "US">United States</option>
   <option value = "CH">China</option>
   <option value = "MY">Malaysia</option>
   <option value = "SG">Singapore</option>
</select>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>
      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>
         <tr>
            <td>Favorite Web Frameworks</td>
            <td> <% String[] favoriteFrameworks = (String[])request.getAttribute("favoriteFrameworks");
               for(String framework: favoriteFrameworks) {
                  out.println(framework);
               }
            %></td>
         </tr>
         <tr>
            <td>Gender</td>
            <td>${(gender=="M"? "Male" : "Female")}</td>
         </tr>
         <tr>
            <td>Favourite Number</td>
            <td>${favoriteNumber}</td>
         </tr>
         <tr>
            <td>Country</td>
            <td>${country}</td>
         </tr>
      </table>
   </body>
</html>

一旦你完成了创建源文件和配置文件，导出你的应用程序。右键单击你的应用程序，使用 Export → WAR File 选项并将你的 HelloWeb.war 文件保存到 Tomcat 的 Webapps 文件夹中。

现在，启动 Tomcat 服务器并确保你能够使用标准浏览器访问 Webapps 文件夹中的其他网页。尝试一个 URL - http://localhost:8080/HelloWeb/user ，如果 Spring Web 应用程序一切正常，我们将看到下面的屏幕。

在提交所需的信息后，单击提交按钮以提交表单。如果 Spring Web 应用程序一切正常，你应该会看到以下屏幕。

Spring MVC - Listbox Example

以下示例展示了如何在表单中使用Spring Web MVC框架中的列表框。首先，让我们使用Eclipse IDE并按照后续步骤使用Spring Web框架开发一个基于动态表单的Web应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp 和 users.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {

   private String username;
   private String password;
   private String address;
   private boolean receivePaper;
   private String [] favoriteFrameworks;
   private String gender;
   private String favoriteNumber;
   private String country;
   private String [] skills;

   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public boolean isReceivePaper() {
      return receivePaper;
   }
   public void setReceivePaper(boolean receivePaper) {
      this.receivePaper = receivePaper;
   }
   public String[] getFavoriteFrameworks() {
      return favoriteFrameworks;
   }
   public void setFavoriteFrameworks(String[] favoriteFrameworks) {
      this.favoriteFrameworks = favoriteFrameworks;
   }
   public String getGender() {
      return gender;
   }
   public void setGender(String gender) {
      this.gender = gender;
   }
   public String getFavoriteNumber() {
      return favoriteNumber;
   }
   public void setFavoriteNumber(String favoriteNumber) {
      this.favoriteNumber = favoriteNumber;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   public String[] getSkills() {
      return skills;
   }
   public void setSkills(String[] skills) {
      this.skills = skills;
   }
}

UserController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class UserController {

   @RequestMapping(value = "/user", method = RequestMethod.GET)
   public ModelAndView user() {
      User user = new User();
	  user.setFavoriteFrameworks((new String []{"Spring MVC","Struts 2"}));
      user.setGender("M");
	  ModelAndView modelAndView = new ModelAndView("user", "command", user);
	  return modelAndView;
   }

   @RequestMapping(value = "/addUser", method = RequestMethod.POST)
   public String addUser(@ModelAttribute("SpringWeb")User user,
      ModelMap model) {
      model.addAttribute("username", user.getUsername());
      model.addAttribute("password", user.getPassword());
      model.addAttribute("address", user.getAddress());
      model.addAttribute("receivePaper", user.isReceivePaper());
	  model.addAttribute("favoriteFrameworks", user.getFavoriteFrameworks());
      model.addAttribute("gender", user.getGender());
      model.addAttribute("favoriteNumber", user.getFavoriteNumber());
      model.addAttribute("country", user.getCountry());
      model.addAttribute("skills", user.getSkills());
      return "users";
   }

   @ModelAttribute("webFrameworkList")
   public List<String> getWebFrameworkList() {
      List<String> webFrameworkList = new ArrayList<String>();
      webFrameworkList.add("Spring MVC");
      webFrameworkList.add("Struts 1");
      webFrameworkList.add("Struts 2");
      webFrameworkList.add("Apache Wicket");
      return webFrameworkList;
   }

   @ModelAttribute("numbersList")
   public List<String> getNumbersList() {
      List<String> numbersList = new ArrayList<String>();
      numbersList.add("1");
      numbersList.add("2");
      numbersList.add("3");
      numbersList.add("4");
      return numbersList;
   }

   @ModelAttribute("countryList")
   public Map<String, String> getCountryList() {
      Map<String, String> countryList = new HashMap<String, String>();
      countryList.put("US", "United States");
      countryList.put("CH", "China");
      countryList.put("SG", "Singapore");
      countryList.put("MY", "Malaysia");
      return countryList;
   }

   @ModelAttribute("skillsList")
   public Map<String, String> getSkillsList() {
      Map<String, String> skillList = new HashMap<String, String>();
      skillList.put("Hibernate", "Hibernate");
      skillList.put("Spring", "Spring");
      skillList.put("Apache Wicket", "Apache Wicket");
      skillList.put("Struts", "Struts");
      return skillList;
   }
}

user.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>User Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addUser">
         <table>
            <tr>
               <td><form:label path = "username">User Name</form:label></td>
               <td><form:input path = "username" /></td>
            </tr>
            <tr>
               <td><form:label path = "password">Age</form:label></td>
               <td><form:password path = "password" /></td>
            </tr>
            <tr>
               <td><form:label path = "address">Address</form:label></td>
               <td><form:textarea path = "address" rows = "5" cols = "30" /></td>
            </tr>
            <tr>
               <td><form:label path = "receivePaper">Subscribe Newsletter</form:label></td>
               <td><form:checkbox path = "receivePaper" /></td>
            </tr>
            <tr>
               <td><form:label path = "favoriteFrameworks">Favorite Web Frameworks</form:label></td>
               <td><form:checkboxes items = "${webFrameworkList}" path = "favoriteFrameworks" /></td>
            </tr>
            <tr>
               <td><form:label path = "gender">Gender</form:label></td>
               <td>
                  <form:radiobutton path = "gender" value = "M" label = "Male" />
                  <form:radiobutton path = "gender" value = "F" label = "Female" />
               </td>
            </tr>
            <tr>
               <td><form:label path = "favoriteNumber">Favorite Number</form:label></td>
               <td>
                  <form:radiobuttons path = "favoriteNumber" items = "${numbersList}" />
               </td>
            </tr>
            <tr>
               <td><form:label path = "country">Country</form:label></td>
               <td>
                  <form:select path = "country">
                     <form:option value = "NONE" label = "Select"/>
                     <form:options items = "${countryList}" />
                  </form:select>
               </td>
            </tr>
            <tr>
               <td><form:label path = "skills">Skills</form:label></td>
               <td>
                  <form:select path = "skills" items = "${skillsList}"
                     multiple = "true" />
               </td>
            </tr>
            <tr>
               <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:select /> 标记，其中具有属性 multiple=true 来绘制一个HTML列表框。例如 −

<form:select path = "skills" items = "${skillsList}" multiple = "true" />

它会呈现以下 HTML 内容。

<select id = "skills" name = "skills" multiple = "multiple">
   <option value = "Struts">Struts</option>
   <option value = "Hibernate">Hibernate</option>
   <option value = "Apache Wicket">Apache Wicket</option>
   <option value = "Spring">Spring</option>
</select>
<input type = "hidden" name = "_skills" value = "1"/>

users.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted User Information</h2>
      <table>
         <tr>
            <td>Username</td>
            <td>${username}</td>
         </tr>
         <tr>
            <td>Password</td>
            <td>${password}</td>
         </tr>
         <tr>
            <td>Address</td>
            <td>${address}</td>
         </tr>
         <tr>
            <td>Subscribed to Newsletter</td>
            <td>${receivePaper}</td>
         </tr>
         <tr>
            <td>Favorite Web Frameworks</td>
            <td> <% String[] favoriteFrameworks = (String[])request.getAttribute("favoriteFrameworks");
               for(String framework: favoriteFrameworks) {
                  out.println(framework);
               }
            %></td>
         </tr>
         <tr>
            <td>Gender</td>
            <td>${(gender=="M"? "Male" : "Female")}</td>
         </tr>
         <tr>
            <td>Favourite Number</td>
            <td>${favoriteNumber}</td>
         </tr>
         <tr>
            <td>Country</td>
            <td>${country}</td>
         </tr>
         <tr>
            <td>Skills</td>
            <td> <% String[] skills = (String[])request.getAttribute("skills");
            for(String skill: skills) {
               out.println(skill);
            }
            %></td>
         </tr>
      </table>
   </body>
</html>

创建源文件和配置文件后，导出应用程序。右键单击应用程序，然后单击 Export → WAR File 选项，并通过 Tomcat 的 webapps 文件夹保存 HelloWeb.war 文件。

现在，启动Tomcat服务器，并确保您能通过标准浏览器访问webapps文件夹中的其它网页。尝试一个URL − http://localhost:8080/HelloWeb/user ，如果Spring Web应用程序正常，我们将看到以下屏幕。

在提交所需的信息后，单击提交按钮以提交表单。如果 Spring Web 应用程序一切正常，你应该会看到以下屏幕。

Spring MVC - Hidden Field Example

以下示例描述了如何在表单中使用Spring Web MVC框架中的隐藏字段。首先，让我们使用Eclipse IDE并按照以下步骤使用Spring Web框架开发一个基于动态表单的Web应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建 Java 类 Student、StudentController。
3	在 jsp 子文件夹下创建视图文件 student.jsp、result.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

Student.java

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.ui.ModelMap;

@Controller
public class StudentController {

   @RequestMapping(value = "/student", method = RequestMethod.GET)
   public ModelAndView student() {
      return new ModelAndView("student", "command", new Student());
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.POST)
   public String addStudent(@ModelAttribute("SpringWeb")Student student,
      ModelMap model) {
      model.addAttribute("name", student.getName());
      model.addAttribute("age", student.getAge());
      model.addAttribute("id", student.getId());

      return "result";
   }
}

在这里，对于第一个服务方法 student() ，我们在ModelAndView对象中传递了一个空白 Studentobject ，名称为“command”，因为如果您在JSP文件中使用<form:form>标记，Spring框架将期待一个名为“command”的对象。因此，当调用 student() 方法时，它将返回 student.jsp 视图。

student.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Student Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addStudent">
         <table>
            <tr>
              <td><form:label path = "name">Name</form:label></td>
              <td><form:input path = "name" /></td>
            </tr>
            <tr>
              <td><form:label path = "age">Age</form:label></td>
              <td><form:input path = "age" /></td>
            </tr>
            <tr>
              <td>< </td>
              <td><form:hidden path = "id" value = "1" /></td>
            </tr>
            <tr>
              <td colspan = "2">
                  <input type = "submit" value = "Submit"/>
              </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:hidden /> 标记来绘制一个HTML隐藏字段。

例如 -

<form:hidden path = "id" value = "1"/>

它会呈现以下 HTML 内容。

<input id = "id" name = "id" type = "hidden" value = "1"/>

result.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted Student Information</h2>
      <table>
         <tr>
            <td>Name</td>
            <td>${name}</td>
         </tr>
         <tr>
            <td>Age</td>
            <td>${age}</td>
         </tr>
         <tr>
            <td>ID</td>
            <td>${id}</td>
         </tr>
      </table>
   </body>
</html>

在您创建了源文件和配置文件以后，导出您的应用程序。右键单击您的应用程序并使用 Export → WAR File 选项，并保存在Tomcat的webapps文件夹中。

现在，启动Tomcat服务器，并确保您能通过标准浏览器访问webapps文件夹中的其它网页。尝试一个URL – http://localhost:8080/HelloWeb/student ，如果Spring Web应用程序正常，我们将看到以下屏幕。

提交所需信息后，单击提交按钮来提交表单。如果你的 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Error Handling Example

以下示例展示了如何在表单中使用Spring Web MVC框架中的错误处理和验证器。首先，让我们使用Eclipse IDE并按照以下步骤使用Spring Web框架开发一个基于动态表单的Web应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在com.tutorialspoint包中创建Java类Student、StudentController和StudentValidator。
3	在jsp子文件夹中创建视图文件addStudent.jsp、result.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

Student.java

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentValidator.java

package com.tutorialspoint;

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

public class StudentValidator implements Validator {

   @Override
   public boolean supports(Class<?> clazz) {
      return Student.class.isAssignableFrom(clazz);
   }

   @Override
   public void validate(Object target, Errors errors) {
      ValidationUtils.rejectIfEmptyOrWhitespace(errors,
         "name", "required.name","Field name is required.");
   }
}

StudentController.java

package com.tutorialspoint;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class StudentController {

   @Autowired
   @Qualifier("studentValidator")
   private Validator validator;

   @InitBinder
   private void initBinder(WebDataBinder binder) {
      binder.setValidator(validator);
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.GET)
   public ModelAndView student() {
      return new ModelAndView("addStudent", "command", new Student());
   }

   @ModelAttribute("student")
   public Student createStudentModel() {
      return new Student();
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.POST)
   public String addStudent(@ModelAttribute("student") @Validated Student student,
      BindingResult bindingResult, Model model) {

      if (bindingResult.hasErrors()) {
         return "addStudent";
      }
      model.addAttribute("name", student.getName());
      model.addAttribute("age", student.getAge());
      model.addAttribute("id", student.getId());

      return "result";
   }
}

HelloWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

   <bean id = "studentValidator" class = "com.tutorialspoint.StudentValidator" />
</beans>

在这里，对于第一个服务方法 student() ，我们在ModelAndView对象中传递了一个空白Studentobject，名称为“command”，因为如果您在JSP文件中使用<form:form>标记，Spring框架将期待一个名为“command”的对象。因此，当调用student()方法时，它将返回 addStudent.jsp 视图。

第二个服务方法 addStudent() 将在 HelloWeb/addStudent URL上的POST方法中被调用。您将根据提交的信息准备您的模型对象。最后，将从服务方法中返回“result”视图，这将导致渲染result.jsp。如果使用验证器生成了错误，那么将返回相同的“addStudent”视图，Spring将自动在视图中从 BindingResult 注入错误消息。

addStudent.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <style>
      .error {
         color: #ff0000;
      }

      .errorblock {
         color: #000;
         background-color: #ffEEEE;
         border: 3px solid #ff0000;
         padding: 8px;
         margin: 16px;
      }
   </style>

   <body>
      <h2>Student Information</h2>
      <form:form method = "POST" action = "/HelloWeb/addStudent" commandName = "student">
      <form:errors path = "*" cssClass = "errorblock" element = "div" />
         <table>
            <tr>
               <td><form:label path = "name">Name</form:label></td>
               <td><form:input path = "name" /></td>
               <td><form:errors path = "name" cssClass = "error" /></td>
            </tr>
            <tr>
               <td><form:label path = "age">Age</form:label></td>
               <td><form:input path = "age" /></td>
            </tr>
            <tr>
               <td><form:label path = "id">id</form:label></td>
               <td><form:input path = "id" /></td>
            </tr>
            <tr>
               <td colspan = "2">
               <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用 <form:errors /> 标签和path="*"来呈现错误消息。例如

<form:errors path = "*" cssClass = "errorblock" element = "div" />

它将呈现所有输入验证的错误消息。

我们使用 <form:errors /> 标签和path="name"来呈现name字段的错误消息。例如

<form:errors path = "name" cssClass = "error" />

它将呈现name字段验证的错误消息。

result.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted Student Information</h2>
      <table>
         <tr>
            <td>Name</td>
            <td>${name}</td>
         </tr>
         <tr>
            <td>Age</td>
            <td>${age}</td>
         </tr>
         <tr>
           <td>ID</td>
           <td>${id}</td>
         </tr>
      </table>
   </body>
</html>

现在，启动 Tomcat 服务器并确保能够使用标准浏览器访问 webapps 文件夹中的其他网页。尝试以下 URL - http://localhost:8080/HelloWeb/addStudent 如果 Spring Web 应用程序一切正常，我们会看到以下屏幕。

提交所需信息后，单击提交按钮提交表单。如果 Spring Web 应用程序一切正常，您应该看到以下屏幕。

Spring MVC - File Upload Example

以下示例展示了如何在表单中使用文件上传控件及使用 Spring Web MVC 框架。首先准备一个可用的 Eclipse IDE，并遵循以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	按照 Spring MVC - Hello World 章节中的说明，使用 com.tutorialspoint 作为包，创建一个名为 HelloWeb 的项目。
2	在 com.tutorialspoint 包下创建 Java 类 FileModel 和 FileUploadController。
3	在 jsp 子文件夹下创建视图文件 fileUpload.jsp 和 success.jsp。
4	在 WebContent 子文件夹下创建一个文件夹 temp 。
5	下载 Apache Commons FileUpload 库 commons-fileupload.jar 和 Apache Commons IO 库 commons-io.jar 。将它们放入您的 CLASSPATH。
6	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

FileModel.java

package com.tutorialspoint;

import org.springframework.web.multipart.MultipartFile;

public class FileModel {
   private MultipartFile file;

   public MultipartFile getFile() {
      return file;
   }

   public void setFile(MultipartFile file) {
      this.file = file;
   }
}

FileUploadController.java

package com.tutorialspoint;

import java.io.File;
import java.io.IOException;

import javax.servlet.ServletContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.util.FileCopyUtils;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FileUploadController {

   @Autowired
   ServletContext context;

   @RequestMapping(value = "/fileUploadPage", method = RequestMethod.GET)
   public ModelAndView fileUploadPage() {
      FileModel file = new FileModel();
      ModelAndView modelAndView = new ModelAndView("fileUpload", "command", file);
      return modelAndView;
   }

   @RequestMapping(value="/fileUploadPage", method = RequestMethod.POST)
   public String fileUpload(@Validated FileModel file, BindingResult result, ModelMap model) throws IOException {
      if (result.hasErrors()) {
         System.out.println("validation errors");
         return "fileUploadPage";
      } else {
         System.out.println("Fetching file");
         MultipartFile multipartFile = file.getFile();
         String uploadPath = context.getRealPath("") + File.separator + "temp" + File.separator;
         //Now do something with file...
         FileCopyUtils.copy(file.getFile().getBytes(), new File(uploadPath+file.getFile().getOriginalFilename()));
         String fileName = multipartFile.getOriginalFilename();
         model.addAttribute("fileName", fileName);
         return "success";
      }
   }
}

HelloWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

   <bean id = "multipartResolver"
      class = "org.springframework.web.multipart.commons.CommonsMultipartResolver" />
</beans>

这里，对于第一个服务方法 fileUploadPage() ，我们在 ModelAndView 对象中传递了一个空白 FileModel 对象，名称为 command，因为如果您在您的 JSP 文件中使用了 <form:form> 标签，Spring 框架会期盼一个名称为 command 的对象。因此，当调用 fileUploadPage() 方法时，它会返回 fileUpload.jsp 视图。

第二个服务方法 fileUpload() 将被用于对比 HelloWeb/fileUploadPage URL 的 POST 方法。您将根据提交的信息准备要上传的文件。最后，服务方法会返回 success 视图，这将导致呈现 success.jsp。

fileUpload.jsp

<%@ page contentType="text/html; charset = UTF-8" %>
<%@ taglib prefix = "form" uri = "http://www.springframework.org/tags/form"%>
<html>
   <head>
      <title>File Upload Example</title>
   </head>

   <body>
      <form:form method = "POST" modelAttribute = "fileUpload"
         enctype = "multipart/form-data">
         Please select a file to upload :
         <input type = "file" name = "file" />
         <input type = "submit" value = "upload" />
      </form:form>
   </body>
</html>

这里，我们使用 modelAttribute 属性以及值为 fileUpload 来映射文件上传控件和服务器模型。

success.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>File Upload Example</title>
   </head>
   <body>
      FileName :
      lt;b> ${fileName} </b> - Uploaded Successfully.
   </body>
</html>

在创建原代码和配置文件后，导出您的应用程序。右键单击您的应用程序，使用 Export → WAR File 选项，并将 HelloWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器并确保能够使用标准浏览器访问 webapps 文件夹中的其他网页。尝试以下 URL - http://localhost:8080/HelloWeb/fileUploadPage 如果 Spring Web 应用程序一切正常，我们会看到以下屏幕。

提交所需信息后，单击提交按钮提交表单。如果 Spring Web 应用程序一切正常，您应该看到以下屏幕。

Spring MVC - Bean Name Url Handler Mapping Example

以下示例展示了如何使用Spring Web MVC框架使用Bean名称URL处理程序映射。 BeanNameUrlHandlerMapping 类是默认的处理程序映射类，该类将URL请求映射到配置中所述bean的名称。

<beans>
   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

   <bean name = "/helloWorld.htm"
      class = "com.tutorialspoint.HelloController" />

   <bean name = "/hello*"
      class = "com.tutorialspoint.HelloController" />

   <bean name = "/welcome.htm"
      class = "com.tutorialspoint.WelcomeController"/>
</beans>

例如，使用以上配置，如果 URI

/helloWorld.htm或/hello{任意字母}.htm被请求，DispatcherServlet就会把请求转发给 HelloController 。
/welcome.htm，DispatcherServlet 将会将请求转发到 WelcomeController 。
/welcome1.htm被请求，DispatcherServlet将找不到任何控制器，服务器将抛出404状态错误。

首先，让我们准备好一个运行的 Eclipse IDE，然后考虑以下步骤使用 Spring Web Framework 开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在com.tutorialspoint包下创建Java类HelloController和WelcomeController。
3	在子文件夹jsp下创建视图文件hello.jsp和welcome.jsp。
4	最后一步是创建所有资源文件和配置文件的内容并导出应用程序，如下所示：

HelloController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class HelloController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("hello");
      model.addObject("message", "Hello World!");
      return model;
   }
}

WelcomeController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class WelcomeController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("welcome");
      model.addObject("message", "Welcome!");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

   <bean name = "/helloWorld.htm"
      class = "com.tutorialspoint.HelloController" />

   <bean name = "/hello*"
      class = "com.tutorialspoint.HelloController" />

   <bean name = "/welcome.htm"
      class = "com.tutorialspoint.WelcomeController"/>
</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

welcome.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Welcome</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

一旦你创建完资源文件和配置文件，导出你的应用程序。右键点击你的应用程序，使用 Export → WAR File 选项并在Tomcat的webapps文件夹中保存 TestWeb.war 文件。

现在，启动你的 Tomcat 服务器并确保你可以使用标准浏览器访问 webapps 文件夹中的其他网页。如果 Spring Web 应用程序一切正常，尝试一下 URL − http://localhost:8080/TestWeb/helloWorld.htm ，我们将看到以下界面。

尝试一个网址 http://localhost:8080/TestWeb/hello.htm ，如果Spring Web应用程序一切正常，我们将会看到以下屏幕。

尝试一个网址 http://localhost:8080/TestWeb/welcome.htm ，如果Spring Web应用程序一切正常，我们将会看到以下屏幕。

尝试一个网址 http://localhost:8080/TestWeb/welcome1.htm ，如果Spring Web应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - Controller Class Name Handler Mapping Example

以下示例展示了如何使用控制器类名处理映射及使用 Spring Web MVC 框架。 ControllerClassNameHandlerMapping 类是基于约定的处理程序映射类，它将 URL 请求映射到配置中提到的控制器的名称。该类获取控制器名称并将它们转换成小写，并在其前面添加 /。

例如 - HelloController 映射到 /hello* URL。

<beans>
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>

   <bean class = "com.tutorialspoint.HelloController" />

   <bean class = "com.tutorialspoint.WelcomeController"/>
</beans>

例如，使用以上配置，如果请求 URI

/helloWorld.htm或/hello{任意字母}.htm被请求，DispatcherServlet就会把请求转发给 HelloController 。
/welcome.htm，DispatcherServlet 将会将请求转发到 WelcomeController 。
如果请求 /Welcome.htm 且 W 为大写，DispatcherServlet 将找不到任何控制器，并且服务器将抛出 404 状态错误。

首先准备一个可用的 Eclipse IDE，并遵循后续步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 HelloController 和 WelcomeController。
3	在子文件夹jsp下创建视图文件hello.jsp和welcome.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class HelloController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("hello");
      model.addObject("message", "Hello World!");
      return model;
   }
}

WelcomeController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class WelcomeController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("welcome");
      model.addObject("message", "Welcome!");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>

   <bean class = "com.tutorialspoint.HelloController" />

   <bean class = "com.tutorialspoint.WelcomeController"/>
</beans>

hello.jsp

<%@ page contentType="text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

welcome.jsp

<%@ page contentType = "text/html; charset=UTF-8" %>
<html>
   <head>
      <title>Welcome</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

在创建原代码和配置文件后，导出您的应用程序。右键单击该应用程序，使用 Export → WAR File 选项，并将 TestWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器并确保能够使用标准浏览器访问 webapps 文件夹中的其他网页。尝试以下 URL - http://localhost:8080/TestWeb/helloWorld.htm 如果 Spring Web 应用程序一切正常，我们会看到以下屏幕。

尝试以下 URL - http://localhost:8080/TestWeb/hello.htm 如果 Spring Web 应用程序一切正常，我们会看到以下屏幕。

尝试一个网址 http://localhost:8080/TestWeb/welcome.htm ，如果Spring Web应用程序一切正常，我们将会看到以下屏幕。

尝试URL http://localhost:8080/TestWeb/Welcome.htm ，如果Spring Web应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Simple Url Handler Mapping Example

以下示例展示如何使用 Spring Web MVC 框架使用 Simple URL Handler Mapping。SimpleUrlHandlerMapping 类有助于将 URL 显式映射到其各自的控制器。

<beans>
   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
      <property name = "mappings">
         <props>
            <prop key = "/welcome.htm">welcomeController</prop>
            <prop key = "/helloWorld.htm">helloController</prop>
         </props>
      </property>
   </bean>

   <bean id = "helloController" class = "com.tutorialspoint.HelloController" />

   <bean id = "welcomeController" class = "com.tutorialspoint.WelcomeController"/>
</beans>

例如，使用以上配置，如果请求 URI

/helloWorld.htm，DispatcherServlet 将会将请求转发到 HelloController 。
/welcome.htm，DispatcherServlet 将会将请求转发到 WelcomeController 。

首先，让我们准备好一个运行的 Eclipse IDE，然后考虑以下步骤使用 Spring Web Framework 开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 HelloController 和 WelcomeController。
3	在 jsp 子文件夹下创建视图文件 hello.jsp 和 welcome.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class HelloController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("hello");
      model.addObject("message", "Hello World!");
      return model;
   }
}

WelcomeController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class WelcomeController extends AbstractController{

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("welcome");
      model.addObject("message", "Welcome!");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
      <property name = "mappings">
         <props>
            <prop key = "/welcome.htm">welcomeController</prop>
            <prop key = "/helloWorld.htm">helloController</prop>
         </props>
      </property>
   </bean>

   <bean id = "helloController" class = "com.tutorialspoint.HelloController" />

   <bean id = "welcomeController" class = "com.tutorialspoint.WelcomeController"/>
</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

welcome.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Welcome</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

一旦创建好源代码和配置文件，就导出你的应用程序。右键单击你的应用程序，使用 Export → WAR File 选项，并将你的 TestWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

尝试一下 URL http://localhost:8080/TestWeb/welcome.htm ，如果你的 Spring Web 应用程序一切正常，你应该会看到以下结果。

Spring MVC - Multi Action Controller Example

以下示例展示了如何使用Spring Web MVC框架使用Multi Action Controller。 MultiActionController 类帮助分别将多个URL与其方法映射到单个控制器。

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("home");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

<bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<bean name = "/home.htm" class = "com.tutorialspoint.UserController" />
<bean name = "/user/*.htm" class = "com.tutorialspoint.UserController" />

例如，使用以上配置，如果请求 URI −

请求/home.htm，DispatcherServlet将转发请求到UserController home() 方法。
请求user/add.htm，DispatcherServlet将转发请求到UserController add() 方法。
请求user/remove.htm，DispatcherServlet将转发请求到UserController remove() 方法。

首先，让我们准备一个可用的Eclipse IDE，并坚持以下步骤，使用Spring Web框架开发基于动态表单的Web应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 UserController。
3	在jsp子文件夹下创建视图文件home.jsp和user.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

UserController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("home");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
   <bean name = "/home.htm"
      class = "com.tutorialspoint.UserController" />
   <bean name = "/user/*.htm"
      class = "com.tutorialspoint.UserController" />
</beans>

home.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = ISO-8859-1">
      <title>Home</title>
   </head>

   <body>
      <a href = "user/add.htm" >Add</a> <br>
      <a href = "user/remove.htm" >Remove</a>
   </body>
</html>

user.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

现在，启动您的Tomcat服务器，并确保您可以使用标准浏览器从webapps文件夹访问其他网页。现在，尝试URL − http://localhost:8080/TestWeb/home.htm ，如果Spring Web应用程序一切正常，我们将看到以下屏幕。

尝试URL http://localhost:8080/TestWeb/user/add.htm ，如果Spring Web应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Properties Method Name Resolver Example

以下示例展示了如何使用Spring Web MVC框架的Multi Action Controller的方法名解析器方法。 MultiActionController 类帮助分别将多个URL与其方法映射到单个控制器。

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

<bean class = "com.tutorialspoint.UserController">
   <property name = "methodNameResolver">
      <bean class = "org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">
         <property name = "mappings">
            <props>
               <prop key = "/user/home.htm">home</prop>
               <prop key = "/user/add.htm">add</prop>
               <prop key = "/user/remove.htm">update</prop>
            </props>
         </property>
      </bean>
   </property>
</bean>

例如，使用以上配置，如果请求 URI −

请求/user/home.htm，DispatcherServlet将转发请求到UserController home() 方法。
请求/user/add.htm，DispatcherServlet将转发请求到UserController add() 方法。
请求/user/remove.htm，DispatcherServlet将转发请求到UserController remove() 方法。

首先，让我们准备一个可用的Eclipse IDE，并考虑以下步骤，使用Spring Web框架开发基于动态表单的Web应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在com.tutorialspoint包下创建Java类UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

UserController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping">
      <property name = "caseSensitive" value = "true" />
   </bean>
   <bean class = "com.tutorialspoint.UserController">
      <property name = "methodNameResolver">
          <bean class = "org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">
            <property name = "mappings">
               <props>
                  <prop key = "/user/home.htm">home</prop>
                  <prop key = "/user/add.htm">add</prop>
                  <prop key = "/user/remove.htm">update</prop>
               </props>
            </property>
         </bean>
      </property>
   </bean>
</beans>

user.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

现在，启动您的Tomcat服务器，并确保您可以使用标准浏览器从webapps文件夹访问其他网页。现在，尝试URL − http://localhost:8080/TestWeb/user/add.htm ，如果Spring Web应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Parameter Method Name Resolver Example

以下示例展示了如何使用 Spring Web MVC 框架的 Parameter Method Name Resolver 使用多动作控制器。 MultiActionController 类有助于为单个控制器分别映射多个网址及其方法。

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

<bean class = "com.tutorialspoint.UserController">
   <property name = "methodNameResolver">
      <bean class = "org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
         <property name = "paramName" value = "action"/>
      </bean>
   </property>
</bean>

例如，使用以上配置，如果请求 URI −

/user/ .htm?action=home is requested, DispatcherServlet will forward the request to the UserController *home() 方法。
/user/ .htm?action=add is requested, DispatcherServlet will forward the request to the UserController *add() 方法。
/user/ .htm?action=remove is requested, DispatcherServlet will forward the request to the UserController *remove() 方法。

首先，我们准备一个可用的 Eclipse IDE，然后遵循以下步骤使用 Spring Web 框架开发基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

UserController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }

   public ModelAndView add(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Add");
      return model;
   }

   public ModelAndView remove(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Remove");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping">
      <property name = "caseSensitive" value = "true" />
   </bean>
   <bean class = "com.tutorialspoint.UserController">
      <property name = "methodNameResolver">
         <bean class = "org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
            <property name = "paramName" value = "action"/>
         </bean>
      </property>
   </bean>
</beans>

user.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

现在，启动 Tomcat 服务器，并确保可以使用标准浏览器访问 webapps 文件夹中的其他网页。现在尝试一个网址 http://localhost:8080/TestWeb/user/test.htm?action=home ，如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Parameterizable View Controller Example

以下示例展示了如何使用Spring Web MVC框架的Multi Action Controller的参数化视图控制器方法。参数化视图允许使用请求映射网页。

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }
}

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
   <property name="mappings">
      <value>
         index.htm=userController
      </value>
   </property>
</bean>
<bean id="userController" class="org.springframework.web.servlet.mvc.ParameterizableViewController">
   <property name="viewName" value="user"/>
</bean>

例如，使用以上配置，如果URI。

请求/index.htm，DispatcherServlet将转发请求到控制器 UserController (设置viewName为user.jsp)。

首先，让我们建立一个可用的 Eclipse IDE，并遵循以下步骤，使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 UserController。
3	在 jsp 子文件夹下创建视图文件 user.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

UserController.java

package com.tutorialspoint;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

public class UserController extends MultiActionController{

   public ModelAndView home(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      ModelAndView model = new ModelAndView("user");
      model.addObject("message", "Home");
      return model;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/"/>
      <property name = "suffix" value = ".jsp"/>
   </bean>

   <bean class = "org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
      <property name = "mappings">
         <value>
            index.htm = userController
         </value>
      </property>
   </bean>
   <bean id = "userController" class = "org.springframework.web.servlet.mvc.ParameterizableViewController">
      <property name = "viewName" value="user"/>
   </bean>
</beans>

user.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>Hello World</h2>
   </body>
</html>

现在，启动您的 Tomcat 服务器，并确保您可以使用标准浏览器从 Webapps 文件夹中访问其他网页。现在，尝试一个 URL – http://localhost:8080/TestWeb/index.htm ，如果 Spring Web 应用程序一切正常，您将看到以下屏幕。

Spring MVC - Internal Resource View Resolver Example

InternalResourceViewResolver 用于将提供的 URI 解析到实际 URI。以下示例展示如何使用 Spring Web MVC Framework 使用 InternalResourceViewResolver。InternalResourceViewResolver 允许将网页与请求进行映射。

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }
}

<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name = "prefix" value = "/WEB-INF/jsp/"/>
   <property name = "suffix" value = ".jsp"/>
</bean>

例如，使用以上配置，如果 URI

/hello被请求，DispatcherServlet将会把请求转发给前缀+视图名称+后缀= /WEB-INF/jsp/hello.jsp。

首先，我们得准备一个Eclipse IDE并按照以下步骤，使用Spring Web框架开发一个基于动态表单的Web应用程序。

Step	Description
1	创建一个名为TestWeb的项目，使用包com.tutorialspoint，如Spring MVC - Hello World示例章节中所解释。
2	在com.tutorialspoint包下创建一个Java类HelloController。
3	在jsp子文件夹下创建一个视图文件hello.jsp。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }

}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

现在，启动你的Tomcat服务器，并保证你可以使用标准浏览器从webapps文件夹访问其他网页。尝试访问网址： http://localhost:8080/TestWeb/hello ，如果Spring Web应用程序一切正常，我们将会看到以下屏幕。

Spring MVC - Xml View Resolver Example

XmlViewResolver 用于使用在 xml 文件中定义的视图 bean 解析视图名称。以下示例演示了如何使用 Spring Web MVC 框架使用 XmlViewResolver。

TestWeb-servlet.xml

<bean class = "org.springframework.web.servlet.view.XmlViewResolver">
   <property name = "location">
      <value>/WEB-INF/views.xml</value>
   </property>
</bean>

views.xml

<bean id = "hello"
   class = "org.springframework.web.servlet.view.JstlView">
   <property name = "url" value = "/WEB-INF/jsp/hello.jsp" />
</bean>

例如，使用以上配置，如果请求 URI −

/hello，DispatcherServlet 会将请求转发到 view.xml 中 bean hello 定义的 hello.jsp。

首先，让我们准备好一个运行的 Eclipse IDE，然后按以下步骤使用 Spring Web Framework 开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建一个 Java 类 HelloController。
3	在 jsp 子文件夹下创建视图文件 hello.jsp。
4	下载 JSTL 库 jstl.jar 。将它放入 CLASSPATH 中。
5	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }

}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.XmlViewResolver">
      <property name = "location">
         <value>/WEB-INF/views.xml</value>
      </property>
   </bean>
</beans>

views.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean id = "hello"
      class = "org.springframework.web.servlet.view.JstlView">
      <property name = "url" value = "/WEB-INF/jsp/hello.jsp" />
   </bean>
</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

现在，启动 Tomcat 服务器并确保你可以使用标准浏览器访问 webapps 文件夹中的其他网页。尝试访问 URL − http://localhost:8080/HelloWeb/hello ，如果 Spring Web 应用程序一切正常，我们将看到以下界面。

Spring MVC - Resource Bundle View Resolver Example

ResourceBundleViewResolver 用于使用属性文件中定义的视图 bean 来解析视图名称。以下示例显示了如何使用 Spring Web MVC 框架的 ResourceBundleViewResolver。

TestWeb-servlet.xml

<bean class = "org.springframework.web.servlet.view.ResourceBundleViewResolver">
   <property name = "basename" value = "views" />
</bean>

这里， basename 指的是资源包的名称，它携带视图。资源包的默认名称是 views.properties ，可以使用 basename 属性覆盖它。

views.properties

hello.(class) = org.springframework.web.servlet.view.JstlView
hello.url = /WEB-INF/jsp/hello.jsp

例如，使用以上配置，如果请求 URI −

请求/hello 时，DispatcherServlet 会将请求转发到 views.properties 中由 bean hello 定义的 hello.jsp。
这里，“hello”是要匹配的视图名称。而 class 指的是视图类型，URL 是视图的位置。

首先，让我们建立一个可用的 Eclipse IDE，并考虑以下步骤，使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建一个 Java 类 HelloController。
3	在 jsp 子文件夹下创建视图文件 hello.jsp。
4	在 src 文件夹下创建属性文件 views.properties。
5	下载 JSTL 库 jstl.jar 。将它放入 CLASSPATH 中。
6	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }

}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.ResourceBundleViewResolver">
      <property name = "basename" value = "views" />
   </bean>
</beans>

views.properties

hello.(class) = org.springframework.web.servlet.view.JstlView
hello.url = /WEB-INF/jsp/hello.jsp

hello.jsp

<%@ page contentType="text/html; charset=UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

创建源文件和配置文件后，导出您的应用程序。右键单击您的应用程序，使用 Export → WAR File 选项并保存 HelloWeb.war 文件到 Tomcat 的 webapps 文件夹中。

Spring MVC - Multiple Resolver Mapping Example

如果您想在 Spring MVC 应用程序中使用多个视图解析器，那么可以使用 order 属性设置优先级顺序。以下示例显示了如何在 Spring Web MVC 框架中使用 ResourceBundleViewResolver 和 InternalResourceViewResolver 。

TestWeb-servlet.xml

<bean class = "org.springframework.web.servlet.view.ResourceBundleViewResolver">
   <property name = "basename" value = "views" />
   <property name = "order" value = "0" />
</bean>
<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name = "prefix" value = "/WEB-INF/jsp/" />
   <property name = "suffix" value = ".jsp" />
   <property name = "order" value = "1" />
</bean>

这里，order 属性定义了视图解析器的排名。在此，0 是第一个解析器，1 是下一个解析器，依此类推。

views.properties

hello.(class) = org.springframework.web.servlet.view.JstlView
hello.url = /WEB-INF/jsp/hello.jsp

例如，使用以上配置，如果请求 URI −

请求/hello 时，DispatcherServlet 会将请求转发到 views.properties 中由 bean hello 定义的 hello.jsp。

首先，让我们准备好一个运行的 Eclipse IDE，然后考虑以下步骤使用 Spring Web Framework 开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建一个 Java 类 HelloController。
3	在 jsp 子文件夹下创建视图文件 hello.jsp。
4	在 SRC 文件夹下创建属性文件 views.properties。
5	下载 JSTL 库 jstl.jar 。将它放在 CLASSPATH 中。
6	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

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

@Controller
@RequestMapping("/hello")
public class HelloController{

   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");

      return "hello";
   }

}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

   <bean class = "org.springframework.web.servlet.view.ResourceBundleViewResolver">
      <property name = "basename" value = "views" />
      <property name = "order" value = "0" />
   </bean>
   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
      <property name = "order" value = "1" />
   </bean>
</beans>

views.properties

hello.(class) = org.springframework.web.servlet.view.JstlView
hello.url = /WEB-INF/jsp/hello.jsp

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

在您创建了源文件和配置文件以后，导出您的应用程序。右键单击您的应用程序，使用 Export → WAR File 选项，并保存在Tomcat的webapps文件夹中。

现在，启动 Tomcat 服务器，并确保您可以使用标准浏览器从 Webapps 文件夹访问其他网页。尝试访问 URL - http://localhost:8080/HelloWeb/hello ，如果 Spring Web 应用程序一切正常，我们将看到以下屏幕。

Spring MVC - Hibernate Validator Example

以下示例演示了如何在表单中使用 Spring Web MVC 框架进行错误处理和验证。首先，让我们建立一个可用的 Eclipse IDE，并遵循以下步骤，使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	在 com.tutorialspoint 包中创建一个名称为 TestWeb 的项目，如 Spring MVC - Hello World 章节中所述。
2	在com.tutorialspoint包中创建Java类Student、StudentController和StudentValidator。
3	在 jsp 子文件夹下创建视图文件 addStudent.jsp 和 result.jsp。
4	下载 Hibernate Validator 库 Hibernate Validator 。解压 hibernate-validator-5.3.4.Final.jar，并导出下载的 ZIP 文件的 required 文件夹中所述的必需依赖项。将它们放入您的 CLASSPATH 中。
5	在SRC文件夹里创建一个属性文件messages.properties。
6	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

Student.java

package com.tutorialspoint;

import org.hibernate.validator.constraints.NotEmpty;
import org.hibernate.validator.constraints.Range;

public class Student {

   @Range(min = 1, max = 150)
   private Integer age;
   @NotEmpty
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }

   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

StudentController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class StudentController {

   @RequestMapping(value = "/addStudent", method = RequestMethod.GET)
   public ModelAndView student() {
      return new ModelAndView("addStudent", "command", new Student());
   }

   @ModelAttribute("student")
   public Student createStudentModel() {
      return new Student();
   }

   @RequestMapping(value = "/addStudent", method = RequestMethod.POST)
   public String addStudent(@ModelAttribute("student") @Validated Student student,
      BindingResult bindingResult, Model model) {
      if (bindingResult.hasErrors()) {
         return "addStudent";
      }
      model.addAttribute("name", student.getName());
      model.addAttribute("age", student.getAge());
      model.addAttribute("id", student.getId());

      return "result";
   }
}

messages.properties

NotEmpty.student.name = Name is required!
Range.student.age = Age value must be between 1 and 150!

在这里，密钥是 <Annotation>.<object-name>.<attribute>。值要显示的消息。

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />
   <mvc:annotation-driven />
   <bean class = "org.springframework.context.support.ResourceBundleMessageSource"
      id = "messageSource">
      <property name = "basename" value = "messages" />
   </bean>
   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>
</beans>

在这里，对于第一个服务方法 student() ，我们在 ModelAndView 对象中传递了一个空的 Studentobject> ，并命名为“command”，因为 spring 框架期望在 JSP 文件中使用 <form:form> 标记时，有一个名为“command”的对象。所以，当调用 student() 方法时，它返回 addStudent.jsp 视图。

addStudent.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <style>
      .error {
         color: #ff0000;
      }

      .errorblock {
         color: #000;
         background-color: #ffEEEE;
         border: 3px solid #ff0000;
         padding: 8px;
         margin: 16px;
      }
   </style>
   <body>

      <h2>Student Information</h2>
      <form:form method = "POST" action = "/TestWeb/addStudent" commandName = "student">
      <form:errors path = "*" cssClass = "errorblock" element = "div" />
         <table>
            <tr>
               <td><form:label path = "name">Name</form:label></td>
               <td><form:input path = "name" /></td>
               <td><form:errors path = "name" cssClass = "error" /></td>
            </tr>
            <tr>
               <td><form:label path = "age">Age</form:label></td>
               <td><form:input path = "age" /></td>
               <td><form:errors path = "age" cssClass = "error" /></td>
            </tr>
            <tr>
               <td><form:label path = "id">id</form:label></td>
               <td><form:input path = "id" /></td>
               </tr>
            <tr>
               <td colspan = "2">
               <input type = "submit" value = "Submit"/>
               </td>
            </tr>
         </table>
      </form:form>
   </body>
</html>

在这里，我们使用了 path="*" 的 <form:errors /> 标记来呈现错误消息。例如 -

<form:errors path = "*" cssClass = "errorblock" element = "div" />

它将针对所有输入验证呈现错误消息。我们使用了 path = “name” 的 <form:errors /> 标记来呈现 name 字段的错误消息。

例如 -

<form:errors path = "name" cssClass = "error" />
<form:errors path = "age" cssClass = "error" />

它将针对 name 和 age 字段验证呈现错误消息。

result.jsp

<%@taglib uri = "http://www.springframework.org/tags/form" prefix = "form"%>
<html>
   <head>
      <title>Spring MVC Form Handling</title>
   </head>
   <body>

      <h2>Submitted Student Information</h2>
      <table>
         <tr>
            <td>Name</td>
            <td>${name}</td>
         </tr>
         <tr>
            <td>Age</td>
            <td>${age}</td>
         </tr>
         <tr>
            <td>ID</td>
            <td>${id}</td>
         </tr>
      </table>
   </body>
</html>

现在，启动 Tomcat 服务器，确保可以使用标准浏览器访问 webapps 文件夹中的其他网页。尝试一个 URL - http://localhost:8080/TestWeb/addStudent ，如果你输入无效值，我们将看到以下屏幕。

Spring MVC - Generate RSS Feed Example

以下示例展示了如何使用 Spring Web MVC 框架生成 RSS 订阅源。首先，我们准备一个可用的 Eclipse IDE，然后考虑以下步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	在包 com.tutorialspoint 下创建一个名称为 TestWeb 的项目，正如 Spring MVC - Hello World 章节中所解释的。
2	在 com.tutorialspoint 包下创建 Java 类 RSSMessage、RSSFeedViewer 和 RSSController。
3	从同一个Maven仓库页面下载Rome类库 Rome 及其依赖项rome-utils、jdom和slf4j。将它们添加到你的CLASSPATH中。
4	在SRC文件夹里创建一个属性文件messages.properties。
5	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

RSSMessage.java

package com.tutorialspoint;

import java.util.Date;

public class RSSMessage {
   String title;
   String url;
   String summary;
   Date createdDate;
   public String getTitle() {
      return title;
   }
   public void setTitle(String title) {
      this.title = title;
   }
   public String getUrl() {
      return url;
   }
   public void setUrl(String url) {
      this.url = url;
   }
   public String getSummary() {
      return summary;
   }
   public void setSummary(String summary) {
      this.summary = summary;
   }
   public Date getCreatedDate() {
      return createdDate;
   }
   public void setCreatedDate(Date createdDate) {
      this.createdDate = createdDate;
   }
}

RSSFeedViewer.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.view.feed.AbstractRssFeedView;

import com.rometools.rome.feed.rss.Channel;
import com.rometools.rome.feed.rss.Content;
import com.rometools.rome.feed.rss.Item;

public class RSSFeedViewer extends AbstractRssFeedView {

   @Override
   protected void buildFeedMetadata(Map<String, Object> model, Channel feed,
      HttpServletRequest request) {

      feed.setTitle("TutorialsPoint Dot Com");
      feed.setDescription("Java Tutorials and Examples");
      feed.setLink("http://www.tutorialspoint.com");

      super.buildFeedMetadata(model, feed, request);
   }

   @Override
   protected List<Item> buildFeedItems(Map<String, Object> model,
      HttpServletRequest request, HttpServletResponse response) throws Exception {

      List<RSSMessage> listContent = (List<RSSMessage>) model.get("feedContent");
      List<Item> items = new ArrayList<Item>(listContent.size());

      for(RSSMessage tempContent : listContent ){

         Item item = new Item();

         Content content = new Content();
         content.setValue(tempContent.getSummary());
         item.setContent(content);

         item.setTitle(tempContent.getTitle());
         item.setLink(tempContent.getUrl());
         item.setPubDate(tempContent.getCreatedDate());

         items.add(item);
      }

      return items;
   }
}

RSSController.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class RSSController {
   @RequestMapping(value="/rssfeed", method = RequestMethod.GET)
   public ModelAndView getFeedInRss() {

      List<RSSMessage> items = new ArrayList<RSSMessage>();

      RSSMessage content  = new RSSMessage();
      content.setTitle("Spring Tutorial");
      content.setUrl("http://www.tutorialspoint/spring");
      content.setSummary("Spring tutorial summary...");
      content.setCreatedDate(new Date());
      items.add(content);

      RSSMessage content2  = new RSSMessage();
      content2.setTitle("Spring MVC");
      content2.setUrl("http://www.tutorialspoint/springmvc");
      content2.setSummary("Spring MVC tutorial summary...");
      content2.setCreatedDate(new Date());
      items.add(content2);

      ModelAndView mav = new ModelAndView();
      mav.setViewName("rssViewer");
      mav.addObject("feedContent", items);

      return mav;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.BeanNameViewResolver" />

   <bean id = "rssViewer" class = "com.tutorialspoint.RSSFeedViewer" />
</beans>

在这里，我们已经创建了一个RSS提要POJO RSSMessage和一个RSS消息查看器，它扩展了 AbstractRssFeedView 并重写了它的方法。在RSSController中，我们生成了一个RSS提要样本。

现在，启动你的Tomcat服务器并确认你能使用一个标准浏览器从webapps文件夹访问其他网页。试试网址− http://localhost:8080/TestWeb/rssfeed 我们会看到以下这个屏幕。

Spring MVC - Generate XML Example

以下示例展示如何使用 Spring Web MVC 框架生成 XML。首先，让我们有一个正在运行的 Eclipse IDE，并坚持以下步骤以使用 Spring Web 框架开发一个可动态创建表单的 Web 应用程序。

Step

Description

如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。

在 com.tutorialspointpackage 下创建 Java 类 User 和 UserController。

最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "user")
public class User {
   private String name;
   private int id;
   public String getName() {
      return name;
   }
   @XmlElement
   public void setName(String name) {
      this.name = name;
   }
   public int getId() {
      return id;
   }
   @XmlElement
   public void setId(int id) {
      this.id = id;
   }
}

UserController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {

   @RequestMapping(value="{name}", method = RequestMethod.GET)
   public @ResponseBody User getUser(@PathVariable String name) {

      User user = new User();

      user.setName(name);
      user.setId(1);
      return user;
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
   <context:component-scan base-package = "com.tutorialspoint" />
   <mvc:annotation-driven />
</beans>

在这里，我们创建了一个 XML 映射的 POJO User，并在 UserController 中，我们返回了 User。Spring 会根据 RequestMapping 自动处理 XML 转换。

创建源文件和配置文件后，导出应用程序。右键单击应用程序，使用 Export → WAR File 选项，将你的 TestWeb.war 文件保存到 Tomcat 的 webapps 文件夹中。

现在，启动 Tomcat 服务器，确保可以使用标准浏览器访问 webapps 文件夹中的其他网页。尝试一个 URL - http://localhost:8080/TestWeb/mahesh ，我们将看到以下屏幕。

Spring MVC - Generate JSON Example

以下示例展示如何使用 Spring Web MVC 框架生成 JSON。首先，让我们有一个正在运行的 Eclipse IDE，并考虑以下步骤以使用 Spring Web 框架开发一个可动态创建表单的 Web 应用程序 -

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint package 下创建 Java 类 User 和 UserController。
3	从 Maven 存储库页面下载 Jackson 库 Jackson Core, Jackson Databind and Jackson Annotations 。将它们放入 CLASSPATH 中。
4	最后一步是创建所有源文件和配置文件的内容，然后按如下所述导出应用程序。

User.java

package com.tutorialspoint;

public class User {
   private String name;
   private int id;
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
}

UserController.java

package com.tutorialspoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {

   @RequestMapping(value="{name}", method = RequestMethod.GET)
   public @ResponseBody User getUser(@PathVariable String name) {

      User user = new User();

      user.setName(name);
      user.setId(1);
      return user;
   }
}

TestWeb-servlet.xml

<beans xmlns = http://www.springframework.org/schema/beans"
   xmlns:context = http://www.springframework.org/schema/context"
   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mvc = http://www.springframework.org/schema/mvc"
   xsi:schemaLocation =
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
   <context:component-scan base-package = com.tutorialspoint" />
   <mvc:annotation-driven />
</beans>

在这里，我们创建了一个简单的 POJO User，并且在 UserController 中，我们返回了 User。Spring 会根据 RequestMapping 和类路径中存在的 Jackson jar 自动处理 JSON 转换。

Spring MVC - Generate Excel Example

以下示例展示如何使用 Spring Web MVC 框架生成 Excel。首先，让我们有一个正在运行的 Eclipse IDE，并坚持以下步骤以使用 Spring Web 框架开发一个可动态创建表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint package 下创建 Java 类 UserExcelView 和 ExcelController。
3	从 Maven 存储库页面下载 Apache POI 库 Apache POI 。将它放入 CLASSPATH 中。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

ExcelController.java

package com.tutorialspoint;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class ExcelController extends AbstractController {

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      //user data
      Map<String,String> userData = new HashMap<String,String>();
      userData.put("1", "Mahesh");
      userData.put("2", "Suresh");
      userData.put("3", "Ramesh");
      userData.put("4", "Naresh");
      return new ModelAndView("UserSummary","userData",userData);
   }
}

UserExcelView.java

package com.tutorialspoint;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.web.servlet.view.document.AbstractExcelView;

public class UserExcelView extends AbstractExcelView {

   @Override
   protected void buildExcelDocument(Map<String, Object> model,
      HSSFWorkbook workbook, HttpServletRequest request, HttpServletResponse response)
      throws Exception {
      Map<String,String> userData = (Map<String,String>) model.get("userData");
      //create a wordsheet
      HSSFSheet sheet = workbook.createSheet("User Report");

      HSSFRow header = sheet.createRow(0);
      header.createCell(0).setCellValue("Roll No");
      header.createCell(1).setCellValue("Name");

      int rowNum = 1;
      for (Map.Entry<String, String> entry : userData.entrySet()) {
         //create the row data
         HSSFRow row = sheet.createRow(rowNum++);
         row.createCell(0).setCellValue(entry.getKey());
         row.createCell(1).setCellValue(entry.getValue());
      }
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping" />

   <bean class = "com.tutorialspoint.ExcelController" />

   <bean class = "org.springframework.web.servlet.view.XmlViewResolver">
      <property name = "location">
         <value>/WEB-INF/views.xml</value>
      </property>
   </bean>
</beans>

views.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean id = "UserSummary" class = "com.tutorialspoint.UserExcelView"></bean>
</beans>

我们在此处创建了一个 ExcelController 和一个 ExcelView。Apache POI 库用于处理 Microsoft Office 文件格式，它会将数据转换为一个 excel 文档。

现在，启动 Tomcat 服务器并确保你能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试 http://localhost:8080/TestWeb/excel URL，我们将看到下面的屏幕。

Spring MVC - Generate PDF Example

下面示例展示了如何使用 Spring Web MVC 框架生成一个 PDF。我们首先要在适当的位置获取一个 Eclipse IDE，然后按照下面的步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	如 Spring MVC 的 Hello World 章节中所述，在 com.tutorialspoint 包下创建一个以 TestWeb 命名的项目。
2	在 com.tutorialspoint 包下创建 Java 类 UserPDFView 和 PDFController。
3	从 maven 仓库页面下载 iText 库 iText 。将其放入你的 CLASSPATH。
4	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

PDFController.java

package com.tutorialspoint;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class PDFController extends AbstractController {

   @Override
   protected ModelAndView handleRequestInternal(HttpServletRequest request,
      HttpServletResponse response) throws Exception {
      //user data
      Map<String,String> userData = new HashMap<String,String>();
      userData.put("1", "Mahesh");
      userData.put("2", "Suresh");
      userData.put("3", "Ramesh");
      userData.put("4", "Naresh");
      return new ModelAndView("UserSummary","userData",userData);
   }
}

UserExcelView.java

package com.tutorialspoint;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.view.document.AbstractPdfView;

import com.lowagie.text.Document;
import com.lowagie.text.Table;
import com.lowagie.text.pdf.PdfWriter;

public class UserPDFView extends AbstractPdfView {

   protected void buildPdfDocument(Map<String, Object> model, Document document,
      PdfWriter pdfWriter, HttpServletRequest request, HttpServletResponse response)
      throws Exception {
      Map<String,String> userData = (Map<String,String>) model.get("userData");

      Table table = new Table(2);
      table.addCell("Roll No");
      table.addCell("Name");

      for (Map.Entry<String, String> entry : userData.entrySet()) {
         table.addCell(entry.getKey());
         table.addCell(entry.getValue());
      }
      document.add(table);
   }
}

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
   <bean class = "org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping" />

   <bean class = "com.tutorialspoint.PDFController" />

   <bean class = "org.springframework.web.servlet.view.XmlViewResolver">
      <property name = "location">
         <value>/WEB-INF/views.xml</value>
      </property>
   </bean>
</beans>

views.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <bean id = "UserSummary" class = "com.tutorialspoint.UserPDFView"></bean>
</beans>

我们在此处创建了一个 PDFController 和 UserPDFView。iText 库用于处理 PDF 文件格式，它会将数据转换为一个 PDF 文档。

现在，启动 Tomcat 服务器并确保你能够使用标准浏览器从 webapps 文件夹访问其他网页。我们还可以尝试 http://localhost:8080/TestWeb/pdf URL，如果一切顺利，我们将看到下面的屏幕。

Spring MVC - Integrate LOG4J Example

下面示例展示了如何使用 Spring Web MVC 框架集成 LOG4J。我们首先要在适当的位置获取一个 Eclipse IDE，然后按照下面的步骤使用 Spring Web 框架开发一个基于动态表单的 Web 应用程序。

Step	Description
1	在包 com.tutorialspoint 下创建一个名称为 TestWeb 的项目，正如 Spring MVC - Hello World 章节中所解释的。
2	在 com.tutorialspoint 包下创建一个 Java 类 HelloController。
3	从 maven 仓库页面下载 log4j 库 LOG4J 。将其放入你的 CLASSPATH。
4	在 SRC 文件夹下创建一个 log4j.properties。
5	最后一步是创建源文件和配置文件的内容，然后按如下所述导出应用程序。

HelloController.java

package com.tutorialspoint;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.ui.ModelMap;

@Controller
@RequestMapping("/hello")
public class HelloController{
   private static final Logger LOGGER = Logger.getLogger(HelloController.class);
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      LOGGER.info("printHello started.");

      //logs debug message
      if(LOGGER.isDebugEnabled()){
         LOGGER.debug("Inside:  printHello");
      }
      //logs exception
      LOGGER.error("Logging a sample exception", new Exception("Testing"));

      model.addAttribute("message", "Hello Spring MVC Framework!");
      LOGGER.info("printHello ended.");
      return "hello";
   }
}

log4j.properties

# Root logger option
log4j.rootLogger = DEBUG, stdout, file

# Redirect log messages to console
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Redirect log messages to a log file
log4j.appender.file = org.apache.log4j.RollingFileAppender
#outputs to Tomcat home
log4j.appender.file.File = ${catalina.home}/logs/myapp.log
log4j.appender.file.MaxFileSize = 5MB
log4j.appender.file.MaxBackupIndex = 10
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

TestWeb-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:mvc = "http://www.springframework.org/schema/mvc"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/mvc
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>
</beans>

hello.jsp

<%@ page contentType = "text/html; charset = UTF-8" %>
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h2>${message}</h2>
   </body>
</html>

我们在此处将 LOG4J 配置为在 Tomcat 控制台和 &t; tomcat 主页 → 日志中 myapp.log 文件中记录详细信息。

现在，启动 Tomcat 服务器并确保你能够使用标准浏览器从 webapps 文件夹访问其他网页。尝试 http://localhost:8080/TestWeb/hello URL，我们将看到 Tomcat 日志上的以下屏幕。