Resumo das formas comuns de empacotamento do maven do programa

Others 2021-03-28 23:08:24 views: null

índice

1. Introdução

Pacote 二 、 mvn

Três, plug-in maven-assembly-plugin

3.1 Uso básico

3.2 Comandos de empacotamento

Quatro, plugin maven-shadow-plugin

4.1 Configuração básica

4.2 Comandos de empacotamento

Cinco, outros requisitos de embalagem

1. Use Jar em um repositório não Maven

2. Exclua Jars que já existem no cluster

3. Empacote o arquivo Scala

Referência

1. Introdução

Ao enviar uma tarefa de big data para execução no cluster, geralmente você precisa primeiro empacotar o projeto em um pacote JAR. Tomando o Maven como exemplo, os métodos de empacotamento comuns são os seguintes:

  • Não adicione plug-ins, use diretamente o pacote mvn para empacotar;

  • Use o plug-in maven-assembly-plugin;

  • Use o plug-in maven-shadow-plugin;

  • Use os plug-ins maven-jar-plugin e maven-dependency-plugin;

Descrições detalhadas são fornecidas abaixo.

Pacote 二 、 mvn

POM não pluga nenhuma configuração, uso direto mvn packagepara itens de embalagem, não é possível para dependências externas do projeto. Mas se o projeto usar um pacote JAR de terceiros, haverá um problema, porque a mvn packageluta está no pacote JAR não contém as dependências, não levará a encontrar um trabalho anormal dependente de terceiros é executado. Este método é mais limitado, porque o projeto real geralmente é muito complicado e geralmente depende de um JAR de terceiros.

Os desenvolvedores de estrutura de Big Data também levam em consideração esse problema, portanto, toda a estrutura básica suporta o uso ao enviar um trabalho --jarsdesignado a dependências de terceiros, mas o problema com esta abordagem também é claro é que você deve manter o ambiente de produção e o ambiente de desenvolvimento. de todos os pacotes JAR são iguais, o que é um custo de manutenção.

Por esses motivos acima, o mais simples é o uso da All In Onemodalidade de empacotamento, todos dependem são empacotados em um arquivo JAR, então uma dependência mínima do ambiente. Para atingir esse objetivo, você pode usar o Maven fornecido maven-assembly-pluginou maven-shade-pluginplug-ins.

Três, plug-in maven-assembly-plugin

AssemblyO plug-in suporta o empacotamento de todas as dependências e arquivos do projeto no mesmo arquivo de saída. Os seguintes tipos de arquivo são atualmente suportados:

  • fecho eclair

  • alcatrão

  • tar.gz (ou tgz)

  • tar.bz2 (ou tbz2)

  • tar.snappy

  • tar.xz (ou txz)

  • jarra

  • para você

  • guerra

3.1 Uso básico

Apresente o plug-in em POM.xml, especifique o arquivo de configuração no formato do pacote assembly.xml(o nome pode ser personalizado) e especifique a classe de entrada principal da tarefa:

<build>
    <plugins>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptors>
                    <descriptor>src/main/resources/assembly.xml</descriptor>
                </descriptors>
                <archive>
                    <manifest>
                        <mainClass>com.heibaiying.wordcount.ClusterWordCountApp</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

O conteúdo do arquivo assembly.xml é o seguinte:

<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 
                              http://maven.apache.org/xsd/assembly-2.0.0.xsd">
    
    <id>jar-with-dependencies</id>
​
    <!--指明打包方式-->
    <formats>
        <format>jar</format>
    </formats>
​
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
        <dependencySet>
            <outputDirectory>/</outputDirectory>
            <useProjectArtifact>true</useProjectArtifact>
            <unpack>true</unpack>
            <scope>runtime</scope>
            <!--这里以排除 storm 环境中已经提供的 storm-core 为例，演示排除 Jar 包-->
            <excludes>
                <exclude>org.apache.storm:storm-core</exclude>
            </excludes>
        </dependencySet>
    </dependencySets>
</assembly>

3.2 Comandos de empacotamento

Os comandos para empacotar usando maven-assembly-plugin são os seguintes:

# mvn assembly:assembly

A geração simultânea de dois pacotes JAR após a embalagem, onde o sufixo jar-with-dependenciesé dependente do pacote JAR contendo um terceiro, o sufixo está assembly.xmlno <id>rótulo especificado pode ser modificações personalizadas.

 

Quatro, plugin maven-shadow-plugin

maven-shade-pluginDo que os maven-assembly-pluginrecursos mais poderosos, como seu projeto depende de muitos do pacote JAR, é JAR dependente JAR vai contar com outros pacotes, de modo que, quando o projeto é dependente de uma versão diferente de JAR, e o JAR com o mesmo nome Quando se trata de arquivos de recursos, o plug-in sombra tentará empacotar todos os arquivos de recursos juntos em vez de realizar a operação de substituição como montagem.

Normalmente maven-shade-plugincapaz de cumprir a maioria dos requisitos de embalagem, sua configuração é simples e a aplicabilidade das mais utilizadas, recomenda-se utilizar este modo prioritário.

4.1 Configuração básica

