Maven详解

Maven概述

Maven是一个开源的项目管理和构建工具，用于帮助Java开发人员自动化构建、依赖管理和项目生命周期管理。
项目结构管理：Maven使用一种约定的项目结构，通过在项目中定义标准目录结构，可以更容易地组织和管理项目代码。
依赖管理：Maven通过使用pom.xml文件来管理项目的依赖关系。开发人员可以在pom.xml文件中指定项目所需的依赖项，Maven会自动下载并将这些依赖项添加到项目的类路径中。
构建管理：Maven使用插件来执行各种构建任务，例如编译代码、运行单元测试、打包应用程序等。开发人员可以配置这些插件来满足项目的特定需求。
项目生命周期管理：Maven定义了一套标准的项目生命周期，包括clean、compile、test、package等阶段。开发人员可以根据需要执行特定的生命周期阶段来构建项目。
发布管理：Maven可以帮助开发人员将项目构建结果发布到仓库或者部署到服务器中，以便其他人可以使用或者访问这些构建结果。
多模块支持：Maven支持多模块项目，允许开发人员将大型项目分割为多个模块，并且可以在父级pom.xml中定义共享的依赖和配置。
总之，Maven提供了一种规范化的项目管理和构建方式，使得开发人员能够更轻松地管理项目依赖、执行构建任务，并且更好地组织和协调项目开发过程。

Maven详解

Maven是一个项目管理工具，特别适用于Java项目，但也可以用于其他语言的项目，如C#、Ruby、Scala等。
Maven是一个纯Java开发的开源项目，由Apache软件基金会提供。它基于项目对象模型（POM）概念，通过一小段描述信息来管理项目的构建、报告和文档。
Maven是一个强大且灵活的项目管理工具，尤其适用于Java项目。它通过标准化的项目结构、强大的依赖管理和丰富的插件生态系统，大大简化了项目的构建和管理过程。掌握Maven的基本概念和使用方法，可以显著提高开发效率和项目的可维护性。

Maven主要功能
依赖管理：帮助开发人员管理项目所需的外部依赖库。开发人员只需在项目的配置文件中声明所需的依赖，Maven就会自动下载并管理这些依赖。
构建管理：执行项目的构建过程，包括编译、测试、打包和部署等。开发人员可以使用Maven提供的命令来执行这些任务，而不需要手动编写复杂的构建脚本。
标准化项目结构：提供一个标准的项目结构，使得不同的开发人员能够更容易地理解和协作。
项目文档生成：根据项目的配置文件和注释信息自动生成文档。
多模块项目管理：支持多模块项目的管理和构建，提高开发效率。
构建配置的统一管理：使用一个XML格式的配置文件来管理项目的构建配置，该文件可以被版本控制系统管理，以便团队成员共享和协作。

Maven的组成和特性
Maven包含一个项目对象模型（POM），一组标准集合，一个项目生命周期，一个依赖管理系统，以及用来运行定义在生命周期阶段中插件目标的逻辑。
POM（Project Object Model）：Maven的核心文件，包含了项目的基础配置信息和依赖管理信息。
标准集合：Maven定义了一套标准的目录结构和命名规范，使得项目结构更加清晰和统一。
项目生命周期：Maven将项目的构建过程划分为一系列的阶段（phase），每个阶段都有特定的目标和插件与之关联。
依赖管理系统：Maven通过坐标（groupId、artifactId、version）来唯一标识一个依赖，并可以从中央仓库或其他远程仓库自动下载所需的依赖。

Maven的常用命令
mvn archetype:generate：创建Maven项目。
mvn compile：编译源代码。
mvn deploy：发布项目。
mvn test-compile：编译测试源代码。
mvn test：运行应用程序中的单元测试。
mvn site：生成项目相关信息的网站。
mvn clean：清除项目目录中的生成结果。
mvn package：根据项目生成的jar或war包。

Maven仓库
Maven仓库是存放所有JAR文件（WAR、ZIP、POM等）的地方，分为本地仓库和远程仓库（包括中央仓库和其他公共仓库）。当Maven项目需要某些构件时，它会首先查看本地仓库，若本地仓库不存在此构件，Maven就会去远程仓库查找并下载到本地仓库使用。

