Spring Roo 简介，第 3 部分: 开发 Spring Roo 的附加组件(转)

最新推荐文章于 2020-07-05 16:52:22 发布

iteye_10717

最新推荐文章于 2020-07-05 16:52:22 发布

阅读量319

点赞数

分类专栏： spring roo 文章标签： spring roo

本文链接：https://blog.csdn.net/iteye_10717/article/details/82602152

版权

spring roo 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

入门

在本 “Spring Roo 简介” 系列的 Spring Roo 简介，第 1 部分：从源代码构建和 Spring Roo 简介，第 2 部分：使用 Spring Roo 开发应用程序，我们使用 Spring Roo 从头开始构建了一个功能完整的企业应用程序。前两篇文章专注于使用 Spring Roo 的快速应用开发环境构建 Web 应用程序。我们涵盖了许多功能，如：JPA、Selenium 测试、Spring Security、电子邮件集成、Spring Roo 社交功能、数据库逆向工程等。现在我们将看一看 Spring Roo 的附加架构。然后我们将使用 addon create 命令编写 Spring Roo 附加组件。到本文的最后，您将能够快速、轻松地创建您自己的 Spring Roo 附加组件。

回页首

Spring Roo 附加架构

简单来说，附加组件是一种软件组件，它将特定的功能添加到软件应用中。例如，在大多数 Web 浏览器中，视频支持由附加组件提供。另一个示例是 Eclipse（许多 Java™ 开发人员使用或至少了解的开源 IDE）。大多数功能，如 JUnit 支持、SVN 支持等，都由附加组件提供。我在使用 add-on 作为插件和扩展的总称。

Spring Roo 还有附加组件的概念：

为了让第三方开发人员能够创建扩展 Spring Roo 的功能的能力
帮助 Spring Roo 轻松添加新功能
帮助 Spring Roo 仍然轻便灵活（即：减少 Spring Roo 的大小）

Spring Roo 逻辑组件

Spring Roo 被分为两个逻辑部分。

Spring Roo 核心组件： 为了实现附加组件的开发， Spring Roo 提供了一组核心组件，这些组件构成了不同附加组件的托管执行环境。这些组件是 Classpath，它支持 Process Manager 和 Shell。反过来，Process Manager 支持 Project 和 File Undo。Project 支持 Model、Metadata 和 File Monitor。最后，还有 Support 组件，它由所有组件使用。图 1 提供了这些关系的可视化表示。

图 1. Spring Roo 核心组件

图中展示了 Spring Roo 组件之间的关系

我们来讨论一些核心模块：

Support—org.springframework.roo.support 模块提供所有核心模块和附加组件使用的常见实用工具类。一些实用工具类包括 Assert、 FileCopyUtils、 XmlUtils、 StringUtils、 FileUtils 等。例如，如果您要将一个文件的内容复制到另一个文件，您可以使用 FileCopyUtils 来完成。
Metadata— org.springframework.roo.metadata 模块提供元数据服务提供程序接口和实现，包括依赖项注册和缓存。
File monitor— org.springframework.roo.file.monitor 模块在检测到的文件系统变化之后公布事件（默认实现使用自动缩放的磁盘轮询）。
File undo— org.springframework.roo.file.undo 模块提供文件撤消工具，供进程管理器使用。
Project— org.springframework.roo.project 模块提取典型的最终用户项目构建系统，如 Apache Maven 和 Apache Ant。
Process manager— org.springframework.roo.process.manager 模块提供一个类似于 ACID 的文件系统抽象，包括磁盘回滚和进程同步。
Classpath— org.springframework.roo.classpath 模块对 Java 和 AspectJ 编译单元执行抽象语法树解析和类型绑定。

Spring Roo 核心组件：Spring Roo 通过附件组件提供所有功能。Roo V1.1.3 附带的基础附加组件：

Add-On Creator— org.springframework.roo.addon.creator 附加组件支持轻松创建第三方 Roo 附加组件。
Backup— org.springframework.roo.addon.backup 附加组件允许通过键入备份对 ZIP 文件进行备份。
Cloud Foundry— org.springframework.roo.addon.cloud.foundry 附加组件提供了 VMware Cloud Foundry 支持。
Configurable— org.springframework.roo.addon.configurable 附加组件支持通过 AspectJ ITD 引入 Spring @Configurable 注释。
Database reverse engineering— org.springframework.roo.addon.dbre 附加组件支持现有数据库的增量逆向工程。
Data on Demand— org.springframework.roo.addon.dod 附加组件支持自动创建用于集成测试的样本数据。
Email— org.springframework.roo.addon.email 附加组件支持在目标项目中集成和配置 Spring 的电子邮件支持。
Entity— org.springframework.roo.addon.entity 附加组件提供了扩展的支持，可自动维护 Java Persistence API @Entity 类。
Dynamic Finder— org.springframework.roo.addon.finder 创建类型安全的与代码完成兼容的 JPA 查询语言查找器。
Git— org.springframework.roo.addon.git 附加组件提供对项目中 GIT 集成的支持。每个成功执行的命令将自动提交到本地 GIT 存储库。
GWT— org.springframework.roo.addon.gwt 附加组件支持使用 Google Web 工具包的 UI 基架。
JavaBean— org.springframework.roo.addon.javabean 附加组件自动维护 JavaBean getter/setter，用于带有 @RooJavaBean 注释的类。
JDBC— org.springframework.roo.addon.jdbc 附加组件封装对不同捆绑包中附带的 JDBC 驱动程序的符合 OSGi 的访问（主要由其他附加组件使用）。
JMS— org.springframework.roo.addon.jms 附加组件支持在目标项目中配置 Java Messaging System 设置。
JPA— org.springframework.roo.addon.jpa 附加组件安装指定的 JPA 提供程序，并相应地设置 JDBC 。
JSON— org.springframework.roo.addon.json 附加组件将与 JSON 相关的序列化和反序列化方法添加到 POJO。
Logging— org.springframework.roo.addon.logging 附加组件设置 Log4j，包括基于命令的日志级配置。
Pluralization— org.springframework.roo.addon.plural 附加组件提供了名词复数（主要由其他附加组件使用）。
Property Editor— org.springframework.roo.addon.property.editor 附加组件按 Spring MVC 的要求管理属性编辑器。
Property File— org.springframework.roo.addon.propfiles 附加组件支持在目标项目中管理属性。
RooBot Client— org.springframework.roo.addon.roobot.client 附加组件支持通过 RooBot 服务器进行附加组件的管理。
Security— org.springframework.roo.addon.security 附加组件设置 Spring Security，包括登录页面、过滤器和依赖项。
Serializable— org.springframework.roo.addon.serializable 附加组件将 java.io.Serializable 支持（如 UID 维护）添加到所请求的 Java 类型。
Solr— org.springframework.roo.addon.solr 附加组件支持在目标项目中配置和集成 Apache Solr 功能。
Integration Test— org.springframework.roo.addon.test 附加组件为项目实体产生 JUnit 集成测试。
ToString— org.springframework.roo.addon.tostring 附加组件为任何带有 @RooToString 注释的类创建一个有效的 toString() 方法。
WebFlow— org.springframework.roo.addon.Web.flow 附加组件支持在目标项目中配置和集成 Spring Web Flow 功能。
Web MVC Controller— org.springframework.roo.addon.Web.mvc.controller 附加组件支持在目标项目中配置和集成 Spring MVC 控制器。
Web MVC Embedded— org.springframework.roo.addon.Web.mvc.embedded 附加组件提供了对 MVC 附加组件的扩展，这允许将地图、视频等嵌入式功能添加到网页中。
Web MVC JSP— org.springframework.roo.addon.Web.mvc.jsp 附加组件在目标项目中配置和集成 Spring MVC JSP 功能。
Selenium— org.springframework.roo.addon.Web.selenium 附加组件支持在目标项目中配置和集成 Selenium Web 测试。

