Spring MVC 快速指南

---

---

Spring - MVC 框架概述

Spring Web MVC 框架提供了一種模型-檢視-控制器架構和現成的元件，可用於開發靈活且鬆散耦合的 Web 應用程式。MVC 模式導致應用程式的不同方面（輸入邏輯、業務邏輯和 UI 邏輯）分離，同時在這些元素之間提供鬆散耦合。

• 模型 (Model) 封裝應用程式資料，通常由POJO組成。

• 檢視 (View) 負責呈現模型資料，通常生成客戶端瀏覽器可以解釋的HTML輸出。

• 控制器 (Controller) 負責處理使用者請求和構建合適的模型，並將其傳遞給檢視進行呈現。

DispatcherServlet

Spring Web 模型-檢視-控制器 (MVC) 框架圍繞一個 DispatcherServlet 設計，它處理所有 HTTP 請求和響應。下圖顯示了 Spring Web MVC DispatcherServlet 的請求處理工作流程。

以下是針對傳入 DispatcherServlet 的 HTTP 請求的事件序列：

• 接收 HTTP 請求後，DispatcherServlet 會查詢HandlerMapping以呼叫相應的控制器。

• 控制器接收請求並根據使用的GET或POST方法呼叫相應的服務方法。服務方法將根據定義的業務邏輯設定模型資料，並將檢視名稱返回給 DispatcherServlet。

• DispatcherServlet 將藉助ViewResolver選擇請求的定義檢視。

• 一旦確定檢視，DispatcherServlet 將模型資料傳遞給檢視，最終在瀏覽器上呈現。

所有上述元件，即 HandlerMapping、Controller 和 ViewResolver 都是WebApplicationContext的一部分，它是普通ApplicationContext的擴充套件，具有 Web 應用程式所需的一些額外功能。

所需配置

我們需要使用web.xml檔案中的 URL 對映來對映您希望 DispatcherServlet 處理的請求。以下是一個示例，顯示了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目錄中。在初始化HelloWeb DispatcherServlet 時，框架將嘗試從應用程式的 WebContent/WEB-INF 目錄中名為[servlet-name]-servlet.xml的檔案載入應用程式上下文。在本例中，我們的檔案將是HelloWeb-servlet.xml。

接下來，<servlet-mapping>標記指示哪些 URL 將由哪個 DispatcherServlet 處理。在這裡，所有以 .jsp 結尾的 HTTP 請求都將由HelloWeb DispatcherServlet 處理。

如果您不想使用預設檔名[servlet-name]-servlet.xml和預設位置 WebContent/WEB-INF，您可以透過在您的 web.xml 檔案中新增 servlet 監聽器ContextLoaderListener來自定義此檔名和位置，如下所示：

<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的檢視實現。

現在讓我們瞭解如何建立實際的元件，即控制器、模型和檢視。

定義控制器

DispatcherServlet 將請求委託給控制器以執行特定於它的功能。@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”的模型。

• 定義的服務方法可以返回一個字串，其中包含要用於呈現模型的檢視的名稱。此示例返回“hello”作為邏輯檢視名稱。

建立 JSP 檢視

Spring MVC 支援許多針對不同表示技術的檢視型別。這些包括 - JSP、HTML、PDF、Excel 工作表、XML、Velocity 模板、XSLT、JSON、Atom 和 RSS Feed、JasperReports 等。但是，最常見的是使用 JSTL 編寫的 JSP 模板。因此，讓我們在 /WEB-INF/hello/hello.jsp 中編寫一個簡單的 hello 檢視：

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

這裡${message}是我們在控制器中設定的屬性。您可以有多個屬性顯示在檢視中。

Spring MVC - 環境搭建

本章將指導您如何準備開發環境以開始使用 Spring 框架。它還將教您如何在設定 Spring 框架之前在您的機器上設定 JDK、Maven 和 Eclipse：

設定 Java 開發工具包 (JDK)

您可以從 Oracle 的 Java 網站下載最新版本的 SDK：Java SE 下載。您將在下載的檔案中找到安裝 JDK 的說明，請按照給定的說明安裝和配置設定。最後設定 PATH 和 JAVA_HOME 環境變數以引用包含 java 和 javac 的目錄，通常分別為 java_install_dir/bin 和 java_install_dir。

如果您正在執行 Windows 並已將 JDK 安裝在 C:\jdk-11.0.11 中，則必須將以下行新增到 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

