zoukankan      html  css  js  c++  java

  • Maven使用和配置

    Maven使用和配置

    一、maven安装和概念

    1. maven安装
    2. maven编译（compile）
    3. 执行测试用例（test）
    4. maven打包（package）
    5. maven依赖管理

    1、maven安装

    1. 官网下载Maven http://maven.apache.org/download.cgi
    2. 解压到存放目录
    3. 配置环境变量
    4. 检查是否安装成功（mvn -version）

    2、maven编译

    • 创建maven项目
    • 创建src文件
    • 编写pom文件
    • 执行编译命令

    编写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>org.codehaus.mojo</groupId>
  <artifactId>my-project</artifactId>
  <version>1.0.SNAPSHOT</version>
</project>

    #mvn 编译命令
mvn compile

---------------------------
[INFO] No sources to compile
[INFO] ---------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ---------------------------------------------------------------
[INFO] Total time: 0.473 s
[INFO] Finished at: 2018-08-05T15:55:44+08:00
[INFO] Final Memory: 6M/153M
[INFO] ---------------------------------------------------------------

    maven 采用了约定的方式从指项目结构中获取源码与资源文件进行编译打包:

    1. 主源码文件：${project}/src/main/java
    2. 主资源文件：${project}/src/main/resources
    3. 测试源码文件：${project}/src/test/java
    4. 测试资源文件：${project}/src/test/resources

    将java 文件移至 src/main/java 目录，重新执行编译：

    mv src/hello.java /src/main/java/hello.java
mvn compile;

    3、maven测试用例

    • 编写测试类
    • 执行测试命令

    编写测试类：

    # 创建测试目录
mkdir -p /src/test/java
# 编写 测试类
vim TestHello.java
#测试类代码------------------------
package com.test.lin;
public class TestHello{
        public void testSayHello(){
                System.out.println("run test .....");
        }
}

#执行测试指令:
mvn test

    maven 对测试类又做了约定，约定必须是Test开头的类名与test 开头的方法才会执行。

    通常测试我们是通过junit 来编译测试用例，这时就就需添加junit 的依赖。

    4、maven打包

    #mvn 打包命令
mvn package

    5、maven依赖管理

    • 在pom文件中添加junit依赖
    • 修改测试类，加入junit代码
    • 执行测试命令

    加入依懒配置:

    <dependencies>
		<dependency>
		  <groupId>junit</groupId>
		  <artifactId>junit</artifactId>
		  <version>4.0</version>
		  <scope>test</scope>
		</dependency>
</dependencies>

    修改测试类引入junit 类：

    package com.test.lin;
//引入junit 类
import org.junit.Assert;
import org.junit.Test;

public class TestHello{
  			@Test
        public void testSayHello(){
                Assert.assertEquals("","hi");
        }
}

    注意：当我们在classPath 当中加入 junit ，原来test 开头的方法不会被执行，必须加入 @Test注解才能被执行。

    在刚才的演示过程当中 ，junit jar包在哪里？是怎么加入到classPath 当中去的？maven 是在执行test 命令的时间 动态从本地仓库中去引入junit jar 包，如果找不到就会去远程仓库下载，然后在引入。

    默认远程仓库：

    默认远程仓库 maven central 其配置在

    maven-model-builder-3.2.1.jarorgapachemavenmodelpom-4.0.0.xml 位置

    本地仓库位置：

    本地仓库位置默认在 ~/.m2/respository 下

    要修改 ${M2_HOME}/conf/settings.xml 来指定仓库目录

    <!-- 指定本地仓库目录-->

    <localRepository>G:.m2 epository</localRepository>

    6、maven 核心功能总结：

    1. maven 核心作用是编译、测试、打包。

    2. 根目录下的pom.xml 文件设置分组ID与artifactId。

    3. maven 基于约定的方式从项目中获取源码与资源文件进行编译打包。

    4. 对于项目所依懒的组件与会本地仓库引用，如果本地仓库不存在则会从中央仓库下载。

    二、maven核心配置

    1. 项目依懒(内部、外部)

    2. 项目聚合与继承

    3. 项目构建配置

    1、项目依赖

    项目依赖是指maven 通过依赖传播、依赖优先原则、可选依赖、排除依赖、依赖范围等特性来管理项目ClassPath。

    1. 依赖传播特性

      我们的项目通常需要依赖第三方组件，而第三方组件又会依赖其它组件遇到这种情况Maven会将依赖网络中的所有节点都会加入ClassPath当中，这就是Maven的依赖传播特性。

      • 举例Spring MVC的依赖网络

        <!-- 添加spring web mvc演示 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.0.4.RELEASE</version>
