FAQ Fichiers, flux et réseauxConsultez toutes les FAQ

Nombre d'auteurs : 15, nombre de questions : 95, dernière mise à jour : 21 mars 2016  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur le forum Java de http://java.developpez.com ainsi que l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.

Sur ce, nous vous souhaitons une bonne lecture.


SommaireRéseaux (19)
précédent sommaire suivant
 

Sur Windows et avec une seule carte réseau, l'information n'est pas trop difficile à obtenir, en invoquant la méthode statique getLocalHost() de la classe java.net.InetAddress :

Code Java : Sélectionner tout
String ip = InetAddress.getLocalHost ().getHostAddress ();

Cependant sur Linux, cette méthode retournera l’adresse de rebouclage (loopback).

JDK 7
À partir du JDK 7, vous pouvez connaître l’adresse de rebouclage de votre machine en invoquant la méthode statique getLoopbackAddress() de la classe java.net.InetAddress :

Code Java : Sélectionner tout
String loopbackIp = InetAddress.getLoopbackAddress().getHostAddress();

Mis à jour le 24 août 2015 bouye Clement Cunin

Comme nous venons de le voir, de manière générale, la valeur retournée par la méthode getLocalHost() de la classe java.net.InetAddress ne s'applique pas aux machines tournant sous Linux. De plus, il est assez fréquent de nos jours qu'une seule machine dispose de plusieurs interfaces réseau (ex. : LAN, WiFi, VPN, etc.) et donc de plusieurs adresses.

JDK 1.4
À partir du JDK 1.4, dans le cas où vous avez de multiples interfaces ou cartes réseau, il vous faut parcourir ces interfaces en invoquant la méthode statique getNetworkInterfaces() de la classe java.net.NetworkInterface pour récupérer une énumération de toutes les interfaces réseau. Vous pouvez ensuite invoquer la méthode getInetAddresses() sur chaque interface pour obtenir la liste des adresses associées à ces interfaces :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try { 
    // Énumération de toutes les cartes réseau. 
    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); 
    while (interfaces.hasMoreElements()) { 
        NetworkInterface interfaceN = (NetworkInterface) interfaces.nextElement(); 
        System.out.println("----> " + interfaceN.getDisplayName()); 
        Enumeration<InetAddress> iEnum = interfaceN.getInetAddresses(); 
        while (iEnum.hasMoreElements()) { 
            InetAddress inetAddress = iEnum.nextElement(); 
            System.out.println(inetAddress.getHostAddress()); 
        } 
    } 
} catch (Exception ex) { 
    System.out.println("pas de carte réseau."); 
    ex.printStackTrace(); 
}

JDK 6
À partir du JDK 6, il est également possible de récupérer la liste des adresses de chaque interface en invoquant la méthode getInterfaceAddresses() de classe java.net.NetworkInterface  :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
try { 
    // Énumération de toutes les cartes réseau. 
    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); 
    while (interfaces.hasMoreElements()) { 
        NetworkInterface interfaceN = (NetworkInterface) interfaces.nextElement(); 
        System.out.println("----> " + interfaceN.getDisplayName()); 
        List<InterfaceAddress> iaList= interfaceN.getInterfaceAddresses(); 
        for (InterfaceAddress interfaceAddress : iaList) { 
            System.out.println(interfaceAddress.getAddress().getHostAddress()); 
        } 
    } 
} catch (Exception ex) { 
    System.out.println("pas de carte réseau."); 
    ex.printStackTrace(); 
}

Mis à jour le 24 août 2015 bouye Clement Cunin