或者，如果您使用整合開發環境 (IDE)，如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio，則必須編譯並執行一個簡單的程式以確認 IDE 知道您安裝 Java 的位置。否則，您必須按照 IDE 文件中給出的說明進行正確的設定。

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

成功啟動後，如果一切正常，則應顯示以下結果：

安裝 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 變數，否則執行應用程式時會遇到問題。

設定 Spring 框架庫

如果一切正常，我們可以繼續設定 Spring 框架。以下是下載並在機器上安裝框架的步驟。

• 選擇您是想在 Windows 上安裝 Spring 還是在 UNIX 上安裝 Spring，然後繼續執行下一步，下載 Windows 的.zip 檔案和 Unix 的.tar.gz 檔案。（原文.tz應為.tar.gz）

• 從 https://repo.spring.io/release/org/springframework/spring下載最新版本的 Spring 框架二進位制檔案。

• 我們在 Windows 機器上下載了spring-5.3.14-dist.zip，解壓縮下載的檔案後，會在 E:\spring 目錄下生成如下所示的目錄結構。

您將在E:\spring\libs目錄中找到所有 Spring 庫。確保正確設定此目錄的 CLASSPATH 變數；否則，執行應用程式時會遇到問題。如果使用 Eclipse，則無需設定 CLASSPATH，因為所有設定都將透過 Eclipse 完成。

完成最後一步後，您就可以繼續學習您的第一個 Spring 示例了，您將在下一章中看到。

Spring MVC - Hello World 示例

以下示例演示瞭如何使用 Spring MVC 框架編寫簡單的基於 Web 的Hello World應用程式。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發動態 Web 應用程式。

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

建立原始碼和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR 檔案選項，並將您的HelloWeb.war檔案儲存到 Tomcat 的webapps資料夾中。

現在啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。現在，嘗試訪問 URL − https://:8080/HelloWeb/hello。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

您應該注意，在給定的 URL 中，HelloWeb是應用程式名稱，hello 是虛擬子資料夾，我們在控制器中使用 @RequestMapping("/hello") 提到了它。您可以使用直接根目錄對映您的 URL，使用@RequestMapping("/")，在這種情況下，您可以使用簡短的 URLhttps://:8080/HelloWeb/訪問同一頁面，但建議在不同的資料夾下具有不同的功能。

Spring MVC - 表單處理示例

以下示例演示瞭如何使用 Spring MVC 框架編寫簡單的基於 Web 的Hello World應用程式。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發動態 Web 應用程式。

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 檢視。

第二個服務方法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>

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 資料夾中的其他網頁。現在，嘗試使用 URL – https://:8080/SpringWeb/student，如果 Spring Web 應用程式一切正常，您應該看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，您應該看到以下螢幕。

Spring MVC - 頁面重定向示例

以下示例演示瞭如何編寫一個簡單的基於 Web 的應用程式，該應用程式使用重定向將 HTTP 請求傳輸到另一個頁面。首先，讓我們準備好一個可用的 Eclipse IDE，並考慮以下步驟來使用 Spring Web 框架開發基於動態表單的 Web 應用程式：

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 –https://:8080/HelloWeb/index，如果 Spring Web 應用程式一切正常，您應該看到以下螢幕。

現在單擊“重定向頁面”按鈕提交表單並轉到最終重定向頁面。如果我們的 Spring Web 應用程式一切正常，我們應該看到以下螢幕：

Spring MVC - 靜態頁面示例

以下示例演示瞭如何使用 Spring MVC 框架編寫一個簡單的基於 Web 的應用程式，該應用程式可以在<mvc:resources>標記的幫助下訪問靜態頁面和動態頁面。

首先，讓我們準備好一個可用的 Eclipse IDE，並遵循以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 屬性必須是指定 HTTP 請求的 URL 模式的Ant 模式。location 屬性必須指定一個或多個包含靜態頁面的有效資源目錄位置，包括影像、樣式表、JavaScript 和其他靜態內容。可以使用逗號分隔的值列表指定多個資源位置。

以下是 Spring 檢視檔案WEB-INF/jsp/index.jsp的內容。這將是一個登入頁面；此頁面將傳送請求以訪問staticPage 服務方法，該方法將把此請求重定向到 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>

建立原始碼和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR 檔案選項，並將您的 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。現在嘗試訪問 URL – https://:8080/HelloWeb/index。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

