您的位置：首页 > 编程语言 > Java开发

Spring3 MVC - 3到Spring MVC框架简介

2013-09-27 14:13 579 查看

Spring3 MVC框架简介

Spring MVC是Spring的框架的Web组件。它提供了丰富的功能，为建设强大的Web应用程序。 Spring MVC框架的架构，并在这样的高度可配置的方式，每一块的逻辑和功能设计。此外Spring可以毫不费力地与其他流行的Web框架，如Struts，WebWork的，的Java Server Faces和Tapestry集成。这意味着，你甚至可以告诉Spring使用Web框架中的任何一个。比Spring更不紧耦合的servlet或JSP向客户端呈现视图。喜欢速度与其他视图技术集成，Freemarker的，Excel或PDF现在也有可能。

Spring3.0 MVC系列

第1部分：到Spring 3.0 MVC框架简介

第2部分：在Spring 3.0 MVC创建Hello World应用程序

第3部分：在Spring 3.0 MVC的形式处理

第4部分：Spring3 MVC的Tiles Support与Eclipse中的例子插件教程

第5部分：Spring3 MVC的国际化及本地化教程与范例在 Eclipse

第6部分：Spring3 MVC示例教程Spring主题

第7部分：创建Spring3 MVC Hibernate 3的示例在Eclipse中使用Maven的

在Spring Web MVC，你可以使用任何对象作为命令或表单支持对象，你不需要实现框架特定的接口或基类。 Spring的数据绑定是高度灵活的：例如，将验证错误类型不作为应用系统错误，可以通过评估的不匹配。因此，你不必重复你的业务对象的属性，简单的无类型的字符串，在表单对象仅仅是为了处理无效的意见，或正确转换的字符串。相反，它往往是最好直接绑定到业务对象。

请求处理生命周期

Spring的Web MVC框架是，像许多其他Web MVC框架，要求为导向，围绕一个中心的servlet，它把请求分派给控制器，提供其他功能，有利于开发Web应用而设计的。 Spring DispatcherServlet DispatcherServlet是Spring IoC容器完全集成，并允许我们使用的每一个Spring的其他功能。

以下是Spring3.0 MVC请求流程的生命周期：

客户端将请求发送到Web容器中的HTTP请求的形式。

这个传入的请求被截获由前端控制器（DispatcherServlet的），然后它会试图找出相应的处理程序映射。

帮助处理程序映射，DispatcherServlet将请求派遣适当的控制器。

控制器尝试处理请求和ModelAndView实例的形式返回到前端控制器模型和视图对象。

前端控制器，然后试图解决咨询视图解析器对象的视图（可以是JSP，FreeMarker的，速度等）。

选定的视图，然后返回到客户端呈现。

Spring3.0的特点

Spring3.0框架支持Java 5。它提供了注释的配置支持。 Java 5的功能，例如泛型，注解，可以使用可变参数等在Spring。

正在引进一种新的表达语言The Spring 的表达语言规划环境地政局局长。 Spring的表达式语言可以使用，同时定义了基于XML和注释的bean定义。

Spring3.0框架支持REST Web服务。

数据格式可从来没有那么容易。 Spring 3.0支持了注释的格式。现在，我们可以使用@ DateFimeFormat（ISO = ISO.DATE）和@NumberFormat（样式= Spring.CURRENCY）标注日期和货币格式转换。

Spring3.0已经开始支持JPA 2.0的。

配置Spring 3.0的MVC

切入点的Spring 3.0 MVC DispatcherServlet 。 DispatcherServlet的是正常的servlet的类，它是HttpServlet的的基类。因此，我们需要在它web.xml配置。

<web-app>

<servlet>

<servlet-name>example</servlet-name>

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

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

</servlet>

<servlet-mapping>

<servlet-name>example</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

在上面的代码片断中，我们必须在web.xml中配置DispatcherServlet的。请注意，我们已经映射*. HTML URL模式，例如DispatcherServlet的。因此，任何与*. HTML模式的URL将调用Spring MVC的前端控制器。一旦DispatcherServlet的初始化，它会查找一个文件名[servlet-name]-servlet.xml Web应用程序的WEB - INF文件夹中。在上面的例子中，将寻找所谓example-servlet.xml servlet.xml的框架。

请注意上面的架构图。 WebApplicationContext上图中指定ApplicationContext平原扩展Web应用程序所需的一些额外的功能。在WebApplicationContext是能够解决的主题，它也与相应的servlet相关。在WebApplicationContext在ServletContext中的约束，并通过对RequestContextUtils类的静态方法，您可以随时查找在WebApplicationContext。

继续

现在，我们有关的Spring 3.0 MVC框架，其生命周期架构的想法，在接下来的部分中，我们将创建一个工作Spring3.0的 Hello World应用程序从头。

Spring3 MVC：在Spring 3.0 MVC创建Hello World应用程序

Spring3.0 MVC系列的第2部分。在以前的文章中，我们经历介绍的Spring MVC 3.0框架，其请求处理生命周期和体系结构图。在这篇文章中，让我们在Spring MVC 3.0创建一个简单的的Hello World应用程序。

对于创建的Hello World演示应用程序，我们将使用Eclipse IDE中。

我们需要的东西

之前，我们与我们的第一个Hello World Struts 2的示例开始，我们将需要一些工具。

JDK 1.5以上（下载）

以上的Tomcat 5.x的或任何其他容器（Glassfish的中，WebSphere，JBoss的，在Weblogic等）（下载）

Eclipse的3.2.x中，它上面的（下载）

Spring3.0 MVC JAR文件：（下载）。以下是此应用程序所需的JAR文件的清单。

commons-logging-1.0.4.jar

jstl-1.2.jar

org.springframework.asm - 3.0.1.RELEASE - A.jar

org.springframework.beans - 3.0.1.RELEASE - A.jar

org.springframework.context - 3.0.1.RELEASE - A.jar

org.springframework.core - 3.0.1.RELEASE - A.jar

org.springframework.expression - 3.0.1.RELEASE - A.jar

org.springframework.web.servlet - 3.0.1.RELEASE - A.jar

org.springframework.web - 3.0.1.RELEASE - A.jar

请注意，根据Spring MVC的当前版本，上述jar文件的版本号可能会改变。

我们的目标

我们的目标是创建一个基本的Spring MVC应用中使用最新的3.0版本。将会有一个索引页，它会显示一个链接”打招呼”给用户。点击此链接，用户将被重定向到另一页打招呼，它会显示一条消息的”Hello World，Spring3.0！”。

入门

让我们开始我们的第一个Spring3.0基于MVC的应用程序。打开Eclipse转到文件- >新建- >项目，然后选择动态Web项目中的新建项目向导屏幕。

选择动态Web项目后，按” 下一步”“ 。

写项目名称。例如Spring3MVC。一旦做到这一点，选择目标运行时环境（如Apache Tomcat的V6.0）。这是在Eclipse环境中运行的项目。在此之后按下Finish。

一旦该项目被创建，您可以在Project Explorer中看到它的结构。现在的WebContent所有所需的JAR文件>的WEB - INF> lib文件夹中复制。创建此文件夹，如果它不存在。

Spring控制器类

我们需要一个Spring MVC控制器类，将处理该请求，并显示”Hello World”消息。为此，我们将创建一个包net.viralpatel.spring3.controller的源文件夹中。这个包将包含控制器文件。

创建一个类叫做HelloWorldController net.viralpatel.spring3.controller包并复制到它下面的内容。

文件：net.viralpatel.spring3.controller.HelloWorldController

package net.viralpatel.spring3.controller;

import org.springframework.stereotype.Controller;

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

import org.springframework.web.servlet.ModelAndView;

@Controller

public class HelloWorldController {

@RequestMapping(“/hello”)

public ModelAndView helloWorld() {

String message = “Hello World, Spring 3.0!”;

return n
4000
ew ModelAndView(“hello”, “message”, message);

}

}

