Alle möglichen Werte os.arch in 32bit JRE und in 64bit Jre

Question

Ich benötige die neueste Kompilierung aller möglichen Werte der os.arch-Eigenschaft in JRE 1.6 unter Linux, Solaris und Windows. Wenn möglich, bitte zitieren Sie die Quelle Ihrer Ergebnisse. Ich brauche diese Werte, um Ressourcen in meiner JNLP-Datei auszuwählen. Grundsätzlich muss ich unterschiedliche JVM-Speicher basierend darauf zuweisen, ob die JRE 32 Bit oder 64 Bit ist. Warten auf Ihre Antwort. Danke

Answer 1

Sie können auch etwas Code wie unten schreiben, um herauszufinden, os und seine archi.

import java.util.HashMap; 
import java.util.Map; 

import org.apache.commons.lang.SystemUtils; 


public class PlatformDetection { 
    private String os; 
    private String arch; 
    public static String OS_WINDOWS = "windows"; 
    public static String OS_OSX = "osx"; 
    public static String OS_SOLARIS = "solaris"; 
    public static String OS_LINUX = "linux"; 
    public static String ARCH_PPC = "ppc"; 
    public static String ARCH_X86_32 = "x86_32"; 
    public static String ARCH_X86_64 = "x86_64"; 

    public PlatformDetection() { 
     // resolve OS 
     if (SystemUtils.IS_OS_WINDOWS) { 
      this.os = OS_WINDOWS; 
     } else if (SystemUtils.IS_OS_MAC_OSX) { 
      this.os = OS_OSX; 
     } else if (SystemUtils.IS_OS_SOLARIS) { 
      this.os = OS_SOLARIS; 
     } else if (SystemUtils.IS_OS_LINUX) { 
      this.os = OS_LINUX; 
     } else { 
      throw new IllegalArgumentException("Unknown operating system " + SystemUtils.OS_NAME); 
     } 

     // resolve architecture 
     Map<String, String> archMap = new HashMap<String, String>(); 
     archMap.put("x86", ARCH_X86_32); 
     archMap.put("i386", ARCH_X86_32); 
     archMap.put("i486", ARCH_X86_32); 
     archMap.put("i586", ARCH_X86_32); 
     archMap.put("i686", ARCH_X86_32); 
     archMap.put("x86_64", ARCH_X86_64); 
     archMap.put("amd64", ARCH_X86_64); 
     archMap.put("powerpc", ARCH_PPC); 
     this.arch = archMap.get(SystemUtils.OS_ARCH); 
     if (this.arch == null) { 
      throw new IllegalArgumentException("Unknown architecture " + SystemUtils.OS_ARCH); 
     } 
    } 

    public String getOs() { 
     return os; 
    } 

    public String getArch() { 
     return arch; 
    } 

    public void setArch(String arch) { 
     this.arch = arch; 
    } 

    public void setOs(String os) { 
     this.os = os; 
    } 

    public String toString() { 

     return os + "_" + arch; 
    } 
} 

Siehe Links unten,

1. https://github.com/trustin/os-maven-plugin/blob/master/src/main/java/kr/motd/maven/os/Detector.java

2. https://github.com/rachelxqy/EligibilityCriteriaModeling/blob/57001f6d86084f074f4ca6aaff157e93ef6abf95/src/main/java/edu/mayo/bmi/medtagger/ml/util/PlatformDetection.java

Answer 2

Der beste Ort, wo man für diese aussehen können, ist es in der eigenen jdk.

Blick auf java.lang.System können Sie sehen, dass die Eigenschaften in initializeSystemClass Methode initProperties Methode initialisiert werden, die unter Verwendung von JNI auf nativen Code beruht:

private static native Properties initProperties(Properties props); 

