我爱编程

Maven备忘

2018-05-14  本文已影响0人  点点渔火

Maven 笔记

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

目录：

Maven 概念

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

settings.xml

参考链接

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

```
<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

配置

所有的 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>

构建生命周期

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

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

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

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 复制最终的包到远程仓库与其他开发者和项目共享
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 后，在编译的时候是用来给不同的目标环境参数（例如，开发，测试和生产环境的数据库服务器的路径）。

    <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阶段生效

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

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文件存储到一个共同的网络位置。

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

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

依赖相关配置

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

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

依赖的范围用于控制依赖于三种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>
上一篇下一篇

猜你喜欢

热点阅读