Maven

  1.     自动化的项目构建工具。
  3.     make->ant->maven->gradle

优点

1、做分布式开发非常方便

2、依赖管理

安装

  1.     [https://maven.apache.org/download.cgi](https://maven.apache.org/download.cgi) 下载maven，压缩包，解压即可使用。
  3.     配置环境变量
  9.     测试maven是否安装成功：在命令行中使用 mvn -v

Maven项目的结构

  1.     **（约定大于配置）**<br />![E6_F{$0]ZDDNG9659E[2]]B.png](https://cdn.nlark.com/yuque/0/2021/png/20356700/1622260636899-8550e3f8-4dbd-49d5-8ffa-281e28f16ede.png#clientId=uf66fccb4-30b8-4&from=drop&id=u44966503&margin=%5Bobject%20Object%5D&name=E6_F%7B%240%5DZDDNG9659E%5B2%5D%5DB.png&originHeight=547&originWidth=328&originalType=binary&size=16688&status=done&style=none&taskId=u9dc7c457-94b5-4fa2-8623-e69aa248e7d)
  4.     maven在项目构建过程中，最主要的几种操作：
  • 清理：删除之前编译的结果，为下一次编译做准备。
    对应的maven命令：mvn clean
  • 编译：将java源文件编译为字节码文件。
    对应的maven命令：mvn compile(编译主程序)或者mvn test-compile(编译测试程序)
  • 测试：对项目开发的关键节点进行测试，保证项目在迭代开发过程中关键节点的正确性。
    对应的maven命令：mvn test
  • 报告：对测试结果使用标准格式进行记录和展示。
  • 打包：将一个包含诸多文件项目封装成一个可被安装或部署的包。java项目->jar，web项目->war
    对应的maven命令：mvn package
  • 安装：在maven环境中，安装是指将打包结果安装到maven的本地仓库。
    对应的maven命令：mvn install

maven的相关配置：

1、本地仓库路径

  1. <localRepository>E:/maven/repository</localRepository>

如果不配置，默认的本地仓库在c:/users/.m2目录中

一般都需要修改本地仓库路径。

2、中央仓库镜像

  1. <mirrors>
  2.       <mirror>
  3.       <id>aliyun-public</id>
  4.       <mirrorOf>*</mirrorOf>
  5.       <name>aliyun public</name>
  6.       <url>https://maven.aliyun.com/repository/public</url>
  7.     </mirror>
  9.     <mirror>
  10.       <id>aliyun-central</id>
  11.       <mirrorOf>*</mirrorOf>
  12.       <name>aliyun central</name>
  13.       <url>https://maven.aliyun.com/repository/central</url>
  14.     </mirror>
  16.     <mirror>
  17.       <id>aliyun-spring</id>
  18.       <mirrorOf>*</mirrorOf>
  19.       <name>aliyun spring</name>
  20.       <url>https://maven.aliyun.com/repository/spring</url>
  21.     </mirror>
  23.     <mirror>
  24.       <id>aliyun-spring-plugin</id>
  25.       <mirrorOf>*</mirrorOf>
  26.       <name>aliyun spring-plugin</name>
  27.       <url>https://maven.aliyun.com/repository/spring-plugin</url>
  28.     </mirror>
  30.     <mirror>
  31.       <id>aliyun-apache-snapshots</id>
  32.       <mirrorOf>*</mirrorOf>
  33.       <name>aliyun apache-snapshots</name>
  34.       <url>https://maven.aliyun.com/repository/apache-snapshots</url>
  35.     </mirror>
  37.     <mirror>
  38.       <id>aliyun-google</id>
  39.       <mirrorOf>*</mirrorOf>
  40.       <name>aliyun google</name>
  41.       <url>https://maven.aliyun.com/repository/google</url>
  42.     </mirror>
  44.     <mirror>
  45.       <id>aliyun-gradle-plugin</id>
  46.       <mirrorOf>*</mirrorOf>
  47.       <name>aliyun gradle-plugin</name>
  48.       <url>https://maven.aliyun.com/repository/gradle-plugin</url>
  49.     </mirror>
  51.     <mirror>
  52.       <id>aliyun-jcenter</id>
  53.       <mirrorOf>*</mirrorOf>
  54.       <name>aliyun jcenter</name>
  55.       <url>https://maven.aliyun.com/repository/jcenter</url>
  56.     </mirror>
  58.     <mirror>
  59.       <id>aliyun-releases</id>
  60.       <mirrorOf>*</mirrorOf>
  61.       <name>aliyun releases</name>
  62.       <url>https://maven.aliyun.com/repository/releases</url>
  63.     </mirror>
  65.     <mirror>
  66.       <id>aliyun-snapshots</id>
  67.       <mirrorOf>*</mirrorOf>
  68.       <name>aliyun snapshots</name>
  69.       <url>https://maven.aliyun.com/repository/snapshots</url>
  70.     </mirror>
  72.     <mirror>
  73.       <id>aliyun-grails-core</id>
  74.       <mirrorOf>*</mirrorOf>
  75.       <name>aliyun grails-core</name>
  76.       <url>https://maven.aliyun.com/repository/grails-core</url>
  77.     </mirror>
  79.     <mirror>
  80.       <id>aliyun-mapr-public</id>
  81.       <mirrorOf>*</mirrorOf>
  82.       <name>aliyun mapr-public</name>
  83.       <url>https://maven.aliyun.com/repository/mapr-public</url>
  84.     </mirror>
  85.   </mirrors>

修改中央仓库镜像的目的是，下载资源时从国内地址下载，下载速度加快。

3、jdk版本

  1.         <profile>
  2.                 <id>jdk-1.8</id>
  3.                 <activation>
  4.                       <activeByDefault>true</activeByDefault>
  5.                       <jdk>1.8</jdk>
  6.                 </activation>
  7.                 <properties>
  8.                       <maven.compiler.source>1.8</maven.compiler.source>
  9.                       <maven.compiler.target>1.8</maven.compiler.target>
  10.                       <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  11.                 </properties>
  12.          </profile>

maven的生命周期

  1.     maven的核心程序定义了三套相互独立的生命周期，生命周期中各个阶段的具体任务是插件来完成。
  3.     maven核心程序为了更好的实现自动化构建，设定了一个生命周期执行规则：**不管是执行生命周期中的哪一个阶段，都会从当前生命周期的最初位置开始执行**。

maven的三套生命周期

clean lifecycle
  1.     在项目构建之前执行的一些清理工作，clean生命周期包含三个阶段：
  1. pre-clean：执行清理工作之前做的一些事情
  2. clean：执行清理工作
  3. post-clean：执行完清理工作之后做的一些事情

default lifecycle
  1.     是项目构建的核心部分，编译、测试、打包、安装、部署等，default生命周期是maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。
  1. validate
  2. generate-sources
  3. process-sources
  4. generate-resources
  5. process-resources：复制并处理资源文件，放到目标目录，准备打包。
  6. compile：编译项目主程序源代码 mvn compile
  7. process-classes
  8. generate-test-sources
  9. process-test-sources
  10. generate-test-resources
  11. process-test-resources：复制并处理资源文件，放到测试目录。
  12. test-compile：编译项目测试程序源代码 mvn test-compile
  13. process-test-classes
  14. test：使用合适的单元测试框架运行测试，测试代码不会被打包和部署。 mvn test
  15. prepare-package
  16. package：接受编译好的代码，打包成可发布的格式。jar或war等。 mvn package
  17. pre-integration-test
  18. integration-test
  19. post-integration-test
  20. verify
  21. install：将打包结果安装到maven本地仓库，以便于其他项目进行依赖。mvn install
  22. deploy：将最终的包复制到远程仓库，以便其他开发人员与项目共享，或者把war包部署到服务器上运行。mvn deploy

site lifecycle
  1.     site生命周期用于生成项目报告，生成一个站点，发布站点。
  1. pre-site：在生成站点文档之前做的一些事情
  2. site：生成站点文档
  3. post-site：生成站点文档之后做的一些事情
  4. site-deploy：将生成的站点文档部署到特定的服务器上。

maven的坐标：

  1. <groupId>com.woniuxy.controller</groupId>
  2. <artifactId>UserController</artifactId>
  3. <version>1.0-SNAPSHOT</version>

:一般描述公司信息

：一般描述项目信息

：描述项目的版本信息

通过坐标，可以在仓库中唯一定位一个项目。

idea中maven的配置：

file->settings->build,ex……->maven

需要配置三个内容：

maven home directory:maven的安装目录

user settings file:指定maven使用哪个settings.xml文件

local repository:指定本地仓库路径

idea中创建maven的web项目

1、勾选 create from archetype

2、选中org.apatch.maven.archtype:web app

3、在创建好的项目的main目录下，补上 java （source ROOT）和resources (resource ROOT)目录

4、在tomcat中部署当前项目。

maven的依赖

  1. mvnrepository.com   寻找依赖的网站
  3. maven项目使用标签来引入外部依赖（第三方的jar）：在本地仓库中引入相应的资源<br />标签不能独立存在，必须出现在中，作为子元素<br />标签中配置的是一个maven项目的坐标。

用于指定导入的依赖的作用范围

  • compile：默认值，表示当前依赖会参与项目的编译、测试、和运行阶段，属于强依赖，打包时，会打进对应的包中。
  • test：表示当前依赖仅仅只参与测试相关的内容，包括测试用例的编译和执行。典型：junit。
  • runtime：当前依赖只参与运行周期中的使用。一般来说，这种都是接口与实现相分离的类库，典型：JDBC类库，在编译时仅依赖相关接口，在具体运行时才需要具体的数据库驱动程序。
  • provided：表示当前依赖不参与打包过程，这个依赖由运行时环境来提供。典型：servlet-api.jar。
  • system：使用上跟provided相同，表示当前依赖不从maven仓库中获取，而从本地文件系统中获取。
  • import：只能在dependencyManagement中使用，能解决maven单继承的问题，import的依赖关系实际上并不参与限制依赖关系的传递性。
  1. <!--
  2.   maven项目使用<dependency>标签来引入外部依赖（第三方的jar）：在本地仓库中引入相应的资源
  3.   <dependency>标签不能独立存在，必须出现在<dependencies>中，作为子元素
  4.   <dependency>标签中配置的是一个maven项目的坐标。
  5.   <groupId></groupId>
  6.   <artifactId></artifactId>
  7.   <version></version>
  8.   mvnrepository.com   寻找依赖的网站
  9.   <scope>用于指定导入的依赖的作用范围
  10.   -->
  11.   <dependencies>
  13.     <dependency>
  14.       <groupId>javax.servlet</groupId>
  15.       <artifactId>servlet-api</artifactId>
  16.       <version>2.5</version>
  17.       <scope>provided</scope>
  18.     </dependency>
  21.     <dependency>
  22.       <groupId>com.woniuxy.controller</groupId>
  23.       <artifactId>UserController</artifactId>
  24.       <version>1.0-SNAPSHOT</version>
  25.     </dependency>
  26.     <dependency>
  27.       <groupId>org.springframework</groupId>
  28.       <artifactId>spring-webmvc</artifactId>
  29.       <version>5.2.8.RELEASE</version>
  30.     </dependency>
  31.     <dependency>
  32.       <groupId>cglib</groupId>
  33.       <artifactId>cglib</artifactId>
  34.       <version>3.3.0</version>
  35.     </dependency>
  36.   </dependencies>

maven的继承和聚合

maven的继承

maven项目的分类
  1.     在maven中，根据项目打包类型的不同，将项目分为三种类型：jar、war、pom。
  • jar：普通java项目
  • war：web项目

  • pom：父项目，如果项目下有子项目存在，则该项目的打包类型一定是pom。

    1.   通过<packaging>来设置项目的打包类型。
  1. <packaging>jar|war|pom</packaging>
  1.     在某个项目的pom.xml中使用<parent>标签来声明该项目的父项目信息后，该项目就作为父项目的子项目出现，从而实现了maven的项目继承。

1、将父项目的打包方式设置为pom

  1. <packaging>pom</packaging>

2、子项目中使用标签实现继承

  1. <!--
  2.         <packaging>用于设定当前项目的打包类型,默认打包类型是jar
  3.         jar   :普通java项目
  4.         war   :web项目
  5.         pom   :父项目
  6.         对于pom（父）项目来说，一般不会有具体的代码
  7.     -->
  8.     <packaging>jar</packaging>
  10.     <parent>
  11.         <!--
  12.             <groupId>
  13.             <artifactId>
  14.             <version>
  15.             就是一个maven的坐标，用于定位父项目
  16.             <relativePath>：用于定位父项目的pom.xml
  17.         -->
  18.         <groupId>a.b.c</groupId>
  19.         <artifactId>d</artifactId>
  20.         <version>1.0-SNAPSHOT</version>
  21.         <relativePath>../d/pom.xml</relativePath>
  22.     </parent>
  1.     在maven的继承中，父项目与子项目之间只有逻辑上的父子关系，也就是说子项目不会被包含在父项目中。

maven的聚合

  1.     maven项目的聚合是建立在继承的基础上的。
  3.     在父项目中使用<modules>标签将子项目引入父项目，此时就实现了maven项目的聚合，给父项目打包时，子项目的内容也会被打包。
  1.     <!-- 指定当前项目中应该包含的模块 -->
  2.     <modules>
  3.         <module>../e</module>
  4.     </modules>

父项目统一管理依赖版本

父项目使用导入对应的依赖，此时依赖不会真正导入项目，而在子项目中通过引入对应依赖时才会真正导入项目。

父项目

  1. <properties>
  2.         <spring.version>5.3.2</spring.version>
  3.     </properties>
  5.     <!-- 使用dependencyManagement引入的依赖不会立即加载到maven项目中 -->
  6.     <dependencyManagement>
  7.         <dependencies>
  8.             <dependency>
  9.                 <groupId>org.springframework</groupId>
  10.                 <artifactId>spring-context</artifactId>
  11.                 <version>${spring.version}</version>
  12.             </dependency>
  13.         </dependencies>
  14.     </dependencyManagement>

子项目

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-context</artifactId>
  5.         </dependency>
  6.     </dependencies>