0% found this document useful (0 votes)
246 views13 pages

Travaux Pratiques: Exercice 1 (Sockets UDP)

1. The document describes exercises for building socket applications in Java. 2. The first exercise involves creating a UDP client that sends messages to a UDP server, which receives the messages and displays them. Code examples are provided for both the UDP client and server. 3. The second exercise involves creating a TCP client and server where the client sends messages to the server, which echoes the messages back. Code examples are provided for both the TCP client and server. 4. The third exercise tasks the reader with modifying the TCP server to handle multiple clients simultaneously using threads. Hints are given about building on the single-client TCP server code.

Uploaded by

Aba
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
246 views13 pages

Travaux Pratiques: Exercice 1 (Sockets UDP)

1. The document describes exercises for building socket applications in Java. 2. The first exercise involves creating a UDP client that sends messages to a UDP server, which receives the messages and displays them. Code examples are provided for both the UDP client and server. 3. The second exercise involves creating a TCP client and server where the client sends messages to the server, which echoes the messages back. Code examples are provided for both the TCP client and server. 4. The third exercise tasks the reader with modifying the TCP server to handle multiple clients simultaneously using threads. Hints are given about building on the single-client TCP server code.

Uploaded by

Aba
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 13

Travaux Pratiques

Sockets en Java

Exercice 1 (Sockets UDP)

Ecrire un serveur qui écoute qu’un client lui envoie un message puis il l’affiche.

Solution
Coté client :
package sockUDP; 
/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.*; 
 
