- Écrire un programme Java qui utilise des sockets pour créer un serveur qui renvoie la date et l’heure actuelles aux clients qui se connectent.
- Écrire un programme Java qui utilise des sockets pour créer un client qui envoie une chaîne de caractères à un serveur et affiche une réponse simple.
- Écrire un programme Java qui utilise des sockets pour créer un serveur qui renvoie un message fixe aux clients qui se connectent. Le message doit être personnalisable et doit pouvoir être modifié facilement dans le code.
Serveur :
javaCopy codeimport java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(5000);
System.out.println("Server started");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("New client connected");
ClientHandler clientHandler = new ClientHandler(socket);
clientHandler.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientHandler extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
out.println("Welcome to the server");
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received message: " + inputLine);
out.println("Message received: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Client :
javaCopy codeimport java.io.*;
import java.net.*;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 5000);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
String serverMessage = in.readLine();
System.out.println("Server message: " + serverMessage);
BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
String userInputLine;
while ((userInputLine = userInput.readLine()) != null) {
out.println(userInputLine);
serverMessage = in.readLine();
System.out.println("Server message: " + serverMessage);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Le programme serveur crée une socket serveur sur le port 5000 et accepte les connexions des clients. Pour chaque nouveau client, il crée un nouveau thread ClientHandler qui gère la communication avec ce client. Le serveur envoie un message de bienvenue au client et écoute ensuite les messages envoyés par le client. Pour chaque message reçu, il affiche le message dans la console et renvoie un message de confirmation au client.
Le programme client se connecte au serveur en créant une socket client sur l’adresse IP localhost et le port 5000. Il lit le message de bienvenue envoyé par le serveur et affiche ce message dans la console. Ensuite, il lit l’entrée utilisateur depuis la console et envoie le message au serveur. Il attend ensuite une réponse du serveur et l’affiche dans la console. Le programme client continue à écouter les entrées utilisateur et à envoyer les messages au serveur jusqu’à ce que l’utilisateur ferme la console.
Serveur :
import java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(5000);
System.out.println("Server started");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("New client connected");
ClientHandler clientHandler = new ClientHandler(socket);
clientHandler.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientHandler extends Thread {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received message: " + inputLine);
out.println("Message received: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Client :
import java.io.*;
import java.net.*;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 5000);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
String userInputLine;
while ((userInputLine = userInput.readLine()) != null) {
out.println(userInputLine);
String serverMessage = in.readLine();
System.out.println("Server message: " + serverMessage);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Le programme serveur crée une socket serveur sur le port 5000 et accepte les connexions des clients. Pour chaque nouveau client, il crée un nouveau thread ClientHandler qui gère la communication avec ce client. Le serveur écoute les messages envoyés par le client et pour chaque message reçu, il l'affiche dans la console et renvoie un message de confirmation au client. Le programme client se connecte au serveur en créant une socket client sur l'adresse IP localhost et le port 5000. Il lit l'entrée utilisateur depuis la console et envoie le message au serveur. Il attend ensuite une réponse du serveur et l'affiche dans la console. Le programme client continue à écouter les entrées utilisateur et à envoyer les messages au serveur jusqu'à ce que l'utilisateur ferme la console.
Serveur :
import java.io.*;
import java.net.*;
import java.util.*;
public class Server {
private static Set<PrintWriter> clients = new HashSet<>();
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(5000);
System.out.println("Server started");
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("New client connected: " + clientSocket.getInetAddress().getHostAddress());
PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true);
clients.add(writer);
new Thread(new ClientHandler(clientSocket, writer)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void broadcast(String message) {
for (PrintWriter client : clients) {
client.println(message);
}
}
private static class ClientHandler implements Runnable {
private Socket clientSocket;
private PrintWriter writer;
public ClientHandler(Socket clientSocket, PrintWriter writer) {
this.clientSocket = clientSocket;
this.writer = writer;
}
@Override
public void run() {
BufferedReader reader;
try {
reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println("Received message from client " + clientSocket.getInetAddress().getHostAddress() + ": " + line);
broadcast(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Client :
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 5000);
System.out.println("Connected to server");
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
new Thread(new ServerHandler(reader)).start();
Scanner scanner = new Scanner(System.in);
while (true) {
String message = scanner.nextLine();
writer.println(message);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static class ServerHandler implements Runnable {
private BufferedReader reader;
public ServerHandler(BufferedReader reader) {
this.reader = reader;
}
@Override
public void run() {
String line;
try {
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Le programme serveur crée une socket serveur sur le port 5000 et accepte les connexions des clients. Pour chaque nouveau client, il crée un nouveau thread de gestion de client (ClientHandler) qui lit les messages envoyés par le client et les envoie à tous les autres clients en appelant la méthode broadcast.
La méthode broadcast envoie le message à tous les clients connectés en utilisant leur PrintWriter.
Le programme client se connecte au serveur en créant une socket client sur l’adresse IP localhost et le port 5000. Il crée également un nouveau thread de gestion de serveur (ServerHandler) qui lit les messages envoyés par le serveur et les affiche dans la console.
Le client demande à l’utilisateur de saisir un message dans la console et l’envoie au serveur en utilisant le PrintWriter. Il continue à demander à l’utilisateur de saisir des messages tant que le programme s’exécute.
Lorsqu’un message est reçu par le serveur à partir d’un client, le serveur l’affiche dans la console et l’envoie à tous les autres clients en appelant la méthode broadcast.
Notez que pour que les clients puissent se connecter au serveur, ils doivent être sur la même machine ou être en mesure d’accéder à l’adresse IP du serveur à partir d’un réseau. Si vous souhaitez exécuter le serveur sur une machine distante, vous devez spécifier son adresse IP dans le code client.