Un socket de (de l'anglais socket qui signifie « prise électrique » ou « soquet », c'est-à-dire un support d'ampoule), également appelé connecteur réseau ou interface de connexion est un élément logiciel qui permet la communication entre deux processus ou dans notre cas présent de faire dialoguer deux entités (distantes ou sur la même machine) via une session TCP. Les sockets sont un concept qui est apparu tout d'abord dans le système d'exploitation UNIX avant d’être généralisé par la suite dans les autres systèmes d'exploitation.

Il existe plusieurs implémentations des sockets en Java :

  • java.net.Socket - un socket régulier manipulable par votre logiciel et qui permet de dialoguer à travers le réseau avec une entité distante. Les clients ont avoir tendance à ouvrir directement des sockets en utilisant l'adresse d'un serveur et un port. Les serveurs vont quant à eux récupérer un socket sur chaque client qui se connecte sur leur socket serveur ;
  • java.net.ServerSocket - le socket serveur que la composante serveur de votre logiciel va ouvrir pour écouter sur un port de manière bloquante. Cette classe permet ensuite de récupérer un socket régulier par client connecté ;
  • java.net.ssl.SSLSocket - un socket régulier qui permet d'utiliser des transactions sécurisées encryptées ;
  • java.net.ssl.SSLServerSocket - le socket serveur permettant d'utiliser des transactions sécurisées encryptées sur votre serveur ;
  • java.nio.channels.SocketChannel - un socket régulier qui permet de faire des transactions non bloquantes en utilisant les canaux NIO ;
  • java.nio.channels.ServerSocketChannel - le socket serveur permettant d'utiliser des transactions non bloquantes en utilisant les canaux NIO sur votre serveur ;
  • java.net.DatagramSocket - permet d'utiliser des connexions datagramme ;
  • java.net.MulticastSocket - permet d'utiliser des connexions datagramme groupées.

Mis à jour le 27 août 2015 bouye

API Java classique
Pour créer un socket régulier, vous pouvez invoquer un des constructeurs de la classe java.net.socket en spécifiant, par exemple, le nom ou l’adresse IP d'un serveur ainsi que le port sur lequel le serveur est à l’écoute. Le socket est lié à des ressources natives et doit être fermé en fin de session en invoquant sa méthode close(). Il est également possible d'utiliser une construction try-with-resource.

Code Java : Sélectionner tout
1
2
3
4
try (Socket socket = new Socket(serveur, port)) {  
   // Dialogue entre le client et le serveur.  
   [...] 
}

À partir du JDK 1.4, vous pouvez également utiliser une des variantes de la méthode createSocket() de la classe java.net.SocketFactory :

Code Java : Sélectionner tout
1
2
3
4
try (Socket socket = SocketFactory.getDefault().createSocket(serveur, port)) {  
   // Dialogue entre le client et le serveur. 
   [...] 
}

Il est également possible d'obtenir un tel socket auprès d'un socket serveur à l’écoute sur un port.

Les sockets obtenus via l'API Java classique sont dits bloquants, c'est-à-dire, par exemple, que l’opération de lecture bloque le thread d’exécution tant que tout le contenu n'est pas entièrement lu. L’opération d’écriture peut également bloquer si le tampon sous-jacent est plein. Il vaut donc mieux gérer ce genre de socket dans son propre thread.

NIO
Vous pouvez invoquer une des variantes de la méthode statique open() de la classe java.nio.channels.SocketChannel ce qui créera votre socket :

Code Java : Sélectionner tout
1
2
3
4
try (SocketChannel socket = SocketChannel.open(new InetSocketAddress(serveur, port))) { 
    // Dialogue entre le client et le serveur. 
    [...] 
}

Note : invoquer open(new InetSocketAddress(serveur, port)) revient à faire :

Code Java : Sélectionner tout
1
2
SocketChannel socket = SocketChannel.open(); 
socket.connect(new InetSocketAddress(serveur, port));


Par défaut, les sockets ainsi créés sont bloquants c'est-à-dire que leurs opérations de connexion, de lecture et d’écriture bloqueront le thread d’exécution courant tant qu'elles ne sont pas terminées. Mais il est possible de configurer le socket pour qu'il passe en mode non bloquant ; ce qui fait que les méthodes peuvent retourner immédiatement (avant la fin de la connexion ou sans que la lecture ne soit complètement terminée ou que toutes les données ne soient écrites). Dans ce cas, le programmeur devra lui-même gérer des boucles pour tester l’état de retour de chaque opération et les relancer ou les compléter si besoin.

Mis à jour le 27 août 2015 bouye

API Java classique
Pour créer un socket serveur, vous pouvez invoquer un des constructeurs de la classe java.net.ServerSocket en spécifiant, par exemple, le port sur lequel le serveur est à l’écoute. Le socket est lié à des ressources natives et doit être fermé en fin de session en invoquant sa méthode close(). Il est également possible d'utiliser une construction try-with-resource.

Code Java : Sélectionner tout
1
2
3
4
try (ServerSocket serverSocket = new ServerSocket(port)) {  
   // Attendre une connexion d'un client.  
   [...] 
}

À partir du JDK 1.4, vous pouvez également utiliser une des variantes de la méthode createServerSocket() de la classe java.net.ServerSocketFactory :

Code Java : Sélectionner tout
1
2
3
4
try (ServerSocket serverSocket = ServerSocketFactory.getDefault().createServerSocket(port)) {  
   // Attendre une connexion d'un client.  
   [...] 
}

NIO
Vous pouvez invoquer une des variantes de la méthode statique open() de la classe java.nio.channels.ServerSocketChannel ce qui créera votre socket. Vous devez ensuite invoquer sa méthode bind() pour lier votre socket à un port d’écoute :

Code Java : Sélectionner tout
1
2
3
4
5
try (ServerSocketChannel serverSocket = ServerSocketChannel.open()) { 
    serverSocket.socket().bind(new InetSocketAddress(port)); 
    // Attendre une connexion d'un client.  
    [...] 
}

Mis à jour le 27 août 2015 bouye

API Java classique
Pour lire depuis un Socket, vous pouvez récupérer son flux d’entrée via sa méthode getInputStream().

Code Java : Sélectionner tout
1
2
3
4
5
try (Socket socket = clientSocket; 
        InputStream input = socket.getInputStream()) { 
    // Lire du contenu binaire. 
    [...] 
}

Ce flux est manipulable comme n'importe quel flux d’entrée, vous pouvez donc, si besoin, l'empaqueter dans un reader de manière à manipuler un flux de caractères :

Code Java : Sélectionner tout
1
2
3
4
5
try (Socket socket = clientSocket; 
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) { 
    // Lire du contenu sous forme de chaine de caractères. 
    [...] 
}

NIO
Lorsque votre SocketChannel a été ouvert, vous pouvez remplir un tampon avec les données qu'il contient. Ici, par exemple un java.nio.ByteBuffer permettra d’accéder au contenu du canal :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
try (SocketChannel socket = clientSocket) {  
    ByteBuffer buffer = ByteBuffer.allocate(48); 
    // Remplissage du tampon avec le contenu du canal. 
    int octetsLus = socket.read(buffer); 
    // Lecture du contenu du tampon. 
    [...] 
}

Mis à jour le 27 août 2015 bouye

API Java classique
Pour écrire sur un Socket, vous pouvez récupérer son flux de sortie via sa méthode getOutputStream().

Code Java : Sélectionner tout
1
2
3
4
5
try (Socket socket = clientSocket; 
        OutputStream output = socket.getOutputStream()) { 
    // Écrire du contenu binaire. 
    [...] 
}

Ce flux est manipulable comme n'importe quel flux de sortie, vous pouvez donc, si besoin, l'empaqueter dans un writer de manière à manipuler un flux de caractères :

Code Java : Sélectionner tout
1
2
3
4
5
try (Socket socket = clientSocket; 
        PrintWriter writer = new PrintWriter(socket.getOutputStream(), true)) { 
    // Écrire du contenu sous forme de chaine de caractères. 
    [...] 
}

NIO
Lorsque votre SocketChannel a été ouvert, vous pouvez remplir un tampon avec les données que vous souhaitez écrire sur le canal. Ici, nous allons, par exemple, écrire dans un java.nio.ByteBuffer que nous allons ensuite recopier dans le canal :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
try (SocketChannel socket = clientSocket) {  
    ByteBuffer buffer = ByteBuffer.allocate(48); 
    buffer.clear(); 
    // Remplissage du tampon. 
    [...] 
    // Écriture du tampon dans le canal. 
    buffer.flip(); 
    // Nous devons boucler tant qu'il reste des données dans le tampon. 
    while (buffer.hasRemaining()) { 
        socket.write(buffer); 
    } 
}

Mis à jour le 27 août 2015 bouye

Note : pour vous connecter sur un serveur tournant sur le même ordinateur que le client, vous pouvez utiliser la valeur « localhost » comme nom de serveur.

Socket bloquant
Pour coder les bases d'un logiciel client, vous devez créer un objet de type java.net.Socket en lui fournissant le nom ou l’adresse de votre serveur ainsi que le port sur lequel le serveur écoute. Le code minimal pour créer le squelette d'un logiciel client est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
// Nom ou adresse du serveur. 
String serveur = [...] 
// Port sur lequel tourne le serveur. 
int port = [...] 
try (Socket socket = new Socket(serveur, port); 
        OutputStream output = socket.getOutputStream(); 
        InputStream input = socket.getInputStream()) { 
    // Dialogue entre le client et le serveur. 
    [...] 
} catch (IOException ex) { 
    ex.printStackTrace(); 
}

NIO
Pour coder les bases d'un logiciel client, vous devez créer un objet de type java.nio.channels.SocketChannel en lui fournissant le nom ou l’adresse de votre serveur ainsi que le port sur lequel le serveur écoute. Le code minimal pour créer le squelette d'un logiciel client est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
// Nom ou adresse du serveur. 
String serveur = [...] 
// Port sur lequel tourne le serveur. 
int port = [...] 
try (SocketChannel socket = SocketChannel.open(new InetSocketAddress(serveur, port))) { 
     // Dialogue entre le client et le serveur. 
    [...] 
} catch (Exception ex) { 
    ex.printStackTrace(); 
}

Vous pouvez configurer votre socket pour qu'il devienne non bloquant en invoquant sa méthode configureBlocking() avec la valeur false en paramètre.

Attention : si votre socket régulier est configuré pour être non bloquant, ses méthodes connect(), read() et write() fonctionneront alors en mode asynchrone. Par exemple connect() peut retourner immédiatement lors de son invocation avant même que le socket ait fini de se connecter au serveur distant. Ou write() peut retourner avant que tous les octets aient été écrits dans le canal. Il faut donc utiliser ces méthodes dans des boucles qui testent leur valeur de retour et font des pauses entre chaque appel de méthode sur le socket.

Mis à jour le 24 août 2015 bouye

Note : dans cet exemple, le serveur gère la connexion d'un seul et unique client.

API Java classique
Pour coder les bases d'un logiciel serveur, vous devez créer un objet de type java.net.ServerSocket en lui fournissant le port sur lequel le serveur va écouter. Vous devez ensuite invoquer la méthode accept() de ce socket. Cet appel sera bloquant jusqu’à la connexion d'un client sur le serveur. Le code minimal pour créer le squelette d'un logiciel serveur est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
// Port sur lequel tourne le serveur. 
int port = [...] 
try (ServerSocket serverSocket = new ServerSocket(port)) { 
    // Cette appel bloque jusqu'à ce qu'un client se connecte. 
    try (Socket clientSocket = serverSocket.accept(); 
            OutputStream output = clientSocket.getOutputStream(); 
            InputStream input = clientSocket.getInputStream()) { 
        // Dialogue entre le client et le serveur. 
        [...] 
    } 
} catch (IOException ex) { 
    ex.printStackTrace(); 
}

NIO
Pour coder les bases d'un logiciel serveur, vous devez créer un objet de type java.nio.channels.ServerSocketChannel en lui fournissant le port sur lequel le serveur va écouter. Vous devez ensuite invoquer la méthode accept() de ce socket. Cet appel sera bloquant jusqu’à la connexion d'un client sur le serveur. Le code minimal pour créer le squelette d'un logiciel serveur est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
// Port sur lequel tourne le serveur.  
int port = [...]  
try (ServerSocketChannel serverSocket = ServerSocketChannel.open()) { 
    serverSocket.socket().bind(new InetSocketAddress(port)); 
    try (SocketChannel clientSocket = serverSocket.accept()) { 
        // Dialogue entre le client et le serveur. 
        [...] 
    } 
} catch (IOException ex) { 
    ex.printStackTrace(); 
}

Vous pouvez configurer votre socket serveur pour qu'il devienne non bloquant en invoquant sa méthode configureBlocking() avec la valeur false en paramètre.

Attention : si votre socket serveur est configuré pour être non bloquant, la méthode accept() retournera immédiatement même si aucun client ne s'est connecté. Il faudra alors utiliser cette méthode dans une boucle qui tester si le socket obtenu est null et qu'il effectue des pauses entre chaque appel à la méthode accept() du socket serveur.

Mis à jour le 24 août 2015 bouye

Le code du serveur que nous venons de vous donner ne peut gérer qu'un seul et unique client. Pour pouvoir gérer plusieurs clients connectés en même temps sur le serveur, vous allez devoir coder une boucle infinie qui relancera l'appel bloquant sur la méthode accept(). De plus, nous allons désormais gérer chaque nouveau client connecté dans son propre thread de manière à ne pas empêcher la connexion concurrente d'autres clients.

API Java classique
Le code minimal pour créer le squelette d'un logiciel serveur gérant plusieurs clients est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Port sur lequel tourne le serveur.  
int port = [...]  
try (ServerSocket serverSocket = new ServerSocket(port)) {  
    // Boucle infinie. 
    while (true) { 
        // Cet appel bloque jusqu'à ce qu'un client se connecte.  
        Socket clientSocket = serverSocket.accept(); 
        // Thread d’exécution séparé pour gérer le client qui vient de se connecter. 
        Thread clientThread = new Thread(() -> handleClient(clientSocket); 
        clientThread.start(); 
    } 
} catch (IOException ex) {  
    ex.printStackTrace();  
} 
  
[...] 
  
/** 
 * Gère un client.  
 * Cette méthode s’exécute dans un thread séparé de celui de la boucle principale du serveur. 
 * @param clientSocket Le socket permettant de dialoguer avec le client. 
 */ 
private void handleClient(Socket clientSocket) { 
    try (Socket socket = clientSocket); 
            OutputStream output = socket.getOutputStream();  
            InputStream input = socket.getInputStream()) {  
        // Dialogue entre le client et le serveur.  
        [...]  
    } catch (IOException ex) {  
        ex.printStackTrace();  
    } 
}

NIO bloquant
Le code minimal pour créer le squelette d'un logiciel serveur gérant plusieurs clients est :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Port sur lequel tourne le serveur.  
int port = [...]  
try (ServerSocketChannel serverSocket = ServerSocketChannel.open()) { 
    serverSocket.socket().bind(new InetSocketAddress(port)); 
    // Boucle infinie. 
    while (true) { 
        // Appel bloquant. 
        SocketChannel clientSocket = serverSocket.accept(); 
        // Thread d’exécution séparé pour gérer le client qui vient de se connecter.  
        Thread clientThread = new Thread(() -> handleClient(clientSocket)); 
        clientThread.start(); 
    } 
} catch (IOException ex) {  
    ex.printStackTrace();  
} 
  
[...] 
  
/** 
 * Gère un client.  
 * Cette méthode s’exécute dans un thread séparé de celui de la boucle principale du serveur. 
 * @param clientSocket Le socket permettant de dialoguer avec le client. 
 */ 
private static void handleClient(SocketChannel clientSocket) { 
    try (SocketChannel socket = clientSocket) { 
        // Dialogue entre le client et le serveur.  
        [...]  
    } catch (IOException ex) { 
        ex.printStackTrace(); 
    } 
}

Mis à jour le 24 août 2015 bouye

Depuis la version 5.0 du JDK, la machine virtuelle a introduit un mécanisme de sélection automatique de serveur proxy lors de la connexion au réseau. Ce mécanisme qui devrait être totalement transparent est malheureusement entaché de quelques bogues problématiques.

Le premier d'entre eux touche particulièrement les machines Windows qui utilisent le protocole NetBIOS, et provoque des connexions réseau anormalement longues (environ 5 secondes par connexion). Pour pallier ce bogue, il est possible de désactiver ce comportement en utilisant la classe ProxySelector :

Code Java : Sélectionner tout
ProxySelector.setDefault(null);

Mais un second bogue peut alors poser problème. Alors que le code ci-dessus est parfaitement valable, ce dernier peut provoquer une exception de type NullPointerException lors de la connexion.

Le premier de ces bogues a été corrigé dans l'update 6 de Java 5.0, alors que le second semble avoir été introduit dans une version ultérieure pour n'être corrigé que dans les premières versions du JDK 6. Ainsi, pour éviter tout problème quelle que soit la JVM cliente utilisée, il est nécessaire de vérifier la version exacte de la JVM avant d'utiliser le code ci-dessus, ce qui pourrait donner :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
// Si on utilise une JVM 1.5  
if ( "1.5".equals(System.getProperty("java.specification.version")) ) { 
    // On récupère le numéro exact de l'update (en supprimant le numéro de version majeure) : 
    String update = System.getProperty("java.version").replaceAll("^1.5.0_", ""); 
    try { 
        // Si on utilise une JVM antérieure à l'update 6 
        if (Integer.parseInt(update) < 6) { 
            ProxySelector.setDefault(null); 
        } 
    } catch (NumberFormatException e) { 
        e.printStackTrace(); 
    } 
}

Bien entendu, si votre application utilise le JDK 6 (ou supérieur), tout ceci est complètement inutile.

Mis à jour le 12 octobre 2006 adiGuba bulbo

Ligne de commande
La première solution consiste à préciser le proxy au démarrage de la JVM, idéal si une application ne gère pas cette option...

Code Console : Sélectionner tout
java -DproxySet=true -DproxyHost=nomproxy -DproxyPort=numport -Dhttp.nonProxyHosts="localhost|*.reseau.entreprise" test.MaClasse

Propriétés système
Ces options peuvent également être initialisées par le programme en modifiant les propriétés système.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
Properties prop = System.getProperties(); 
prop.setProperty("http.proxyHost", "172.28.48.1"); 
prop.setProperty("http.proxyPort", "8080"); 
prop.setProperty("http.nonProxyHosts", "localhost|*.reseau.entreprise"); 
prop.setProperty("https.proxyHost", "172.28.48.1"); 
prop.setProperty("https.proxyPort", "8080"); 
[...]

Proxy
À partir du JDK 5, vous pouvez également utiliser la classe java.net.Proxy qui peut être utilisée pour l'ouverture d'URL ou de sockets.

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
InetSocketAddress("172.28.48.1", 8080); 
Proxy proxy = new Proxy(Proxy.Type.HTTP, addr); 
// 
try (Socket socket = new Socket(proxy)) { 
    InetSocketAddress dest = new InetSocketAddress("server.example.org", 1234); 
    socket.connect(dest); 
    [...] 
} 
// 
URL url = new URL("http://java.developpez.com/"); 
URLConnection conn = url.openConnection(proxy); 
[...]

ProxySelector
À partir du JDK 5, vous pouvez spécifier un ou plusieurs proxy globaux pour la JVM via la classe java.net.ProxySelector. Lorsque votre code ouvre un socket ou une URL, le sélecteur de proxy sera invoqué pour décider quel proxy doit être utilisé par votre connexion. Cette classe dispose de plusieurs méthodes que vous pouvez surcharger :

  • List<Proxy> select(URI uri) - cette méthode est invoquée avant l'ouverture d'une nouvelle connexion de socket ou d'URL et permet d'effectuer un filtrage et de sélectionner un ou plusieurs proxy en fonction du protocole ou de l’adresse du serveur ou de la ressource cible de l'URI, etc. ;
  • void connectFailed(URI uri, SocketAddress sa, IOException ioe) - cette méthode est invoquée si la connexion échoue en utilisant le proxy sa. Elle permet de changer ou d'invalider le contenu de la liste des proxy retournée par les appels ultérieurs à select().


Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
ProxySelector.setDefault(new ProxySelector() { 
    private final List<Proxy> proxies = Arrays.asList(proxy); 
  
    @Override 
    public List<Proxy> select(URI uri) { 
        String protocol = uri.getScheme(); 
        if ("http".equalsIgnoreCase(protocol) || "https".equalsIgnoreCase(protocol)) { 
            return Collections.unmodifiableList(proxies); 
        } 
        // Il faut retourner cet élément si on n'utilise pas de proxy. 
        return Arrays.asList(Proxy.NO_PROXY); 
    } 
  
    @Override 
    public void connectFailed(URI uri, SocketAddress sa, IOException ioe) { 
        // Ici, ne fait rien. 
    } 
}

Authentification
À partir du JDK 1.2, si vous avez besoin de vous authentifier sur le proxy avec un nom d'utilisateur et un mot de passe, il faut utiliser la classe java.net.Authenticator pour spécifier ces informations. Il suffit d'utiliser la méthode setDefault() avec un Authenticator personnel :

Code Java : Sélectionner tout
1
2
3
4
5
Authenticator.setDefault(new Authenticator() { 
    protected PasswordAuthentication getPasswordAuthentication() {  
        return new PasswordAuthentication("user", "password".toCharArray()); 
    } 
});

Mis à jour le 6 juin 2002 adiGuba bentechno bouye Clement Cunin

JDK antérieurs au JDK 5
La commande ping nécessite des paquets ICMP ; or, les bibliothèques standards de Java ne supportent pas ICMP. Il n'est donc pas possible d'effectuer de ping en Java sans avoir recours à du code natif ou un programme externe.

JDK 5
Vous pouvez utiliser la méthode isReachable() de la classe InnetAdress qui indique si l'adresse est accessible. Les implémentations de cette méthode utilisent en général ICMP. En cas de problèmes d'accès ICMP, la méthode tente une connexion TCP sur le port 7 (echo).

Mis à jour le 28 août 2015 Clement Cunin knotty

Rien n'est spécifiquement prévu dans l'API pour gérer les connexions FTP. Mais à partir des RFC959 et 1123 et avec un peu de courage, vous pouvez faire votre propre client FTP. Heureusement, d'autres programmeurs sont passés avant vous, et des bibliothèques sont à votre disposition :

  • edtFTPj/Free - disponible sous licence LGPL, avec toutes les fonctions nécessaires ;
  • FTPConnection - de Bret Taylor, modifiee par Julian Robichaux  ; également libre et complète ;
  • Apache Commons Net - disponible sous licence Apache, propose les implémentations client de plusieurs protocoles de base d'Internet (dont le FTP).

Mis à jour le 7 avril 2003 Clement Cunin Pierre-Yves VAROUX

Vous trouverez toutes les informations nécessaires sur le lien suivant :

Mis à jour le 10 octobre 2015

https://java.net/projects/javamail/pages/Home

Il faut se connecter à l'URL et vérifier le code de réponse. On voit ainsi si l'URL est valide.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.io.*; 
import java.net.*; 
  
publique boolean testUrl(String url) { 
	try { 
		HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection(); 
		conn.connect(); 
  
		return conn.getResponseCode() == HttpURLConnection.HTTP_OK; 
	} catch (MalformedURLException e) {  
		return false;  
	} catch (IOException e) {  
		return false;  
	} 
}

Mis à jour le 2 juin 2007 romuluslepunk

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2016 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Java : Mickael Baron -