</dependency>

        在刚刚的演示当中，项目直接依赖了spring-webmvc 叫直接依赖，而对commons-logging 依赖是通过webmvc传递的所以叫间接依赖。

    2. 依赖优先原则

      基于依赖传播特性，导致整个依赖网络会很复杂，难免会出现相同组件不同版本的情况。Maven此时会基于依赖优先原则选择其中一个版本。

      第一原则：最短路径优先。

      <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

      上述例子中commons-logging 通过spring-webmvc 依赖了1.1.3，而项目中直接依赖了1.2，基于最短路径原则项目最终引入的是1.2 版本。

      第二原则：相同路径下配置在前的优先。

    3. 可选依赖

      可选依赖表示这个依赖不是必须的。通过在 <dependency> 添 <optional>true</optional> 表示，默认是不可选的。可选依赖不会被传递。

    4. 排除依赖

      即排除指定的间接依赖。通过配置 <exclusions> 配置排除指定组件。

      <!-- 排除指定项目 -->
<exclusions>
    <exclusion>
       <groupId>org.springframework</groupId>
       <artifactId>spring-web</artifactId>
    </exclusion>
</exclusions>

    5. 依赖范围

      像junit 这个组件 我们只有在运行测试用例的时候去要用到，这就没有必要在打包的时候把junit.jar 包过构建进去，可以通过Mave 的依赖范围配置<scope>来达到这种目的。maven 总共支持以下四种依赖范围：

      compile(默认): 编译范围，编译和打包都会依赖。

      provided：提供范围，编译时依赖，但不会打包进去。如：servlet-api.jar

      runtime：运行时范围，打包时依赖，编译不会。如：mysql-connector-java.jar

      test：测试范围，编译运行测试用例依赖，不会打包进去。如：junit.jar

      system：表示由系统中CLASSPATH指定。编译时依赖，不会打包进去。配合<systemPath> 一起使用。示例：java.home下的tool.jar

      system 除了可以用于引入系统classpath 中包，也可以用于引入系统非maven 收录的第三方Jar，做法是将第三方Jar放置在 项目的 lib 目录下，然后配置 相对路径，但因system 不会打包进去所以需要配合 maven-dependency-plugin 插件配合使用。当然推荐通过将第三方Jar手动install 到仓库。

    2、项目聚合与继承

    1. 聚合

      是指将多个模块整合在一起，统一构建，避免一个一个的构建。聚合需要个父工程，然后使用 <modules> 进行配置其中对应的是子工程的相对路径。

      <modules>
    <module>lin-client</module>
    <module>lin-server</module>
</modules>

    2. 继承

      继承是指子工程直接继承父工程 当中的属性、依赖、插件等配置，避免重复配置。

      1. 属性继承：

      2. 依赖继承：

      3. 插件继承：

      上面的三个配置子工程都可以进行重写，重写之后以子工程的为准。

    3. 依赖管理

      通过继承的特性，子工程是可以间接依赖父工程的依赖，但多个子工程依赖有时并不一至，这时就可以在父工程中加入 <dependencyManagement> 声明该功程需要的JAR包，然后在子工程中引入。

      <！-- 父工程中声明 junit 4.12 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</dependencyManagement>
<!-- 子工程中引入 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
</dependency>

    4. 项目属性

      通过 <properties> 配置 属性参数，可以简化配置。

      !-- 配置proName属性 -->
<properties>
    <proName>ddd</proName>
</properties>
<!-- 引用方式 -->
${proName}
maven 默认的属性
${basedir} 项目根目录  
${version}表示项目版本;  
${project.basedir}同${basedir};  
${project.version}表示项目版本,与${version}相同;  
${project.build.directory} 构建目录，缺省为target  
${project.build.sourceEncoding}表示主源码的编码格式;  
${project.build.sourceDirectory}表示主源码路径;  
${project.build.finalName}表示输出文件名称;  
${project.build.outputDirectory} 构建过程输出目录，缺省为target/classes

    3、项目构建配置

    1. 构建资源配置

    2. 编译插件

    3. profile 指定编译环境

    构建资源配置：

    <defaultGoal>package</defaultGoal>
<directory>${basedir}/target2</directory>
<finalName>${artifactId}-${version}</finalName>

    说明：

    defaultGoal，执行构建时默认的goal或phase，如jar:jar或者package等
    directory，构建的结果所在的路径，默认为${basedir}/target目录
    finalName，构建的最终结果的名字，该名字可能在其他plugin中被改变

    三、maven生命周期

    1. 生命周期的概念和意义

    2. maven 三大生命周期与其对应的phase(阶段)

    3. 生命周期与插件的关系

    4. 生命周期与默认插件的绑定

    1、生命周期的概念和意义

    在项目构建时通常会包含清理、编译、测试、打包、验证、部署，文档生成等步骤，maven 统一对其进行了整理抽像成三个生命周期 (lifecycle)及各自对应的多个阶段(phase)。这么做的意义是：

    1. 每个阶段都成为了一个扩展点，可以采用不同的方式来实现，提高了扩展性与灵活性。

    2. 规范统一了maven 的执行路径。

    在执行项目构建阶段时可以采用jar方式构建也可以采用war包方式构建提高了灵活性。我们可以通过命令 mvn ${phase name}直接触发指定阶段的执行

    如：

    #执行清理phase
