Jak programowo określić system operacyjny w Javie?

Chciałbym określić system operacyjny hosta, który mój program Java uruchamia programowo (na przykład: Chciałbym móc ładować różne właściwości w zależności od tego, czy korzystam z platformy Windows, czy Unix). Jaki jest najbezpieczniejszy sposób, aby to zrobić przy 100% niezawodności?

Możesz użyć:

System.getProperty("os.name")

PS Ten kod może ci się przydać:

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

Wystarczy wydrukować wszystkie właściwości dostarczone przez implementacje Java. Daje ci wyobrażenie o tym, co możesz dowiedzieć się o swoim środowisku Java za pomocą właściwości. :-)

Jak wskazano w innych odpowiedziach, System.getProperty zapewnia surowe dane. Jednak składnik Apache Commons Lang zapewnia opakowanie dla java.lang.System z przydatnymi właściwościami, takimi jak SystemUtils.IS_OS_WINDOWS, podobnie jak wyżej wspomniane użycie Swingx OS.

Październik 2008:

Polecam buforowanie go w zmiennej statycznej:

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
}

W ten sposób za każdym razem, gdy poprosisz o system operacyjny, nie pobierzesz właściwości więcej niż raz w ciągu całego życia aplikacji.

Luty 2016: 7+ lata później:

Wystąpił błąd w systemie Windows 10 (który nie istniał w czasie oryginalnej odpowiedzi).
Zobacz „ Java” „os.name” dla Windows 10? ”

niektóre linki w powyższych odpowiedziach wydają się być zepsute. Dodałem wskaźniki do bieżącego kodu źródłowego w poniższym kodzie i oferuję podejście do obsługi sprawdzania z wyliczeniem jako odpowiedzią, aby można było użyć instrukcji switch podczas oceny wyniku:

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

Klasa pomocnicza to:

/**
 * 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;
  }
}

Następujące klasy JavaFX mają statyczne metody określania bieżącego systemu operacyjnego (isWindows (), isLinux () ...):

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

Przykład:

if (PlatformUtil.isWindows()){
           ...
}

TL; DR

Dostępu do korzystania OS: System.getProperty("os.name").

Ale dlaczego nie stworzyć klasy użyteczności, spraw, aby można ją było ponownie wykorzystać! I prawdopodobnie o wiele szybciej w przypadku wielu połączeń. Czysto, czysto, szybciej!

Utwórz klasę Util dla takich funkcji narzędziowych. Następnie utwórz publiczne wyliczenia dla każdego typu systemu operacyjnego.

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;
    }
}

Teraz możesz łatwo wywoływać klasę z dowolnej klasy w następujący sposób (PS Ponieważ zadeklarowaliśmy zmienną os jako statyczną, identyfikacja typu systemu zajmie czas tylko raz, więc można jej używać do momentu zatrzymania aplikacji).

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

i to jest to!

Mały przykład tego, co próbujesz osiągnąć, prawdopodobnie byłby classpodobny do tego, co poniżej:

import java.util.Locale;

public class OperatingSystem
{
    private static String OS = System.getProperty("os.name", "unknown").toLowerCase(Locale.ROOT);

    public static boolean isWindows()
    {
        return OS.contains("win");
    }

    public static boolean isMac()
    {
        return OS.contains("mac");
    }

    public static boolean isUnix()
    {
        return OS.contains("nux");
    }
}

Ta konkretna implementacja jest dość niezawodna i powinna mieć uniwersalne zastosowanie. Po prostu skopiuj i wklej go do swojego classwyboru.

Jeśli jesteś zainteresowany tym, jak projekt open source robi takie rzeczy, możesz sprawdzić klasę terakoty (Os.java), która obsługuje te śmieci tutaj:

• http://svn.terracotta.org/svn/tc/dso/trunk/code/base/common/src/com/tc/util/runtime/
• http://svn.terracotta.org/svn/tc/dso/tags/2.6.4/code/base/common/src/com/tc/util/runtime/

I możesz zobaczyć podobną klasę do obsługi wersji JVM (Vm.java i VmVersion.java) tutaj:

• http://svn.terracotta.org/svn/tc/dso/trunk/common/src/main/java/com/tc/util/runtime/

Wypróbuj to, proste i łatwe

System.getProperty("os.name");
System.getProperty("os.version");
System.getProperty("os.arch");

Zaczerpnięte z tego projektu 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 {
}

Poniższy kod pokazuje wartości, które można uzyskać z System API, wszystkie te rzeczy, które można uzyskać za pośrednictwem tego API.

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"));
    }
}

Odpowiedzi: -

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
\

Uważam, że Utils OS Swils wykonuje pracę.

Myślę, że podążanie może dać szerszy zasięg w mniejszej liczbie linii

import org.apache.commons.exec.OS;

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

Więcej informacji tutaj: https://commons.apache.org/proper/commons-exec/apidocs/org/apache/commons/exec/OS.html

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

Możesz po prostu użyć metody sun.awt.OSInfo # getOSType ()

Jeśli pracujesz w środowisku wrażliwym na bezpieczeństwo, przeczytaj to.

Proszę, nigdy nie ufajcie nieruchomości uzyskanej za pomocą System#getProperty(String)podprogramu! W rzeczywistości prawie każda właściwość, w tym os.arch, os.namei, os.versionnie jest tylko do odczytu, jak można się spodziewać - zamiast tego są wręcz przeciwnie.

Przede wszystkim każdy kod z wystarczającą zgodą na wywołanie System#setProperty(String, String)podprogramu może dowolnie modyfikować zwracany literał. Jednak nie jest to koniecznie główny problem, ponieważ można go rozwiązać za pomocą tak zwanego SecurityManager, jak opisano bardziej szczegółowo tutaj .

Rzeczywistym problemem jest to, że każdy użytkownik może edytować te właściwości podczas uruchamiania danego JARpytania. Oznacza to, że nie ma sposobu, aby ustalić, czy te właściwości są rzeczywiście dokładne. Z tego powodu oto kilka dodatkowych sprawdzeń, aby uniknąć manipulacji:

// The first thing we're able to do is to query the filesystem.
switch (java.io.File.separator)
{
    case "/":
        // Windows is a potential candidate.
        break;
    case "\\":
        // And here it could really be anything else.
        break;
    default:
        // There's probably something really wrong here by now.
        break;
}

Innym dobrym pomysłem jest sprawdzenie obecności katalogów specyficznych dla systemu operacyjnego. Niezależnie od tego, jakie podejmiesz podejście, pamiętaj, że język Java jest przeznaczony dla wielu platform. Dlaczego więc nie spróbujesz zrobić tego samego?

Podoba mi się odpowiedź Wolfganga tylko dlatego, że uważam, że takie rzeczy powinny być consts ...

więc sformułowałem to trochę dla siebie i postanowiłem to udostępnić :)

/**
 * 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;
    }
}

Ten kod do wyświetlania wszystkich informacji o typie systemu operacyjnego, nazwie, informacjach Java i tak dalej.

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));
    }
}

W klasie com.sun.jna.Platform można znaleźć przydatne metody statyczne, takie jak

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

i wiele więcej.

Jeśli używasz Maven, po prostu dodaj zależność

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

W przeciwnym razie po prostu znajdź plik jar biblioteki jna (np. Jna-5.2.0.jar) i dodaj go do ścieżki klasy.

Po prostu użyj com.sun.javafx.util.Utilsjak poniżej.

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

ALBO UŻYJ

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