Leggendo il mio Jar's Manifest

Devo leggere il Manifestfile, che ha consegnato la mia classe, ma quando uso:

getClass().getClassLoader().getResources(...)

Ottengo il MANIFESTprimo .jarcaricato in Java Runtime.
La mia app verrà eseguita da un'applet o da un webstart,
quindi credo che non avrò accesso al mio .jarfile.

In realtà voglio leggere l' Export-packageattributo da .jarcui è stato avviato Felix OSGi, quindi posso esporre quei pacchetti a Felix. Qualche idea?

Puoi fare una delle due cose:

1. Chiama getResources()e scorre la raccolta restituita di URL, leggendoli come manifest fino a quando non trovi il tuo:

   Enumeration<URL> resources = getClass().getClassLoader()
     .getResources("META-INF/MANIFEST.MF");
   while (resources.hasMoreElements()) {
       try {
         Manifest manifest = new Manifest(resources.nextElement().openStream());
         // check that this is your manifest and do what you need or get the next one
         ...
       } catch (IOException E) {
         // handle
       }
   }

2. Puoi provare a verificare se getClass().getClassLoader()è un'istanza di java.net.URLClassLoader. La maggior parte dei classloader Sun sono inclusi AppletClassLoader. Puoi quindi lanciarlo e chiamare ciò findResource()che è noto - almeno per le applet - per restituire direttamente il manifest necessario:

   URLClassLoader cl = (URLClassLoader) getClass().getClassLoader();
   try {
     URL url = cl.findResource("META-INF/MANIFEST.MF");
     Manifest manifest = new Manifest(url.openStream());
     // do stuff with it
     ...
   } catch (IOException E) {
     // handle
   }

Puoi prima trovare l'URL per la tua classe. Se è un JAR, allora carichi il manifest da lì. Per esempio,

Class clazz = MyClass.class;
String className = clazz.getSimpleName() + ".class";
String classPath = clazz.getResource(className).toString();
if (!classPath.startsWith("jar")) {
  // Class not from JAR
  return;
}
String manifestPath = classPath.substring(0, classPath.lastIndexOf("!") + 1) + 
    "/META-INF/MANIFEST.MF";
Manifest manifest = new Manifest(new URL(manifestPath).openStream());
Attributes attr = manifest.getMainAttributes();
String value = attr.getValue("Manifest-Version");

È possibile utilizzare Manifestsda jcabi-manifesta e leggere qualsiasi attributo da uno qualsiasi dei file MANIFEST.MF disponibili con una sola riga:

String value = Manifests.read("My-Attribute");

L'unica dipendenza di cui hai bisogno è:

<dependency>
  <groupId>com.jcabi</groupId>
  <artifactId>jcabi-manifests</artifactId>
  <version>0.7.5</version>
</dependency>

Inoltre, vedi questo post del blog per maggiori dettagli: http://www.yegor256.com/2014/07/03/how-to-read-manifest-mf.html

