Utilice Maven para generar varios paquetes jar para un proyecto

Tabla de contenido

Implementación del complemento Maven-assembly-plugin

Digresión en la etiqueta de propiedades (variables integradas de maven)

Prefacio

A veces necesitamos ejecutar comandos de empaquetado en un proyecto java para generar múltiples paquetes jar, y el contenido específico de cada paquete jar está vinculado a una clase de implementación específica, que tiene la ventaja de la conveniencia. Por ejemplo, nuestro proyecto proporciona extensiones de complemento externas, los usuarios de terceros solo necesitan implementar nuestra interfaz de complemento y luego cargarlo en un paquete jar y cargarlo en nuestro proyecto para un análisis dinámico, y las necesidades del usuario pueden ser en un proyecto Edite varios complementos comerciales al mismo tiempo y, finalmente, genere varios paquetes jar diferentes para diferentes propósitos. Por lo tanto, como parte del producto, deben proporcionar una demostración para que puedan usarlos directamente.

lograr

Implementación de varios módulos

Esto debe entenderse bien. Se puede implementar en una forma de múltiples módulos. Cada módulo es equivalente a un complemento. Cuando se completa el empaquetado final, directamente el paquete mvn puede generar sus respectivos paquetes jar en los directorios de destino de diferentes módulos La implementación es simple, pero a nivel Hay una relación padre-hijo, pero en realidad no existe, por lo que no es buena.

Implementación del complemento Maven-assembly-plugin

Utilice el complemento para cooperar con el archivo de descripción para lograr la estructura general del proyecto como se muestra en la siguiente figura:

El archivo pom es el siguiente:

<?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>qingcha.test</groupId>
    <artifactId>multiPluginDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 引入插件目标接口以及相关依赖 -->
        <dependency>
            <artifactId>hornet-web-api</artifactId>
            <groupId>uyun.hornet</groupId>
            <version>2.0.0-SNAPSHOT</version>
            <!-- 表示已提供依赖范围，由于是作为插件jar包运行在主项目中，而主项目中存在该依赖，因此实际运行的时候并不需要maven重复引入一遍，
             因此该依赖范围表示只在测试和编译classpath时有效，在运行时无效，换句话说就是该依赖不会被打进包中-->
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <!-- 在properties标签中定义的值可以通过使用${key}在pom的任何位置访问，其中key为属性值 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <project.assembly.directory>src/main/resources/assembly</project.assembly.directory>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>

                 <configuration>
                    <!--该方式会将所有依赖打包到jar，生成的jar包带有jar-with-dependencies后缀 -->
                    <descriptorRefs>
                        <!-- 将依赖一起打包到 JAR -->
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>

                    <!-- 该标签可以配置主main类，即 使该jar包成为可执行jar包，可在META-INF下的MF文件中找到Main-class一行 -->
                    <archive>
                        <manifest>
                            <mainClass></mainClass>
                        </manifest>
                    </archive>
                </configuration>

                <!-- 配置执行器，若还想增加编写新的插件，在此处新增执行器即可 -->
                <executions>
                    <execution>
                        <!-- 执行器id -->
                        <id>plugin1</id>
                        <!-- 绑定到maven的package生命周期 -->
                        <phase>package</phase>
                        <goals>
                            <!-- 代表只运行一次 -->
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptors>
                                <!-- 描述文件的地址 -->
                                <descriptor>${project.assembly.directory}/assembly-plugin1.xml</descriptor>
                            </descriptors>
                            <!-- 自定义包名，如果不配置则是 artifactId + version + assemblyId，配置后则为 finalName + assemblyId，当然也可以增加属性去除自动拼接assemblyId值 -->
                            <finalName>multiPluginDemo</finalName>
                        </configuration>
                    </execution>

                    <execution>
                        <id>plugin2</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptors>
                                <descriptor>${project.assembly.directory}/assembly-plugin2.xml</descriptor>
                            </descriptors>
                            <finalName>multiPluginDemo</finalName>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

El archivo assembly-plugin1.xml de uno de los scripts de empaquetado es el siguiente:

<assembly
        xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">

    <!-- 文件id，与前面保持一致即可 -->
    <id>plugin1</id>
    <!-- 是否生成和压缩包同名的项目和目录 -->
    <includeBaseDirectory>false</includeBaseDirectory>
    <formats>
        <!-- 指定格式 -->
        <format>jar</format>
    </formats>

    <fileSets>
        <fileSet>
            <!-- 文件所在项目中的位置 -->
            <directory>${project.build.outputDirectory}/qingcha/test/common</directory>
            <!-- 打包后的展示路径，必须与包路径保持一致 -->
            <outputDirectory>qingcha/test/common</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>${project.build.outputDirectory}/qingcha/test/plugin1</directory>
            <outputDirectory>qingcha/test/plugin1</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>src/main/resources/plugin1</directory>
            <!-- 由于依赖spi机制，因此这里的输出路径需要满足条件，否则插件便不生效了 -->
            <outputDirectory>META-INF/services</outputDirectory>
        </fileSet>
    </fileSets>
</assembly>

Finalmente, puede usar directamente mvn package to package, puede ver el paquete jar final en el directorio target /, varios complementos tendrán varios paquetes jar:

Si desea agregar un complemento, puede agregar la clase de implementación correspondiente, el archivo de configuración del proveedor, el archivo de descripción del script y el ejecutor a su vez

Digresión en la etiqueta de propiedades (variables integradas de maven)

En el archivo de descripción de la secuencia de comandos anterior, se usa $ {project.build.outputDirectory}, y luego, mirando el archivo pom, encontramos que no definimos el valor de la clave, por lo que también podemos adivinar que esta es una variable incorporada de maven. Las variables integradas más utilizadas son las siguientes:

$ {project.basedir}: se refiere a la carpeta raíz del módulo / proyecto (donde se encuentra el archivo pom.xml actual), y también se puede simplificar: $ {basedir}
$ {project.build.directory}: representa la carpeta de destino predeterminada.
$ {project.build.outputDirectory}: representa la carpeta de destino / clases de forma predeterminada.
$ {project.build.testOutputDirectory}: Esto representa la carpeta predeterminada de clases de prueba / destino.
$ {project.build.sourceDirectory}: esto significa la carpeta src / main / java por defecto.
$ {project.build.testSourceDirectory}: esto significa la carpeta src / test / java por defecto.
$ {project.build.finalName}: definido como $ {project.artifactId} - $ {project.version} de forma predeterminada.
$ {project.version}: esto se puede usar donde se debe escribir una versión de texto, de lo contrario, especialmente si está construyendo dependencias entre múltiples módulos.
$ {settings.localRepository}: se refiere a la ubicación del repositorio local. Este es el repositorio predeterminado $ {home} /. M2 /.