Maven是一个项目管理和构建自动化工具，主要用于Java项目。它基于Project Object Model（POM），可以通过简化项目的构建过程和依赖管理来提高开发效率。

Maven项目结构

Maven建议使用的标准项目目录结构如下：

my-app
|-- src
|   |-- main
|   |   |-- java
|   |   |   `-- com
|   |   |       `-- mycompany
|   |   |           `-- app
|   |   |               `-- App.java
|   |   `-- resources
|   |       `-- application.properties
|   `-- test
|       |-- java
|       |   `-- com
|       |       `-- mycompany
|       |           `-- app
|       |               `-- AppTest.java
|       `-- resources
|-- pom.xml
`-- target

POM文件

POM（Project Object Model）文件是Maven项目的核心配置文件，通常命名为pom.xml。一个简单的POM文件示例如下：

<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>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
依赖管理
在POM文件中，通过<dependencies>标签可以声明项目所需的依赖。例如：
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
</dependencies>

构建和生命周期

Maven的构建过程分为多个阶段，每个阶段完成一组特定的任务。常用的构建命令包括：
mvn validate：验证项目是否正确且所有必要信息是否可用。
mvn compile：编译项目的源代码。
mvn test：运行测试。
mvn package：打包编译代码成可分发的格式（如JAR）。
mvn install：将包安装到本地仓库，以供其他项目使用。
mvn deploy：将最终包复制到远程仓库，以共享给其他开发者和项目。

插件系统
Maven插件用于执行各种任务，从编译代码到生成报告。例如，使用maven-compiler-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>

多模块项目
Maven支持多模块项目，使得可以将一个大项目拆分为多个子模块。父POM文件如下：

<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>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>module-a</module>
        <module>module-b</module>
    </modules>
</project>

子模块的POM文件可以继承父POM

<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>
    <parent>
        <groupId>com.mycompany.app</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>module-a</artifactId>
</project>

Maven 中 package 和 install 区别

package 是把 jar 打到本项目的 target 下，而 install 时把 target 下的 jar 安装到本地仓库，供其他项目使用。
在 Maven 中，install 和 package 是两个不同的构建命令，它们有以下区别：
undefined package 命令：package 命令是 Maven 的默认生命周期阶段之一。执行 mvn package 命令会将项目编译、测试并打包成可分发的格式（如 JAR、WAR 或其他类型）。这个过程会生成项目的构建产物，并将其存放在目标文件夹 (target) 下。package 过程通常不涉及发布构件到远程仓库，只是在本地构建产物文件，供进一步的使用或测试。
undefined install 命令：install 命令也是 Maven 的默认生命周期阶段之一。执行 mvn install 命令会首先执行 package 阶段，并将构建产物安装到本地 Maven 仓库中。这样，其他项目可以引用并依赖于该构建产物。install 过程主要用于项目间的依赖管理。当你希望将一个项目的构建产物放入本地仓库，并让其他项目可以通过 Maven 引用和使用该构建产物时，可以使用 install 命令。
总结起来，package 命令将项目打包成可分发的格式，而 install 命令在此基础上将构建产物安装到本地仓库，使其可以供其他项目引用。

idea中实用插件Search In Repository

maven依赖jar 新的
Maven Repository官网：https://mvnrepository.com/

Maven Helper jar 依赖冲突

Maven Helper 依赖冲突
Maven Helper——分析Maven项目的相关依赖
maven helper ------ 可以快速解决maven依赖冲突，和查看结构

jar包依赖关系 mvn dependency:tree

#打印依赖树
mvn dependency:tree

#将依赖树打印到文件中
mvn dependency:tree > a.txt

#打印包含某些包的依赖树
mvn dependency:tree -Dincludes=com.alibaba:fastjson

Maven项目中导入第三方jar包

把jar打打到pom文件中
生成对应的pom文件，maven仓库加入对应的jar包和pom文件
mvn install:install-file -Dfile=lucene-queryparser-4.6.1.jar -DgroupId=org.apache.lucene -DartifactId=lucene-queryparser -Dversion=4.6.1 -Dpackaging=jar
项目

 <!--视翰显示器-->
        <dependency>
            <groupId>com.shihan</groupId>
            <artifactId>displayer-plugin</artifactId>
            <version>1.0.0</version>
        </dependency>

mvn install:install-file -Dfile=lumen_protocol.jar  -DgroupId=com.shihan  -DartifactId=displayer-plugin  -Dversion=1.0.0  -Dpackaging=jar

mvn install:install-file -Dfile=D:\liucheng\sh\code\ruili\ams\sms.maxvision-plugin\src\main\resources\lib\masmgc.jar -DgroupId=com.mobileSms -DartifactId=masmgc-sdk-sms -Dversion=1.0.0 -Dpackaging=jar

Jar包指定lib目录启动项目(springboot精简打包jar，使用外部lib)

每次打包项目并上传到服务器，Jar 包大小都有几十上百 M，这是因为Jar包中包含了项目所依赖的全部其他 Jar 包，就是在 Idea 目录下外部库列表的那些。修改主工程 pom 文件的 Maven 插件配置，可以在打包的时候排除这些 Jar 包依赖。




org.springframework.boot
spring-boot-maven-plugin

true
ZIP


nothing
nothing

${artifactId}

去除依赖包后，小项目的话打包后也就只有几百 K 了。
运行以下 Maven 命令，可以将排除的外部依赖 Jar 包下载到本地。
mvn dependency:copy-dependencies -DoutputDirectory=D:\wwwroot\lib -DincludeScope=runtime
项目的 Jar 包，和依赖库 lib 文件夹，放到文件夹（这个没啥要求），新建启动项目的批处理命令，就可以指定 lib 目录启动项目了。后面要更新项目就只用替换比较小的项目 Jar 包了，当然在添加新的依赖的时候，记得将新的依赖 Jar 包添加到 lib 文件夹中。

PS：直接在命令行运行这个命令可能启动不了，我碰到的问题是：报错 找不到或无法加载主类。找了挺久也没找到答案，有懂的大佬可以评论区告知，感谢！
【springboot精简打包jar，使用外部lib】

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
            </plugin>
            <!--打包jar-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <!--不打包资源文件-->
                    <!--<excludes>-->
                    <!--<exclude>*.**</exclude>-->
                    <!--<exclude>*/*.xml</exclude>-->
                    <!--</excludes>-->
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <!--MANIFEST.MF 中 Class-Path 加入前缀-->
                            <classpathPrefix>lib/</classpathPrefix>
                            <!--jar包不包含唯一版本标识-->
                            <useUniqueVersions>false</useUniqueVersions>
                            <!--指定入口类-->
                            <mainClass>com.XXX.XXXX</mainClass>
                        </manifest>
                    </archive>
                    <outputDirectory>${project.build.directory}</outputDirectory>
                </configuration>
            </plugin>
            <!--拷贝依赖 copy-dependencies-->
            <!--也可以执行mvn copy-dependencies 命令打包依赖-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>
                                ${project.build.directory}/lib/
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!--spring boot repackage，依赖 maven-jar-plugin 打包的jar包 重新打包成 spring boot 的jar包-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--重写包含依赖，包含不存在的依赖，jar里没有pom里的依赖-->
                    <includes>
                        <include>
                            <groupId>null</groupId>
                            <artifactId>null</artifactId>
                        </include>
                    </includes>
                    <layout>ZIP</layout>
                    <!--使用外部配置文件，jar包里没有资源文件-->
                    <addResources>true</addResources>
                    <outputDirectory>${project.build.directory}</outputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <!--配置jar包特殊标识 配置后，保留原文件，生成新文件 *-run.jar -->
                            <!--配置jar包特殊标识 不配置，原文件命名为 *.jar.original，生成新文件 *.jar -->
                            <!--<classifier>run</classifier>-->
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

项目执行：
nohup java -Dloader.path=/home/java/lib/* -jar comm-cron.jar >cons.log &
备注：-Dloader.path后面编辑为lib包路径