Obtenga la versión de artefactos de Maven en tiempo de ejecución

He notado que en el JAR de un artefacto Maven, el atributo project.version está incluido en dos archivos:

META-INF/maven/${groupId}/${artifactId}/pom.properties
META-INF/maven/${groupId}/${artifactId}/pom.xml

¿Hay alguna forma recomendada de leer esta versión en tiempo de ejecución?

No debería necesitar acceder a archivos específicos de Maven para obtener la información de versión de una biblioteca / clase determinada.

Simplemente puede usar getClass().getPackage().getImplementationVersion()para obtener la información de la versión que se almacena en un archivo .jar MANIFEST.MF. Afortunadamente, Maven es lo suficientemente inteligente ¡ Desafortunadamente, Maven no escribe la información correcta en el manifiesto también de forma predeterminada!

En cambio, uno tiene que modificar el <archive>elemento de configuración de maven-jar-pluginestablecer addDefaultImplementationEntriesy addDefaultSpecificationEntriespara true, de esta manera:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>                   
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
        </archive>
    </configuration>
</plugin>

Idealmente, esta configuración se debe poner en la empresa pomu otra base-pom.

La documentación detallada del <archive>elemento se puede encontrar en la documentación del Archivo Maven .

Para seguir la respuesta anterior, para un .warartefacto, descubrí que tenía que aplicar la configuración equivalente a maven-war-plugin, en lugar de maven-jar-plugin:

<plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1</version>
    <configuration>
        <archive>                   
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
        </archive>
    </configuration>
</plugin>

Esto agregó la información de la versión MANIFEST.MFen el proyecto .jar(incluido en WEB-INF/libel .war)

Aquí hay un método para obtener la versión de pom.properties, recurriendo a obtenerla del manifiesto

public synchronized String getVersion() {
    String version = null;

    // try to load from maven properties first
    try {
        Properties p = new Properties();
        InputStream is = getClass().getResourceAsStream("/META-INF/maven/com.my.group/my-artefact/pom.properties");
        if (is != null) {
            p.load(is);
            version = p.getProperty("version", "");
        }
    } catch (Exception e) {
        // ignore
    }

    // fallback to using Java API
    if (version == null) {
        Package aPackage = getClass().getPackage();
        if (aPackage != null) {
            version = aPackage.getImplementationVersion();
            if (version == null) {
                version = aPackage.getSpecificationVersion();
            }
        }
    }

    if (version == null) {
        // we could not compute the version so use a blank
        version = "";
    }

    return version;
} 

Pasé algún tiempo en los dos enfoques principales aquí y no funcionaron para mí. Estoy usando Netbeans para las compilaciones, puede que haya más cosas allí. Tuve algunos errores y advertencias de Maven 3 con algunas construcciones, pero creo que fueron fáciles de corregir. No es problema.

Encontré una respuesta que parece fácil de mantener y de implementar en este artículo en DZone:

• Sello de número de versión y tiempo de compilación en un archivo de propiedades con Maven

Ya tengo una subcarpeta recursos / config, y llamé a mi archivo: app.properties, para reflejar mejor el tipo de cosas que podemos guardar allí (como una URL de soporte, etc.).

La única advertencia es que Netbeans advierte que el IDE necesita filtrado. No estoy seguro de dónde / cómo. No tiene ningún efecto en este momento. Quizás haya una solución para eso si necesito cruzar ese puente. La mejor de las suertes.

Estoy usando maven-assembly-pluginpara mi empaque maven. El uso de Apache Maven Archiver en la respuesta de Joachim Sauer también podría funcionar:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution .../>
    </executions>
</plugin>

Debido a que archiever es uno de los componentes compartidos de maven , podría ser utilizado por múltiples complementos de construcción de maven, lo que también podría tener conflictos si se introducen dos o más complementos, incluida la archiveconfiguración interna.

Para que esto funcione en Eclipse, así como en una compilación de Maven, debe agregar las entradas addDefaultImplementationEntriesy addDefaultSpecificationEntriespom como se describe en otras respuestas, luego use el siguiente código:

