¿Cómo determino programáticamente el sistema operativo en Java?

Me gustaría determinar el sistema operativo del host que mi programa Java está ejecutando mediante programación (por ejemplo: me gustaría poder cargar diferentes propiedades en función de si estoy en una plataforma Windows o Unix). ¿Cuál es la forma más segura de hacer esto con 100% de confiabilidad?

Puedes usar:

System.getProperty("os.name")

PD: Puede encontrar útil este código:

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

Todo lo que hace es imprimir todas las propiedades proporcionadas por sus implementaciones de Java. Le dará una idea de lo que puede averiguar sobre su entorno Java a través de propiedades. :-)

Como se indica en otras respuestas, System.getProperty proporciona los datos sin procesar. Sin embargo, el componente Lang de Apache Commons proporciona un contenedor para java.lang.System con propiedades útiles como SystemUtils.IS_OS_WINDOWS, muy similar a la mencionada utilidad Swingx OS.

Octubre de 2008:

Recomendaría almacenarlo en caché en una variable estática:

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
}

De esa manera, cada vez que solicita el sistema operativo, no obtiene la propiedad más de una vez durante la vida útil de su aplicación.

Febrero de 2016: más de 7 años después:

Hay un error con Windows 10 (que no existía en el momento de la respuesta original).
Consulte " Java" os.name "para Windows 10? "

Algunos de los enlaces en las respuestas anteriores parecen estar rotos. He agregado punteros al código fuente actual en el código a continuación y ofrezco un enfoque para manejar la verificación con una enumeración como respuesta para que se pueda usar una declaración de cambio al evaluar el resultado:

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

La clase auxiliar es:

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

Las siguientes clases JavaFX tienen métodos estáticos para determinar el sistema operativo actual (isWindows (), isLinux () ...):

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

Ejemplo:

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

TL; DR

Para acceder a su uso OS: System.getProperty("os.name").

Pero, ¿por qué no crear una clase de utilidad, hacerla reutilizable! Y probablemente mucho más rápido en múltiples llamadas. ¡Limpio, claro, más rápido!

Cree una clase Util para tales funciones de utilidad. Luego, cree enumeraciones públicas para cada tipo de sistema operativo.

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

Ahora, puede invocar fácilmente la clase desde cualquier clase de la siguiente manera, (PD: ya que declaramos la variable os como estática, consumirá tiempo solo una vez para identificar el tipo de sistema, luego se puede usar hasta que su aplicación se detenga).

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

¡y eso es todo!

Un pequeño ejemplo de lo que está tratando de lograr probablemente sería classsimilar a lo que hay debajo:

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

Esta implementación particular es bastante confiable y debería ser universalmente aplicable. Simplemente cópielo y péguelo en su classelección.

Si está interesado en cómo un proyecto de código abierto hace cosas como esta, puede consultar la clase de terracota (Os.java) que maneja esta basura aquí:

• 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/

Y puede ver una clase similar para manejar versiones JVM (Vm.java y VmVersion.java) aquí:

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

Prueba esto, simple y fácil

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

Tomado de este proyecto 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 {
}

El siguiente código muestra los valores que puede obtener de la API del sistema, todo lo que puede obtener a través de esta 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"));
    }
}

Respuestas: -

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
\

Encuentro que las utilidades del sistema operativo de Swingx hacen el trabajo.

Creo que seguir puede dar una cobertura más amplia en menos líneas

import org.apache.commons.exec.OS;

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

Más detalles aquí: 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);

Puede usar el método sun.awt.OSInfo # getOSType ()

Si está trabajando en un entorno sensible a la seguridad, lea esto detenidamente.

¡Abstenerse de confiar en una propiedad obtenida a través de la System#getProperty(String)subrutina! En realidad, casi todas las propiedades os.arch, incluidos os.name, yos.version no son de solo lectura como cabría esperar; en cambio, en realidad son todo lo contrario.

En primer lugar, cualquier código con permiso suficiente para invocar la System#setProperty(String, String)subrutina puede modificar el literal devuelto a voluntad. Sin embargo, ese no es necesariamente el problema principal aquí, ya que se puede resolver mediante el uso de un llamado SecurityManager, como se describe en mayor detalle aquí .

El problema real es que cualquier usuario puede editar estas propiedades cuando ejecuta el JARen cuestión. Esto significa que no hay forma de determinar si estas propiedades son realmente precisas. Debido a esto, aquí hay algunas comprobaciones adicionales para tratar de evitar la manipulación:

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

Otra buena idea es verificar la presencia de directorios específicos del sistema operativo. Cualquiera que sea el enfoque que tome, recuerde que el lenguaje Java está diseñado para ser la plataforma cruzada. Entonces, ¿por qué no intentas hacer lo mismo?

Me gustó la respuesta de Wolfgang, solo porque creo que cosas así deberían ser const ...

así que lo reformulé un poco para mí y pensé en compartirlo :)

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

Este código para mostrar toda la información sobre el tipo de sistema operativo, nombre, información de Java, etc.

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

En la clase com.sun.jna.Platform puedes encontrar métodos estáticos útiles como

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

y mucho más.

Si usa Maven simplemente agregue dependencia

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

De lo contrario, solo busque el archivo jar de la biblioteca jna (por ejemplo, jna-5.2.0.jar) y agréguelo a classpath.

Solo use com.sun.javafx.util.Utilscomo a continuación.

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

O USAR

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