Maven是一个项目管理工具,它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期(Project Lifecycle),一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

  1. 版本:maven有自己的版本定义和规则
  2. 构建:可以完成编译,打包,部署等。
  3. 依赖管理:方便引入所需依赖 Jar 包,不需手动下载
  4. 文档生成:maven的site命令支持各种文档信息的发布,包括构建过程的各种输出,javadoc,产品文档等。
  5. 项目关系:一个大型的项目通常有几个小项目或者模块组成,用maven可以很方便地管理

 

Maven 安装和配置

Maven 下载:

下载地址:http://maven.apache.org/download.cgi

Maven配置环境变量:

系统配置
Windows

右键 "计算机",选择 "属性",之后点击 "高级系统设置",点击"环境变量",来设置环境变量,有以下系统变量需要配置:

新建系统变量 MAVEN_HOME,变量值:E:\Maven\apache-maven-3.3.9

编辑系统变量 Path,添加变量值:;%MAVEN_HOME%\bin

注意:注意多个值之间需要有分号隔开,然后点击确定。

 

 

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 POM

POM( Project Object Model,项目对象模型 ) 是 Maven 工程的基本工作单元,是一个XML文件,包含了项目的基本信息,用于描述项目如何构建,声明项目依赖,等等。

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

在创建 POM 之前,我们首先需要描述项目组 (groupId), 项目的唯一ID。

<!-- 工程的根标签 -->
<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">
 
    <!-- 模型版本,声明项目描述符遵循哪一个POM模型版本 -->
    <modelVersion>4.0.0</modelVersion>

    <!--父项目的坐标。如果子项目中没有规定某个元素的值,那么父项目中的对应值即为子项目的默认值 -->    
    <parent>    
         <!--被继承的父项目的构件标识符-->    
         <artifactId/>    
         <!--被继承的父项目的全球唯一标识符-->    
         <groupId/>    
         <!--被继承的父项目的版本-->    
         <version/>      
    </parent>  

    <!-- 这是工程组的标识。它在一个组织或者项目中通常是唯一的,
         如com.companyname.project-group,maven会将该项目打成的jar包放本地路径:/com/companyname/project-group -->
    <groupId>com.companyname.project-group</groupId>
 
    <!-- 这是工程的标识,项目的唯一ID,它通常是工程的名称。一个groupId下面可能多个项目,就是靠artifactId来区分的。 -->
    <!-- groupId 和 artifactId 一起定义了 artifact 在仓库中的位置 -->
    <artifactId>project</artifactId>
 
    <!--项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->
    <version>0.0.1-SNAPSHOT</version>

    <!-- 项目的打包类型:pom(父类型都为pom类型)、jar(内部调用或者是作服务使用)、war(类型为war的项目产生一个web应用) -->   
    <packaging>jar</packaging>

    <!--项目的名称, Maven产生的文档用-->     
    <name>search-resources</name>     

    <!--项目主页的URL, Maven产生的文档用-->     
    <url>http://www.missbe.cn</url>   

    <!--描述了这个项目构建环境中的前提条件,jar包的统一版本管理。-->   
    <properties>
        <!-- 编码格式 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- JDK版本 -->
        <java.version>1.8</java.version>
    </properties>

    <!-- 版本锁定,当子工程中有需要并且自行添加了具体依赖后才有效 -->
    <!-- parent中加上<dependencyManagement>,里面的依赖只能用于声明jar的版本,
         在子模块中需要再声明一次该依赖,无需声明版本。 --> 
    <dependencyManagement>
        <dependencies>     
            <dependency>    
                <!--依赖的group ID-->    
                <groupId>org.apache.maven</groupId>     
                <!--依赖的artifact ID-->    
                <artifactId>maven-artifact</artifactId>     
                <version>3.8.1</version>
                <!--依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
                    - compile :默认范围,用于编译      
                    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
                    - runtime: 在执行时需要使用      
                    - test:    用于test任务时使用      
                    - system: 需要外在提供相应的元素。通过systemPath来取得      
                    - systemPath: 仅用于范围为system。提供相应的路径      
                    - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用-->     
                <scope>test</scope> 
            </dependency>    
        </dependencies>
    </dependencyManagement>

    <!--构建项目需要的信息-->    
    <build>
          <!--使用的插件列表-->    
          <plugins>  

          </plugins>    
     </build>   
</project>

 

parent标签和dependencyManagement标签的区别:

首先我们来说说parent标签,其实这个不难解释,就是父的意思,pom也有继承的。比方说我现在有A,B,C,A是B,C的父级。现在就是有一个情况B,C其实有很多jar都是共同的,其实是可以放在父项目里面,这样,让B,C都继承A就方便管理了。在dependencyManagement标签包围的jar里面,B,C是没有继承的,也就是不会自动引入的,你要 在子项目中显示的声明一些依赖才可以引入父项目的jar(不需要指定version,scope)。parent标签是将父项目的依赖,子项目会自动引入的,这也是两者的区别。

 

什么是Maven仓库

