精华内容
下载资源
问答
  • Maven使用教程

    2021-03-31 23:34:12
    Maven使用教程什么是Maven?下载安装Maven1、环境配置2、修改配置文件2.1、添加国内镜像源2.2、本地仓库位置修改Maven基本命令IDEA中使用Maven1、IDEA下配置Maven2、创建Maven项目3、 什么是Maven? 如今我们构建一...

    1、什么是Maven?

    如今我们构建一个项目需要用到很多第三方的类库,如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌,并且Jar包之间的关系错综复杂,一个Jar包往往又会引用其他Jar包,缺少任何一个Jar包都会导致项目编译失败。

    以往开发项目时,程序员往往需要花较多的精力在引用Jar包搭建项目环境上,而这一项工作尤为艰难,少一个Jar包、多一个Jar包往往会报一些让人摸不着头脑的异常。

    而Maven就是一款帮助程序员构建项目的工具,我们只需要告诉Maven需要哪些Jar 包,它会帮助我们下载所有的Jar,极大提升开发效率。是一个项目管理工具。

    2、下载安装Maven

    在Maven的官网即可下载,根据不同系统选择下载,点击访问Apache Maven
    在这里插入图片描述

    1、环境配置

    1. 添加M2_HOME:对应Maven的解压目录即可。
      在这里插入图片描述
    2. 添加MAVEN_HOME:对应maven的bin目录
      在这里插入图片描述
    3. 编辑Path环境变量:path = %M2_HOME%\bin
      在这里插入图片描述

    测试:在cmd窗口输入 mvn -v 查看
    显示如下即配置成功:
    在这里插入图片描述

    2、修改配置文件

    通常我们需要修改解压目录下 conf/settings.xml 文件,这样可以更好的适合我们的使用。

    注:所有的修改一定要在注释标签外面,不然修改无效。Maven很多标签都是给的例子,都是注释掉的。

    2.1、添加国内镜像源

    由于国外的镜像资源较慢,所以我们更换为国内的镜像源,这里使用阿里云的镜像源。

    更改settings.xml文件下的< mirrors>标签

     //阿里云镜像
    <mirrors>
          <mirror>
             <id>nexus-aliyun</id>
             <mirrorOf>*</mirrorOf>
             <name>Nexus aliyun</name>
             <url>http://maven.aliyun.com/nexus/content/groups/public</url>
          </mirror> 
    </mirrors>
    

    2.2、本地仓库位置修改

    Maven仓库用来存放Maven管理的所有Jar包。

    在 < localRepository>标签内添加自己的本地位置路径:

      <!--配置本地仓库 -->
      <localRepository>D:\Maven\apache-maven-3.6.3\maven-repository</localRepository>
    

    Maven基本命令

    1. -v:查询Maven版本:本命令用于检查maven是否安装成功。
      Maven安装完成之后,在命令行输入mvn -v,若出现maven信息,则说明安装成功。

    2. compile:编译
      将java源文件编译成class文件

    3. test:测试项目
      执行test目录下的测试用例

    4. package:打包
      将项目打成jar包

    5. clean:删除target文件夹

    6. install:安装

    3、IDEA中使用Maven

    1、IDEA下配置Maven

    打开Setting设置,找到Maven设置
    在这里插入图片描述
    1:此处修改为自己解压的Maven目录

    2:勾选Override,修改为自己目录下的settings.xml目录

    3:修改为自己的本地仓库地址:就是上面修改的本地仓库的位置

    2、创建Maven项目

    创建一个Maven项目:
    在这里插入图片描述

    填写项目名称:
    在这里插入图片描述

    选择Maven文件地址和仓库:
    在这里插入图片描述
    如果在IDEA配置了Maven,就会默认显示设置内容,就不用填写。

    Maven的目录文件结构:
    在这里插入图片描述
    maven工具栏项目结构:
    在这里插入图片描述

    4、Maven名词解释

    1、POM

    Maven项目对象模型(POM-Project Object Model),可以通过一小段描述信息来管理项目的构建,报告和文档的软件项目管理工具。具体下面在细说。

    2、坐标

    groupId , artifactId , version 三个元素是项目的坐标,唯一的标识这个项目。

    • groupId 项目所在组,一般是组织或公司

    • artifactId 是当前项目在组中的唯一ID;

    • version 表示版本,SNAPSHOT表示快照,表示此项目还在开发中,不稳定。

    groupId 和实际项目不一定是一一对应的,maven 有模块的概念,例如 spring-core, spring-context…;

    groupId 也不应该只对应公司或组织名,建议具体到项目名,因为公司或者组织下有多个项目,

    而artifactId只能代表模块名。

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    

    3、资源库

    本地资源库:用来存储所有项目的依赖关系(插件jar和其他文件)。
    默认的文件夹是“.m2”目录 Windows系统 – C:\Documents and Settings{your-username}.m2
    中央存储库:当你建立一个 Maven 的项目,Maven 会检查你的 pom.xml 文件,以确定哪些依赖下载。
    首先,Maven 将从本地资源库获得 Maven 的本地资源库依赖资源,如果没有找到,然后把它会从默认的 Maven 中下载。

    5、在IDEA配置Tomcat

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    6、POM文件

    pom.xml 是Maven的核心配置文件,包含了项目的基本信息,用于描述项目如何构建,声明项目依赖,等等。

    执行任务或目标时,Maven 会在当前目录中查找 POM。它读取 POM,获取所需的配置信息,然后执行目标。

    POM 中可以指定以下配置:

    • 项目依赖
    • 插件
    • 执行目标
    • 项目构建 profile
    • 项目版本
    • 项目开发者列表
    • 相关邮件列表信息

    1.project下的子元素

    <?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>
        <!-- 公司或者组织的唯一标志,并且配置时生成的路径也是由此生成, 如com.companyname.project-group,maven会将该项目打成的jar包放本地路径:/com/companyname/project-group -->
        <groupId>com.companyname.project-group</groupId>
     
        <!-- 项目的唯一ID,一个groupId下面可能多个项目,就是靠artifactId来区分的 -->
        <artifactId>project</artifactId>
     
        <!-- 版本号 -->
        <version>1.0</version>
        <!--打包方式,没有定义packaging时默认jar-->
        <packaging>jar</packaging>
        <!--项目构件的文件名与坐标是相对应的,一般规则:
          artifactId-version[-classfier-].packaging
          强调:packaging并非一定与构件扩展名一致,例:
          <packaging>maven-plugin</packaging>的构件扩展名为jar -->
       
        <!--项目依赖配置,可以包含一个或者多个<dependency>元素-->
        <dependencies>
            <!--每个依赖的具体配置,可以拥有多个依赖-->
            <dependency></dependency>
        </dependencies>
    </project>
    

    2. < dependencies>元素,依赖的配置:

    <!--项目依赖配置,可以包含一个或者多个<dependency>元素-->
        <dependencies>
            <!--每个依赖的具体配置-->
            <dependency>
                <!--groupId,artifactId,version基础依赖坐标-->
                <groupId> ...</groupId>
                <artifactId> ...</artifactId>
                <version> ...</version>
                <!--依赖的类型,对应于项目坐标中的packaging,一般不需要声明,默认jar-->
                <type>jar</type>
                <!--依赖范围-->
                <scope>test</scope>
                <!--标记依赖是否可选,默认false-->
                <optional>false</optional>
                <!---->
                <systemPath>{basedir}\src\lib\</systemPath>
                <!--用于排除传递性依赖-->
                <exclusions>
                    <!--要排除的具体依赖-->
                    <exclusion>
                        <artifactId> ...</artifactId>
                        <groupId> ...</groupId>
                    </exclusion>
                    .
                    .
                </exclusions>
            </dependency>
        </dependencies>
    
    展开全文
  • 超级详细的Maven使用教程

    万次阅读 多人点赞 2018-08-13 13:05:40
    什么是Maven? 如今我们构建一个项目需要用到很多第三方的类库,如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌,并且Jar包之间的关系错综复杂,一个Jar包往往又会...

    什么是Maven?

    如今我们构建一个项目需要用到很多第三方的类库,如写一个使用Spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们瞠目结舌,并且Jar包之间的关系错综复杂,一个Jar包往往又会引用其他Jar包,缺少任何一个Jar包都会导致项目编译失败。

    以往开发项目时,程序员往往需要花较多的精力在引用Jar包搭建项目环境上,而这一项工作尤为艰难,少一个Jar包、多一个Jar包往往会报一些让人摸不着头脑的异常。

    而Maven就是一款帮助程序员构建项目的工具,我们只需要告诉Maven需要哪些Jar 包,它会帮助我们下载所有的Jar,极大提升开发效率。

    安装Maven 和 Maven的Eclipse插件

     安装Maven和Maven的Eclipse插件,用Eclipse的同学可以参考,推荐使用IDEA开发;

    Maven规定的目录结构

    若要使用Maven,那么项目的目录结构必须符合Maven的规范,其目录结构如下:

    Maven基本命令

    1. -v:查询Maven版本

      本命令用于检查maven是否安装成功。

      Maven安装完成之后,在命令行输入mvn -v,若出现maven信息,则说明安装成功。

    2. compile:编译

      将java源文件编译成class文件

    3. test:测试项目

      执行test目录下的测试用例

    4. package:打包

      将项目打成jar包

    5. clean:删除target文件夹

    6. install:安装

      将当前项目放到Maven的本地仓库中。供其他项目使用

    什么是Maven仓库?

    Maven仓库用来存放Maven管理的所有Jar包。分为:本地仓库 和 中央仓库。

    • 本地仓库:Maven本地的Jar包仓库。
    • 中央仓库: Maven官方提供的远程仓库。

    当项目编译时,Maven首先从本地仓库中寻找项目所需的Jar包,若本地仓库没有,再到Maven的中央仓库下载所需Jar包。

    什么是“坐标”?

    在Maven中,坐标是Jar包的唯一标识,Maven通过坐标在仓库中找到项目所需的Jar包。

    如下代码中,groupId和artifactId构成了一个Jar包的坐标。

    <dependency>
       <groupId>cn.missbe.web.search</groupId>
       <artifactId>resource-search</artifactId>
       <packaging>jar</packaging>
       <version>1.0-SNAPSHOT</version>
    </dependency>
    • groupId:所需Jar包的项目名
    • artifactId:所需Jar包的模块名
    • version:所需Jar包的版本号

    传递依赖 与 排除依赖

    • 传递依赖:如果我们的项目引用了一个Jar包,而该Jar包又引用了其他Jar包,那么在默认情况下项目编译时,Maven会把直接引用和简洁引用的Jar包都下载到本地。
    • 排除依赖:如果我们只想下载直接引用的Jar包,那么需要在pom.xml中做如下配置:(将需要排除的Jar包的坐标写在中)
    <exclusions>
       <exclusion>
          <groupId>cn.missbe.web.search</groupId>
          <artifactId>resource-search</artifactId>
          <packaging>pom</packaging>
          <version>1.0-SNAPSHOT</version>
       </exclusion>
    </exclusions>

    依赖范围scope

    在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
    - compile :默认范围,用于编译      
    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
    - runtime: 在执行时需要使用      
    - test:    用于test任务时使用      
    - system: 需要外在提供相应的元素。通过systemPath来取得      
    - systemPath: 仅用于范围为system。提供相应的路径      
    - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用

    依赖冲突

    若项目中多个Jar同时引用了相同的Jar时,会产生依赖冲突,但Maven采用了两种避免冲突的策略,因此在Maven中是不存在依赖冲突的。

    1.短路优先

    本项目——>A.jar——>B.jar——>X.jar
    本项目——>C.jar——>X.jar
    

    若本项目引用了A.jar,A.jar又引用了B.jar,B.jar又引用了X.jar,并且C.jar也引用了X.jar。

    在此时,Maven只会引用引用路径最短的Jar。

    2.声明优先

    若引用路径长度相同时,在pom.xml中谁先被声明,就使用谁。

    聚合

    1. 什么是聚合?

      将多个项目同时运行就称为聚合。

    2. 如何实现聚合?

      只需在pom中作如下配置即可实现聚合:

    <modules>
        <module>web-connection-pool</module>
        <module>web-java-crawler</module>
    </modules>

    继承

    1. 什么是继承?

      在聚合多个项目时,如果这些被聚合的项目中需要引入相同的Jar,那么可以将这些Jar写入父pom中,各个子项目继承该pom即可。

    2. 如何实现继承?

    • 父pom配置:将需要继承的Jar包的坐标放入标签即可。

    <dependencyManagement>
        <dependencies>
              <dependency>
                <groupId>cn.missbe.web.search</groupId>
                <artifactId>resource-search</artifactId>
                <packaging>pom</packaging>
                <version>1.0-SNAPSHOT</version>
              </dependency> 
        </dependencies>
    </dependencyManagement>
    • 子pom配置:
    <parent>
          <groupId>父pom所在项目的groupId</groupId>
          <artifactId>父pom所在项目的artifactId</artifactId>
          <version>父pom所在项目的版本号</version>
    </parent>
     <parent>
          <artifactId>resource-search</artifactId>
          <groupId>cn.missbe.web.search</groupId>
          <version>1.0-SNAPSHOT</version>
    </parent>

    使用Maven构建Web项目

    1. New Maven项目:选择WebApp:

    2. 若使用JSP,需添加Servlet依赖:

      注:Servlet依赖只在编译和测试时使用!

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.0.1</version>
        <!-- 只在编译和测试时运行 -->
        <scope>provided</scope>
    </dependency>
    1. 在Bulid Path中设置resource输出目录:

    2. 勾选:Dynamic Web Module

    3. 删掉测试目录

    4. 在pom中加入jetty的插件,并设置JDK版本:

    <plugins> 
      <plugin> 
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-compiler-plugin</artifactId>  
        <configuration> 
          <source>1.8</source>  
          <target>1.8</target> 
        </configuration> 
      </plugin>  
      <plugin> 
        <groupId>org.eclipse.jetty</groupId>  
        <artifactId>jetty-maven-plugin</artifactId>  
        <version>9.3.10.v20160621</version>  
        <executions> 
          <execution> 
            <phase>package</phase> 
          </execution> 
        </executions> 
      </plugin> 
    </plugins>
    1. 运行项目:

    2. 输入:jetty:run

    3. 访问127.0.0.1:8080

      若出现如下界面,表示成功!

    pom.xml详解

    pom.xml是Maven的核心,你的项目需要什么Jar包就在pom.xml里面配置。当编译项目时Maven读取该文件,并从仓库中下载相应的Jar包。

    <?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.0http://maven.apache.org/maven-v4_0_0.xsd">  
      <!--父项目的坐标。如果项目中没有规定某个元素的值,
    那么父项目中的对应值即为项目的默认值。 
    坐标包括group ID,artifact ID和 version。-->  
      <parent> 
        <!--被继承的父项目的构件标识符-->  
        <artifactId/>  
        <!--被继承的父项目的全球唯一标识符-->  
        <groupId/>  
        <!--被继承的父项目的版本-->  
        <version/> 
      </parent>  
      <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,
    但它仍然是必不可少的,这是为了当Maven引入了新的特性或者其他模型变更的时候,
    确保稳定性。-->  
      <modelVersion>4.0.0</modelVersion>  
      <!--项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。
    并且构建时生成的路径也是由此生成, 如com.mycompany.app生成的相对路径为:
    /com/mycompany/app-->  
      <groupId>cn.missbe.web</groupId>  
      <!-- 构件的标识符,它和group ID一起唯一标识一个构件。换句话说,
    你不能有两个不同的项目拥有同样的artifact ID和groupID;在某个 
    特定的group ID下,artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西,
    Maven为项目产生的构件包括:JARs,源码,二进制发布和WARs等。-->  
      <artifactId>search-resources</artifactId>  
      <!--项目产生的构件类型,例如jar、war、ear、pom。插件可以创建
    他们自己的构件类型,所以前面列的不是全部构件类型-->  
      <packaging>war</packaging>  
      <!--项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->  
      <version>1.0-SNAPSHOT</version>  
      <!--项目的名称, Maven产生的文档用-->  
      <name>search-resources</name>  
      <!--项目主页的URL, Maven产生的文档用-->  
      <url>http://www.missbe.cn</url>  
      <!-- 项目的详细描述, Maven 产生的文档用。  当这个元素能够用HTML格式描述时
    (例如,CDATA中的文本会被解析器忽略,就可以包含HTML标 签), 
    不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面,
    你应该修改你自己的索引页文件,而不是调整这里的文档。-->  
      <description>A maven project to study maven.</description>  
      <!--描述了这个项目构建环境中的前提条件。-->  
      <prerequisites> 
        <!--构建该项目或使用该插件所需要的Maven的最低版本-->  
        <maven/> 
      </prerequisites>  
      <!--构建项目需要的信息-->  
      <build> 
        <!--该元素设置了项目源码目录,当构建项目的时候,
    构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->  
        <sourceDirectory/>  
        <!--该元素设置了项目脚本源码目录,该目录和源码目录不同:
    绝大多数情况下,该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的,而不是被编译的)。-->  
        <scriptSourceDirectory/>  
        <!--该元素设置了项目单元测试使用的源码目录,当测试项目的时候,
    构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->  
        <testSourceDirectory/>  
        <!--被编译过的应用程序class文件存放的目录。-->  
        <outputDirectory/>  
        <!--被编译过的测试class文件存放的目录。-->  
        <testOutputDirectory/>  
        <!--使用来自该项目的一系列构建扩展-->  
        <extensions> 
          <!--描述使用到的构建扩展。-->  
          <extension> 
            <!--构建扩展的groupId-->  
            <groupId/>  
            <!--构建扩展的artifactId-->  
            <artifactId/>  
            <!--构建扩展的版本-->  
            <version/> 
          </extension> 
        </extensions>  
        <!--这个元素描述了项目相关的所有资源路径列表,例如和项目相关的属性文件,
    这些资源被包含在最终的打包文件里。-->  
        <resources> 
          <!--这个元素描述了项目相关或测试相关的所有资源路径-->  
          <resource> 
            <!-- 描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。举个例 子,如果你想资源在特定的包里(org.apache.maven.messages),你就必须该元素设置为org/apache/maven /messages。
    然而,如果你只是想把资源放到源码目录结构里,就不需要该配置。-->  
            <targetPath/>  
            <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性,
    文件在filters元素里列出。-->  
            <filtering/>  
            <!--描述存放资源的目录,该路径相对POM路径-->  
            <directory/>  
            <!--包含的模式列表,例如**/*.xml.-->  
            <includes/>  
            <!--排除的模式列表,例如**/*.xml-->  
            <excludes/> 
          </resource> 
        </resources>  
        <!--这个元素描述了单元测试相关的所有资源路径,例如和单元测试相关的属性文件。-->  
        <testResources> 
          <!--这个元素描述了测试相关的所有资源路径,参见build/resources/resource元素的说明-->  
          <testResource> 
            <targetPath/>
            <filtering/>
            <directory/>
            <includes/>
            <excludes/> 
          </testResource> 
        </testResources>  
        <!--构建产生的所有文件存放的目录-->  
        <directory/>  
        <!--产生的构件的文件名,默认值是${artifactId}-${version}。-->  
        <finalName/>  
        <!--当filtering开关打开时,使用到的过滤器属性文件列表-->  
        <filters/>  
        <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。
    给定插件的任何本地配置都会覆盖这里的配置-->  
        <pluginManagement> 
          <!--使用的插件列表 。-->  
          <plugins> 
            <!--plugin元素包含描述插件所需要的信息。-->  
            <plugin> 
              <!--插件在仓库里的group ID-->  
              <groupId/>  
              <!--插件在仓库里的artifact ID-->  
              <artifactId/>  
              <!--被使用的插件的版本(或版本范围)-->  
              <version/>  
              <!--是否从该插件下载Maven扩展(例如打包和类型处理器),由于性能原因,
    只有在真需要下载时,该元素才被设置成enabled。-->  
              <extensions/>  
              <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。-->  
              <executions> 
                <!--execution元素包含了插件执行需要的信息-->  
                <execution> 
                  <!--执行目标的标识符,用于标识构建过程中的目标,或者匹配继承过程中需要合并的执行目标-->  
                  <id/>  
                  <!--绑定了目标的构建生命周期阶段,如果省略,目标会被绑定到源数据里配置的默认阶段-->  
                  <phase/>  
                  <!--配置的执行目标-->  
                  <goals/>  
                  <!--配置是否被传播到子POM-->  
                  <inherited/>  
                  <!--作为DOM对象的配置-->  
                  <configuration/> 
                </execution> 
              </executions>  
              <!--项目引入插件所需要的额外依赖-->  
              <dependencies> 
                <!--参见dependencies/dependency元素-->  
                <dependency>......</dependency> 
              </dependencies>  
              <!--任何配置是否被传播到子项目-->  
              <inherited/>  
              <!--作为DOM对象的配置-->  
              <configuration/> 
            </plugin> 
          </plugins> 
        </pluginManagement>  
        <!--使用的插件列表-->  
        <plugins> 
          <!--参见build/pluginManagement/plugins/plugin元素-->  
          <plugin> 
            <groupId/>
            <artifactId/>
            <version/>
            <extensions/>  
            <executions> 
              <execution> 
                <id/>
                <phase/>
                <goals/>
                <inherited/>
                <configuration/> 
              </execution> 
            </executions>  
            <dependencies> 
              <!--参见dependencies/dependency元素-->  
              <dependency>......</dependency> 
            </dependencies>  
            <goals/>
            <inherited/>
            <configuration/> 
          </plugin> 
        </plugins> 
      </build>  
      <!--模块(有时称作子项目) 被构建成项目的一部分。
    列出的每个模块元素是指向该模块的目录的相对路径-->  
      <modules/>  
      <!--发现依赖和扩展的远程仓库列表。-->  
      <repositories> 
        <!--包含需要连接到远程仓库的信息-->  
        <repository> 
          <!--如何处理远程仓库里发布版本的下载-->  
          <releases> 
            <!--true或者false表示该仓库是否为下载某种类型构件(发布版,快照版)开启。 -->  
            <enabled/>  
            <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是:always(一直),daily(默认,每日),interval:X(这里X是以分钟为单位的时间间隔),或者never(从不)。-->  
            <updatePolicy/>  
            <!--当Maven验证构件校验文件失败时该怎么做:ignore(忽略),fail(失败),或者warn(警告)。-->  
            <checksumPolicy/> 
          </releases>  
          <!-- 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置,
    POM就可以在每个单独的仓库中,为每种类型的构件采取不同的 策略。
    例如,可能有人会决定只为开发目的开启对快照版本下载的支持。
    参见repositories/repository/releases元素 -->  
          <snapshots> 
            <enabled/>
            <updatePolicy/>
            <checksumPolicy/> 
          </snapshots>  
          <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库-->  
          <id>banseon-repository-proxy</id>  
          <!--远程仓库名称-->  
          <name>banseon-repository-proxy</name>  
          <!--远程仓库URL,按protocol://hostname/path形式-->  
          <url>http://192.168.1.169:9999/repository/</url>  
          <!-- 用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。Maven 2为其仓库提供了一个默认的布局;然 而,Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。-->  
          <layout>default</layout> 
        </repository> 
      </repositories>  
      <!--发现插件的远程仓库列表,这些插件用于构建和报表-->  
      <pluginRepositories> 
        <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->  
        <pluginRepository>......</pluginRepository> 
      </pluginRepositories>  
      <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。
    它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->  
      <dependencies> 
        <dependency> 
          <!--依赖的group ID-->  
          <groupId>org.apache.maven</groupId>  
          <!--依赖的artifact ID-->  
          <artifactId>maven-artifact</artifactId>  
          <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->  
          <version>3.8.1</version>  
          <!-- 依赖类型,默认类型是jar。它通常表示依赖的文件的扩展名,但也有例外
    。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应,
     尽管这也有例外。一些类型的例子:jar,war,ejb-client和test-jar。
    如果设置extensions为 true,就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。-->  
          <type>jar</type>  
          <!-- 依赖的分类器。分类器可以区分属于同一个POM,但不同构建方式的构件。
    分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR,
    一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件。-->  
          <classifier/>  
          <!--依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
                    - compile :默认范围,用于编译      
                    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
                    - runtime: 在执行时需要使用      
                    - test:    用于test任务时使用      
                    - system: 需要外在提供相应的元素。通过systemPath来取得      
                    - systemPath: 仅用于范围为system。提供相应的路径      
                    - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用-->  
          <scope>test</scope>  
          <!--仅供system范围使用。注意,不鼓励使用这个元素,
    并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。
    需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如${java.home}。-->  
          <systemPath/>  
          <!--当计算传递依赖时, 从依赖构件列表里,列出被排除的依赖构件集。
    即告诉maven你只依赖指定的项目,不依赖项目的依赖。此元素主要用于解决版本冲突问题-->  
          <exclusions> 
            <exclusion> 
              <artifactId>spring-core</artifactId>  
              <groupId>org.springframework</groupId> 
            </exclusion> 
          </exclusions>  
          <!--可选依赖,如果你在项目B中把C依赖声明为可选,你就需要在依赖于B的项目(例如项目A)中显式的引用对C的依赖。可选依赖阻断依赖的传递性。-->  
          <optional>true</optional> 
        </dependency> 
      </dependencies>  
      <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,
    而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),
    如果group ID和artifact ID以外的一些信息没有描述,
    则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。-->  
      <dependencyManagement> 
        <dependencies> 
          <!--参见dependencies/dependency元素-->  
          <dependency>......</dependency> 
        </dependencies> 
      </dependencyManagement>  
      <!--项目分发信息,在执行mvn deploy后表示要发布的位置。
    有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。-->  
      <distributionManagement> 
        <!--部署项目产生的构件到远程仓库需要的信息-->  
        <repository> 
          <!--是分配给快照一个唯一的版本号(由时间戳和构建流水号)?
    还是每次都使用相同的版本号?参见repositories/repository元素-->  
          <uniqueVersion/>  
          <id>banseon-maven2</id>  
          <name>banseon maven2</name>  
          <url>file://${basedir}/target/deploy</url>  
          <layout/> 
        </repository>  
        <!--构件的快照部署到哪里?如果没有配置该元素,默认部署到repository元素配置的仓库,
    参见distributionManagement/repository元素-->  
        <snapshotRepository> 
          <uniqueVersion/>  
          <id>banseon-maven2</id>  
          <name>Banseon-maven2 Snapshot Repository</name>  
          <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>  
          <layout/> 
        </snapshotRepository>  
        <!--部署项目的网站需要的信息-->  
        <site> 
          <!--部署位置的唯一标识符,用来匹配站点和settings.xml文件里的配置-->  
          <id>banseon-site</id>  
          <!--部署位置的名称-->  
          <name>business api website</name>  
          <!--部署位置的URL,按protocol://hostname/path形式-->  
          <url>scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web</url> 
        </site>  
        <!--项目下载页面的URL。如果没有该元素,用户应该参考主页。
    使用该元素的原因是:帮助定位那些不在仓库里的构件(由于license限制)。-->  
        <downloadUrl/>  
        <!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素,
    因为这是工具自动更新的。有效的值有:none(默认),
    converted(仓库管理员从 Maven 1 POM转换过来),partner(直接从伙伴Maven 2仓库同步过来),deployed(从Maven 2实例部 署),verified(被核实时正确的和最终的)。-->  
        <status/> 
      </distributionManagement>  
      <!--以值替代名称,Properties可以在整个POM中使用,也可以作为触发条件(见settings.xml配置文件里activation元素的说明)。格式是<name>value</name>。-->  
      <properties/> 
    </project>
    

    参考原文:Maven使用详解

    展开全文
  • maven使用教程

    2018-05-01 19:36:36
    1.下载并解压maven安装包2.配置maven环境变量2.1新建系统变量MAVEN_HOME,变量值为maven的安装目录。2.2添加maven目录至系统变量Path中。3.验证maven是否安装成功打开cmd,输入mvn -version命令,能看到maven相关...


    1.下载并解压maven安装包

    2.配置maven环境变量

    2.1新建系统变量MAVEN_HOME,变量值为maven的安装目录。

    2.2添加maven目录至系统变量Path中。

    3.验证maven是否安装成功

    打开cmd,输入mvn -version命令,能看到maven相关信息,代表安装成功。

    4.配置maven本地仓库

    替换apache-maven-3.3.9\conf目录下的settings.xml文件

    5.Eclipse配置maven

    5.1 方式一:Eclipse设置user settings,选择安装maven的settings配置文件,点击更新操作。

    5.2 方式二:Eclipse设置user settings,可以不依赖于maven的安装与否,只需找到我们项目需要的settings.xml文件即可。

    6.IntelliJ IDEA中配置maven

    展开全文
  • Maven 使用教程

    2014-11-07 15:57:53
    一、Maven介绍 我们在开发项目的过程中,会使用一些开源框架、第三方的工具等等,这些都是以jar包的方式被项目所引用,并且有些jar包还会依赖其他的jar包,我们同样需要添加到项目中,所有这些相关的jar包都会作为...

    一、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:\Dev\Tool\Java\jdk1.6.0_38
        在path中加入%JAVA_HOME%\bin;
    2、安装Maven
     
    下载Maven最新版本的二进制zip压缩包就可以,如:apache-maven-3.0.5-bin.zip
    下载完成后,解压,例如我们把解压后的文件夹放在D:\Dev\Tool\目录下。
    然后,将Maven的bin目录添加到path环境变量中,我们这里就是这个目录:D:\Dev\Tool\apache-maven-3.0.4\bin
     
    在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:
    [html
    <?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/maven-v4_0_0.xsd">  
      
        <modelVersion>4.0.0</modelVersion>  
        <groupId>com.boya.spring</groupId>  
        <artifactId>spring_ioc</artifactId>  
        <packaging>jar</packaging>  
        <version>1.0.0</version>  
      
        <name>${project.artifactId}</name>  
        <description>Spring Ioc Sample</description>  
      
        <dependencies>  
            <!-- spring start -->  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-core</artifactId>  
                <version>3.2.0.RELEASE</version>  
                <exclusions>  
                    <exclusion>  
                        <groupId>commons-logging</groupId>  
                        <artifactId>commons-logging</artifactId>  
                    </exclusion>  
                </exclusions>  
            </dependency>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-beans</artifactId>  
                <version>3.2.0.RELEASE</version>  
            </dependency>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-context</artifactId>  
                <version>3.2.0.RELEASE</version>  
            </dependency>  
      
            <!-- logging start -->  
            <dependency>  
                <groupId>org.slf4j</groupId>  
                <artifactId>slf4j-api</artifactId>  
                <version>1.6.4</version>  
            </dependency>  
            <dependency>  
                <groupId>org.slf4j</groupId>  
                <artifactId>slf4j-log4j12</artifactId>  
                <version>1.6.4</version>  
            </dependency>  
            <dependency>  
                <groupId>org.slf4j</groupId>  
                <artifactId>jcl-over-slf4j</artifactId>  
                <version>1.6.4</version>  
            </dependency>  
            <dependency>  
                <groupId>log4j</groupId>  
                <artifactId>log4j</artifactId>  
                <version>1.2.16</version>  
            </dependency>  
            <dependency>  
                <groupId>log4jdbc</groupId>  
                <artifactId>log4jdbc4</artifactId>  
                <version>1.2</version>  
            </dependency>  
      
            <!--Test start-->  
            <dependency>  
                <groupId>junit</groupId>  
                <artifactId>junit</artifactId>  
                <version>4.10</version>  
                <scope>test</scope>  
            </dependency>  
        </dependencies>  
    </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仓库。
     
     
    Maven在根据依赖坐标查找依赖时,首先会从本地仓库查找该依赖包,当本地仓库中没有这个依赖包时,Maven会从中央仓库查找依赖,并下载到本地仓库。最后,在我们项目的classpath中引用本地仓库的依赖包路径。
    例如,当项目只依赖strtus2-core这个依赖包时,会生成这样的classpath文件:
    [html]  
    <?xml version="1.0" encoding="UTF-8"?>  
    <classpath>  
      <classpathentry kind="src" path="src/main/java" output="/src/main/webapp/WEB-INF/classes" including="**/*.java"/>  
      <classpathentry kind="src" path="src/main/resources" output="/src/main/webapp/WEB-INF/classes" excluding="**/*.java"/>  
      <classpathentry kind="output" path="src/main/webapp/WEB-INF/classes"/>  
      <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>  
      <classpathentry kind="con" path="com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER"/>  
      <classpathentry kind="var" path="M2_REPO/org/apache/struts/struts2-core/2.3.8/struts2-core-2.3.8.jar" />  
      <classpathentry kind="var" path="M2_REPO/org/apache/struts/xwork/xwork-core/2.3.8/xwork-core-2.3.8.jar" />  
      <classpathentry kind="var" path="M2_REPO/org/apache/commons/commons-lang3/3.1/commons-lang3-3.1.jar" />  
      <classpathentry kind="var" path="M2_REPO/ognl/ognl/3.0.6/ognl-3.0.6.jar" />  
      <classpathentry kind="var" path="M2_REPO/javassist/javassist/3.11.0.GA/javassist-3.11.0.GA.jar" />  
      <classpathentry kind="var" path="M2_REPO/asm/asm/3.3/asm-3.3.jar"/>  
      <classpathentry kind="var" path="M2_REPO/asm/asm-commons/3.3/asm-commons-3.3.jar"/>  
      <classpathentry kind="var" path="M2_REPO/asm/asm-tree/3.3/asm-tree-3.3.jar"/>  
      <classpathentry kind="var" path="M2_REPO/org/freemarker/freemarker/2.3.19/freemarker-2.3.19.jar" />  
      <classpathentry kind="var" path="M2_REPO/commons-fileupload/commons-fileupload/1.2.2/commons-fileupload-1.2.2.jar" />  
      <classpathentry kind="var" path="M2_REPO/commons-io/commons-io/2.3/commons-io-2.3.jar" />  
    </classpath>  
    其中,本地仓库目录会使用M2_REPO变量表示,因此IDE环境未配置该变量时,需在IDE中添加这个变量的classpath。
     
    五、聚合与继承
    一个项目通常存在多个模块,每个模块都是作为一个独立的工程存在。通过Maven配置文件可以把多个模块聚合在一起进行编译发布,并且它的聚合非常简单只需要使用<modules>元素添加模块就可以完成聚合。我们参考struts2的pom.xml文件来看一下聚合的配置方式:
    [html]  
    <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">  
        <modelVersion>4.0.0</modelVersion>  
        <parent>  
            <groupId>org.apache.struts</groupId>  
            <artifactId>struts2-parent</artifactId>  
            <version>2.3.8</version>  
        </parent>  
        <groupId>org.apache.struts</groupId>  
        <artifactId>struts2-apps</artifactId>  
        <packaging>pom</packaging>  
        <name>Webapps</name>  
        <modules>  
            <module>blank</module>  
            <module>mailreader</module>  
            <module>portlet</module>  
            <module>showcase</module>  
            <module>rest-showcase</module>  
        </modules>  
    ....  
    </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的示例可以参考我后面的教程和代码示例。
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,814
精华内容 1,925
关键字:

maven使用教程