• Maven使用教程

    一、Maven介绍
    我们在开发项目的过程中，会使用一些开源框架、第三方的工具等等，这些都是以jar包的方式被项目所引用，并且有些jar包还会依赖其他的jar包，我们同样需要添加到项目中，所有这些相关的jar包都会作为项目的依赖。通常，一个Java EE项目所依赖的jar包会有很多。然而，这还并非是主要问题，在管理这些jar包过程中，jar包的版本往往是最令人头疼的问题。选择一个jar包的版本，需要考虑它所依赖的jar包是否支持这个版本，并且还需要确认依赖它的jar包能不能对这个版本兼容。所以，在过去的构建项目过程中，整理出这么一堆能让项目正常运行的jar包之后，这个lib目录就会变为禁区。jar包版本更新了，我们也很少会自找麻烦去触碰它。至于是不是存在冗余的jar包？能正常运行就好了嘛。。。。
     
    Maven的出现，解决了开发过程中的这一难题。它可以对项目依赖的jar包进行管理，可以让你的项目保持基本的依赖，排除冗余jar包，并且可以让你非常轻松的对依赖的jar包进行版本升级。而这些仅仅是Maven最基本的功能，它可以在这基础上对项目进行清理、编译、测试、打包、发布等等构建项目的工作。
     
    可以说，Maven是现在Java社区中最强大的项目管理和项目构建工具，而更加值得庆幸的是，这样一个强大的工具，它的使用也是非常简单的。
     
    现在，JavaEE项目使用的开源软件都可以通过Maven来获取，并且，越来越多的公司也开始使用Maven来管理构建项目了。
     
    二、Maven下载安装
    1、配置Java运行环境
    Maven依赖Java运行环境，因此使用Maven之前需要配置Java的运行环境。下载并安装JDK，配置JDK的环境变量：
        JAVA_HOME=D:DevToolJavajdk1.6.0_38
        在path中加入%JAVA_HOME%in;
    2、安装Maven
    下载Maven最新版本的二进制zip压缩包就可以，如:apache-maven-3.0.5-bin.zip
    下载完成后，解压，例如我们把解压后的文件夹放在D:DevTool目录下。
    然后，将Maven的bin目录添加到path环境变量中，我们这里就是这个目录：D:DevToolapache-maven-3.0.4in
     
    在Windows命令提示符下，输入mvn -v测试一下，如图：
     
    这样，maven就安装完成了，就是这么简单。接下来我们先来了解一下Maven是如何来管理项目的。
     
    三、Maven依赖管理
    前面讲了，Maven最核心的就是对依赖jar包的管理，那么它是通过什么方式来进行管理的呢？
    Maven要求每一个jar包都必须明确定义自己的坐标，Maven就是通过这个坐标来查找管理这些jar包的。
    在Maven中，一个jar包的坐标是由它的groupId、artifactId、version这些元素来定义的。例如：
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.3.8</version>
        <packaging>jar</packaging>
    groupId：表明其所属组织或公司及其所属项目，命名规则为组织或公司域名反转加项目名称。
    artifactId：项目的模块名，通常与实际项目名称一致。模块的命名通常为项目名前缀加模块名。
    version：当前项目的版本号。
    packaging：定义项目的打包方式，可选值有jar、war、pom。默认为jar
    注：：一个组织或公司都会有很多的项目，而每个项目下都会划分多个模块，在开发中我们可以灵活选择依赖某个模块。而Maven管理的jar包基本都是模块性质的项目构建出的jar包。所以，artifactId通常都是模块名，而不是项目名称。项目名称是和组织名称组合作为groupId来使用的。
     
    上面的配置定义了一个Maven项目的坐标，而如果在项目中依赖这个项目时，同样是利用它的坐标来指定依赖。例如：
    <project>
        ...
        <dependencies>
            <dependency>
                <groupId>org.apache.struts</groupId>
                <artifactId>struts2-core</artifactId>
                <version>2.3.8</version>
            </dependency>
        </dependencies>
        ...
    </project>
     
    Maven的配置文件中dependencies元素包含了所有依赖的jar包，每一个jar包依赖使用dependency元素定义。
    在声明一个jar包依赖时，除了指定groupId、artifactId、version这三项基本坐标外，还可以使用使用以下元素进行配置：
    scope元素：指定依赖的范围
    exclusions元素：排除传递性依赖
     
    Maven有以下几种依赖范围：
    compile：编译依赖范围(默认值），依赖在编译、测试、运行期间都有效。
    test：测试依赖范围，只对测试的classpath有效，在编译或运行时无法使用指定为test的依赖包。
    provided：已提供的依赖范围，只对编译和测试的classpath有效，运行期间不会使用这个依赖。例如servlet-api，在运行时容器已经提供，不需要再重复引入。
    runtime：运行时依赖范围，编译时无效，只在测试和运行时使用这个依赖。
    system：系统依赖范围，和provided范围一致，但是provided是使用容器提供依赖，system是使用系统提供依赖，需要指定依赖文件路径。
     
    传递性依赖，是指依赖包对其他包的依赖，比如，我们依赖struts2-core，而strtus2-core需要依赖xwork-core、ognl等，Maven会将这些传递性依赖同时引入项目之中。这也是Maven的一大优点，简化了我们对jar包依赖的管理。而有时我们希望替换某个传递性依赖时，就需要使用exclusions排除掉这个传递性依赖，然后再添加我们自己要替换的依赖包。
     
    例如，如下一个Maven的配置文件，pom.xml：
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
    5.   
    6.     <modelVersion>4.0.0</modelVersion>  
    7.     <groupId>com.boya.spring</groupId>  
    8.     <artifactId>spring_ioc</artifactId>  
    9.     <packaging>jar</packaging>  
    10.     <version>1.0.0</version>  
    11.   
    12.     <name>${project.artifactId}</name>  
    13.     <description>Spring Ioc Sample</description>  
    14.   
    15.     <dependencies>  
    16.         <!-- spring start -->  
    17.         <dependency>  
    18.             <groupId>org.springframework</groupId>  
    19.             <artifactId>spring-core</artifactId>  
    20.             <version>3.2.0.RELEASE</version>  
    21.             <exclusions>  
    22.                 <exclusion>  
    23.                     <groupId>commons-logging</groupId>  
    24.                     <artifactId>commons-logging</artifactId>  
    25.                 </exclusion>  
    26.             </exclusions>  
    27.         </dependency>  
    28.         <dependency>  
    29.             <groupId>org.springframework</groupId>  
    30.             <artifactId>spring-beans</artifactId>  
    31.             <version>3.2.0.RELEASE</version>  
    32.         </dependency>  
    33.         <dependency>  
    34.             <groupId>org.springframework</groupId>  
    35.             <artifactId>spring-context</artifactId>  
    36.             <version>3.2.0.RELEASE</version>  
    37.         </dependency>  
    38.   
    39.         <!-- logging start -->  
    40.         <dependency>  
    41.             <groupId>org.slf4j</groupId>  
    42.             <artifactId>slf4j-api</artifactId>  
    43.             <version>1.6.4</version>  
    44.         </dependency>  
    45.         <dependency>  
    46.             <groupId>org.slf4j</groupId>  
    47.             <artifactId>slf4j-log4j12</artifactId>  
    48.             <version>1.6.4</version>  
    49.         </dependency>  
    50.         <dependency>  
    51.             <groupId>org.slf4j</groupId>  
    52.             <artifactId>jcl-over-slf4j</artifactId>  
    53.             <version>1.6.4</version>  
    54.         </dependency>  
    55.         <dependency>  
    56.             <groupId>log4j</groupId>  
    57.             <artifactId>log4j</artifactId>  
    58.             <version>1.2.16</version>  
    59.         </dependency>  
    60.         <dependency>  
    61.             <groupId>log4jdbc</groupId>  
    62.             <artifactId>log4jdbc4</artifactId>  
    63.             <version>1.2</version>  
    64.         </dependency>  
    65.   
    66.         <!--Test start-->  
    67.         <dependency>  
    68.             <groupId>junit</groupId>  
    69.             <artifactId>junit</artifactId>  
    70.             <version>4.10</version>  
    71.             <scope>test</scope>  
    72.         </dependency>  
    73.     </dependencies>  
    74. </project>  
     
    四、Maven仓库
    Maven通过项目定义的坐标来管理这些依赖，而这些依赖的物理文件是通过Maven的仓库来统一管理的。
    对于一个依赖坐标，它会按照如下方式反映到Maven的仓库中。
    1、将groupId转化为路径：将groupId中的包名分隔符(.)转换成路径分隔符(/)。对于上面的例子就是 org.apache.struts -> org/apache/struts/
    2、将artifactId转化为路径：在groupId转化的路径基础上连接artifactId。生成路径为： org/apache/struts/struts2-core/
    3、将verion转化为路径：在artifactId转化的路径基础上连接version。生成路径为： org/apache/struts/struts2-core/2.3.8/
    4、根据artifactId和version生成依赖包文件名：上例就是 struts2-core-2.3.8
    5、根据依赖的打包方式确定文件的扩展名。对于上例它的扩展名就是.jar
     
    这样根据路径和文件名就找到了这个物理文件在仓库中的位置：org/apache/struts/struts2-core/2.3.8/struts2-core-2.3.8.jar
     
    Maven的仓库分为本地仓库和远程仓库。
    本地仓库：是Maven在我们本机设置的仓库目录，默认目录为当前用户目录下的.m2/repository.
    远程仓库包括中央仓库、私服、其他公共仓库。
    中央仓库是Maven提供的远程仓库，地址是：http://repo.maven.apache.org/maven2
    私服是我们为了节省带宽和时间，提升效率，在局域网架设的私有Maven仓库。
    其他公共库有Java.net的maven库(http://download.java.net/maven/2/)和JBoss Maven库(http://repository.jboss.com/)等。
     
    Maven在根据依赖坐标查找依赖时，首先会从本地仓库查找该依赖包，当本地仓库中没有这个依赖包时，Maven会从中央仓库查找依赖，并下载到本地仓库。最后，在我们项目的classpath中引用本地仓库的依赖包路径。
    例如，当项目只依赖strtus2-core这个依赖包时，会生成这样的classpath文件：
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <classpath>  
    3.   <classpathentry kind="src" path="src/main/java" output="/src/main/webapp/WEB-INF/classes" including="**/*.java"/>  
    4.   <classpathentry kind="src" path="src/main/resources" output="/src/main/webapp/WEB-INF/classes" excluding="**/*.java"/>  
    5.   <classpathentry kind="output" path="src/main/webapp/WEB-INF/classes"/>  
    6.   <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>  
    7.   <classpathentry kind="con" path="com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER"/>  
    8.   <classpathentry kind="var" path="M2_REPO/org/apache/struts/struts2-core/2.3.8/struts2-core-2.3.8.jar" />  
    9.   <classpathentry kind="var" path="M2_REPO/org/apache/struts/xwork/xwork-core/2.3.8/xwork-core-2.3.8.jar" />  
    10.   <classpathentry kind="var" path="M2_REPO/org/apache/commons/commons-lang3/3.1/commons-lang3-3.1.jar" />  
    11.   <classpathentry kind="var" path="M2_REPO/ognl/ognl/3.0.6/ognl-3.0.6.jar" />  
    12.   <classpathentry kind="var" path="M2_REPO/javassist/javassist/3.11.0.GA/javassist-3.11.0.GA.jar" />  
    13.   <classpathentry kind="var" path="M2_REPO/asm/asm/3.3/asm-3.3.jar"/>  
    14.   <classpathentry kind="var" path="M2_REPO/asm/asm-commons/3.3/asm-commons-3.3.jar"/>  
    15.   <classpathentry kind="var" path="M2_REPO/asm/asm-tree/3.3/asm-tree-3.3.jar"/>  
    16.   <classpathentry kind="var" path="M2_REPO/org/freemarker/freemarker/2.3.19/freemarker-2.3.19.jar" />  
    17.   <classpathentry kind="var" path="M2_REPO/commons-fileupload/commons-fileupload/1.2.2/commons-fileupload-1.2.2.jar" />  
    18.   <classpathentry kind="var" path="M2_REPO/commons-io/commons-io/2.3/commons-io-2.3.jar" />  
    19. </classpath>  
    其中，本地仓库目录会使用M2_REPO变量表示，因此IDE环境未配置该变量时，需在IDE中添加这个变量的classpath。
     
    五、聚合与继承
    一个项目通常存在多个模块，每个模块都是作为一个独立的工程存在。通过Maven配置文件可以把多个模块聚合在一起进行编译发布，并且它的聚合非常简单只需要使用<modules>元素添加模块就可以完成聚合。我们参考struts2的pom.xml文件来看一下聚合的配置方式：
    1. <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/maven-v4_0_0.xsd">  
    2.     <modelVersion>4.0.0</modelVersion>  
    3.     <parent>  
    4.         <groupId>org.apache.struts</groupId>  
    5.         <artifactId>struts2-parent</artifactId>  
    6.         <version>2.3.8</version>  
    7.     </parent>  
    8.     <groupId>org.apache.struts</groupId>  
    9.     <artifactId>struts2-apps</artifactId>  
    10.     <packaging>pom</packaging>  
    11.     <name>Webapps</name>  
    12.     <modules>  
    13.         <module>blank</module>  
    14.         <module>mailreader</module>  
    15.         <module>portlet</module>  
    16.         <module>showcase</module>  
    17.         <module>rest-showcase</module>  
    18.     </modules>  
    19. ....  
    20. </project>  
    另外，在这个项目的个各模块间通常是存在引用关系，并且每个模块会引用一些相同的依赖，Maven也提供了继承的机制来管理这些共同的依赖。你可以编写一个pom.xml文件作为父级pom配置，各个模块在自己的pom.xml中继承父级pom文件，就像上面的示例那样，使用<parent>元素标识继承的父级pom文件。
     
    父级pom文件的编写：
    1、父级pom文件的packaging必须是pom，它需要作为pom文件发布以便子pom继承
    2、在父级pom可以使用<dependencyManagement>配置依赖管理。在<dependencyManagement>下的依赖声明不会引入实际依赖，但是可以让子模块继承依赖配置。例如，在子模块中我们只标识依赖的groupId和artifactId，它就可以根据父类的依赖管理获取这个依赖的version及exclussions等配置。
    3、在父级pom中可以使用<pluginManagement>配置插件管理。作用和<dependencyManagement>类似，只不过一个管理依赖一个管理插件。
     
    子模块pom文件的编写：
    1、需要使用<parent>元素标识继承的父pom
    2、可以使用<relativePath>标识父级pom的物理路径，子模块会直接从指定的路径加载父级pom文件，未指定该元素时，子模块将根据父级pom的坐标从Maven仓库查找
    3、子模块pom可以继承父级pom中除artifactId之外的大部分配置，因此子模块的groupId、version以及依赖的version都可以省略。
     
    六、Maven脚本使用
    现在大部分IDE都有插件支持Maven，使用插件可以方便的构建Maven项目，如果IDE不支持Maven插件或未安装Maven插件也可以使用一个简单的批处理脚本来完成Maven项目的构建。
    例如，保存下面内容，存储为bat格式的批处理文件
    cd %~dp0
    call mvn eclipse:clean eclipse:eclipse

    pause
    运行该文件，就会自动根据该目录下的pom.xml生成该项目的eclipse开发环境配置。
     
    在后面的教程及示例中我都是使用Maven来构建的，pom.xml的示例可以参考我后面的教程和代码示例。
  • 相关阅读:
    scp 利用 ssh 协议 复制文件
    linux (fedora 28) 制作启动U盘，启动盘
    nc 命令使用详解
    env ：让系统决定你命令的位置
    tali -f 和 tail -F 之间的区别
    斯诺克台球比赛规则 (Snooker)
    中式台球 规则 （ ChinaBilliards ）
    美式九球比赛规则 (Nine-ball)
    Tmux 使用教程 on Fedora 28
    python 3.6 的 venv 模块
  • 原文地址：https://www.cnblogs.com/Raymond-YYC/p/4054256.html
Copyright © 2020-2023  润新知