首页 > 其他分享 >Maven笔记（二）：进阶使用

Maven笔记（二）：进阶使用

时间：2024-09-17 15:51:43浏览次数：8  
标签：maven 依赖 进阶 工程 jar 私服 笔记 Maven 模块

Maven笔记（二）-进阶使用

一、Maven分模块开发

分模块开发对项目的扩展性强，同时方便其他项目引入相同的功能。
image.png
将原始模块按照功能拆分成若干个子模块，方便模块间的相互调用，接口共享(类似Jar包一样之间引用、复用)。
image.png

开发步骤：

  1. 创建Maven项目
  2. 书写模块代码

分模块开发需要先针对模块功能进行设计，再进行编码。不会先将工程开发完毕，然后进行拆分！根据自己需求，分模块构建各模块功能，形成一个独立的资源，其它模块使用时，使用依赖的模式进行引用。
对应在主模块的 pom.xml 文件中，使用 dependency 标签引入对应待使用的相关maven项目依赖!

  1. 通过Maven指令安装模块到本地仓库（install指令 mvn install），这样才能使得在其它模块中进行 compile操作时，才不会找不到本地仓库下的对应模块依赖jar！

团队内部开发需要发布模块功能到团队内部可共享的仓库中（私服）

二、依赖管理

2.1 依赖传递

image.png
如果项目中依赖了某个资源A，这个资源A中依赖了其它资源B。那么在该项目中已能直接使用资源B。

  • 依赖之间存在传递性，传递性分为：
  1. 直接依赖：中当前项目中通过依赖配置建立的依赖关系
  2. 间接依赖：被资源的资源如果依赖其他资源，当前项目就间接依赖其他资源

image.png

  • 依赖传递冲突问题：
  1. 路径优先：当依赖中出现相同的资源时，层级越深，优先级越低哦，层级越浅，优先级越高。(eg:上图中的 2度资源优先级高于3度资源)
  2. 声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的。(eg：上图中的两个3度资源，谁先考前就使用谁)
  3. 特殊优先：pom配置文件中当同级配置了相同资源的不同版本，后配置的覆盖先配置的。
  • 在IDEA 可以查看项目中的依赖关系图 maven --> show dependencies

image.png

2.2 可选依赖 optional

A依赖B，B依赖C，如果B不想将C依赖对A进行开发，或者是C想对外隐藏自己的依赖关系，可以通过 <optional> true </optional>标签来实现对C依赖的可选：

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>maven_03_pojo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--可选依赖是隐藏当前工程所依赖的资源，隐藏后对应资源将不具有依赖传递性-->
    <optional>true</optional>
</dependency>

可以理解为B中的依赖不在进行传递操作！ 项目A依赖B资源时，如果也使用了B中传递依赖C时，如果B资源中的该C资源设置为<optional>true</optional> ，则项目A中还需要在单独引入该隐藏的资源！[隐藏自己的依赖，使依赖不传递 不透明]
image.png

2.3 排除依赖 exclusions

当A依赖B、B依赖C，如果A中不想将B依赖中的C依赖引入进项目，则可以通过排除依赖谁主动断开依赖的资源，被排除的资源无需确定版本，只需要指定 groupId、artifactId 即可！

<dependency>
    <groupId>com.itheima</groupId>
    <artifactId>maven_04_dao</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--排除依赖是隐藏当前资源对应的依赖关系-->
    <exclusions>
        <exclusion>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </exclusion>
    </exclusions>
</dependency>

刷新一下 maven 即可排除：[主动断开依赖的资源 不需要]
image.png

image.png

三、继承与聚合

3.1 聚合工程 modules

image.png

  • 聚合：将多个模块组织成一个整体，同时进行整个项目构建的过程称为聚合

  • 聚合工程：通常是一个不具有业务功能的”空“工程（有且仅有一个pom文件）

  • 作用： 使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现所包含的模块进行同步构建，当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题！

  • 聚合工程开发

  1. 创建Maven模块，聚合工程(父工程)的导报类型为pom<packaging>pom</packaging>。每个maven工程都有对应的打包方式，默认为jar，web工程打包方式为war；
  2. 设置当前聚合工程所包含管理的子模块名称
<packaging>pom</packaging>

<!-- 子工程项目信息 -->
<modules>
    <module>Module-common</module>
    <module>Module-admin</module>
    <module>Module-core</module>
</modules>

下图中的 Maven-Module 就是一个聚合工程，用来做**工程管理（管理其它模块）**的，做聚合的！
image.png 聚合工程中所包含的模块在进行构建时会根据模块间的依赖关系设置构建顺序，与聚合工程中模块的配置书写位置无关。会自动按照依赖关系进行构建，先构建没有依赖关系的项目后，在进行构建其它模块！
参与聚合的工程无法向上感知是否参与聚合，只能向下配置哪些模块参与本工程的聚合。

