// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Spring Web MVC 简介
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Spring Web MVC 简介 - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Spring Web MVC 简介

本文档向您介绍如何使用 link:http://www.springframework.org/[+Spring Framework+] 构造简单的 Web link:http://www.oracle.com/technetwork/articles/javase/index-142890.html[+MVC+] 应用程序。该应用程序使用户能够在一个文本字段中输入他的姓名，单击 "OK"（确定）后，返回该姓名并且显示在具有欢迎问候的另一个页面上。

Spring Framework 是一种流行的开源应用程序框架，可简化 Java EE 开发。它包括一个容器、一个用于管理组件的框架和一组针对 Web 用户界面、事务和持久性的咬接（snap-in）服务。Spring Web MVC 是 Spring Framework 的一部分，它是用于创建 Web 应用程序的可扩展 MVC 框架。

IDE 提供了对 Spring Framework 4.x 和 3.x 的内置支持。框架库是与 IDE 一起打包的，当选择该框架时会自动添加到项目类路径。提供配置设置，如 Spring Web MVC `DispatcherServlet` 的命名和映射。也可以选择在项目创建时注册 JSTL 库。此外，还提供了对 Spring XML Bean 配置文件的支持，包括以下功能：

* *代码完成*。在 Spring XML 配置文件中调用，用于 Java 类和 bean 引用。
* *导航*。在 Spring bean 定义中提到的 Java 类和属性的超链接以及到其他 Spring bean 引用的超链接。
* *重构*。在 Spring XML 配置文件中重命名对 Java 类的引用。

有关 Spring Framework 的详细信息，请访问 link:http://www.springsource.org/[+http://www.springsource.org/+]。有关 Spring Framework 工件的工作原理以及如何与应用程序中其他对象交互的更详细信息，请参见正式的 link:http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/[+Spring Framework 参考文档+]或参阅 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/[+Spring Framework API 文档+]。


image::images/netbeans-stamp-80-74-73.png[title="此页上的内容适用于 NetBeans IDE 7.2、7.3、7.4 和 8.0"]


*要学完本教程，您需要具备以下软件和资源。*

|===
|软件或资源 |要求的版本 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |7.2、7.3、7.4、8.0、Java EE 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Java 开发工具包 (JDK)+] |版本 7 或 8 

|link:http://glassfish.dev.java.net/public/downloadsindex.html[+GlassFish Server+] |3.x、4.x 
|===

*注：*

* IDE 的 Java 安装允许您选择性地在 IDE 中安装和注册 GlassFish Server。
* 如果需要将项目与工作解决方案进行比较，可以link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%2520Web%252FHelloSpring69.zip[+下载样例应用程序+]。


[[setting]]
== 建立具有 Spring Web MVC 支持的新项目

* <<creating,创建 Spring Web MVC 框架项目>>
* <<running,运行框架项目>>


[[creating]]
=== 创建 Spring Web MVC 框架项目

首先，使用 Spring Framework 为 Web 应用程序创建一个新项目。

1. 从 IDE 的 "File"（文件）菜单中选择 "New Project"（新建项目）（Ctrl-Shift-N 组合键；在 Mac 上为 ⌘-Shift-N 组合键）。选择 "Java Web" 类别，然后在 "Projects"（项目）下选择 "Web Application"（Web 应用程序）。单击 "Next"（下一步）。
2. 在 "Project Name"（项目名称）中键入 *HelloSpring*。单击 "Next"（下一步）。
3. 在步骤 3 "Server and Settings"（服务器和设置）中，取消选择 "Enable Contexts and Dependency Injection"（启用上下文和依赖关系注入）选项，因为在本教程中将不使用 link:http://jcp.org/en/jsr/detail?id=299[+JSR-299+] 规范。
4. 确认在 "Server"（服务器）下拉列表中选定 "GlassFish Server"。单击 "Next"（下一步）。

Java EE 版本取决于所选服务器的版本。当所选服务器为 GlassFish Server 4.0 时，默认 Java EE 版本是 Java EE 7 Web。


[start=5]
. 在步骤 4 "Frameworks"（框架）面板中，选择 "Spring Web MVC"。

[start=6]
. 在 "Spring Library"（Spring 库）下拉列表中选择 *Spring Framework 3.x*。

image::images/frameworks-window.png[title=""Frameworks"（框架）面板中显示的 Spring Web MVC"]