單擊“獲取 HTML 頁面”按鈕以訪問 staticPage 服務方法中提到的靜態頁面。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 文字框示例

以下示例演示瞭如何在 Spring Web MVC 框架中使用表單中的文字框。首先，讓我們準備好一個可用的 Eclipse IDE，並堅持以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式：

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 檢視。

第二個服務方法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>

建立原始碼和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR 檔案選項，並將HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試使用 URL – https://:8080/HelloWeb/student，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，我們應該看到以下螢幕。

Spring MVC - 密碼示例

以下示例描述瞭如何在 Spring Web MVC 框架中使用表單中的密碼。首先，讓我們準備好一個可用的 Eclipse IDE，並遵循以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 物件中傳遞了一個空 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 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 –https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 文字區域示例

以下示例解釋瞭如何在使用 Spring Web MVC 框架的表單中使用文字區域。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 物件中以“command”為名稱傳遞了一個空的 User 物件，因為如果您在 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 文字區域框。例如：

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

建立原始碼和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR 檔案選項，並將您的 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動您的 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 複選框示例

以下示例描述瞭如何在使用 Spring Web MVC 框架的表單中使用單個複選框。首先，讓我們準備好一個可用的 Eclipse IDE，並考慮以下步驟來使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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()，我們在 ModelAndView 物件中以“command”為名稱傳遞了一個空的 User 物件，因為如果您在 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 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>

建立原始碼和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR 檔案選項，並將您的 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動您的 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 多選框示例

以下示例解釋瞭如何在使用 Spring Web MVC 框架的表單中使用多個複選框。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 物件中以“command”為名稱傳遞了一個空的User物件，因為如果您在 JSP 檔案中使用 <form:form> 標籤，Spring 框架期望一個名為“command”的物件。因此，當呼叫user()方法時，它返回user.jsp檢視。

第二個服務方法addUser()將針對HelloWeb/addUserURL上的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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將您的HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果您的 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 單選按鈕示例

以下示例顯示瞭如何在使用 Spring Web MVC 框架的表單中使用單選按鈕。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式：

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 物件中以“command”為名稱傳遞了一個空的User物件，因為如果您在 JSP 檔案中使用 <form:form> 標籤，Spring 框架期望一個名為“command”的物件。因此，當呼叫user()方法時，它返回user.jsp檢視。

第二個服務方法addUser()將針對HelloWeb/addUserURL上的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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動您的 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – https://:8080/HelloWeb/user，如果您的 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 多選按鈕示例

以下示例解釋瞭如何在使用 Spring Web MVC 框架的表單中使用多個單選按鈕。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 檢視。

第二個服務方法addUser()將針對HelloWeb/addUserURL上的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><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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問以下 URL – https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果您的 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 下拉列表示例

以下示例描述瞭如何在使用 Spring Web MVC 框架的表單中使用下拉列表。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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()，我們在 ModelAndView 物件中以“command”為名稱傳遞了一個空的User物件，因為如果您在 JSP 檔案中使用 <form:form> 標籤，Spring 框架期望一個名為“command”的物件。因此，當呼叫user()方法時，它返回user.jsp檢視。

第二個服務方法addUser()將針對HelloWeb/addUserURL上的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><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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將您的 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，您應該看到以下螢幕。

Spring MVC - 列表框示例

以下示例顯示瞭如何在使用 Spring Web MVC 框架的表單中使用列表框。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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()，我們在 ModelAndView 物件中以“command”為名稱傳遞了一個空的User物件，因為如果您在 JSP 檔案中使用 <form:form> 標籤，Spring 框架期望一個名為“command”的物件。因此，當呼叫user()方法時，它返回user.jsp檢視。

第二個服務方法addUser()將針對HelloWeb/addUserURL上的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><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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將 HelloWeb.war 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL − https://:8080/HelloWeb/user，如果 Spring Web 應用程式一切正常，我們將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果 Spring Web 應用程式一切正常，您應該看到以下螢幕。

Spring MVC - 隱藏欄位示例

以下示例描述瞭如何在使用 Spring Web MVC 框架的表單中使用隱藏欄位。首先，讓我們準備好一個可用的 Eclipse IDE，並考慮以下步驟來使用 Spring Web 框架開發基於動態表單的 Web 應用程式。

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 物件中以“command”為名稱傳遞了一個空的Studentobject物件，因為如果您在 JSP 檔案中使用 <form:form> 標籤，Spring 框架期望一個名為“command”的物件。因此，當呼叫student()方法時，它返回student.jsp檢視。

