Méthode Java préférée pour envoyer une requête ping à une URL HTTP pour la disponibilité

J'ai besoin d'une classe de surveillance qui vérifie régulièrement si une URL HTTP donnée est disponible. Je peux m'occuper de la partie "régulièrement" en utilisant l'abstraction Spring TaskExecutor, donc ce n'est pas le sujet ici. La question est: Quelle est la meilleure façon de pinguer une URL en java?

Voici mon code actuel comme point de départ:

try {
    final URLConnection connection = new URL(url).openConnection();
    connection.connect();
    LOG.info("Service " + url + " available, yeah!");
    available = true;
} catch (final MalformedURLException e) {
    throw new IllegalStateException("Bad URL: " + url, e);
} catch (final IOException e) {
    LOG.info("Service " + url + " unavailable, oh no!", e);
    available = false;
}

1. Est-ce que c'est bon du tout (fera-t-il ce que je veux)?
2. Dois-je fermer la connexion d'une manière ou d'une autre?
3. Je suppose que c'est une GETdemande. Existe-t-il un moyen d'envoyer à la HEADplace?

Est-ce que c'est bon du tout (ça fera ce que je veux?)

Vous pouvez le faire. Un autre moyen possible consiste à utiliser java.net.Socket.

public static boolean pingHost(String host, int port, int timeout) {
    try (Socket socket = new Socket()) {
        socket.connect(new InetSocketAddress(host, port), timeout);
        return true;
    } catch (IOException e) {
        return false; // Either timeout or unreachable or failed DNS lookup.
    }
}

Il y a aussi InetAddress#isReachable():

boolean reachable = InetAddress.getByName(hostname).isReachable();

Cependant, cela ne teste pas explicitement le port 80. Vous risquez d'obtenir de faux négatifs en raison d'un pare-feu bloquant d'autres ports.

Dois-je fermer la connexion d'une manière ou d'une autre?

Non, vous n'en avez pas explicitement besoin. Il est manipulé et regroupé sous les capots.

Je suppose que c'est une demande GET. Existe-t-il un moyen d'envoyer HEAD à la place?

Vous pouvez convertir la méthode obtenue URLConnectionen HttpURLConnectionpuis l'utiliser setRequestMethod()pour définir la méthode de demande. Cependant, vous devez prendre en compte le fait que certaines applications Web de mauvaise qualité ou serveurs locaux peuvent renvoyer une erreur HTTP 405 pour un HEAD (c'est-à-dire non disponible, non implémenté, non autorisé) alors qu'un GET fonctionne parfaitement. L'utilisation de GET est plus fiable dans le cas où vous avez l'intention de vérifier les liens / ressources et non les domaines / hôtes.

Tester la disponibilité du serveur n'est pas suffisant dans mon cas, j'ai besoin de tester l'URL (la webapp peut ne pas être déployée)

En effet, connecter un hébergeur informe uniquement si l'hôte est disponible, pas si le contenu est disponible. Il peut aussi bien arriver qu'un serveur Web ait démarré sans problème, mais que l'application Web n'a pas pu se déployer lors du démarrage du serveur. Cependant, cela n'entraînera généralement pas la panne de l'ensemble du serveur. Vous pouvez le déterminer en vérifiant si le code de réponse HTTP est 200.

HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
connection.setRequestMethod("HEAD");
int responseCode = connection.getResponseCode();
if (responseCode != 200) {
    // Not OK.
}

// < 100 is undetermined.
// 1nn is informal (shouldn't happen on a GET/HEAD)
// 2nn is success
// 3nn is redirect
// 4nn is client error
// 5nn is server error

Pour plus de détails sur les codes d'état de réponse, voir la section 10 de la RFC 2616 . L'appel connect()n'est d'ailleurs pas nécessaire si vous déterminez les données de réponse. Il se connectera implicitement.

Pour référence future, voici un exemple complet de saveur d'une méthode utilitaire, en tenant également compte des délais d'expiration:

