Spring 博客

所有帖子
工程
发布
新闻和事件

Green Beans：Maven 和 Spring 入门

工程 | Josh Long | 2011 年 1 月 17 日 | ...

Apache Maven 是一个流行的开源工具，它提供了一种约定优于配置的方法来管理项目构建。事实上，Eclipse Community Surveys 显示 Maven 的采用率从2009 年的 8% 增长到2010 年的 28%，这凸显了它在各种项目设置中的有用性。即使您可以在不使用 Maven 的情况下使用 Spring，但仍有许多理由建议 Spring 开发人员使用它。在本文中，我将向您展示如何开始使用 Maven，以及如何成功地将其与 Spring 库、仓库和工具（如SpringSource Tool Suite 和Spring Roo）结合使用。

Maven 处理项目构建。如果您的项目遵循 Maven 的约定，Maven 可以相对轻松地提供强大的功能和复杂性。它是声明式的；您描述*要*做什么，而不是*如何*做。如果您来自 Make 或 Ant 等传统的构建工具，这种方法会显得不同。

您在 Maven 项目配置中声明项目的依赖项。然后，这些依赖项会被为您解析并下载。这类似于许多不同操作系统中的包系统。假设您使用的是 OS X 的 fink 或 ports 命令行工具。要更新操作系统的功能，用户会在管理客户端中选择一个包（例如，最新的安全补丁，或新版本的 glib 库）来安装，然后指示客户端从称为包仓库的已知服务器下载并安装它。下载包后，包管理器会查看包的清单，其中列出了该包所依赖的所有库（位于其他包中）——其传递依赖项。这些也会被下载。

如果你还没有安装 Maven，有几种安装方法。你可以从 Apache 网站 下载。选择一个较新的版本。目前，很多人在使用 Maven 2.21，或者最近发布的 Maven 3。下载你想要使用的版本，然后将其解压到你选择的目录。另外，许多操作系统在包系统中提供了 Maven 2 的构建（很快也会有 Maven 3 的构建）。例如，在 Ubuntu 上，你可以运行 sudo apt-get install maven2 。如果你使用的是 SpringSource Tool Suite（可在此免费下载），那么你无需担心，Maven 已经下载并包含在你的 STS 安装文件夹中了。无论你如何将 Maven 二进制文件安装到你的系统上，都要确保该二进制文件在操作系统的搜索路径中。通常，这只需要将 Maven 安装目录下的 bin 文件夹添加到操作系统的 PATH 变量中即可。最好也为 Maven 安装本身创建一个名为 MAVEN_HOME 的系统变量。在 Unix（包括 OS X）或 Linux 机器上，设置方法大同小异。在我的机器（一台 Ubuntu Linux 机器）上，它是这样的：

export MAVEN_HOME=/home/jlong/bin/springsource/maven-2.2.1.RELEASE 
export PATH=$PATH:$MAVEN_HOME/bin

要进行测试，请打开一个新的 shell 并发出以下命令

mvn --version

您应该会看到一些输出，确认命令存在于您的系统中，如下所示

jlong@jlong-mbp:~/Desktop/code$ mvn --version 
Apache Maven 2.2.1 (r801777; 2009-08-06 12:16:01-0700) 
Java version: 1.6.0_22 
Java home: /usr/lib/jvm/java-6-sun-1.6.0.22/jre 
Default locale: en_US, platform encoding: UTF-8 
OS name: "linux" version: "2.6.35-22-generic" arch: "amd64" Family: "unix" 
jlong@jlong-mbp:~/Desktop/code$

Maven 入门

Maven 项目假定有一个标准的目录结构，该结构至少看起来像这样

./pom.xml
./src
./src/main
./src/main/java
./src/main/resources
./src/test
./src/test/java
./src/test/resources

目录结构的最顶层是一个 XML 文件（始终称为 pom.xml），Maven 期望在该位置找到它。pom.xml（POM 是 Project Object Model 的缩写）描述了项目特有的、无法自动推断的内容，例如依赖项、项目名称等。