请注意，尽管使用 IDE 可以将 Spring 4.x 库添加到项目中，但是对于本教程，将使用 Spring 4.x 中不支持的 SimpleFormController。另外，当选择 "Spring Web MVC" 时，注意到在项目创建期间默认将 JSTL (JavaServer Pages Standard Tag Library) 库添加到类路径中。取消选择此选项（如以上屏幕快照中所示），因为本教程中不需要 JSTL。


[start=7]
. 单击 "Configuration"（配置）标签，并请注意，您可以在向导中指定 Spring 分派程序 Servlet 的名称和映射。 

image::images/spring-configuration.png[title="在 "Configuration"（配置）标签下指定 Spring 分派程序 Servlet 的名称和映射"]

[start=8]
. 单击 "Finish"（完成）。IDE 将为整个应用程序创建一个项目，包括所有元数据以及可以从 "Files"（文件）窗口（Ctrl-2 组合键；在 Mac 上为 ⌘-2 组合键）中查看的项目的 Ant 构建脚本。可以从 "Projects"（项目）窗口（Ctrl-1 组合键；在 Mac 上为 ⌘-1 组合键）中查看模板结构。另请注意，默认情况下在 IDE 的编辑器中打开四个文件：`dispatcher-servlet.xml`、`applicationContext.xml`、`redirect.jsp` 和 `index.jsp`。

[start=9]
. 在 "Projects"（项目）窗口中，展开新项目的 "Libraries"（库）节点，并请注意 Spring JAR 包含在项目的类路径中。 

image::images/spring-libraries.png[title="Spring JAR 在项目的 "Libraries"（库）节点下列出"]


[[running]]
=== 运行框架项目

在对项目文件进行任何更改之前，尝试在 IDE 中运行新项目：

1. 单击 IDE 主工具栏中的 "Run Project"（运行项目）(image:images/run-project-btn.png[])。IDE 将自动启动 GlassFish Server（如果尚未运行），编译项目，然后将其部署到该服务器。请注意 IDE "Output"（输出）窗口（Ctrl-4 组合键；在 Mac 上为 ⌘-4 组合键）中显示的任何输出。构建的输出以`成功构建`消息结尾。

image::images/output.png[title="运行项目时 "Output"（输出）窗口将显示信息"] 

IDE 的默认浏览器将启动，并且您会看到欢迎页视图 (`/WEB-INF/jsp/index.jsp`) 的内容。 

image::images/browser-output.png[title="欢迎页输出显示在浏览器中"]

在 IDE 中运行项目时，将编译项目并将其部署到服务器，然后在默认浏览器中将其打开。此外，IDE 还提供“在保存时部署”功能，默认情况下将为 Web 项目激活该功能。在编辑器中保存文件时，会自动重新编译项目并将其部署到服务器。要查看更改，只需在浏览器中刷新页面即可。

为了了解刚刚发生的情况，我们从检查项目的部署描述符 (`Web.xml`) 开始。要在源代码编辑器中打开该文件，请在 "Projects"（项目）窗口中右键单击 `WEB-INF` > `Web.xml` 节点，然后选择 "Edit"（编辑）。应用程序的默认入口点为 `redirect.jsp`：


[source,xml]
----

<welcome-file-list>
    <welcome-file>redirect.jsp</welcome-file>
</welcome-file-list>
----

在 `redirect.jsp` 中，有一个重定向语句，该语句将所有请求指向 `index.htm`：


[source,java]
----

<% response.sendRedirect("index.htm"); %>
----

在部署描述符中，请注意，与 `*.htm` 匹配的 URL 模式的所有请求都被映射到 Spring 的 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html[+`DispatcherServlet`+]。


[source,xml]
----

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>*.htm</url-pattern>
</servlet-mapping>
----

上面显示的分派程序 Servlet 的全限定名称为 `org.springframework.web.servlet.DispatcherServlet`。此类包含在创建项目时添加到项目类路径的 Spring 库中。您可以在 "Projects"（项目）窗口的 "Libraries"（库）节点中向下浏览，以便对此进行验证。找到 `spring-webmvc-3.1.1.RELEASE.jar`，然后将其展开以查找 `org.springframework.web.servlet` > `DispatcherServlet`。

`DispatcherServlet` 根据 `dispatcher-servlet.xml` 中的配置设置处理传入请求。单击编辑器中的 `dispatcher-servlet.xml` 标签以将其打开。请注意以下代码。


[source,xml]
----

<bean id="urlMapping" class="org.springframework.web.servlet.handler.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.html[+SimpleUrlHandlerMapping+]">
    <property name="mappings">
        <props>
            <prop key="/index.htm">indexController</prop>
        </props>
    </property>
