¿Es posible cambiar el nombre de un maven jar-with-dependencies?

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

Dado que este tarro está siendo utilizado por programas RPG en un AS400, me gustaría acortarlo para facilitarles la vida a esos desarrolladores. Pero, aparte de a mano, no he encontrado una manera de cambiar el nombre del tarro de la forma habitual project-name-version-classifier-jar-with-dependencies.jar. Me gustaría algo comoproject-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.jary project-name-version-region.jardebe almacenarse en el repositorio. En el primer ejemplo, el clasificador está lleno de regiones, en el segundo es región. Este último está funcionando.

Puede especificar la propiedad finalName para darle al jar el nombre que desea y especificar 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 tus comentarios, usar el descriptor incorporado no funcionará. Creo que esto se debe a un error en las versiones recientes del complemento de ensamblaje: han eliminado 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 alternativa, puede copiar el descriptor de ensamblaje utilizado por el descriptor jar-with-dependencies y modificar la identificación.

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

La configuración de 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 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>

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

Básicamente es lo mismo que la respuesta de Rich, excepto que finalName se especifica con el artifactId 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 los documentos de Maven, se me ocurrió la siguiente configuración para un ensamblaje de jar ejecutable reempaquetado 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 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>

Esto producirá MyJarName.jarcon todas sus dependencias re-empaquetadas en el mismo jar y el especificado Main-Class: karlthepagain.MyMain.

Voy a dar crédito a Rich por señalarme en la dirección correcta, pero quería publicar la solución que funcionó para mí, ya que Rich estaba un poco fuera de lugar:

Mi jar-assembly.xml se parecía a esto, lo que permitió que la identificación del ensamblaje 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 plugin de ensamblaje de maven ya que esto construyó mi proyecto con mi nombre de proyecto-versión-env-full.jar donde env-full era el clasificador.

Imagine mi sorpresa cuando supe que el ensamblado xml podía ser parametrizado por elementos en la compilación. Esto era exactamente lo que estaba buscando.

Esto funciono para mi

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

También es posible sobrescribir el archivo jar original utilizando ${project.build.finalName}como nombre 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>