Maven备忘

Maven 笔记

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

目录:

Maven 概念

中央和远程存储库配置和解释,有些术语可能需要在 Maven 使用前理解。

  • 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
    | This is a list of proxies which can be used on this machine to connect to the network.
    | Unless otherwise specified (by system property or command-line switch), the first proxy
    | specification in this list marked as active will be used.
    |-->
    <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

    <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>
点赞