现在我们已经看过了 Spring Roo 核心组件以及 Spring Roo 提供的基本附加组件，接下来我们编写自己的附加组件。

回页首

OSGi 运行时环境

Spring Roo 基于 OSGi，它是 Roo 的附加架构的理想之选。OSGi 提供了非常好的基础架构来开发模块化和嵌入式的面向服务应用程序。

Roo shell 使用 Apache Felix 作为其 OSGi 运行时框架，同时使用 Service Component Runtime (SCR) 进行组件管理，使用 OSGi Bundle Repository (OBR) 进行捆绑解析。在 Roo shell 中有各种 OSGi 命令，您可以通过键入 help osgi 查看，如清单 1 所示。

清单 1. 针对 OSGi 的 Roo 帮助

roo> help osgi 
* osgi find - Finds bundles by name 
* osgi framework command - Passes a command directly 
through to the Felix shell infrastructure 
* osgi headers - Display headers for a specific bundle 
* osgi install - Installs a bundle JAR from a given URL 
* osgi log - Displays the OSGi log information 
* osgi obr deploy - Deploys a specific OSGi Bundle Repository (OBR) bundle 
* osgi obr info - Displays information on a specific OSGi Bundle Repository (OBR) bundle 
* osgi obr list - Lists all available bundles from the 
OSGi Bundle Repository (OBR) system 
* osgi obr start - Starts a specific OSGi Bundle Repository (OBR) bundle 
* osgi obr url add - Adds a new OSGi Bundle Repository (OBR) repository file URL 
* osgi obr url list - Lists the currently-configured 
OSGi Bundle Repository (OBR) repository file URLs 
* osgi obr url refresh - Refreshes an existing 
OSGi Bundle Repository (OBR) repository file URL 
* osgi obr url remove - Removes an existing 
OSGi Bundle Repository (OBR) repository file URL 
* osgi ps - Displays OSGi bundle information 
* osgi resolve - Resolves a specific bundle ID 
* osgi scr config - Lists the current SCR configuration 
* osgi scr disable - Disables a specific SCR-defined component 
* osgi scr enable - Enables a specific SCR-defined component 
* osgi scr info - Lists information about a specific SCR-defined component 
* osgi scr list - Lists all SCR-defined components 
* osgi start - Starts a bundle JAR from a given URL 
* osgi uninstall - Uninstalls a specific bundle 
* osgi update - Updates a specific bundle 
* osgi version - Displays OSGi framework version

回页首

Spring Roo 附加组件创建命令

Spring Roo 绑定了附加组件创建命令，用于创建不同类型的附加组件。Add-on Creator 公开 addon create 命令，也是一个 Roo 附加组件。 Roo 目前支持四类附加组件：

Internationalization Add-on— 它支持为 Roo 的支架式 Spring MVC 应用程序添加语言翻译（例如，添加对印地语的翻译）。
Simple Add-on— Simple Add-on 支持对项目依赖项或配置或这两者的小增补（例如，进行一些 maven pom.xml 修改，如添加某些 JAR 或 Maven 插件）。
Advanced Add-on— 该附加组件执行繁重的工作，用于构建功能完整的 Spring Roo 附加组件，该组件需要创建 Java 代码（构建一个能够为域对象编写 equals 和 hashcode 方法的附加组件。）已经有一个社区附加组件来执行这些功能。
Wrapper Add-on—该附加组件包含一个 Maven 工件，以创建符合 OSGi 的捆绑包。当附加组件需要依赖项来完成其功能时需要它。例如，Spring Roo 数据库逆向工程附加组件需要 Postgres JDBC 驱动程序来完成任务，因此您将使用该附加组件包装 Postgres JDBC 驱动程序。

这些附加组件创建命令来简化 Roo 附加组件的开发，通过创建新的附加组件：

httppgp://

Spring Roo V1.1 推出了 Pretty Good Privacy (PGP)，允许用户指定哪些开发人员是可信赖的，能够为可以在 Roo shell 中下载和激活的软件签名。事实上，每个版本的 Roo 本身现在都有 PGP 签名。一种称为 httppgp:// 的新协议处理程序被引入 Roo 中，表明 URL 还具有 PGP 防护独立的签名。这提供了一种开放的安全形式，有助于防止用户进行恶意下载。这些标准还允许使用独立的 PHP 工具来独立验证 Roo 的操作。

与 Google Code SVN 源代码控制集成。
在公共 Maven 存储库中托管，作为 Google 代码项目的一部分创建。
符合 RooBot，一种 VMware 托管服务，为公共 Roo OBR 文件中的重要内容编制索引。 OBR 文件是对捆绑包元数据的基于 XML 的表示。为了符合 RooBot，附加组件应：
1. 符合 OSGi。
2. PGP 签名的工件，带有公共密钥。
3. 通过 httppgp:// 协议注册。

使用 Roo addon create 命令，您能够获得自动为您的附加组件配置的上述所有功能。这无疑减少了创建和向外界发布附加组件的时间。

在开始编写附加组件之前，请确保您拥有一个正在运行的 Spring Roo 环境。Spring Roo 安装说明可在本系列的 Spring Roo 简介，第 1 部分：从源代码构建找到。

回页首

我想要印地语支持（i18N 附加组件创建）

