it-swarm.com.de

Wie bestimme ich programmgesteuert das Betriebssystem in Java?

Ich möchte das Betriebssystem des Hosts bestimmen, auf dem mein Programm Java programmgesteuert ausgeführt wird (Beispiel: Ich möchte verschiedene Eigenschaften laden können, je nachdem, ob ich mich auf einer Windows- oder einer Unix-Plattform befinde). . Was ist der sicherste Weg, dies mit 100% iger Zuverlässigkeit zu tun?

475
karlgrz

Sie können verwenden:

System.getProperty("os.name")

P.S. Möglicherweise finden Sie diesen Code nützlich:

class ShowProperties {
    public static void main(String[] args) {
        System.getProperties().list(System.out);
    }
}

Es werden lediglich alle Eigenschaften ausgedruckt, die von Ihren Java -Implementierungen bereitgestellt werden. Sie erhalten eine Vorstellung davon, was Sie über Eigenschaften über Ihre Java -Umgebung herausfinden können. :-)

577

Wie in anderen Antworten angegeben, stellt System.getProperty die Rohdaten bereit. Die Komponente Apache Commons Lang bietet jedoch einen Wrapper für Java.lang.System mit praktischen Eigenschaften wie SystemUtils.IS_OS_WINDOWS , ähnlich wie die vorgenannten Swingx OS util.

136
Leif Carlsen

Okt. 2008:

Ich würde empfehlen, es in einer statischen Variablen zwischenzuspeichern:

public static final class OsUtils
{
   private static String OS = null;
   public static String getOsName()
   {
      if(OS == null) { OS = System.getProperty("os.name"); }
      return OS;
   }
   public static boolean isWindows()
   {
      return getOsName().startsWith("Windows");
   }

   public static boolean isUnix() // and so on
}

Auf diese Weise rufen Sie die Eigenschaft jedes Mal, wenn Sie nach dem Betriebssystem fragen, mehr als einmal in der Lebensdauer Ihrer Anwendung ab.


Februar 2016: 7+ Jahre später:

Es gibt einen Fehler in Windows 10 (der zum Zeitpunkt der ursprünglichen Antwort noch nicht vorhanden war).
Siehe " Javas" os.name "für Windows 10? "

76
VonC

einige der Links in den Antworten oben scheinen defekt zu sein. Im folgenden Code habe ich dem aktuellen Quellcode Zeiger hinzugefügt und einen Ansatz zum Behandeln des Schecks mit einer Aufzählung als Antwort angegeben, damit bei der Auswertung des Ergebnisses eine switch-Anweisung verwendet werden kann:

OsCheck.OSType ostype=OsCheck.getOperatingSystemType();
switch (ostype) {
    case Windows: break;
    case MacOS: break;
    case Linux: break;
    case Other: break;
}

Die Helferklasse ist:

/**
 * helper class to check the operating system this Java VM runs in
 *
 * please keep the notes below as a pseudo-license
 *
 * http://stackoverflow.com/questions/228477/how-do-i-programmatically-determine-operating-system-in-Java
 * compare to http://svn.terracotta.org/svn/tc/dso/tags/2.6.4/code/base/common/src/com/tc/util/runtime/Os.Java
 * http://www.docjar.com/html/api/org/Apache/commons/lang/SystemUtils.Java.html
 */
import Java.util.Locale;
public static final class OsCheck {
  /**
   * types of Operating Systems
   */
  public enum OSType {
    Windows, MacOS, Linux, Other
  };

  // cached result of OS detection
  protected static OSType detectedOS;

  /**
   * detect the operating system from the os.name System property and cache
   * the result
   * 
   * @returns - the operating system detected
   */
  public static OSType getOperatingSystemType() {
    if (detectedOS == null) {
      String OS = System.getProperty("os.name", "generic").toLowerCase(Locale.ENGLISH);
      if ((OS.indexOf("mac") >= 0) || (OS.indexOf("darwin") >= 0)) {
        detectedOS = OSType.MacOS;
      } else if (OS.indexOf("win") >= 0) {
        detectedOS = OSType.Windows;
      } else if (OS.indexOf("nux") >= 0) {
        detectedOS = OSType.Linux;
      } else {
        detectedOS = OSType.Other;
      }
    }
    return detectedOS;
  }
}
37
Wolfgang Fahl

Die folgenden JavaFX-Klassen verfügen über statische Methoden zur Ermittlung des aktuellen Betriebssystems (isWindows (), isLinux () ...):

  • com.Sun.javafx.PlatformUtil
  • com.Sun.media.jfxmediaimpl.HostUtils
  • com.Sun.javafx.util.Utils

Beispiel:

if (PlatformUtil.isWindows()){
           ...
}
36
Igor Rybak
    private static String OS = System.getProperty("os.name").toLowerCase();

    public static void detectOS() {
        if (isWindows()) {

        } else if (isMac()) {

        } else if (isUnix()) {

        } else {

        }
    }

    private static boolean isWindows() {
        return (OS.indexOf("win") >= 0);
    }

    private static boolean isMac() {
        return (OS.indexOf("mac") >= 0);
    }

    private static boolean isUnix() {
        return (OS.indexOf("nux") >= 0);
    }