目录 描述目录内容（相对于项目根目录）
src/main/java 包含项目的 Java 源代码
src/main/resources 包含项目任何类路径相关的资源（例如，Spring 应用程序上下文 .xml 文件）
src/test/java 包含你的测试类的 Java 源代码。此目录不会包含在最终构建中。此处的所有测试都将被编译并运行。如果测试失败，则中止构建。
src/test/resources 此目录不会包含在最终的 Java 构建中。此文件夹包含你的测试代码的任何类路径相关的资源（例如，一个 Spring 应用程序上下文 .xml 文件）。

让我们构建一个使用 Spring Framework 的简单 Maven 项目。在你的硬盘上创建一个类似上面的目录结构。如果你使用的是类 Unix 操作系统，你可以使用以下命令来处理项目目录内的目录设置：

mkdir spring-example1; 
cd spring-example1; 
mkdir -p src/{test,main}/{java,resources}

创建一个名为 pom.xml 的文本文件。在文件中输入以下内容：

<?xml version="1.0" encoding="UTF-8"?> 
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <modelVersion>4.0.0</modelVersion> 

  <groupId>org.springsource.greenbeans.maven</groupId> 
  <artifactId>example1</artifactId> 
  <version>1.0-SNAPSHOT</version> 
 
  <name>Our Simple Project</name> 
   
</project>

现在让我们暂时忽略此文件的内容。我们只需要知道该文件的内容足以唯一标识项目给 Maven，并让 Maven 完成它的工作。让我们直接跳到重点：在项目的根文件夹中 - 与 pom.xml 同一个文件夹 - 在命令行上运行以下命令：

mvn install

第一次运行时，这可能需要（相当）长的时间。你会在屏幕上看到大量的下载进度数字快速滚动。这些进度数字表明 Maven 的依赖项和插件正在被下载。Maven 没有构建“目标”的概念。相反，Maven 有一个生命周期阶段的概念。这里，install 是一个阶段。这些阶段按顺序依次调用。对于每个阶段，都有预打包的插件被注册并在每个阶段调用。Maven 已经配置了良好的默认插件，所以你通常不需要过多处理，但了解正在发生什么是有帮助的。用户可以覆盖或添加插件，并配置它们在任何所需的阶段运行。当一个阶段被调用时，所有在其之前的阶段都会首先被调用。以下是标准阶段以及对每个阶段意图的解释。请记住，不同的项目可能会为这些阶段配置不同的插件。

阶段 描述
validate 对项目本身进行健全性检查
compile 编译源代码
test 运行编译后的测试类（委托给特定的单元测试插件运行程序，如 jUnit 或 TestNG）
package 从编译后的代码和类路径资源生成一个工件，并将其存储在项目根目录的 target 文件夹中
integration-test 处理并部署打包的工件到集成测试环境
verify 运行检查以确认包是否有效
install 将打包的工件安装到你的本地存储库。你的本地存储库是一个文件夹，其中存储和缓存了所有下载的依赖项。后续尝试解析缓存中已有的依赖项的构建将不会重新下载依赖项，而是使用本地存储库中的依赖项。通常，它位于你的主目录下的 .m2 文件夹中，名为 repository。因此，在我的系统上，这将是 /home/jlong/.m2/repository
deploy 将最终工件复制到另一个环境。通常是一个共享服务器，以便不同的团队可以共享一个共享依赖项。

所以，Maven 构建遵循阶段，并且每个项目最终通过运行这些阶段来产生一个工件。你可以通过在 pom.xml 文件中指定 <packaging> 元素来更改生成的工件类型。在上面的示例中，我们省略了 packaging 元素，因此默认为 jar 类型。其他打包类型包括 war 和 ear。

考虑到以上所有因素，我们上面简单的调用应该显得相当强大了！

mvn install 指示 Maven - 除其他事项外 - 下载所有插件和依赖项（如果尚未下载并缓存），编译源代码，运行单元测试，构建一个 .jar 文件，将生成的 .jar 文件安装到项目根目录下的 target 文件夹中，并将生成的 .jar 文件安装到本地存储库 ~/.m2/repository。由于阶段是标准的，目录是标准的，默认配置的插件也是标准的，因此你应该能够获取任何 Maven 项目，并运行 mvn install，并可预测地获得一个经过测试、可用的二进制文件。

有时你希望 Maven 丢弃“target”文件夹中的所有内容并从头开始。为此，你可以在“install”命令之前使用“clean”命令。这将删除任何预先构建的二进制文件，然后安装工件。