当您使用 Spring Roo 创建基于 Spring MVC 的 Web 应用程序时，您可以使用 Web mvc language 命令添加对不同语言的支持。Spring Roo 开箱即用地支持英语、德语、西班牙语、意大利语、荷兰语和瑞典语。国际化支持由 Web MVC JSP 附加组件提供，仅当您的 Webapp 目录中有 JSPX 文件时才启用该附加组件。JSPX 文件由一个控制器命令生成，该命令将简单的基于 JAR 的应用程序转换为 Spring MVC Web 应用程序。

作为一名印度人，我想要在我的 Web 应用程序中添加对印地语的支持。Spring Roo 提供一个 addon create i18n 命令，该命令提供对 Web mvc install language command 的扩展，添加对印地语等新语言的支持。它只需要将 messages.properties 文件转换成所需的语言。

当 Spring Roo 创建 Spring MVC Web 应用程序时，它创建两个属性文件：application.properties 和 messages.properties。 application.properties 文件包含特定于应用程序的属性，比如应用程序名称。messages.properties 文件包含的属性不特定于任何应用程序，比如当您单击删除按钮时会出现 “您确定要删除该项目吗？” 消息，还有登录、注销等消息。因此，在编写 i18n 附加组件时，您需要提供对 messages.properties 文件的翻译。

现在，我们已经讨论了 Spring Roo 中的默认国际化支持，让我们编写能够添加印地语支持的 i18n 附加组件。我将展示如何使用 Google 代码建立项目，使用命令编写附加组件，并向外界发布，最后使用 RooBot 服务注册它。使用 RooBot 服务进行注册很重要，因为这会让 RooBot 为您的附加组件编制索引并在其他开发人员通过 addon search 命令进行搜索时显示该组件。

项目建立

Spring Roo 文档生动地讲解了如何使用 Google 代码建立您的项目和 Maven 存储库，因此我不会重复。我只说明我将使用项目名称 “roo-hind-addon”。

创建一个 i18N 附加组件

在建立了项目后，您将有一个空目录，称为 roo-hindi-addon。进入该目录并输入 roo command。在进入 shell 后，输入 addon create i18n。如果按下 tab 键，您将看到该命令接受 7 个属性。在这 7 个属性中，有 3 个属性是必选的： topLevelPackage（新附加组件的顶层包）、locale（语言设置缩写，如 “it” 代表意大利语）和 messageBundle （到 message_xx.properties 的完全限定路径，其中 xx 是区域名称）。另外 4 个属性是可选属性： language（语言的全名）、 flagGraphic（到 xx.png 文件的完整路径，其中 xx 是标志名称）、description （对附加组件的说明）和 projectName（项目名称（如果没有提供，则使用顶层包名称））。我建议您使用 projectName 属性并确保其值是在 Google 代码上托管的项目的名称。因此，在我们的示例中，将是 roo-hindi-addon。

在上述属性中，最重要的是 messageBundle，它指定转换后的 messages.properties 文件。为了将 messages.properties 转换成印地语，最简单的方法是使用 Google translate 等服务，依次转换每个属性，然后将它们写入到 messages_hi.properties 文件。然而，这在我们的情况下不可行，因为 Java 属性文件使用 ISO-8859-1 编码，不支持印地文字符。为了克服这个问题，我使用了一个称为 Eclipse ResourceBundle Editor 的 Eclipse 插件，它允许您为不同语言转换并创建资源包。您可以使用 http://www.nightlabs.de/updatesites/development/ 更新站点安装它。将 messages.properties 文件转换为 messages_hi.properties 文件不在本文的讨论范围内。ResourceBundle Editor 插件易于使用。请注意，如果支持该语言字符，则不需要使用 ResourceBundle Editor。messages_hi.properties 文件看起来与清单 2 类似。

清单 2. messages_hi.properties 文件示例

button_cancel = \u0930\u0926\u094D\u0926 
button_end = \u0905\u0902\u0924
button_find = \u0916\u094B\u091C\u0947\u0902
button_home = \u0918\u0930 
...

查看 full file。一旦您拥有了转换后的 messages_hi.properties 文件，您便可以创建该附加组件，只需输入一个命令便能完成。您可以通过将清单 3 中的命令输入到 Roo shell 中来创建印地语附加组件，。

清单 3. 创建印地语附加组件的命令

addon create i18n --locale hi --topLevelPackage org.xebia.roo.addon.i18n.hindi 
  --messageBundle <location to messages_hi.properties> \
--language hindi --projectName roo-hindi-addon 
  --flagGraphic <full path to flag hi.png>

清单 4 显示了通过 addon create i18n 命令创建的工件。

清单 4. 创建的工件

Created ROOT/pom.xml 
Created ROOT/readme.txt 
Created ROOT/legal 
Created ROOT/legal/LICENSE.TXT 
Created SRC_MAIN_JAVA 
Created SRC_MAIN_RESOURCES 
Created SRC_TEST_JAVA 
Created SRC_TEST_RESOURCES 
Created SRC_MAIN_WEBAPP 
Created SRC_MAIN_RESOURCES/META-INF/spring 
Created ROOT/src/main/assembly 
Created ROOT/src/main/assembly/assembly.xml 
Created SRC_MAIN_RESOURCES/org/xebia/roo/addon/i18n/hindi 
Created SRC_MAIN_RESOURCES/org/xebia/roo/addon/i18n/hindi/messages_hi.properties 
Created SRC_MAIN_RESOURCES/org/xebia/roo/addon/i18n/hindi/hi.png 
Created SRC_MAIN_JAVA/org/xebia/roo/addon/i18n/hindi 
Created SRC_MAIN_JAVA/org/xebia/roo/addon/i18n/hindi/HindiLanguage.java

该命令生成了一个 Maven 项目，可以通过 File > Import > Maven > Existing Maven projects 导入到 Eclipse（有 m2eclipse）或 SpringSource 工具套件。您不需要导入该项目，因为我们不需要修改该附加组件。

现在我们可以安装该附加组件，在我们的项目中使用它，并将其对外发布。但是，首先我们讨论一些工件，以更多地了解生成的代码：

pom.xml 是一个标准的 Maven 项目配置。所生成的 pom.xml 有各种预配置的插件，它们执行与使用 PGP 对工件进行签名的工作，使用 Maven 版本插件发行该附加组件，使用 Maven 捆绑包插件创建 OSGi 捆绑包。它还将 OSGi 和 Felix 依赖项添加到项目中，这是让附加组件在 Roo shell 内运行所必需的。
assembly.xml 定义了由 Maven 程序集插件用来包装附加组件的配置。
messages_hi.properties 是在创建附加组件时我们提供的消息包文件，被复制到资源文件夹。
hi.png 是在创建附加组件时我们提供的标志 PNG 文件，被复制到资源文件夹。
HindiLanguage.java 是该附加组件所创建的惟一的 Java 文件，用于获取对应于特定语言的信息。例如，它提供本地名称、消息包资源文件等。