请注意，我们已经注明HelloWorldController类@Controller和7号线和10 @RequestMapping(“/hello”) 当春扫描我们的包，将其识别为一个处理请求的控制器bean这个bean。 @RequestMapping注解告诉Spring，这个控制器应该处理所有请求/ URL路径打招呼开始。这包括/hello/*和/hello.html 。

在HelloWorld（）方法返回ModelAndView对象。 ModelAndView对象，试图解决一个名为”Hello”和数据模型是被传递回浏览器，所以我们可以在JSP访问数据视图。逻辑视图名称解析为”/WEB-INF/jsp/hello.jsp” 我们将讨论这在短期内如何的”Hello”，这是在ModelAndView对象返回的逻辑名称映射到路径/ WEB-INF/jsp/hello.jsp。

ModelAndView对象还包含了一个关键的”消息”和价值的”Hello World，Spring3.0！”的消息。这是数据，我们通过我们的观点。通常情况下，这将是一个价值形式的Java bean将包含要显示的数据我们认为对象。在这里，我们只是传递一个字符串。

这样的观点：创建JSP

要显示Hello World消息，我们将创建一个JSP。请注意，这个JSP是创建文件夹/ WEB-INF/jsp。创建hello.jsp下WEB-INF/jsp目录，并复制以下内容进去。

文件：WEB-INF/jsp/hello.jsp

<html>

<head>

<title>Spring 3.0 MVC Series: Hello World - ViralPatel.net</title>

</head>

<body>

${message}

</body>

</html>

上面的JSP只显示一条消息，使用表达式${message} 。请注意，”消息”的名称，我们在设置一个消息字符串ModelAndView对象。

同时，我们也将需要一个index.jsp文件，这将是我们的应用程序的入口点。创建一个WebContent文件夹下的文件在您的项目并复制以下内容的index.jsp。

文件的WebContent / index.jsp的

<html>

<head>

<title>Spring 3.0 MVC Series: Index - ViralPatel.net</title>

</head>

<body>

<a href=“hello.html”>Say Hello</a>

</body>

</html>

Spring MVC的映射Web.xml中

正如在以前的文章（Spring3.0 MVC）讨论，Spring MVC应用的切入点将是在部署描述符（web.xml）中定义的Servlet。因此，我们将定义在web.xml中的一个条目org.springframework.web.servlet.DispatcherServlet org.springframework.web.servlet.DispatcherServlet类。打开web.xml文件，该文件是在WEB - INF文件夹，并复制粘贴下面的代码。

文件：WEB-INF/web.xml中

<?xml version=“1.0” encoding=“UTF-8”?>

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

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

xmlns:web=“http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”

xsi:schemaLocation=“http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
id=“WebApp_ID” version=“2.5”>

<display-name>Spring3MVC</display-name>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

<servlet>

<servlet-name>spring</servlet-name>

<servlet-class>

org.springframework.web.servlet.DispatcherServlet

</servlet-class>

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

</servlet>

<servlet-mapping>

<servlet-name>spring</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

上面的代码将在web.xml中映射URL模式*. HTML的DispatcherServlet。另外请注意，我们已经定义作为欢迎文件的index.jsp。

这里有一点要注意<servlet-name>标签在web.xml中的servlet的名称。 DispatcherServlet的初始化后，它会查找一个文件名[servlet-name]-servlet.xml Web应用程序的WEB - INF文件夹中。在这个例子中，该框架将称为文件spring-servlet.xml寻找。

Spring配置文件

The Spring - servlet.xml中创建一个文件在WEB - INF文件夹，并复制到它下面的内容。

文件：WEB-INF/spring-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:p=“http://www.springframework.org/schema/p”

xmlns:context=“http://www.springframework.org/schema/context”

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=“net.viralpatel.spring3.controller” />

<bean id=“viewResolver”

class=“org.springframework.web.servlet.view.UrlBasedViewResolver”>

<property name=“viewClass”

value=“org.springframework.web.servlet.view.JstlView” />

<property name=“prefix” value=“/WEB-INF/jsp/” />

<property name=“suffix” value=“.jsp” />

</bean>

</beans>

在上面的XML配置文件，我们已经定义了一个标记<context:component-scan>。这将允许Spring载入net.viralpatel.spring3.controller从包中的所有组件和它的所有子包。这将载入我们HelloWorldController类。另外，我们定义一个bean viewResolver 。这个bean将解决意见，并添加前缀字符串/ WEB-INF/jsp /以及后缀。JSP在ModelAndView的观点。请注意，我们已经在我们的HelloWorldController类，返回一个ModelAndView对象的视图名称的”Hello”。
这将是解决路径/ WEB-INF/jsp/hello.jsp。

这是所有Folks

您可能需要运行的应用程序现在看到的结果。我假设你已经在Eclipse中配置Tomcat的。所有您需要做的：从”窗口”>“显示视图”>“服务器打开服务器视图。在此视图中右键单击并选择New> Server，并添加您的服务器的详细信息。要运行该项目，从Project Explorer中的项目名称上点击右键并选择>运行在服务器上运行（快捷键：ALT + SHIFT + X，R ）

下载源代码

点击这里下载源代码（9.05kb）

继续

在本教程中，我们创建了一个小型的Hello World应用程序，使用Spring 3.0 MVC框架。此外，我们了解了Spring的配置和喜欢不同@Controller @ @RequestMapping RequestMapping的。在下一篇文章中，我们将看到它是多么容易使用Spring 3.0的MVC来处理表单数据。

Spring3 MVC：在Spring 3.0 MVC的处理形式

Spring3.0 MVC系列的第3部分。在以前的文章中，我们创建了一个在Spring MVC的Hello World应用程序。我们俯身如何在web.xml中配置Spring MVC中，如何使用不同的注释，如@控制器，@ RequestMapping的等在这篇文章中，让我们来看看如何处理在Spring 3.0 MVC的形式。

我们将利用我们在以前的文章中创建一个基本参考，并添加在它的形式的功能框架。另外，我们创建的应用程序将是一个联系人管理器应用程序。

我们的目标

我们的目标是创建基本的联系人管理器应用程序。这个应用程序将有一个表格，从用户的详细联系方式。现在我们将只打印在日志中的细节。我们将学习如何捕捉在Spring3 MVC的表单数据。

入门

让我们添加的接触形式，以Spring3 MVC Hello World应用程序。打开index.jsp文件，并改变它，以下列：

文件的WebContent / index.jsp的

<jsp:forward page=“contacts.html”></jsp:forward>

上面的代码将重定向用户contacts.html页。

查看- contact.jsp

创建一个JSP文件，将显示联系表格给我们的用户。文件：/的WebContent / WEB - INF / JSP / contact.jsp

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

<html>

<head>

<title>Spring 3 MVC Series - Contact Manager</title>

</head>

<body>

<h2>Contact Manager</h2>

<form:form method=“post” action=“addContact.html”>

<table>

<tr>

<td><form:label path=“firstname”>First Name</form:label></td>

<td><form:input path=“firstname” /></td>

</tr>

<tr>

<td><form:label path=“lastname”>Last Name</form:label></td>

<td><form:input path=“lastname” /></td>

</tr>

<tr>

<td><form:label path=“lastname”>Email</form:label></td>

<td><form:input path=“email” /></td>

</tr>

<tr>

<td><form:label path=“lastname”>Telephone</form:label></td>

<td><form:input path=“telephone” /></td>

</tr>

<tr>

<td colspan=“2”>

<input type=“submit” value=“Add Contact”/>

</td>

</tr>

</table>

</form:form>

</body>

</html>

在这里，我们在上面的JSP显示的形式。请注意的形式提交给 addContact.html页。

在Spring3添加的表格和控制器

现在我们将添加在The Spring 3的逻辑显示的形式，并获取它的值。为此，我们将创建两个Java文件。首先Contact.java这只不过是形式显示/检索从屏幕上的数据和ContactController.java ContactController.java这是Spring的控制器类。

文件：net.viralpatel.spring3.form.Contact

package net.viralpatel.spring3.form;

public class Contact {

private String firstname;

private String lastname;

private String email;

private String telephone;

//.. getter and setter for all above fields.

}

上述文件是从屏幕上的数据的接触形式持有。请注意，我没有表现出getter和setter方法。您可以按ALT + SHIFT + S，R pressiong这些方法产生。

文件：net.viralpatel.spring3.controller.ContactController

package net.viralpatel.spring3.controller;

import net.viralpatel.spring3.form.Contact;

import org.springframework.stereotype.Controller;

import org.springframework.validation.BindingResult;

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.bind.annotation.SessionAttributes;

import org.springframework.web.servlet.ModelAndView;

@Controller

@SessionAttributes

public class ContactController {

@RequestMapping(value = “/addContact”, method = RequestMethod.POST)

public String addContact(@ModelAttribute(“contact”)

Contact contact, BindingResult result) {

System.out.println(“First Name:” + contact.getFirstname() +

“Last Name:” + contact.getLastname());

return “redirect:contacts.html”;

}

@RequestMapping(“/contacts”)

public ModelAndView showContacts() {

return new ModelAndView(“contact”, “command”, new Contact());

}

}

在上面的控制器类，请注意，我们已经创建了两个请求映射/联系人/ addContact的方法。方法showContacts()时将调用用户对一个URL contacts.html的请求。这种方法将呈现一个模型，名为”接触”。请注意ModelAndView ModelAndView对象，我们已经通过一个名为”命令”空白的联系对象。 Spring框架预计name命令的对象，如果您使用在你的JSP文件。

另外请注意， addContact()方法，我们有注明此RequestMapping的，并通过一个属性的方法=“RequestMethod.POST” 。因此，该方法将被调用，只有当用户生成一个POST方法请求URL / addContact.html。我们已经注明@ModelAttribute与标注的参数联系。这将结合从请求对象联系的数据。在此方法中，我们只印的名字和姓氏值和重定向的视图cotnacts.html。

这是所有Folks

现在的形式完成。只要运行在Eclipse应用程序由pression ALT + SHIFT + X，R。它将显示的联系表格。只需输入视图的值，然后按添加按钮。一旦你按下按钮，它会打印SYSOUT日志的名字和姓氏。

下载源代码

点击这里下载源代码（7.43kb）

在这篇文章中，我们将学习如何创建一个表单，使用The Spring 3 MVC，并显示在JSP。此外，我们学会了如何检索使用ModelAttribute注解的形式值。在下一节，我们将通过在Spring3 MVC的表单验证和不同的数据转换方法。

Spring 3 MVC: Tiles Plugin Tutorial with Example in Eclipse

Spring3.0 MVC系列的第4部分。在以前的文章中，我们看到了如何创建使用Spring MVC的表单，并显示在JSP。同时，我们也了解注解@ModelAttribute 。

在这一部分，我们将讨论关于Tiles框架和它与Spring 3.0 MVC的集成。我们将添加Tiles Support支持我们的HelloWorld Spring应用程序，我们在前面部分中创建的。我强烈建议你去通过以前的文章中和下载我们的示例应用程序的源代码。

Tiles Support2

如今，网站一般分为可重复使用的模板正在呈现不同的网页之间的的。例如，一个网站中包含的页眉，页脚，菜单等项目仍然通过了该网站相同，并给它一个共同的外观和感觉。这是很难很难的代码在每一个网页，如果以后需要改变是不是所有的页面需要修改。因此，我们使用模板化机制。我们创建一个共同的页眉，页脚，菜单页，其中包括在每一页。

Tiles Support插件允许模板和组件。事实上，这两种机制是相似的：你定义页面的某些部分（a ”Tile”）组装建立另一部分或整页。 A部分参数，使动态内容，并且可以在Java语言中的一种方法。 Tiles是用来保持一致的外观和感觉整个Web应用程序的所有网页模板系统。增加模板的可重用性和减少代码重复。

是指在一个中央配置文件的网站的一个共同的布局，这种布局可以延长Web应用程序的所有网页。

我们的应用程序布局

我们的目标是我们的Spring3 HelloWorld应用程序添加页眉，页脚和菜单。以下将是相同的布局。

所需的jar文件

为了增加Tiles Support到我们Spring3的应用程序的支持，我们将需要几个jar文件。以下是在我们的例子中的JAR名单。在WEB-INF/lib文件夹中添加这些JAR。在上面的列表中突出显示的jar文件要在Tiles Support一体化项目增添了新的罐
19954
子。

在Spring MVC的配置Tiles框架

要配置Tiles,an entry for bean TilesConfigure has to be made in spring-servlet.xml。打开WEB - INF文件夹的Spring- servlet.xml中之间添加以下代码<beans> </beans>标记。

文件：/的WebContent / WEB - INF /Spring- servlet.xml中

<bean id=“viewResolver”

class=“org.springframework.web.servlet.view.UrlBasedViewResolver”>

<property name=“viewClass”>

<value> org.springframework.web.servlet.view.tiles2.TilesView </value>

</property>

</bean>

<bean id=“tilesConfigurer”

class=“org.springframework.web.servlet.view.tiles2.TilesConfigurer”>

<property name=“definitions”>

<list>

<value>/WEB-INF/tiles.xml</value>

</list>

</property>

</bean>

输入配置文件/ WEB-INF/tiles.xml是通过在上面的bean定义的参数。这个文件包含了我们的Web应用程序的Tiles定义。

在WEB - INF文件夹，复制下面的代码创建的文件tiles.xml。

文件：的WebContent / WEB - INF文件/ tiles.xml

<bean id="viewResolver"

class="org.springframework.web.servlet.view.UrlBasedViewResolver">

<property name="viewClass">

<value>

org.springframework.web.servlet.view.tiles2.TilesView

</value>

</property>

</bean>

<bean id="tilesConfigurer"

class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">

<property name="definitions">

<list>

<value>/WEB-INF/tiles.xml</value>

</list>

</property>

</bean>

这里，tiles.xml我们定义一个模板base.definition。此布局包含的头，标题，身体，菜单和页脚等属性。布局是那么的联系页面的扩展和新的定义。我们已经覆盖默认的布局，并改变了机构和标题的内容。

创建视图 - JSP

我们将定义为我们的web应用在所谓的layout.jsp一个JSP文件的模板。此模板将包含网页的不同部分（页眉，页脚，菜单等）。创建4个新的JSP文件layout.jsp，header.jsp中，menu.jsp和footer.jsp和复制以下内容在他们每个人。

文件的WebContent / WEB - INF / JSP / layout.jsp

<%@ taglib uri=“http://tiles.apache.org/tags-tiles” prefix=“tiles”%>

<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”

“http://www.w3.org/TR/html4/loose.dtd”>

<html>

<head>

<meta http-equiv=“Content-Type” content=“text/html; charset=UTF-8”>

<title><tiles:insertAttribute name=“title” ignore=“true” /></title>

</head>

<body>

<table border=“1” cellpadding=“2” cellspacing=“2” align=“center”>

<tr>

<td height=“30” colspan=“2”><tiles:insertAttribute name=“header” />

</td>

</tr>

<tr>

<td height=“250”><tiles:insertAttribute name=“menu” /></td>

<td width=“350”><tiles:insertAttribute name=“body” /></td>

</tr>

<tr>

<td height=“30” colspan=“2”><tiles:insertAttribute name=“footer” />

</td>

</tr>

</table>

</body>

</html>

文件的WebContent / WEB - INF / JSP / header.jsp中

<h1>Header</h1>

文件的WebContent / WEB - INF / JSP / menu.jsp

<p>Menu</p>

文件的WebContent / WEB - INF / JSP / footer.jsp

<p>Copyright © ViralPatel.net</p>

这是所有Folks

在Eclipse中编译和执行应用程序和看到的标题，菜单和页脚是正确运用。

下载源代码

点击这里下载源代码（8.88kb）。

今天，我们看到了我们如何使用Spring MVC应用程序配置Tiles框架。我们在bean定义中使用org.springframework.web.servlet.view.tiles2.TilesConfigurer类”定义的Tiles Support配置文件。在接下来的部分我们将讨论有关国际化/本地化和增加其在Spring3 MVC的支持。我希望你喜欢这篇文章。随意张贴您的查询，并在注释部分的意见。

Spring3 MVC：国际化和本地化教程示例

Spring3.0 MVC系列的第5部分。在以前的文章中，我们看到了如何使用Spring MVC应用程序配置Tiles框架。我们使用org.springframework.web.servlet.view.tiles2.TilesConfigurer bean定义的类定义Tiles Support的配置文件。这个分裂我们的HelloWorld Spring MVC的应用部分，如页眉，页脚等。

在这一部分，我们将讨论有关国际化（I18N）和本地化（L10N）的在Spring 3.0 MVC。我们将添加L10N我们的HelloWorld Spring应用程序，我们在本系列前面的教程中创建的i18n支持。我强烈建议你去通过以前的文章中和下载我们的示例应用程序的源代码。

什么是国际化和本地化？

在计算，国际化和本地化是计算机软件，以适应不同的语言和地区差异的手段。国际化是设计的软件应用程序，以便它可以适应在没有更改设计的情况下，以各种语言和地区的过程中。本地化是适应一个特定的地区或语言的国际化软件加入区域设置特定的组件和翻译文本的过程。

这两个术语经常缩写为numeronyms I18N（其中18代表字母之间的第一次我在国际化的最后n）和本地化，由于长度的话。 L10N资本大号帮助，以区别于小写我在I18N。

我们的目标

我们的目标是到我们的Spring MVC应用添加国际化和本地化支持。一旦完成，我们的应用程序看起来像。

我们将添加两个我们的应用程序语言支持：英语和德语。根据用户的浏览器的区域设置，将选择适当的语言。此外，用户将可以选择从右上角角落里的应用程序的语言。

消息Resouces文件

我们将创建两个属性的文件，其中将包含所有要在应用程序中显示的消息。这些文件都保存在所谓的”资源”源文件夹。创建一个在您的项目的源文件夹，右键单击项目名称>“新建”>“源文件夹和名称资源。

创建两个文件messages_en.properties和messages_de.properties在此文件夹，并复制到它下面的内容。

文件：资源/ messages_en.properties

label.firstname=First Name

label.lastname=Last Name

label.email=Email

label.telephone=Telephone

label.addcontact=Add Contact

label.menu=Menu

label.title=Contact Manager

label.footer=© ViralPatel.net

文件：资源/ messages_de.properties

label.firstname=Vorname

label.lastname=Familiename

label.email=Email

label.telephone=Telefon

label.addcontact=Addieren Kontakt

label.title=Kontakt Manager

label.menu=Menü

label.footer=© ViralPatel.net

在Spring MVC的配置国际化（i18n）/本地化（localization）

现在，我们已经创建了信息资源的属性，为我们的应用程序。我们需要在Spring配置文件中声明这些文件。我们将使用类org.springframework.context.support.ReloadableResourceBundleMessageSource定义消息资源。

此外，请注意，我们将为您提供一个功能，用户将能够选择应用程序的语言。这是通过使用org.springframework.web.servlet.i18n.LocaleChangeInterceptor类。 LocaleChangeInterceptor类将截获的语言环境中的任何变化。这些变化，然后将其保存在未来要求的Cookie org.springframework.web.servlet.i18n.CookieLocaleResolver org.springframework.web.servlet.i18n.CookieLocaleResolver类将被用来存储在cookie中的语言环境的变化。

Spring- servlet.xml文件中添加下面的代码。

文件：的WebContent / WEB - INF文件/The Spring - servlet.xml中

<bean id=“messageSource”

class=“org.springframework.context.support.ReloadableResourceBundleMessageSource”>

<property name=“basename” value=“classpath:messages” />

<property name=“defaultEncoding” value=“UTF-8”/>

</bean>

<bean id=“localeChangeInterceptor”

class=“org.springframework.web.servlet.i18n.LocaleChangeInterceptor”>

<property name=“paramName” value=“lang” />

</bean>

<bean id=“localeResolver”

class=“org.springframework.web.servlet.i18n.CookieLocaleResolver”>

<property name=“defaultLocale” value=“en”/>

</bean>

<bean id=“handlerMapping”

class=“org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping”>

<property name=“interceptors”>

<ref bean=“localeChangeInterceptor” />

</property>

</bean>

注意：在上述配置中，我们已经定义到CLASSPATH messageSource bean 基名属性：消息。受此影响，Spring，将确定的消息资源讯息：将被用于这个应用程序。

更改视图 - 的JSP

现在，因为我们已经创建了两个消息资源文件和配置在Spring MVC，我们将在JSP文件中使用这些消息。打开我们的演示应用程序的所有JSP文件，下面的代码更新。

文件的WebContent / WEB - INF / JSP / header.jsp中

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

<h3><spring:message code="label.title"/></h3>

<span style="float: right">

<a href="?lang=en">en</a>

|

<a href="?lang=de">de</a>

</span>

文件的WebContent / WEB - INF / JSP / menu.jsp

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

<p><spring:message code="label.menu”/></p>

文件的WebContent / WEB - INF / JSP / footer.jsp

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

<spring:message code="label.footer"/>

文件的WebContent / WEB - INF / JSP / contact.jsp

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

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

<html>

<head>

<title>Spring 3 MVC Series - Contact Manager</title>

</head>

<body>

<form:form method="post" action="addContact.html">

<table>

<tr>

<td><form:label path="firstname"><spring:message code="label.firstname"/></form:label></td>

<td><form:input path="firstname" /></td>

</tr>

<tr>

<td><form:label path="lastname"><spring:message code="label.lastname"/></form:label></td>

<td><form:input path="lastname" /></td>

</tr>

<tr>

<td><form:label path="lastname"><spring:message code="label.email"/></form:label></td>

<td><form:input path="email" /></td>

</tr>

<tr>

<td><form:label path="lastname"><spring:message code="label.telephone"/></form:label></td>

<td><form:input path="telephone" /></td>

</tr>

<tr>

<td colspan="2">

<input type="submit" value="<spring:message code="label.addcontact"/>"/>

</td>

</tr>

</table>

</form:form>

</body>

</html>

请注意，在上面的JSP中，我们<spring:message> <spring:message>标签来显示从资源包的消息。

这里，我们必须注意的一件事情是，在header.jsp中的文件，我们已经指定了两个环节，选择语言。 LANG =链接设置请求参数？当用户点击这个链接。注意，Spring标识使用此请求参数LocaleChangeInterceptor拦截和相应改变的地方。另外请注意，在配置LocaleChangeInterceptorThe Spring - servlet.xml文件中，我们已经指定为”lang” property ” paramName”

<property name="paramName" value="lang" />

因此Spring框架将寻找所谓的”郎”从请求参数。

这是所有Folks

这是相当多：）我们只是增加了国际化和本地化支持，我们的演示Spring 3.0 MVC应用程序中。所有你所要做的的仅仅是执行在Eclipse的应用程序。按Alt + Shift + X，R。

下载源代码

点击这里下载源代码（10.2kb）

今天，我们看到如何添加到Spring 3.0基于Web应用程序国际化的国际化和本地化本地化支持。我们使用LocaleChangeInterceptor拦截的语言环境和ReloadableResourceBundleMessageSource类添加消息资源属性的变化。在接下来的部分我们将讨论在Spring MVC，以及如何实现它的主题。我希望你喜欢这篇文章。随意张贴您的查询，并在注释部分的意见。

Spring3例Spring教程MVC：主题

Spring3.0 MVC系列的第6部。在以前的文章中，我们看到了如何添加到Spring 3.0基于Web应用程序国际化的国际化和本地化本地化支持。我们使用LocaleChangeInterceptor拦截的语言环境和ReloadableResourceBundleMessageSource类添加消息资源属性的变化。

在这一部分，我们将看到如何在Spring MVC中添加主题。我们将创建三个不同的主题，并在我们的HelloWorldSpring项目中添加功能，用户可以选择任何可用的主题。一旦用户选择了一个主题，我们可以在Cookie中保存它，以便它可以在不同的会话之间持久。

在Spring MVC主题简介

主题是静态资源，典型的样式表和图像，影响视觉风格的应用程序的集合。我们可以申请的Spring Web MVC框架的主题设置的整体外观和感觉应用，从而提高用户体验。

在您的Web应用程序要使用的主题，您必须设置的org.springframework.ui.context.ThemeSource接口的一个实现。在WebApplicationContext接口扩展ThemeSource但其职责委托一个专门的实施。默认情况下，委托将org.springframework.ui.context.support.ResourceBundleThemeSource实施，从classpath的根目录加载的属性文件。要使用一个自定义的ThemeSource实现或配置的ResourceBundleThemeSource基地名称的前缀，你可以注册一个保留名称themeSource的应用程序上下文的bean。
Web应用程序上下文自动检测与这个名字的bean，并使用它。

当使用ResourceBundleThemeSource，主题是指在一个简单的属性文件。属性文件中列出的资源，弥补主题。下面是一个例子：

我们的目标

我们的目标是要改变的Hello World春3 MVC的主题支持。用户将有3预定义的主题（默认情况下，黑色和蓝色）的选项来选择主题。

Spring3 MVC添加主题支持

让我们配置Spring3 MVC应用程序中添加主题支持。为此，我们将下面的代码添加到The Spring - servlet.xml文件。

文件：的WebContent / WEB - INF文件/The Spring - servlet.xml中

<bean id="themeSource"

class="org.springframework.ui.context.support.ResourceBundleThemeSource">

<property name="basenamePrefix" value="theme-" />

</bean>



<bean id="themeChangeInterceptor"

class="org.springframework.web.servlet.theme.ThemeChangeInterceptor">

<property name="paramName" value="theme" />

</bean>

<bean id="themeResolver"

class="org.springframework.web.servlet.theme.CookieThemeResolver">

<property name="defaultThemeName" value="default" />

</bean>

<bean id="handlerMapping"

class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">

<property name="interceptors">

<list>

<ref bean="localeChangeInterceptor" />

<ref bean="themeChangeInterceptor" />

</list>

</property>

</bean>

在上述配置中，首先我们必须增加 themeSource bean 。请注意，这个bean是一个类ResourceBundleThemeSource实例ResourceBundleThemeSource，我们也有指定的属性与价值”为主题的 “ basenamePrefix。 ResourceBundleThemeSource类加载的属性文件包含前缀开始”为主题的主题定义”。因此，如果我们定义了3个新主题在我们的项目（默认情况下，黑色和蓝色），然后我们将创建3个属性文件，同时将有一定的配置属性。此外，这些文件将被划归项目的类路径。

接下来，我们定义了一个拦截器，这是一个类的实例org.springframework.web.servlet.theme.ThemeChangeInterceptor bean themeChangeInterceptor 。另外请注意在这里，我们已经指定的属性PARAMNAME与价值主题。每当一个请求参数具有不同价值观的”主题”，这个拦截器被调用。

一旦themeChangeInterceptor拦截主题的变化，这些变化，然后将其存储在使用类org.springframework.web.servlet.theme.CookieThemeResolver饼干org.springframework.web.servlet.theme.CookieThemeResolver。我们已经在我们的Spring- servlet.xml的配置文件配置这个类。另外请注意，我们已经指定这个bean的默认主题名称。

现在，创建以下资源/项目文件夹的属性文件。

文件：资源/主题default.properties

css=themes/default.css

文件：资源/主题blue.properties

css=themes/blue.css

文件：资源/主题black.properties

css=themes/black.css

针对不同主题的CSS样式表

让我们创建CSS样式表将作为我们项目的主题文件。创建以下文件夹中的WebContent /主题的CSS文件。

文件的WebContent /主题/是default.css

body {

background-color: white;

color: black;

}

文件的WebContent /主题/ blue.css
body {

background-color: #DBF5FF;

color: #007AAB;

}

文件的WebContent /主题/ black.css
body {

background-color: #888;

color: white;

}

JSP视图的变化

我们几乎完成剩余的变化和最后一位的是增加一个功能，为用户选择从UI的主题。为此，我们将改变header.jsp中的文件，并添加不同主题的3个环节。用户可以点击此链接的任何改变web应用的主题。

文件的WebContent / WEB - INF / JSP / header.jsp中

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

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

<h3><spring:message code="label.title"/></h3>

<span style="float: right">

<a href="?lang=en">en</a>

|

<a href="?lang=de">de</a>

</span>

<span style="float: left">

<a href="?theme=default">def</a>

|

<a href="?theme=black">blk</a>

|

<a href="?theme=blue">blu</a>

</span>

请注意，在上面的JSP的变化中，我们创建了带参数的3个环节”？主题=“。因此，每当用户点击这些链接，将通过一个新的参数的要求与相应的主题。 Spring的请求拦截器会取这个值，并相应地改变主题。

这是所有Folks

这是相当多吧：）我们刚刚添加主题支持我们的演示的Spring 3.0 MVC应用程序。所有你所要做的的仅仅是执行在Eclipse的应用程序。按Alt + Shift + X，R。

下载源代码

点击这里下载源代码（21KB，邮编）

创建Spring3 MVC Hibernate 3的示例在Eclipse中使用Maven的

让我们做一个完整的终端到终端的应用程序使用Spring3.0 MVC前端技术和Hibernate作为后端ORM技术。对于这种应用，我们也将作为数据库使用Maven来坚持数据构建和依赖管理和MySQL。

该应用程序将是一个简单的联系人管理器的应用程序，这将允许用户添加新的联系人。将显示联系人列表中，用户将可以删除现有的联系人。

我们的目标

正如上面描述的，我们的目标是创建一个联系人管理器应用程序，这将允许用户添加联系人，或将其删除。联系人管理应用程序的基本要求是：

在联系人列表中添加新的联系人。

从联系人列表中显示所有联系人。

从联系人列表中删除联系人。

以下是最终应用的截图。

应用程序体系结构

我们将有一个为我们的演示应用程序的分层架构。该数据库将被普遍称为DAO层的数据访问层的访问。这一层将使用Hibernate API来与数据库交互。 DAO层将调用一个服务层。在我们的应用程序中，我们将有一个服务接口称为ContactService。

入门

对于我们的联系人管理器的例子，我们将使用MySQL数据库。在任何MySQL数据库创建一个表接触。这是非常初步的例子，因此，我们有最低的列代表联系。随意延长这个例子中，创建一个更复杂的应用程序。

CREATE TABLE CONTACTS

(

id INT PRIMARY KEY AUTO_INCREMENT,

firstname VARCHAR(30),

lastname VARCHAR(30),

telephone VARCHAR(15),

email VARCHAR(30),

created TIMESTAMP DEFAULT NOW()

);

在Eclipse中创建工程

联系人管理器应用程序将使用Maven的构建和依赖管理。为此，我们将使用Eclipse中的Maven的动态Web项目作为我们的应用程序的基础架构。

下载下面的源代码： Maven的动态Web项目（6.7 KB）

解压缩到您的硬盘驱动器和源代码导入Eclipse项目。一旦该项目是在Eclipse中导入，我们将创建一个Java源代码的包结构。 src /主/ Java的文件夹下创建以下软件包。

net.viralpatel.contact.controller -这个包将包含联系人管理器应用程序的Spring控制器类。

net.viralpatel.contact.form -这个包将包含形式为Contact Manager应用程序的对象。联系的形式将一个简单的POJO类的不同属性，如名字，姓氏等。

net.viralpatel.contact.service -这个包将包含我们的联系人管理器应用程序服务层的代码。服务层将有一个ContactService接口和相应的实现类

net.viralpatel.contact.dao -这是Contact Manager应用程序的DAO层。它由ContactDAO接口和相应的实现类。 DAO层使用Hibernate API来与数据库交互。

实体类 - Hibernate的域类

让我们先从Contact Manager应用程序的编码。首先，我们将创建一个表单对象或Hibernate的POJO类来存储联系人信息。这个类将是一个实体类，将与联系人数据库表联系起来。 net.viralpatel.contact.form包和复制下面的代码下创建一个Java类Contact.java。

文件：src /主/ JAVA / NET / viralpatel /联系方式/形式/ Contact.java

package net.viralpatel.contact.form;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name="CONTACTS")

public class Contact {

@Id

@Column(name="ID")

@GeneratedValue

private Integer id;

@Column(name="FIRSTNAME")

private String firstname;

@Column(name="LASTNAME")

private String lastname;

@Column(name="EMAIL")

private String email;

@Column(name="TELEPHONE")

private String telephone;

public String getEmail() {

return email;

}

public String getTelephone() {

return telephone;

}

public void setEmail(String email) {

this.email = email;

}

public void setTelephone(String telephone) {

this.telephone = telephone;

}

public String getFirstname() {

return firstname;

}

public String getLastname() {

return lastname;

}

public void setFirstname(String firstname) {

this.firstname = firstname;

}

public void setLastname(String lastname) {

this.lastname = lastname;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

}

你会注意到的第一件事情是，import语句导入javax.persistence，而不是一个Hibernate或者Spring包。与Spring中使用Hibernate，标准的JPA注解很好的工作，这就是我这里使用。

首先，我们已经注明@Entity实体，它告诉Hibernate这个类表示一个对象，我们可以坚持。

@Table(name = “CONTACTS”)注解告诉Hibernate的表在这个类中的地图属性。在这一类的第16行的第一个属性是我们的对象ID将是独一无二的，持续的所有事件。这是为什么我们带有@Id 。

@GeneratedValue批注说，这个值将确定源代码。

@Column(name = “FIRSTNAME”)注解是用来映射在Contacts表中的这个属性FirstName列。

数据访问（DAO）层

Contact Manager应用程序的DAO层包括一个ContactDAO ContactDAO和相应的ContactDAOImpl类ContactDAOImpl。创建以下Java中的文件net.viralpatel.contact.dao包。

文件：src /主/ JAVA / NET / viralpatel /联系我们/ DAO / ContactDAO.java

package net.viralpatel.contact.dao;

import java.util.List;

import net.viralpatel.contact.form.Contact;

public interface ContactDAO {

public void addContact(Contact contact);

public List<Contact> listContact();

public void removeContact(Integer id);

}

文件：src /主/ JAVA / NET / viralpatel /联系我们/ DAO / ContactDAOImpl.java

package net.viralpatel.contact.dao;

import java.util.List;

import net.viralpatel.contact.form.Contact;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

@Repository

public class ContactDAOImpl implements ContactDAO {

@Autowired

private SessionFactory sessionFactory;

public void addContact(Contact contact) {

sessionFactory.getCurrentSession().save(contact);

}

public List<Contact> listContact() {

return sessionFactory.getCurrentSession().createQuery(“from Contact”)

.list();

}

public void removeContact(Integer id) {

Contact contact = (Contact) sessionFactory.getCurrentSession().load(

Contact.class, id);

if (null != contact) {

sessionFactory.getCurrentSession().delete(contact);

}

}

}

在上面的代码的DAO ContactDAOImpl ContactDAOImpl实现数据访问ContactDAO接口ContactDAO定义方法listContact() （ addContact() （）等，以从数据库中访问数据。

请注意，我们已经使用了两个@Repository @ @Autowired Autowired进行。

带注释的标记类是由Spring使用基于注解的配置和Classpath扫描时，自动检测的候选人。 @Component注解是主要的刻板印象，表明一个被注解的类是一个”组件”。

@Repository注解，另一个是在Spring 2.0中引入的刻板印象。这个注解是用来表明，作为一个仓库一类的功能和需要有异常转换应用透明就可以了。异常翻译的好处是，服务层只有从Spring的DataAccessException体系的例外处理，即使使用纯JPA的DAO类。

在ContactDAOImpl使用的另一种注解@Autowired 。这是用来自动装配上的SessionFactory ContactDAOImpl的依赖。

服务层

联系人管理器的应用服务层组成的接口ContactService和相应的实现类ContactServiceImpl。创建下面的Java文件net.viralpatel.contact.service包。

文件：src /主/ JAVA / NET / viralpatel /联系我们/服务/ ContactService.java

package net.viralpatel.contact.service;

import java.util.List;

import net.viralpatel.contact.form.Contact;

public interface ContactService {

public void addContact(Contact contact);

public List<Contact> listContact();

public void removeContact(Integer id);

}

文件：src /主/ JAVA / NET / viralpatel /联系我们/服务/ ContactServiceImpl.java

package net.viralpatel.contact.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import net.viralpatel.contact.dao.ContactDAO;

import net.viralpatel.contact.form.Contact;

@Service

public class ContactServiceImpl implements ContactService {

@Autowired

private ContactDAO contactDAO;

@Transactional

public void addContact(Contact contact) {

contactDAO.addContact(contact);

}

@Transactional

public List<Contact> listContact() {

return contactDAO.listContact();

}

@Transactional

public void removeContact(Integer id) {

contactDAO.removeContact(id);

}

}

在上述服务层的代码，我们创建了一个接口ContactService ，并在课堂上ContactServiceImpl ContactServiceImpl 。请注意，我们使用一些如春@Service @ @Autowired @Transactional @ Transactional在我们的代码。这些注解被称为春典型化注解。

用于装饰ContactServiceImpl类@Service的刻板印象注释是一个专门@Component注解的形式。这是适当的注释与服务层中@Service @服务，以方便工具的处理或预测任何未来服务的特定功能，可能被添加到这个注解。

添加Spring MVC的支持

让我们添加到我们的Web应用程序的Spring MVC的支持。

更新web.xml文件，并添加org.springframework.web.servlet.DispatcherServlet servlet映射。另外请注意，我们已制订与URL / springServlet，所以所有的请求处理的Spring。

文件：/ src目录/ webapp的/ WEB - INF目录/ web.xml中

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

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

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

xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">

<display-name>Spring3-Hibernate</display-name>

<welcome-file-list>

<welcome-file>list.html</welcome-file>

</welcome-file-list>

<servlet>

<servlet-name>spring</servlet-name>

<servlet-class>

org.springframework.web.servlet.DispatcherServlet

</servlet-class>

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

</servlet>

<servlet-mapping>

<servlet-name>spring</servlet-name>

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

</servlet-mapping>

</web-app>

一旦在web.xml配置，让我们在/ src目录/主/ webapp的/ WEB - INF文件夹中添加- servlet.xml的Spring和jdbc.properties文件。文件：/ SRC /主/ webapp的/ WEB - INF目录/ jdbc.properties

jdbc.driverClassName= com.mysql.jdbc.Driver

jdbc.dialect=org.hibernate.dialect.MySQLDialect

jdbc.databaseurl=jdbc:mysql://localhost:3306/ContactManager

jdbc.username=root

jdbc.password=testpass

jdbc.properties文件包含数据库连接信息，例如数据库URL，用户名，密码，驱动程序类。如果你不使用MySQL，你可能要编辑的DriverClass和其他数据库的方言。

文件：/ SRC /主/ webapp的/ WEB - INF /Spring- 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:aop="http://www.springframework.org/schema/aop"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:jee="http://www.springframework.org/schema/jee"

xmlns:lang="http://www.springframework.org/schema/lang"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:util="http://www.springframework.org/schema/util"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

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

http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd

http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

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

<context:annotation-config />

<context:component-scan base-package="net.viralpatel.contact" />

<bean id="jspViewResolver"

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

<property name="viewClass"

value="org.springframework.web.servlet.view.JstlView" />

<property name="prefix" value="/WEB-INF/jsp/" />

<property name="suffix" value=".jsp" />

</bean>

<bean id="messageSource"

class="org.springframework.context.support.ReloadableResourceBundleMessageSource">

<property name="basename" value="classpath:messages" />

<property name="defaultEncoding" value="UTF-8" />

</bean>

<bean id="propertyConfigurer"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"

p:location="/WEB-INF/jdbc.properties" />

<bean id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"

p:driverClassName="${jdbc.driverClassName}"

p:url="${jdbc.databaseurl}" p:username="${jdbc.username}"

p:password="${jdbc.password}" />

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource" ref="dataSource" />

<property name="configLocation">

<value>classpath:hibernate.cfg.xml</value>

</property>

<property name="configurationClass">

<value>org.hibernate.cfg.AnnotationConfiguration</value>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">${jdbc.dialect}</prop>

<prop key="hibernate.show_sql">true</prop>

</props>

</property>

</bean>

<tx:annotation-driven />

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory" />

</bean>

</beans>

Spring- servlet.xml文件中包含不同的The Spring ，如事务管理器，Hibernate会话的工厂bean，数据源等映射

jspViewResolver This bean -这个bean定义的视图解析器Spring MVC的。对于这个bean，我们也设置为”/ / WEB-INF/jsp”作为”。jsp”为后缀的前缀。因此The Spring 自动解析WEB-INF/jsp文件夹，并分配后缀JSP。JSP来。

messageSource bean -提供国际化，我们的演示应用程序中，我们定义束资源属性文件，要求在CLASSPATH中的messages.properties。在Spring MVC 相关：国际化

propertyConfigurer绿 bean -这个bean是用来装载数据库属性文件jdbc.properties。这是Hibernate中的连接设置使用的文件存储在数据库连接的详细信息。

数据源bean -这是Java的数据源连接到联系人管理器数据库。我们提供的JDBC驱动程序类，用户名，密码等配置。

SessionFactory的 bean -这是我们定义Hibernate配置不同的休眠设置。 hibernate.cfg.xml中设置一个配置文件，其中包含实体类的映射

TransactionManager的绿 bean -我们使用Hibernate事务管理器来管理我们的联系人管理器应用程序的交易。

文件：/ SRC /主要/资源/ hibernate.cfg.xml中

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

”-//Hibernate/Hibernate Configuration DTD//EN”

”http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

<hibernate-configuration>

<session-factory>

<mapping class=“net.viralpatel.contact.form.Contact” />

</session-factory>

</hibernate-configuration>

文件：/ src /主/资源/ messages_en.properties

label.firstname=First Name

label.lastname=Last Name

label.email=Email

label.telephone=Telephone

label.addcontact=Add Contact

label.menu=Menu

label.title=Contact Manager

label.footer=© ViralPatel.net

Spring MVC的控制器

我们几乎完成了我们的应用程序。只需添加下面的Spring控制器类ContactController.java net.viralpatel.contact.controller包。

文件：/ src /主/ JAVA / NET / viralpatel /联系我们/控制器/ ContactController.java

package net.viralpatel.contact.controller;

import java.util.Map;

import net.viralpatel.contact.form.Contact;

import net.viralpatel.contact.service.ContactService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.validation.BindingResult;

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

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

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

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

@Controller

public class ContactController {

@Autowired

private ContactService contactService;

@RequestMapping("/index")

public String listContacts(Map<String, Object> map) {

map.put("contact", new Contact());

map.put("contactList", contactService.listContact());

return "contact";

}

@RequestMapping(value = "/add", method = RequestMethod.POST)

public String addContact(@ModelAttribute("contact")

Contact contact, BindingResult result) {

contactService.addContact(contact);

return "redirect:/index";

}

@RequestMapping("/delete/{contactId}")

public String deleteContact(@PathVariable("contactId")

Integer contactId) {

contactService.removeContact(contactId);

return "redirect:/index";

}

}

The Spring 控制器定义了三种方法来操纵Contact Manager应用程序。

listContacts方法-该方法使用服务接口ContactServer来获取我们的应用程序中的所有详细联系方式。它返回一个接触数组。请注意，我们已经请求映射”/指数”，以这种方法。因此，Spring会自动调用此方法，每当遇到这个URL请求中。

addContact方法-这种方法增加了一个新的联系人，联系人列表。获取详细联系方式Contact使用对象@ModelAttribute注解。另外请注意，请求”/添加”映射使用此方法。请求的方法也应发表。在接触使用列表添加ContactService一旦接触，我们重定向到/索引页，再调用listContacts()方法以显示到用户的联系人列表。相关：在Spring MVC的表单

deleteContact方法-这种方法将删除从联系人列表中的联系人。类似的以这种方法也addContact重定向用户/索引页，一旦接触被删除。要注意在这个方法是我们所请求的URL映射使用@ RequestMapping注解的方式。网址”/ / {的ContactID}”映射因此，每当用户发送一个请求/ delete/12，删除，deleteCotact方法将尝试删除接触与ID：12。

最后添加下面的JSP文件到WEB-INF/jsp文件夹。

文件：/ SRC /主/ webapp的/ WEB - INF / JSP / contact.jsp

<%@taglib uri=“http://www.springframework.org/tags” prefix=“spring”%>

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

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

<html>

<head>

<title>Spring 3 MVC Series - Contact Manager | viralpatel.net</title>

</head>

<body>

<h2>Contact Manager</h2>

<form:form method=“post” action=“add.html” commandName=“contact”>

<table>

<tr>

<td><form:label path=“firstname”><spring:message code=“label.firstname”/></form:label></td>

<td><form:input path=“firstname” /></td>

</tr>

<tr>

<td><form:label path=“lastname”><spring:message code=“label.lastname”/></form:label></td>

<td><form:input path=“lastname” /></td>

</tr>

<tr>

<td><form:label path=“email”><spring:message code=“label.email”/></form:label></td>

<td><form:input path=“email” /></td>

</tr>

<tr>

<td><form:label path=“telephone”><spring:message code=“label.telephone”/></form:label></td>

<td><form:input path=“telephone” /></td>

</tr>

<tr>

<td colspan=“2”>

<input type=“submit” value=“<spring:message code=“label.addcontact”/>“/>

</td>

</tr>

</table>

</form:form>

<h3>Contacts</h3>

<c:if test=“${!empty contactList}”>

<table class=“data”>

<tr>

<th>Name</th>

<th>Email</th>

<th>Telephone</th>

<th> </th>

</tr>

<c:forEach items=“${contactList}” var=“contact”>

<tr>

<td>${contact.lastname}, ${contact.firstname} </td>

<td>${contact.email}</td>

<td>${contact.telephone}</td>

<td><a href=“delete/${contact.id}”>delete</a></td>

</tr>

</c:forEach>

</table>

</c:if>

</body>

</html>

下载源代码

点击这里下载Contact Manager应用程序的完整的源代码（16 KB ）

这是所有Folks

编译并执行在Eclipse中的联系人管理器应用程序。

在Spring3 MVC和Hibernate保存/ Retreving BLOB对象

使用BLOB / CLOB数据类型在数据库中的某个时候一个简单的任务。我发现，特别是与Hibernate 3的工作时，存储和检索BLOB对象，我们需要照顾的某些事情。让我们看到了一个教程，我们将使用Spring 3 MVC和Hibernate 3的存储和检索数据库中的BLOB对象。

我们的目标

我们的目标是创建一个在Spring3 MVC和Hibernate的文档管理应用程序。以下是功能。

与领域，如文件名称，描述和浏览按钮选择文件系统的文件的主要页面上显示窗体。

从本地驱动器，用户可以选择任何文件，并上传使用保存文件的功能相同。

添加的所有文件保存在一个数据库表。

目前数据库中的所有文件列表显示在主页上。

列表中的每个文件有两个按钮：删除和下载。

点击下载按钮，可以对任何文件下载。

点击删除按钮，可以删除任何文件。

这里是最后文件管理器应用程序的屏幕截图。

第1步：创建数据库表

文件管理器应用程序，我们将使用MySQL数据库。在MySQL数据库docdb中创建表文件。这是非常初步的例子，因此我们有最低的列代表一个文档。随意延长这个例子中，创建一个更复杂的应用程序。

CREATE DATABASE 'docdb';

USE 'docdb';

CREATE TABLE 'documents' (

'id' int(11) NOT NULL AUTO_INCREMENT,

'name' varchar(200) NOT NULL,

'description' text NOT NULL,

'filename' varchar(200) NOT NULL,

'content' mediumblob NOT NULL, /* for ORACLE enter BLOB*/

