Annuaire d'articles
1. Base de programmation réseau
1. Réseau et carte réseau
Le réseau est le premier moteur de l'informatique actuelle
. Il existe plusieurs cartes réseau sur chaque équipement informatique.
Chaque carte réseau possède une adresse matérielle et une adresse MAC uniques au monde.
2. Adresse IP : Chaque carte réseau/machine possède une ou plusieurs adresses IP
IPV4 : 192.168.0.100, chaque segment est compris entre 0 et 255
IPV6 : 128 bits de long, divisé en 8 segments, chaque segment est composé de 4 nombres hexadécimaux
L'adresse IP réservée à la machine : 127.0.0.1
Windows via la requête ipconfig, Linux/Mac via ifconfig
3. Port, 0-65535
0-1023, OS et occupé, 80 est Web, 23 est telent
1024-65535, des programmes généraux peuvent être utilisés (attention aux conflits)
La communication entre les deux machines s'effectue sur IP+Port,
Windows/Linux/Mac est interrogé par netstat -an
4. Public (World Wide Web/Internet) et Intranet (LAN)
Le réseau est en couches,
la couche la plus externe est le réseau public/Internet
et chaque couche en dessous est l'
adresse IP intranet. Vous pouvez utiliser
tracert sur chaque couche du réseau pour voir le relais d'accès de la machine actuelle et de la machine cible.
5. Protocole de communication de la couche transport
TCP (Transmission Control Protocol)
protocole de contrôle de transmission, protocole orienté connexion
Transmission de données fiable et sans erreur entre deux machines Transmission de
flux d'octets bidirectionnel
UDP (User Datagram Protocol)
protocole de datagramme utilisateur, le protocole sans connexion
ne garantit pas la fiabilité des données La
vitesse de transmission est rapide , et il peut également être utilisé dans un environnement réseau médiocre
6. Communication informatique
Les données sont envoyées depuis un port IP (expéditeur) et transportées vers un autre port IP (récepteur)
2. UDP : protocole de communication sans connexion et sans état
1. Caractéristiques
L'expéditeur envoie un message. Si le destinataire se trouve à destination, il peut être reçu. Sinon, le message sera perdu. L'
expéditeur ne peut pas savoir si le message a été envoyé avec succès
. Les avantages d'UDP sont la simplicité, les économies, et économie.
2. Idées
Le pipeline de données ds qui établit la communication
via DatagramSocket ds qui établit le conteneur de données dp
via DatagramPacket transmet le bytecode du message et la longueur du bytecode du message dans DatagramPacket
S'il s'agit de l'expéditeur, alors l'étiquette d'adresse entrante : destination IP+Port
via InetAddress.getByName ("IP ") La méthode d'envoi de l'adresse entrante
implémente l'envoi et la méthode de réception implémente la réception
. Le récepteur doit s'exécuter avant l'initiateur
3.démo：UdpRecv
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpRecv {
public static void main(String[] args) throws Exception
{
//定义管道为本机3000端口
DatagramSocket ds=new DatagramSocket(3000);
//定义字节数组存放信息
byte [] buf=new byte[1024];
//定义集装箱，用来封装信息
DatagramPacket dp = new DatagramPacket(buf,1024);
System.out.println("UdpRecv: 我在等待信息");
//等待信息，如果有信息过来，则会封装在dp中
//如果没有信息过来，则会造成阻塞
ds.receive(dp);
System.out.println("UdpRecv: 我接收到信息");
//dp.getAddress().getHostAddress()方法获取IP
//dp.getPort()方法获取Port
String strRecv=new String(dp.getData()) +
" from " + dp.getAddress().getHostAddress()+":"+dp.getPort();
//打印信息和信息的来源地址
System.out.println(strRecv);
//线程暂停1s
Thread.sleep(1000);
//设置将要发送的信息
String str="hello yh";
//定义集装箱，装入dp内容和长度并且贴了目的地
//目的地为127.0.0.1:3000
//str.getBytes()方法把str类型转化为byte类型
//str.length()
//地址标签：目的地IP+Port
DatagramPacket dp2=new DatagramPacket(str.getBytes(),str.length(),
InetAddress.getByName("127.0.0.1"),dp.getPort());
System.out.println("UdpRecv: 我要发送信息");
//发送信息
ds.send(dp2);
System.out.println("UdpRecv: 我发送信息结束");
//关闭管道
ds.close();
}
}
4.démo：UdpSend
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
public class UdpSend {
public static void main(String [] args) throws Exception
{
//DatagramSocket:通讯的数据管道
//定义管道
DatagramSocket ds = new DatagramSocket();
//定义将要发送的信息
String str = "hello henrik";
//定义集装箱，装入dp内容和长度并且贴了目的地
//目的地为127.0.0.1:3000
//str.getBytes()方法把str类型转化为byte类型
//str.length()
//地址标签：目的地IP+Port
DatagramPacket dp = new DatagramPacket(str.getBytes(),str.length(),
InetAddress.getByName("127.0.0.1"),3000);
System.out.println("UdpSend: 我要发送信息");
//发送信息
ds.send(dp);
System.out.println("UdpSend: 我发送信息结束");
//进程暂停1s
Thread.sleep(1000);
//定义字节数组存放信息
byte [] buf=new byte[1024];
//定义集装箱用来封装信息
DatagramPacket dp2 = new DatagramPacket(buf,1024);
System.out.println("UdpSend: 我在等待信息");
ds.receive(dp2);
System.out.println("UdpSend: 我接收到信息");
//dp.getAddress().getHostAddress()方法获取IP
//dp.getPort()方法获取Port
String str2 = new String(dp2.getData()) +
" from " + dp2.getAddress().getHostAddress()+":"+dp2.getPort();
//打印信息和信息的来源地址
System.out.println(str2);
//关闭管道
ds.close();
}
}
5. Effets
3. TCP : Il existe une connexion pour assurer un protocole de communication fiable
1. Idées
Le serveur crée un ServerSocket et attend une connexion
Le client crée un Socket,
le ServerSocket connecté au serveur reçoit la connexion, crée un Socket et établit une connexion dédiée avec le Socket du client, et le dialogue qui s'ensuit entre le serveur et le client ( cette paire de Sockets) sera en cours d'exécution sur un thread séparé (serveur),
le ServerSocket du serveur continue d'attendre une connexion
2. Caractéristiques
Lorsque le serveur attend une réponse, il est dans un état bloquant . Le
serveur peut répondre à plusieurs clients en même temps
. Chaque fois que le serveur accepte un client, il démarre un thread indépendant correspondant à celui-ci
. Le client et le serveur peut choisir de fermer le canal de la paire de Sockets
ServerSocket En tant que port du serveur, vous devez lier le port. S'il y a plusieurs cartes réseau, vous devez lier une adresse IP
Socket comme canal de transport. Le client écrit des données au flux d'entrée du socket, l'envoie au serveur et prend le serveur du flux de sortie du socket. données, côté serveur et vice versa
3.démo：TcpServer
import java.net.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class TcpServer
{
public static void main(String [] args)
{
try{
//驻守在8001端口
ServerSocket ss = new ServerSocket(8001);
//等待客户端连接
Socket s = ss.accept();
//阻塞提示
System.out.println("welcome to the java world");
//有人连接上打开输入流
InputStream ips = s.getInputStream();
//打开输出流
OutputStream ops = s.getOutputStream();
//同一个通道，服务端的输出流输入流就是客户端的输出流输入流
//输出一句话给客户端
ops.write("hello client".getBytes());
//从客户端读取一句话
BufferedReader br = new BufferedReader(new InputStreamReader(ips));
System.out.println("client said:"+br.readLine());
//关闭各对象
ips.close();
ops.close();
s.close();
ss.close();
} catch (IOException exception) {
exception.printStackTrace();
}
}
}
4.démo：TcpClient
import java.net.*;
import java.io.*;
public class TcpClient {
public static void main(String[] args) {
try {
//用地址标签创建通道，这里需要服务端先开启
Socket s = new Socket(InetAddress.getByName("127.0.0.1"), 8001);
//同一个通道，服务端的输出流就是客户端的输入流；服务端的输入流就是客户端的输出流
//开启通道的输入流
InputStream ips = s.getInputStream();
BufferedReader brNet = new BufferedReader(new InputStreamReader(ips));
//开启通道的输出流
OutputStream ops = s.getOutputStream();
//包装输出流
DataOutputStream dos = new DataOutputStream(ops);
//键盘录入信息
//System.in是一个位流，InputStreamReader转换为字符流，然后再使用BufferedReader为其增加缓冲功能
BufferedReader brKey = new BufferedReader(new InputStreamReader(System.in));
while (true)
{
String strWord = brKey.readLine();
//判断是否为换行，换行则表示结束
if (strWord.equalsIgnoreCase("quit"))
{
break;
}
else
{
System.out.println("I want to send: " + strWord);
//System.getProperty("line.separator")获取操作系统对应的换行符
dos.writeBytes(strWord + System.getProperty("line.separator"));
System.out.println("Server said: " + brNet.readLine());
}
}
//关闭对象
dos.close();
brNet.close();
brKey.close();
s.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
5. Effets