将印地语支持添加到应用程序

现在我将向您展示如何使用我们刚刚创建的附加组件将印地语支持添加到您的应用程序：

退出 Roo shell 并运行 mvn clean install 命令。在构建过程中，它会询问您的 GPG 密码。
在构建了 Roo 附加组件后，打开新的命令行并创建名为 i18n-hindi-client 的目录。我们将为我们的附加组件创建一个简单的客户端。
进入 i18n-hindi-client 目录并输入 roo 命令。

在 Roo shell 中执行以下命令。这将创建一个简单的 Spring MVC Web 应用程序。

清单 5. 创建 MVC Web 应用程序的 Roo 命令

project --topLevelPackage com.shekhar.roo.i18n.client \
--projectName i18n-hindi-client  
persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY  
entity --class ~.domain.MyUser  
field string --fieldName name --notNull  
controller all --package ~.web

输入该命令并按下 Tab 键：Web mvc language --code de en es it nl sv
您不会看到印地语支持。这是因为我们还没有安装印地语附加组件。
要安装该附加组件，请输入：
```
osgi start --url file:///<location to addon target 
   folder>/org.xebia.roo.addon.i18n.hindi-0.1.0.BUILD-SNAPSHOT.jar
```
这样应该便能够安装并激活我们的 Spring Roo 印地语附加组件。您可以使用 osgi ps 命令查看该附加组件的状态，这会显示 OSGi 包信息及其状态，如下所示：
```
[ 95] [Active ] [ 1] roo-hindi-addon (0.1.0.BUILD-SNAPSHOT)
```
再次输入 Web mvc language –code 并按下 Tab 键。这次，您将看到针对印地语的代码。选择 hi 代码，印地语支持将被添加到您的应用程序。
```
Web mvc language –code hi
```
退出 Roo shell 并输入 mvn tomcat:run。您将在页脚看到印度国旗。单击该国旗，您的应用程序将用印地语显示出来，如图 2 所示。
图 2. 印地语支持

在测试了该附加组件在您的开发系统中运行良好后，您可以将该附加组件推送到我们创建的 Google 代码项目。

高级选项

现在我们已经看到我们创建的附加组件运行正常，让我们看一下如何将印地语提供给应用程序：

roo-hindi-addon 通过 osgi start 命令启动。
在附加组件启动后，由 addon create i18n command 创建的 HindiLanguage 类在 i18nComponent 上得到注册。i18nComponent 是一个 OSGi 服务侦听器，用于注册和注销 i18n 附加组件。 HindiLanguage 类标有 @Component 和 @Service 注释，这由 Apache Felix 提供。这些注释确保在 Roo shell 上注册了这些组件和服务，且它们可供使用。
当我们输入 Web mvc install language –code 命令并按下 tab 键后，tab 完成服务将调用 i18nComponent 类 getSupportedLanguages() 方法，这将返回 i18n 附加组件的 java.util.Set。因为 HindiLanguage 已经在 i18nComponent 上进行了注册，因此也会返回它。

对外发布附加组件

对外发布附加组件非常容易，因为 Roo create 命令已经通过安装所有必需的 Maven 插件为我们完成了大多数操作。转到项目根目录，并输入清单 6 中的命令。

清单 6. 发布 Roo 项目

svn add pom.xml src/ legal/ readme.txt 
svn commit -m "Roo Hindi Addon first version" 
mvn release:prepare release:perform

Maven 版本插件会要求输入发行版本、标记名称以及开发版本。您可以只选择默认设置，然后继续。发行和发布工件到 Google 代码项目需要几分钟的时间。然后您可以在您的 Google 代码项目中查看这些附加工件。

在 RooBot 上注册您的附加组件

在发布了插件后，您可以通过电子邮件将它发送到 s2-roobot@vmware.com 来注册您的附加组件存储库。电子邮件的主题行必须包含 repository.xml 文件。例如，对于我们刚刚创建的附加组件，repository.xml 为 http://code.google.com/p/roo-hindi-addon/source/browse/repo/repository.xml。如需了解关于 RooBot 注册的更多信息，请参见 Spring Roo 文档。

回页首

我想要监控我的 Java 应用程序（简单的附加组件创建）

许多企业应用程序中的一个常见要求就是监控 Java 应用程序来确定应用程序的性能瓶颈。我也有同样的要求，因此我决定看一下一些可用的开源解决方案。Java Application Monitor (JAMon) 是免费的、高性能、线程安全的 Java API，使您能够轻松监控生产应用程序。

要在您的 Web 应用程序中添加 JAMon 支持：

您必须在您的 pom.xml 中添加 jamon JAR。
您必须在您的应用程序上下文文件中定义 JamonPerformanceMonitorInterceptor bean。示例 bean 定义与清单 7 中的代码类似。

清单 7. JamonPerformanceMonitorInterceptor 代码

	<bean id="jamonPerformanceMonitorInterceptor" 
		class=\
"org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor"> 
		<property name="trackAllInvocations" value="true"></property> 
		<property name="useDynamicLogger" value="true"></property> 
	</bean> 

	<bean id="autoProxyCreator" 
		class=\
"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
		<property name="interceptorNames"> 
			<list> 
				<idref bean="jamonPerformanceMonitorInterceptor" /> 
			</list> 
		</property> 
		<property name="beanNames"> 
			<list> 
				<value>speakerController</value> 
				<value>talkController</value> 
			</list> 
		</property> 
	</bean>

这不是任何开发人员都能够轻松铭记的简单的 bean 定义，我认为如果我可以自动化该样板配置会很不错。因此我决定编写一个附加组件，它能够自动化添加 JAMon 依赖项和连接侦听器 bean 的流程。您如何决定您需要简单还是高级附加组件呢？

当您想要将 Maven 依赖项、配置工件或这两者添加到您的项目时，使用简单附加组件。
当您需要编写增强现有 Java 类型的功能完整的附加组件、引入新的 Java 类型和 AspectJ ITD 或同时实现这两点时，使用高级附加组件。

我们的要求是将 jamon.jar 添加到类路径，并编写包含我们的 bean 定义的应用程序上下文文件。最好编写一个新的 Spring 应用程序上下文文件，而不是使用现有的上下文文件，因为这有助于模块化应用程序上下文。根据这些要求，显然我们应该编写简单的附加程序，能够将 JAMon 支持添加到任何 Web 应用程序。

项目建立

我们需要以与国际化附加组件相同的方式建立项目。我将该项目命名为 “spring-roo-addon-jamon”。

创建简单的附加组件

在建立了项目后，您将得到一个名为 spring-roo-addon-jamon 的目录以及 .svn 文件夹。转到 spring-roo-addon-jamon 目录并启动 Spring Roo shell。然后输入下面的命令：