'content_type' varchar(255) NOT NULL,

'created' timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,

PRIMARY KEY ('id')

);

第2步：在Eclipse中创建Maven项目

文档管理器应用程序将使用Maven的构建和依赖管理。为此，我们将使用Eclipse中的Maven的动态Web项目作为我们的应用程序的基础架构。

或直接下载下面的源代码： Maven的动态Web项目（6.7 KB）

一旦导入/创建在Eclipse的Maven的Web项目。 Maven的pom.xml文件复制到以下内容。这些都是我们将使用我们的文件管理器应用程序的依赖关系。文件：/的pom.xml

<?xml version=“1.0” encoding=“UTF-8”?><project>

<modelVersion>4.0.0</modelVersion>

<groupId>MavenWeb</groupId>

<artifactId>MavenWeb</artifactId>

<packaging>war</packaging>

<version>0.0.1-SNAPSHOT</version>

<description></description>

<build>

<plugins>

<plugin>

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

<configuration>

<source>1.5</source>

<target>1.5</target>

</configuration>

</plugin>

<plugin>

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

<version>2.0</version>

</plugin>

</plugins>

</build>

<dependencies>

<dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<version>2.5</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>${org.springframework.version}</version>

</dependency>

<dependency>

<groupId>taglibs</groupId>

