Maven备忘

2023年2月14日 202次阅读

Maven 笔记

https://www.yiibai.com/maven/enable-proxy-setting-in-maven.html

Maven本地资源库
Maven 的本地资源库是用来存储项目的依赖库，默认的文件夹是 “.m2” 目录，可能需要将其更改为另一个文件夹。 settings.xml中可配置
Maven中央存储库http://repo1.maven.org/maven2/
Maven 中央存储库是 Maven 用来下载所有项目的依赖库的默认位置。不必配置，可以在http://search.maven.org/#browse查找
如何从Maven远程存储库下载？，如何添加远程库？
并非所有的库存储在Maven的中央存储库，很多时候需要添加一些远程仓库来从其他位置，而不是默认的中央存储库下载库。pom.xml中可添加
Maven依赖机制
这里的文章是关于传统方式和Maven方式的依赖库的不同，并说明 Maven 会从那里搜索这些库。
定制库到Maven本地资源库
很多库仍然不支持 Maven 的 pom.xml 的概念，这里有一个指南来说明如何包括“非Maven支持”库到 Maven 本地资源库中。

settings.xml

我们可以通过这个文件来定义本地仓库、远程仓库和联网使用的代理信息等。这些在IDEA编辑器中也可以在用户偏好中设置。

settings.xml位置
- 当前用户->.m2下面
- 全局 mvn安装目录conf/, 不存在则自建
settings.xml中主要包括以下元素：
- localRepository：
  表示Maven用来在本地储存信息的本地仓库的目录。默认是用户家目录下面的.m2/repository目录。
```
<settings>
```
```
  </settings>

  ```
```
- interactiveMode：表示是否使用交互模式，默认是true；如果设为false，那么当Maven需要用户进行输入的时候，它会使用一个默认值。
- offline：表示是否离线，默认是false。这个属性表示在Maven进行项目编译和部署等操作时是否允许Maven进行联网来下载所需要的信息。
- pluginGroups：在pluginGroups元素下面可以定义一系列的pluginGroup元素。表示当通过plugin的前缀来解析plugin的时候到哪里寻找。pluginGroup元素指定的是plugin的groupId。默认情况下，Maven会自动把org.apache.maven.plugins和org.codehaus.mojo添加到pluginGroups下。
- proxies：其下面可以定义一系列的proxy子元素，表示Maven在进行联网时需要使用到的代理。当设置了多个代理的时候第一个标记active为true的代理将会被使用。
```
    <proxies>
        <proxy>
            <id>xxx</id>
            <active>true</active>
            <protocol>http</protocol>
            <username>用户名</username>
            <password>密码</password>
            <host>代理服务器地址</host>
            <port>代理服务器的端口</port>
            <nonProxyHosts>不使用代理的主机 </nonProxyHosts>
        </proxy>
    </proxies>
```
```

<proxies>
  <proxy>
  <id>optional</id>
  <active>true</active>
  <protocol>http</protocol>
  <username>yiibai</username>
  <password>password</password>
  <host>proxy.yiibai.com</host>
  <port>8888</port>
  <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
</proxy>
</proxies>
```
- servers：其下面可以定义一系列的server子元素，表示当需要连接到一个远程服务器的时候需要使用到的验证方式。这主要有username/password和privateKey/passphrase这两种方式。以下是一个使用servers的示例：
```
      <servers>
        <server>
            <id>id</id>
            <username>用户名</username>
            <password>密码</password>
            </server>
        </servers>
```
- mirrors：用于定义一系列的远程仓库的镜像。我们可以在pom中定义一个下载工件的时候所使用的远程仓库。但是有时候这个远程仓库会比较忙，所以这个时候人们就想着给它创建镜像以缓解远程仓库的压力，也就是说会把对远程仓库的请求转换到对其镜像地址的请求。每个远程仓库都会有一个id，这样我们就可以创建自己的mirror来关联到该仓库，那么以后需要从远程仓库下载工件的时候Maven就可以从我们定义好的mirror站点来下载，这可以很好的缓解我们远程仓库的压力。在我们定义的mirror中每个远程仓库都只能有一个mirror与它关联，也就是说你不能同时配置多个mirror的mirrorOf指向同一个repositoryId
  - id：是用来区别mirror的，所有的mirror不能有相同的id
  - mirrorOf：用来表示该mirror是关联的哪一个仓库，其值为其关联仓库的id。当要同时关联多个仓库时，这多个仓库之间可以用逗号隔开；当要关联所有的仓库时，可以使用“”表示；当要关联除某一个仓库以外的其他所有仓库时，可以表示为“,!repositoryId”；当要关联不是localhost或用file请求的仓库时，可以表示为“external:*”。
  - url：表示该镜像的url。当Maven在建立系统的时候就会使用这个url来连接到我们的远程仓库。

```
<mirrors>
    <mirror>
        <id>mirrorId</id>
        <mirrorOf>repositoryId</mirrorOf>
        <name>定义一个容易看懂的名称 </name>
        <url>http://my.repository.com/repo/path</url>
    </mirror>