第二個服務方法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>< </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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將您的HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/HelloWeb/student，如果Spring Web應用程式一切正常，您將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果您的 Spring Web 應用程式一切正常，我們將看到以下螢幕。

Spring MVC - 錯誤處理示例

以下示例演示如何在使用Spring Web MVC框架的表單中使用錯誤處理和驗證器。首先，讓我們準備好一個可用的Eclipse IDE，並按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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物件中以“command”名稱傳遞了一個空的Student物件，因為如果您在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 />標籤，路徑為“*”，來呈現錯誤訊息。例如

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

它將呈現所有輸入驗證的錯誤訊息。

我們使用<form:errors />標籤，路徑為“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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/HelloWeb/addStudent，如果Spring Web應用程式一切正常，您將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果Spring Web應用程式一切正常，您將看到以下螢幕。

Spring MVC - 檔案上傳示例

以下示例演示如何在使用Spring Web MVC框架的表單中使用檔案上傳控制元件。首先，讓我們準備好一個可用的Eclipse IDE，並按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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物件中以“command”名稱傳遞了一個空的FileModel物件，因為如果您在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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將HelloWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/HelloWeb/fileUploadPage，如果Spring Web應用程式一切正常，您將看到以下螢幕。

提交所需資訊後，單擊提交按鈕提交表單。如果Spring Web應用程式一切正常，您將看到以下螢幕。

Spring MVC - Bean名稱URL處理器對映示例

以下示例演示如何使用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框架開發基於動態表單的Web應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/TestWeb/helloWorld.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL – https://:8080/TestWeb/hello.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/welcome.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/welcome1.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

Spring MVC - 控制器類名稱處理器對映示例

以下示例演示如何使用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應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/TestWeb/helloWorld.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/hello.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/welcome.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/Welcome.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

Spring MVC - 簡單URL處理器對映示例

以下示例演示如何使用Spring Web MVC框架使用簡單URL處理器對映。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框架開發基於動態表單的Web應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試使用URL – https://:8080/TestWeb/helloWorld.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試使用URL https://:8080/TestWeb/welcome.htm，如果您的Spring Web應用程式一切正常，您應該看到以下結果。

Spring MVC - 多動作控制器示例

以下示例演示如何使用Spring Web MVC框架使用多動作控制器。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應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。現在，嘗試使用URL – https://:8080/TestWeb/home.htm，如果Spring Web應用程式一切正常，您將看到以下螢幕。

嘗試訪問URL **https://:8080/TestWeb/user/add.htm**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 屬性方法名稱解析器示例

以下示例演示瞭如何使用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應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。現在，嘗試訪問URL – **https://:8080/TestWeb/user/add.htm**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 引數方法名稱解析器示例

以下示例演示瞭如何使用Spring Web MVC框架中多動作控制器的引數方法名稱解析器。**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.ParameterMethodNameResolver">
         <property name = "paramName" value = "action"/>
      </bean>
   </property>
</bean>

例如，使用上述配置，如果請求URI：