mvn clean install

表明你的身份！

所有 Maven 项目都可以通过其 artifactId、groupId 和 version 元素的组合来唯一标识。这些信息提供了项目的“坐标”。我们在 pom.xml 文件中指定的信息告诉 Maven 我们项目的坐标。Maven 可以通过指定具有唯一坐标的依赖项，在编译和执行期间自动将其他工件（依赖项）添加到项目的类路径中。以下是坐标三个最重要的部分的概述。

坐标元素 描述
groupId groupId 可以是任何东西。可以将其视为构建的 Java 包。通常，它是你的组织域与项目的组合。例如，Spring Integration 项目的 groupId 是：org.springframework.integration
artifactIdartifactId 是 groupId 中此特定工件的名称。一个 groupId 可能对许多不同的工件通用，这些工件共同描述了一个完整的系统。ArtifactIds 可以根据目的、模块名称或任何其他区分符来命名。Spring Integration File 支持具有以下 artifactId：spring-integration-file
版本 这是项目的版本。Maven 版本可以是固定数字，也可以是 SNAPSHOT。项目的最终 GA 版本可能是 1.0 或 3.5 等。然而，在开发过程中，相同的项目被认为是最终发布的快照。Maven 可以通过 SNAPSHOT 后缀来适应这一点，该后缀告诉 Maven“获取最新构建”。一个示例版本可能是 1.0-SNAPSHOT，这翻译为“1.0 的最新构建”。

我们的项目唯一地标识了自己

  

<groupId>org.springsource.greenbeans.maven</groupId>:<artifactId>example1</artifactId>:<version>1.0-SNAPSHOT</version>

一旦你 installed 了这个项目，任何其他项目都可以通过将其作为依赖项添加到你的 Maven pom.xml 文件中来依赖它。这对其他项目也同样有效。让我们修改 pom.xml 以依赖 Spring Framework。你的新 pom.xml 文件将如下所示：



<?xml version="1.0" encoding="UTF-8"?> 
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <modelVersion>4.0.0</modelVersion> 

  <groupId>org.springsource.greenbeans.maven</groupId> 
  <artifactId>example2</artifactId> 
  <version>1.0-SNAPSHOT</version> 
 
  <name>Our Simple Project</name> 

  <dependencies> 
       <dependency> 
            <groupId>org.springframework</groupId> 
            <artifactId>spring-context</artifactId> 
            <version>3.0.5.RELEASE</version>
       </dependency>
  </dependencies>
</project>

重新运行 mvn install，你应该会开始看到 Spring Framework 库 - 以及它所依赖的库 - 被下载下来。检查输出，你会看到 Maven 从公共存储库 http://repo1.maven.org 下载依赖项。有许多公共存储库，Maven 默认会咨询其中几个。这些存储库只是具有目录的 HTTP 服务器。你通常可以在浏览器中检查它们来搜索你想要的特定依赖项。例如，如果你想查看所有可用的 Spring Framework 依赖项，你可能需要浏览到 URL http://repo1.maven.org/maven2/org/springframework/。要查看所有 Spring Integration 依赖项，请浏览到 http://repo1.maven.org/maven2/org/springframework/integration/。要查看所有 Spring Batch 依赖项，请浏览到 http://repo1.maven.org/maven2/org/springframework/batch/ 等。SpringSource 还维护着几个 Maven 存储库，其中包含我们最新的依赖项，例如 http://maven.springframework.org 和 spring-roo-repository.springsource.org

这些存储库都遵循通用布局，并且它们都包含关于存储在标准位置的每个工件的元数据。这种存储库结构已成为事实上的标准，现在其他工具消费它们非常普遍。除了 Maven 之外，还有其他更专业的构建工具现在消费和生成与 Maven 相同的元数据。

Maven 的默认设置对于大多数构建来说已经足够了，但偶尔你会发现有必要在构建阶段期间调整 Maven 的行为，或者偶尔添加一个可以独立于任何阶段调用的功能。在 Maven 中，你使用插件来更改这些设置。我经常改变的一件事是编译器的语言支持。我通常想使用 Java 5 或更高版本，而 Maven 2 的默认行为是 1.4。我们将覆盖默认的 Maven 编译器行为并配置特定的语言兼容性。下面是更新后的 Maven 项目文件。