Devo ammettere in anticipo che questa risposta non risponde alla domanda originale, quella di poter generalmente accedere al Manifesto. Tuttavia, se ciò che è veramente necessario è leggere uno di una serie di attributi manifest "standard", la seguente soluzione è molto più semplice di quelle postate sopra. Quindi spero che il moderatore lo consenta. Nota che questa soluzione è in Kotlin, non in Java, ma mi aspetterei che una porta su Java sarebbe banale. (Anche se lo ammetto, non conosco l'equivalente Java di ".`package`".

Nel mio caso, volevo leggere l'attributo "Implementazione-Versione", quindi ho iniziato con le soluzioni sopra indicate per ottenere il flusso e quindi leggerlo per ottenere il valore. Mentre questa soluzione ha funzionato, un collega che ha esaminato il mio codice mi ha mostrato un modo più semplice per fare quello che volevo. Nota che questa soluzione è in Kotlin, non in Java.

val myPackage = MyApplication::class.java.`package`
val implementationVersion = myPackage.implementationVersion

Ancora una volta notare che questo non risponde alla domanda originale, in particolare "Pacchetto esportazione" non sembra essere uno degli attributi supportati. Detto questo, esiste un myPackage.name che restituisce un valore. Forse qualcuno che lo capisce più di quanto possa commentare se restituisce il valore richiesto dal poster originale.

Credo che il modo più appropriato per ottenere il manifest per qualsiasi bundle (incluso il bundle che ha caricato una determinata classe) sia utilizzare l'oggetto Bundle o BundleContext.

// If you have a BundleContext
Dictionary headers = bundleContext.getBundle().getHeaders();

// If you don't have a context, and are running in 4.2
Bundle bundle = FrameworkUtil.getBundle(this.getClass());
bundle.getHeaders();

Si noti che fornisce anche l'oggetto Bundle getEntry(String path) ricerca di risorse contenute in un bundle specifico, anziché la ricerca dell'intero percorso di classe di quel bundle.

In generale, se si desidera informazioni specifiche sul bundle, non fare affidamento su ipotesi sui programmi di caricamento classi, basta usare direttamente le API OSGi.

Il codice seguente funziona con più tipi di archivi (jar, war) e più tipi di classloader (jar, url, vfs, ...)

  public static Manifest getManifest(Class<?> clz) {
    String resource = "/" + clz.getName().replace(".", "/") + ".class";
    String fullPath = clz.getResource(resource).toString();
    String archivePath = fullPath.substring(0, fullPath.length() - resource.length());
    if (archivePath.endsWith("\\WEB-INF\\classes") || archivePath.endsWith("/WEB-INF/classes")) {
      archivePath = archivePath.substring(0, archivePath.length() - "/WEB-INF/classes".length()); // Required for wars
    }

    try (InputStream input = new URL(archivePath + "/META-INF/MANIFEST.MF").openStream()) {
      return new Manifest(input);
    } catch (Exception e) {
      throw new RuntimeException("Loading MANIFEST for class " + clz + " failed!", e);
    }
  }

Il modo più semplice è usare la classe JarURLConnection:

String className = getClass().getSimpleName() + ".class";
String classPath = getClass().getResource(className).toString();
if (!classPath.startsWith("jar")) {
    return DEFAULT_PROPERTY_VALUE;
}

URL url = new URL(classPath);
JarURLConnection jarConnection = (JarURLConnection) url.openConnection();
Manifest manifest = jarConnection.getManifest();
Attributes attributes = manifest.getMainAttributes();
return attributes.getValue(PROPERTY_NAME);

Perché in alcuni casi ...class.getProtectionDomain().getCodeSource().getLocation();dà il percorso con vfs:/, quindi questo dovrebbe essere gestito in aggiunta.

È possibile utilizzare getProtectionDomain (). GetCodeSource () in questo modo:

URL url = Menu.class.getProtectionDomain().getCodeSource().getLocation();
File file = DataUtilities.urlToFile(url);
JarFile jar = null;
try {
    jar = new JarFile(file);
    Manifest manifest = jar.getManifest();
    Attributes attributes = manifest.getMainAttributes();
    return attributes.getValue("Built-By");
} finally {
    jar.close();
}

Perché includi il passaggio getClassLoader? Se dici "this.getClass (). GetResource ()" dovresti ottenere risorse relative alla classe chiamante. Non ho mai usato ClassLoader.getResource (), anche se da una rapida occhiata a Java Docs sembra che questo ti porterà la prima risorsa con quel nome trovata in qualsiasi percorso di classe corrente.

  public static Manifest getManifest( Class<?> cl ) {
    InputStream inputStream = null;
    try {
      URLClassLoader classLoader = (URLClassLoader)cl.getClassLoader();
      String classFilePath = cl.getName().replace('.','/')+".class";
      URL classUrl = classLoader.getResource(classFilePath);
      if ( classUrl==null ) return null;
      String classUri = classUrl.toString();
      if ( !classUri.startsWith("jar:") ) return null;
      int separatorIndex = classUri.lastIndexOf('!');
      if ( separatorIndex<=0 ) return null;
      String manifestUri = classUri.substring(0,separatorIndex+2)+"META-INF/MANIFEST.MF";
      URL url = new URL(manifestUri);
      inputStream = url.openStream();
      return new Manifest( inputStream );
    } catch ( Throwable e ) {
      // handle errors
      ...
      return null;
    } finally {
      if ( inputStream!=null ) {
        try {
          inputStream.close();
        } catch ( Throwable e ) {
          // ignore
        }
      }
    }
  }

Ho usato la soluzione di Anthony Juckel ma in MANIFEST.MF la chiave deve iniziare con le maiuscole.

Quindi il mio file MANIFEST.MF contiene una chiave come:

Mykey: valore

Quindi nell'attivatore o in un'altra classe puoi usare il codice di Anthony per leggere il file MANIFEST.MF e il valore di cui hai bisogno.

// If you have a BundleContext 
Dictionary headers = bundleContext.getBundle().getHeaders();

// If you don't have a context, and are running in 4.2 
Bundle bundle = `FrameworkUtil.getBundle(this.getClass()); 
bundle.getHeaders();

Ho questa strana soluzione che esegue applicazioni di guerra in un server Jetty incorporato, ma queste app devono anche funzionare su server Tomcat standard e abbiamo alcune proprietà speciali nel modo più efficace.

Il problema era che quando in Tomcat, il manifest poteva essere letto, ma quando nel molo, veniva raccolto un manifest casuale (che mancava le proprietà speciali)

Sulla base della risposta di Alex Konshin, ho trovato la seguente soluzione (l'inputstream viene quindi utilizzato in una classe Manifest):

private static InputStream getWarManifestInputStreamFromClassJar(Class<?> cl ) {
    InputStream inputStream = null;
    try {
        URLClassLoader classLoader = (URLClassLoader)cl.getClassLoader();
        String classFilePath = cl.getName().replace('.','/')+".class";
        URL classUrl = classLoader.getResource(classFilePath);
        if ( classUrl==null ) return null;
        String classUri = classUrl.toString();
        if ( !classUri.startsWith("jar:") ) return null;
        int separatorIndex = classUri.lastIndexOf('!');
        if ( separatorIndex<=0 ) return null;
        String jarManifestUri = classUri.substring(0,separatorIndex+2);
        String containingWarManifestUri = jarManifestUri.substring(0,jarManifestUri.indexOf("WEB-INF")).replace("jar:file:/","file:///") + MANIFEST_FILE_PATH;
        URL url = new URL(containingWarManifestUri);
        inputStream = url.openStream();
        return inputStream;
    } catch ( Throwable e ) {
        // handle errors
        LOGGER.warn("No manifest file found in war file",e);
        return null;
    }
}