Maven在某个统一的位置存储所有项目的共享的构件,这个统一的位置,就称之为仓库(仓库就是存放依赖和插件的地方)。分为:本地仓库 和 中央仓库。

  • 本地仓库:就是Maven在本机存储构件的地方。maven的本地仓库,在安装maven后并不会创建,它是在第一次执行maven命令的时候才被创建。maven本地仓库的默认位置:在用户的目录下都只有一个.m2/repository/的仓库目录;可以修改。
  • 中央仓库:包含了绝大多数流行的开源Java构件,以及源码、作者信息、SCM、信息、许可证信息等。开源的Java项目依赖的构件都可以在这里下载到。
    中央仓库的地址:http://repo1.maven.org/maven2/
  • 在远程仓库中又分成了3种:中央仓库、私服、其它公共库。

私服:是一种特殊的远程仓库,它是架设在局域网内的仓库。

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

 

什么是“坐标”

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

Maven坐标主要组成:

groupId:定义当前Maven项目隶属项目、组织
artifactId:定义实际项目中的一个模块
version:定义当前项目的当前版本
packaging:定义该项目的打包方式(pom/jar/war,默认为jar)
groupId、artifactId、version简称为GAV

如何获取Maven坐标:

推荐一个Maven坐标查询网站:http://mvnrepository.com/

网站上可以搜索具体的组织或项目关键字,之后复制对应的坐标到pom.xml中。如:

 

聚合与继承

什么是聚合:

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

什么是继承

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

父工程的设置:

1)父工程的pom.xml中的打包方式必须设置为pom方式;

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

    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.sm1234</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 父类型都为pom类型 --> 
    <packaging>pom</packaging>     

    <!-- 集中定义依赖版本号 -->
    <properties>
        <junit.version>4.10</junit.version>
        <spring.version>4.1.0.RELEASE</spring.version>
        <slf4j.version>1.6.4</slf4j.version>
    </properties>

    <!-- 聚合项目 -->
    <modules> 
        <module>childA</module> <!-- 不加module则不会被联合编译 -->
        <module>childB</module>
    </modules>

    <!-- 版本锁定,当子工程中有需要并且自行添加了具体依赖后才有效 -->
    <!-- parent中加上<dependencyManagement>,里面的依赖只能用于声明jar的版本,
         在子模块中需要再声明一次该依赖,无需声明版本。 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 若只存在dependencies标签,子模块可以继承里面的依赖,无需再次声明。 -->    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

 

3)子pom配置:

    <packaging>jar</packaging>  <!-- 默认类型,内部调用或者是作服务使用 --> 
    <!-- 父项目的坐标。如果项目中没有规定某个元素的值,那么父项目中的对应值即为项目的默认值 -->
    <!-- 子项目的pom.xml都需要配置parent,防止引入的包冲突(如果不加parent,会分别去编译他们引入的依赖,会重复引入包) -->
    <parent>
        <groupId>父pom所在项目的groupId</groupId>
        <artifactId>父pom所在项目的artifactId</artifactId>
        <version>父pom所在项目的版本号</version>
        <!-- 父项目的pom.xml文件的相对路径;一般可不指定 -->
        <relativePath>../parent</relativePath>
    </parent>
    <!-- 例如 -->
    <parent>
        <groupId>cn.sm1234</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <!-- 子pom间存在引用关系,比如childB引用到了childA的jar包 -->
    <dependency>
        <groupId>com.module</groupId>
        <artifactId>childA</artifactId> <!--加上childA的依赖-->
        <version>1.0-SNAPSHOT</version>
    </dependency>

    <!-- 依赖 -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!-- 版本号由父工程里面统一指定不再需要特别指定 -->
            <!-- <version>${junit.version}</version> -->
            <scope>test</scope>
        </dependency>
    </dependencies>

 

 

Maven 常用插件

Maven的核心仅仅定义了抽象的生命周期,具体的任务都是交由插件完成的。
每个插件都能实现多个功能,每个功能就是一个插件目标。Maven的生命周期与插件目标相互绑定,以完成某个具体的构建任务。例如;compile就是插件maven-compiler-plugin的一个插件目标。

1. maven-source-plugin提供项目自动将源码打包并发布的功能

<build>
    <plugins>
        <!-- 配置打项目源码包的插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>2.2.1</version>
        </plugin>
    </plugins>
</build>

 

  1. 执行 mvn install,maven会自动将source install到repository 。
  2. 执行 mvn deploy,maven会自动将source deploy到remote-repository 。
  3. 执行 mvn source:jar,单独打包源码。

注意:在多项目构建中,将source-plugin置于顶层或parent的pom中并不会发挥作用,必须置于具体项目的pom中。

2. 添加tomcat插件;以后可以针对项目快速配置多个不同端口的tomcat

<!-- 配置Tomcat插件 -->
<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <configuration>
        <path>/</path>
        <port>8080</port>
        <uriEncoding>UTF-8</uriEncoding>
        <server>tomcat7</server>
    </configuration>
</plugin>

 

配置参数:
path:是访问应用的路径
port:是tomcat 的端口号
uriEncoding:URL按UTF-8进行编码,这样就解决了中文参数乱码。
Server:指定tomcat名称。

3. Spring Boot 的Maven插件

Spring Boot的Maven插件(Spring Boot Maven plugin)能够以Maven的方式为应用提供Spring Boot的支持,即为Spring Boot应用提供了执行Maven操作的可能。
Spring Boot Maven plugin能够将Spring Boot应用打包为可执行的jar或war文件,然后以通常的方式运行Spring Boot应用。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.0.1.RELEASE</version>
        </plugin>
    </plugins>
</build>

 

posted on 2019-08-11 09:24  FuYingju  阅读(76)  评论(0编辑  收藏  举报