Enchufes: descubra la disponibilidad del puerto con Java

Question

¿Cómo puedo determinar mediante programación la disponibilidad de un puerto en una máquina determinada utilizando Java?

i.e dado un número de puerto, determinar si ya se está utilizando o no ?.

Answer 1

Si no le preocupa el rendimiento, siempre puede intentar escuchar en un puerto utilizando la clase ServerSocket. Si arroja una excepción de excepción, se está utilizando.

boolean portTaken = false; 
    ServerSocket socket = null; 
    try { 
     socket = new ServerSocket(_port); 
    } catch (IOException e) { 
     portTaken = true; 
    } finally { 
     if (socket != null) 
      try { 
       socket.close(); 
      } catch (IOException e) { /* e.printStackTrace(); */ } 
} 

EDIT: Si todo lo que estamos tratando de hacer es seleccionar un puerto libre entonces new SocketServer(0) va a encontrar uno para usted.

Answer 2

Este es el implementation procedente del proyecto Apache camel:

/** 
* Checks to see if a specific port is available. 
* 
* @param port the port to check for availability 
*/ 
public static boolean available(int port) { 
    if (port < MIN_PORT_NUMBER || port > MAX_PORT_NUMBER) { 
     throw new IllegalArgumentException("Invalid start port: " + port); 
    } 

    ServerSocket ss = null; 
    DatagramSocket ds = null; 
    try { 
     ss = new ServerSocket(port); 
     ss.setReuseAddress(true); 
     ds = new DatagramSocket(port); 
     ds.setReuseAddress(true); 
     return true; 
    } catch (IOException e) { 
    } finally { 
     if (ds != null) { 
      ds.close(); 
     } 

     if (ss != null) { 
      try { 
       ss.close(); 
      } catch (IOException e) { 
       /* should not be thrown */ 
      } 
     } 
    } 

    return false; 
} 

están comprobando la DatagramSocket así comprobar si el puerto está disponible en UDP y TCP.

Espero que esto ayude.

Answer 3

En mi caso, me ayudó a probar y conectarme al puerto; si el servicio ya está presente, respondería.

try { 
     log.debug("{}: Checking if port open by trying to connect as a client", portNumber); 
     Socket sock = new Socket("localhost", portNumber);   
     sock.close(); 
     log.debug("{}: Someone responding on port - seems not open", portNumber); 
     return false; 
    } catch (Exception e) {   
     if (e.getMessage().contains("refused")) { 
      return true; 
    } 
     log.error("Troubles checking if port is open", e); 
     throw new RuntimeException(e);    
    } 

Answer 4

Parece que a partir de Java 7, David Santamaria's answer no funciona de forma fiable más. Sin embargo, parece que todavía se puede usar un Socket de manera confiable para probar la conexión.

private static boolean available(int port) { 
    System.out.println("--------------Testing port " + port); 
    Socket s = null; 
    try { 
     s = new Socket("localhost", port); 

     // If the code makes it this far without an exception it means 
     // something is using the port and has responded. 
     System.out.println("--------------Port " + port + " is not available"); 
     return false; 
    } catch (IOException e) { 
     System.out.println("--------------Port " + port + " is available"); 
     return true; 
    } finally { 
     if(s != null){ 
      try { 
       s.close(); 
      } catch (IOException e) { 
       throw new RuntimeException("You should handle this error." , e); 
      } 
     } 
    } 
} 

Answer 5

Para Java 7 puede utilizar try-con-recurso para más código compacto:

private static boolean available(int port) { 
    try (Socket ignored = new Socket("localhost", port)) { 
     return false; 
    } catch (IOException ignored) { 
     return true; 
    } 
} 

Answer 6

soluciones basadas en la toma de try/catch, podría no dar resultados precisos (la dirección de socket es "localhost "y en algunos casos el puerto podría estar" ocupado "no por la interfaz de bucle invertido y al menos en Windows he visto que esta prueba falla, es decir, el prot declarado falsamente como disponible).

Hay una biblioteca fresca llamado SIGAR, el siguiente código puede liarte:

Sigar sigar = new Sigar(); 
int flags = NetFlags.CONN_TCP | NetFlags.CONN_SERVER | NetFlags.CONN_CLIENT;    NetConnection[] netConnectionList = sigar.getNetConnectionList(flags); 
for (NetConnection netConnection : netConnectionList) { 
    if (netConnection.getLocalPort() == port) 
     return false; 
} 
return true; 

Answer 7

He intentado algo como esto y funcionó muy bien conmigo

  Socket Skt; 
      String host = "localhost"; 
      int i = 8983; // port no. 

       try { 
        System.out.println("Looking for "+ i); 
        Skt = new Socket(host, i); 
        System.out.println("There is a Server on port " 
        + i + " of " + host); 
       } 
       catch (UnknownHostException e) { 
        System.out.println("Exception occured"+ e); 

       } 
       catch (IOException e) { 
        System.out.println("port is not used"); 

       } 

Answer 8

En mi caso Tuve que usar la clase DatagramSocket.

boolean isPortOccupied(int port) { 
    DatagramSocket sock = null; 
    try { 
     sock = new DatagramSocket(port); 
     sock.close(); 
     return false; 
    } catch (BindException ignored) { 
     return true; 
    } catch (SocketException ex) { 
     System.out.println(ex); 
     return true; 
    } 
} 

No se olvide de importar primera

import java.net.DatagramSocket; 
import java.net.BindException; 
import java.net.SocketException; 

Answer 9

La siguiente solución se inspira en la implementación de SocketUtils Primavera-núcleo (licencia Apache).

En comparación con otras soluciones que utilizan Socket(...) es bastante rápido (pruebas de 1000 puertos TCP en menos de un segundo):

public static boolean isTcpPortAvailable(int port) { 
    try (ServerSocket serverSocket = new ServerSocket()) { 
     // setReuseAddress(false) is required only on OSX, 
     // otherwise the code will not work correctly on that platform   
     serverSocket.setReuseAddress(false); 
     serverSocket.bind(new InetSocketAddress(InetAddress.getByName("localhost"), port), 1); 
     return true; 
    } catch (Exception ex) { 
     return false; 
    } 
}