3.2 继承关系 parent

  • 聚合工程出现的问题：
  1. 在所以子模块中，每个模块都需要配置自己的依赖资源，这会导致出现很多重复配置的依赖资源。
  2. 出现部分模块中出现了相同依赖的配置。
  3. 当需要将项目某个依赖的版本号进行调整时(某个模块对某个资源版本号不支持时)，需要满足已修改，所有的子模块相关依赖都进行修改。

image.png
继承描述的是两个工程之间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。继承的作用：简化配置、减少版本冲突。

  • 继承关系开发
  1. 创建Maven集合工程(父工程)，设置打包类型为pom（建议父工程打包方式设置为pom[上方聚合工程创建的方式]）
  2. 在父工程的pom文件中配置依赖关系（子工程将沿用父工程中的依赖关系）
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    ……
</dependencies>

<dependencies>标签中的依赖是直接沿用到子工程中，全部子工程中都会统一使用。
image.png

  1. 在父工程的pom文件配置子工程中可选的依赖关系
 <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        ……
    </dependencies>
</dependencyManagement>

image.png

  1. 在子工程pom.xml中配置当前工程所继承的父工程
<!--定义该工程的父工程-->
<parent>
    <groupId>com.itheima</groupId>
    <artifactId>maven_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--填写父工程的pom文件，根据实际情况填写（可以不写可以写）-->
    <relativePath>../maven_parent/pom.xml</relativePath>
</parent>

image.png
image.png

  1. 在子工程中配置使用父工程中可选依赖的坐标

父工程pom文件下<dependencyManagement> 标签中的依赖是提供给子工程选择使用的依赖，只有在子模块pom中指定 该标签中的依赖相关信息后(注意在引用时不需要写版本号)，才会沿用到子模块中！
image.png

  • 注意：

子工程中使用父工程中的可选依赖时，仅需要提供群组id和项目id，无需提供版本，版本由父工程统一提供，避免版本冲突！
子工程中还可以定义父工程中没有定义的依赖关系！
在pom文件中该可以使用 <properties> 标签来定义参数，统一控制依赖版本信息，在对应依赖中的<version>标签中通过 ${表达式}来确定对应版本号！（四、属性中介绍）
image.png

3.3 聚合与继承的区别

  • 作用

聚合用于快速构建项目，继承用于快速配置项目

  • 相同点

聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中；
聚合与继承均属于设计型模块，并无实际的模块内容。

  • 不同点

聚合是在当前父模块中配置关系，聚合可以感知到参与聚合的模块有哪些；
继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己。

四、属性管理

4.1 自定义属性 properties

属性的作用就是定义一个变量，然后在 pom 文件中直接引用即可。
image-20210805124018028.png
在为项目中的依赖版本控制的时候，能够快速的批量引用了同一变量的依赖版本。

  • 属性管理使用方式：
  1. 首先定义<properties>...</properties>标签
  2. 在<properties>标签中定义变量值

image.png

  1. 在依赖中使用变量名${变量变量名称}

image.png

4.2 资源文件引用属性 resource

不太主流使用

4.2.1 子工程配置文件中引用maven变量过程

  1. 首先在 聚合工程(父工程)pom 文件中的<properties>标签下定义待使用的属性值：

image.png

  1. 在子模块的配置文件中直接以同样方式${属性名} 引用改变了

image.png

  1. 聚合工程(父Maven)中,即使用properties标签定义了变量的pom文件中，扩大Maven的控制范围。
   <!--配置资源文件，该资源文件下以可以使用maven中的变量-->
  <resources>
      <resource>
          <!-- 配置文件目录 -->
          <directory>${project.basedir}/src/main/resources</directory>
          <!-- 包含的文件类型 -->
          <includes>
              <include>**/*.properties</include>
              <include>**/*.xml</include>
          </includes>
          <!-- 配置过滤规则 能够识别${}格式 -->
          <filtering>true</filtering>
      </resource>
  </resources>

4.2.2 检测配置文件引用变量是否成功

通过以上设置之后就可以直接在 子工程 的配置文件下 使用 ${变量名称} 的方式读取到 聚合工程(父工程) pom 中设置的变量数据了。
这里我们将 Module-core 模块的打包模式设置为 war 包，这样打包后就能查看到 jdbc配置文件中的数据是否加载成功！
image.png

通过 install操作成功之后，在对应本地仓库中找到 对应 groupId 和 artifactId 下的该war包。然后 打开war包路径下的 /WEB-Inf/classses/配置文件
image.png

4.2.3 问题记录

  • 如果 install 过程中出现如下错误：
    • 方式一：