</mirrors>
```

远程仓库

默认情况下，Maven从Maven中央仓库<>下载所有依赖关系。但是，有些库丢失在中央存储库，只有在Java.net或JBoss的储存库远程仓库中能找到。
修改pom.xml

<project ...>
    <repositories>  <!--Java.net-->
        <repository>
            <id>java.net</id>
            <url>https://maven.java.net/content/repositories/public/</url>
        </repository>
    </repositories>
    <repositories>
        <repository>   <!--JBoss-->
            <id>JBoss repository</id>
            <url>http://repository.jboss.org/nexus/content/groups/public/</url>
        </repository>
    </repositories>
</project>

现在，Maven的依赖库查询顺序更改为：

在 Maven 本地资源库中搜索，如果没有找到，进入第 2 步，否则退出。
在 Maven 中央存储库搜索，如果没有找到，进入第 3 步，否则退出。
在java.net Maven的远程存储库搜索，如果没有找到，提示错误信息，否则退出。

添加依赖jar包示例：

<dependencies>
    <dependency>
        <groupId>org.jvnet.localizer</groupId>
        <artifactId>localizer</artifactId>
        <version>1.8</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
</dependencies>

自定义jar包

mvn install:install-file -Dfile=jars/ojdbc6.jar -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.3 -Dpackaging=jar

    <dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc6</artifactId>
        <version>11.2.0.3</version>
    </dependency>

Maven Pom

配置

project dependencies
plugins
goals
build profiles
project version
developers
mailing list

所有的 POM 文件要项目元素必须有三个必填字段: groupId，artifactId，version

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.yiibai.project-group</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
<project>

超级POM
所有的POM继承自父类(尽管明确界定)。这个基础的 POM 被称为超级 POM，并包含继承默认值。 Maven使用有效的POM(超级POM加项目配置的配置)执行有关目标。它可以帮助开发人员指定最低配置的详细信息写在 pom.xml 中。
```
mvn help:effective-pom
```

构建生命周期

一个典型的 Maven 构建生命周期是由下列顺序的阶段：

阶段	处理	描述
准备资源	资源复制	资源复制可以进行定制
编译	执行编译	源代码编译在此阶段完成
包装	打包	创建JAR/WAR包如在 pom.xml 中定义提及的包
安装	安装	这一阶段在本地/远程Maven仓库安装程序包

当 Maven 开始建立一个项目，它通过定义序列阶段步骤和执行注册的每个阶段的目标。 Maven有以下三种标准的生命周期：

clean
default(或 build)
site

mvn clean dependency:copy-dependencies package

在这里，清洁的阶段，将首先执行，然后是依赖关系：复制依赖性的目标将被执行，并终于将执行包阶段。

clean(清洁生命周期)

在基于Maven的项目中，很多缓存输出在“target”文件夹中。如果想建立项目部署，必须确保清理所有缓存的输出，从面能够随时获得最新的部署。

当我们执行命令 mvn clean 命令后，Maven 调用清洁的生命周期由以下几个阶段组成：

* pre-clean

* clean

* post-clean

当 mvn clean 命令执行时，Maven会删除编译目录

####### default( 默认（或生成）生命周期 )
maven compile
这是 Maven 主要的生命周期，用于构建应用程序。它有以下 23 个阶段。

生命周期阶段	描述
validate	验证项目是否正确，并且所有必要的信息可用于完成构建过程
initialize	建立初始化状态，例如设置属性
generate-sources	产生任何的源代码包含在编译阶段
process-sources	处理源代码，例如，过滤器值
generate-resources	包含在包中产生的资源
process-resources	复制和处理资源到目标目录，准备打包阶段
compile	编译该项目的源代码
process-classes	从编译生成的文件提交处理，例如：Java类的字节码增强/优化
generate-test-sources	生成任何测试的源代码包含在编译阶段
process-test-sources	处理测试源代码，例如，过滤器任何值
test-compile	编译测试源代码到测试目标目录
process-test-classes	处理测试代码文件编译生成的文件
test	运行测试使用合适的单元测试框架（JUnit）
prepare-package	执行必要的任何操作的实际打包之前准备一个包
package	提取编译后的代码，并在其分发格式打包，如JAR，WAR或EAR文件
pre-integration-test	完成执行集成测试之前所需操作。例如，设置所需的环境
integration-test	处理并在必要时部署软件包到集成测试可以运行的环境
pre-integration-test	完成集成测试已全部执行后所需操作。例如，清理环境
verify	运行任何检查，验证包是有效的，符合质量审核规定
install	将包安装到本地存储库，它可以用作当地其他项目的依赖
deploy	复制最终的包到远程仓库与其他开发者和项目共享

Maven是分阶段运行，因此，执行“package”阶段的时候，所有阶段 – “validate“, “compile” 和 “test“, 包括目前的阶段“package”将被执行。打包生成jar还是war取决于pom的配置，建议 mvn clean package

将项目安装到Maven本地资源库 mvn install 建议 mvn clean install

site( 网站的生命周期 )

maven site
Maven的网站插件通常用于创建新的文档，创建报告，部署网站等。目前没啥太大作用，不用太关注
阶段

pre-site

site

post-site

site-deploy

maven 资源文件(没太懂)

https://www.yiibai.com/maven/maven_build_profiles.html

生成配置文件是一组可以用来设置或覆盖 Maven 构建配置值的默认值。使用生成配置文件，你可以针对不同的环境，如：生产V/S开发环境自定义构建。

配置文件中指定 pom.xml 文件使用其配置文件/配置文件元素和多种方式来触发。配置文件修改 POM 后，在编译的时候是用来给不同的目标环境参数（例如，开发，测试和生产环境的数据库服务器的路径）。

创建配置文件的文件主要有三种类型：

类型	定义位置
Per Project	在项目中定义的POM文件, pom.xml
Per User	定义在 Maven 中的设置 XML 文件(~/.m2/settings.xml)
Global	定义在 Maven 中的全局设置 xml 文件 (Maven安装目录/conf/settings.xml)

配置文件激活

Maven 构建配置文件的文件，可以使用以下几种方式来激活。

明确使用命令从控制台输入。

通过 Maven 设置。

基于环境变量（用户/系统变量）。

OS设置（例如，Windows系列）。

呈现/丢失的文件。

现在下src/main/resources 有三个特定的文件：
文件名称描述
env.properties 如果没有配置文件关联则使用默认配置
env.test.properties 当测试配置文件用于测试配置
env.prod.properties 生产配置时，prod信息被使用
pom.xml

文件名称	描述
env.properties	如果没有配置文件关联则使用默认配置
env.test.properties	当测试配置文件用于测试配置
env.prod.properties	生产配置时，prod信息被使用

    <project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <profiles>
      <profile>
      <id>test</id>
      <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.1</version>
            <executions>
               <execution>
                  <phase>test</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                  <tasks>
                   <!--看这里， 执行了文件拷贝的工作，
                   实际代码中读env.properties这个文件 
                   疑问是{project.build.outputDirectory}是哪一个目录呢？ 生成的build文件下？-->
                     <echo>Using env.test.properties</echo>
            <copy file="src/main/resources/env.test.properties" tofile
            ="${project.build.outputDirectory}/env.properties"/>  
                  </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
      </build>
      </profile>
   </profiles>
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
</project>

看上面的配置，引入插件maven-antrun-plugin，在test阶段生效，如果非test是直接跳过的

通过配置文件名作为参数可使用 -P 选项。

mvn test -P test
mvn test -P prod 类似的

maven 插件

https://www.yiibai.com/maven/maven_plugins.html

https://www.cnblogs.com/AlanLee/p/6428859.html
Maven 是一个执行插件的框架，每一个任务实际上是由插件完成的。Maven 插件通常用于：

创建 jar 文件

创建 war 文件 

编译代码文件

进行代码单元测试

创建项目文档

创建项目报告

Maven 提供以下两种类型插件：

类型	描述
构建插件	在生成过程中执行，并在 pom.xml 中的<build/> 元素进行配置
报告插件	在网站生成期间执行，在 pom.xml 中的 <reporting/> 元素进行配置

以下是一些常见的插件列表：

插件	描述
clean	编译后的清理目标，删除目标目录
compiler	编译 Java 源文件
surefile	运行JUnit单元测试，创建测试报告
jar	从当前项目构建 JAR 文件
war	从当前项目构建 WAR 文件
javadoc	产生用于该项目的 Javadoc
antrun	从构建所述的任何阶段运行一组 Ant 任务

示例：使用 maven-antrun-plugin 插件在例子中来在控制台打印数据

<build>
<plugins>
   <plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-antrun-plugin</artifactId>
   <version>1.1</version>
   <executions>
      <execution>
         <id>id.clean</id>
         <phase>clean</phase>
         <goals>
            <goal>run</goal>
         </goals>
         <configuration>
            <tasks>
               <echo>clean phase</echo>
            </tasks>
         </configuration>
      </execution>     
   </executions>
   </plugin>
</plugins>
</build>

引入maven-antrun-plugin clean阶段生效

一个插件通常提供了一组目标，可使用以下语法来执行：
mvn [plugin-name]:[goal-name]
例如，一个 Java 项目可以使用 Maven 编译器插件来编译目标，通过运行以下命令编译
mvn compiler:compile

解释：
<id></id> <phase>对应哪个构建阶段</phase> <goals>目标 <goal>目标1<goal> <goal>目标2<goal> ...... </goals> <configuration> <task> <echo></echo> <> <task> </configuration>

插件可在 pom.xml 使用的 plugin 元素来指定；
每个插件可以有多个目标；
从插件应使用它的相位元素开始处理定义阶段。这里已经使用 clean 阶段；
可以通过将它们绑定到插件的目标来执行配置任务。这里已经绑定 echo 任务到 maven-antrun-plugin 的运行目标；可以执行多条命令<>
就这样，Maven将处理其余部分。如果没有可用的本地存储库，它会下载这个插件；

mvn创建java项目

mvn archetype:generate
-DgroupId=com.companyname.bank 
-DartifactId=consumerBanking 
-DarchetypeArtifactId=maven-archetype-quickstart 
-DinteractiveMode=false

这告诉 Maven 来从 maven-archetype-quickstart 模板创建 Java 项目。如果忽视 archetypeArtifactId 选项，一个巨大的 Maven 模板列表将列出。

项目目录：
mvn archetype:generate + maven-archetype-quickstart 模板

project-name
|-src
   |---main
   |-----java
   |-------com
   |---------yiibai   
   |-----------App.java
   |---test|-----java
   |-------com
   |---------yiibai
   |-----------AppTest.java
   |-pom.xml

打开pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.companyname.projectgroup</groupId>
      <artifactId>project</artifactId>
      <version>1.0</version>
      <dependencies>
         <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
         </dependency>
      </dependencies>  
</project>

你可以看到 Maven 已经添加了 Junit 测试框架。默认情况下 Maven 增加了一个源文件 App.java，以及在前面的章节中讨论的一样，默认目录结构中也有一个测试文件：AppTest.java。

mvn clean package
想下之前讲的，先clean目标目录(干掉build文件)，然后执行默认生命周期(直接到package步骤为止，前面包含了编译测试等工序)

现在我们已经建立项目，并创建生成最终 jar 文件，以下是主要一些概念介绍：

我们给 maven 两个目标，首先要清理目标目录（clean），然后打包项目生成 JAR（包）输出 ；

打包的 JAR 可在 consumerBanking\target 文件夹找到文件：consumerBanking-1.0-SNAPSHOT.jar ；

测试报告在 consumerBanking\target\surefire-reports 文件夹中；

Maven 编译的源代码文件，然后测试源代码文件；

然后 Maven 运行测试用例；

最后 Maven 创建包；

cd target\classes
java com.companyname.bank.App

修改代码后重新编译

mvn clean compile
cd target\classes
java -cp com.companyname.bank.App

添加外部依赖

举一个例子，让我们在 Maven创建项目这一章节中创建的项目做以下的修改。

添加 lib 文件夹到 src 文件夹

复制任何的 jar 到 lib 文件夹。这里使用的是 ldapjdk.jar，这是 LDAP 操作的辅助库。 

 <dependency>
     <groupId>ldapjdk</groupId>
     <artifactId>ldapjdk</artifactId>
     <scope>system</scope>
     <version>1.0</version>
     <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
  </dependency>

它清除以下有关外部依赖的重要概念。

外部依赖（JAR库的位置）可以在 pom.xml 中配置为与其他依赖的方式相同；

指定 groupId 同样作为库的名称；

指定 artifactId 同样作为库的名称

指定范围的系统；

指定相系统项目的位置；

Maven项目文档

mvn site

cd target/site

index.html

Maven快照

快照（SNAPSHOT ）是一个特殊版本，指出目前开发拷贝。不同于常规版本，Maven 每生成一个远程存储库都会检查新的快照版本。

现在，数据服务团队将在每次发布代码后更新快照存储库为：data-service:1.0-SNAPSHOT 替换旧的 SNAPSHOT jar。

快照与版本

在使用版本时，如果 Maven 下载所提到的版本为 data-service:1.0，那么它永远不会尝试在库中下载已经更新的版本1.0。要下载更新的代码，data-service的版本必须要升级到1.1。

在使用快照（SNAPSHOT）时，Maven会在每次应用程序UI团队建立自己的项目时自动获取最新的快照（data-service:1.0-SNAPSHOT）。

在使用快照（SNAPSHOT）时，Maven 自动获取最新的快照版本。不过我们也可以强制使用 -U 切换到任何 maven 命令来下载最新的快照版本。

mvn clean package -U

依赖方使用SNAPSHOT，自动更新1.0版本的最新SNAPSHOT

<dependencies>
      <dependency>
      <groupId>data-service</groupId>
         <artifactId>data-service</artifactId>
         <version>1.0-SNAPSHOT</version>
         <scope>test</scope>
      </dependency>
</dependencies>

提供方, 不稳定版本version提供为SNAPSHOT形式

<project xmlns="http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>data-service</groupId>
   <artifactId>data-service</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>health</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   </project>

Maven构建自动化

https://www.yiibai.com/maven/maven_build_automation.html#article-start

app-web-ui， app-desktop-ui分别依赖了bus-core-api项目

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>app_web_ui</groupId>
   <artifactId>app_web_ui</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <name>app_web_ui</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>bus_core_api</groupId>
         <artifactId>bus_core_api</artifactId>
         <version>1.0-SNAPSHOT</version>
         <scope>system</scope>
         <systemPath>C:\MVN\bus_core_api\target\bus_core_api-1.0-SNAPSHOT.jar</systemPath>
      </dependency>
   </dependencies>
</project>

现在，每当bus-core-api项目的变化时，app-web-ui和app-desktop-ui项目团队需要自己编译过程。

使用快照确保可以使用最新的 bus-core-api 项目，但要满足上面我们需要做一些额外的要求。

* 添加一个生成后的目标 bus-core-api POM的应用程序是在 app-web-ui 和 app-desktop-ui 的基础之上。

* 使用持续集成（CI）的服务器自动管理构建自动化。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
   <modelVersion>4.0.0</modelVersion> 
   <groupId>bus-core-api</groupId> 
   <artifactId>bus-core-api</artifactId>
    <version>1.0-SNAPSHOT</version> 
    <packaging>jar</packaging> 
    <build> 
        <plugins>    
         <plugin> 
            <artifactId>maven-invoker-plugin</artifactId> 
            <version>1.6</version>
             <configuration> 
                <debug>true</debug>
                 <pomIncludes>  <!--这里配置了哪些项目依赖于它-->
                    <pomInclude>app-web-ui/pom.xml</pomInclude>                     <pomInclude>app-desktop-ui/pom.xml</pomInclude> 
                 </pomIncludes> 
             </configuration> 
             <executions> 
                <execution>
                     <id>build</id>
                      <goals>
                         <goal>run</goal> 
                      </goals>
                 </execution>
             </executions>
         </plugin>
         </plugins>
    <build>
 </project>

看上面的配置，引入插件maven-invoker-plugin，在build阶段生效

cd bus-core-api
mvn clean package -U

maven会依次重新编译打包三个项目的jar包

使用Maven持续集成服务

使用CI服务器更适合作为开发人员，每次创建一个新的项目不需要更新 bus-core-api 项目的 POM，例如 app-mobile-ui 添加作为 bus-core-api 项目相关的项目。Hudson 自动管理使用 Maven 依赖管理构建自动化。

Hudson 认每个项目生成的工作。一旦一个项目的代码签入到SVN（或映射到哈德森任何源管理工具），哈德森开始它的构建工作，一旦这项工作得到完成，它会自动启动其他相关工作（其他相关项目）。

在上面的例子中，当bus-core-ui 源代码SVN更新，Hudson 开始它的构建。当构建成功，Hudson 自动查找相关的项目，并开始构建 app-web-ui 和app-desktop-ui 项目。

Maven依赖管理

https://www.yiibai.com/maven/maven_manage_dependencies.html#article-start

Maven自动化部署

https://www.yiibai.com/maven/maven_deployment_automation.html

在项目开发中，通常是部署过程包含以下步骤

检入代码在建项目全部进入SVN或源代码库中，并标记它。

从SVN下载完整的源代码。

构建应用程序。

生成输出要么WAR或EAR文件存储到一个共同的网络位置。

从网络获取的文件和文件部署到生产现场。

更新日期和应用程序的更新版本号的文件。

依赖相关配置

排除依赖
https://www.cnblogs.com/duanxz/p/6084494.html
用maven管理库依赖，有个好处就是连同库的依赖的全部jar文件一起下载，免去手工添加的麻烦，但同时也带来了同一个jar会被下载了不同版本的问题，好在pom的配置里面允许用<exclusion>来排除一些不需要同时下载的依赖jar 。

补充：如果想把当前依赖的所有传递依赖排除掉，可以使用通配符*

<dependency>
     <groupId>com.jsun.test</groupId>
     <artifactId>B</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <exclusions>
       <exclusion>
         <groupId>com.jsun.test</groupId>
         <artifactId>C</artifactId>
       </exclusion>
     </exclusions>
   </dependency>

依赖范围
https://blog.csdn.net/javaloveiphone/article/details/52081464
依赖范围由<dependency></dependency>标签中<scope></scope>标签来定义。
项目如果要使用某个框架或依赖，需要把相关jar包引用到classpath中，maven项目提供了三个classpath：编译、测试、运行。

依赖的范围用于控制依赖于三种classpath关系的，包括：compile、provided、runtime、test、system、import

    compile:默认范围，编译、测试、运行都有效
    provided:编译和测试有效，最后运行不会被加入，如tomcat依赖
    runtime:在测试和运行的时候有效，编译不会被加入，比如jdbc驱动jar
    test:测试阶段有效，比如junit
    system:与provided一致，编译和测试阶段有效，但与系统关联，可移植性差
    import:导入的范围，它只是用在dependencyManagement中，表示从其它的pom中导入dependency的配置

compile

默认就是compile，什么都不配置也就是意味着compile。compile表示被依赖项目需要参与当前项目的编译，当然后续的测试，运行周期也参与其中，是一个比较强的依赖。打包的时候通常需要包含进去。
test

scope为test表示依赖项目仅仅参与测试相关的工作，包括测试代码的编译，执行。比较典型的如junit。
runntime

runntime表示被依赖项目无需参与项目的编译，不过后期的测试和运行周期需要其参与。与compile相比，跳过编译而已，说实话在终端的项目（非开源，企业内部系统）中，和compile区别不是很大。比较常见的如JSR×××的实现，对应的API jar是compile的，具体实现是runtime的，compile只需要知道接口就足够了。oracle jdbc驱动架包就是一个很好的例子，一般scope为runntime。另外runntime的依赖通常和optional搭配使用，optional为true。我可以用A实现，也可以用B实现。
provided

provided意味着打包的时候可以不用包进去，别的设施(Web Container)会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。相当于compile，但是在打包阶段做了exclude的动作。
system

从参与度来说，也provided相同，不过被依赖项不会从maven仓库抓，而是从本地文件系统拿，一定需要配合systemPath属性使用。

例子

    <dependency>
      <groupIdjunit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <!-- 只在测试阶段使用该依赖 -->
      <scope>test</scope>
    </dependency>
    <!-- 只在编译、测试期有效，在运行期无效，运行期使用tomcat容器自己的jar包 -->
        <!-- servlet support -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- jsp support -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>

依赖冲突
**这个很重要 **
https://blog.csdn.net/javaloveiphone/article/details/52081464

算法网