</bean>

<bean id="viewResolver"
      class="org.springframework.web.servlet.view.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/view/InternalResourceViewResolver.html[+InternalResourceViewResolver+]"
      p:prefix="/WEB-INF/jsp/"
      p:suffix=".jsp" />

<bean name="indexController"
      class="org.springframework.web.servlet.mvc.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html[+ParameterizableViewController+]"
      p:viewName="index" />
----

在该文件中定义了三个 Bean：`indexController`、`viewResolver` 和 `urlMapping`。当 `DispatcherServlet` 收到与 `*.htm` 匹配的请求（如 `index.htm`）时，它将在 `urlMapping` 中查找可以容纳该请求的控制器。从上面可以看出，有一个 `mappings` 属性将 `/index.htm` 链接到 `indexController`。

然后运行时环境将搜索名为 `indexController` 的 Bean 定义，该定义由框架项目提供。请注意，`indexController` 扩展了 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html[+`ParameterizableViewController`+]。这是由 Spring 提供的另一个类，该类只返回一个视图。注意 `p:viewName="index"` 指定逻辑视图名称，使用 `viewResolver` 通过加前缀 `/WEB-INF/jsp/` 以及加后缀 `.jsp` 来解析该名称。这将允许运行时环境在应用程序目录中查找该文件，并用欢迎页视图 (`/WEB-INF/jsp/index.jsp`) 进行响应。


[[overview]]
== 应用程序概述

您创建的应用程序由两个 JSP 页（在 link:http://www.oracle.com/technetwork/articles/javase/index-142890.html[+MVC+] 术语中称为_视图_）组成。第一个视图包含一个 HTML 窗体，该窗体具有一个要求用户输入名字的输入字段。第二个视图是一个页面，该页面只显示包含用户名字的一个 hello 消息。

视图由_控制器_管理，控制器接收应用程序的请求并确定返回的视图。它还向视图传递所需显示的任何信息（这称为_控制器_）。该应用程序的控制器名为 `HelloController`。

在复杂的 Web 应用程序中，业务逻辑不直接包含在控制器中。在控制器需要执行某些业务逻辑时，它会使用另一个名为_服务_的实体。在我们的应用程序中，业务逻辑限制为处理 hello 消息的操作，出于此目的，您将创建 `HelloService`。


== 实现服务

确定正确设置环境之后，可以开始根据需要扩展框架项目。从创建 `HelloService` 类开始。

1. 在 IDE 的工具栏中单击 "New File"（新建文件）(image:images/new-file-btn.png[]) 按钮。（也可以按 Ctrl-N 组合键；在 Mac 上按 ⌘-N 组合键。）
2. 选择 *Java* 类别，然后选择 *Java Class*（Java 类）并单击 "Next"（下一步）。
3. 在显示的新建 Java 类向导中，为 "Class Name"（类名）键入 *HelloService*，为 "Package Name"（包名）输入 *service* 来为该类创建一个新包。
4. 单击 "Finish"（完成）。IDE 将创建新类，并在编辑器中打开该类。

`HelloService` 类执行一个非常简单的服务。它将名称用作参数并准备返回一个包含该名称的 `String`。在编辑器中，为该类创建以下 `sayHello()` 方法（更改以*粗体*显示）。


[source,java]
----

public class HelloService {

    *public static String sayHello(String name) {
        return "Hello " + name + "!";
    }*
}
----


[[controller]]
== 实现控制器和模型

可以使用 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html[+`SimpleFormController`+] 来处理用户数据并确定返回的视图。

*注：*SimpleFormController 在 Spring 3.x 中已过时。在本教程中使用它是出于演示目的。但是，应使用标注的控制器而非 XML 文件。

1. 按 Ctrl-N 组合键（在 Mac 上按 ⌘-N 组合键）打开新建文件向导。在 "Categories"（类别）下，选择 *Spring Framework*；在 "File Types"（文件类型）下，选择 *Simple Form Controller*（简单窗体控制器）。

image::images/simple-form-controller.png[title="NetBeans IDE 为各种 Spring 工件提供模板"] 

[tips]#NetBeans IDE 为各种 Spring 工件（包括 Spring XML 配置文件、link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/AbstractController.html[+`AbstractController`+] 和 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html[+`SimpleFormController`+]）提供了模板。#

[start=2]
. 单击 "Next"（下一步）。