<?xml version="1.0" encoding="UTF-8"?> 
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <modelVersion>4.0.0</modelVersion> 

  <groupId>org.springsource.greenbeans.maven</groupId> 
  <artifactId>example2</artifactId> 
  <version>1.0-SNAPSHOT</version> 
 
  <name>Our Simple Project</name> 

  <dependencies> 
       <dependency> 
            <groupId>org.springframework</groupId> 
            <artifactId>spring-context</artifactId>
            <version>3.0.5.RELEASE</version>
       </dependency>
  </dependencies>

  <build>

    <plugins>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>

        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>

      </plugin>
    </plugins>
  </build>
</project>

有大量的插件可用，还有许多其他插件由各种社区项目贡献。一个常见的插件用途是将 aspectj-compiler 插件添加到 compile 阶段，以确保 AspectJ aspect 被正确编译。另一个常见的需求是为基于 WSDL 的 Web 服务合同生成 Java 接口。通常，一个插件可以独立使用，不与任何特定的构建阶段绑定。Maven 允许你调用单个插件，而无需调用整个构建。插件通常提供几个特定的命令。要调用插件，请使用以下形式：

mvn [plugin-name]:[command-name]

插件名称可以是一个别名，也可以是一个完全限定的插件名称。来自 Maven 项目存储库的插件是别名的，易于使用。一个非常有用的插件是 Maven 依赖插件。依赖插件支持许多命令。人们常见的需求是获取附加到给定项目的（传递的或非传递的）所有依赖项的清单。Maven 依赖插件可以打印一个树，显示项目中所有依赖项。像这样调用它：

 mvn dependency:tree

注意：此插件的输出在 Maven 3 中不可靠，STS 还包含了一个相关的依赖项的视觉图。在我的系统上，输出如下：