addon create simple --topLevelPackage org.xebia.roo.addon.jamon \
--projectName spring-roo-addon-jamon

好！附加组件创建完成。

安装生成的附加组件

您可以通过下面的命令安装该附加组件：

osgi start --url file://<Location to addon
    target folder>/org.xebia.roo.addon.jamon-0.1.0.BUILD-SNAPSHOT.jar

在安装了附加组件后，创建一个要测试的简单客户端，正如我们为 i18n 附加组件所创建的。生成的附加组件提供两个命令：

say hello，该命令在 Roo shell 上打印出一条欢迎消息。该命令将总是可用，您可以在 Roo shell 运行时随时输入该命令。
Web mvc install tags 取代了默认 MVC 标记，当您构建 Web 应用程序时会生成该标记。该命令只能在您创建了 Web 应用程序后才可用。

看一看生成的代码

现在您已经测试了该附加组件，让我们看一看该附加组件生成的文件，如清单 8 所示。

清单 8. 为 spring-roo-addon-jamon 生成的文件

Created ROOT/pom.xml 
Created ROOT/readme.txt 
Created ROOT/legal 
Created ROOT/legal/LICENSE.TXT 
Created SRC_MAIN_JAVA 
Created SRC_MAIN_RESOURCES 
Created SRC_TEST_JAVA 
Created SRC_TEST_RESOURCES 
Created SRC_MAIN_WEBAPP 
Created SRC_MAIN_RESOURCES/META-INF/spring 
Created SRC_MAIN_JAVA/com/shekhar/roo/addon/jamon 
Created SRC_MAIN_JAVA/com/shekhar/roo/addon/jamon/JamonCommands.java 
Created SRC_MAIN_JAVA/com/shekhar/roo/addon/jamon/JamonOperations.java 
Created SRC_MAIN_JAVA/com/shekhar/roo/addon/jamon/JamonOperationsImpl.java 
Created SRC_MAIN_JAVA/com/shekhar/roo/addon/jamon/JamonPropertyName.java 
Created ROOT/src/main/assembly 
Created ROOT/src/main/assembly/assembly.xml 
Created SRC_MAIN_RESOURCES/com/shekhar/roo/addon/jamon 
Created SRC_MAIN_RESOURCES/com/shekhar/roo/addon/jamon/info.tagx 
Created SRC_MAIN_RESOURCES/com/shekhar/roo/addon/jamon/show.tagx

文件 pom.xml、assembly.xml、LICENSE.TXT 和 readme.txt 与 i18n 附加组件所生成的相同。我们在前面已经讨论了这些文件，因此我不会再次讨论。比较有趣的工件包括 JamonCommands、JamonOperations、 JamonOperationsImpl 和 JamonPropertyName。我们将逐个进行讨论，以了解简单的附加组件命令生成的代码。

JamonCommands.java:JamonCommands— 这个类实现了一个称为 CommandMarker 的标记接口，并公开了两个命令，say hello 和 Web mvc install 标记，如清单 9 所示。
清单 9. JamonCommands.java:JamonCommands 生成的代码
```
@Component 
@Service 
public class JamonCommands implements CommandMarker { 
        
       @Reference private JamonOperations operations; 
        
       @Reference private StaticFieldConverter staticFieldConverter; 


       protected void activate(ComponentContext context) { 
           staticFieldConverter.add(JamonPropertyName.class); 
           } 


       protected void deactivate(ComponentContext context) { 
               staticFieldConverter.remove(JamonPropertyName.class); 
       } 
        
       @CliAvailabilityIndicator("say hello") 
       public boolean isSayHelloAvailable() { 
               return true; 
       } 
        
       @CliCommand(value = "say hello", 
help = "Prints welcome message to the Roo shell") 
       public void sayHello( 
               @CliOption(key = "name", mandatory = true, 
help = "State your name") String name, 
               @CliOption(key = "contryOfOrigin", mandatory = false, 
       help = "Country of origin") JamonPropertyName country) { 
                
               log.info("Welcome " + name + "!"); 
               log.warning("Country of origin: " + (country == null ? \
JamonPropertyName.NOT_SPECIFIED.getPropertyName() : country.getPropertyName())); 
               
               log.severe("It seems you are a running JDK " 
+ operations.getProperty("java.version")); 
               log.info("You can use the default JDK logger anywhere in your" 
+ " add-on to send messages to the Roo shell"); 
       } 
        
       @CliAvailabilityIndicator("web mvc install tags") 
       public boolean isInstallTagsCommandAvailable() { 
               return operations.isInstallTagsCommandAvailable(); 
       } 
        
       @CliCommand(value = "web mvc install tags", 
help="Replace default Roo MVC tags used for scaffolding") 
       public void installTags() { 
               operations.installTags(); 
       } 
}
```
我已经删除了代码生成器所生成的所有注释，以减少代码的冗余。让我们看看这个类的重要成员：
1. CommandMarker— 所有命令类都应该实现 CommandMarker 接口，并通过 @Component 和 @Service 注释注明，以便对它们进行注册并让它们的命令在 Roo shell 中可用。通过 @Reference 注释的字段是 JamonCommands 类的依赖项，通过底层 Roo OSGi 容器注入。所有使用 @Component 和 @Service annotations 注释的类都可以被注入到其他附加组件。
2. Activate 和 Deactivate 方法—activate 和 deactivate 方法是在您使用 addon install 命令安装附加组件或使用 addon remove 命令删除附加组件时调用的方法。这些方法允许您挂接到附加组件的生命周期，这通过底层 Roo OSGi 容器管理。
3. 标有 @CliAvailabilityIndicator 注释的方法— 标有 @CliAvailabilityIndicator 注释的方法是在命令不可用时帮助隐藏命令的方法。例如，security setup 命令，它将 Spring Security 安装到项目中，除非该项目是一个 Web 应用程序，否则它不可见。不要求您必须拥有这些方法，但是它们非常有用，因为它们不允许用户发出当时没有意义的命令。例如，在用户拥有 Web 应用程序之前执行 security setup 命令就没有任何意义。
4. 标有 @CliCommand 注释的方法— 标有 @CliCommand 注释的方法将命令注册在 Roo shell 中。 @CliCommand 注释有两个属性：value，它定义命令名称，和 help，它定义帮助消息，当您输入 help 命令时会显示帮助消息。每个命令都能够使用 @CliOption 注释定义强制性和非强制性属性，作为该命令的一部分。例如， say hello 命令有一个称为 name 的强制性属性和一个称为 country 的非强制性属性。