[start=3]
. 将该类命名为 *HelloController* 并通过在 "Package"（包）文本字段中键入 *controller* 为其创建一个新的包。单击 "Finish"（完成）。IDE 将创建新类，并在编辑器中打开该类。

[start=4]
. 通过取消注释 setter 方法（默认情况下，在类模板中显示）来指定控制器属性。要取消注释代码片段，请突出显示该代码（如下图所示），然后按 Ctrl-/ 组合键（在 Mac 上按 ⌘-/ 组合键）。

image::images/comment-out.png[title="突出显示代码片段，然后按 Ctrl-/ 以开启/关闭注释"] 

[tips]#按 Ctrl-/ 组合键（在 Mac 上按 ⌘-/ 组合键）可在编辑器中开启/关闭注释。#

[start=5]
. 进行以下更改（以*粗体*显示）。

[source,java]
----

public HelloController() {
    link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandClass(java.lang.Class)[+setCommandClass+](*Name*.class);
    link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandName(java.lang.String)[+setCommandName+]("*name*");
    link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setSuccessView(java.lang.String)[+setSuccessView+]("*hello*View");
    link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)[+setFormView+]("*name*View");
}
----

设置 `FormView` 使您能够设置用于显示窗体的视图的名称。这是包含允许用户输入其名称的文本字段的页面。同样，设置 `SuccessView` 允许您设置在成功提交时应该显示的视图的名称。当设置 `CommandName` 时，在模型中定义命令的名称。在本例中，命令就是将请求参数绑定到自身的窗体对象。设置 `CommandClass` 允许您设置命令类的名称。填充该类的一个实例并在每个请求上验证它。

注意在 `setCommandClass()` 方法中为 `Name` 标记了一个错误：

image::images/set-command-class.png[title="为 setCommandClass() 显示错误标记"]

现在，您需要创建 `Name` 类作为简单 Bean 以包含每个请求的信息。


[start=6]
. 在 "Projects"（项目）窗口中，右键单击项目节点并选择 "New"（新建）> "Java Class"（Java 类）。此时将显示新建 Java 类向导。

[start=7]
. 在 "Class Name"（类名）中输入 *Name*，从 "Package"（包）的下拉列表中选择 *controller*。

[start=8]
. 单击 "Finish"（完成）。`Name` 类随即创建，并在编辑器中打开。

[start=9]
. 对于 `Name` 类，创建一个名为 `value` 的字段，然后为该字段创建存取方法（即，getter 和 setter 方法）。首先声明 `value` 字段：

[source,java]
----

public class Name {

    *private String value;*

}
----

要快速键入 "`private`"，您可以键入 "`pr`"，然后按 Tab 键。"`private`" 访问修饰符会自动添加到该行。这是使用编辑器代码模板的一个示例。要获得代码模板的完整列表，请选择 "Help"（帮助）> "Keyboard Shortcuts Card"（快捷键列表）。


IDE 可以为您创建存取方法。在编辑器中，右键单击 `value`，然后选择 "Insert Code"（插入代码）（或按 Alt-Insert 组合键；在 Mac 上按 Ctrl-I 组合键）。在弹出式菜单中，选择 "Getter and Setter"（getter 和 setter）。 

image::images/generate-code.png[title="通过 "Generate Code"（生成代码）弹出式菜单可以设置存取方法"]

[start=10]
. 在显示的对话框中，选择 `value : String` 选项，然后单击 "OK"（确定）。`getValue()` 和 `setValue()` 方法会添加到 `Name` 类中：

[source,java]
----

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}
----

[start=11]
. 按 Ctrl-Tab 组合键并选择 `HelloController` 以切换回 `HelloController` 类。请注意，以前的错误标记已经消失，因为现在存在 `Name` 类。

[start=12]
. 删除 `doSubmitAction()` 方法并取消注释 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)[+`onSubmit()`+] 方法。使用 `onSubmit()` 方法，您可以创建自己的 `ModelAndView`，此处需要这样做。进行以下更改：

[source,java]
----

@Override
protected ModelAndView onSubmit(
            HttpServletRequest request,
            HttpServletResponse response,
            Object command,
            BindException errors) throws Exception {

        Name name = (Name) command;
        ModelAndView mv = new ModelAndView(getSuccessView());
        mv.addObject("helloMessage", helloService.sayHello(name.getValue()));
        return mv;
}
----
如上所述，将 `command` 重塑为 `Name` 对象。创建 `ModelAndView` 的一个实例，并且在 `SimpleFormController` 中使用 getter 获取成功视图。最后，用数据填充模型。我们模型中的唯一项就是从以前创建的 `HelloService` 中获取的 hello 消息。使用 `addObject` 方法将此 hello 消息添加到名称 `helloMessage` 下的模型中。

