Java Language
Sockets Java
Recherche…
Introduction
Les sockets sont une interface réseau de bas niveau qui aide à créer une connexion entre deux programmes, principalement des clients qui peuvent ou non s'exécuter sur le même ordinateur.
Socket Programming est l'un des concepts de réseautage les plus utilisés.
Remarques
Il existe deux types de trafic Internet:
1. TCP - Transmission Control Protocol 2. UDP - Protocole de datagramme utilisateur
TCP est un protocole orienté connexion.
UDP est un protocole sans connexion.
Le protocole TCP convient aux applications nécessitant une grande fiabilité et le temps de transmission est relativement moins critique.
UDP convient aux applications nécessitant une transmission rapide et efficace, comme les jeux. La nature sans état d'UDP est également utile pour les serveurs qui répondent à de petites requêtes provenant d'un grand nombre de clients.
En termes plus simples -
Utilisez le protocole TCP lorsque vous ne pouvez pas vous permettre de perdre des données et que le temps nécessaire pour envoyer et recevoir des données importe peu. Utilisez UDP lorsque vous ne pouvez pas vous permettre de perdre du temps et que la perte de données n'a pas d'importance.
Il existe une garantie absolue que les données transférées restent intactes et arrivent dans l’ordre dans lequel elles ont été envoyées en cas de TCP.
alors qu'il n'y a aucune garantie que les messages ou les paquets envoyés atteindraient du tout dans UDP.
Un serveur de retour d'écho TCP simple
Notre serveur TCP echo back sera un thread séparé. C'est simple comme c'est un début. Il ne fera que répéter ce que vous envoyez, mais sous forme de majuscule.
public class CAPECHOServer extends Thread{
// This class implements server sockets. A server socket waits for requests to come
// in over the network only when it is allowed through the local firewall
ServerSocket serverSocket;
public CAPECHOServer(int port, int timeout){
try {
// Create a new Server on specified port.
serverSocket = new ServerSocket(port);
// SoTimeout is basiacally the socket timeout.
// timeout is the time until socket timeout in milliseconds
serverSocket.setSoTimeout(timeout);
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
try {
// We want the server to continuously accept connections
while(!Thread.interrupted()){
}
// Close the server once done.
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Acceptez maintenant les connexions. Mettons à jour la méthode d'exécution.
@Override
public void run(){
while(!Thread.interrupted()){
try {
// Log with the port number and machine ip
Logger.getLogger((this.getClass().getName())).log(Level.INFO, "Listening for Clients at {0} on {1}", new Object[]{serverSocket.getLocalPort(), InetAddress.getLocalHost().getHostAddress()});
Socket client = serverSocket.accept(); // Accept client conncetion
// Now get DataInputStream and DataOutputStreams
DataInputStream istream = new DataInputStream(client.getInputStream()); // From client's input stream
DataOutputStream ostream = new DataOutputStream(client.getOutputStream());
// Important Note
/*
The server's input is the client's output
The client's input is the server's output
*/
// Send a welcome message
ostream.writeUTF("Welcome!");
// Close the connection
istream.close();
ostream.close();
client.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
// Close the server once done
try {
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
Maintenant, si vous pouvez ouvrir telnet et essayer de vous connecter, vous verrez un message de bienvenue.
Vous devez vous connecter au port que vous avez spécifié et à l'adresse IP.
Vous devriez voir un résultat similaire à celui-ci:
Welcome!
Connection to host lost.
Eh bien, la connexion a été perdue parce que nous l'avons terminée. Parfois, nous devrions programmer notre propre client TCP. Dans ce cas, nous avons besoin d'un client pour demander une entrée de l'utilisateur et l'envoyer sur le réseau, recevoir la saisie en majuscule.
Si le serveur envoie d'abord des données, le client doit d'abord lire les données.
public class CAPECHOClient extends Thread{
Socket server;
Scanner key; // Scanner for input
public CAPECHOClient(String ip, int port){
try {
server = new Socket(ip, port);
key = new Scanner(System.in);
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
DataInputStream istream = null;
DataOutputStream ostream = null;
try {
istream = new DataInputStream(server.getInputStream()); // Familiar lines
ostream = new DataOutputStream(server.getOutputStream());
System.out.println(istream.readUTF()); // Print what the server sends
System.out.print(">");
String tosend = key.nextLine();
ostream.writeUTF(tosend); // Send whatever the user typed to the server
System.out.println(istream.readUTF()); // Finally read what the server sends before exiting.
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
} finally {
try {
istream.close();
ostream.close();
server.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
Maintenant, mettez à jour le serveur
ostream.writeUTF("Welcome!");
String inString = istream.readUTF(); // Read what the user sent
String outString = inString.toUpperCase(); // Change it to caps
ostream.writeUTF(outString);
// Close the connection
istream.close();
Et maintenant, exécutez le serveur et le client, vous devriez avoir une sortie similaire à celle-ci
Welcome!
>
