Java est un langage de programmation de haut niveau lancé par Sun Microsystems en mai 1995. Java peut s'exécuter sur plusieurs plates-formes, telles que Windows, Mac OS et d'autres versions de systèmes UNIX. En tant que représentant des langages de programmation statiques orientés objet, le langage Java implémente parfaitement la théorie orientée objet et permet aux programmeurs d'effectuer une programmation complexe avec une façon de penser élégante. "Tutoriel vidéo Java de la Geek Academy" vous emmènera dans le monde du langage Java, du plus profond au plus profond, du basique au avancé.
Adresse de lecture du cours : http://www.php.cn/course/275.html
Le style d'enseignement de l'enseignant :
Les cours de l'enseignant sont simples et approfondis, de structure claire, analysés couche par couche, imbriqués, rigoureux dans l'argumentation, rigoureux dans la structure et l'utilisation le pouvoir logique de la pensée pour attirer l'attention des élèves. Force, utiliser la raison pour contrôler le processus d'enseignement en classe. En écoutant les cours de l'enseignant, les étudiants acquièrent non seulement des connaissances, mais reçoivent également une formation à la réflexion, et sont également influencés et infectés par l'attitude académique rigoureuse de l'enseignant
Le point le plus difficile de cette vidéo est la communication Socket en Java :
1. Deux problèmes principaux dans la programmation réseau
L'un est de savoir comment localiser avec précision un ou plusieurs ordinateurs sur le réseau L'autre est de savoir comment transmettre des données de manière fiable et efficace après avoir trouvé l'hôte.
Dans le protocole TCP/IP, la couche IP est principalement responsable du positionnement des hôtes réseau et du routage de la transmission des données. L'adresse IP peut identifier de manière unique un hôte sur Internet.
La couche TCP fournit des mécanismes de transmission de données fiables (tcp) ou peu fiables (UDP) orientés application. C'est l'objet principal de la programmation réseau. Généralement, vous n'avez pas besoin de vous soucier de la façon dont la couche IP traite les données. .
Le modèle de programmation réseau actuellement le plus populaire est la structure client/serveur (C/S). Autrement dit, l'une des parties à la communication agit comme un serveur et attend que le client fasse une demande et réponde. Les clients s'adressent au serveur lorsqu'ils ont besoin de services. Le serveur fonctionne généralement toujours comme un processus démon, écoutant le port réseau. Une fois qu'il y a une demande client, il lancera un processus de service pour répondre au client et continuera en même temps à surveiller le port de service afin que les clients suivants. peut recevoir des services à temps.
Deuxièmement, deux types de protocoles de transmission : TCP ; UDP
TCP est l'abréviation de Transfer Control Protocol, qui est un protocole orienté connexion qui garantit une transmission fiable. Transmis via le protocole TCP, un flux de données séquentiel et sans erreur est obtenu. Une connexion doit être établie entre les deux sockets de l'expéditeur et du destinataire afin de communiquer sur la base du protocole TCP. Lorsqu'une socket (généralement un socket serveur) attend d'établir une connexion, l'autre socket peut demander qu'une connexion soit établie. Connexion établie, une fois ces deux prises connectées, elles peuvent effectuer une transmission de données bidirectionnelle et les deux parties peuvent effectuer des opérations d'envoi ou de réception.
UDP est l'abréviation de User Datagram Protocol. Il s'agit d'un protocole sans connexion. Chaque datagramme est une information indépendante, comprenant une adresse source complète ou une adresse de destination. Il est transmis sur le réseau de toutes les manières possibles. Le chemin est transmis vers la destination, donc si la destination peut être atteinte, le temps pour atteindre la destination et l'exactitude du contenu ne peuvent pas être garantis.
Comparez :
UDP : 1, les informations d'adresse complètes sont fournies dans chaque datagramme, il n'est donc pas nécessaire d'établir une connexion entre l'expéditeur et le destinataire.
2. Il existe une limite de taille lorsque UDP transmet des données. Chaque datagramme transmis doit être limité à 64 Ko.
3. UDP est un protocole peu fiable. Les datagrammes envoyés par l'expéditeur n'arrivent pas nécessairement au destinataire dans le même ordre
TCP : 1. Protocole orienté connexion, dans le socket Une connexion doit être effectuée. être établi avant la transmission des données entre eux, donc un temps de connexion
est requis dans TCP.
2. Limite de taille des données de transmission TCP. Une fois la connexion établie, les sockets des deux parties peuvent transmettre des données
volumineuses dans un format unifié.
3. TCP est un protocole fiable, qui garantit que le destinataire obtient complètement et correctement toutes les données envoyées par l'expéditeur.
Application :
1. TCP a une forte vitalité dans la communication réseau. Par exemple, la connexion à distance (Telnet) et le transfert de fichiers (FTP) nécessitent que des données de longueur variable soient transmises de manière fiable. Cependant, une transmission fiable a un prix : vérifier l'exactitude du contenu des données nécessitera inévitablement du temps de traitement informatique et de la bande passante du réseau. Par conséquent, la transmission TCP n'est pas aussi efficace que l'UDP.
2. UDP est simple à utiliser et nécessite moins de supervision, il est donc généralement utilisé pour les applications client/serveur dans les systèmes distribués avec une grande fiabilité dans les réseaux locaux. Par exemple, le système de visioconférence n'exige pas que les données audio et vidéo soient absolument correctes, pour peu que la continuité soit assurée. Dans ce cas, il est évidemment plus raisonnable d'utiliser UDP.
3. Programmation réseau Java basée sur Socket
1. Qu'est-ce que Socket
Deux programmes sur le réseau réalisent l'échange de données via une connexion de communication bidirectionnelle. bidirectionnel Une extrémité du lien est appelée Socket. Socket est généralement utilisé pour réaliser la connexion entre le client et le serveur. Socket est une interface de programmation très populaire pour le protocole TCP/IP. Un Socket est déterminé de manière unique par une adresse IP et un numéro de port.
Cependant, les types de protocoles pris en charge par Socket ne sont pas uniquement TCP/IP, il n'y a donc aucune connexion nécessaire entre les deux. Dans l'environnement Java, la programmation Socket fait principalement référence à la programmation réseau basée sur le protocole TCP/IP.
2. Le processus de communication Socket
Le côté serveur écoute pour voir s'il y a une demande de connexion sur un certain port. Le côté client envoie une demande de connexion au côté serveur, et le côté client. Le côté serveur envoie une demande de connexion au côté client. Une connexion est établie. Le côté serveur et le côté client peuvent communiquer entre eux via l'envoi, l'écriture et d'autres méthodes.
Pour un Socket entièrement fonctionnel, il doit contenir la structure de base suivante, et son processus de travail comprend les quatre étapes de base suivantes :
(1) Créer un Socket
( 2) Ouvrez le flux d'entrée/sortie connecté au Socket ;
(3) Effectuez des opérations de lecture/écriture sur le Socket selon un certain protocole
(4) Fermez le Socket (. Dans les applications pratiques, la fermeture affichée n'est pas utilisée, bien que de nombreux articles le recommandent, mais dans mon programme, cela peut n'avoir aucun impact car le programme lui-même est relativement simple et les exigences ne sont pas élevées)
3, Create Socket
Create Socket
java fournit deux classes, Socket et ServerSocket, dans le package java.NET, qui sont utilisées pour représenter respectivement le client et le serveur des connexions bidirectionnelles. Ce sont deux classes très bien encapsulées et très pratiques à utiliser. Sa méthode de construction est la suivante :
Socket(InetAddress address, int port); Socket(InetAddress address, int port, boolean stream); Socket(String host, int prot); Socket(String host, int prot, boolean stream); Socket(SocketImpl impl) Socket(String host, int port, InetAddress localAddr, int localPort) Socket(InetAddress address, int port, InetAddress localAddr, int localPort) ServerSocket(int port); ServerSocket(int port, int backlog); ServerSocket(int port, int backlog, InetAddress bindAddr)
Où adresse, hôte et port sont respectivement l'adresse IP, le nom d'hôte et le numéro de port de l'autre partie dans la connexion bidirectionnelle, le flux indique si le socket est un socket de flux ou un socket de datagramme, et localPort indique local Le numéro de port de l'hôte, localAddr et bindAddr sont l'adresse de la machine locale (l'adresse de l'hôte de ServerSocket), et impl est la classe parent du socket, qui peut être utilisée pour créer à la fois serverSocket et Socket. count représente le nombre maximum de connexions que le serveur peut prendre en charge. Par exemple : Learning Video Network http://www.php.cn
Socket client = new Socket("127.0.01.", 80);
ServerSocket server = new ServerSocket(80);Notez qu'il faut être prudent lors de la sélection du port. Chaque port fournit un service spécifique. Ce n'est qu'en indiquant le bon port que vous pourrez obtenir le service correspondant. Les numéros de port de 0 à 1023 sont réservés par le système. Par exemple, le numéro de port pour le service http est 80, le numéro de port pour le service telnet est 21 et le numéro de port pour le service FTP est 23. Par conséquent, lorsque nous choisissons un port numéro, il est préférable de choisir un numéro de port supérieur à 1023. numéro pour éviter les conflits.
Si une erreur survient lors de la création du socket, une IOException sera générée, qui devra être gérée dans le programme. Ainsi, lors de la création d'un Socket ou d'un ServerSocket, vous devez intercepter ou lever une exception.
4, Programme client/serveur simple
1. Programme client
import java.io.*;
import java.net.*;
public class TalkClient {
public static void main(String args[]) {
try{
Socket socket=new Socket("127.0.0.1",4700);
//向本机的4700端口发出客户请求
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
PrintWriter os=new PrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
String readline;
readline=sin.readLine(); //从系统标准输入读入一字符串
while(!readline.equals("bye")){
//若从标准输入读入的字符串为 "bye"则停止循环
os.println(readline);
//将从系统标准输入读入的字符串输出到Server
os.flush();
//刷新输出流，使Server马上收到该字符串
System.out.println("Client:"+readline);
//在系统标准输出上打印读入的字符串
System.out.println("Server:"+is.readLine());
//从Server读入一字符串，并打印到标准输出上
readline=sin.readLine(); //从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
}catch(Exception e) {
System.out.println("Error"+e); //出错，则打印出错信息
}
}
}2. Programme serveur
import java.io.*;
import java.Net.*;
import java.applet.Applet;
public class TalkServer{
public static void main(String args[]) {
try{
ServerSocket server=null;
try{
server=new ServerSocket(4700);
//创建一个ServerSocket在端口4700监听客户请求
}catch(Exception e) {
System.out.println("can not listen to:"+e);
//出错，打印出错信息
}
Socket socket=null;
try{
socket=server.accept();
//使用accept()阻塞等待客户请求，有客户
//请求到来则产生一个Socket对象，并继续执行
}catch(Exception e) {
System.out.println("Error."+e);
//出错，打印出错信息
}
String line;
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
PrintWriter os=newPrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
System.out.println("Client:"+is.readLine());
//在标准输出上打印从客户端读入的字符串
line=sin.readLine();
//从标准输入读入一字符串
while(!line.equals("bye")){
//如果该字符串为 "bye"，则停止循环
os.println(line);
//向客户端输出该字符串
os.flush();
//刷新输出流，使Client马上收到该字符串
System.out.println("Server:"+line);
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+is.readLine());
//从Client读入一字符串，并打印到标准输出上
line=sin.readLine();
//从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
server.close(); //关闭ServerSocket
}catch(Exception e){
System.out.println("Error:"+e);
//出错，打印出错信息
}
}
}5, Client/serveur programme qui prend en charge plusieurs clients
Le programme Client/Serveur précédent ne peut réaliser que le dialogue entre le Serveur et un client. Dans les applications pratiques, un programme permanent est souvent exécuté sur le serveur, qui peut recevoir des requêtes de plusieurs autres clients et fournir les services correspondants. Afin de réaliser la fonction de fourniture de services à plusieurs clients côté serveur, le programme ci-dessus doit être modifié et le multithreading est utilisé pour implémenter le mécanisme multi-client. Le serveur surveille toujours s'il y a des demandes client sur le port désigné. Une fois qu'une demande client est surveillée, le serveur démarrera un thread de service spécial pour répondre à la demande du client, et le serveur lui-même entrera en état d'écoute immédiatement après le démarrage du thread. . En attendant l'arrivée du prochain client.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