Usando maven-shade-pluginempacotado, quando um exemplo de configuração da seguinte forma:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <configuration>
        <createDependencyReducedPom>true</createDependencyReducedPom>
        <filters>
            <filter>
                <artifact>*:*</artifact>
                <excludes>
                    <exclude>META-INF/*.SF</exclude>
                    <exclude>META-INF/*.sf</exclude>
                    <exclude>META-INF/*.DSA</exclude>
                    <exclude>META-INF/*.dsa</exclude>
                    <exclude>META-INF/*.RSA</exclude>
                    <exclude>META-INF/*.rsa</exclude>
                    <exclude>META-INF/*.EC</exclude>
                    <exclude>META-INF/*.ec</exclude>
                    <exclude>META-INF/MSFTSIG.SF</exclude>
                    <exclude>META-INF/MSFTSIG.RSA</exclude>
                </excludes>
            </filter>
        </filters>
        <artifactSet>
            <excludes>
                <exclude>org.apache.storm:storm-core</exclude>
            </excludes>
        </artifactSet>
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                       implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                    <transformer
                       implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

A configuração acima vem do Storm Github. Na configuração acima, alguns arquivos são excluídos. Isso ocorre porque quando alguns pacotes JAR são gerados, o jarsigner será usado para gerar assinaturas de arquivo (verificação de integridade), que são divididos em dois arquivos e armazenados em META-INF sob o conteúdo:

  • um arquivo de assinatura, com uma extensão .SF ；

  • um arquivo de bloco de assinatura, com extensão .DSA, .RSA ou .EC。

Se houver referências repetidas a certos pacotes, o que pode resultar em um pacote Invalid signature file digest for Manifest main attributesanormal, exclua esses arquivos da configuração.

4.2 Comandos de empacotamento

Ao usar o plugin maven-shadow para empacotamento, os comandos de empacotamento são iguais aos de empacotamento comum:

# mvn package

Após o empacotamento, dois pacotes JAR serão gerados. Ao enviar para o cluster de servidor, use JARs que começam com não originais.

4.3 Como costumo embalar

<!--编译打包插件-->
<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin </artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifest>
                        <mainClass>需要填写和自己建的全类名一致</mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Cinco, outros requisitos de embalagem

1. Use Jar em um repositório não Maven

Normalmente, os dois pacotes acima podem satisfazer a maioria dos cenários de uso. Mas se você quiser que alguns não consigam invadir o pacote JAR do Maven JAR até o final, como você em resources/liboutro repositório não Maven introduzido no JAR, então você pode usar maven-jar-plugine maven-dependency-pluginplugá-lo no JAR final.

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                          <!--指定 resources/lib 目录-->
                        <classpathPrefix>lib/</classpathPrefix>
                          <!--应用的主入口类-->
                        <mainClass>com.heibaiying.BigDataApp</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy</id>
                    <phase>compile</phase>
                    <goals>
                         <!--将 resources/lib 目录所有 Jar 包打进最终的依赖中-->
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                         <!--将 resources/lib 目录所有 Jar 包一并拷贝到输出目录的 lib 目录下-->
                        <outputDirectory>
                            ${project.build.directory}/lib
                        </outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2. Exclua Jars que já existem no cluster

Geralmente, para evitar conflitos, os documentos oficiais irão sugerir que você exclua os pacotes JAR já fornecidos no cluster, da seguinte forma:

Capítulo de envio de inscrições do documento oficial do Spark:

Ao criar jars de montagem, liste Spark e Hadoop como provideddependências; eles não precisam ser empacotados, pois são fornecidos pelo gerenciador do cluster no tempo de execução.

Capítulo do documento oficial da Strom Executando Topologias em um Cluster de Produção:

Em seguida, execute mvn assembly: assembly para obter um frasco devidamente embalado. Certifique-se de excluir os jars do Storm, pois o cluster já tem o Storm no caminho de classe.

De acordo com a descrição acima, existem duas maneiras principais de excluir pacotes JAR:

  • A necessidade de excluir <scope>provided</scope>tags de adição de confiança , ponto em que o pacote JAR será excluído, mas não é recomendado usar dessa forma, porque então você não pode usar o pacote JAR rodando localmente;

  • Na proposta diretamente maven-assembly-pluginou maven-shade-pluginusando um arquivo de configuração <exclude>excluído.

3. Empacote o arquivo Scala

Se você usar a linguagem de programação Scala, desta vez precisa de atenção especial: Por padrão, o Maven não colocará scalao arquivo no JAR final, a necessidade de adicionar maven-scala-pluginplug-ins adicionais , a configuração comum é a seguinte:

<plugin>
    <groupId>org.scala-tools</groupId>
    <artifactId>maven-scala-plugin</artifactId>
    <version>2.15.1</version>
    <executions>
        <execution>
            <id>scala-compile</id>
            <goals>
                <goal>compile</goal>
            </goals>
            <configuration>
                <includes>
                    <include>**/*.scala</include>
                </includes>
            </configuration>
        </execution>
        <execution>
            <id>scala-test-compile</id>
            <goals>
                <goal>testCompile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Referência

Para a configuração detalhada de cada plug-in do Maven, você pode verificar seus documentos oficiais:

Para obter mais configurações do maven-shadow-plugin, consulte este blog: maven-shadow-plugin guia de primeiros passos

Acho que você gosta

Origin blog.csdn.net/godlovedaniel/article/details/108884731
Recomendado
Clasificación
Diario
Más
2024-05-27(0)
2024-05-26(0)
2024-05-25(0)
2024-05-24(11)
2024-05-23(35)
2024-05-22(9)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(32)

Code World

© 2018 codetd.com