image.png
是因为 Maven在进行打war包时，必须要对应工程中必须要包含 web.xml 文件。 这里就需要在对应打war包的工程中创建对应的文件即可！(临时解决方案)
image.png

  • 方式二：

在对应需要打 war包 的子模块 的pom.xml 中配置 maven-war-plugin 打war插件：

 <build>
        <resources>
            <!--打包src/main/java下的文件-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <!--打包src/main/resources文件夹下的文件-->
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.2.3</version>
                <configuration>
                    <!--  排除web.xml文件,没有web.xml文件时不报错 -->
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>
    </build>
  • 执行 install 操作出现找不到jar 问题

这种情况，需要先在聚合工程中执行一下 compile 操作，然后在执行 install 操作
image.png

  • install 操作后，war包中不含配置文件

打war包成功之后，如果子工程 Module-core 的war中没有对应的 jdbc.properties 配置文件，则需要在该子工程的pom.xml 配置文件中 buidl 标签下 添加 resource 标签。

<build>
  <resources>
      <!--打包src/main/java下的文件-->
      <resource>
          <directory>src/main/java</directory>
          <includes>
              <include>**/*.properties</include>
              <include>**/*.xml</include>
          </includes>
          <filtering>true</filtering>
      </resource>
      <!--打包src/main/resources文件夹下的文件-->
      <resource>
          <directory>src/main/resources</directory>
          <includes>
              <include>**/*.xml</include>
              <include>**/*.properties</include>
          </includes>
          <filtering>true</filtering>
      </resource>
  </resources>
</build>

4.3 Maven中的其它属性

maven中的所有属性分为如下几级：

  1. 自定义属性（常用）
  2. 内置属性
  3. Setting属性
  4. Java系统属性
  5. 环境变量属性

image-20210805124411768.png

具体内容如下（一般使用不上）：
在maven安装路径中的bin目录下执行 mvn help:system 命令 查询系统级的一些属性：
image.png

  • 在指令执行完成之后。对应的 Environment Variables 标签下对应的变量就是对应我们系统的环境变量属性：

image.png

  • 对应 System Properties 标签下的变量 对应的是 Java系统属性：

image.png

使用方式于自定义变量的方式一样，通过${变量名称}使用即可，平时一般情况使用不到，需要获取一些系统设置时可以用到。

4.4 版本管理

4.4.1 工程版本

  1. SNAPSHOT（快照版本）
  • 项目开发过程中临时输出的版本，成为快照版本
  • 快照版本会随着开发的进展不断更新
  1. RELEASE (发布版本)
  • 项目开发到进入阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的
  • 即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本

4.4.2 发布版本

这些版本一般不会保证他的安全性，eg：以前的qq会出新功能，提前让人尝鲜，就会发布一个 beta版本，表示已经经过了beta测试！

  • alpha版
  • beta版
  • 纯数字版

五、多环境配置与应用

5.1 多环境开发 profiles

maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境。
即是将一系列的自定义变量进行编组配置 同时 设置唯一 id,启动时通过命令 指定使用某组环境属性值！
image-20210805124805979.png

  • 在父工程(聚合工程)中进行多种环境的配置：
 <!-- 配置多环节 -->
  <profiles>
      <!-- 开发环境profile 配置 -->
      <profile>
          <id>env-dep</id>
          <properties>
              <jdbc.url>jdbc:mysql://localhost:3306/test</jdbc.url>
          </properties>
          <!-- 设定为默认启动的环境 -->
          <activation>
              <activeByDefault>true</activeByDefault>
          </activation>
      </profile>

      <!-- 生产环境配置 -->
      <profile>
          <id>env-pro</id>
          <properties>
              <jdbc.url>jdbc:mysql://127.1.1.1:3306/test</jdbc.url>
          </properties>
      </profile>

      <!-- 测试环境配置 -->
      <profile>
          <id>env-test</id>
          <properties>
              <jdbc.url>jdbc:mysql://127.0.0.0:3306/test</jdbc.url>
          </properties>
      </profile>
  </profiles>

按照前面方式，在聚合工程中 通过 install项目之后，在对应的war包中查看 配置文件中是否正确加载了对应环境下的参数变量值！

  • 在父工程中，通过mvn 指令执行执行，选择指定环境配置变量

执行指令： mvn install -P 环境id（需要选择对应父工程下来执行该mvn指令）

  • mvn 指令 –P 环境定义id

image.png

执行完指令，确定好环境id后 ，查询war包中对应配置文件数据是否正确加载！
image.png

5.2 跳过测试插件

