¿Cuál de las siguientes es la mejor y más portátil forma de obtener el nombre de host de la computadora actual en Java?
Runtime.getRuntime().exec("hostname")
vs
InetAddress.getLocalHost().getHostName()
¿Cuál de las siguientes es la mejor y más portátil forma de obtener el nombre de host de la computadora actual en Java?
Runtime.getRuntime().exec("hostname")
vs
InetAddress.getLocalHost().getHostName()
Respuestas:
Hablando estrictamente, no tiene más remedio que llamar a cualquiera de los dos hostname(1)
, en Unix gethostname(2)
. Este es el nombre de tu computadora. Cualquier intento de determinar el nombre de host por una dirección IP como esta
InetAddress.getLocalHost().getHostName()
está obligado a fallar en algunas circunstancias:
Tampoco confunda el nombre de una dirección IP con el nombre del host (nombre del host). Una metáfora podría aclararlo:
Hay una gran ciudad (servidor) llamada "Londres". Dentro de las murallas de la ciudad ocurren muchos negocios. La ciudad tiene varias puertas (direcciones IP). Cada puerta tiene un nombre ("Puerta Norte", "Puerta del Río", "Puerta de Southampton" ...) pero el nombre de la puerta no es el nombre de la ciudad. Tampoco puede deducir el nombre de la ciudad utilizando el nombre de una puerta: "Puerta Norte" atraparía la mitad de las ciudades más grandes y no solo una ciudad. Sin embargo, un extraño (paquete de IP) camina a lo largo del río y le pregunta a un local: "Tengo una dirección extraña: 'Rivergate, segunda izquierda, tercera casa'. ¿Me pueden ayudar?" El local dice: "Por supuesto, está en el camino correcto, simplemente siga adelante y llegará a su destino dentro de media hora".
Esto lo ilustra más o menos, creo.
La buena noticia es: el nombre de host real generalmente no es necesario. En la mayoría de los casos, cualquier nombre que se resuelva en una dirección IP en este host funcionará. (El extraño podría ingresar a la ciudad por Northgate, pero los lugareños útiles traducen la parte de "segunda izquierda").
Si los casos de esquina restantes debe utilizar la definitiva fuente de esta opción de configuración - que es la función C gethostname(2)
. Esa función también es llamada por el programa hostname
.
InetAddress.getLocalHost().getHostName()
Es la forma más portátil.
exec("hostname")
en realidad llama al sistema operativo para ejecutar el hostname
comando.
Aquí hay otras respuestas relacionadas sobre SO:
EDITAR: debe echar un vistazo a la respuesta de AH o la respuesta de Arnout Engelen para obtener detalles sobre por qué esto podría no funcionar como se esperaba, dependiendo de su situación. Como respuesta para esta persona que solicitó específicamente un dispositivo portátil, sigo pensando que getHostName()
está bien, pero mencionan algunos puntos buenos que deberían considerarse.
InetAddress.getLocalHost()
en algunos casos devuelve el dispositivo de bucle invertido. En ese caso, getHostName()
devuelve "localhost", que no es muy útil.
Como otros han señalado, obtener el nombre de host basado en la resolución DNS no es confiable.
Como desafortunadamente esta pregunta aún es relevante en 2018 , me gustaría compartir con ustedes mi solución independiente de la red, con algunas ejecuciones de prueba en diferentes sistemas.
El siguiente código intenta hacer lo siguiente:
En Windows
Lea la COMPUTERNAME
variable de entorno a través System.getenv()
.
Ejecuta hostname.exe
y lee la respuesta
En Linux
Lea la HOSTNAME
variable de entorno a través deSystem.getenv()
Ejecuta hostname
y lee la respuesta
Leer /etc/hostname
(para hacer esto, lo estoy ejecutando cat
ya que el fragmento ya contiene código para ejecutar y leer. Simplemente leer el archivo sería mejor).
El código:
public static void main(String[] args) throws IOException {
String os = System.getProperty("os.name").toLowerCase();
if (os.contains("win")) {
System.out.println("Windows computer name through env:\"" + System.getenv("COMPUTERNAME") + "\"");
System.out.println("Windows computer name through exec:\"" + execReadToString("hostname") + "\"");
} else if (os.contains("nix") || os.contains("nux") || os.contains("mac os x")) {
System.out.println("Unix-like computer name through env:\"" + System.getenv("HOSTNAME") + "\"");
System.out.println("Unix-like computer name through exec:\"" + execReadToString("hostname") + "\"");
System.out.println("Unix-like computer name through /etc/hostname:\"" + execReadToString("cat /etc/hostname") + "\"");
}
}
public static String execReadToString(String execCommand) throws IOException {
try (Scanner s = new Scanner(Runtime.getRuntime().exec(execCommand).getInputStream()).useDelimiter("\\A")) {
return s.hasNext() ? s.next() : "";
}
}
Resultados para diferentes sistemas operativos:
macOS 10.13.2
Unix-like computer name through env:"null"
Unix-like computer name through exec:"machinename
"
Unix-like computer name through /etc/hostname:""
OpenSuse 13.1
Unix-like computer name through env:"machinename"
Unix-like computer name through exec:"machinename
"
Unix-like computer name through /etc/hostname:""
Ubuntu 14.04 LTS
Este es un poco extraño ya que echo $HOSTNAME
devuelve el nombre de host correcto, pero System.getenv("HOSTNAME")
no:
Unix-like computer name through env:"null"
Unix-like computer name through exec:"machinename
"
Unix-like computer name through /etc/hostname:"machinename
"
EDITAR: Según legolas108 , System.getenv("HOSTNAME")
funciona en Ubuntu 14.04 si lo ejecuta export HOSTNAME
antes de ejecutar el código Java.
Windows 7
Windows computer name through env:"MACHINENAME"
Windows computer name through exec:"machinename
"
Windows 10
Windows computer name through env:"MACHINENAME"
Windows computer name through exec:"machinename
"
Los nombres de las máquinas han sido reemplazados pero mantuve las mayúsculas y la estructura. Tenga en cuenta la nueva línea adicional al ejecutar hostname
, puede que tenga que tenerla en cuenta en algunos casos.
export HOSTNAME
antes de ejecutar el código Java en Ubuntu 14.04 LTS también lo devuelve System.getenv("HOSTNAME")
.
export HOSTNAME
que Java lo use? Pensé que debería ser un entorno predeterminado como PATH.
\A
delimitador es solo un truco para leer todo el InputStream usando a Scanner
.
InetAddress.getLocalHost().getHostName()
es mejor (como explica Nick), pero aún no es muy bueno
Un host se puede conocer con muchos nombres de host diferentes. Por lo general, buscará el nombre de host que tiene en un contexto específico.
Por ejemplo, en una aplicación web, es posible que esté buscando el nombre de host utilizado por quien emitió la solicitud que está manejando actualmente. La mejor manera de encontrarla depende del marco que esté utilizando para su aplicación web.
En algún otro tipo de servicio con conexión a Internet, querrá el nombre de host para el que está disponible su servicio desde el 'exterior'. Debido a los servidores proxy, los cortafuegos, etc., es posible que este ni siquiera sea un nombre de host en la máquina en la que está instalado su servicio; puede intentar obtener un valor predeterminado razonable, pero definitivamente debe hacer que esto sea configurable para quien lo instale.
Aunque este tema ya ha sido respondido, hay más que decir.
Primero que nada: Claramente necesitamos algunas definiciones aquí. El InetAddress.getLocalHost().getHostName()
le da el nombre del host como se ve desde una perspectiva de red . Los problemas con este enfoque están bien documentados en las otras respuestas: a menudo requiere una búsqueda de DNS, es ambiguo si el host tiene múltiples interfaces de red y simplemente falla a veces (ver más abajo).
Pero en cualquier sistema operativo también hay otro nombre. Un nombre del host que se define muy temprano en el proceso de arranque, mucho antes de que se inicialice la red. Windows se refiere a esto como nombre de computadora , Linux lo llama nombre de host del núcleo y Solaris usa la palabra nombrenodo . Me gusta más la palabra computername , así que usaré esa palabra de ahora en adelante.
En Linux / Unix, el nombre de la computadora es lo que obtienes de la función C gethostname()
, o el hostname
comando de la shell o HOSTNAME
la variable de entorno en shells tipo Bash.
En Windows, el nombre del equipo es lo que obtienes de la variable de entorno COMPUTERNAME
o la GetComputerName
función Win32 .
Java no tiene forma de obtener lo que he definido como 'nombre de computadora'. Claro, hay soluciones como se describe en otras respuestas, como para las llamadas de Windows System.getenv("COMPUTERNAME")
, pero en Unix / Linux no hay una buena solución sin recurrir a JNI / JNA o Runtime.exec()
. Si no le importa una solución JNI / JNA, hay gethostname4j, que es muy simple y muy fácil de usar.
Pasemos con dos ejemplos, uno de Linux y otro de Solaris, que demuestran cómo puede entrar fácilmente en una situación en la que no puede obtener el nombre de la computadora utilizando métodos estándar de Java.
En un sistema recién creado, donde el host durante la instalación ha sido nombrado como 'Chicago', ahora cambiamos el llamado nombre de host del núcleo:
$ hostnamectl --static set-hostname dallas
Ahora el nombre de host del núcleo es 'dallas', como se desprende del comando hostname:
$ hostname
dallas
Pero todavia tenemos
$ cat /etc/hosts
127.0.0.1 localhost
127.0.0.1 chicago
No hay una mala configuración en esto. Simplemente significa que el nombre en red del host (o más bien el nombre de la interfaz de bucle invertido) es diferente del nombre de la computadora del host.
Ahora, intente ejecutar InetAddress.getLocalHost().getHostName()
y arrojará java.net.UnknownHostException. Básicamente estás atrapado. No hay forma de recuperar ni el valor 'dallas' ni el valor 'chicago'.
El siguiente ejemplo se basa en Solaris 11.3.
El host se configuró deliberadamente para que el nombre de bucle invertido <> nombrenodo.
En otras palabras tenemos:
$ svccfg -s system/identity:node listprop config
...
...
config/loopback astring chicago
config/nodename astring dallas
y el contenido de / etc / hosts:
:1 chicago localhost
127.0.0.1 chicago localhost loghost
y el resultado del comando hostname sería:
$ hostname
dallas
Al igual que en el ejemplo de Linux, una llamada a InetAddress.getLocalHost().getHostName()
fallará con
java.net.UnknownHostException: dallas: dallas: node name or service name not known
Al igual que el ejemplo de Linux, ahora estás atascado. No hay forma de recuperar ni el valor 'dallas' ni el valor 'chicago'.
Muy a menudo encontrará que InetAddress.getLocalHost().getHostName()
, de hecho, devolverá un valor que es igual al nombre del equipo. Por lo tanto, no hay problema (a excepción de la sobrecarga adicional de la resolución de nombres).
El problema surge típicamente en entornos PaaS donde hay una diferencia entre el nombre de la computadora y el nombre de la interfaz de bucle invertido. Por ejemplo, las personas informan problemas en Amazon EC2.
Un poco de búsqueda revela este informe RFE: link1 , link2 . Sin embargo, a juzgar por los comentarios sobre ese informe, el tema parece haber sido mal entendido por el equipo de JDK, por lo que es poco probable que se aborde.
Me gusta la comparación en el RFE con otros lenguajes de programación.
Las variables de entorno también pueden proporcionar un medio útil, COMPUTERNAME
en Windows, HOSTNAME
en la mayoría de los shells modernos de Unix / Linux.
Ver: https://stackoverflow.com/a/17956000/768795
Los estoy utilizando como métodos "complementarios" para InetAddress.getLocalHost().getHostName()
, como señalan varias personas, esa función no funciona en todos los entornos.
Runtime.getRuntime().exec("hostname")
Es otro posible suplemento. En este momento, no lo he usado.
import java.net.InetAddress;
import java.net.UnknownHostException;
// try InetAddress.LocalHost first;
// NOTE -- InetAddress.getLocalHost().getHostName() will not work in certain environments.
try {
String result = InetAddress.getLocalHost().getHostName();
if (StringUtils.isNotEmpty( result))
return result;
} catch (UnknownHostException e) {
// failed; try alternate means.
}
// try environment properties.
//
String host = System.getenv("COMPUTERNAME");
if (host != null)
return host;
host = System.getenv("HOSTNAME");
if (host != null)
return host;
// undetermined.
return null;
StringUtils
, es proporcionado por el proyecto Apache commons-lang. Usarlo, o algo así, es muy recomendable.
System.getenv("HOSTNAME")
salió nulo en Mac a través de Beanshell para Java, pero PATH
se extrajo bien. También podría hacerlo echo $HOSTNAME
en Mac, solo System.getenv ("HOSTNAME") parece tener problemas. Extraño.
La forma más portátil de obtener el nombre de host de la computadora actual en Java es la siguiente:
import java.net.InetAddress;
import java.net.UnknownHostException;
public class getHostName {
public static void main(String[] args) throws UnknownHostException {
InetAddress iAddress = InetAddress.getLocalHost();
String hostName = iAddress.getHostName();
//To get the Canonical host name
String canonicalHostName = iAddress.getCanonicalHostName();
System.out.println("HostName:" + hostName);
System.out.println("Canonical Host Name:" + canonicalHostName);
}
}
Si no está en contra de usar una dependencia externa de maven central, escribí gethostname4j para resolver este problema por mí mismo. Simplemente usa JNA para llamar a la función gethostname de libc (u obtiene ComputerName en Windows) y se la devuelve como una cadena.
hostName == null;
Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
{
while (interfaces.hasMoreElements()) {
NetworkInterface nic = interfaces.nextElement();
Enumeration<InetAddress> addresses = nic.getInetAddresses();
while (hostName == null && addresses.hasMoreElements()) {
InetAddress address = addresses.nextElement();
if (!address.isLoopbackAddress()) {
hostName = address.getHostName();
}
}
}
}
Solo una línea ... multiplataforma (Windows-Linux-Unix-Mac (Unix)) [Siempre funciona, no se requiere DNS]:
String hostname = new BufferedReader(
new InputStreamReader(Runtime.getRuntime().exec("hostname").getInputStream()))
.readLine();
¡Ya terminaste!
InetAddress.getLocalHost (). GetHostName () es la mejor manera de salir de los dos, ya que esta es la mejor abstracción a nivel de desarrollador.