jlong@jlong-mbp:~/Desktop/mavenspring/code/example1$ mvn dependency:tree 
[INFO] Scanning for projects... 
[INFO] Searching repository for plugin with prefix: 'dependency'. 
[INFO] ------------------------------------------------------------------------ 
[INFO] Building Our Simple Project 
[INFO]    task-segment: [dependency:tree] 
[INFO] ------------------------------------------------------------------------ 
[INFO] [dependency:tree {execution: default-cli}] 
[INFO] org.springsource.greenbeans.maven:example1:jar:1.0-SNAPSHOT 
[INFO] +- log4j:log4j:jar:1.2.16:compile 
[INFO] +- org.springframework:spring-jdbc:jar:3.0.5.RELEASE:compile 
[INFO] |  +- org.springframework:spring-beans:jar:3.0.5.RELEASE:compile 
[INFO] |  +- org.springframework:spring-core:jar:3.0.5.RELEASE:compile 
[INFO] |  |  \- commons-logging:commons-logging:jar:1.1.1:compile 
[INFO] |  \- org.springframework:spring-tx:jar:3.0.5.RELEASE:compile 
[INFO] |     \- aopalliance:aopalliance:jar:1.0:compile 
[INFO] +- org.springframework:spring-context:jar:3.0.5.RELEASE:compile 
[INFO] |  +- org.springframework:spring-aop:jar:3.0.5.RELEASE:compile 
[INFO] |  +- org.springframework:spring-expression:jar:3.0.5.RELEASE:compile 
[INFO] |  \- org.springframework:spring-asm:jar:3.0.5.RELEASE:compile 
[INFO] \- junit:junit:jar:4.5:compile 
[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD SUCCESSFUL 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total time: 4 seconds 
[INFO] Finished at: Wed Jan 10 02:07:36 PST 2011 
[INFO] Final Memory: 22M/279M 
[INFO] ------------------------------------------------------------------------ 
jlong@jlong-mbp:~/Desktop/mavenspring/code/example1$

现在你知道了依赖图的样子。另一个常见问题是如何将所有依赖项汇集到一个文件夹中。这对于最近的 Spring Framework 用户来说尤其常见。核心 Spring Framework 不再提供所有依赖项，因为像 Maven 这样的工具可以更轻松地获取所有依赖项。特别是 dependency 插件使这更容易。运行 mvn dependency:copy-dependencies 命令，所有依赖项将被放入项目的 target/dependency/ 文件夹中。这是我系统上的输出：

jlong@jlong-mbp:~/Desktop/mavenspring/code/example1$ mvn dependency:copy-dependencies 
[INFO] Scanning for projects... 
[INFO] Searching repository for plugin with prefix: 'dependency'. 
[INFO] ------------------------------------------------------------------------ 
[INFO] Building Our Simple Project 
[INFO]    task-segment: [dependency:copy-dependencies] 
[INFO] ------------------------------------------------------------------------ 
[INFO] [dependency:copy-dependencies {execution: default-cli}] 
[INFO] Copying aopalliance-1.0.jar to /home/jlong/...example1/target/dependency/aopalliance-1.0.jar 
[INFO] Copying commons-logging-1.1.1.jar to /home/jlong/...example1/target/dependency/commons-logging-1.1.1.jar 
[INFO] Copying junit-4.5.jar to /home/jlong/...example1/target/dependency/junit-4.5.jar 
[INFO] Copying log4j-1.2.16.jar to /home/jlong/...example1/target/dependency/log4j-1.2.16.jar 
[INFO] Copying spring-aop-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-aop-3.0.5.RELEASE.jar 
[INFO] Copying spring-asm-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-asm-3.0.5.RELEASE.jar 
[INFO] Copying spring-beans-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-beans-3.0.5.RELEASE.jar 
[INFO] Copying spring-context-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-context-3.0.5.RELEASE.jar 
[INFO] Copying spring-core-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-core-3.0.5.RELEASE.jar 
[INFO] Copying spring-expression-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-expression-3.0.5.RELEASE.jar 
[INFO] Copying spring-jdbc-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-jdbc-3.0.5.RELEASE.jar 
[INFO] Copying spring-tx-3.0.5.RELEASE.jar to /home/jlong/...example1/target/dependency/spring-tx-3.0.5.RELEASE.jar 
[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD SUCCESSFUL 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total time: 3 seconds 
[INFO] Finished at: Wed Jan 12 02:18:02 PST 2011 
[INFO] Final Memory: 22M/279M 
[INFO] ------------------------------------------------------------------------ 
jlong@jlong-mbp:~/Desktop/mavenspring/code/example1$

在 SpringSource Tool Suite 中使用 Maven

Maven 鼓励可重现的构建。命令是标准的，阶段、插件配置和项目类型，都是标准的。任何安装了 Maven 的开发人员都应该能够获取项目的源代码及其 pom.xml 文件，并精确地重建它，就像原始开发人员在其私人工作站上构建它一样。理论上，不需要在构建文件周围闲逛来调试构建逻辑，也很少需要采取特殊措施来设置构建所需的（属性文件、shell 变量等）环境。这个

Maven 的 pom.xml 文件指定了构建项目所需的一切。它指定了编译所需的库，知道使用哪个编译器，知道哪些源代码放在哪里。它知道你的项目的一切。因此，像 SpringSource Tool Suite 这样的优秀工具包含（即 M2Eclipse 插件，它为 Eclipse 衍生物提供了出色的 Maven 支持）直接导入 Maven 项目的功能，这并不奇怪。首先，我们需要将项目导入 STS。为此：转到 File > Import > Maven > General，然后浏览到包含你的 pom.xml 的文件夹。

在这个例子中，我们已经将一个 Maven 项目导入到 STS 环境中，但你也可以在 STS 中创建基于 Maven 的项目。STS 提供了许多使用 Maven 的模板项目，你可以访问它们。只需转到 File > New > Spring Template Project 并选择其中一个项目。它们也基于 Maven，所以它们是快速入门的好方法。

你现在在 STS 中拥有了一个工作的 Maven 项目，并且可以立即开始编码。浏览“Package Explorer”。你会看到项目中的一个“Maven Dependencies”库，其中包含 Maven pom 中指定的依赖项以及传递依赖项。你还会注意到 M2Eclipse 插件已正确添加了 Maven 在 STS 中所需的四个源代码根目录。

此时，我们已经有了一个工作的 STS 项目，它已经设置好了类路径并且能够正确构建。我不知道你怎么样，但我的第一反应是 - 这个项目感觉就像一块干净的白板，迫不及待地等待着被描绘 - 就是开始编写代码。毕竟，我还有工作要做！通常，我会添加 jUnit 并保存 pom.xml 文件。

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.5</version>
</dependency>

此时，STS 会自动更新项目中的 Maven 依赖项。

然后，我通常会添加一个日志框架，并保存它

```xml log4j log4j 1.2.16 ```

然后，我将开始添加我的任务所需的特定依赖项。假设我上周阅读了关于 Green Beans 的帖子，并想利用 JDBC 和 Spring 的 JdbcTemplate，我将添加它：

```xml org.springframework spring-jdbc 3.0.5.RELEASE ```

就这样！让我们写一些代码。这是 M2Eclipse Maven 集成的我个人最喜欢的特性之一。你看，亲爱的读者，我在代码中犯了很多错误。:-) 我花了很多时间运行和调试代码。我通常会破坏一些东西，需要调试我的代码和框架之间的交互。Maven 依赖项通常会随附源代码一起部署，因此 M2Eclipse 插件可以自动为你下载源代码。为了在实践中看到这一点，让我们看一下 JdbcTemplate 的代码。在 STS 中，转到 Navigate > Open Type。输入 JdbcTemplate，然后按 Enter。STS 最初会打开 .class 文件（默认行为），然后尝试在后台下载源代码。几秒钟后，你应该就能看到 JdbcTemplate 的正确源代码了。然后，你可以检查代码并设置断点，你可以在调试器中逐步执行这些断点。方便吧？

让 Spring Roo 来处理

我们已经看到 SpringSource Tool Suite 是处理 Java（以及 Spring 和 Maven）代码的理想环境。使用 Maven 和 STS 可以轻松开始 Spring 项目。然而，Spring Roo 更容易，并且已经包含在 STS 中，并且可以轻松地在 STS 中使用。我个人政策是，只要可能，就让“Spring Roo 来处理”。Spring Roo 为每个 Spring Roo 项目设置了一个优雅的 Maven 构建，因此创建 Spring Roo 项目本身就带来了很多好处。让我们创建一个 Spring Roo 项目（当然是使用 STS 的向导！），然后看看 Spring Roo 对 Maven 的支持如何简化 Maven 构建的配置。

在 STS 中，转到 File > New > Spring Roo Project。这将启动 Spring Roo 向导。你会注意到向导允许你指定 Maven 的参与程度。保留默认设置 - Full Maven Build。

这将为你留下一个新的 Maven 项目，类似于我们的第一个示例。你需要重复上一个示例中包含资源文件夹的步骤。和以前一样，你可以获得 STS 对 Maven 的所有支持，但现在你也可以通过 Spring Roo shell 与 Maven 项目配置进行交互和修改。首先，你可以使用 Roo shell 来安装新创建的项目：

perform command --mavenCommand install

这等同于运行我们之前的 mvn install。你应该对任何新创建的 Spring Roo 项目都运行它。Spring Roo 还提供了方便的、可脚本化的 shell 命令来添加和删除 Maven 依赖项。要添加 Spring Integration 框架（特别是与文件系统相关的支持），你可能会发出以下命令：

dependency add --groupId org.springframework.integration --artifactId spring-integration-file --version 2.0.0.RELEASE 
perform package

perform package 命令会生成一个完全构建的工件，因此使用此命令构建的 .war 项目（例如）就可以立即部署到你的容器中了。还有一个命令 dependency remove，可用于从 Maven 项目中删除依赖项。

总结

在这篇文章中，我们探索了 Apache Maven，一个构建和项目理解工具。我们研究了 Maven 的约定优于配置理念和声明式依赖管理如何简化项目构建。为了简化，我们然后使用了 STS，它预装了 Apache Maven、M2Eclipse 插件和 Spring Roo。

获取 Spring 新闻通讯

通过 Spring 新闻通讯保持联系

订阅

领先一步

VMware 提供培训和认证，助您加速进步。

了解更多

获得支持

Tanzu Spring 提供 OpenJDK™、Spring 和 Apache Tomcat® 的支持和二进制文件，只需一份简单的订阅。

了解更多

即将举行的活动

查看 Spring 社区所有即将举行的活动。

查看所有