Sockets: Discover port availability using Java

问题:

How do I programmatically determine the availability of a port in a given machine using Java?

i.e given a port number, determine whether it is already being used or not?.

回答1:

This is the implementation coming from the Apache camel project:

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

They are checking the DatagramSocket as well to check if the port is avaliable in UDP and TCP.

Hope this helps.

回答2:

For Java 7 you can use try-with-resource for more compact code:

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

回答3:

It appears that as of Java 7, David Santamaria\'s answer doesn\'t work reliably any more. It looks like you can still reliably use a Socket to test the connection, however.

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

回答4:

If you\'re not too concerned with performance you could always try listening on a port using the ServerSocket class. If it throws an exception odds are it\'s being used.

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: If all you\'re trying to do is select a free port then new SocketServer(0) will find one for you.

回答5:

The following solution is inspired by the SocketUtils implementation of Spring-core (Apache license).

Compared to other solutions using Socket(...) it is pretty fast (testing 1000 TCP ports in less than a second):

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

回答6:

The try/catch socket based solutions , might not yield accurate results (the socket address is \"localhost\" and in some cases the port could be \"occupied\" not by the loopback interface and at least on Windows I\'ve seen this test fails i.e. the prot falsely declared as available).

There is a cool library named SIGAR , the following code can hook you up :

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;

回答7:

In my case it helped to try and connect to the port - if service is already present, it would respond.

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

回答8:

In my case I had to use DatagramSocket class.

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

Don\'t forget to import first

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

回答9:

I have Tried something Like this and it worked really fine with me

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

                 }