• 請求/user/*.htm?action=home時，DispatcherServlet將請求轉發到UserController的**home()**方法。

• 請求/user/*.htm?action=add時，DispatcherServlet將請求轉發到UserController的**add()**方法。

• 請求/user/*.htm?action=remove時，DispatcherServlet將請求轉發到UserController的**remove()**方法。

首先，讓我們準備好一個可用的Eclipse IDE，並按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。現在，嘗試訪問URL – **https://:8080/TestWeb/test.htm?action=home**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 可引數化檢視控制器示例

以下示例演示瞭如何使用Spring Web MVC框架中多動作控制器的可引數化檢視控制器方法。可引數化檢視允許將網頁與請求對映。

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應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。現在，嘗試訪問URL – **https://:8080/TestWeb/index.htm**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 內部資源檢視解析器示例

**InternalResourceViewResolver** 用於將提供的URI解析為實際URI。以下示例演示瞭如何使用Spring Web MVC框架中的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將請求轉發到prefix + viewname + suffix = /WEB-INF/jsp/hello.jsp。

首先，讓我們準備好一個可用的Eclipse IDE，然後按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/TestWeb/hello**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - Xml檢視解析器示例

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框架開發基於動態表單的Web應用程式。

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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/HelloWeb/hello**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 資源包檢視解析器示例

**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應用程式。

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>

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用**匯出→WAR檔案**選項，並將您的HelloWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/HelloWeb/hello**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - 多個解析器對映示例

如果您想在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框架開發基於動態表單的Web應用程式。

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>

完成原始碼和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將您的HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/HelloWeb/hello**，如果Spring Web應用程式一切正常，您將看到以下介面。

Spring MVC - Hibernate Validator示例

以下示例演示瞭如何在表單中使用Spring Web MVC框架進行錯誤處理和驗證。首先，讓我們準備好一個可用的Eclipse IDE，並按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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物件中以“command”名稱傳遞了一個空的**Studentobject>**，因為如果您在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 = "/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 />標籤來渲染名稱欄位的錯誤訊息。

例如：

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

它將渲染名稱和年齡欄位驗證的錯誤訊息。

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檔案選項，並將HelloWeb.war檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/TestWeb/addStudent**，如果您輸入了無效的值，您將看到以下介面。

Spring MVC - 生成RSS Feed示例

以下示例演示瞭如何使用Spring Web MVC框架生成RSS Feed。首先，讓我們準備好一個可用的Eclipse IDE，然後按照以下步驟使用Spring Web框架開發基於動態表單的Web應用程式。

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("https://tutorialspoint.tw");

      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 feed POJO RSSMessage和一個RSS訊息檢視器，它擴充套件了**AbstractRssFeedView**並覆蓋了它的方法。在RSSController中，我們生成了一個示例RSS Feed。

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動您的Tomcat伺服器，並確保您可以使用標準瀏覽器訪問webapps資料夾中的其他網頁。嘗試訪問URL – **https://:8080/TestWeb/rssfeed**，您將看到以下介面。

Spring MVC - 生成XML示例

以下示例演示如何使用 Spring Web MVC 框架生成 XML。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發一個基於動態表單的 Web 應用程式。

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 轉換。

完成原始檔和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用 **匯出 → WAR 檔案** 選項，並將您的 **TestWeb.war** 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – **https://:8080/TestWeb/mahesh**，我們將看到以下螢幕。

Spring MVC - 生成 JSON 示例

以下示例演示如何使用 Spring Web MVC 框架生成 JSON。首先，讓我們準備好一個可用的 Eclipse IDE，並考慮以下步驟來開發一個基於動態表單的 Web 應用程式，使用 Spring Web 框架 -

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 和 classpath 中存在的 Jackson jar 自動處理 JSON 轉換。

完成原始檔和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用 **匯出 → WAR 檔案** 選項，並將您的 **TestWeb.war** 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – **https://:8080/TestWeb/mahesh**，我們將看到以下螢幕。

Spring MVC - 生成 Excel 示例

以下示例演示如何使用 Spring Web MVC 框架生成 Excel。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發一個基於動態表單的 Web 應用程式。

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 文件。

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – **https://:8080/TestWeb/excel**，我們將看到以下螢幕。

Spring MVC - 生成 PDF 示例

以下示例演示如何使用 Spring Web MVC 框架生成 PDF。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發一個基於動態表單的 Web 應用程式。

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 文件。

建立原始檔和配置檔案後，匯出您的應用程式。右鍵單擊您的應用程式，使用匯出→WAR檔案選項，並將TestWeb.war檔案儲存到Tomcat的webapps資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。我們還可以嘗試以下 URL – **https://:8080/TestWeb/pdf**，如果一切順利，我們將看到以下螢幕。

Spring MVC - 整合 LOG4J 示例

以下示例演示如何使用 Spring Web MVC 框架整合 LOG4J。首先，讓我們準備好一個可用的 Eclipse IDE，並按照以下步驟使用 Spring Web 框架開發一個基於動態表單的 Web 應用程式。

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 控制檯和 Tomcat 主目錄 → logs 資料夾下的 myapp.log 檔案中。

完成原始檔和配置檔案的建立後，匯出您的應用程式。右鍵單擊您的應用程式，使用 **匯出 → WAR 檔案** 選項，並將您的 **TestWeb.war** 檔案儲存到 Tomcat 的 webapps 資料夾中。

現在，啟動 Tomcat 伺服器，並確保您可以使用標準瀏覽器訪問 webapps 資料夾中的其他網頁。嘗試訪問 URL – **https://:8080/TestWeb/hello**，我們將看到 Tomcat 日誌中的以下螢幕。