JamonOperationsImpl.java— 在执行某个命令时命令类需要执行某些操作。这些操作由操作类执行。JamonOperationsImpl 是一个操作类，负责执行实际工作，比如在 pom.xml 中添加依赖项，或将资源复制到所需的位置。 JamonOperationsImpl 使用 Spring Roo 框架提供的核心服务执行其操作。例如，要添加一个依赖项，它使用 ProjectOperations 接口。要复制文件，它则使用 FileManager 接口。让我们看看 JamonOperationsImpl 类的代码（参见清单 10）以便更好地了解 Roo 附加组件。

清单 10. JamonOpertionsImpl

	@Component 
	@Service 
	public class JamonOperationsImpl implements JamonOperations { 
		private static final char SEPARATOR = File.separatorChar; 
	 
		@Reference private FileManager fileManager; 
		@Reference private ProjectOperations projectOperations; 

		public boolean isInstallTagsCommandAvailable() { 
			return projectOperations.isProjectAvailable() &&
            fileManager.exists(projectOperations.getProjectMetadata().
			getPathResolver().getIdentifier(Path.SRC_MAIN_WEBAPP,
                "WEB-INF" + SEPARATOR + "tags")); 
	} 

		public String getProperty(String propertyName) { 
			Assert.hasText(propertyName, "Property name required"); 
			return System.getProperty(propertyName); 
		} 

		public void installTags() { 
			PathResolver pathResolver =
            projectOperations.getProjectMetadata().getPathResolver(); 
			createOrReplaceFile(pathResolver.getIdentifier(
			    Path.SRC_MAIN_WEBAPP, "WEB-INF" + SEPARATOR +
                    "tags" + SEPARATOR + "util"), "info.tagx"); 

		createOrReplaceFile(pathResolver.getIdentifier(
			Path.SRC_MAIN_WEBAPP, "WEB-INF" + SEPARATOR +
                "tags" + SEPARATOR + "form"), "show.tagx"); 
		} 
	 
		private void createOrReplaceFile(String path, String fileName) { 
			String targetFile = path + SEPARATOR + fileName; 
			MutableFile mutableFile = fileManager.exists(targetFile) ?
                fileManager.updateFile(targetFile) :
                fileManager.createFile(targetFile); 
			    try { 
			    	FileCopyUtils.copy(TemplateUtils.getTemplate(getClass(),
                        fileName), mutableFile.getOutputStream()); 
			    } catch (IOException e) { 
				throw new IllegalStateException(e); 
			} 
		} 
	}

JamonOperationsImpl 类有两个重要的方法： isInstallTagsCommandAvailable 检查该命令是否可用， installTags 将标记安装到目标项目。为了执行这些操作， JamonOperationsImpl 类使用一些 Spring Roo 核心服务和实用程序：

ProjectOperations : JamonOperationsImpl 类使用 ProjectOperations 服务来检查项目是否可用，并获得标记文件夹的路径。
FileManager : JamonOperationsImpl 类使用 FileManager 服务来检查一个文件是否在某个路径上存在，并获得更新或创建一个 MutableFile。 MutableFile 是另一个特定于 Roo 的类，它表示一个可以进行修改的文件的句柄。
TemplateUtils : TemplateUtils 实用程序类用于在我们的附加组件包里为模板文件（info.tagx 和 show.tagx）获取一个 InputStream。
FileCopyUtils : FileCopyUtils 实用程序类用于将模板（从 TemplateUtils）复制到 MutableFile（从 FileManager）。

修改附加组件以满足我们的要求

在关于简单附加组件的小节中，我们讨论了两个必须满足的要求，以便使我们的附加组件能够在任何 Spring MVC Web 应用程序中配置 JAMon。要求如下：

在您的 pom.xml 中添加 JAMon JAR
在应用程序上下文文件中定义 JamonPerformanceMonitorInterceptor bean

为了满足这些要求，我们将更改 JamonCommands 类，以支持 jamon setup 命令。然后我们将添加一个对应于 jamon setup 命令的操作来执行实际工作，以满足要求。

JamonCommands—JamonCommands 类现在只有两个方法：isInstallJamon 检查 jamon setup 命令是否可用， installJamon 用于在触发 jamon setup 命令时安装 JAMon。（参见清单 11。）

清单 11. JamonCommands 的代码

@Component 
@Service 
public class JamonCommands implements CommandMarker { 
	 
	private Logger log = Logger.getLogger(getClass().getName()); 

	@Reference private JamonOperations operations; 
	 
	@CliAvailabilityIndicator("jamon setup") 
	public boolean isInstallJamon() { 
		return operations.isInstallJamonAvailable(); 
	} 
	 
	@CliCommand(value = "jamon setup", help = "Setup Jamon into your project") 
	public void installJamon() { 
		operations.installJamon(); 
	} 
}

这是我们在 JamonCommands 类中所需要的。它只需要公开 jamon setup 命令，剩下的工作委托 JamonOperationsImpl 类完成。（参见清单 12。）

清单 12. JamonOperationsImpl 的代码

JamonOperationsImpl

JamonOperationsImpl need to implement two methods – \
isInstallJamonAvailable() and installJamon(). 

The isinstallJamonAvailable() method returns a boolean indicating whether 
command is available at this location or not. I want to enable JAMon only for the web
applications so we need to perform the check whether the project is 
a web application or not. To do that we will write the code as shown below 

	public boolean isInstallJamonAvailable() { 
		return projectOperations.isProjectAvailable() &&
        fileManager.exists(projectOperations.getPathResolver()
			.getIdentifier(Path.SRC_MAIN_WEBAPP, "/WEB-INF/web.xml")); 
	}

清单 12 中显示的代码使用 ProjectOperations 服务检查项目在该位置是否可用，以获得 web.xml 文件的路径（web.xml 文件只对 Web 应用程序存在）。FileManager 服务用于检查 Web.xml 是否在 ProjectOperations 指定的位置存在。

我们需要实现的第二个方法是 installJamon()，它应当在 pom.xml 中添加 JAMon 依赖项，并将 bean 定义添加到 Webmvc-config.xml。在编写该方法的代码之前，我们必须在 src/main/resources/org/xebia/roo/addon/jamon 文件夹内创建一个名为 configuration.xml 的 XML 文件。该文件夹结构是 org/xebia/roo/addon/jamon，与您的 Roo 附加组件的包结构相同。configuration.xml 定义 JAMon 版本和 JAMon JAR 依赖项，如清单 13 所示。

清单 13. configuration.xml 的内容

<?xml version="1.0" encoding="UTF-8" standalone="no"?> 
<configuration> 
    <jamon> 
        <properties> 
            <jamon.version>2.4</jamon.version> 
        </properties> 
        <dependencies> 
            <dependency> 
            <groupId>com.jamonapi</groupId> 
            <artifactId>jamon</artifactId> 
            <version>${jamon.version}</version> 
        </dependency> 
        </dependencies> 
    </jamon> 
