Pour simplifier l'envoi d'une commande par un client et la réception d'un flux de donnée à partir d'un serveur, voici un exemple de class.
Communication par sockets avec JAVA
La class SocketClient est une class de bas niveau et communique directement avec le socket du poste de travail. Les deux principales fonctions sont l'envoient d'une commande à un serveur distant et la reception du message.import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
/**
* Communication socket coté client
* http://www.fobec.com/java/911/communication-client-serveur-avec-sockets.html
* @author Fobec 2010
*/
public class SocketClient {
private Socket socket = null;
//par defaut port 80 internet
final private int port = 80;
//par defaut yimeout de 5 secondes
final private int timeout = 5000;
/**
* Se connecter à un serveur
* @param address String domaine du serveur (google.com)
* @throws UnknownHostException
* @throws IOException
*/
public void open(String address) throws UnknownHostException, IOException {
this.open(address, this.port, this.timeout);
}
/**
* Se connecter à un serveur
* @param address String domaine du serveur (google.com)
* @param port int port de communication
* @throws UnknownHostException
* @throws IOException
*/
public void open(String address, int port) throws UnknownHostException, IOException {
this.open(address, port, this.timeout);
}
/**
* Connecter à un serveur
* @param address String domaine du serveur (google.com)
* @param port int port de communication
* @param timeout int délai d'attente
* @throws UnknownHostException
* @throws IOException
*/
public void open(String address, int port, int timeout) throws UnknownHostException, IOException {
this.socket = new Socket(InetAddress.getByName(address), port);
this.socket.setSoTimeout(timeout);
}
/**
* Déconnecter du serveur
* @throws IOException
*/
public void close() throws IOException {
this.socket.close();
}
/**
* Envoyer une demande et receptionner la réponse
* @param command String message à envoyer au serveur
* @return String réponse du serveur
* @throws IOException
* @throws SocketTimeoutException
*/
public String send(String command) throws IOException, SocketTimeoutException {
BufferedReader inStream = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
PrintWriter outStream = new PrintWriter(new OutputStreamWriter(this.socket.getOutputStream()));
inStream = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
outStream = new PrintWriter(new OutputStreamWriter(this.socket.getOutputStream()));
StringBuilder sb = new StringBuilder();
outStream.print(command);
outStream.print("rn");
outStream.flush();
String line = null;
while ((line = inStream.readLine()) != null&&!line.equals(".")) {
sb.append(line);
sb.append("n");
}
outStream.close();
inStream.close();
return sb.toString();
}
}
Receptionner des données d'un serveur
A titre d'exemple, créons une class héritée à partir de SocketClient pour lister les groupes accessibles sur un forum NNTP. (Exemple news.gmane.org sur le port 119)import java.io.IOException;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @author Fobec 2010
*/
public class NNTPClient extends SocketClient {
/**
* Lister les groupes disponibles sur un serveur NNTP
* @param server String nom du serveur
* @return String nom des groupes
*/
public String ListGroup(String server) {
String list="";
try {
this.open(server, 119, 30000);
list= this.send("LIST");
} catch (UnknownHostException ex) {
Logger.getLogger(NNTPClient.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(NNTPClient.class.getName()).log(Level.SEVERE, null, ex);
}
return list;
}
/**
* créer la class
* @param args
*/
public static void main(String[] args) {
NNTPClient nntpClient = new NNTPClient();
System.out.print(nntpClient.ListGroup("news.gmane.org"));
}
}
Toutes les communications sur un réseau passe par la connexion à un socket. Si l'on peut, je trouve que de programmer soi-même l'envoi puis la réception de données vers un serveur distant est formateur.
De plus le principe de communication via un socket en JAVA reste le même pour une application de chat, de partage de fichier ou encore pour un logiciel de domotique.
