速览 - 目录
groupId && artifactId && version
希望我们可以在时间的流逝中, 抓住时间的缝隙, 不断成长. (●'◡'●)
来由
在企业级应用开发中, 往往都需要使用到很多的第三方的类库, 例如我们常用到的单元测试框架junit, 日志框架slf4j, 还有一些常用的工具类库.
到了后期, 项目的规模大了之后, 管理的第三方类库就会越多, 类库数量众多, 并且还存在着类库依赖类库的这种错综复杂的情况. 让项目的管理变得非常繁琐.
如何管理这些类库就成了一个非常大的问题: 前期需要大量的时间和精力去处理好这些第三方库, 引用这些库, 而且一旦缺少某些jar包, 就会编译失败.
Maven横空出世, maven通过一小段的标记语言(xml), 来描述整个项目结构和依赖.
前世今生(了解即可)
- 创始人及起源：
- Maven的创始人是Jason Van Zyl。
- Maven起源于Jakarta Alexandria项目，并在2002年10月左右迁移到Turbine项目中继续发展。
- 发展背景：
- Jason Van Zyl发现了一种更好的项目管理方式，即在一个地方可以查找属于这个项目的所有内容，包括一个标准的目录结构，以便不必在库、资源和文档中到处寻找。
- 基于这种思想，Jason Van Zyl发明了Maven，用于简化项目的建设和管理。
- 发展历程：
- Maven发展至今，经历了三代：Maven 1、Maven 2和Maven 3。
- 每一代Maven都带来了不令人兴奋但功能特性上的改进和增强。
- 功能特性：
- Maven提供了一个简单的构建框架，支持对项目进行编译、测试和部署。
- 它主要解决了Java项目构建过程中的一些基本问题，如依赖管理、自动化编译和标准化构建流程等。
- 社区发展：
- 随着Java生态系统的不断发展，越来越多的开发者开始关注和使用Maven。
- Maven社区迅速发展壮大，涌现出了大量的插件和扩展，覆盖了从项目构建、测试、部署到文档生成等各个方面。
- 一些大型开源项目也开始采用Maven作为其构建和管理工具。
- 标准与自动化：
- Maven遵循一套标准的项目结构，如Maven目录结构，这有利于团队协作和项目管理。
- 通过坐标定位的方式，Maven能够自动下载和管理项目所需的依赖库，提高了项目的开发效率和可维护性。
为什么他叫maven?
Maven这个单词来自于意第绪语（犹太语），意为知识的积累，最初在Jakata Turbine项目中用来简化构建过程。当时有一些项目（有各自Ant build文件），仅有细微的差别，而JAR文件都由CVS来维护。于是希望有一种标准化的方式构建项目，一个清晰的方式定义项目的组成，一个容易的方式发布项目的信息，以及一种简单的方式在多个项目中共享JARs。
现在最常用的版本就是maven3
说了那么多, 你也大概知道maven是干嘛的了,
Maven的本质
什么是Maven
Maven本质就是一个项目管理工具, 刚才也说过, maven是使用一种标记语言, 来描述和管理对象, 这个语言就是xml, Maven是纯java代码编写的, 所以在使用的时候, 需要安装java运行环境, 并且Maven本身这个项目的构建, 也是基于java的面向对象的特性, 具体面向对象的特性就体现在我们常用的一个文件上, 也就是pom.xml这个文件.
下面是一个pom.xml文件的样例, 看完这个案例你就会理解, 为什么是面向对象特性:
<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>com.example</groupId>
<artifactId>my-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<!-- 项目名称和URL（可选） -->
<name>My Project</name>
<url>http://maven.apache.org</url>
<!-- 开发者信息（可选） -->
<developers>
<developer>
<id>your-id</id>
<name>Your Name</name>
<email>your-email@example.com</email>
</developer>
</developers>
<!-- 项目依赖（可选） -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- 添加其他依赖 -->
</dependencies>
<!-- 构建配置（可选） -->
<build>
<plugins>
<!-- 添加构建插件 -->
</plugins>
</build>
<!-- 其他配置，如属性、仓库等（可选） -->
<properties>
<!-- 定义属性 -->
</properties>
<repositories>
<!-- 定义仓库 -->
</repositories>
<!-- 其他POM元素，如profiles、modules等 -->
</project>把上面的内容都过一遍, 下面我们来尝试描述这些标签的含义是什么...
<groupId>、<artifactId>和<version>是 Maven 项目的坐标，用于唯一标识项目, 后面会讲<packaging>定义了项目的打包方式，常见的值有jar、war等。<dependencies>元素用于定义项目的依赖。<build>元素包含了构建相关的配置，如插件定义。<properties>元素用于定义属性，这些属性可以在 POM 的其他部分使用。<repositories>元素用于定义项目依赖的仓库位置。
这些现在了解即可, 后面会讲解.
面向对象性质
这个文件是由一个project标签开始, 它是整个xml文件的根标签, 代表着这个项目, 项目里面则可以定义的基本开发信息, 开发者信息, 以及所选的依赖和插件, 他们都是在project的子标签中定义, 这样就有了一个类似于树形结构的样式,, 当然你也可以理解为这些(标红处)是这个xml文件的属性, 而xml文件的本身就可以看做是一个类.
项目对象模型
在了解了这些基本特性之后, 就大概有了一个初步的认识, 从上述描述和代码案例中, 通过这个pom.xml来构建一个项目对象模型, 然后第三方类库的信息, 都放在dependency中, 如下:
<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>
<!-- ... 此处省略了一些标签 -->
<!-- 项目依赖（可选） -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- 添加其他依赖 -->
</dependencies>
<!-- ... 此处省略了一些标签 -->
</project>我们提到过, 这只是一个xml文件的, 里面的dependency再怎么样, 也只不过是一堆代码, 几十个字符, 他难道能是对应的依赖文件吗? 当然不是, 它仅仅只是做了一个标记, 标记你要用到的使什么依赖, 然后到特定的位置去引用对应的jar包.
下图是pom模型的一个图解:
下面是一个依赖的描述:
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency> 其中:
- groupId : :定义当前Maven项目隶属组织名称(通常是域名反写，例如:org.mybatis
- artifactld : 定义当前Maven项目名称(通常是模块名称，例如CRM、SMS)
- version : 定义当前项目版本号
了解即可.
下载安装Maven
纯绿色软件, 下载解压即可使用
纯绿色软件, 下载解压即可使用
纯绿色软件, 下载解压即可使用
maven是由阿帕奇软件基金会维护的一个项目, 直接去官网下载即可:
Maven – Welcome to Apache Maven
https://maven.apache.org/
点击download, 跳转到下载页面 , 下载对应的版本即可(在使用maven之前你应该安装java运行环境, 注意maven和当前java的版本相匹配) :
解压之后的文件目录结构如下:
其中:
- bin目录：包含Maven的可执行文件，如
mvn（Maven命令行工具）和mvnDebug（用于调试的Maven命令行工具）。这些文件是用户与Maven进行交互的主要方式。 - boot目录：包含Maven自身的类加载器所需的jar包和配置文件。这些文件用于加载Maven运行时的类库。之前也说过, maven本身也是由java写的, 本身也依赖了很多三方库.
- conf目录：所见即所得, 也就是配置文件, 包含Maven的配置文件，主要是
settings.xml。这个文件用于配置Maven的全局设置，如代理设置、仓库地址等。 - lib目录：包含Maven运行所依赖的jar包。这些jar包是Maven自身的组成部分，用于提供Maven的各种功能。
检查是否安装成功:
如果你配置了maven的环境变量的话, 直接win + r 输入cmd, 打开然后输入mvn看看有没有对应的提示信息: 如果你不想配置环境变量的话,你可以直接在maven的bin目录中cmd, 然后输入mvn:
maven基本概念
仓库
之前我们说过, 我们使用maven管理项目的时候, 需要首先在项目对象模型的文件中(pom.xml)引入对应的依赖, 那么它终究只是引入, 如下代码, 而不是真正的jar包, 那么真正的jar包放在那里呢?
<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>
<!-- ... 此处省略了一些标签 -->
<!-- 项目依赖（可选） -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- 添加其他依赖 -->
</dependencies>
<!-- ... 此处省略了一些标签 -->
</project>你可能会想到, 我直接存储在本地啊, 我在pom文件中, 要用到什么依赖, 我就引入什么依赖, 然后要用到这个依赖的jar包的时候, 我从本地的存储里面去找不就行了, 确实, 但是你本地的存储的jar包又是哪来的呢? 当然有几种方法:
- 第一种就是, 你在网上下载很多jar包, 例如spring官网去下载springframework的核心jar包, 或者是其他的jar包, 下载好之后, 通过maven的某些加载命令(
mvn install:install-file), 然后指定一些参数, 以便后续方便引用这个jar包.
下面是安装自己在网上下载的jar包到本地maven仓库的命令案例:
mvn install:install-file -Dfile=path/to/your/downloaded.jar \
-DgroupId=com.example \
-DartifactId=my-library \
-Dversion=1.0.0 \
-Dpackaging=jar为什么要定义什么groupId, artifactId, 还有什.么version啊? 这是因为, 无论是本地的仓库, 还是远程的仓库, 都存在很多jar包, 你可以一次性引用很多个jar包, 但是为了对这些资源进行区分, 我们需要给他一个类似于"主键"的东西, 让我们可以通过这个 "主键" 可以找到唯一的那个jar包
但是由于不同的jar包, 是由不同的公司或者组织开发的, 所以为了区分这些组织, 也就有了groupId这个属性, 这个属性通常是公司域名的反写形式, 例如spring框架的依赖通常是 org.springframework, artifactId就是你这个jar包的名字, version顾名思义就是版本的意思.
- 第二种就是, 手动下载jar包区安装, 就有点违背我们使用maven的初心了, maven真的是好人做到底了, 为了防止不同的人按照上述的install来安装jar包, 同一个jar包使用不同命名的情况出现, 例如有的人下载spring的依赖之后, install的时候, 给的groupid为org.springframework, 但是有的人就会想, 我为什么要写org啊, 我少写两个省事不行吗.
于是为了防止这种情况, maven就维护了一个中央网站, 让大家都在这个网站里面下载jar包, 这些jar包是直接下载到你的maven本地仓库, 无需maven installfile的命令, 并且这些jar包的groupid和artifactId还有version都是已经命名好的, 避免同一个jar包不同的命名这种不方便管理和可读性差的情况.
但是存在另外一种情况, 因为中央仓库的地址: https://mvnrepository.com/https://mvnrepository.com/ 他是部署在国外的服务器上, 因此在访问上多多少少不如国内, 于是为了处理这种情况, 就可以在本地仓库和中央仓库之间再部署一个服务器, 让这个服务器去专门访问这个中央仓库, 本将jar包下载到本地供给本地仓库下载.
这个服务器就叫做私服, 私服的作用如下:
但是这样还是不够, 因为这样的话, 还是从国外的网站下载, 于是国内的一些公司就开发了自己的maven仓库资源的镜像源, 来方便我们下载.
同时一些公司开发的好用的jar包是不能直接上传到maven的, 因为别人是可以直接下载到的. 这可能就会出现后期的一些法律上的纠纷.
中央仓库是由maven团队直接维护的, 是存储所有的资源的仓库.
坐标
上面提到过, 坐标就是用于定位中央仓库中资源的位置, 他有如下要素:
- groupld:定义当前Maven项目隶属组织名称(通常是域名反写，例如:org.mybatis)
- artifactld:定义当前Maven项目名称(通常是模块名称，例如CRM、SMS)
- version:定义当前项目版本号
使用唯一标识，唯一性定位资源位置，通过该标识可以将资源的识别与下载工作交由机器完成
这里不再赘述.
仓库配置
Maven中有很多配置文件, 例如本地仓库的位置, 自定义仓库位置的设置, 此外我们中央仓库下载的位置, 也是可以配置的, 例如你们在下载的时候, 如果你下载的是国外的中央仓库, 如果不挂vpn, 那么就会出现下载速度慢的情况, 这个时候你就可以配置下载地址, 比如配置为国内的阿里镜像云.
配置文件在什么位置?
conf, 顾名思义就是配置文件的意思.
- logging : 也就是日志配置文件, 里面有一个配置文件如下:
日志配置
打开它:
# 本文件名为: simplelogger.properties
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
org.slf4j.simpleLogger.defaultLogLevel=info
org.slf4j.simpleLogger.showDateTime=false
org.slf4j.simpleLogger.showThreadName=false
org.slf4j.simpleLogger.showLogName=false
org.slf4j.simpleLogger.logFile=System.out
org.slf4j.simpleLogger.cacheOutputStream=true
org.slf4j.simpleLogger.levelInBrackets=true
org.slf4j.simpleLogger.log.Sisu=info
org.slf4j.simpleLogger.warnLevelString=WARNING
# MNG-6181: mvn -X also prints all debug logging from HttpClient
# Be aware that the shaded packages are used
# org.apache.http -> org.apache.maven.wagon.providers.http.httpclient
org.slf4j.simpleLogger.log.org.apache.maven.wagon.providers.http.httpclient=off
org.slf4j.simpleLogger.log.org.apache.maven.wagon.providers.http.httpclient.wire=off
这是一个用于配置slf4j的一个SimpleLogger实现, slf4j 是一个用于java 的简单日志门面, 它允许用户在运行时候将任何支持的日志框架, 例如 logback log4j等, 插入到应用中, 这个simpleLogger是slf4j的一个简单的日志实现.
了解即可
解释如下:
org.slf4j.simpleLogger.defaultLogLevel=info | 默认日志级别设置为INFO。这意味着所有INFO级别及以上的日志（如WARN、ERROR）都将被记录。 |
org.slf4j.simpleLogger.showDateTime=false | 不在日志消息中显示日期和时间。 |
org.slf4j.simpleLogger.showThreadName=false | 不在日志消息中显示线程名。 |
org.slf4j.simpleLogger.showLogName=false | 不在日志消息中显示日志记录器的名称。 |
org.slf4j.simpleLogger.logFile=System.out | 将日志输出到System.out（通常是控制台）。如果你希望将日志输出到文件，可以指定一个文件路径，如logFile=mylog.log。 |
org.slf4j.simpleLogger.cacheOutputStream=true | 启用输出流缓存。这可以提高性能，但可能会增加内存使用。 |
org.slf4j.simpleLogger.levelInBrackets=true | 在日志消息中，将日志级别放在方括号内。 |
org.slf4j.simpleLogger.log.Sisu=info | 为Sisu这个特定的日志记录器设置日志级别为INFO。这意味着Sisu相关的日志消息将遵循这个特定的级别设置，而不是默认的INFO级别。 |
org.slf4j.simpleLogger.warnLevelString=WARNING | 设置WARN级别的日志消息的字符串为WARNING。这通常用于自定义日志级别的显示方式。 |
org.slf4j.simpleLogger.log.org.apache.maven.wagon.providers.http.httpclient=off | 禁用与Maven的HTTP Wagon提供商（它使用Apache HttpClient）相关的所有日志。 |
org.slf4j.simpleLogger.log.org.apache.maven.wagon.providers.http.httpclient.wire=off | 禁用与Maven的HTTP Wagon提供商（特别是与HTTP通信的“线”或详细调试）相关的所有日志。这可以帮助减少输出中的噪声，特别是当你使用mvn -X（启用Maven的调试模式）时。 |
本地maven配置
用于管理本地的maven配置
下图是settings.xml这个文件的内容:
<?xml version="1.0" encoding="UTF-8"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
-->
<!--
| This is the configuration file for Maven. It can be specified at two levels:
|
| 1. User Level. This settings.xml file provides configuration for a single user,
| and is normally provided in ${user.home}/.m2/settings.xml.
|
| NOTE: This location can be overridden with the CLI option:
|
| -s /path/to/user/settings.xml
|
| 2. Global Level. This settings.xml file provides configuration for all Maven
| users on a machine (assuming they're all using the same Maven
| installation). It's normally provided in
| ${maven.conf}/settings.xml.
|
| NOTE: This location can be overridden with the CLI option:
|
| -gs /path/to/global/settings.xml
|
| The sections in this sample file are intended to give you a running start at
| getting the most out of your Maven installation. Where appropriate, the default
| values (values used when the setting is not specified) are provided.
|
|-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
<!-- interactiveMode
| This will determine whether maven prompts you when it needs input. If set to false,
| maven will use a sensible default value, perhaps based on some other setting, for
| the parameter in question.
|
| Default: true
<interactiveMode>true</interactiveMode>
-->
<!-- offline
| Determines whether maven should attempt to connect to the network when executing a build.
| This will have an effect on artifact downloads, artifact deployment, and others.
|
| Default: false
<offline>false</offline>
-->
<!-- pluginGroups
| This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
| when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
| "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
|-->
<pluginGroups>
<!-- pluginGroup
| Specifies a further group identifier to use for plugin lookup.
<pluginGroup>com.your.plugins</pluginGroup>
-->
</pluginGroups>
<!-- proxies
| This is a list of proxies which can be used on this machine to connect to the network.
| Unless otherwise specified (by system property or command-line switch), the first proxy
| specification in this list marked as active will be used.
|-->
<proxies>
<!-- proxy
| Specification for one proxy, to be used in connecting to the network.
|
<proxy>
<id>optional</id>
<active>true</active>
<protocol>http</protocol>
<username>proxyuser</username>
<password>proxypass</password>
<host>proxy.host.net</host>
<port>80</port>
<nonProxyHosts>local.net|some.host.com</nonProxyHosts>
</proxy>
-->
</proxies>
<!-- servers
| This is a list of authentication profiles, keyed by the server-id used within the system.
| Authentication profiles can be used whenever maven must make a connection to a remote server.
|-->
<servers>
<!-- server
| Specifies the authentication information to use when connecting to a particular server, identified by
| a unique name within the system (referred to by the 'id' attribute below).
|
| NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
| used together.
|
<server>
<id>deploymentRepo</id>
<username>repouser</username>
<password>repopwd</password>
</server>
-->
<!-- Another sample, using keys to authenticate.
<server>
<id>siteServer</id>
<privateKey>/path/to/private/key</privateKey>
<passphrase>optional; leave empty if not used.</passphrase>
</server>
-->
</servers>
<!-- mirrors
| This is a list of mirrors to be used in downloading artifacts from remote repositories.
|
| It works like this: a POM may declare a repository to use in resolving certain artifacts.
| However, this repository may have problems with heavy traffic at times, so people have mirrored
| it to several places.
|
| That repository definition will have a unique id, so we can create a mirror reference for that
| repository, to be used as an alternate download site. The mirror site will be the preferred
| server for that repository.
|-->
<mirrors>
<!-- mirror
| Specifies a repository mirror site to use instead of a given repository. The repository that
| this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
| for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
|
<mirror>
<id>mirrorId</id>
<mirrorOf>repositoryId</mirrorOf>
<name>Human Readable Name for this Mirror.</name>
<url>http://my.repository.com/repo/path</url>
</mirror>
-->
</mirrors>
<!-- profiles
| This is a list of profiles which can be activated in a variety of ways, and which can modify
| the build process. Profiles provided in the settings.xml are intended to provide local machine-
| specific paths and repository locations which allow the build to work in the local environment.
|
| For example, if you have an integration testing plugin - like cactus - that needs to know where
| your Tomcat instance is installed, you can provide a variable here such that the variable is
| dereferenced during the build process to configure the cactus plugin.
|
| As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
| section of this document (settings.xml) - will be discussed later. Another way essentially
| relies on the detection of a system property, either matching a particular value for the property,
| or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
| value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
| Finally, the list of active profiles can be specified directly from the command line.
|
| NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
| repositories, plugin repositories, and free-form properties to be used as configuration
| variables for plugins in the POM.
|
|-->
<profiles>
<!-- profile
| Specifies a set of introductions to the build process, to be activated using one or more of the
| mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
| or the command line, profiles have to have an ID that is unique.
|
| An encouraged best practice for profile identification is to use a consistent naming convention
| for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
| This will make it more intuitive to understand what the set of introduced profiles is attempting
| to accomplish, particularly when you only have a list of profile id's for debug.
|
| This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
<profile>
<id>jdk-1.4</id>
<activation>
<jdk>1.4</jdk>
</activation>
<repositories>
<repository>
<id>jdk14</id>
<name>Repository for JDK 1.4 builds</name>
<url>http://www.myhost.com/maven/jdk14</url>
<layout>default</layout>
<snapshotPolicy>always</snapshotPolicy>
</repository>
</repositories>
</profile>
-->
<!--
| Here is another profile, activated by the system property 'target-env' with a value of 'dev',
| which provides a specific path to the Tomcat instance. To use this, your plugin configuration
| might hypothetically look like:
|
| ...
| <plugin>
| <groupId>org.myco.myplugins</groupId>
| <artifactId>myplugin</artifactId>
|
| <configuration>
| <tomcatLocation>${tomcatPath}</tomcatLocation>
| </configuration>
| </plugin>
| ...
|
| NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
| anything, you could just leave off the <value/> inside the activation-property.
|
<profile>
<id>env-dev</id>
<activation>
<property>
<name>target-env</name>
<value>dev</value>
</property>
</activation>
<properties>
<tomcatPath>/path/to/tomcat/instance</tomcatPath>
</properties>
</profile>
-->
</profiles>
<!-- activeProfiles
| List of profiles that are active for all builds.
|
<activeProfiles>
<activeProfile>alwaysActiveProfile</activeProfile>
<activeProfile>anotherAlwaysActiveProfile</activeProfile>
</activeProfiles>
-->
</settings>
内容太长了,我们截取部分:
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!-- 某些设置属性-->
<!-- 插件 -->
<pluginGroups>
</pluginGroups>
<!-- 插件 -->
<proxies>
</proxies>
<!-- 插件 -->
</servers>
<!-- 插件 -->
<mirrors>
</mirrors>
<!-- 插件 -->
<profiles>
</profiles>
</settings>
xml文件
题外话: xml文件
我们看到这个文件的第一行是: <?xml version="1.0" encoding="UTF-8"?>
这个是XML文件的声明, 这个声明在xml文档中是可选的, 但是通常建议加上他, 因为它为解析器提供了关于文档的一些基本信息.
这个声明有下面这几个部分组成:
- <?xml 这个是声明开始的标志
- version 是指的xml的版本, 目前最常用的是1.0
- encoding 是指定了文档使用的字符编码
- ?> 这个是声明结束的标志.
settings.xml配置文件
首先这个配置文件要生效的话, 分为两种, 一种是用户配置, 一种是全局配置, 如下:
- 用户配置: 这个settings.xml 文件提供了一个用户配置, 并且这个配置文件会在你的用户的home目录中的.m2文件夹中, 名字也是为settings.xml, 如下:
首先你得开启隐藏文件夹显示:
然后 :
- 全局配置: 这个配置文件提供给所有的Maven用户(在一个机器上的, 假设这些user使用的是时同一个maven应用), 这个文件存在于maven的配置文件中, 如下:
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!--
省略了一些代码
-->
</settings>讲完这个我们再来看看这个xml的根标签settings中的属性配置:
- xmlns: 全名XML NameSpace, 他定义了该元素和其子元素的默认命名空间, 在这个例子中，
xmlns="http://maven.apache.org/SETTINGS/1.0.0"意味着<settings>元素及其子元素属于http://maven.apache.org/SETTINGS/1.0.0这个命名空间。这允许 XML 文档中的元素名在全局范围内具有唯一性，避免命名冲突。这个属性就像是为 XML 文件里的元素起了一个“名字前缀”。它告诉解析器，这些元素是按照某个特定的规则或标准来定义的。在这个例子中，xmlns的值告诉解析器，<settings>元素及其子元素是遵循 Maven 的某个特定版本（1.0.0）的规则来定义的。 xmlns:xsi:这是为xsi前缀定义的命名空间。xsi是 XML Schema Instance 的缩写，它提供了一些用于验证 XML 文档的结构和内容的额外属性。在这个例子中，xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"定义了xsi前缀的命名空间。这个属性就像是给 XML 文件里的某个特定部分起了一个“别名”。xsi是 XML Schema Instance 的缩写，它提供了一些额外的属性，比如schemaLocation，来帮助我们找到与这个命名空间相关的“规则书”（也就是 XML Schema 文件）。xsi:schemaLocation:这个属性用于指定与xmlns定义的命名空间相关联的 XML Schema 文件的位置。XML Schema 文件定义了 XML 文档的结构和元素、属性的数据类型等。xsi:schemaLocation的值由两部分组成：命名空间 URI 和对应的 Schema 文件的位置 URI。在这个例子中，xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd"表示http://maven.apache.org/SETTINGS/1.0.0这个命名空间由http://maven.apache.org/xsd/settings-1.0.0.xsd这个 Schema 文件定义。这个属性就像是告诉我们“规则书”放在哪里。它告诉解析器，如果我们想要知道<settings>元素及其子元素应该怎么写，应该遵循哪些规则，那么就去指定的 URL（在这个例子中是http://maven.apache.org/xsd/settings-1.0.0.xsd）下载并查看那个“规则书”。
学习xml:
通常xml可以自己去定义标签和根标签, 来组织自己的数据, 但是虽然是自己定义, 但是你还是希望你的xml文件拥有一些语法检错, 和固定的格式, 来让你的数据保持这种格式, 来方便自己维护, 这就是xml的命名空间(namespace)和模式(schema)的作用.
例如它里面规定了根标签下面存在着test标签, 那么你可以写test, 但是假如你写错了写成了tets, 那么这就是一个错误的xml文档.
下面是settings.xml中标签的解释:
| 元素 | 解释 |
|---|---|
| settings | 这是 |
| localRepository |
|
| interactiveMode |
|
| usePluginRegistry |
|
| offline |
|
| pluginGroups |
|
| servers |
|
| mirrors |
|
| proxies |
|
| profiles |
|
| activeProfiles |
|
配置本地仓库
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
</settings>本地仓库如果不配置, 默认就是user.home中的.m2文件夹中的仓库, 也就是默认用户级别的仓库, 我们可以通过这个localRepository标签来更改这个本地仓库的位置:
例如: 我们将其存放在D盘的maven文件夹的Repository文件夹中
<localRepository>D:\maven\repository</localRepository>本地仓库是默认访问中央仓库的, 网速会比较慢:
这个时候, 就需要配置国内镜像源. 注意这里是mirrors结点
<mirrors>
<mirror>
<id>nexus aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
</mirrors>Maven工程目录的结构
但是还缺少一个pom.xml文件来描述他的maven文档结构, 在上述的maven项目的src文件夹中添加pom.xml文件形如:
<?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>com.showmac</groupId>
<artifactId>titans</artifactId>
<version>1.1.1</version>
<packaging>jar</packaging>
<modules>
<module>tethys</module>
</modules>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>3.2.6</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.yaml</include>
<include>**/*.yml</include>
<include>**/*.xml</include>
<include>**/*.sql</include>
<include>**/*.html</include>
<include>**/*.js</include>
<include>**/*.css</include>
<include>**/*.png</include>
<include>**/*.gif</include>
<include>**/*.php</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>3.3.0</version>
<configuration>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.2.5</version>
<configuration>
<argLine>-Xmx1024m</argLine>
</configuration>
</plugin>
</plugins>
</build>
</project>
这个文件添加完毕之后, 这就是一个完整的可以被mavne识别的maven项目了.
pom.xml是 Maven 项目中的核心配置文件，它包含了项目的各种配置信息，如项目依赖、插件、构建设置等。下面是一些常见的 pom.xml 标签及其作用和说明：
| pom.xml中的标签 | 含义和作用 |
|---|---|
<project> | 这是 pom.xml 的根元素，它包含了项目的所有配置。 |
<modelVersion> | 指定了当前 POM 模型的版本，通常是 4.0.0。 |
<groupId> | 定义了项目的唯一标识符，通常包含组织或公司的域名反转（例如 com.example） |
<artifactId> | 定义了项目的名称或模块名，通常与项目的基本名称相对应 |
<version> | 定义了项目的当前版本 |
<packaging> | 定义了项目的打包方式，如 jar、war、pom 等。默认为 jar |
<name> | 提供了项目的名称 |
<description> | 提供了项目的描述 |
<url> | 项目的 URL，通常指向项目的网站或主页 |
|
| 定义了项目的依赖关系。<dependencies> 是依赖的容器，<dependency> 定义了单个依赖，包含 groupId、artifactId、version 等属性 |
<build> |
|
<properties> | 定义了可以在 POM 中其他地方引用的属性。例如，可以定义项目编码、依赖版本等 |
<profiles> 和 <profile> | 定义了构建配置文件，可以根据不同的环境或条件激活不同的配置 |
|
| 定义了 Maven 用于查找依赖的仓库 |
<distributionManagement> | 定义了如何发布项目，包括发布到哪些仓库等 |
<modules> 和 <module> | 定义了多模块 Maven 项目中的子模块 |
<scm> | 定义了项目的源代码管理系统（如 Git）的信息 |
|
| 定义了项目的开发者信息 |
<licenses> 和 <license> | 定义了项目的许可证信息 |
|
| 定义了与项目相关的邮件列表信息 |
<issueManagement> | 定义了与项目问题追踪系统（如 JIRA）相关的信息 |
<ciManagement>rrr | 定义了与持续集成系统（如 Jenkins）相关的信息 |
下面我们依次讲解这些标签
project
这个标签就是pom.xml的根标签, pom.xml的本质就是XML 文档结构基于树形结构，其中每个元素都是树中的一个节点。根标签是树的根节点，它包含了所有的其他元素, 如下:
这个project标签, 也就是groupId, artifactId, version, packaging, dependency, repository, build等标签的父标签, 他们则是project的子标签, 也可以称之为子元素.
modelVersion
modelVersion 描述的pom.xml的模型版本, 而不是指的maven的版本, 这个模型就是通过面向对象的方法, 把maven项目抽象成一种对象的方法, 例如project标签就代表这个项目, 下面的version就代表版本.
不同的model版本代表着拥有不同的maven对象文档结构, Maven的modelVersion用于定义POM（Project Object Model，项目对象模型）文件的版本。在Maven的生命周期中，POM文件是一个非常重要的配置文件，它包含了项目的构建配置、依赖管理、项目信息管理等内容。
modelVersion是为了pom文档结构的支持和更新, 但是对于maven3和maven4, 其modelVersion都是4.0版本, 变化不大.
虽然模型版本没有变化, 但Maven 3在功能和性能上进行了许多改进和优化，如更智能的依赖解析、更快的构建速度等。这些改进和优化使得Maven 3成为目前广泛使用的版本。
groupId && artifactId && version
这个就要说到我们如何定位一个maven仓库中一个jar包的地址了, 因为这种jar包会由不同的组织或者公司开发出来, 因此就需要一个标识, 来记录它是哪个公司开发的, 但是一个公司也会有很多个项目被打成jar包上传, 为了区分不同的jar包, 就给这些jar包一个artifactId. 但是, 一个jar包它不可能永远不变啊, 他会随着漏洞的修复和性能的提升而改变版本, 不同的版本因此就有了不同的特性, 为了区分这些版本, 还需要使用到一个叫做version的标签, 如下:
其次, 你如果用过maven, 有时候你就会发现, 有些依赖的版本中会携带-SNAPSHOT后缀, 例如:
<project xmlns="http://maven.apache.org/POM/4.0.0"
...
<groupId>...</groupId>
<artifactId>my-app</artifactId>
...
<version>1.0-SNAPSHOT</version>
<name>Maven Quick Start Archetype</name>
...这个snapshot的值的意思就是如下:
也就是快照版本, 它拥有者这个项目的最新的代码, 在其开发的分支上, 并且不担保snapshot版本的稳定性, 相反的, 在release 版本的代码, 就会稳定很多, 后期的版本更新也会很少. 因此release版本也称为稳定版, 一般稳定版的漏洞都比较少.
packaging
packaging, 字如其名, 也就是打包的意思.<packaging>标签用于指定项目的打包方式。这个标签的值决定了Maven如何构建和打包你的项目。
他有如下打包方式:
- jar : 默认值, 如果你不写<packaging>标签, 那么项目的默认打包方式就为jar包. 所谓jar包, 就是包含了java类文件, 资源文件(例如配置文件) 和元数据的包, 当你有一个包含可执行main方法的java项目的时候, 就可以将其打成jar包
- war : 表示其被打包成一个war文件, war文件是一个用于web应用程序的压缩包, 它里面包含了servlet, jsp页面, 和一些类文件, 库文件. 当你在开发一个web项目的时候, 例如你正在使用servlet, jsp和mvc这些技术, 你应该打成war包
- ear : 表示将项目打包成一个ear文件, ear文件是javaEE 应用程序的压缩包, 它包含了多个模块, 例如EJB, war, RAR等, 当你处在java EE的开发环境中, 当你一个包偶多个模块, 例如包含EJB和web模块的时候, 你就可以使用这种ear的打包方式
- pom : 一种特殊的打包方式,, 表示该项目是一个Maven POM文件, 这种项目通常用于父项目, 它包含了多种子模块, 并管理这些子模块的依赖和构建配置
name
只是一种描述项目名称的方式, name标签用于定义项目名称, 这种名称主要用在maven的构建的生命周期过程中, 以及某些IDE 中显示项目的名称, 这可以让开发者可以更加直观的识别和管理项目, 所以这个name标签的值, 应该是那些可读性强的值.
下面是name标签使用的案例:
<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>com.example</groupId>
<artifactId>my-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<!-- 项目名称 -->
<name>My Example Project</name>
<!-- 其他配置 -->
<!-- ... -->
</project>description
提供项目描述信息, 帮助他人快速了解项目的用途和功能。description标签是可选的.
<project>
...
<description>
这是一个用于处理用户数据的Maven项目。它提供了用户注册、登录和数据查询等功能。
</description>
...
</project>- 项目文档：Maven生成的文档或网站可能会使用
description标签的内容作为项目的描述。 - IDE集成：某些集成开发环境（IDE）如IntelliJ IDEA或Eclipse在显示项目信息时可能会展示
description标签的内容。 - 报告和日志：在构建报告或日志中，可能会包含项目的描述信息以提供上下文。
url
在Maven的pom.xml文件中，<url>标签用于指定项目的URL地址。这个URL地址通常指向项目的网站、文档页面或源代码仓库等。<url>标签提供了关于项目位置或相关信息的快速访问途径，对于其他开发人员、用户或维护者了解和使用项目非常有帮助。
<project>
...
<url>https://github.com/username/my-project</url>
...
</project>- 项目文档：Maven生成的文档或网站可能会使用
url标签的内容作为项目的链接，方便用户直接访问。 - IDE集成：IDE在显示项目信息时可能会包含项目的URL链接，方便用户直接跳转到项目的主页或源代码仓库。
- 依赖管理：在依赖管理工具中，项目的URL可能用于显示额外的信息或提供下载链接。
dependencies
这个标签是所有依赖 的 父元素, 在 dependencies 可以有很多个dependency标签, 每一个dependency表示一个依赖项目, 每一个dependency需要groupId,artifactId和version来对其进行定位, 如下:
我们在项目中可能会使用到junit进行单元测试:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>modules && module
在 Maven 的 pom.xml 文件中，<modules> 和 <module> 标签通常用于定义多模块项目（Multi-Module Projects）的结构。这种结构允许你将一个大的项目拆分成多个小的、独立的、但又相互关联的模块，每个模块都有自己的 pom.xml 文件，用于管理其自己的依赖、构建配置等。
<modules> 标签位于父项目的 pom.xml 文件中，用于列出所有的子模块。每个子模块都应该是一个目录，其名称应与 <module> 标签中指定的名称相匹配。
<project>
...
<modules>
<module>module1</module>
<module>module2</module>
<module>module3</module>
</modules>
...
</project> 在这个例子中，父项目包含了三个子模块：module1、module2 和 module3。这些子模块的目录应该与父项目的 pom.xml 文件在同一目录下，并且名称应该与 <module> 标签中指定的名称一致。
build
默认情况下，Maven 会从 src/main/resources 目录中复制资源文件到输出目录（通常是 target/classes）。但你可以通过 <resources> 标签来自定义资源目录。
<build>
<resources>
<resource>
<directory>src/main/my-resources</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.properties</include>
</includes>
</resource>
</resources>
...
</build> 在这个例子中，Maven 将从 src/main/my-resources 目录中复制所有的 .xml 和 .properties 文件到输出目录。
<plugins> 标签用于配置在构建过程中要使用的插件。每个 <plugin> 标签代表一个插件的配置。
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
...
</build>developers && developer
在 Maven 的 pom.xml 文件中，<developers> 和 <developer> 标签并不是标准的 Maven 配置元素。这些元素通常出现在项目的元数据中，特别是在 Maven 的项目对象模型（POM）的父级模型，即 maven-site-plugin 生成的站点文档中。它们用于记录项目的开发者信息，但并不直接影响项目的构建过程。
<developers> 是 <developers> 元素的容器，用于包含多个 <developer> 元素。每个 <developer> 元素代表一个项目的开发者，包含该开发者的各种信息，如姓名、ID、电子邮件、角色等。
<project>
...
<name>My Project</name>
<description>A description of my project</description>
...
<developers>
<developer>
<id>john-doe</id>
<name>John Doe</name>
<email>john.doe@example.com</email>
<roles>
<role>developer</role>
</roles>
<timezone>+1</timezone>
</developer>
<developer>
<id>jane-smith</id>
<name>Jane Smith</name>
<email>jane.smith@example.com</email>
<roles>
<role>maintainer</role>
<role>developer</role>
</roles>
<timezone>-7</timezone>
</developer>
</developers>
...
</project>如果你正在使用 Maven 站点插件（maven-site-plugin）来生成项目的站点文档，并且想要在站点中包含开发者信息，那么你可以在项目的 pom.xml 文件中添加 <developers> 和 <developer> 元素。否则，这些元素并不是必须的。
Maven的构建过程和生命周期
Maven – Users Centrehttps://maven.apache.org/users/index.html
mvn指令
指令基础
当你下载好maven之后, 然后配置好环境变量, 你就可以在电脑里面使用mvn命令来快速构建项目和完成特定生命周期的操作, 如下:
这是你下载的maven仓库:
进入bin目录 :
maven命令脚本就在此定义, 然后在此页面打开cmd
输入mvn就可以看见如下信息, 那么你就安装成功了,
查看maven版本, 在这个命令行中输入mvn -v:
快速构建maven项目
难道我每次创建项目都要写一大堆文件夹和文件吗, 我就不能一键创建maven的目录结构,还给我自动加上pom文件多好. 肯定可以啊, 使用命令:
mvn -B archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4这个指令有这么几个需要注意的地方
- mvn : 这个就不必多说, mvn的指令命令行工具, 用于构建maven项目.
- -B : 这是 --batch-mode 的缩写。在批处理模式下，Maven 不会与用户进行任何交互，它会按照命令行参数中指定的选项执行。这对于脚本或自动化任务特别有用，因为它可以确保 Maven 不会在执行过程中停下来等待用户输入。
- archetype : 这是 Maven Archetype 插件的一个目标（goal）。Archetype 插件用于从 Maven 原型生成项目结构。原型是一个 Maven 项目模板，它包含了一些预定义的目录结构、文件等，可以作为一个起点来快速开始一个新的 Maven 项目。
- -DgroupId : 同样，这里使用 -D 选项设置了项目的 artifactId。artifactId 也是 Maven 项目坐标的一部分，用于标识项目的具体名称或模块。在这个例子中，artifactId 被设置为 my-app, groupId被设置为com.mycompany.app。
- -DarchetypeArtifactId : 这里指定了要使用的 Maven 原型的 artifactId。在这个例子中，我们选择了 maven-archetype-quickstart 原型，它是一个简单的 Maven 项目模板，只包含了一些基本的文件和目录结构。
- -DarchetypeVersion : 这里指定了要使用的 Maven 原型的版本。不同的原型版本可能包含不同的文件、目录结构或默认设置。在这个例子中，我们选择了 1.4 版本的 maven-archetype-quickstart 原型。
当然,不只是quickstart这个版本模板, 还有其他的模板:
一旦你执行了这个命令, 那么你就会发现发生了很多有趣的事情, 第一个就是你会注意到会生成一个叫做my-app 的项目已经被创建, 并且这个文件夹里面包含一个 名为 pom.xml的文件, 如下面:
这也就是我们上面提到的.
<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>com.mycompany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.0-SNAPSHOT</version>
<name>my-app</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
... lots of helpful plugins
</pluginManagement>
</build>
</project>目录结构如下:
my-app
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- com
| `-- mycompany
| `-- app
| `-- App.java
`-- test
`-- java
`-- com
`-- mycompany
`-- app
`-- AppTest.java构建生命周期
compile
首先你需要将目录切换到当前的项目目录下面, 然后在这个目录里面打开mvn命令行工具, 然后执行 编译指令来 编译你的项目:
mvn compile当你执行这个命令之后, 你就可以看到命令行出现了很多 info:
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< com.mycompany.app:my-app >----------------------
[INFO] Building my-app 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:resources (default-resources) @ my-app ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory <dir>/my-app/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.0:compile (default-compile) @ my-app ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to <dir>/my-app/target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.899 s
[INFO] Finished at: 2020-07-12T11:31:54+01:00
[INFO] ------------------------------------------------------------------------这是因为maven本身也是用到了其他的一些日志框架的jar包进行日志的记录.
tips: 当你第一次使用maven的执行编译的指令的时候, 也就是mvn compile, maven需要先去下载所有的插件, 和相关的依赖, 才能完成指令的执行, 因为你的maven中目前很干净, 这些插件都需要你去下载, 所以第一次加载可能会花上个几分钟时间, 不要急~
当下载完成之后, 你再次编译, 那么就不会重新下载, 因为你之前已经下载了对应的插件和依赖, 但是如果你引入了其他的依赖, 并且你本地没有下载的情况下, 你还是需要去下载这个依赖.
正如你所看到的输出记录那样, 这些被编译的类, 将会被存储到当前项目根目录的target的classes文件夹中. 这个target目录是maven项目约定的目录结构之一, 所以如果你想要 用的时间久了, 你就会发现, maven这个文件目录和pom的面向对象的特性非常nice, maven项目使用了约定好的目录结构, 并且使用pom去标记, pom可以使用非常小的空间, 并且你不需要告诉maven, 你的资源文件在哪, 或者你的输出文件将会存在哪.
根据标准的约定, 你可以不费吹灰之力, 就可以做很多事情, 做一个简单的比较, 我们来看看, 你会在ant中做些什么来完成同样的事情:
现在，这只是编译一个应用程序源代码树，所示的Ant脚本与上面所示的POM大小相当。但是我们将会看到仅仅用这个简单的POM我们还能做多少事情.
test
你成功编译你的应用之后, 现在你有一些单元测试也想要去编译和执行一下, 因为每一个项目都会写和执行一些单元测试
执行下面的指令, 执行单元测试:
mvn test你会看到命令行输出:
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< com.mycompany.app:my-app >----------------------
[INFO] Building my-app 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:resources (default-resources) @ my-app ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory <dir>/my-app/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.0:compile (default-compile) @ my-app ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:testResources (default-testResources) @ my-app ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory <dir>/my-app/src/test/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.8.0:testCompile (default-testCompile) @ my-app ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to <dir>/my-app/target/test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) @ my-app ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.mycompany.app.AppTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.025 s - in com.mycompany.app.AppTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.881 s
[INFO] Finished at: 2020-07-12T12:00:33+01:00
[INFO] ------------------------------------------------------------------------输出显示:
- 在这个过程中, 同样会下载所需的依赖, 为了执行测试, 依赖和插件式必不可少的, 已经存在的依赖是不需要再次下载的, 因为已经下载到了你的本地仓库
- 在你编译和执行测试 之前, maven会编译main方法中的代码, 所有的这些类都是最新的, 因为我们没有改变任何东西(在我们最后一次编译之后)
test-compile
如果你想要编译你的test源码, 而不是执行测试, 你就可以用下面的命令:
mvn test-compile现在你就可以编译你的测试代码了, 并且执行这些测试
这个时候你又或许会问, 我如何创建一个jar包并且将其安装到我的本地仓库?
package
生成jar包, 可以直接使用下面指令:
mvn package你就会在你的项目根目录下的target文件夹中看到一个jar包, 这个jar包就是你生成的项目的jar包.
然后执行install来安装这个jar包到你的本地仓库.
install
注意, 这个操作默认是安装到你本地的仓库, 也就是${user.home} /.m2/repository中的
执行安装命令
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< com.mycompany.app:my-app >----------------------
[INFO] Building my-app 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:resources (default-resources) @ my-app ---
...
[INFO] --- maven-compiler-plugin:3.8.0:compile (default-compile) @ my-app ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:testResources (default-testResources) @ my-app ---
...
[INFO] --- maven-compiler-plugin:3.8.0:testCompile (default-testCompile) @ my-app ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) @ my-app ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.mycompany.app.AppTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.025 s - in com.mycompany.app.AppTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-jar-plugin:3.0.2:jar (default-jar) @ my-app ---
[INFO] Building jar: <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-install-plugin:2.5.2:install (default-install) @ my-app ---
[INFO] Installing <dir>/my-app/target/my-app-1.0-SNAPSHOT.jar to <local-repository>/com/mycompany/app/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.jar
[INFO] Installing <dir>/my-app/pom.xml to <local-repository>/com/mycompany/app/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.678 s
[INFO] Finished at: 2020-07-12T12:04:45+01:00
[INFO] ------------------------------------------------------------------------注意, 执行测试的插件surefire 会寻找包含在特定文件里面的测试用例, 这些测试用例一般的命名都如下:
**/*Test.java**/Test*.java**/*TestCase.java
默认包含:
**/Abstract*Test.java**/Abstract*TestCase.java
clean
clean操作会删除 target文件夹, 还有其他所有的 构建数据, 以保证maven项目的纯净.
mvn clean其实我们构建, 并不只是这么多, 只是分为了几个关键的阶段, 其实还有其他的不太重要的阶段, 如下:
至此, 你已经学会了maven项目构建的整个过程, 从开始的配置, 到现在的 构建, 测试, 打包 和 安装 一个maven工程, 这就是一个maven项目的绝大部分的工作和周期, 如果您已经注意到，到目前为止您所能做的一切都是由一个18行的文件驱动的，即项目的模型或POM。
maven除了提供构建插件和依赖, 你还可以去下载其他的插件, 简便实用, 开箱即用, 你只需要实用下面的命令:
mvn site在Maven（一个流行的Java项目管理和构建自动化工具）中，site 是一个生命周期阶段（lifecycle phase），它主要用于生成项目的站点文档。Maven站点通常包括项目的API文档、项目报告、依赖关系图等。
当你运行 mvn site 命令时，Maven会执行site生命周期阶段以及之前所有的阶段（包括validate、compile、test、package、verify、install）。然后，它会收集项目的各种信息并生成一个静态网站，该网站通常位于项目的 target/site 目录下。
Maven站点通常包括以下几个部分：
- 项目信息：如项目的名称、描述、版本、依赖关系等。
- API文档：如果你使用JavaDoc或其他类似的工具为你的代码生成文档，那么这些文档将被包含在站点中。
- 报告：Maven有许多插件可以生成各种报告，如JUnit测试报告、CPD（Copy/Paste Detector）报告、PMD（Programming Mistake Detector）报告等。这些报告通常用于分析代码质量、测试覆盖率等。
- 依赖关系图：Maven可以生成项目的依赖关系图，这有助于你理解项目如何与其他库和框架交互。
要生成站点，你需要在项目的pom.xml文件中配置一些插件。最常用的插件之一是Maven Site Plugin，它负责生成站点的结构和大部分内容。你还可以通过添加其他插件来扩展站点的功能。
如何使用插件
maven, 其实就是一个插件执行框架, 所有的工作都由插件来完成, 你需要寻找特定的目标来执行? 你可以去根据官网给出的提示来进行操作, 存在构建插件和报告插件:
- 构建插件, 将会在项目构建的时候执行, 并且这类插件需要在<build> 元素下进行设置
- 报告插件, 将会在站点生成的时候执行, 并且他们应该被配置在<reporting> 元素中, 因为报告插件的结果, 也是生成的站点的一部分. 报告插件需要同时国际化和本地化.
下面是maven官网中描述的, maven所支持的插件:
Maven – Available Pluginshttps://maven.apache.org/plugins/查看其他最新的插件列表:
如果你想客制化你的maven项目的构建过程, 你可以添加和配置一些实用的插件, 比如, 你可以将允许jdk1.5版本的java源文件编译的java编译器配置到其中, 下面是一个如何将插件添加到你的pom中的案例:
...
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
</build>
...你会注意到在maven中所有的插件都像一个依赖一样, 仔细对比可以发现, 插件拥有和依赖一样的属性:
- groupId
- artifactId
- version
除此之外, 还拥有一些依赖所没有的属性:
- configuration
- source
- target
- .... (其他子属性)
这个configuration属性(或者称之为元素) 是, 这个配置属性会将其每个参数, 都应用于编译插件给定的目标位置.
在上面的例子中, 编译插件已经在构建的过程中被使用, 这个过程或许也可以添加新的属性值, 来让我在configuration中去配置
疑难解答
将resources添加到jar包
// todo 预留的问题
如何添加资源过滤器
// todo
如何使用外部依赖
如何将jar推送到远程仓库
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