mvn clean
#执行compile phase
mvn compile
# 也可以同时执行 清理加编译
mvn clean comile

    2、maven三大生命周期与其对应的plase（阶段）

    maven 总共包含三大生生命周期

    1. clean Lifecycle ：清理生命周期，用于于清理项目

    2. default Lifecycle：默认生命周期，用于编译、打包、测试、部署等

    3. site Lifecycle 站点文档生成，用于构建站点文档

    生命周期(lifecycle) 阶段(phase) 描述(describe)
    clean Lifecycle pre-clean 预清理
    clean 清理
    post-clean 清理之后
    default Lifecycle validate 验证
    initialize 初始化
    generate-sources
    process-sources
    generate-resources
    process-resources
    compile 编译
    process-classes
    generate-test-sources
    process-test-sources
    generate-test-resources
    process-test-resources
    test-compile 编译测试类
    process-test-classes
    test 执行测试
    prepare-package 构建前准备
    package 打包构建
    pre-integration-test
    integration-test
    post-integration-test
    verify 验证
    install 上传到本地仓库
    deploy 上传到远程仓库
    site Lifecycle pre-site 准备构建站点
    site 构建站点
    post-site 构建站点之后
    site-deploy 站点部署

    三大生命周期其相互独立执行，也可以合在一起执行。但lifecycle 中的phase 是有严格执行的顺序的，比如必须是先执行完compile 才能执行pakcage 动作，此外phase 还有包含逻辑存在，即当你执行一个phase 时 其前面的phase 会自动执行。

    # 执行编译
mvn compile
# 执行打包就包含了编译指令的执行
mvn package

    3、生命周期与插件的关系

    生命周期的phase组成了项目过建的完整过程，但这些过程具体由谁来实现呢？这就是插件，maven 的核心部分代码量其实很少，其大部分实现都是由插件来完成的。比如：test 阶段就是由 maven-surefire-plugin 实现。在pom.xml 中我们可以设置指定插件目标(gogal)与phase 绑定，当项目构建到达指定phase时 就会触发些插件gogal 的执行。 一个插件有时会实现多个phas比如：maven-compiler-plugin插件分别实现了compile 和testCompile。

    总结：

    生命周期的 阶段 可以绑定具体的插件及目标

    不同配置下同一个阶段可以对应多个插件和目标

    phase==>plugin==>goal(功能)

    4、生命周期与插件的默认绑定

    在我们的项目当中并没有配置 maven-compiler-plugin 插件,但当我们执行compile 阶段时一样能够执行编译操作，原因是maven 默认为指定阶段绑定了插件实现。列如下以下两个操作在一定程度上是等价的。

    # 
mvn compile
#直接执行compile插件目标
mvn org.apache.maven.plugins:maven-compiler-plugin:3.1:compile

    四、maven自定义插件开发

    1. 插件的相关概念

    2. 常用插件的使用

    3. 开发一个自定义插件

    1、插件的相关概念

    插件坐标定位：

    插件与普通jar 包一样包含 一组件坐标定位属性即：

    groupId、artifactId、version，当使用该插件时会从本地仓库中搜索，如果没有即从远程仓库下载

    <!-- 唯一定位到dependency 插件 -->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.10</version>

    插件执行execution：

    execution 配置包含一组指示插件如何执行的属性：

    id ： 执行器命名

    phase：在什么阶段执行？

    goals：执行一组什么目标或功能？

    configuration：执行目标所需的配置文件？

    # 将插件依赖拷贝到指定目录
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>3.1.1</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>              <outputDirectory>${project.build.directory}/alternateLocation</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>true</overWriteSnapshots>
                <excludeTransitive>true</excludeTransitive>
            </configuration>
        </execution>
    </executions>
</plugin>

    2、常用插件使用

    除了通过配置的方式使用插件以外，Maven也提供了通过命令直接调用插件目标其命令格式如下：

    mvn groupId:artifactId:version:goal -D{参数名}

    # 展示pom的依赖关系树
mvn org.apache.maven.plugins:maven-dependency-plugin:2.10:tree
# 也可以直接简化版的命令，但前提必须是maven 官方插件
mvn dependency:tree