12
Nikesh Jauhari

Ja, die kurze Antwort lautet System.getProperty("os.name"). Aber warum nicht eine Utility-Klasse erstellen, wiederverwendbar machen! Und wahrscheinlich viel schneller bei mehreren Anrufen. Sauber, klar, schneller!

Erstellen Sie eine Util-Klasse für solche Dienstprogrammfunktionen. Erstellen Sie dann öffentliche Enums für jeden Betriebssystemtyp.

public class Util {     
        public enum OS {
            WINDOWS, LINUX, MAC, SOLARIS
        };// Operating systems.

    private static OS os = null;

    public static OS getOS() {
        if (os == null) {
            String operSys = System.getProperty("os.name").toLowerCase();
            if (operSys.contains("win")) {
                os = OS.WINDOWS;
            } else if (operSys.contains("nix") || operSys.contains("nux")
                    || operSys.contains("aix")) {
                os = OS.LINUX;
            } else if (operSys.contains("mac")) {
                os = OS.MAC;
            } else if (operSys.contains("sunos")) {
                os = OS.SOLARIS;
            }
        }
        return os;
    }
}

Jetzt können Sie einfach eine Klasse aus einer beliebigen Klasse aufrufen, wie folgt: (S. Da wir die Variable os als statisch deklariert haben, benötigt sie nur einmal Zeit, um den Systemtyp zu identifizieren. Dann kann sie verwendet werden, bis Ihre Anwendung anhält.)

            switch (Util.getOS()) {
            case WINDOWS:
                //do windows stuff
                break;
            case LINUX:

und das ist alles!

12
Memin

Wenn Sie daran interessiert sind, wie ein Open-Source-Projekt so etwas macht, können Sie sich die Terracotta-Klasse (Os.Java) ansehen, die diesen Müll behandelt:

Eine ähnliche Klasse für JVM-Versionen (Vm.Java und VmVersion.Java) finden Sie hier:

10
Alex Miller

Aus diesem Projekt entnommen https://github.com/RishiGupta12/serial-communication-manager

String osName = System.getProperty("os.name");
String osNameMatch = osName.toLowerCase();
if(osNameMatch.contains("linux")) {
    osType = OS_LINUX;
}else if(osNameMatch.contains("windows")) {
    osType = OS_WINDOWS;
}else if(osNameMatch.contains("solaris") || osNameMatch.contains("sunos")) {
    osType = OS_SOLARIS;
}else if(osNameMatch.contains("mac os") || osNameMatch.contains("macos") || osNameMatch.contains("darwin")) {
    osType = OS_MAC_OS_X;
}else {
}
9
john miller

Versuchen Sie dies einfach und leicht

System.getProperty("os.name");
System.getProperty("os.version");
System.getProperty("os.Arch");
8
Kamidu

Der folgende Code zeigt die Werte, die Sie von der System-API erhalten können. Dies sind alles Dinge, die Sie über diese API erhalten können.

public class App {
    public static void main( String[] args ) {
        //Operating system name
        System.out.println(System.getProperty("os.name"));

        //Operating system version
        System.out.println(System.getProperty("os.version"));

        //Path separator character used in Java.class.path
        System.out.println(System.getProperty("path.separator"));

        //User working directory
        System.out.println(System.getProperty("user.dir"));

        //User home directory
        System.out.println(System.getProperty("user.home"));

        //User account name
        System.out.println(System.getProperty("user.name"));

        //Operating system architecture
        System.out.println(System.getProperty("os.Arch"));

        //Sequence used by operating system to separate lines in text files
        System.out.println(System.getProperty("line.separator"));

        System.out.println(System.getProperty("Java.version")); //JRE version number

        System.out.println(System.getProperty("Java.vendor.url")); //JRE vendor URL

        System.out.println(System.getProperty("Java.vendor")); //JRE vendor name

        System.out.println(System.getProperty("Java.home")); //Installation directory for Java Runtime Environment (JRE)

        System.out.println(System.getProperty("Java.class.path"));

        System.out.println(System.getProperty("file.separator"));
    }
}

Antworten: -

Windows 7
6.1
;
C:\Users\user\Documents\workspace-Eclipse\JavaExample
C:\Users\user
user
AMD64


1.7.0_71
http://Java.Oracle.com/
Oracle Corporation
C:\Program Files\Java\jre7
C:\Users\user\Documents\workspace-Eclipse\JavaExample\target\classes
\
7
PAA

Ich finde, dass das OS Utils von Swingx den Job macht.

7

Ich denke, das Folgen kann eine breitere Abdeckung in weniger Zeilen ergeben

import org.Apache.commons.exec.OS;

if (OS.isFamilyWindows()){
                //load some property
            }
else if (OS.isFamilyUnix()){
                //load some other property
            }

Weitere Details hier: https://commons.Apache.org/proper/commons-exec/apidocs/org/Apache/commons/exec/OS.html

6
Nafeez Quraishi
String osName = System.getProperty("os.name");
System.out.println("Operating system " + osName);
5

Ich mochte die Antwort von Wolfgang, nur weil ich glaube, dass solche Dinge Konstanten sein sollten ...

also habe ich es ein bisschen für mich selbst umformuliert und gedacht, es zu teilen :)