<artifactId>standard</artifactId>

<version>1.1.2</version>

</dependency>

<dependency>

<groupId>javax.servlet</groupId>

<artifactId>jstl</artifactId>

<version>1.1.2</version>

</dependency>

<dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-entitymanager</artifactId>

<version>3.3.2.ga</version>

</dependency>

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>5.1.10</version>

</dependency>

<dependency>

<groupId>commons-dbcp</groupId>

<artifactId>commons-dbcp</artifactId>

<version>20030825.184428</version>

</dependency>

<dependency>

<groupId>commons-pool</groupId>

<artifactId>commons-pool</artifactId>

<version>1.5.4</version>

</dependency>

<dependency>

<groupId>commons-fileupload</groupId>

<artifactId>commons-fileupload</artifactId>

<version>1.2.1</version>

</dependency>

<dependency>

<groupId>commons-io</groupId>

<artifactId>commons-io</artifactId>

<version>1.3</version>

</dependency>

</dependencies>

<properties>

<org.springframework.version>3.0.2.RELEASE</org.springframework.version>

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

</properties>

</project>

解压缩到您的硬盘驱动器和源代码导入Eclipse项目。一旦该项目是在Eclipse中导入，我们将创建一个Java源代码的包结构。首先重命名项目DocumentManager和src /主/ Java的文件夹下创建以下包。

