Spring 博客

所有帖子
工程
发布
新闻和活动

Green Beans: Maven 和 Spring 入门

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

Apache Maven 是一个流行的开源工具，它提供了一种约定优于配置的项目构建管理方法。事实上，Eclipse 社区调查显示 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_HOME 的系统变量，指向 Maven 安装目录本身，也是一个好习惯。在 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

在目录结构的根目录下是 Maven 所期望的一个 XML 文件（总是命名为 pom.xml）。pom.xml（POM 是 Project Object Model 的缩写）描述了项目中无法自动推断的特定内容，例如依赖项、项目名称等。

目录 描述 目录内容（相对于项目根目录）
src/main/java 包含项目的 Java 源代码
src/main/resources 包含项目中与 classpath 相关的任何资源（例如，Spring 应用上下文 .xml 文件）
src/test/java 包含测试类的 Java 源代码。这个目录不会包含在最终的构建中。其中的所有测试都会被编译并运行。如果测试失败，构建会中止。
src/test/resources 这个目录不会包含在最终的 Java 构建中。这个文件夹包含测试代码中与 classpath 相关的任何资源（例如，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 从编译的代码和 classpath 资源生成一个 artifact，并将其存储在项目根目录下的 target 文件夹中
integration-test 将打包的 artifact 处理并部署到集成测试环境中
verify 运行检查以确认包是有效的
install 将打包的 artifact 安装到你的本地仓库中。你的本地仓库是一个文件夹，其中存储并缓存了所有下载的依赖项。后续尝试解析缓存中已有的依赖项的构建不会重新下载该依赖项，而是使用本地仓库中的版本。通常，它位于你的家目录下的 .m2 文件夹中的一个名为 repository 的子文件夹中。因此，在我的系统上，这将是 /home/jlong/.m2/repository
deploy 将最终的 artifact 复制到另一个环境。通常是一个共享服务器，以便不同的团队可以共享同一个依赖项。

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

考虑到这一切，我们上面简单的调用应该显得非常强大！

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

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

mvn clean install

标识你的项目！

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

坐标元素 描述
groupId groupId 可以是任何东西。可以将其视为构建的 Java 包。通常，它是你组织的域名和项目的组合。例如，Spring Integration 项目的 groupId 是：org.springframework.integration
artifactIdartifactId 是此特定 artifact 在 groupId 中的名称。一个 groupId 可能包含许多不同的 artifact，它们共同描述一个完整的系统。ArtifactId 可以根据用途、模块名称或任何其他区分符命名。Spring Integration 文件支持的 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

这些仓库都遵循一个共同的布局，并且它们都包含存储在标准位置的每个 artifact 的元数据。这种仓库结构已成为事实标准，现在其他工具也普遍使用它们。除了 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>

有许多可用的插件，还有许多由各种社区项目贡献的插件。插件的一个常见用例是在 compile 阶段添加 aspectj-compiler 插件，以确保 AspectJ 切面正确编译。另一个常见需求是为基于 WSDL 的 Web 服务契约生成 Java 接口。通常，插件本身就很有用，并且不绑定到任何特定的构建阶段。Maven 允许你调用单个插件，而无需调用整个构建。插件通常提供它们提供的几个特定命令。要调用插件，请使用以下形式

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

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

 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$

将 Maven 与 SpringSource Tool Suite 结合使用

Maven 鼓励可重现的构建。命令是标准的，阶段、插件配置和项目类型都是标准的。任何安装了 Maven 的开发者都应该能够获取项目的源代码及其 pom.xml 文件，并完全按照原始开发者在其私人工作站上构建的方式重新构建它。理论上，应该不需要在构建文件中摸索调试构建逻辑，也很少或根本不需要通过技巧（属性文件、shell 变量等）来设置构建所需的环境。这

一个 Maven pom.xml 文件指定了构建项目所需的一切。它指定了哪些库需要可用于编译，它知道要使用哪个编译器，它知道源代码应该放在哪里。它知道关于你项目的一切。因此，像 SpringSource Tool Suite 这样优秀的工具包含了直接导入 Maven 项目的功能也就不足为奇了（即 M2Eclipse 插件，它为基于 Eclipse 的工具提供了出色的 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 插件已正确地在 STS 中添加了 Maven 所需的四个源代码根目录。

此时，我们已经有了一个可工作的 STS 项目，它已经配置了 classpath 并能正确构建。我不知道你怎么样，但在这一点上我的第一个想法——这个项目感觉就像一块干净的白色画布，就等着被画上东西——是开始写代码。毕竟，我还有工作要做！通常，我会添加 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 命令会生成一个完全构建好的 artifact，因此使用此命令构建的 .war 项目（例如）就可以立即部署到你的容器中。还有另一个命令 dependency remove，可用于从 Maven 项目中删除依赖项。

总结

在这篇文章中，我们探讨了 Apache Maven，一个构建和项目理解工具。我们了解了 Maven 的约定优于配置理念和声明性依赖管理如何简化项目构建。为了简化事情，我们接着使用了 STS，它预打包了 Apache Maven、M2Eclipse 插件以及 Spring Roo。

获取 Spring 新闻通讯

订阅 Spring 新闻通讯，保持联系

订阅

领先一步

VMware 提供培训和认证，助你快速提升。

了解更多

获取支持

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

了解更多

近期活动

查看 Spring 社区的所有近期活动。

查看全部