/**
 * Pings a HTTP URL. This effectively sends a HEAD request and returns <code>true</code> if the response code is in 
 * the 200-399 range.
 * @param url The HTTP URL to be pinged.
 * @param timeout The timeout in millis for both the connection timeout and the response read timeout. Note that
 * the total timeout is effectively two times the given timeout.
 * @return <code>true</code> if the given HTTP URL has returned response code 200-399 on a HEAD request within the
 * given timeout, otherwise <code>false</code>.
 */
public static boolean pingURL(String url, int timeout) {
    url = url.replaceFirst("^https", "http"); // Otherwise an exception may be thrown on invalid SSL certificates.

    try {
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setConnectTimeout(timeout);
        connection.setReadTimeout(timeout);
        connection.setRequestMethod("HEAD");
        int responseCode = connection.getResponseCode();
        return (200 <= responseCode && responseCode <= 399);
    } catch (IOException exception) {
        return false;
    }
}

Au lieu d'utiliser URLConnection, utilisez HttpURLConnection en appelant openConnection () sur votre objet URL.

Ensuite, utilisez getResponseCode () vous donnera la réponse HTTP une fois que vous aurez lu à partir de la connexion.

voici le code:

    HttpURLConnection connection = null;
    try {
        URL u = new URL("http://www.google.com/");
        connection = (HttpURLConnection) u.openConnection();
        connection.setRequestMethod("HEAD");
        int code = connection.getResponseCode();
        System.out.println("" + code);
        // You can determine on HTTP return code received. 200 is success.
    } catch (MalformedURLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        if (connection != null) {
            connection.disconnect();
        }
    }

Vérifiez également la question similaire Comment vérifier si une URL existe ou renvoie 404 avec Java?

J'espère que cela t'aides.

Vous pouvez également utiliser HttpURLConnection , qui vous permet de définir la méthode de requête (sur HEAD par exemple). Voici un exemple qui montre comment envoyer une demande, lire la réponse et se déconnecter.

Le code suivant exécute une HEADdemande pour vérifier si le site Web est disponible ou non.

public static boolean isReachable(String targetUrl) throws IOException
{
    HttpURLConnection httpUrlConnection = (HttpURLConnection) new URL(
            targetUrl).openConnection();
    httpUrlConnection.setRequestMethod("HEAD");

    try
    {
        int responseCode = httpUrlConnection.getResponseCode();

        return responseCode == HttpURLConnection.HTTP_OK;
    } catch (UnknownHostException noInternetConnection)
    {
        return false;
    }
}

ici l'auteur suggère ceci:

public boolean isOnline() {
    Runtime runtime = Runtime.getRuntime();
    try {
        Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
        int     exitValue = ipProcess.waitFor();
        return (exitValue == 0);
    } catch (IOException | InterruptedException e) { e.printStackTrace(); }
    return false;
}

Questions possibles

• Est-ce vraiment assez rapide? Oui, très rapide!
• Ne pourrais-je pas simplement envoyer un ping à ma propre page, que je souhaite quand même demander? Sûr! Vous pouvez même vérifier les deux, si vous souhaitez faire la différence entre «connexion Internet disponible» et vos propres serveurs accessibles. Et si le DNS est en panne? Google DNS (par exemple 8.8.8.8) est le plus grand service DNS public au monde. En 2013, il traite 130 milliards de demandes par jour. Disons simplement que votre application ne répond pas ne serait probablement pas la conversation du jour.

lisez le lien. ça semble très bien

EDIT: dans mon exp de l'utiliser, ce n'est pas aussi rapide que cette méthode:

public boolean isOnline() {
    NetworkInfo netInfo = connectivityManager.getActiveNetworkInfo();
    return netInfo != null && netInfo.isConnectedOrConnecting();
}

ils sont un peu différents, mais dans la fonctionnalité de vérification de la connexion à Internet, la première méthode peut devenir lente en raison des variables de connexion.

Pensez à utiliser le framework Restlet, qui a une excellente sémantique pour ce genre de chose. C'est puissant et flexible.

Le code pourrait être aussi simple que:

Client client = new Client(Protocol.HTTP);
Response response = client.get(url);
if (response.getStatus().isError()) {
    // uh oh!
}