Come leggere il mio file META-INF/MANIFEST.MF in un'app di Spring Boot?

Question

Sto provando a leggere il mio file META-INF/MANIFEST.MF dalla mia app Web Spring Boot (contenuta in un file jar).

sto cercando il seguente codice:

 InputStream is = getClass().getResourceAsStream("/META-INF/MANIFEST.MF"); 

     Properties prop = new Properties(); 
     prop.load(is); 

Ma a quanto pare c'è qualcosa dietro le quinte in primavera Boot che un manifest.mf diverso viene caricato (e non la mia si trova nella cartella META-INF) .

Qualcuno sa come posso leggere la mia app manifest nella mia app Spring Boot?

UPDATE: Dopo alcune ricerche ho notato che con il solito modo di leggere un file MANIFEST.MF, in un'applicazione di primavera di avvio questo è il vaso che si accede

org.springframework.boot.loader.jar.JarFile 

Answer 1

Praticamente tutto vaso i file vengono forniti con un file manifest, quindi il codice restituisce prima file può trovare nel classpath.

Perché dovresti comunque il manifest? È un file usato da Java. Inserisci qualsiasi valore personalizzato di cui hai bisogno da qualche altra parte, come in un file .properties accanto al tuo file .class.

Update 2

Come menzionato in un commento qui sotto, non nella questione, il vero obiettivo è le informazioni sulla versione del manifesto. Java fornisce già tali informazioni con la classe java.lang.Package.

Non provare a leggere il manifest da solo, anche se lo si potesse trovare. Aggiornamento

Si noti che il file manifesto è non un file Properties. La sua struttura è molto più complessa di quella.

Vedere l'esempio nella documentazione java dello JAR File Specification.

Manifest-Version: 1.0 
Created-By: 1.7.0 (Sun Microsystems Inc.) 

Name: common/class1.class 
SHA-256-Digest: (base64 representation of SHA-256 digest) 

Name: common/class2.class 
SHA1-Digest: (base64 representation of SHA1 digest) 
SHA-256-Digest: (base64 representation of SHA-256 digest) 

Come si può vedere, Name e SHA-256-Digest si verifica più di una volta. La classe Properties non può gestirlo, dal momento che è solo un Map e le chiavi devono essere uniche.

Answer 2

public Properties readManifest() throws IOException { 
    Object inputStream = this.getClass().getProtectionDomain().getCodeSource().getLocation().getContent(); 
    JarInputStream jarInputStream = new JarInputStream((InputStream) inputStream); 
    Manifest manifest = jarInputStream.getManifest(); 
    Attributes attributes = manifest.getMainAttributes(); 
    Properties properties = new Properties(); 
    properties.putAll(attributes); 
    return properties; 
} 

Answer 3

E 'semplice basta aggiungere questa

InputStream is = this.getClass().getClassLoader().getResourceAsStream("META-INF/MANIFEST.MF"); 

    Properties prop = new Properties(); 
    try { 
     prop.load(is); 
    } catch (IOException ex) { 
     Logger.getLogger(IndexController.class.getName()).log(Level.SEVERE, null, ex); 
    } 

Lavorare per me.

Nota:

getClass().getClassLoader() è importante

e

"META-INF/MANIFEST.MF" non "/META-INF/MANIFEST.MF"

Grazie Aleksandar

Answer 4

Dopo aver testato e cercato i documenti di Spring, ho trovato un modo per leggere il file manifest.

Prima di tutto, Spring Boot implementa il proprio ClassLoader che cambia il modo in cui vengono caricate le risorse. Quando chiami getResource(), Spring Boot caricherà la prima risorsa che corrisponde al nome di risorsa specificato nell'elenco di tutti i JAR disponibili nel percorso di classe e il tuo contenitore di applicazioni non è la prima scelta.

Così, quando l'emissione di un comando come:

getClassLoader().getResourceAsStream("/META-INF/MANIFEST.MF"); 

Il primo file MANIFEST.MF si trovano in qualunque vaso del percorso di classe viene restituito. Nel mio caso, proveniva da una libreria jar JDK.

SOLUZIONE:

sono riuscito a ottenere un elenco di tutti i Jars caricate dal app che contiene la risorsa "/META-INF/MANIFEST.MF" e controllato se la risorsa è venuto dal mio vaso di applicazione. Se è così, leggere il suo file MANIFEST.MF e tornare alla app, come quella:

private Manifest getManifest() { 
    // get the full name of the application manifest file 
    String appManifestFileName = this.getClass().getProtectionDomain().getCodeSource().getLocation().toString() + JarFile.MANIFEST_NAME; 

    Enumeration resEnum; 
    try { 
     // get a list of all manifest files found in the jars loaded by the app 
     resEnum = Thread.currentThread().getContextClassLoader().getResources(JarFile.MANIFEST_NAME); 
     while (resEnum.hasMoreElements()) { 
      try { 
       URL url = (URL)resEnum.nextElement(); 
       // is the app manifest file? 
       if (url.toString().equals(appManifestFileName)) { 
        // open the manifest 
        InputStream is = url.openStream(); 
        if (is != null) { 
         // read the manifest and return it to the application 
         Manifest manifest = new Manifest(is); 
         return manifest; 
        } 
       } 
      } 
      catch (Exception e) { 
       // Silently ignore wrong manifests on classpath? 
      } 
     } 
    } catch (IOException e1) { 
     // Silently ignore wrong manifests on classpath? 
    } 
    return null; 
} 

Questo metodo restituirà tutti i dati da un file MANIFEST.MF all'interno di un oggetto Manifest.

ho preso in prestito parte della soluzione da reading MANIFEST.MF file from jar file using JAVA

Answer 5

uso java.lang.Package di leggere l'attributo Implementation-Version in avvio molla dal manifesto.

String version = Application.class.getPackage().getImplementationVersion(); 

L'attributo Implementation-Version deve essere configurato in build.gradle

jar { 
    baseName = "my-app" 
    version = "0.0.1" 
    manifest { 
     attributes("Implementation-Version": version) 
    } 
} 

Answer 6

ce l'ho sfruttando risoluzione risorsa Primavera:

@Service 
public class ManifestService { 

    protected String ciBuild; 

    public String getCiBuild() { return ciBuild; } 

    @Value("${manifest.basename:/META-INF/MANIFEST.MF}") 
    protected void setManifestBasename(Resource resource) { 
     if (!resource.exists()) return; 
     try (final InputStream stream = resource.getInputStream()) { 
      final Manifest manifest = new Manifest(stream); 
      ciBuild = manifest.getMainAttributes().getValue("CI-Build"); 
     } 
     catch (IOException e) { 
      throw new RuntimeException(e); 
     } 
    } 

} 

Qui stiamo ottenendo CI-Build, e si può facilmente estendere la esempio per caricare altri attributi.