¿Es posible cambiar el nombre de un jar maven con dependencias?

Actualmente estoy usando el ensamblaje jar-with-dependencies para crear dicho jar. Sin embargo, el nombre de mi frasco es un poco largo.

Dado que este jar está siendo utilizado por programas RPG en un AS400, me gustaría acortarlo para hacer la vida un poco más fácil para esos desarrolladores. Pero, además de a mano, no he encontrado una manera de cambiar el nombre del frasco de la forma habitual project-name-version-classifier-jar-with-dependencies.jar. me gustaría algo como project-name-version-classifier-full.jar

¿Hay alguna forma de hacer esto sin copiar básicamente el descriptor de ensamblaje jar-with-dependencies y llamarlo completo?

Además, quiero seguir teniendo el jar sin el classpath ensamblado almacenado en el repositorio.

Necesito dos artefactos. El frasco con mi clasificador que contiene la región para la que es la compilación. El jar con todas las dependencias que también incluye la región.

project-name-version-region-full.jar y project-name-version-region.jar debe almacenarse en el repositorio. En el primer ejemplo, el clasificador está lleno de región, en el segundo es región. Este último está trabajando.

Puede especificar el nombrefinal propiedad para darle al jar el nombre que desee y especifique que appendAssemblyId debe ser falso para evitar el sufijo “jar-with-dependencies”.

La siguiente configuración generará un jar llamado “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>

Actualización: según sus comentarios, el uso del descriptor incorporado no funcionará. Creo que esto se debe a un error en las versiones recientes del complemento de ensamblaje: eliminaron la compatibilidad con los clasificadores, pero la identificación se corrige si usa un descriptor incorporado, por lo que termina con un gran nombre tonto.

Como solución temporal, puede copiar el descriptor de ensamblado utilizado por el jar-con-dependencias descriptor y modificar el id.

Este ejemplo daría como resultado que la identificación del ensamblado se agregue al finalName, por lo que si necesita tener un nombre de region-full.jarpuede especificar el nombre final como región y la identificación del ensamblado como completo. Esto dará como resultado un archivo en el destino llamado region-full.jar, pero tenga en cuenta que aún se instalará en el repositorio de Maven como un artefacto adjunto con completo utilizado como clasificador. Sin embargo, siempre que esta identificación sea diferente a la de su otro ensamblaje, no debería haber colisión.

La configuración del pom se vería así.

<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>

y el jar-assembly.xml en src/main/assembly así:

<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>

Creo que he encontrado una manera de configurar esto directamente en el pom sin necesidad de un jar-assembly.xml por separado.

Es básicamente lo mismo que la respuesta de Rich, excepto que el nombre final se especifica con el artefacto y la versión.

<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>

Gracias a las publicaciones aquí y algunas excavaciones en el documentos expertos Se me ocurrió la siguiente configuración para un conjunto de jar ejecutable reempaquetado único general con un nombre personalizado.

En 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>

En ensamblado.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>

esto producirá MyJarName.jar con todas sus dependencias empaquetadas en ese mismo jar y el especificado Main-Class: karlthepagain.MyMain.

También es posible sobrescribir el archivo jar original usando ${project.build.finalName} como nombre definitivo:

<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>

Voy a darle a Rich el crédito por indicarme la dirección correcta, pero quería publicar la solución que funcionó para mí, ya que la de Rich estaba ligeramente desviada:

Mi jar-assembly.xml se veía así, lo que permitía que la identificación del ensamblado cambiara para la región que estaba almacenada como una propiedad en mi 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>

No utilicé el parámetro finalName en la configuración de maven-assembly-plugin ya que esto creó mi proyecto con mi nombre de proyecto-versión-env-full.jar donde env-full era el clasificador.

Imagínese mi sorpresa cuando supe que el ensamblado xml podía parametrizarse mediante elementos en la compilación. Esto era exactamente lo que estaba buscando.

esto funcionó para mí

<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>