[start=13]
. 在编辑器中单击鼠标右键并选择 "Fix Imports"（修复导入）（Ctrl-Shift-I 组合键；在 Mac 上为 ⌘-Shift-I 组合键）以修复导入错误。 

image::images/fix-imports70.png[title="按 Ctrl-Shift-I 修复文件中的导入"]

*注：*确认在 "Fix All Imports"（修复所有导入）对话框中选择了 * ``org.springframework.validation.BindException`` * 和 * ``org.springframework.web.servlet.ModelAndView`` *。


[start=14]
. 单击 "OK"（确定）。向文件顶部添加以下导入语句：

[source,java]
----

import link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/ModelAndView.html[+org.springframework.web.servlet.ModelAndView+];
----
如 API 文档中所述，此类“表示处理程序返回的要由 `DispatcherServlet` 解析的模型和视图。视图可以采用需要由 `ViewResolver` 对象解析的 `String` 视图名称格式；或者，也可以直接指定 `View` 对象。模型是一个 `Map`，允许使用按照名称键入的多个对象。”

请注意，此时并未修复所有错误，因为该类仍然无法识别 `HelloService` 类，也不能使用其 `sayHello()` 方法。

[start=15]
. 在 `HelloController` 中，声明一个名为 `HelloService` 的私有字段：

[source,java]
----

private HelloService helloService;
----
然后为该字段创建一个公用的 setter 方法：

[source,java]
----

public void setHelloService(HelloService helloService) {
    this.helloService = helloService;
}
----
最后，在编辑器中单击鼠标右键，然后选择 "Fix Imports"（修复导入）（Ctrl-Shift-I 组合键；在 Mac 上为 ⌘-Shift-I 组合键）。以下语句将添加到文件顶部：

[source,java]
----

import service.HelloService;
----
现在应该修复了所有错误。

[start=16]
. 在 `applicationContext.xml` 中注册 `HelloService`。在编辑器中打开 `applicationContext.xml`，然后输入以下 Bean 声明：

[source,java]
----

<bean name="helloService" class="service.HelloService" />
----
IDE 中的 Spring 支持包括 XML 配置文件中 Java 类以及 Bean 引用的代码完成。要调用代码完成，请在使用编辑器时按 Ctrl-空格键： 

image::images/code-completion.png[title="按 Ctrl-空格键时调用的代码完成"]

[start=17]
. 在 `dispatcher-servlet.xml` 中注册 `HelloController`。在编辑器中打开 `dispatcher-servlet.xml`，然后输入以下 Bean 声明：

[source,java]
----

<bean class="controller.HelloController" p:helloService-ref="helloService"/>
----


[[view]]
== 实现视图

要实现此项目的视图，您需要创建两个 JSP 页。首先，您将调用 `nameView.jsp` 作为欢迎页，并且允许用户输入名称。另一个页面 `helloView.jsp` 显示包含输入名称的问候消息。首先创建 `helloView.jsp`。

1. 在 "Projects"（项目）窗口中，右键单击 "WEB-INF" > `jsp` 节点，然后选择 "New"（新建）> "JSP"。此时将打开新建 JSP 文件向导。将该文件命名为 *helloView*。
2. 单击 "Finish"（完成）。新的 JSP 页随即在 `jsp` 文件夹中创建，并在编辑器中打开。
3. 在编辑器中，将文件标题更改为 `Hello`，并且更改输出消息以检索在 `HelloController` 中创建的 `ModelandView` 对象的 `helloMessage`。

[source,xml]
----

<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>*Hello*</title>
</head>
<body>
    <h1>*${helloMessage}*</h1>
</body>

----

[start=4]
. 采用与<<create-jsp,以上所述>>相同的方式创建另一个 JSP 页，但将其命名为 `nameView`。

[start=5]
. 在编辑器中，将以下 Spring 标记库声明添加到 `nameView.jsp` 中。

[source,java]
----

<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
----
这将导入 link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html[+Spring 标记库+]，它包含将视图作为 JSP 页实现时有用的标记。

[start=6]
. 将 `<title>` 和 `<h1>` 标记的内容更改为：`Enter Your Name`。

[start=7]
. 在 `<h1>` 标记下面输入以下代码：