/**
 * types of Operating Systems
 *
 * please keep the note below as a pseudo-license
 *
 * helper class to check the operating system this Java VM runs in
 * http://stackoverflow.com/questions/228477/how-do-i-programmatically-determine-operating-system-in-Java
 * compare to http://svn.terracotta.org/svn/tc/dso/tags/2.6.4/code/base/common/src/com/tc/util/runtime/Os.Java
 * http://www.docjar.com/html/api/org/Apache/commons/lang/SystemUtils.Java.html
 */
public enum OSType {
    MacOS("mac", "darwin"),
    Windows("win"),
    Linux("nux"),
    Other("generic");

    private static OSType detectedOS;

    private final String[] keys;

    private OSType(String... keys) {
        this.keys = keys;
    }

    private boolean match(String osKey) {
        for (int i = 0; i < keys.length; i++) {
            if (osKey.indexOf(keys[i]) != -1)
                return true;
        }
        return false;
    }

    public static OSType getOS_Type() {
        if (detectedOS == null)
            detectedOS = getOperatingSystemType(System.getProperty("os.name", Other.keys[0]).toLowerCase());
        return detectedOS;
    }

    private static OSType getOperatingSystemType(String osKey) {
        for (OSType osType : values()) {
            if (osType.match(osKey))
                return osType;
        }
        return Other;
    }
}
3
TacB0sS

Sie können einfach die Methode Sun.awt.OSInfo # getOSType () verwenden

3
Kirill Gamazkov

Dieser Code zum Anzeigen aller Informationen über den Betriebssystemtyp, den Namen, Java Informationen usw.

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Properties pro = System.getProperties();
    for(Object obj : pro.keySet()){
        System.out.println(" System  "+(String)obj+"     :  "+System.getProperty((String)obj));
    }
}
2
ShinnedHawks

Alle obigen Antworten sind anfällig für einen schwerwiegenden Fehler im Design der System#getProperty -Unterroutine!

Vertrauen Sie niemals den Eigenschaften os.name, os.version und os.Arch. Diese Eigenschaften sind eigentlich nicht schreibgeschützt - stattdessen kann ein Angreifer problemlos ein beliebiges Zeichenfolgenliteral in sie einfügen!

Beispielsweise würde auf meinem Windows 10 Computer der folgende Code tatsächlich das Zeichenfolgenliteral "Linux" ausgeben. bei folgenden Schritten:

public static void main(String[] args)
{
     System.out.println(System.getProperty("os.name");
}

Nachdem wir nun class in eine ausführbare JAR gepackt haben, können wir sie tatsächlich wie unten gezeigt ausführen.

$ Java -jar PATH.jar -Dos.name = "Linux"

Daher besteht bei all Antworten die Gefahr, dass Ihr Programm denkt, es würde auf einem völlig falschen OS ausgeführt. Sie könnten sich jetzt fragen, wie man dieses Problem lösen würde? Nun, momentan besteht die einzige Möglichkeit, dieses Versehen zu beheben, darin, die Parameter des JVM zur Laufzeit manuell zu überprüfen.

Im Folgenden finden Sie ein kurzes Beispiel für die programmgesteuerte Abfrage dieser Eigenschaften. Angenommen, Sie würden einen static -Initialisierungsblock zu Ihrem primären class hinzufügen. Dann würde der folgende Code verhindern, dass jemand die Eigenschaft os.name extern manipuliert.

if (Java.util.Arrays.toString(jdk.internal.misc.VM.getRuntimeArguments()).contains("Dos.name"))
{
    throw new Java.lang.InternalError("Please refrain from tampering with the \"os.name\" property.");
}

Der jdk.internal.misc.VMclass ist nicht für die public Verwendung vorgesehen. Verwenden Sie es daher nicht im Seriencode!

2
Niklas Simandi

In der Klasse com.Sun.jna.Platform finden Sie nützliche statische Methoden wie

Platform.isWindows();
Platform.is64Bit();
Platform.isIntel();
Platform.isARM();

und vieles mehr.

Wenn Sie Maven verwenden, fügen Sie einfach Abhängigkeit hinzu

<dependency>
 <groupId>net.Java.dev.jna</groupId>
 <artifactId>jna</artifactId>
 <version>5.2.0</version>
</dependency>

Andernfalls suchen Sie einfach die jna-Bibliothek-JAR-Datei (z. B. jna-5.2.0.jar) und fügen sie dem Klassenpfad hinzu.

1

Verwenden Sie einfach com.Sun.javafx.util.Utils wie unten.

if ( Utils.isWindows()){
     // LOGIC HERE
}

ODER BENUTZEN

boolean isWindows = OSInfo.getOSType().equals(OSInfo.OSType.WINDOWS);
       if (isWindows){
         // YOUR LOGIC HERE
       }
1
itro