跳转至

使用maven-assembly-plugin插件定制化打包

1 有个想法

以 SpringBoot 为例，使用官方默认的 maven 插件 spring-boot-maven-plugin 进行打包时，最终的形态是一个 jar 包，其中 配置文件 、 lib依赖 都会打进 jar 内，这就导致了整个 jar 包的体积很大。对于经常进行版本更迭的项目来说，每次都是要把整个 jar 上传。如果网速较慢的话，那么整个更迭的过程会很痛苦。

那么理想状态是什么样子呢？对于 lib依赖 、 配置文件 没有变更的情况，我只上传代码就可以了。也就是说如果将 jar 包中的 配置文件 、 lib依赖 分离出来，那么就可以更灵活的进行版本更迭了。

2 实现想法

有了想法，那么就开始实操啦。具体要实现的步骤如下：

  1. 需要将 jar 进行瘦身，只把代码放进去，并添加对 配置文件 、 lib依赖 的引用；

  2. 需要将需要的 配置文件 ，拷贝出来；

  3. 需要将 lib依赖 ，拷贝出来；

  4. 整合打包；

3 jar瘦身

jar 瘦身，需要用到 maven-jar-plugin 插件，其配置如下：

  • pom.xml

    XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <!-- 项目启动类 -->
                <mainClass>cn.blueisacat.gc.boot.Application</mainClass>
                <!-- 依赖的jar的目录前缀 -->
                <classpathPrefix>../lib</classpathPrefix>
                <addClasspath>true</addClasspath>
            </manifest>
            <manifestEntries>
                <!-- 配置文件的目录-->
                <Class-Path>../config/</Class-Path>
            </manifestEntries>
        </archive>
        <excludes>
            <exclude>config/**</exclude>
        </excludes>
    </configuration>
</plugin>

    Tip

    • mainClass ：指定 jar 的启动类

    • classpathPrefix ：添加 lib依赖 到 classpath ， ../lib 为稍后 lib依赖 拷贝的目录

    • Class-Path ：添加 配置文件 的目录到 classpath ， ../config 为稍后 配置文件 拷贝的目录

4 配置文件拷贝

配置文件 拷贝，需要用到 maven-resources-plugin 插件，其配置如下：

  • pom.xml

    XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
</plugin>

<resources>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
        <includes>
            <include>application.yml</include>
            <include>application-${profileActive}.yml</include>
            <include>logback-spring.xml</include>
        </includes>
        <targetPath>config</targetPath>
    </resource>
</resources>

    Tip

    • directory ：指定 配置文件 从哪里拷贝

    • targetPath ：指定 配置文件 拷贝到哪里

    这里需要注意的是，最终拷贝到的根目录是 \target\classes 。

5 lib依赖拷贝

lib依赖 拷贝，需要用到 maven-dependency-plugin 插件，其配置如下：

  • pom.xml

    XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>target/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
                <includeScope>compile</includeScope>
            </configuration>
        </execution>
    </executions>
</plugin>

    Tip

    • outputDirectory ： lib依赖 拷贝到哪里

6 整合打包

整合打包，需要用到 maven-assembly-plugin 插件，其配置如下：

  • pom.xml

    XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptors>
            <descriptor>src/main/resources/assembly.xml</descriptor>
        </descriptors>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

    Tip

    • descriptor ：指定了 assembly.xml 的位置

  • assembly.xml

    XML
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    <?xml version="1.0" encoding="UTF-8"?>
<assembly>
    <!-- 可自定义，这里指定的是项目环境 -->
    <id>${project.version}-${profileActive}</id>
    <!-- 打包的类型，如果有N个，将会打N个类型的包 -->
    <formats>
        <format>tar.gz</format>
    </formats>
    <includeBaseDirectory>true</includeBaseDirectory>
    <fileSets>
        <!--
            0755->即用户具有读/写/执行权限，组用户和其它用户具有读写权限；
            0644->即用户具有读写权限，组用户和其它用户具有只读权限；
        -->
        <!-- 将src/bin目录下的所有文件输出到打包后的bin目录中 -->
        <fileSet>
            <directory>${basedir}/src/bin</directory>
            <outputDirectory>bin</outputDirectory>
            <fileMode>0755</fileMode>
            <includes>
                <include>**.sh</include>
                <include>**.bat</include>
            </includes>
        </fileSet>
        <!-- 指定输出target/classes/config中的配置文件到config目录中 -->
        <fileSet>
            <directory>${basedir}/target/classes/config</directory>
            <outputDirectory>config</outputDirectory>
            <fileMode>0644</fileMode>
        </fileSet>
        <!-- 将第三方依赖打包到lib目录中 -->
        <fileSet>
            <directory>${basedir}/target/lib</directory>
            <outputDirectory>lib</outputDirectory>
            <fileMode>0755</fileMode>
        </fileSet>
        <!-- 将项目启动jar打包到boot目录中 -->
        <fileSet>
            <directory>${basedir}/target</directory>
            <outputDirectory>boot</outputDirectory>
            <fileMode>0755</fileMode>
            <includes>
                <include>${project.build.finalName}.jar</include>
            </includes>
        </fileSet>
        <!-- 创建license空目录 -->
        <fileSet>
            <outputDirectory>license</outputDirectory>
            <excludes>
                <exclude>**/*</exclude>
            </excludes>
        </fileSet>
    </fileSets>
</assembly>

7 验证想法

通过按照上面的插件配置，最终打包会在 \target 目录下生成一个 *.tar.gz 的压缩文件，解压后其目录结构如下：

Bash
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
--根目录
    --boot
        --jar包
    --config
        --application.yml
        --application-dev.yml
        --logback-spring.xml
    --lib
        --依赖.jar
        ……
        --依赖.jar
    --license

至此，最终形态已经符合预期。