net.viralpatel.docmanager.controller -这个包将包含文件管理器应用程序的Spring控制器类。

net.viralpatel.docmanager.model -这个包将包含文件管理器应用程序的表单对象。文档模型，将具有不同属性，如文件名称，说明，文件名等简单的POJO类

net.viralpatel.docmanager.dao -这是文件管理器应用程序的DAO层。它由DocumentDao类将使用Hibernate API来与数据库交互。

在 src /主要/资源文件夹，将Hibernate配置文件：hibernate.cfg.xml中。

在WEB - INF文件夹中的 JSP / documents.jsp文件呈现文档列表和添加形式和jdbc.properties文件，其中包含数据库连接配置。此外，它包含The Spring - servlet.xml中，将定义所有的控制器类和 web.xml包含Spring配置。

实体类 - Hibernate的模型类

让我们先从文件管理器应用程序的编码。首先，我们将创建一个模型对象或Hibernate的POJO类来存储文件中的信息。这个类将是一个实体类，将文件，数据库表链接。

创建一个Java类Document.java net.viralpatel.docmanager.model包和复制下面的代码下。文件：/ src /主/ JAVA / NET / viralpatel / docmanager /模型/ Document.java

package net.viralpatel.docmanager.model;

import java.sql.Blob;

import java.sql.Date;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Lob;

import javax.persistence.Table;

@Entity

@Table(name="documents")

public class Document {

@Id

@GeneratedValue

@Column(name="id")

private Integer id;

@Column(name="name")

private String name;

@Column(name="description")

private String description;

@Column(name="filename")

private String filename;

@Column(name="content")

@Lob

private Blob content;

@Column(name="content_type")

private String contentType;

@Column(name="created")

private Date created;

//Getter and Setter methods

}

你会注意到的第一件事情是，import语句导入javax.persistence，而不是一个Hibernate或者Spring包。与Spring中使用Hibernate，标准的JPA注解很好的工作，这就是我这里使用。

首先，我们已经注明@Entity实体，它告诉Hibernate这个类表示一个对象，我们可以坚持。

@Table(name = “documents”)注解告诉Hibernate的表映射在这个类的属性文件表。在这一类在第20行的第一个属性是我们的对象ID将是独一无二的，持续的所有事件。这是为什么我们带有@Id 。

@GeneratedValue批注说，这个值将确定源代码。

@Column(name = “filename”)注释是使用这个属性映射到DOCUMENTS表中的文件名列。

数据访问（DAO）层

文件管理器应用程序的DAO层组成的一类DocumentDAO。理想的解决方案将创建一个接口（DocumentDAO）和其相应的实现类DocumentDAOImpl。但为简单起见，我们将创建只是正常的DAO类DocumentDAO.java。

文件：src /主/ JAVA / NET / viralpatel / docmanager / DAO / DocumentDAO.java

package net.viralpatel.docmanager.dao;

import java.util.List;

import net.viralpatel.docmanager.model.Document;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

@Repository

public class DocumentDAO {

@Autowired

private SessionFactory sessionFactory;

@Transactional

public void save(Document document) {

Session session = sessionFactory.getCurrentSession();

session.save(document);

}

@Transactional

public List<Document> list() {

Session session = sessionFactory.getCurrentSession();

List<Document> documents = null;

try {

documents = (List<Document>)session.createQuery(“from Document”).list();

} catch (HibernateException e) {

e.printStackTrace();

}

return documents;

}

@Transactional

public Document get(Integer id) {

Session session = sessionFactory.getCurrentSession();

return (Document)session.get(Document.class, id);

}

@Transactional

public void remove(Integer id) {

Session session = sessionFactory.getCurrentSession();

Document document = (Document)session.get(Document.class, id);

session.delete(document);

}

}

方法：

list（）方法-该方法获取存储在文件表中的所有文件的列表，并返回一个Document对象名单。

save（）方法-该方法是使用数据库存储到一个新的文档（包括BLOB）。

get（）方法-该方法返回一个给定的ID从数据库文档的条目。下载功能，用于从数据库中存储的文件下载。

remove（）方法-该方法是使用一个特定的ID从数据库中删除的文件。

请注意，我们已经使用了两个@Repository @ @Autowired Autowired进行。带注释的标记类是由Spring使用基于注解的配置和Classpath扫描时，自动检测的候选人。 @Component注解是主要的刻板印象，表明一个被注解的类是一个”组件”。