</configuration>

下面我们编写在 pom.xml 中添加依赖项的代码，如清单 14 所示。

清单 14. pom.xml 的内容

	public void installJamon() { 
		Element configuration = XmlUtils.getConfiguration(getClass()); 
		updatePomProperties(configuration); 
		updateDependencies(configuration); 
	} 

	private void updatePomProperties(Element configuration) { 
		List<Element> properties = \
XmlUtils.findElements("/configuration/jamon/properties/*"
		, configuration); 
		for (Element property : properties) { 
			projectOperations.addProperty(new Property(property)); 
		} 
	} 

	private void updateDependencies(Element configuration) { 

		List<Dependency> dependencies = new ArrayList<Dependency>(); 
		List<Element> jamonDependencies = XmlUtils.findElements(
			"/configuration/jamon/dependencies/dependency", configuration); 
		for (Element dependencyElement : jamonDependencies) { 
			dependencies.add(new Dependency(dependencyElement)); 
		} 
		projectOperations.addDependencies(dependencies); 
	}

这是在 pom.xml 中添加依赖项的标准机制，您可以在大多数 Roo 附加组件中找到它。清单 14 中所示的代码很显而易见，使用 Spring Roo 实用程序类 XmlUtils 读取 configuration.xml 中的内容，然后使用 ProjectOperations 服务更新 pom.xml 文件。

在添加了 pom.xml 依赖项之后，我们需要创建一个单独的 Spring 配置，即 web-jamon-config.xml，它包含 JamonPerformanceMonitorInterceptor 的 bean 定义。

清单 15. web-jamon-config.xml 的内容

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


	<bean id="jamonPerformanceMonitorInterceptor" 
		class=\
"org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor"> 
		<property name="trackAllInvocations" value="true"></property> 
		<property name="useDynamicLogger" value="true"></property> 
	</bean> 

	<bean id="autoProxyCreator" 
		class=\
"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
		<property name="interceptorNames"> 
			<list> 
				<idref bean="jamonPerformanceMonitorInterceptor" /> 
			</list> 
		</property> 
		<property name="beanNames"> 
			<list> 
				<value></value> 
			</list> 
		</property> 
	</bean> 

</beans>

在清单 15 所示的 web-jamon-config.xml 文件中，我们已经配置了基于 Spring 的应用程序中的 JAMon 所需的一切。我惟一没有指定的是要监控的 bean 的名称。代码生成器无法预测这个，因此需要附加组件开发人员进行指定。

现在我们需要编写将该 web-jamon-config.xml 文件复制到 web_INF/spring 文件夹的代码，webmvc-config.xml 也在该文件夹中，还要编写 add import 语句的代码，该语句在 webmvc-config.xml 中要导入 web-jamon-config.xml（参见清单 16）。

清单 16. 操作 pom.xml 的代码

public void installJamon() { 
		 
	// update pom.xml code 
	PathResolver pathResolver =

        projectOperations.getProjectMetadata().getPathResolver(); 
	String resolvedSpringConfigPath = pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP,

        "/WEB-INF/spring"); 
	if (fileManager.exists(resolvedSpringConfigPath + "/web-jamon-config.xml")) { 
			return; 
	} 
	copyTemplate("web-jamon-config.xml", resolvedSpringConfigPath); 
		 
	String webMvcConfigPath = resolvedSpringConfigPath + "/webmvc-config.xml"; 

	new XmlTemplate(fileManager).update(webMvcConfigPath, new DomElementCallback() { 
		public boolean doWithElement(Document document, Element root) { 
			if (null ==
               XmlUtils.findFirstElement\
("/beans/import[@resource='web-jamon-config.xml']",
                   root)) { 
                   Element element = document.createElement("import"); 
		        element.setAttribute("resource", "web-jamon-config.xml"); 
				root.appendChild(element); 
		        return true; 
		    } 
		    return false; 
		   } 
	}); 
		 
} 
	 
private void copyTemplate(String templateFileName, String resolvedTargetDirectoryPath) { 
	
    try { 
	    FileCopyUtils.copy(TemplateUtils.getTemplate(getClass(),
               templateFileName), fileManager.createFile(
	            resolvedTargetDirectoryPath + "/" +
                   templateFileName).getOutputStream()); 
	} catch (IOException e) { 
           throw new IllegalStateException(
               "Encountered an error during copying of resources for Jamon addon.", e); 
    } 
}

上面使用的 XmlTemplate 类来自于 Spring Web flow 附加组件。因此您需要将 Web flow 附加组件的依赖项添加到您的附加组件中（参见清单 17）。

清单 17. 添加 Web flow 附加组件的依赖项

<dependency> 
		<groupId>org.springframework.roo</groupId> 
		<artifactId>org.springframework.roo.addon.web.flow</artifactId> 
		<version>${roo.version}</version> 
      		<type>bundle</type> 
	</dependency>

在清单 17 中，roo.version 是您所使用的 Roo 的版本。

我们在该附加组件中需要做的最后一件事是配置项目日志，并设置要跟踪的日志级别。这通过 LoggingOperations 完成，它是 log4j 附加组件的操作类。要使用该类，我们首先需要在 pom.xml 文件中添加日志附加依赖项，如清单 18 所示。

清单 18. 添加日志附加依赖项的 XML 代码

	<dependency> 
		<groupId>org.springframework.roo</groupId> 
		<artifactId>org.springframework.roo.addon.logging</artifactId> 
		<version>${roo.version}</version> 
      		<type>bundle</type> 
	</dependency>

在 pom.xml 中添加了依赖项之后，使用以下代码行将 LoggingOperation 添加到 JamonOperationsImpl 类中：

@Reference private LoggingOperations loggingOperations;

下一步，将下面的代码添加到 installJamon 方法：

loggingOperations.configureLogging(LogLevel.TRACE, LoggerPackage.PROJECT);

这是我们需要为该附加组件编写的所有代码。 JamonOperationsImpl 类的完整代码如清单 19 所示。

清单 19. JamonOperationsImpl 的完整代码

@Component 
@Service 
public class JamonOperationsImpl implements JamonOperations { 
       @Reference private FileManager fileManager; 
       @Reference private ProjectOperations projectOperations; 
       @Reference private LoggingOperations loggingOperations; 


       public boolean isInstallJamonAvailable() { 
               return projectOperations.isProjectAvailable() && 
fileManager.exists(projectOperations.getPathResolver()
.getIdentifier(Path.SRC_MAIN_WEBAPP,"/WEB-INF/web.xml")); 
       } 