/** 
* Initialize the system class. Called after thread initialization. 
*/ 
private static void initializeSystemClass() { 

    // VM might invoke JNU_NewStringPlatform() to set those encoding 
    // sensitive properties (user.home, user.name, boot.class.path, etc.) 
    // during "props" initialization, in which it may need access, via 
    // System.getProperty(), to the related system encoding property that 
    // have been initialized (put into "props") at early stage of the 
    // initialization. So make sure the "props" is available at the 
    // very beginning of the initialization and all system properties to 
    // be put into it directly. 
    props = new Properties(); 
    initProperties(props); // initialized by the VM 
    ... 
    ... 
} 

Wenn Sie die Quelle dieses nativen Code von initProperties für die angerufene überprüfen verschiedene Plattformen können Sie die möglichen Werte für os.arch Systemeigenschaft sehen. So tun es Schritt für Schritt:

Zuerst Blick auf System.c, um die JNI Methode von java.lang.System.initProperties genannt zu sehen. So Von System.c

JNIEXPORT jobject JNICALL 
Java_java_lang_System_initProperties(JNIEnv *env, jclass cla, jobject props) 
{ 
    char buf[128]; 
    java_props_t *sprops = GetJavaProperties(env); 
    jmethodID putID = (*env)->GetMethodID(env, 
              (*env)->GetObjectClass(env, props), 
              "put", 
      "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); 

    if (sprops == NULL || putID == NULL) return NULL; 

    PUTPROP(props, "java.specification.version", 
      JDK_MAJOR_VERSION "." JDK_MINOR_VERSION); 
    PUTPROP(props, "java.specification.name", 
      "Java Platform API Specification"); 
    PUTPROP(props, "java.specification.vendor", "Sun Microsystems Inc."); 

    PUTPROP(props, "java.version", RELEASE); 
    PUTPROP(props, "java.vendor", VENDOR); 
    PUTPROP(props, "java.vendor.url", VENDOR_URL); 
    PUTPROP(props, "java.vendor.url.bug", VENDOR_URL_BUG); 

    ... 

    /* os properties */ 
    PUTPROP(props, "os.name", sprops->os_name); 
    PUTPROP(props, "os.version", sprops->os_version); 

    // HERE IS THE `os.arch` PROPERTY :) 

    PUTPROP(props, "os.arch", sprops->os_arch); 

wie Sie sehen können die os.arch kommt von PUTPROP(props, "os.arch", sprops->os_arch); und die sprops erreicht ist mit java_props_t *sprops = GetJavaProperties(env);. so kann bei GetJavaProperties(env), diese Methode sieht es in java_props.h definiert ist:

java_props_t *GetJavaProperties(JNIEnv *env);

Und die Umsetzung scheint, dass auf O abhängt.

So schließlich eine spezifische Implementierung für GetJavaProperties; in Windows die möglichen Werte, die diese Eigenschaft annehmen kann, sind ia64, amd64, x86 oder unknown.Sie können von java_props_md.c file sehen:

#if _M_IA64 
     sprops.os_arch = "ia64"; 
#elif _M_AMD64 
     sprops.os_arch = "amd64"; 
#elif _X86_ 
     sprops.os_arch = "x86"; 
#else 
     sprops.os_arch = "unknown"; 
#endif 

Für Solaris komplizierter scheint, da der Wert der Eigenschaft in den nativen Code aus einem in der java_props_md.c spezifisch für solaris definiert Macro kommt:

sprops.os_arch = ARCHPROPNAME; 

Und dieses Makro ist es definiert in der Folge Makefile wie:

OTHER_CPPFLAGS += -DARCHPROPNAME='"$(ARCHPROP)"'

so sieht es aus So kommt es aus der Umgebung, wo es kompiliert wurde (Entschuldigung, ich bin kein C-Experte, ich rate nur, aber vielleicht kann ich dich ein bisschen führen).

In dem Linux-Ordner in src/linux/native/ gibt es keine java_props_md.c also nehme ich an, dass in diesem Fall die gleiche Quelle wie Solaris nehmen (ich rate wieder ...).

HINWEIS: Ich verwende die Version 1.6, um diese Werte zu erhalten, aber neue Werte können in den neuesten Java-Versionen hinzugefügt werden, überprüfen Sie daher Ihre benötigte Version.

Hoffe, dass es hilft,