Table des matières
préface:
En programmation Java, l'utilisation du protocole TCP pour la communication Socket est un scénario très courant. Cet article présentera en détail comment implémenter TCP pour envoyer et recevoir des messages Socket en Java, et utiliser le mode multithread pour améliorer l'efficacité de la communication.
texte:
1. Créez un serveur :
Tout d’abord, nous devons créer un serveur pour traiter la demande de connexion Socket reçue. Voici les étapes à mettre en œuvre :
- Créez un objet ServerSocket et spécifiez le numéro de port d'écoute.
- Utilisez la méthode accept() pour surveiller la demande de connexion du client et créez un nouveau thread pour chaque connexion à traiter.
- Dans le thread, utilisez la méthode getInputStream() de l'objet Socket pour obtenir le flux d'entrée et lire le message envoyé par le client.
- Mettre en œuvre la logique métier et traiter les messages reçus.
- Utilisez la méthode getOutputStream() de l'objet Socket pour obtenir le flux de sortie et envoyer un message de réponse au client.
- Fermez la connexion Socket et les ressources associées.
2. Créez un client :
Ensuite, nous devons créer un client pour envoyer des messages Socket au serveur. Voici les étapes à mettre en œuvre :
- Créez un objet Socket et spécifiez l'adresse IP et le numéro de port du serveur.
- Utilisez la méthode getOutputStream() de l'objet Socket pour obtenir le flux de sortie et envoyer des messages au serveur.
- Implémentez la logique métier et envoyez les messages qui doivent être transmis.
- Utilisez la méthode getInputStream() de l'objet Socket pour obtenir le flux d'entrée et lire le message de réponse du serveur.
- Fermez la connexion Socket et les ressources associées.
3. Mode multithread :
Dans l'implémentation côté serveur ci-dessus, nous avons créé un nouveau thread pour chaque connexion afin de traiter les messages. De cette manière, les demandes de plusieurs clients peuvent être traitées simultanément, améliorant ainsi l'efficacité de la communication. Voici les étapes à mettre en œuvre :
- Créez une classe d'implémentation de l'interface Runnable et implémentez la méthode run().
- Dans la méthode run(), implémentez la logique côté serveur : surveillez les connexions client, recevez des messages, traitez les messages et envoyez des réponses.
- Dans le thread principal côté serveur, créez un pool de threads (ThreadPoolExecutor) pour gérer l'exécution des threads.
- Utilisez la méthode execute() du pool de threads pour soumettre des tâches, et chaque fois qu'il y a une nouvelle demande de connexion, créez une nouvelle tâche et exécutez-la.
- Fermez le pool de threads et les ressources associées.
exemple de code
Bien entendu, ce qui suit est un exemple de code simple qui montre comment implémenter l'envoi et la réception de messages Socket TCP en Java (mode multithread) :
Exemple de code côté serveur :
import java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(12345);
System.out.println("Server started, waiting for client...");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("Client connected: " + socket.getInetAddress().getHostAddress());
Thread thread = new Thread(new ClientHandler(socket));
thread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static class ClientHandler implements Runnable {
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String message = reader.readLine();
System.out.println("Received message from client: " + message);
// 处理消息（这里仅做回显）
String response = "Server: " + message.toUpperCase();
writer.write(response);
writer.newLine();
writer.flush();
System.out.println("Sent response to client: " + response);
// 关闭连接
socket.close();
System.out.println("Connection closed");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Exemple de code côté client :
Envoyer des messages TCP en mode synchrone
import java.io.*;
import java.net.*;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 12345);
System.out.println("Connected to server");
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String message = "Hello from client";
writer.write(message);
writer.newLine();
writer.flush();
System.out.println("Sent message to server: " + message);
String response = reader.readLine();
System.out.println("Received response from server: " + response);
// 关闭连接
socket.close();
System.out.println("Connection closed");
} catch (IOException e) {
e.printStackTrace();
}
}
}
mode asynchrone
Voici un exemple de code permettant au client d'envoyer des messages Socket de manière asynchrone et de recevoir des messages de réponse du serveur :
import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 12345);
System.out.println("Connected to server");
// 异步发送消息
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Void> sendFuture = executorService.submit(() -> {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String message = "Hello from client";
writer.write(message);
writer.newLine();
writer.flush();
System.out.println("Sent message to server: " + message);
return null;
});
// 异步接收响应
Future<String> receiveFuture = executorService.submit(() -> {
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String response = reader.readLine();
System.out.println("Received response from server: " + response);
return response;
});
// 等待发送和接收完成
sendFuture.get();
String response = receiveFuture.get();
// 关闭连接
socket.close();
executorService.shutdown();
System.out.println("Connection closed");
} catch (IOException | InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
Dans cet exemple de mode asynchrone, nous utilisons ExecutorServicepour créer un pool de threads et utilisons submit()la méthode pour effectuer des tâches d'envoi et de réception de manière asynchrone. FutureObjet utilisé pour obtenir le résultat d'une tâche asynchrone.
De cette manière, le client peut envoyer des messages et recevoir des réponses en parallèle, améliorant ainsi l'efficacité de la communication. Veuillez noter que dans l'application réelle, vous devrez peut-être modifier et ajuster le code en fonction de besoins spécifiques pour répondre aux exigences du projet.
Dans l'exemple ci-dessus, le serveur écoute le port 12345, accepte la demande de connexion du client et crée un nouveau thread pour chaque connexion à traiter. L'extrémité client se connecte à l'extrémité serveur, envoie un message et reçoit la réponse de l'extrémité serveur. Le serveur convertit uniquement le message envoyé par le client en majuscules et le renvoie.
Veuillez noter que dans les applications réelles, vous devrez peut-être modifier et étendre le code en fonction de besoins spécifiques pour répondre à des scénarios et à des exigences fonctionnelles plus complexes.
en conclusion:
Grâce aux étapes ci-dessus, nous pouvons implémenter TCP pour envoyer et recevoir des messages Socket en Java et utiliser le mode multithread pour améliorer l'efficacité de la communication. Cela peut répondre aux besoins de concurrence à grande échelle, permettant au serveur de traiter les demandes de plusieurs clients en même temps.
Il convient de noter que dans les applications pratiques, nous devons également prendre en compte des problèmes tels que les anomalies du réseau et la sécurité de la transmission des données, et effectuer le traitement et l'optimisation correspondants.
J'espère que cet article vous aidera à comprendre comment envoyer et recevoir des messages Socket en mode TCP et en mode multithread en Java. Si vous avez des questions, n'hésitez pas à me les poser. Si vous aimez cet article, aimez-le et collectionnez-le.