public synchronized static final String getVersion() {
    // Try to get version number from pom.xml (available in Eclipse)
    try {
        String className = getClass().getName();
        String classfileName = "/" + className.replace('.', '/') + ".class";
        URL classfileResource = getClass().getResource(classfileName);
        if (classfileResource != null) {
            Path absolutePackagePath = Paths.get(classfileResource.toURI())
                    .getParent();
            int packagePathSegments = className.length()
                    - className.replace(".", "").length();
            // Remove package segments from path, plus two more levels
            // for "target/classes", which is the standard location for
            // classes in Eclipse.
            Path path = absolutePackagePath;
            for (int i = 0, segmentsToRemove = packagePathSegments + 2;
                    i < segmentsToRemove; i++) {
                path = path.getParent();
            }
            Path pom = path.resolve("pom.xml");
            try (InputStream is = Files.newInputStream(pom)) {
                Document doc = DocumentBuilderFactory.newInstance()
                        .newDocumentBuilder().parse(is);
                doc.getDocumentElement().normalize();
                String version = (String) XPathFactory.newInstance()
                        .newXPath().compile("/project/version")
                        .evaluate(doc, XPathConstants.STRING);
                if (version != null) {
                    version = version.trim();
                    if (!version.isEmpty()) {
                        return version;
                    }
                }
            }
        }
    } catch (Exception e) {
        // Ignore
    }

    // Try to get version number from maven properties in jar's META-INF
    try (InputStream is = getClass()
        .getResourceAsStream("/META-INF/maven/" + MAVEN_PACKAGE + "/"
                + MAVEN_ARTIFACT + "/pom.properties")) {
        if (is != null) {
            Properties p = new Properties();
            p.load(is);
            String version = p.getProperty("version", "").trim();
            if (!version.isEmpty()) {
                return version;
            }
        }
    } catch (Exception e) {
        // Ignore
    }

    // Fallback to using Java API to get version from MANIFEST.MF
    String version = null;
    Package pkg = getClass().getPackage();
    if (pkg != null) {
        version = pkg.getImplementationVersion();
        if (version == null) {
            version = pkg.getSpecificationVersion();
        }
    }
    version = version == null ? "" : version.trim();
    return version.isEmpty() ? "unknown" : version;
}

Si su compilación Java coloca clases de destino en otro lugar que no sea "target / classes", entonces es posible que deba ajustar el valor de segmentosToRemove.

En mi aplicación de arranque de primavera, la solución de la respuesta aceptada funcionó hasta que recientemente actualicé mi jdk a la versión 12. Intenté todas las otras respuestas también y no pude hacer que eso funcionara.

En ese momento, agregué la línea a continuación a la primera clase de mi aplicación de arranque de primavera, justo después de la anotación @SpringBootApplication

@PropertySources({ 
        @PropertySource("/META-INF/maven/com.my.group/my-artefact/pom.properties")
})

Más tarde, uso lo siguiente para obtener el valor del archivo de propiedades en la clase en la que quiero usar su valor y me appVersionda la versión del proyecto:

@Value("${version}")
private String appVersion;

Espero que ayude a alguien.

Una solución simple que es compatible con Maven y funciona para cualquier clase (por lo tanto, también de terceros):

    private static Optional<String> getVersionFromManifest(Class<?> clazz) {
        try {
            File file = new File(clazz.getProtectionDomain().getCodeSource().getLocation().toURI());
            if (file.isFile()) {
                JarFile jarFile = new JarFile(file);
                Manifest manifest = jarFile.getManifest();
                Attributes attributes = manifest.getMainAttributes();
                final String version = attributes.getValue("Bundle-Version");
                return Optional.of(version);
            }
        } catch (Exception e) {
            // ignore
        }
        return Optional.empty();
    }

Variante de Java 8 para EJB en archivo war con proyecto maven. Probado en EAP 7.0.

@Log4j // lombok annotation
@Startup
@Singleton
public class ApplicationLogic {

    public static final String DEVELOPMENT_APPLICATION_NAME = "application";

    public static final String DEVELOPMENT_GROUP_NAME = "com.group";

    private static final String POM_PROPERTIES_LOCATION = "/META-INF/maven/" + DEVELOPMENT_GROUP_NAME + "/" + DEVELOPMENT_APPLICATION_NAME + "/pom.properties";

    // In case no pom.properties file was generated or wrong location is configured, no pom.properties loading is done; otherwise VERSION will be assigned later
    public static String VERSION = "No pom.properties file present in folder " + POM_PROPERTIES_LOCATION;

    private static final String VERSION_ERROR = "Version could not be determinated";

    {    
        Optional.ofNullable(getClass().getResourceAsStream(POM_PROPERTIES_LOCATION)).ifPresent(p -> {

            Properties properties = new Properties();

            try {

                properties.load(p);

                VERSION = properties.getProperty("version", VERSION_ERROR);

            } catch (Exception e) {

                VERSION = VERSION_ERROR;

                log.fatal("Unexpected error occured during loading process of pom.properties file in META-INF folder!");
            }
        });
    }
}