@Repository注解，另一个是在Spring 2.0中引入的刻板印象。这个注解是用来表明，作为一个仓库一类的功能和需要有异常转换应用透明就可以了。异常翻译的好处是，服务层只有从Spring的DataAccessException体系的例外处理，即使使用纯JPA的DAO类。

在DocumentDAO使用的另一种注解@Autowired 。这是用来自动装配DocumentDAO SessionFactory的依赖。

另外请注意，我们每个方法使用@ Transactional注解。理想情况下，DAO层是从一个服务层和事务管理的需要，在服务层指定的访问。但同样为简单起见，我们将不包括在我们的例子中的服务层，直接调用DAO层从Spring控制器。再次，随意改变的执行情况，并添加您自己的服务层之间。

在Spring MVC和Hibernate的分层应用与服务的更多信息，阅读本教程。 Spring MVC的休眠Maven的例子

Spring MVC的支持添加到WebApplication的

让我们添加到我们的Web应用程序的Spring MVC的支持。更新web.xml文件，并添加org.springframework.web.servlet.DispatcherServlet servlet映射。另外请注意，我们已制订与URL / springServlet，所以所有的请求处理的Spring。

文件：/ src目录/ webapp的/ WEB - INF目录/ web.xml中

<?xml version=“1.0” encoding=“UTF-8”?>

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

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

xmlns:web=“http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”

xsi:schemaLocation=“http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
id=“WebApp_ID” version=“2.5”>

<display-name>DocumentManager</display-name>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

</welcome-file-list>

<servlet>

<servlet-name>spring</servlet-name>

<servlet-class>

org.springframework.web.servlet.DispatcherServlet

</servlet-class>

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

</servlet>

<servlet-mapping>

<servlet-name>spring</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

一旦在web.xml配置，让我们在/ src目录/主/ webapp的/ WEB - INF文件夹中添加- servlet.xml的Spring和jdbc.properties文件。

文件：/ SRC /主/ webapp的/ WEB - INF目录/ jdbc.properties

jdbc.driverClassName= com.mysql.jdbc.Driver

jdbc.dialect=org.hibernate.dialect.MySQLDialect

jdbc.databaseurl=jdbc:mysql://localhost:3306/docdb

jdbc.username=root

jdbc.password=password

jdbc.properties文件包含数据库连接信息，例如数据库URL，用户名，密码，驱动程序类。如果你不使用MySQL，你可能要编辑的DriverClass和其他数据库的方言。

文件：/ SRC /主/ webapp的/ WEB - INF /Spring- 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:aop=“http://www.springframework.org/schema/aop”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:jee=“http://www.springframework.org/schema/jee”

xmlns:lang=“http://www.springframework.org/schema/lang”

xmlns:p=“http://www.springframework.org/schema/p”

xmlns:tx=“http://www.springframework.org/schema/tx”

xmlns:util=“http://www.springframework.org/schema/util”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

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

http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd

http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd”>

<context:annotation-config />

<context:component-scan base-package=“net.viralpatel.docmanager” />

<bean id=“jspViewResolver”

class=“org.springframework.web.servlet.view.InternalResourceViewResolver”>

<property name=“viewClass”

value=“org.springframework.web.servlet.view.JstlView” />

<property name=“prefix” value=“/WEB-INF/jsp/” />

<property name=“suffix” value=“.jsp” />

</bean>

<bean id=“propertyConfigurer”

class=“org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”

p:location=“/WEB-INF/jdbc.properties” />

<bean id=“dataSource”

class=“org.apache.commons.dbcp.BasicDataSource” destroy-method=“close”

p:driverClassName=“${jdbc.driverClassName}”

p:url=“${jdbc.databaseurl}” p:username=“${jdbc.username}”

p:password=“${jdbc.password}” />

<bean id=“sessionFactory”

class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>

<property name=“dataSource” ref=“dataSource” />

<property name=“configLocation”>

<value>classpath:hibernate.cfg.xml</value>

</property>

<property name=“configurationClass”>

<value>org.hibernate.cfg.AnnotationConfiguration</value>

</property>

<property name=“hibernateProperties”>

<props>

<prop key=“hibernate.dialect”>${jdbc.dialect}</prop>

<prop key=“hibernate.show_sql”>true</prop>

<prop key=“hibernate.connection.SetBigStringTryClob”>true</prop>

<prop key=“hibernate.jdbc.batch_size”>0</prop>

</props>

</property>

</bean>

<bean id=“multipartResolver”

class=“org.springframework.web.multipart.commons.CommonsMultipartResolver”>



<property name=“maxUploadSize” value=“10000000” />

</bean>

<tx:annotation-driven />

<bean id=“transactionManager”

class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>

<property name=“sessionFactory” ref=“sessionFactory” />

</bean>

</beans>

Spring- servlet.xml文件中包含不同的The Spring ，如事务管理器，Hibernate会话的工厂bean，数据源等映射

jspViewResolver绿 bean -这个bean定义的视图解析器Spring MVC的。对于这个bean，我们也设置为”/ / WEB-INF/jsp”作为”。jsp”为后缀的前缀。因此The Spring 自动解析WEB-INF/jsp文件夹，并分配后缀JSP。JSP来。

propertyConfigurer绿 bean -这个bean是用来装载数据库属性文件jdbc.properties。这是Hibernate中的连接设置使用的文件存储在数据库连接的详细信息。

数据源bean -这是Java的数据源连接到文档管理数据库。我们提供的JDBC驱动程序类，用户名，密码等配置。

SessionFactory的 bean -这是我们定义Hibernate配置不同的休眠设置。 hibernate.cfg.xml中设置一个配置文件，其中包含实体类映射。另外请注意，在SessionFactory的，我们有指定的几个Hibernate的属性， hibernate.connection.SetBigStringTryClob hibernate.connection.SetBigStringTryClob hibernate.jdbc.batch_size hibernate.jdbc.batch_size
。这些是用来在Hibernate配置将BLOB / CLOB设置。

的MultipartResolver绿 bean -我们使用Spring MVCS CommonsMultipartResolver。这个解析器将请求解决多重形式的数据，如文件上传和Spring控制器提供的文件对象。请注意，我们有指定maxUploadSize属性maxUploadSize，价值千万。这是在我们的例子中可以上传最大的文件大小限制。

TransactionManager的绿 bean -我们使用Hibernate事务管理器来管理我们的文件管理器应用程序的交易。

文件：/ SRC /主要/资源/ hibernate.cfg.xml中

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<mapping class="net.viralpatel.docmanager.model.Document" />

</session-factory>

</hibernate-configuration>

控制器 - Spring MVC控制器类

我们几乎完成了我们的应用程序。只需添加下面的Spring控制器类DocumentController.java net.viralpatel.docmanager.controller包。

文件：/ src /主/ JAVA / NET / viralpatel / docmanager /控制器/ DocumentController.java

package net.viralpatel.docmanager.controller;

import java.io.IOException;

import java.io.OutputStream;

import java.sql.Blob;

import java.sql.SQLException;

import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import net.viralpatel.docmanager.dao.DocumentDAO;

import net.viralpatel.docmanager.model.Document;

import org.apache.commons.io.IOUtils;

import org.hibernate.Hibernate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

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

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.RequestParam;

import org.springframework.web.multipart.MultipartFile;

@Controller