       public void installJamon() { 
               Element configuration = XmlUtils.getConfiguration(getClass()); 
               updatePomProperties(configuration); 
               updateDependencies(configuration); 
               PathResolver pathResolver = 
projectOperations.getProjectMetadata().getPathResolver(); 
               String resolvedSpringConfigPath = 
pathResolver.getIdentifier(Path.SRC_MAIN_WEBAPP, 
            "/WEB-INF/spring"); 
               if (fileManager.exists(resolvedSpringConfigPath 
+ "/web-jamon-config.xml")) { 
                       return; 
               } 


               copyTemplate("web-jamon-config.xml", resolvedSpringConfigPath); 
                
               String webMvcConfigPath = resolvedSpringConfigPath 
+ "/webmvc-config.xml";


               new XmlTemplate(fileManager).update(webMvcConfigPath, 
new DomElementCallback() { 
                       public boolean doWithElement(Document document, Element root) {
                            if (null == XmlUtils.findFirstElement(
"/beans/import[@resource='web-jamon-config.xml']",
root)) { 
                                 
Element element = document.createElement("import"); 
                                element.setAttribute("resource", "web-jamon-config.xml"); 
                                root.appendChild(element); 
                                return true; 
                             } 
                             return false; 
                       } 
               });
               loggingOperations.configureLogging(LogLevel.TRACE, 
LoggerPackage.PROJECT); 
       } 
        
       private void copyTemplate(String templateFileName, 
String resolvedTargetDirectoryPath) { 
               try { 
FileCopyUtils.copy(
      TemplateUtils.getTemplate(getClass(), templateFileName),
              fileManager.createFile(resolvedTargetDirectoryPath + "/" + 
              templateFileName).getOutputStream()); 
               } catch (IOException e) { 
                       throw new IllegalStateException(
               "Encountered an error during copying of resources for Jamon addon.", e);
               } 
       } 
        
       private void updatePomProperties(Element configuration) { 
               List<Element> properties = XmlUtils
     .findElements("/configuration/jamon/properties/*",configuration);
               for (Element property : properties) { 
                       projectOperations.addProperty(new Property(property));
               } 
       } 


       private void updateDependencies(Element configuration) { 
               List<Dependency> dependencies = new ArrayList<Dependency>(); 
               List<Element> jamonDependencies = XmlUtils.findElements(
           "/configuration/jamon/dependencies/dependency", configuration); 
               for (Element dependencyElement : jamonDependencies) { 
                       dependencies.add(new Dependency(dependencyElement)); 
               } 
               projectOperations.addDependencies(dependencies); 
       } 
        
}

您可以从 Google 代码库下载该附加组件的完整源代码。现在我们使用刚刚创建的附加组件将 JAMon 支持添加到我们的应用程序：

退出 roo shell 并运行 mvn clean install 命令。在构建过程中，它会询问 GPG 密码。
在构建完 Roo 附加组件后，打开一个新命令行并创建一个名为 jamon-client 的目录。我们将为我们的附加组件创建一个简单的客户端。
转到目录 jamon-client 并输入 roo 命令，以打开 Roo shell。

在 Roo shell 中执行清单 20 中的命令。这会创建一个简单的 Spring MVC Web 应用程序。

清单 20. 创建简单的 MVC Web 应用程序

project --topLevelPackage com.shekhar.roo.jamon.client --projectName jamon-client 
persistence setup --provider HIBERNATE --database
HYPERSONIC_IN_MEMORY
entity --class ~.domain.MyUser
field string --fieldName name --notNull
controller all --package ~.web

要安装该附加组件，请输入：
```
osgi start --url <a
href="../../../../">file:///</a><location \
to addon target folder >
/org.xebia.roo.addon.jamon-0.1.0.BUILD-SNAPSHOT.jar
```
这样能够安装并激活我们的 JAMon 附加组件。您可以使用 osgi ps 命令查看该附加组件的状态。
输入 jamon setup 命令，您将看到在您的应用程序中配置的 JAMon。如果您现在使用 mvn tomcat:run 运行您的应用程序，您在控制台不会看到任何日志，因为您还没有配置任何要监控的 bean。让我们在 web-jamon-config.xml 中使用清单 21 中的代码配置我们的 myUserController bean。
清单 21. web-jamon-config.xml 中 myUserController 的配置
```
<bean id="autoProxyCreator" 
		class=\
"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
		<property name="interceptorNames"> 
			<list> 
				<idref bean="jamonPerformanceMonitorInterceptor" /> 
			</list> 
		</property> 
		<property name="beanNames"> 
			<list> 
				<value>myUserController</value> 
			</list> 
		</property> 
	</bean>
```

现在使用 mvn tomcat:run 运行该应用程序，您将在您的 maven 控制台看到 JAMon 日志。示例如清单 22 所示。

清单 22. 示例 JAMon 日志

TRACE MyUserController - JAMon performance statistics for method 
[MyUserController.populateMyUsers]: 
JAMon Label=MyUserController.populateMyUsers, Units=ms.: (LastValue=187.0, 
Hits=1.0, Avg=187.0, Total=187.0, Min=187.0, Max=187.0, Active=0.0, Avg 
Active=1.0, Max Active=1.0, First Access=Wed May 18 15:33:41 IST 2011, Last 
Access=Wed May 18 15:33:41 IST 2011)

在测试过您的附加组件在您的开发系统中运行良好后，您可以将其推送到我们创建的 Google 代码项目中。要对外发布附加组件，请遵循我们用来发布 i18n 附加组件的过程。同样，要在 RooBot 上注册该附加组件，请遵循 i18n 注册过程。

回页首

结束语

我们探究了 Spring Roo 附加架构，以及如何编写国际化和简单的附加组件。附加架构对于 Roo 非常重要，因为它为 Roo 提供了快速添加新功能的灵活性。对于开发人员来说，该附加架构非常重要，因为它能够满足他们的要求而无需等待功能在全局实现。过些时候，如果将一个功能纳入到 Roo 中，可以相对容易地改变实现来删除自定义解决方案。

在该 “ Spring Roo 简介” 系列的第 4 部分，我将讨论如何编写高级的包装附加组件。

原文地址：http://www.ibm.com/developerworks/cn/opensource/os-springroo3/

iteye_10717

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Roo 简介，第 3 部分: 开发 Spring Roo 的附加组件(转)

入门在本 “Spring Roo 简介” 系列的 Spring Roo 简介，第 1 部分：从源代码构建和 Spring Roo 简介，第 2 部分：使用 Spring Roo 开发应用程序，我们使用 Spring Roo 从头开始构建了一个功能完整的企业应用程序。前两篇文章专注于使用 Spring Roo 的快速应用开发环境构建 Web 应用程序。我们涵盖了许多功能，如：JPA、S...
复制链接

扫一扫