其它常用插件：
# 查看pom 文件的最终配置 
mvn help:effective-pom
# 原型项目生成
archetype:generate
#快速创建一个WEB程序
mvn archetype:generate -DgroupId=tuling -DartifactId=simple-webbapp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
#快速创建一个java 项目
mvn archetype:generate -DgroupId=tuling -DartifactId=simple-java -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

    3、开发一个自定义插件

    • 创建maven 插件项目

    • 设定packaging 为maven-plugin

    • 添加插件依赖

    • 编写插件实现逻辑

    • 打包构建插件

    插件 pom 配置：

    <?xml version="1.0" encoding="UTF-8"?>
<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>tuling</groupId>
    <version>1.0.SNAPSHOT</version>
    <artifactId>tuling-maven-plugin</artifactId>
    <packaging>maven-plugin</packaging>
    <dependencies>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugin-tools</groupId>
            <artifactId>maven-plugin-annotations</artifactId>
            <version>3.4</version>
        </dependency>
    </dependencies>
</project>

    插件实现类：

    package com.tuling.maven; 

import javafx.beans.DefaultProperty;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;

@Mojo(name = "lin")
public class LubanPlugin extends AbstractMojo {
    @Parameter
    String sex;

    @Parameter
    String describe;

    public void execute() throws MojoExecutionException, MojoFailureException {
        getLog().info(String.format("lin sex=%s describe=%s",sex,describe));
    }
}

    五、nexus私服搭建

    1. 私服的使用场景

    2. nexus 下载安装

    3. nexus 仓库介绍

    4. 本地远程仓库配置

    5. 发布项目至nexus 远程仓库

    6. 关于SNAPSHOT(快照)与RELEASE(释放) 版本说明

    1、私服的使用场景

    私服使用场景如下：

    1. 公司不能连接公网，可以用一个私服务来统一连接
    2. 公司内部jar 组件的共享

    2、nexus下载安装

    nexus下载地址：https://sonatype-download.global.ssl.fastly.net/nexus/oss/nexus-2.14.5-02-bundle.tar.gz

    解压并设置环境变量:

    #解压
shell>tar -zxvf nexus-2.14.5-02-bundle.tar.gz
#在环境变量当中设置启动用户
shell> vim /etc/profile
#添加profile文件。安全起见不建议使用root用户，如果使用其它用户需要加相应权限
export RUN_AS_USER=root

    配置启动参数：

    shell> vi ${nexusBase}/conf/nexus.properties
 #端口号
 application-port=9999
启动与停止nexus
#启动
shell>  ${nexusBase}/bin/nexus start
#停止
shell>  ${nexusBase}/bin/nexus stop

    登录nexus界面：

    地址：http://{ip}:9999/nexus/

    用户名:admin

    密码：admin123

    3、nexus仓库介绍

    3rd party：第三方仓库

    Apache Snapshots：apache 快照仓库

    Central: maven 中央仓库

    Releases：私有发布版本仓库

    Snapshots：私有 快照版本仓库

    4、本地远程仓库配置

    在pom 中配置远程仓库：

    <repositories>
    <repository>
        <id>nexus-public</id>
        <name>my nexus repository</name>
<url>http://192.168.0.147:9999/nexus/content/groups/public/</url>
    </repository>
</repositories>

    或者在settings.xml 文件中配置远程仓库镜像 效果一样，但作用范围广:

    <mirror>        
  <id>nexus-aliyun</id>
        <mirrorOf>*</mirrorOf>
        <name>Nexus aliyun</name>
  <url>http://192.168.0.147:9999/nexus/content/groups/public/</url>
</mirror> 

    5、发布项目至nexus远程仓库

    配置仓库地址：

    <distributionManagement>
    <repository>
        <id>nexus-release</id>
        <name>nexus release</name>
        <url>http://192.168.0.147:9999/nexus/content/repositories/releases/</url>
    </repository>
    <snapshotRepository>
        <id>nexus-snapshot</id>
        <name>nexus snapshot</name>
        <url>http://192.168.0.147:9999/nexus/content/repositories/snapshots/</url>
    </snapshotRepository>
</distributionManagement>

    设置 setting.xml 中设置server:

    <server>
      <id>nexus-snapshot</id>
      <username>deployment</username>
      <password>deployment123</password>
    </server>
	 <server>
      <id>nexus-release</id>
      <username>deployment</username>
      <password>deployment123</password>
    </server>

    执行deploy 命令：

    mvn deploy
  • 相关阅读:
    Linux速成（二）
    Linux速成（一）
    突如其来的有赞电话面试！
    mark一下岗位
    游戏道具上下架设计
    ET框架学习-ECS组件式编程的基本思想之于UNITY
    一个类似与地平线中的车漆画板制作
    unity用刚体做玩家移动和玩家看向鼠标点
    C#简单的消除注释
    拉格朗日差值法, 快速排序.
  • 原文地址：https://www.cnblogs.com/jinchengll/p/11968803.html
Copyright © 2011-2022 走看看