[source,xml]
----

<spring:nestedPath path="name">
    <form action="" method="post">
        Name:
        <spring:bind path="value">
            <input type="text" name="${status.expression}" value="${status.value}">
        </spring:bind>
        <input type="submit" value="OK">
    </form>
</spring:nestedPath>

----
link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.bind[+spring:bind+] 允许您绑定一个 bean 属性。绑定标记提供一个绑定状态和值，您可以将它用作输入字段的名称和值。采用这种方法提交窗体时，Spring 将知道如何提取提交的值。此处，我们的命令类 (`controller.Name`) 具有一个 `value` 属性，因此将 `path` 设置为 `value`。 

link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.nestedPath[+spring:nestedPath+] 使您能够在 Bean 前面加上指定的路径。因此，当与上面显示的 `spring:bind` 一起使用时，Bean 的路径变为：`name.value`。当再次调用时，`HelloController` 的命令名称为 `name`。因此，该路径引用该页面范围内名为 `name` 的 Bean 的 `value` 属性。

[start=8]
. 更改应用程序的相对入口点。当前，项目入口点仍然为 `index.htm`，如上面的<<running,运行框架项目>>中所述，它重定向到 `WEB-INF/jsp/index.jsp`。当部署和运行项目时，可以指定项目的入口点。在 "Projects"（项目）窗口中，右键单击该项目节点并选择 "Properties"（属性）。此时将显示 "Project Properties"（项目属性）对话框。在 "Categories"（类别）下，选择 "Run"（运行）。在 "Relative URL"（相对 URL）字段中，键入 `/hello.htm`，然后单击 "OK"（确定）。

此时，您可能希望了解 `hello.htm` 到 `HelloController` 的映射所在的位置。您尚未添加到 `urlMapping` Bean 的映射，框架项目的欢迎页 `index.htm` 就是这样。这可能就是 Spring 的特殊魅力所在，它是由 `dispatcher-servlet.xml` 文件中的下列 bean 定义提供的：

[source,java]
----

<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
----
此 Bean 负责为文件中注册的所有控制器自动创建 URL 映射。它获取控制器的全限定类名（本例中为 `controller.HelloController`）并且去除读写包名称和 `Controller` 后缀，然后将结果用作 URL 映射。因此，对于 `HelloController` 而言，它创建了一个 `hello.htm` 映射。但是，此特点并不适于 Spring Framework 中包含的控制器，如 `ParameterizableViewController`。它们需要显式映射。

[start=9]
. 在 "Projects"（项目）窗口中，右键单击该项目节点并选择 "Run"（运行）。这将编译、部署和运行该项目。您的默认浏览器会打开，并且将 `hello.htm` 显示为项目的 `nameView`： 

image::images/name-view.png[title="nameView 显示在浏览器中"] 

在文本字段中输入您的名字，然后按 Enter 键。将显示带有问候消息的 `helloView`： 

image::images/hello-view.png[title="helloView 显示在浏览器中"]

link:/about/contact_form.html?to=3&subject=Feedback:%20Introduction%20to%20Spring[+请将您的反馈意见发送给我们+]


[[seeAlso]]
== 另请参见

对 NetBeans IDE 中 Spring Framework 的简介到此结束。本文档演示了如何使用 Spring Framework 在 NetBeans IDE 中构建简单的 Web MVC 应用程序，并且向您介绍了用于开发 Web 应用程序的 IDE 界面。

建议您通过 NetBeans IDE 中的其他教程继续学习 Spring Framework，例如link:http://sites.google.com/site/springmvcnetbeans/step-by-step/[+使用 NetBeans 和 GlassFish Server 循序渐进开发 Spring Framework MVC 应用程序+]。这是 Thomas Risberg 编写的官方 link:http://static.springframework.org/docs/Spring-MVC-step-by-step/[+Spring Framework 教程+]，Arulazi Dhesiaseelan 已针对 NetBeans IDE 对该教程进行了改编。

许多 Spring NetBeans Module 功能还适用不基于 Web 的 Spring Framework 应用程序。

有关其他相关教程，请参见以下资源：

* link:../../docs/web/framework-adding-support.html[+添加对 Web 框架的支持+]。此基本指南介绍如何通过使用 NetBeans Update Center 安装 Web 框架插件来添加支持。
* link:jsf20-intro.html[+JavaServer Faces 2.0 简介+]。演示如何将 JSF 2.0 支持添加到现有项目中，连接受管 Bean，以及利用 Facelets 模板。