É possível renomear um jar maven com dependências?

Atualmente, estou usando o assembly jar-with-dependencies para criar esse jar. No entanto, o nome do meu frasco é um pouco longo.

Como esse jar está sendo usado por programas de RPG em um AS400, eu gostaria de reduzi-lo para tornar a vida um pouco mais fácil para esses desenvolvedores. Mas, além da mão, não encontrei uma maneira de renomear o frasco do habitual project-name-version-classifier-jar-with-dependencies.jar. Eu gostaria de algo comoproject-name-version-classifier-full.jar

Existe alguma maneira de fazer isso sem basicamente copiar o descritor de assembly jar-with-dependencies e chamá-lo de completo?

Além disso, desejo continuar com o jar sem o caminho de classe montado armazenado no repositório.

Eu preciso de dois artefatos. A jarra com meu classificador segurando a região para a qual a compilação se destina. O jar com todas as dependências, que também inclui a região.

project-name-version-region-full.jare project-name-version-region.jardeve ser armazenado no repositório. No primeiro exemplo, o classificador é completo por região, no 2º é por região. O último está funcionando.

Você pode especificar a propriedade finalName para dar ao jar o nome desejado e especificar que appendAssemblyId deve ser false para evitar o sufixo "jar-with-dependencies".

A configuração abaixo produzirá um jar chamado "test.jar"

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.2-beta-4</version>
  <executions>
    <execution>
      <id>jar-with-dependencies</id>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <finalName>test</finalName>
        <appendAssemblyId>false</appendAssemblyId>
      </configuration>
    </execution>
  </executions>
</plugin>

Atualização: com base nos seus comentários, o uso do descritor interno não funcionará. Acredito que isso se deva a um bug nas versões recentes do assembly-plugin - eles removeram o suporte para classificadores, mas o id é corrigido se você usar um descritor interno, para que acabe com um grande nome estúpido.

Como solução alternativa, você pode copiar o descritor de assembly usado pelo descritor jar-with-dependencies e modificar o ID.

Este exemplo resultaria no acréscimo do ID do assembly ao finalName; portanto, se você precisar ter um nome de region-full.jar , poderá especificar o finalName como região e o ID do assembly como completo . Isso resultará em um arquivo no destino chamado region-full.jar, mas observe que ele ainda será instalado no repositório Maven como um artefato anexado, sendo full usado como classificador. Contanto que esse ID seja diferente daquele para sua outra montagem, não deve haver colisão.

A configuração do pom ficaria assim.

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.2-beta-4</version>
  <executions>
    <execution>
      <id>jar-with-dependencies</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptors>
          <descriptor>src/main/assembly/jar-assembly.xml</descriptor>
        </descriptors>
        <finalName>region</finalName>
      </configuration>
    </execution>
  </executions>
</plugin>

e o jar-assembly.xml em src / main / assembly, como este:

<assembly>
  <id>full</id>
  <formats>
    <format>jar</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <dependencySets>
    <dependencySet>
      <unpack>true</unpack>
      <scope>runtime</scope>
    </dependencySet>
  </dependencySets>
  <fileSets>
    <fileSet>
      <directory>${project.build.outputDirectory}</directory>
    </fileSet>
  </fileSets>
</assembly>

Acho que encontrei uma maneira de configurar isso diretamente no pom sem precisar de um jar-assembly.xml separado.

É basicamente o mesmo que a resposta de Rich, exceto que o finalName é especificado com o artifactId e a versão.

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <finalName>${project.artifactId}-${project.version}-full</finalName>
        <appendAssemblyId>false</appendAssemblyId>
        <archive>
            <manifest>
                <mainClass>com.mycompany.MyMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-my-jar-with-dependenciess</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Graças às postagens aqui e algumas pesquisas nos documentos escritos, criei a seguinte configuração para um conjunto de jar executável único e reembalado com um nome personalizado.

No pom.xml:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2</version>
    <executions>
        <execution>
            <id>exe</id>
            <phase>package</phase>
            <goals><goal>single</goal></goals>
            <configuration>
                <finalName>MyJarName</finalName>
                <attach>false</attach>
                <appendAssemblyId>false</appendAssemblyId>
                <descriptors>
                    <descriptor>assembly.xml</descriptor>
                </descriptors>
                <archive>
                    <manifest>
                        <mainClass>karlthepagain.MyMain</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </execution>
    </executions>
</plugin>

Em assembly.xml:

<assembly>
    <id>exe</id>
    <formats>
        <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
        <dependencySet>
            <outputDirectory>/</outputDirectory>
            <unpack>true</unpack>
            <scope>runtime</scope>
        </dependencySet>
    </dependencySets>
</assembly>

Isso produzirá MyJarName.jarcom todas as suas dependências empacotadas novamente no mesmo jar e no especificado Main-Class: karlthepagain.MyMain.

Vou dar a Rich o crédito por me apontar na direção certa, mas queria postar a solução que funcionou para mim, pois a Rich's estava um pouco desanimada:

Meu jar-assembly.xml era assim, permitindo que o ID do assembly fosse alterado para a região que foi armazenada como uma propriedade no meu perfil:

<assembly>
  <id>${env}-full</id>
    <formats>
      <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <dependencySets>
      <dependencySet>
        <unpack>true</unpack>
        <scope>runtime</scope>
      </dependencySet>
    </dependencySets>
    <fileSets>
      <fileSet>
        <directory>${project.build.outputDirectory}</directory>
      </fileSet>
    </fileSets>
</assembly>

Eu não usei o parâmetro finalName nas configurações do maven-assembly-plugin, pois isso construiu meu projeto com o meu nome-do-projeto-versão-env-full.jar nome em que env-full era o classificador.

Imagine minha surpresa quando soube que o XML da montagem poderia ser parametrizado por itens na compilação. Era exatamente isso que eu estava procurando.

Isso funcionou para mim

<build>
    <finalName>anynameyoulike</finalName>
    <plugins>           
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>                   
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>com.mycompany.MyMainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id> <!-- this is used for inheritance merges -->
                    <phase>package</phase> <!-- bind to the packaging phase -->
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Também é possível sobrescrever o arquivo jar original usando ${project.build.finalName}como nome final:

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
   <executions>
      <execution>
          <phase>package</phase>
          <goals>
             <goal>single</goal>
          </goals>
      </execution>
   </executions>
   <configuration>
     <descriptorRefs>
       <descriptorRef>jar-with-dependencies</descriptorRef>
     </descriptorRefs>
     <finalName>${project.build.finalName}</finalName>
     <appendAssemblyId>false</appendAssemblyId>
   </configuration>
 </plugin>