maven每次执行指令时，都会执行测试过程！能保证程序执行完成之后，打包的正确性！
image.png 但是有时候会存在一种特殊情况，需要不进行测试从而直接进行打包操作！
比如如下需求：程序开发完成后，有一个功能进行了调整，现在想上线进行测试，但是目前有一块功能还没调通没开发完则测试用例无法跑通，就会导致打包安装无法成功！这时候就行跳过测试！

5.2.1 IDEA 跳过测试用例

image.png
这种方式只能跳过所有的测试！

  • 使用命令的方式跳过测试

image.png
-D：表示添加参数
skipTest: 表示跳过测试

5.2.2 细粒度控制跳过测试

测试是一个插件 maven-surefire-plugin，所有需要在 <build>标签中进行设置！
<excludes></excludes> ：排除标签
<includes></includes>：包含标签

 <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12.4</version>
            <configuration>
                <!-- 跳过测试 -->
                <skipTests>false</skipTests>
                <!-- 排除掉不参与测试的资源文件 -->
                <excludes>
                    <exclude>**/Main.java</exclude>
                </excludes>
            </configuration>
        </plugin>
   </plugins>
 </build>

image.png

六、maven私服(略）

场景：自己开发的资源，在别人需要使用时，只能通过U盘的方式进行传递！ 因为重要仓库不能存入私人的资源jar。这种情况下就可以通过私服的方式来实现。
类似替代重要服务器，所作用范围为开发团队共享 或者 公司共享！image-20210805125240781.png

6.1 Nexus私服

Sonatype公司的一款maven私服产品

安装路径下etc目录中nexus-default.properties文件保存有nexus基础配置信息，例如默认访问端口。

  • 修改服务器运行配置信息

安装路径下bin目录中nexus.vmoptions文件保存有nexus服务器启动对应的配置信息，例如默认占用内存空间。

  • 启动服务器（命令行启动）nexus.exe /run nexus

6.2 私服资源操作流程分析

在没有私服之前，我们的jar资源都是存放在maven的本地仓库之中的。私服中也有对应的仓库！上传和下载都是在私服的仓库中进行打交道！
可以按照资源类型创建多个仓库来使用

  • ssm_dao:将自己开发的资源，可以放入私服中，团队也可从该仓库中进行获取
  • spring-context:第三方资源，从中央服务器下载的资源。 也可以直接实现放入私服中，这样所有资源都从私服中进行获取！(外网禁用的情况下，私服与中央服务器打交道)
  • ssm_pojo.snapshot ：存入 临时、快照版本资源

image-20210805125509894.png

需求： 上传时能实现存入那个仓库，在下载时无需指定某个仓库！
实习方式：将所有仓库设置为一个仓库组。

6.3 私服仓库分类

image-20210805125522304.png

  • 宿主仓库：

第三方资源：指示的是中央仓库中都不含有的资源。比如 Oracle 数据库连接驱动！（因为涉及版权和开源所以中央仓库中没有）！

  • 代理仓库：不允许上传，只能下载
  • 仓库组：对所有仓库进行打包下载，只用于下载

6.4 资源的上传与下载

私服不能随便访问，需要在本地仓库中配置访问权限、上传位置(宿主地址)、下载访问权限、下载地址(仓库组地址）。
image-20210805125541963.png
以上设置都是进行设置本地仓库的配置文件maven安装地址/conf/settings.xml中进行设置：

6.4.1 本地仓库访问私服权限设置

需要在本地Maven配置文件settings.xml 的<servers>标签下进行设置：
image.png
私服中的服务器id就是对应私服中仓库的name。
image.png

  • 在nexus中设置允许匿名下载，如果不允许将不会从私服中下载依赖

image-20201119201910078.png

6.4.2 私服的访问地址(镜像)配置

需要在本地Maven配置文件settings.xml 的<mirrors>标签下进行设置，需要注释掉aliyun的配置。

<morrors>
  <!-- 私服的访问路径 -->
    <mirror>
      <id>仓库组Id</id>
      <!-- 资源来源：*表示所有 -->
      <mirrorOf>*</mirrorOf>
      <url>仓库组地址</url>
    </mirror>
</morrors>

image.png

对应仓库组中 查看管理的仓库，需要将我们自建的仓库拉入仓库组
image.png

  • 如果私服中没有对应的jar，会去中央仓库下载，速度很慢。可以配置让私服去阿里云中下载依赖。

image-20210817102823906.png

6.4.3 项目工程中指定上传私服仓库 distributionManagement

需要在聚合工程的 pom文件中进行如下配置发布管理：

<distributionManagement>
    <!-- 发布正式版本仓库 -->
    <repository>
      	<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>heima-nexus</id>
      	<!--如果jar的版本是release版本，那么就上传到这个仓库，根据自己情况修改-->
        <url>http://localhost:8081/repository/heima-releases/</url>
    </repository>
    <!-- 发布临时版仓库 -->
    <snapshotRepository>
      	<!--和maven/settings.xml中server中的id一致，表示使用该id对应的用户名和密码-->
        <id>heima-nexus</id>
      	<!--如果jar的版本是snapshot版本，那么就上传到这个仓库，根据自己情况修改-->
        <url>http://localhost:8081/repository/heima-snapshots/</url>
    </snapshotRepository>
</distributionManagement>
  • 发布资源到私服 mvn deploy

在向私服中发布资源时间，会根据版本号( SNAPSHOT / RELEASE )进行上传到正式版本仓库和临时版本仓库。
image.png
发布的资源会一直留下来，不会自动主动删除！ 需要在私服中进行手动删除。

七、maven打包将配置文件放在jar包外[记录文件]

通过以下配置，将项目 依赖jar文件、resource下的所有资源文件 全部独立出来进行项目部署操作！ 同时将这些文件数据 在加上 项目启动脚本将部署程序在独立压缩为一个zip。 方便项目部署操作！
最终效果通过 7.4中展现出来！

7.1 项目中Maven的配置

 <properties>
   <!-- 注意设置该属性值与springboot版本一致，spring-boot-maven-plugin插件需要引用该属性与springboot版本保持一致 -->
    <spring-boot.version>2.7.6</spring-boot.version>
</properties>


<build>
  <plugins>
      <!--打包jar[用于将项目打包成JAR文件] -->
      <!-- [通过这些配置，可以生成一个包含特定Manifest信息的JAR文件，并排除不需要的资源文件，最终输出到指定的目录中。] -->
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-jar-plugin</artifactId>
          <configuration>
              <!--<includeSystemScope>true</includeSystemScope>-->
              <!--不打包资源文件[jar中需要排除的文件] -->
              <excludes>
                  <!-- 这里排除了所有文件（*.**）和所有子目录中的XML文件（*/*.xml） -->
                  <exclude>*.**</exclude>
                  <exclude>*/*.xml</exclude>
              </excludes>
              <!-- 归档配置 -->
              <!-- archive标签内配置了JAR文件的Manifest文件内容。 -->
              <archive>
                  <manifest>
                      <!-- [表示在Manifest文件中添加类路径] -->
                      <addClasspath>true</addClasspath>
                      <!--MANIFEST.MF 中 Class-Path 加入前缀 [表示在Manifest文件的Class-Path条目中添加前缀lib/]-->
                      <classpathPrefix>lib/</classpathPrefix>
                      <!--jar包不包含唯一版本标识 [表示JAR包不包含唯一版本标识。]-->
                      <useUniqueVersions>false</useUniqueVersions>
                      <!--指定入口类 [指定了JAR文件的入口类] -->
                      <mainClass>com.zdsf.u8cloudmanagementproject.U8CloudManagementProjectApplication</mainClass>
                  </manifest>
                  <manifestEntries>
                      <!--MANIFEST.MF 中 Class-Path 加入资源文件目录 [指定了资源文件目录为./resources/] -->
                      <Class-Path>./resources/</Class-Path>
                  </manifestEntries>
              </archive>
              <!--[配置JAR文件的输出目录为Maven项目构建目录（通常是target目录）] -->
              <outputDirectory>${project.build.directory}</outputDirectory>
          </configuration>
      </plugin>
  
      <!--拷贝依赖 copy-dependencies [这个插件用于处理项目的依赖。]-->
      <!-- [主要功能是将项目的依赖库拷贝到target/lib/目录下。这样做的好处是可以将所有依赖库集中管理，便于项目的部署和运行。] -->
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-dependency-plugin</artifactId>
          <!-- 标签内定义了插件的执行配置。 -->
          <executions>
              <!-- 具体的执行任务 -->
              <execution>
                  <id>copy-dependencies</id>
                  <!-- 表示这个任务在Maven的package阶段执行 -->
                  <phase>package</phase>
                  <goals>
                      <!-- goals标签内定义了要执行的目标，这里的目标是copy-dependencies，即拷贝依赖。 -->
                      <goal>copy-dependencies</goal>
                  </goals>
                  <!-- 定义了该执行任务的具体配置 -->
                  <configuration>
                      <!-- 指定了依赖文件的输出目录，这里使用Maven属性${project.build.directory}，通常是target目录，后面加上/lib/子目录。 -->
                      <outputDirectory>
                          ${project.build.directory}/lib/
                      </outputDirectory>
                  </configuration>
              </execution>
          </executions>
      </plugin>
  
      <!--拷贝资源文件 copy-resources -->
      <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <!--执行配置-->
          <executions>
              <!--具体的执行任务-->
              <execution>
                  <id>copy-resources</id>
                  <!-- 指定该任务在 Maven 的 package 阶段执行。 -->
                  <phase>package</phase>
                  <goals>
                      <goal>copy-resources</goal>
                  </goals>
                  <!--定义了该执行任务的具体配置-->
                  <configuration>
                      <!-- 定义了要拷贝的资源文件 -->
                      <resources>
                          <!-- 指定了资源文件的源目录，即 src/main/resources。 -->
                          <resource>
                              <directory>src/main/resources</directory>
                          </resource>
                      </resources>
                      <!-- 指定了资源文件的输出目录，这里使用 Maven 属性 ${project.build.directory}，通常是 target 目录，后面加上 /resources 子目录。 -->
                      <outputDirectory>${project.build.directory}/resources</outputDirectory>
                  </configuration>
              </execution>
          </executions>
      </plugin>
  
      <plugin>
          <!-- YUI Compressor Maven压缩插件 -->
          <!--  YUI Compressor Maven 插件，用于压缩项目中的 JS 文件 -->
          <groupId>net.alchim31.maven</groupId>
          <artifactId>yuicompressor-maven-plugin</artifactId>
          <version>1.5.1</version>
          <!-- 这里指定了一个执行目标 compress，即压缩文件。 -->
          <executions>
              <execution>
                  <goals>
                      <goal>compress</goal>
                  </goals>
              </execution>
          </executions>
          <!-- 开始配置插件的具体参数 -->
          <configuration>
              <!-- 读取js,css文件采用UTF-8编码 -->
              <encoding>UTF-8</encoding>
              <!-- 不显示js可能的错误 [设置为 false，表示不显示 JS 可能的错误。] -->
              <jswarn>false</jswarn>
              <!-- 若存在已压缩的文件，会先对比源文件是否有改动 有改动便压缩，无改动就不压缩 -->
              <force>false</force>
              <!-- 在指定的列号后插入新行 [设置为 -1，表示不插入新行] -->
              <linebreakpos>-1</linebreakpos>
              <!-- 压缩之前先执行聚合文件操作 [true，表示压缩之前先执行聚合文件操作]-->
              <preProcessAggregates>true</preProcessAggregates>
              <!-- 压缩后保存文件后缀 无后缀 -->
              <nosuffix>true</nosuffix>
              <!-- 源目录，即需压缩的根目录 [指定需压缩的根目录] -->
              <sourceDirectory>src/main/resources/static/js</sourceDirectory>
              <!-- 输出目录，即压缩后的目录 -->
              <outputDirectory>${project.build.directory}/resources/</outputDirectory>
              <force>true</force>
              <!-- 压缩js和css文件 -->
              <includes>
                  <include>**/*.js</include>
              </includes>
              <!-- 以下目录和文件不会被压缩 -->
              <excludes>
                  <exclude>**/*.min.js</exclude>
                  <exclude>**/*.css</exclude>
                  <exclude>**/common/**</exclude>
                  <exclude>**/OrderDetails.js</exclude>
                  <exclude>**/ht_Administory/*.js</exclude>
                  <exclude>**/refund/*.js</exclude>
              </excludes>
          </configuration>
      </plugin>
  
      <!--spring boot repackage，依赖 maven-jar-plugin 打包的jar包 重新打包成 spring boot
          的jar包 -->
      <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <version>${spring-boot.version}</version>
          <configuration>
              <!--重写包含依赖，包含不存在的依赖，jar里没有pom里的依赖 -->
              <includes>
                  <!-- includes标签用于指定在打包时包含的依赖。这里配置了一个groupId和artifactId都为null的依赖，这实际上是一个占位符，表示不包含任何实际的依赖。 -->
                  <include>
                      <groupId>null</groupId>
                      <artifactId>null</artifactId>
                  </include>
              </includes>
              <!-- layout标签指定了打包的布局格式为ZIP。 -->
              <layout>ZIP</layout>
              <!--使用外部配置文件，jar包里没有资源文件 [addResources标签设置为true，表示在打包时使用外部配置文件，而不是将资源文件打包进JAR中。] -->
              <addResources>true</addResources>
              <!-- 指定了输出目录为Maven项目构建目录 -->
              <outputDirectory>${project.build.directory}</outputDirectory>
          </configuration>
          <executions>
              <!--执行目标repackage，表示重新打包 -->
              <execution>
                  <goals>
                      <goal>repackage</goal>
                  </goals>
                  <configuration>
                      <!--配置jar包特殊标识 配置后，保留原文件，生成新文件 *-run.jar -->
                      <!--配置jar包特殊标识 不配置，原文件命名为 *.jar.original，生成新文件 *.jar -->
                      <!--<classifier>run</classifier> -->
                  </configuration>
              </execution>
          </executions>
      </plugin>
  
      <plugin>
          <!-- 用于创建自定义分发包的插件 -->
          <artifactId>maven-assembly-plugin</artifactId>
          <configuration>
              <!-- not append assembly id in release file name -->
              <!-- 表示在生成的分发包文件名中不附加assembly ID。这样可以保持文件名的简洁。 -->
              <appendAssemblyId>false</appendAssemblyId>
              <descriptors>
                  <!-- 定义了一个描述符文件src/main/resources/package.xml，这个文件用于描述如何打包项目，包括哪些文件和目录需要包含在分发包中。 -->
                  <descriptor>src/main/resources/package.xml</descriptor>
              </descriptors>
          </configuration>
          <!-- 插件的执行配置。 -->
          <executions>
              <execution>
                  <id>make-assembly</id>
                  <!-- 任务在Maven的package阶段执行 -->
                  <phase>package</phase>
                  <!-- 定义了要执行的目标，这里的目标是single，表示执行一次打包操作。 -->
                  <goals>
                      <goal>single</goal>
                  </goals>
              </execution>
          </executions>
      </plugin>
  </plugins>
</build>

[注意修改内容]：

  • spring-boot-maven-plugin 打包插件版本号

之间在配置的属性中进行修改即可！

  • 指定入口类位置

在 maven-jar-plugin 插件中的 mainClass 属性中需要根据自己项目对主类入口地址进行调整！

7.2 分发包插件配置文件

在项目源码中创建一个 package.xml 配置文件，用于 maven-assembly-plugin 分发包插件的调用！
image.png

  • package.xml 文件内容
<?xml version="1.0" encoding="UTF-8"?>
<assembly
	xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
	<id>package</id>
	<formats>
		<format>zip</format>
	</formats>
	<includeBaseDirectory>true</includeBaseDirectory>
	<!-- 将项目构建目录中的资源文件打包到压缩包中，并对特定类型的文件（如脚本文件）设置特定的权限和输出目录 -->
	<fileSets>
		<fileSet>
			<!-- 源目录路径中 目录中选择所有 .bat 和 .sh 文件。 -->
			<directory>${project.build.directory}/resources</directory>
			<outputDirectory>/</outputDirectory>
			<!-- 脚本文件在 linux 下的权限设为 755，无需 chmod 可直接运行 -->
			<fileMode>755</fileMode>
			<includes>
				<include>*.bat</include>
				<include>*.sh</include>
			</includes>
		</fileSet>

		<fileSet>
			<!-- 目录中选择所有非 .bat 和 .sh 文件 -->
			<directory>${project.build.directory}/resources</directory>
			<outputDirectory>/resources</outputDirectory>
			<excludes>
				<exclude>**/*.bat</exclude>
				<exclude>**/*.sh</exclude>
			</excludes>
		</fileSet>

		<fileSet>
			<directory>${project.build.directory}/lib</directory>
			<outputDirectory>/lib</outputDirectory>
		</fileSet>

		<fileSet>
			<directory>${project.build.directory}</directory>
			<outputDirectory>/</outputDirectory>
			<includes>
				<include>*.jar</include>
			</includes>
		</fileSet>

	</fileSets>

</assembly>

7.3 项目启动脚本编写

在源码中创建四个项目启动相关的脚本文件，用于项目jar的启动操作！
这几个启动脚本会在打包时被 分发包插件 统一压缩到zip文件下，在项目部署时直接解压压缩包之后点击脚本即可启动项目！
image.png

[注意：所有脚本中的 **java -Dfile.encoding=utf-8 -jar xxxx.jar** 命令后面的xxx.jar jar包文件名称需要根据自己项目打包后的名称进行修改! 否则脚本无法实现项目启动功能！ ]

  • restart.sh 脚本内容
#!/bin/bash
echo stop application
source stop.sh
echo start application
source start.sh
  • start.bat 脚本内容
@echo off
set "JRE_HOME=.\jre1.8.0_221"
set "JAVA_HOME=.\jdk1.8.0_221"
set "CLASSPATH=.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar"
path %path%;%JRE_HOME%\bin
path %path%;%JAVA_HOME%\bin
path
java -Dfile.encoding=utf-8 -jar u8CloudManagementProject-0.0.1-SNAPSHOT.jar
@pause
  • star.sh 脚本内容
#!/bin/bash
#（自己安装解压后的jdk路径----自行修改）
export JAVA_HOME=/user_normal/java/jdk1.8
export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$JAVA_HOME/bin:$PATH
nohup java -Dfile.encoding=utf-8 -jar u8CloudManagementProject-0.0.1-SNAPSHOT.jar
  • stop.sh 脚本内容
#!/bin/bash
PID=$(ps -ef | WXJFSPCXGSJZYV2-2.0.jar | grep -v grep | awk '{ print $2 }')
if [ -z "$PID" ]
then
    echo Application is already stopped
else
    echo kill $PID
    kill $PID
fi

7.4 项目执行打包操作效果

通过maven 执行 package 操作后的 target 文件夹中的内容：

image.png
这样就实现了 资源和jar 分离的操作！
同时这里生成了一个.zip 压缩包，解压后进入该文件夹可以得到项目运行所需要的所有资源：
image.png

标签：maven,依赖,进阶,工程,jar,私服,笔记,Maven,模块
From： https://blog.csdn.net/LiuCJ_20000/article/details/140350932

相关文章

  • 【软考】进制转换笔记
    学习参考：https://www.bilibili.com/video/BV1rc411t71D?p=2一、十进制数74356.234 按十进制算法为 整数部分：7 位权为数4，4 位权数为3，3位权数为2，5位权数为1，6位权数为0小数部分：2 位权数为-1，3 位权数为-2，4位权数-3进制为10，公式是 进制N的位权数次方所得整......
  • 代码整洁之道--读书笔记(11)
    代码整洁之道简介：本书是编程大师“Bob大叔”40余年编程生涯的心得体会的总结，讲解要成为真正专业的程序员需要具备什么样的态度，需要遵循什么样的原则，需要采取什么样的行动。作者以自己以及身边的同事走过的弯路、犯过的错误为例，意在为后来者引路，助其职业生涯迈上更高台阶。本......
  • 基于django+vue高校笔记分享系统【开题报告+程序+论文】-计算机毕设
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景在信息化高速发展的今天，高等教育领域正经历着前所未有的变革。随着知识更新速度的加快和在线学习平台的兴起，学生们对于高效获取、整理与分......
  • 【学习笔记】欧拉线性筛
    欧拉线性筛简介欧拉线性筛主要用于求\(n\)以内的所有素数，时间复杂度为\(O(n)\)算法实现欧拉线性筛的原理是保证\(n\)以内的所有素数只被他所含有的最小质因子筛过，这样就使得每个素数只被筛过了一次。我们设一个数组\(prime[i]\)表示第\(i\)个素数是多少,\(is\_prime[i]\)表示......
  • 【学习笔记】扩展欧几里得
    扩展欧几里得算法(exgcd)简介扩展欧几里得算法基于辗转相除法构建，主要用于求方程\[ax+by=c\]最小正整数解步骤1.求方程\(ax+by=gcd(a,b)\)的解我们构造两个方程\[\begin{cases}ax+by=gcd(a,b)\\bx'+(a\%b)y'=gcd(b,a\%b)\end{cases}\]因为由欧几里得算法易于得到\[gc......
  • CMake构建学习笔记17-uriparser库的构建和使用
    在连续论述了几篇关于CMake如何使用的文章之后，笔者也是感觉被掏空了。接下来几篇就还是回到构建依赖库的问题上，容笔者花时间找到更好的主题来介绍更多关于CMake使用干货。如何有的读者自信已经很熟悉这方面的知识，可以进行跳过，在需要的时候再进行查阅。uriparser是一个严格遵循RFC......
  • 2024/9/17 笔记
    多项式以后再写吧。首先庆祝一下把猪国杀A了[SDOI2010]猪国杀题目描述游戏背景《猪国杀》是一种多猪牌类回合制游戏，一共有\(3\)种角色：主猪，忠猪，反猪。每局游戏主猪有且只有\(1\)只，忠猪和反猪可以有多只，每只猪扮演$1$种角色。游戏目的主猪/\(\texttt{MP}\)：自己存活......
  • 初学Linux笔记
    对linux系统中目录的解释：/bin：bin是Binary的缩写,这个目录存放着最经常使用的命令。/boot：这里存放的是启动Linux时使用的一些核心文件，包括一些连接文件以及镜像文件。/dev：dev是Device(设备)的缩写,存放的是Linux的外部设备，在Linux中访问设备的方式和访问文件的方式是相同的。/e......
  • 【学习笔记】数位DP
    数位DP适用条件此类题目一般要求在\([l,r]\)区间内满足条件的数的个数，答案一般与数的大小无关，而与数各位的组成有关。题目中给出的数的范围一般较大，往往在\(10^9\)以上因此无法暴力枚举，只能使用动态规划代码实现使用记忆化搜索更简单易于理解。从数的高位向低位搜索，每一位可......
  • C/C++笔记
    C/CPP笔记杂记structmsg_train和typedefstructmsg_train大小不一样cstdio和stdio#include<stdio.h>intmain(){printf("Hello,World!\n");return0;}#include<cstdio>intmain(){std::printf("Hello,World!\n"......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99