public class DocumentController {

@Autowired

private DocumentDAO documentDao;

@RequestMapping(“/index”)

public String index(Map<String, Object> map) {

try {

map.put(“document”, new Document());

map.put(“documentList”, documentDao.list());

}catch(Exception e) {

e.printStackTrace();

}

return “documents”;

}

@RequestMapping(value = “/save”, method = RequestMethod.POST)

public String save(

@ModelAttribute(“document”) Document document,

@RequestParam(“file”) MultipartFile file) {

System.out.println(“Name:” + document.getName());

System.out.println(“Desc:” + document.getDescription());

System.out.println(“File:” + file.getName());

System.out.println(“ContentType:” + file.getContentType());

try {

Blob blob = Hibernate.createBlob(file.getInputStream());

document.setFilename(file.getOriginalFilename());

document.setContent(blob);

document.setContentType(file.getContentType());

} catch (IOException e) {

e.printStackTrace();

}

try {

documentDao.save(document);

} catch(Exception e) {

e.printStackTrace();

}

return “redirect:/index.html”;

}

@RequestMapping(“/download/{documentId}”)

public String download(@PathVariable(“documentId”)

Integer documentId, HttpServletResponse response) {

Document doc = documentDao.get(documentId);

try {

response.setHeader(“Content-Disposition”, “inline;filename=\”“ +doc.getFilename()+ “\”“);

OutputStream out = response.getOutputStream();

response.setContentType(doc.getContentType());

IOUtils.copy(doc.getContent().getBinaryStream(), out);

out.flush();

out.close();

} catch (IOException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

return null;

}

@RequestMapping(“/remove/{documentId}”)

public String remove(@PathVariable(“documentId”)

Integer documentId) {

documentDao.remove(documentId);

return “redirect:/index.html”;

}

}

The Spring 控制器定义了四个方法来操作文件管理器应用程序。

索引方法-该方法使用列表（）DocumentDAO的方法来获取从数据库中的所有文件的列表。请注意，我们已经请求映射”/指数”，以这种方法。因此，Spring会自动调用此方法，每当遇到这个URL请求中。

保存方法-这种方法增加了一个新的文件，文件清单。获取该文件的细节，在文档中使用@ModelAttribute @ ModelAttribute注解。另外请注意，请求”/保存”，用这种方法映射。请求的方法也应发表。一旦该文件是在文件列表中添加，我们重定向到/ index.html页面，这反过来又调用index（）方法来显示文件列表给用户。还有一点需要注意的是@RequestParam 。我们MultipartFile对象使用@ RequestParam（”文件”）注释映射。 Spring自动检测要求”文件”的数据和地图MultipartFile对象。
这个对象是后来转换为BLOB对象，并在文件的内容设置。相关：在Spring MVC的表单

下载方法-这种方法是用来下载所选的测试用例。请注意，我们是从数据库使用DAO类和THN设置响应的数据流中获取文件的内容。另外请注意，我们使用response.setHeader()方法来设置”Content-Disposition” 。这将提高在浏览器中的另存为对话框，当用户尝试下载文件。

删除的方法-这种方法从文件清单中删除的文件。类似的save（）这个方法也重定向用户/ index.html页面，一旦该文件被删除。在此方法中需要注意的一点是我们所请求的URL映射使用@ RequestMapping注解的方式。网址”/删除/ {documentId}”映射从而每当用户发送一个请求/ remove/12.html，remove方法将尝试删除与身份证件：12。

最后添加下面的JSP文件到WEB-INF/jsp文件夹。文件：/ SRC /主/ webapp的/ WEB - INF / JSP / documents.jsp

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

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

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

<html>

<head>

<title>Document Manager - viralpatel.net</title>

</head>

<body>

<h2>Document Manager</h2>

<h3>Add new document</h3>

<form:form method="post" action="save.html" commandName="document" enctype="multipart/form-data">

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

<table>

<tr>

<td><form:label path="name">Name</form:label></td>

<td><form:input path="name" /></td>

</tr>

<tr>

<td><form:label path="description">Description</form:label></td>

<td><form:textarea path="description" /></td>

</tr>

<tr>

<td><form:label path="content">Document</form:label></td>

<td><input type="file" name="file" id="file"></input></td>

</tr>

<tr>

<td colspan="2">

<input type="submit" value="Add Document"/>

</td>

</tr>

</table>

</form:form>

<br/>

<h3>Document List</h3>

<c:if test="${!empty documentList}">

<table class="data">

<tr>

<th>Name</th>

<th>Description</th>

<th> </th>

</tr>

<c:forEach items="${documentList}" var="document">

<tr>

<td width="100px">${document.name}</td>

<td width="250px">${document.description}</td>

<td width="20px">

<a href="${pageContext.request.contextPath}/download/${document.id}.html"><img

src="${pageContext.request.contextPath}/img/save_icon.gif" border="0"

title="Download this document"/></a>

<a href="${pageContext.request.contextPath}/remove/${document.id}.html"

onclick="return confirm('Are you sure you want to delete this document?')"><img

src="${pageContext.request.contextPath}/img/delete_icon.gif" border="0"

title="Delete this document"/></a>

</td>

</tr>

</c:forEach>

</table>

</c:if>

</body>

</html>

下载源代码

点击这里下载完整的源代码文件管理器应用程序（16 KB）

这是所有Folks

编译并执行文件管理器应用程序在Eclipse。打开网址http://localhost:8080/DocumentManager/index.html

　　另见：

Spring3 MVC：在Spring 3.0 MVC的处理形式

教程：创建Spring3 MVC Hibernate 3的示例在Eclipse中使用Maven的

Spring3例Spring教程MVC：主题

Spring3 MVC：国际化和本地化教程示例

Spring3 MVC：Tiles Support与示例插件在Eclipse教程

Spring3 MVC：在Spring 3.0 MVC创建Hello World应用程序

如何实现主/详细信息的形式，使用Spring Roo的

教程：在Spring3 MVC和Hibernate保存/ Retreving BLOB对象

以上翻译来自：
http://viralpatel.net/blogs/2010/06/tutorial-spring-3-mvc-introduction-spring-mvc-framework.html
Spring Roo的：两个数据库配置

我见过很多时候，一个Spring Roo的论坛经常问题。现在的问题是”如何配置应用程序来处理这两个数据库”。

当然，这是一个更充裕的Spring Roo的问题，由于它涉及JPA和Spring的持久性堆栈。所以，我相信这将是所有的Spring开发的社会，面对这样的问题感兴趣。

我假设读者是一些与Spring Roo的familarity的Java开发。我将重点讨论如何去配置只。对于如何使用Roo的帮助，请访问http://www.springsource.org/roo 。

Hands on the problem

我创建了解释设置以下最低Roo的项目（如图所示）。我将修改的方式，每个实体将来自不同的独立的数据库配置。

project --topLevelPackage org.pragmatikroo.twodb

persistence setup --provider HIBERNATE --database MYSQL --userName <username> --password <password> --databaseName twodbone

logging setup --level DEBUG --package PERSISTENCE

entity --class ~.domain.DbOne

field string --fieldName name

entity --class ~.domain.DbTwo

field string --fieldName name

perform clean

perform eclipse

exit

Database.properties文件的原始

database.password=<password>

database.url=jdbc\:mysql\://localhost\:3306/twodb

database.username=<username>

database.driverClassName=com.mysql.jdbc.Driver

Database.properties文件的修改

database.password1=<password1>

database.url1=jdbc\:mysql\://localhost\:3306/twodbone

database.username1=<username1>

database.password2=<password1>

database.url2=jdbc\:mysql\://localhost\:3306/twodbtwo

database.username2=<username2>

database.driverClassName=com.mysql.jdbc.Driver

基本上，我有重复的代码，从袋鼠交付定义第二个数据库的原始文件。这种模式将重复以及其他文件。

修改persistence.xml文件

<persistence-unit name=“persistenceUnit1” transaction-type=“RESOURCE_LOCAL”>

<provider>org.hibernate.ejb.HibernatePersistence</provider>

<class>org.josean.twodb.domain.DbOne</class>

<exclude-unlisted-classes>true</exclude-unlisted-classes>

<properties>

<property name=“hibernate.dialect” value=“org.hibernate.dialect.MySQL5InnoDBDialect”/>



<property name=“hibernate.hbm2ddl.auto” value=“update”/>

<property name=“hibernate.ejb.naming_strategy” value=“org.hibernate.cfg.ImprovedNamingStrategy”/>

<property name=“hibernate.connection.charSet” value=“UTF-8”/>







</properties>

</persistence-unit>

<persistence-unit name=“persistenceUnit2” transaction-type=“RESOURCE_LOCAL”>

<provider>org.hibernate.ejb.HibernatePersistence</provider>

<class>org.josean.twodb.domain.DbTwo</class>

<exclude-unlisted-classes>true</exclude-unlisted-classes>

<properties>

<property name=“hibernate.dialect” value=“org.hibernate.dialect.MySQL5InnoDBDialect”/>



<property name=“hibernate.hbm2ddl.auto” value=“update”/>

<property name=“hibernate.ejb.naming_strategy” value=“org.hibernate.cfg.ImprovedNamingStrategy”/>

<property name=“hibernate.connection.charSet” value=“UTF-8”/>







</properties>

</persistence-unit>

我第二个数据库的持久化单元的代码复制并定义唯一的ID 重要：添加<class>和<exclude-unlisted-classes>在上面的代码所示。暗示这个持久化单元处理的每个实体都包括在内。

applicationContext.xml文件修改

<bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource1">

<property name="driverClassName" value="${database.driverClassName}"/>

<property name="url" value="${database.url1}"/>

<property name="username" value="${database.username1}"/>

<property name="password" value="${database.password1}"/>

<property name="validationQuery" value="SELECT 1 FROM DUAL"/>

<property name="testOnBorrow" value="true"/>

</bean>

<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory1">

<property name="dataSource" ref="dataSource1"/>

<property name="persistenceUnitName" value="persistenceUnit1"/>

</bean>

<tx:annotation-driven mode="aspectj" transaction-manager="transactionManager1" />

<bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager1">

<property name="entityManagerFactory" ref="entityManagerFactory1" />

</bean>

<bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource2">

<property name="driverClassName" value="${database.driverClassName}"/>

<property name="url" value="${database.url2}"/>

<property name="username" value="${database.username2}"/>

<property name="password" value="${database.password2}"/>

<property name="validationQuery" value="SELECT 1 FROM DUAL"/>

<property name="testOnBorrow" value="true"/>

</bean>

<bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager2">

<property name="entityManagerFactory" ref="entityManagerFactory2"/>

</bean>

<tx:annotation-driven mode="aspectj" transaction-manager="transactionManager2" />

<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory2">

<property name="dataSource" ref="dataSource2"/>

<property name="persistenceUnitName" value="persistenceUnit2"/>

</bean>

同一进程的其他文件。重复的，如图所示。添加属性的entityManagerFactory的 bean 。

修改web.xml文件

<filter>

<filter-name>Spring OpenEntityManagerInViewFilter1</filter-name>

<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>

<init-param>

<param-name>entityManagerFactoryBeanName</param-name>

<param-value>entityManagerFactory1</param-value>

</init-param>

</filter>

<filter>

<filter-name>Spring OpenEntityManagerInViewFilter2</filter-name>

<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>

<init-param>

<param-name>entityManagerFactoryBeanName</param-name>

<param-value>entityManagerFactory2</param-value>

</init-param>

</filter>

这就是它！。部署和测试应用就绪。

结论

我比较有兴趣的读者，特别是Spring Roo的开发人员，如何设置一个Spring的web应用程序来访问第二个数据库的应用程序上下文。

Spring Roo的自定义Web MVC用户界面的形式

还有，我喜欢从Spring Roo的许多功能：

外壳是非常有效的一个有用的标签完成建设项目

往返是必不可少的，以保持同步代码

没有”不必要的抽象”代码生成令人耳目一新，虽然1.1.2版本可能会带来一些他们只是仅举几例。

在列表的顶部，我把，我考虑的宝石冠：Tagx库JSP（X）的意见。本文假定读者熟悉Spring Roo的一些。对于Spring Roo的更多信息，请访问其网站http://www.springsource.org/roo。

简而言之Tagx图书馆

tagx库是由Web MVC安装附加。 Spring Roo的支架控制器和实体类的意见。点击创建从tagx库的组件。请阅读参考文件http://static.springsource.org/spring-roo/reference/html/base-web.html一个完整的描述。

事不宜迟。迷你型业务。

本文指的是在世界年鉴实施JD网站的形式。世界年鉴是一个创建Web应用程序与Spring Roo的发展实验组的成员。展示网站的链接 https://pragmatikroo.org/showcases 。的目的，是落实典型的Web的CRUD范围以外的发展要求。

这是工作的问题：我需要自定义list.tagx的组件来呈现国家的国旗图像。通常，此组件呈现一个网格内的字符串和数字。轻松导航的形式将分页，如下图所示。此功能提供了一个世界年鉴广场查看，此外，我要附加导航到一个国家的详细信息页面的点击事件。

的形式提供了两种选择控制，使县过滤。分页的形式和导航一个典型的list.jspx形式是相同的方式。通常情况下，Roo的选择按钮与动作按钮。在这种情况下，我删除和过滤作用是触发选择选择。我没有从头开始。我只是调整Roo的生成的源代码。袋鼠是伟大的！。

分页画廊表

下面是呈现标志国家画廊查看源代码。这里有很多的定制。但是你仍然可以看到原支架Roo的创建形式的骨架。

画廊JSPX分页代码

<?xml version=“1.0” encoding=“UTF-8” standalone=“no”?>

<div xmlns:jsp=“http://java.sun.com/JSP/Page”

xmlns:page=“urn:jsptagdir:/WEB-INF/tags/form”

xmlns:table=“urn:jsptagdir:/WEB-INF/tags/form/fields” version=“2.0”

xmlns:field=“urn:jsptagdir:/WEB-INF/tags/form/fields”

xmlns:form=“urn:jsptagdir:/WEB-INF/tags/form”

xmlns:fn=“http://java.sun.com/jsp/jstl/functions”>

<script type=“text/javascript”>

<![CDATA[

function selectIt( aName ){

var selectContinentPage=“/worldAlmanac/countrys”;

document.body.innerHTML = '<form id=“dynForm” action='+

selectContinentPage+

' method=“get”>'+

'<input type=“hidden” name=“find” value=“gallery” />'+

'<input type=“hidden” name=“\page” value=“1” />'+

'<input type=“hidden” name=“\size” value=“50” />'+

'<input type=“hidden” name=“'+aName.name+'“ value=“'+aName.value+'“ />'+

'</form>';

document.getElementById(“dynForm”).submit();

}

]]>

</script>

<jsp:output omit-xml-declaration=“yes” />

<div id=“wrapperTop”>

<input name=“btnBack” title=“Previous Page”

onMouseOver=“window.status='Previous Page'; return true”

onMouseOut=“window.status=''; return true”

onclick=“location.href = '/worldAlmanac'“

type=“button” value=“Previous Page”/>

</div>

<page:list id=“pl:org.josean.rooworld.domain.Country”

items=“${countrys}”>

<div>

<div style=“float: left; width: 60%;”>

<field:select disableFormBinding=“true”

id=“f:org.josean.rooworld.domain.Country.continent”

items=“${continent}”

field=“continent”

path=“/countrys”

onchange=“selectIt(this);”/>

</div>

<div>

<field:select disableFormBinding=“true”

id=“f:org.josean.rooworld.domain.Country.region”

items=“${region}”

field=“region”

path=“/countrys”

onchange=“selectIt(this);” />

</div>

</div>

<table:gallery data=“${countrys}”

id=“l:org.josean.rooworld.domain.Country” path=“/countrys”

title=“Click on image to select country info” page=“${page}” size=“${size}”

typeIdFieldName=“code” pageid=“page” sizeid=“size” delete=“false”

update=“false” create=“false” select=“false” show=“false”

anchorURL=“/countrys?find=gallery”>

<table:column id=“c:org.josean.rooworld.domain.Country.code”

type=“img” property=“code” />

</table:gallery>

</page:list>

<script type=“text/javascript”>

<![CDATA[

function applyStateControl(aControl, anItem){

var option = aControl.getElementsByClassName(“HTMLOptionElement”);

for( i=0; i<aControl.options.length;i++){

if(aControl.options.item(i).value==anItem)

break;

}

aControl.options.item(i).defaultSelected=true;

}

var selectedItem= window.location.search;

var cIndex = selectedItem.indexOf(“continent”);

var rIndex = selectedItem.indexOf(“region”);

if(cIndex>-1){

var continent= selectedItem.substring( cIndex+10, selectedItem.length);

var control = document.getElementById(“_continent_id”);

applyStateControl(control, continent);

}

else if (rIndex>-1){

var region= selectedItem.substring( rIndex+7, selectedItem.length);

var control = document.getElementById(“_region_id”);

applyStateControl(control, region);

}

]]>

</script>

</div>

接下来，我将向国家详细表格后，点击其国旗航行。 WorldAlmanac集成以及容易谷歌地图。这使得国家的地图，使用其存储在数据库中的纬度/经度。所有元素，共同创造一个很好的组合。

详细的国家表

详细的国家JSPX代码

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

<div

xmlns:field="urn:jsptagdir:/WEB-INF/tags/form/fields"

xmlns:jsp="http://java.sun.com/JSP/Page"

xmlns:page="urn:jsptagdir:/WEB-INF/tags/form"

version="2.0"

xmlns:spring="http://www.springframework.org/tags"

xmlns:c="http://java.sun.com/jsp/jstl/core">

<jsp:output omit-xml-declaration="yes" />

<spring:url

value="http://maps.google.com/maps/api/js?sensor=false"

var="google_map_url" />

<spring:url

value="/static/js/googleMap.js"

var="tmp_map_url" />

<c:set

var="map_url"

value="uri:/${tmp_map_url}" />

<script

type="text/javascript"

src="${google_map_url}">

</script>

<script

src="${tmp_map_url}"

type="text/javascript">

</script>

<page:show

id="ps:org.josean.rooworld.domain.Country"

object="${country}"

z="3tU6/DN2doNWT+sTLgEAZR7U8hk=">

<table

width="100%;">

<tr>

<td

width="50%">

<field:display

field="code"

id="s:org.josean.rooworld.domain.Country.code"

object="${country}"

type="img"

z="?"

label="Flag" />

<field:display

field="name"

id="s:org.josean.rooworld.domain.Country.name"

object="${country}"

z="FAyyuD7aX42uNNgL4e7tS//taRI=" />

<field:display

field="continent"

id="s:org.josean.rooworld.domain.Country.continent"

object="${country}"

z="fSpvsKUctolI0akJTZzYHoOwueo=" />

<field:display

field="region"

id="s:org.josean.rooworld.domain.Country.region"

object="${country}"

z="z7xfg8bZs8LFPftHWVjP45HdpGI=" />

<field:display

field="surfaceArea"

id="s:org.josean.rooworld.domain.Country.surfaceArea"

object="${country}"

z="7C7ri5E3jCruBij5X5iEJqh4g1k=" />

<field:display

field="indepYear"

id="s:org.josean.rooworld.domain.Country.indepYear"

object="${country}"

z="EZL1ubZ/J9SiMbCUfokjr1OoDKA=" />

<field:display

field="population"

id="s:org.josean.rooworld.domain.Country.population"

object="${country}"

z="kqB3gvDWozV4lRD2m/S/6tpw2rE=" />

<field:display

field="lifeExpectancy"

id="s:org.josean.rooworld.domain.Country.lifeExpectancy"

object="${country}"

z="6Sj9b9rtuCZd1V5oNnz7gmAaQkI=" />

<field:display

field="gnp"

id="s:org.josean.rooworld.domain.Country.gnp"

object="${country}"

z="cQC9QwBNccJoYP9+xn4nAakFVVk=" />

<field:display

field="gnpold"

id="s:org.josean.rooworld.domain.Country.gnpold"

object="${country}"

z="AKqXyf8qWGWBU0HwUSIvnnLzZeE=" />

<field:display

field="localName"

id="s:org.josean.rooworld.domain.Country.localName"

object="${country}"

z="jYwa2XCaRe58W9ae45HLAaLlt7A=" />

<field:display

field="govermentForm"

id="s:org.josean.rooworld.domain.Country.govermentForm"

object="${country}"

z="N9WckigFkEM6lBgGaHR3QG13Lq4=" />

<field:display

field="capital"

id="s:org.josean.rooworld.domain.Countr
d3c7
y.capital"

object="${country}"

z="JRQSSvwHoOt1d2yff5JeK7NDn0k=" />

<field:display

field="code2"

id="s:org.josean.rooworld.domain.Country.code2"

object="${country}"

z="gIR7Z72tUJCdEBJHExd4FLG1ze0=" />

<field:display

field="headofState"

id="s:org.josean.rooworld.domain.Country.headofState"

object="${country}"

z="EmNqI9StH4djy7tAZsVKe3+VJ+A=" />

<field:display

field="latitude"

id="s:org.josean.rooworld.domain.Country.latitude"

object="${country}"

z="?" />

<field:display

field="longitude"

id="s:org.josean.rooworld.domain.Country.longitude"

object="${country}"

z="?" />

<page:find

reportParam="${country.code}"

path="/pdf/countryReport"

id="c:report"

buttonLabel="Pdf Report" />

</td>

<td>

<div

id="map_canvas"

style="width: 400px; height: 550px;">

<button

onclick="initialize();">Show Map</button>

</div>

</td>

</tr>

</table>

</page:show>

</div>

这就是它！

结论

本文展示了一个定制的例子，使用最初创建由Spring Roo的Web MVC的附加脚手架开始的代码。我发现极具表现力和直观的JSPX符号。 tagx库充裕，很容易扩展如果需要的话。 JSPX XML文档，因此，他们对健康验证。我不得不说这开始感到厌烦我，而是很短的时间后，我习惯了，并开始喜欢它。且不说形式错误检查的好处。

Spring Roo的Web MVC的意见和他们的禁忌部分大量基于JavaScript和Ajax的交互式少。不过，我相信他们是在不同的Web开发项目和大量的市场，他们非常有用。读者可以看到，外观和感觉一个Roo的创建应用程序可以完全改变，以满足任何UI /网页设计要求。此代码示例创建Spring Roo的1.1.0.M1。

以上翻译:
http://viralpatel.net/blogs/2011/02/spring-roo-customizing-web-mvc-ui-forms.html
其他参考：
http://viralpatel.net/blogs/2011/02/spring-roo-save-read-blob-object-spring-roo-tutorial.html http://viralpatel.net/blogs/2011/01/spring-roo-implement-masterdetail-forms.html
Spring 3.0新增特性与功能前瞻(1)

Java SE与Java EE支持

现在的Spring Framework基于Java 5，并且完全支持Java 6。而且，它兼容J2EE 1.4及Java EE 5，同时还引入了一些对Java EE 6的早期支持。

1、Java 5

为了利用Java 5特性，例如泛型、可变参数和其他语言改进，整个框架的代码都被修改过了。我们尽可能地保证代码能够向后兼容。我们现在一致使用的泛型 Collection和Map，一致使用泛型FactoryBean，并且在Spring AOP API中有一致的桥接方法解析。泛型ApplicationListener只会自动接收特定的事件类型。所有的回调接口，例如 TransactionCallback和HibernateCallback，可以声明泛型结果值了。总而言之，Spring的核心代码经过了彻底的修改，并为Java
5做了优化。

为了与Java 5的java.util.concurrent机制紧密结合，Spring的TaskExecutor抽象也被修改过了。我们为Callable和 Future提供了一流的支持，还有ExecutorService适配器、ThreadFactory集成等等。这些特性都尽可能与JSR- 236（Concurrency Utilities for Java EE 6）保持一致。此外，针对通过新的@Async注解（或者EJB 3.1的@Asynchronous注解）进行异步方法调用，我们也提供了相应的支持。

2、改进的文档

Spring的参考文档也不断被更新着，这样它才能完整地反映Spring 3.0的变化和新特性。尽管我们进了一切努力不在文档中犯错，但还是有些漏网之鱼。如果你发现了一些拼写错误或者更严重的错误，并能在午餐时挤出点时间的话，请将这些错误告诉Spring团队，提个事件就可以了。

3、新的入门教程

现在有了一份新的开发基础Spring 3.0 MVC Web应用程序的教程。这个教程是一份独立的文档，你能在Spring Documentation 页面中找到它。

注意：要到Spring 3.0正式发布时才能获得该文档。 4、新的模块组织结构和构建系统

我们修改了框架的模块，并用每个模块jar一棵源码树的方式分别进行管理：

• org.springframework.aop• org.springframework.beans• org.springframework.context• org.springframework.context.support• org.springframework.expression• org.springframework.instrument

从Spring Web Flow 2.0开始，我们使用了新的Spring构建系统。这给了我们：

◆基于Ivy的“Spring Build”系统

◆一致的部署过程

◆一致的依赖管理方式

◆一致的OSGi Manifest生成方式

5、新特性概述

以下是Spring 3.0新特性的列表，我们稍后会更详细地介绍它们。

◆Spring Expression Language

◆IoC增强 / 基于Java的Bean元数据

◆从Spring Web Services迁移过来的对象 / XML映射功能（OXM）

◆全面的REST支持

◆更多@MVC注解

◆声明式模型验证

◆Java EE 6早期支持

◆嵌入式数据库支持

针对Java 5的核心API更新

BeanFactory接口会尽可能地返回确定类型的Bean实例：

◆T getBean(String name, Class requiredType)

◆Map getBeansOfType(Class type)

Spring的TaskExecutor接口现在扩展了java.util.concurrent.Executor接口：

扩展了的AsyncTaskExecutor支持带Future的标准Callable

新的基于Java 5的转换器API和SPI：

◆无状态的ConversionService和Converter

◆取代标准JDK PropertyEditor

指定类型的ApplicationListener

Spring Expression Language

Spring引入了一种表达式语言，它在语法上很像Unified EL，但提供了更多功能。在定义XML和基于注解的Bean定义的时候，可以使用该表达式语言，此外，它也是Spring Portfolio中表达式语言支持的基础。该功能的详细信息请参考Spring Expression Language（SpEL）一章。

Spring Expression Language为Spring社区提供了一种能在所有Spring Portfolio产品中使用的、有良好支持的表达式语言。它的语言特性是由Spring Portfolio中项目的需求来驱动的，其中也包含工具的需求，例如，在基于Eclipse的SpringSource Tool Suite中的代码补全支持。

下面是一个例子，演示了如何用它来配置数据库属性。

<bean class="mycompany.RewardsTestDatabase">

<property name="databaseName"

value="#{systemProperties.databaseName}"/>

<property name="keyGenerator"

value="#{strategyBean.databaseKeyGenerator}"/>

bean>

如果你更喜欢用注解来配置你的组件，该功能也同样适用：

@Repository

public class RewardsTestDatabase {

@Value("#{systemProperties.databaseName}")

public void setDatabaseName(String dbName) { … }

@Value("#{strategyBean.databaseKeyGenerator}")

public voidsetKeyGenerator(KeyGenerator kg) { … }

}

控制反转（Inversion of Control，IoC）容器

基于Java的Bean元数据

如今，Java Config项目中的一些核心特性已经被添加到了Spring Framework项目中，这意味着现在Spring直接支持下面的这些注解了：

◆@Configuration

◆@Bean

◆@Primary

◆@Lazy

◆@Import

◆@Value

以下是一个Java类使用新JavaConfig特性提供基本配置的例子：

@Configuration

public class AppConfig{

private @Value("#{jdbcProperties.url}") String jdbcUrl;

private @Value("#{jdbcProperties.username}") String username;

private @Value("#{jdbcProperties.password}") String password;

@Bean

public FooService fooService() {

return new FooServiceImpl(fooRepository());

}

@Bean

public FooRepository fooRepository() {

return new HibernateFooRepository(sessionFactory());

}

@Bean

public SessionFactory sessionFactory() {

// wire up a session factory

AnnotationSessionFactoryBean asFactoryBean =

new AnnotationSessionFactoryBean();

asFactoryBean.setDataSource(dataSource());

// additional config

return asFactoryBean.getObject();

}

@Bean

public DataSource dataSource() {

return new DriverManagerDataSource(jdbcUrl, username, password);

}

}

要让上面的代码运行起来，你需要将如下组件扫描配置加入应用程序上下文XML文件中

<context:component-scan

base-package="com.myco.config"/>

在组件中定义Bean元数据

Spring组件中也同样支持添加了@Bean注解的方法，它们为容器提供了一个工厂Bean。

数据层

对象 / XML映射功能（OXM）已经从Spring Web Services项目迁移到核心Spring Framework中了，可以在org.springframework.oxm包中找到它。

Web层

Web层中最令人兴奋的新特性莫过于对构建RESTful Web服务和Web应用程序的支持了。此外，还有一些用于Web应用程序中的新注解。

全面的RESTful支持

通过对现有的注解驱动MVC Web框架的扩展，Spring Framework提供了构建RESTful应用程序的服务器端支持。客户端的支持则由RestTemplate类提供，它和JdbcTemplate、 JmsTemplate这些模板类非常类似。无论是服务器端还是客户端的REST功能，都使用了HttpConverter来简化对象与对应的HTTP请求/应答中的表述的转换。

MarshallingHttpMessageConverter用到了之前提到的OXM功能。

更多@MVC注解

新增了几个注解，例如@CookieValue和@RequestHeaders。详见“使用@CookieValue注解映射Cookie值”和“用@RequestHeader注解映射请求头属性”。

声明式模型验证

Hibernate Validator，JSR303

进行中，未包括在Spring 3.0 M3中。

Java EE 6早期支持

我们提供了对使用@Async注解（或EJB 3.1的@Asynchronous注解）进行异步方法调用的支持，还支持JSF 2.0、JPA 2.0等。

进行中，未包括在Spring 3.0 M3中。

支持嵌入式数据库

目前已经提供了对嵌入式Java数据库引擎的支持，包括HSQL、H2和Derby。

【编辑推荐】

Spring 3.0即将发布新增Spring表达式语言

Spring 3.0 M3发布强化对标注的支持

专家Isvy谈Spring 3.0

企业级Java云 SpringSource云工厂初探

Spring实例化Bean的三种方式

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航