Comment déterminez-vous l'architecture 32 ou 64 bits de Windows en utilisant Java?

Je ne fais pas exactement confiance à la lecture du système d'exploitation.arche de la variable système. Alors que cela fonctionne si un utilisateur exécute une JVM 64 bits sur un système 64 bits. Il ne fonctionne pas si l'utilisateur exécute une JVM 32 bits sur un système 64 bits.

Le code suivant fonctionne pour détecter correctement les systèmes d'exploitation Windows 64 bits. Sur un système Windows 64 bits la variable d'environnement "Programfiles (x86)" sera défini. Il ne sera PAS défini sur un système 32 bits et java le lira comme null.

boolean is64bit = false;
if (System.getProperty("os.name").contains("Windows")) {
    is64bit = (System.getenv("ProgramFiles(x86)") != null);
} else {
    is64bit = (System.getProperty("os.arch").indexOf("64") != -1);
}

Pour d'autres opérations des systèmes comme Linux ou Solaris ou Mac, nous pouvons également voir ce problème. Donc ce n'est pas une solution complète. Pour Mac, vous êtes probablement en sécurité car Apple verrouille la JVM pour qu'elle corresponde au système d'exploitation. Mais Linux et Solaris, etc.. ils peuvent toujours utiliser une JVM 32 bits sur 64 bits. Alors utilisez ceci avec prudence.

J'ai utilisé l'invite de commande (command > > wmic OS get OSArchitecture) pour obtenir l'architecture du système d'exploitation. Le programme suivant permet d'obtenir tous les paramètres requis:

import java.io.*;

public class User {
    public static void main(String[] args) throws Exception {

        System.out.println("OS --> "+System.getProperty("os.name"));   //OS Name such as Windows/Linux

        System.out.println("JRE Architecture --> "+System.getProperty("sun.arch.data.model")+" bit.");       // JRE architecture i.e 64 bit or 32 bit JRE

        ProcessBuilder builder = new ProcessBuilder(
            "cmd.exe", "/c","wmic OS get OSArchitecture");
        builder.redirectErrorStream(true);
        Process p = builder.start();
        String result = getStringFromInputStream(p.getInputStream());

        if(result.contains("64"))
            System.out.println("OS Architecture --> is 64 bit");  //The OS Architecture
        else
            System.out.println("OS Architecture --> is 32 bit");

        }


    private static String getStringFromInputStream(InputStream is) {

        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();

        String line;
        try {

            br = new BufferedReader(new InputStreamReader(is));
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return sb.toString();

    }

}

Vous pouvez essayer ce code, je pense qu'il est préférable de détecter le modèle de JVM

boolean is64bit = System.getProperty("sun.arch.data.model").contains("64");

Peut-être que ce n'est pas la meilleure façon, mais ça marche.

Tout ce que je fais est d'obtenir la "Variable d'environnement" que Windows a configurée pour le dossier Program Files x86. Je veux dire que Windows x64 a le dossier (Program Files x86) et le x86 ne le fait pas. Parce qu'un utilisateur peut changer le chemin des Fichiers de programme dans Enviroment Variables, ou il peut créer un répertoire "Program Files (x86)" dans C:\, je n'utiliserai pas la détection du dossier mais le "Chemin d'environnement" de "Program Files (x86)" avec la variable dans Windows registre.

public class getSystemInfo {

    static void suckOsInfo(){

    // Get OS Name (Like: Windows 7, Windows 8, Windows XP, etc.)
    String osVersion = System.getProperty("os.name");
    System.out.print(osVersion);

    String pFilesX86 = System.getenv("ProgramFiles(X86)");
    if (pFilesX86 !=(null)){
        // Put here the code to execute when Windows x64 are Detected
    System.out.println(" 64bit");
    }
    else{
        // Put here the code to execute when Windows x32 are Detected
    System.out.println(" 32bit");
    }

    System.out.println("Now getSystemInfo class will EXIT");
    System.exit(0);

    }

}

(Uniquement pour Windows) Vérifiez si C:\Windows\SysWOW64 exister. si le répertoire existe, il s'agit d'un processus 64 bits. Sinon, il s'agit d'un processus 32 bits.

Avertissement: veuillez ne pas downvote ceci comme une réponse en double, car je voulais partager ma solution de code Java à cela (celui-ci est un code natif).

Je voudrais compléter la réponse de M. James Van Huis; Depuis la propriété os.Arch: System.getProperty("os.arch"); renvoie le bitness de JRE, cela peut en fait être très utile. Extrait de l'article:

Dans votre code, vous devez d'abord vérifier la taille de IntPtr, s'il renvoie 8, vous utilisez un système d'exploitation 64 bits. S'il renvoie 4, vous êtes exécution d'une application 32 bits, vous devez maintenant savoir si vous exécutez nativement ou sous WOW64.

Par conséquent, la vérification de la taille IntPtr est la même vérification que vous effectuez en regardant le "système d'exploitation.Arch". Après cela, vous pouvez déterminer si le processus s'exécute nativement ou sous WOW64.

Cela peut être fait en utilisant la bibliothèque jna(par exemple NativeLibrary) qui offre l'utilisation des fonctions natives dont vous avez besoin.

//test the JRE here by checking the os.arch property
//go into the try block if JRE is 32bit
try {
    NativeLibrary kernel32Library = NativeLibrary.getInstance("kernel32");
    Function isWow64Function = kernel32Library.getFunction("IsWow64Process");

    WinNT.HANDLE hProcess = Kernel32.INSTANCE.GetCurrentProcess();
    IntByReference isWow64 = new IntByReference(0);
    Boolean returnType = false;
    Object[] inArgs = {
        hProcess,
        isWow64
    };
    if ((Boolean) isWow64Function.invoke(returnType.getClass(), inArgs))    {
        if (isWow64.getValue() == 1)    {
                //32bit JRE on x64OS
        }
    }
} catch (UnsatisfiedLinkError e) {  //thrown by getFunction

}

Quelque chose comme ça pourrait aussi travail, mais je recommanderais la première version, car c'est celle que j'ai testée sur x64 et 32bit JRE sur x64 OS. En outre, cela devrait être le moyen le plus sûr, car dans ce qui suit, vous ne vérifiez pas réellement si la fonction "IsWow64Process" existe ou non.

Ici, j'ajoute un exemple de la vérification JRE, juste pour qu'elle soit complète, même si ce n'est pas difficile à trouver.

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

System.getProperty("os.arch");

Vous pouvez utiliser le système d'exploitation.propriété arch dans les propriétés du système pour le savoir.

Properties pr = System.getProperties();
System.out.println(pr.getProperty("os.arch"));

Si vous êtes sur 32 bits, il devrait montrer i386 ou quelque chose