Java Socket (socket) est également communément appelée "socket", qui décrit les adresses IP et les ports, et est une poignée pour une chaîne de communication. Les applications font généralement des demandes ou répondent aux demandes de réseau via des "sockets".
Utilisez Socket pour réaliser la communication entre plusieurs clients et le même client; Tout d'abord, le client se connecte au serveur pour envoyer un message, le serveur traite le message après avoir reçu le message, puis répondez au client à un message après l'avoir terminé. J'ai écrit un code implémenté par le serveur et le client à travers ma propre pensée, dans l'espoir d'apprendre de tout le monde et de progresser ensemble.
Code de serveur
/ ** * Socket Server * Fonction Description: * * / / public class Server {/ ** * Entry * * @param args * @throws ioException * / public static void main (String [] args) lance ioException {// Pour simplicité, toutes les informations d'exception sont jetées intrus = 8899; // de définir un écouteur de service sur port 8899 serversectionnard = new SERVERSOCKET (port); System.out.println ("attendre la connexion au client ..."); tandis que (true) {// le serveur essaie de recevoir des demandes de connexion d'autres sockets. La méthode d'acceptation du serveur est une prise de blocage de blocage = server.accept (); / ** * Notre serveur gère les demandes de connexion du client de manière synchrone. Chaque fois que nous recevons une demande de connexion du client *, nous devons d'abord communiquer avec le client actuel avant de traiter la prochaine demande de connexion. Cela affectera sérieusement les performances du programme lorsqu'il y aura plus de concurrence. * À cette fin, nous pouvons le changer en traitement asynchrone suivant de la communication avec le client * /// Chaque fois qu'une prise est reçue, un nouveau thread est établi pour le gérer un nouveau thread (nouvelle tâche (socket)). Start ();} // Server.close ();} / ** * Classe de threads qui gère les demandes de socket * / socket de la classe Socket * / * Socket) {this.socket = socket;} @ override public void run () {try {handlersocket ();} catch (exception e) {e.printStackTrace ();}} / ** * Communiquer avec le Socket client * * @throws ioException * / private Void HandLedersock Les informations envoyées par le client à partir de l'informatique / ** * lors de la réception de données de l'entrée du socket, la lecture un peu comme celle ci-dessus est trop compliquée. * Parfois, nous passerons à l'utilisation de BufferedReader pour lire une ligne à la fois * * La méthode de lecture de BufferedReader lit une ligne à la fois. Cette méthode est bloquée. Le programme ne continuera pas à s'exécuter avant de lire une ligne de données. * Alors, quand Readline Lire une ligne? La méthode Readline ne pensera pas qu'une ligne a été lue, et * mettra fin au blocage et laissera le programme continuer à s'exécuter. * Ainsi, lorsque nous utilisons la ligne de lecture de BufferedReader pour lire les données, nous devons nous rappeler d'écrire des ruptures de ligne dans le flux de sortie correspondant (* sera automatiquement marqué comme fin après la fin du flux, et la ligne de lecture peut être reconnue). Après avoir écrit des ruptures de ligne, nous devons nous rappeler de rincer si le flux de sortie n'est pas fermé immédiatement, * seulement alors les données peuvent être vraiment écrites à partir du tampon. * / BufferedReader br = new BufferedReader (new InputStreamReader (socket.getInputStream (), "utf-8")); stringBuilder sb = new StringBuilder (); String temp; int index; while ((temp = br.readline ())! = Null) {if (index = temp.Indexof ("eof")! = -1) {/ the REP.Indexof ("eof")! = -1) {/ le Temp.Indexof ("EOF")! = -1) {/ The The RECHIDExof de SB.APPEND (temp.SubString (0, index)); Break;} sb.append (temp);} System.out.println ("Form Client [port:" + socket.getport () + "] Contenu du message:" + sb.tostring ()); // Répondre à la client "Utf-8"); writer.write (string.format ("Salut,% d. Le ciel est brillant et l'air est clair, le vent est lisse!", Socket.getport ())); writer.flush (); writer.close (); system.out.println ("à client [port:" + socket.getport () + "] Réponse du client avec succès "); br.close (); socket.close ();}}}Code client
import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.io.Reader;import java.io.Writer;import java.net.Socket;/** * Socket client* Function description: * * @author A wise and stupid little understanding* @Date August 30, 2016* @version 1.0 */public class Client {/** * Entry* @param args * / public static void main (String [] args) {// Ouvrir trois clients, un thread représente un client pour (int i = 0; i <3; i ++) {new thread (new Runnable () {@Override public void run () {try {testClient client) week-end? ", client.client.getLocalport ())); client.receive ();} catch (exception e) {e.printStackTrace ();}}}). Démarrer ();}} / ** * Factory qui produit le test client * / static Class TestClientFactory {public static TestClient CreateClient () lance une exception {retour TestClient ("127.0.0.1", 8899);}} / ** * Test Client * / Static Class Static TestClient {/ ** * Constructor * @param Host IP Adresse du serveur à connecter * @param port le port d'écoute correspondant du serveur à connecter * @throws exception * / public TestClient (String Host, int) trows exception exception { Socket (hôte, port); System.out.println ("Client [port:" + client.getLocalport () + "] Établir une connexion avec le serveur ...");} Socket Private Client; écrivain privé Send (String Msg) lance un message * @param msg * @throws exception * New outputStreamWriter (client.getOutputStream (), "utf-8");} writer.write (msg); writer.write ("eof / n"); writer.flush (); // après avoir écrit, n'oubliez pas de fluster System.out.println ("Client [port:" + client.getLocalport () + "] Message envoyé avec succès");} / **; recese () lève une exception {// lire après avoir écrit lecteur lecteur = new inputStreamReader (client.getInputStream (), "utf-8"); // définir le temps pour recevoir des données sur 10 secondes client.setsotimeout (10 * 1000); char [] chars = new Char [64]; int len; stringbuilder sb = new stringbuilder (); (len = len = Reader.read (Chars))! = -1) {sb.append (new String (Chars, 0, Len));} System.out.println ("Client [port:" + client.getLocalport () + "] Le message a été reçu, le contenu:" + sb.tostring ()); Reader.Close (); // Close la connexion writer.close (); client.close ();}}}Ensuite, simulons:
1. Exécutez d'abord le serveur
2. Ensuite, exécutez le client (ouvrez trois demandes du client)
Pour la démonstration, j'utilise l'outil Eclipse sur le serveur et l'outil IntelliJ Idea sur le client. Pour le moment, vous pouvez voir le message imprimé par le client sur la console
Un numéro de port représente un client. Revenons sur le message imprimé par le serveur sur la console.
Résumer
Ce qui précède est tout le contenu de cet article sur le socket de programmation Java implémentant plusieurs clients pour se connecter au même code de serveur. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez laisser un message et l'éditeur répondra à tout le monde à temps.