public class UDPEchoClient { 
/*Adresse IP du serveur*/ 
private static InetAddress host; 
//Port du serveur 
private static final int PORT = 1234; 
// Datagram Socket 
private static DatagramSocket dtgrSocket; 
//Emission/Réception des paquets UDP 
private static DatagramPacket inPkt, outPkt; 
//Mémoire tampon contenant les données 
private static byte[] buff; 
//Variable stockant le contenu du message 
private static String msg = "", msgIn = ""; 
   
public static void main(String[] args) 

try{ 
host = InetAddress.getLocalHost(); 

catch(UnknownHostException e){ 
System.out.println("Host not found!"); 
System.exit(1); 

run(); 

   
private static void run(){ 
try{ 
dtgrSocket = new DatagramSocket(); 
BufferedReader userEntry; 
userEntry = new BufferedReader(new 
InputStreamReader(System.in)); 
do{ 
System.out.println("Entrer le message !"); 
msg = userEntry.readLine(); 
if(!msg.equals("BYE")){ 
outPkt = new DatagramPacket(msg.getBytes(), 
msg.length(), host, PORT); 
dtgrSocket.send(outPkt); 
buff = new byte[256]; 
inPkt = new DatagramPacket(buff, 
buff.length); 
dtgrSocket.receive(inPkt); 
msgIn = new String(inPkt.getData(), 0, 
inPkt.getLength()); 
System.out.println("Serveur: " + msgIn); 

}while(!msg.equals("BYE")); 

catch(IOException e){ 
e.printStackTrace(); 

finally{ 
dtgrSocket.close(); 


1. Coté serveur :
package sockUDP; 
 
/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.*; 
/*UDP server class.*/ 
 
public class UDPEchoServer { 
/*port used by the server.*/ 
 
private static final int PORT = 1234; 
/*the datagram socket specific to UDP.*/ 
private static DatagramSocket dgramSocket; 
/*incoming and outgoing packets objects.*/ 
private static DatagramPacket inPkt, outPkt; 
/*packet data buffer.*/ 
private static byte[] buffer; 
 
public static void main(String[] args) { 
System.out.println("Opening port...\n"); 
try { 
/*create the datagram socket*/ 
dgramSocket = new DatagramSocket(PORT); 
} catch (SocketException e) { 
/*handle potential exceptions.*/ 
System.out.println("Error attach port!"); 
System.exit(1); 

run(); 

/*run() performs the main task of the server.*/ 
 
private static void run() { 
try { 
/*buffers for the messages to be sent and 
received.*/ 
String msgIn, msgOut; 
/*number of messages.*/ 
int numMsgs = 0; 
do { 
/*create the packet buffer.*/ 
buffer = new byte[256]; 
/*create the incoming packet.*/ 
inPkt = new DatagramPacket(buffer, 
buffer.length); 
/*receive the packet from the client.*/ 
dgramSocket.receive(inPkt); 
/*retrieve the sender’s IP address.*/ 
InetAddress cliAddress = inPkt.getAddress(); 
/*retrieve the sender’s port number.*/ 
int cliPort = inPkt.getPort(); 
/*store the content of the message.*/ 
msgIn 
= new String(inPkt.getData(), 0, 
inPkt.getLength()); 
System.out.println("Message received."); 
/*increment the message number.*/ 
numMsgs++; 
/*generate the outgoing message.*/ 
msgOut = ("Msg " + numMsgs + ": " + msgIn); 
/*create the outgoing packet.*/ 
outPkt = new DatagramPacket(msgOut.getBytes(), 
msgOut.length(), cliAddress, cliPort); 
/*send the outgoing packet to the client.*/ 
dgramSocket.send(outPkt); 
} while (true); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
/*close the socket and release its resources.*/ 
dgramSocket.close(); 



Compiler et exécuter ces programmes sur deux machines distinctes.

Exercice 2
Coté serveur (TCPEchoServer.java)
package sockTCP; 
/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.*; 
/*TCP-based echo server*/ 
 
public class TCPEchoServer { 
/*server socket*/ 
 
private static ServerSocket servSock; 
/*server port*/ 
private static final int PORT = 1234; 
 
public static void main(String[] args) { 
System.out.println("Opening port\n"); 
try { 
/*Create the server socket*/ 
servSock = new ServerSocket(PORT); 
} catch (SocketException e) { 
/*handle potential exceptions*/ 
System.out.println("Error attach port!"); 
System.exit(1); 
} catch (IOException e) { 
/*handle potential exceptions*/ 
System.out.println("Error create socket!"); 
System.exit(1); 

/*perform the echo service indefinitely*/ 
do { 
run(); 
} while (true); 

 
private static void run() { 
/*data socket*/ 
Socket sock = null; 
try { 
/*listen for incoming connections*/ 
sock = servSock.accept(); 
/*create a socket buffer reader*/ 
BufferedReader in = new BufferedReader( 
new 
InputStreamReader(sock.getInputStream())); 
/*create the socket writer*/ 
PrintWriter out = new PrintWriter( 
sock.getOutputStream(), true); 
int numMsgs = 0; 
/*read from the data socket*/ 
String msg = in.readLine(); 
while (!msg.equals("BYE")) { 
System.out.println("Message received."); 
numMsgs++; 
out.println("Message " + numMsgs + ": " + msg); 
msg = in.readLine(); 

out.println(numMsgs + " messages received."); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
/*close the socket*/ 
try { 
sock.close(); 
} catch (IOException e) { 
e.printStackTrace(); 



Coté client (TCPEchoClient.java)

/* 
* To change this license header, choose License Headers in 
Project Properties. 
* To change this template file, choose Tools | Templates 
* and open the template in the editor. 
*/ 
package sockTCP; 
 
/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.*; 
 
public class TCPEchoClient { 
/*server IP*/ 
 
private static InetAddress host; 
/*server port*/ 
private static final int PORT = 1234; 
 
public static void main(String[] args) { 
System.out.println("Opening port\n"); 
try { 
/*create server IP address object*/ 
host = InetAddress.getLocalHost(); 
} catch (UnknownHostException e) { 
System.out.println("Host not found!"); 
System.exit(1); 

run(); 

 
private static void run() { 
Socket sock = null; 
try { 
/*create data socket*/ 
sock = new Socket(host, PORT); 
/*create socket reader and writer*/ 
BufferedReader in = new BufferedReader(new 
InputStreamReader(sock.getInputStream())); 
PrintWriter out = new PrintWriter( 
sock.getOutputStream(), true); 
/*Set up stream for user entry*/ 
BufferedReader reader 
= new BufferedReader(new 
InputStreamReader(System.in)); 
/*storage for message and response message*/ 
String msgOut, msgIn; 
do { 
System.out.print("Entrer le message: "); 
/*read user message*/ 
msgOut = reader.readLine(); 
/*send the message*/ 
out.println(msgOut); 
/*read the response*/ 
msgIn = in.readLine(); 
System.out.println("SERVEUR> " + msgIn); 
} while (!msgOut.equals("BYE")); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
/*close the data socket*/ 
try { 
sock.close(); 
} catch (IOException e) { 
e.printStackTrace(); 



Compiler et exécuter les programmes ci-dessus sur deux machines différentes

Exercice 3 : Serveur TCP multi-client


Pour cela on réalise d’abord un serveur mono-client ensuite le serveur multi-client sera en réalité
plusieurs threads exécutant chacun un serveur mono-client.

Code serveur mono-client (SingleTCPEchoServer.java)

package sockTCP; 
 
/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.Socket; 
/*single-threaded server class*/ 
/*handles client communication*/ 
 
public class SingleTCPEchoServer extends Thread { 
 
/*client data socket*/ 
private static Socket sock; 
/*server port*/ 
private static final int PORT = 1234; 
/*BufferReader used to read data from data socket*/ 
private BufferedReader in; 
/*PrinterWriter used to write to the data socket*/ 
private PrintWriter out; 
/*Constructor for the single threaded server*/ 
 
public SingleTCPEchoServer(Socket s) 
throws IOException { 
/*set the data socket*/ 
sock = s; 
/*create the BufferReader from data socket*/ 
in = new BufferedReader(new InputStreamReader( 
sock.getInputStream())); 
/*create the PrintWriter for data socket*/ 
out = new PrintWriter( 
sock.getOutputStream(), true); 
/*If any of the above calls throws an exception, 
the caller will close the socket. 
Otherwise the thread will close it.*/ 
/*call the run() method*/ 
start(); 

/*run() method performs the actual task*/ 
 
public void run() { 
try { 
int numMessages = 0; 
/*read message from the data socket (client)*/ 
String msg = in.readLine(); 
/*verify if the message is BYE*/ 
while (!msg.equals("BYE")) { 
System.out.println("Message received."); 
/*count the number of messages received*/ 
numMessages++; 
/*send the reply message to the client*/ 
out.println("Message " + numMessages 
+ ": " + msg); 
/*read the next message*/ 
msg = in.readLine(); 

/*at this point BYE has been received*/ 
/*the server reports the number of received 
messages*/ 
out.println(numMessages + " messages received."); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
try { 
System.out.println("\n Closing connection"); 
/*close the data socket*/ 
sock.close(); 
} catch (IOException e) { 
System.out.println("Unable to disconnect!"); 
System.exit(1); 


} /*run()*/ 
 

package sockTCP; 

/** 

* @author ddiongue 
*/ 
import java.io.*; 
import java.net.*; 
 
/*Class implementing the multi-threaded echo server.*/ 
/*This server receives a message from the clients 
*and replies with the same message back. 
*/ 
public class MultiTCPEchoServer { 
/*The server socket is defined as a class member.*/ 
 
private static ServerSocket servSock; 
/*The port number is defined as a member.*/ 
/*The server will listen on this port.*/ 
private static final int PORT = 1234; 
/*Data socket is defined as a member.*/ 
/*Socket to be used for */ 
/*communication with the client.*/ 
Socket sock = null; 
/*Constructor.*/ 
 
public MultiTCPEchoServer() { 

/*The main function to be run 
*when the server application stars.*/ 
 
public static void main(String[] args) 
throws IOException { 
System.out.println("Opening port\n"); 
try { 
/*Create the server socket to listen on PORT*/ 
servSock = new ServerSocket(PORT); 
} catch (IOException e) { 
/*Handles potential exceptions 
*thrown while the server socket is created.*/ 
/*Most common exception is triggered 
*when the chosen port is already used*/ 
System.out.println("Port error!"); 
System.exit(1); 

/*At this point the server socket 
*was successfully created.*/ 
try { 
/*main server loop.*/ 
do { 
/*Server accepts connections from client.*/ 
/*The Accept method blocks 
*until a connection occurs.*/ 
Socket socket = servSock.accept(); 
try { 
/*Create a single-threaded server.*/ 
/*This will handle the client.*/ 
new SingleTCPEchoServer(socket); 
} catch (IOException e) { 
/*Handle potential exceptions.*/ 
/*As the creation of the 
*single-threaded server failed, 
*communication with the client can not 
start, 
*so the data socket is closed. 
*/ 
socket.close(); 

} while (true); 
} finally { 
/*When the server end its operation, 
*the server socket is closed. 
*/ 
servSock.close(); 


Exercice 4 

Le serveur attend de multiples requêtes du client. Le client envoie de multiples 


requêtes au serveur. Le serveur répond par reçu. 

Le serveur : 

* To change this template file, choose Tools | Templates 


* and open the template in the editor. 
*/ 
package sockets; 
 
/** 

* @author ddiongue 
*/ 
 

public class Serveur  

{
public static void main(String args[]) throws Exception {  

String str; 
ServerSocket ssoc; 
ssoc = new ServerSocket(9999); 
while(true) 

System.out.println("En attente..."); Socket soc = 
ssoc.accept(); System.out.println("Socket accepte");  

InputStream is = soc.getInputStream(); DataInputStream dis = 


new DataInputStream(is);  

System.out.println("Lecture du socket"); str = dis.readUTF(); 


System.out.println("RECU: "+str);  

soc.close(); 

} }  

Le client : 

* To change this template file, choose Tools | Templates 


* and open the template in the editor. 
*/ 
package sockets; 
 
/** 

* @author ddiongue 
*/ 
 
public class Client 

static public void main(String args[]) throws Exception {  

while(true) 

DataInputStream in = new DataInputStream(System.in); 
System.out.print("> ");
System.out.flush();
String valeur= 
in.readLine();  
Socket soc = new Socket(InetAddress.getLocalHost(),9999);  

OutputStream os=soc.getOutputStream(); DataOutputStream dos=new 


DataOutputStream(os);  

dos.writeUTF(valeur); 
soc.close(); 

} }  

You might also like