Programmation réseau Java expliquée en détail avec des images et du texte

Cet article présente les théories liées aux réseaux et des exemples simples d'introduction à la programmation réseau Java

Cet article présente principalement l'architecture globale d'un réseau informatique et les fonctions de chaque couche.

• Le concept de réseau informatique

• Modèle de référence OSI

• Modèle de référence TCP/IP

• Protocole IP

• Protocole et port TCP

• Programme d'introduction à la programmation réseau Java

---

Ordinateur Le concept de réseau

Un réseau est une chose qui est interconnectée entre différents nœuds via des connexions. Par analogie, un réseau informatique est un système réseau puissant qui connecte des ordinateurs situés dans différents emplacements géographiques via des lignes de communication. Dans ce réseau, chaque ordinateur est un nœud.

Modèle de référence OSI

OSI (Open System Interconnection) est un ensemble d'architecture de réseau étudié par l'organisation ISO. Ce nom est bien choisi
Les noms et fonctions de chaque couche doivent être compris :

名称	功能
物理层	不要理解错了，这一层不包含什么网线、电缆的物理介质。这里只是规定网线和电缆的接口类型，信号电压等。使用bit传输
数据链路层	负责两个相邻节点间的路线，以帧为单位传输。典型设备交换机(Switch)
网络层	两台计算机传输数据可能会经过很多数据链路，网络层的作用就是选择最优的路线。典型设备就是路由器
传输层	提供两个端系统的会话的建立、维护和取消传输连接的功能。使用报文传输
会话层	管理进程间的会话过程，即建立、管理、终止进程间的会话。使用报文传输
表示层	对数据的加解密、解压缩和格式转换等。
应用层	这层就是和用户的具体应用交互。例如：收发E-mail等。

Modèle de référence TCP/IP

Car la structure du réseau OSI est trop superposé et trop compliqué, c'est pourquoi le protocole TCP/IP est né. Le protocole TCP/IP s'appuie également sur l'idée en couches de​​OSI, mais il n'est divisé qu'en quatre couches :

名称	功能
主机网络层	为上层提供一个访问接口
网络互联层	把IP数据包发送到目标主机。这一层使用的是IP协议，IP协议规定了数据包的格式，并且规定了为数据包寻找路由的流程。
传输层	使源主机和目标主机的进程可以进行会话。这一层定义了两种协议TCP和UDP协议。
应用层	TCP/IP模型将OSI参考模型中的会话层和表现层功能合并到应用层。

Les principales applications basées sur le protocole TCP sont les suivantes :

• FTP : Protocole de transfert de fichiers, qui permet le transfert de fichiers sur le réseau.
• TELNET : Protocole de terminal virtuel, permettant de se connecter à l'hôte distant B depuis l'hôte A.
• HTTP : Hypertext Transfer Protocol, permet au réseau de transmettre de l'hypertexte.
• HTTPS : Protocole de transfert hypertexte sécurisé.
• POP3 : permet aux utilisateurs d'accéder et de gérer le courrier et les dossiers de courrier sur le serveur Fortune.
• IMAP4 : Messaging Access Protocol version 4, permet aux utilisateurs d'accéder et de gérer le courrier et les dossiers de courrier sur le serveur Yuanyun.
• SMTP : Protocole d'envoi d'emails.

Protocole de couche application basé sur le protocole UDP :

• SNMP : Simple Network Management Protocol fournit un moyen standardisé de gérer les périphériques réseau locaux et distants et constitue une gestion centralisée distribuée. protocole dans un environnement centralisé.
• DNS : Domain Name System Protocol, qui convertit le nom de domaine de l'hébergeur en l'adresse IP correspondante.

Protocole IP

Chaque hôte d'un réseau IP (un réseau utilisant le protocole IP) possède une adresse IP unique, et l'adresse IP identifie chaque hôte du réseau. Une adresse IP est une séquence de nombres binaires de 32 bits. Par exemple : 192.168.3.4. L'adresse réseau est obtenue en combinant ET l'adresse IP avec le masque de sous-réseau. Si le masque de sous-réseau est 255.255.255.0, alors l'adresse réseau est : 192.168.3.0

Le processus d'envoi de paquets de données

IP est un protocole orienté paquet, c'est-à-dire que les données sont divisées en plusieurs petits paquets et transmises séparément. Les hôtes du réseau IP peuvent uniquement envoyer des paquets de données directement à d'autres hôtes du réseau local (c'est-à-dire des hôtes ayant des adresses IP similaires). L’hébergeur dispose en réalité de deux véritables adresses de natures différentes. Lorsque l'hôte A envoie un paquet à un autre hôte B sur le même réseau, il obtiendra l'adresse physique de l'autre partie via le protocole ARP (Address Resolution Protocol), puis donnera le paquet à l'autre partie. Le mécanisme de fonctionnement du protocole ARP est que l'hôte A diffuse un message ARP sur le réseau : "Recherche d'un hôte avec l'adresse 192.166.3.5." L'hôte B avec cette adresse IP répondra et indiquera à A son adresse physique.

Lorsque l'hôte A envoie un paquet à l'hôte B sur un autre réseau :
L'hôte A utilise le protocole ARP pour trouver l'adresse physique du routeur sur le réseau local et transmet le paquet au routeur. Le routeur traite le paquet de données comme suit :

1. Si le cycle de vie du paquet de données a expiré, le paquet de données est rejeté.

2. Recherchez dans la table de routage, en donnant la priorité aux hôtes dans la table de routage. Si un hôte avec l'adresse IP cible est trouvé, le paquet de données est envoyé à l'hôte.

3. Si la correspondance avec l'hôte échoue, continuez à rechercher la table de routage, faites correspondre la table de routage du sous-réseau et si une table de routage correspondante est trouvée, transférez le paquet vers ce routeur.

4. Si la correspondance du routeur sur le même sous-réseau échoue, continuez à rechercher dans la table de routage pour faire correspondre le routeur sur le même réseau. Si un routeur correspondant est trouvé, le paquet de données sera transféré. au routeur.

5. Si la correspondance ci-dessus échoue, la route par défaut est recherchée. Si la route par défaut existe, le paquet de données est envoyé selon la route par défaut, sinon le paquet de données est rejeté.
   L'organigramme est le suivant :
   

Nom de domaine

IP est une chaîne de chiffres et a aucun sens. Un nom de domaine est une chaîne significative de caractères ou de chiffres correspondant à une adresse IP. Par exemple : www.google.com
La correspondance entre nom de domaine et IP nécessite un système de résolution de nom de domaine pour convertir le nom de domaine en IP. Le serveur DNS peut résoudre ce problème.

URL (Uniform Resource Locator)

URL (Uniform Resource Location) est une méthode d'adressage mise en place spécifiquement pour identifier l'emplacement des ressources sur le réseau. L'URL se compose généralement de 3 parties :

应用层协议://主机IP地址或域名/资源所在路径/资源名

Par exemple : http://www.php.cn/ où http fait référence à Hypertext Transfer Protocol, blog.csdn.net est le nom de domaine du serveur web, /article/details/ est le chemin de la page web, 54962975 Il s'agit du fichier de la page web correspondant.

Protocole et port TCP

Lorsque le protocole IP envoie des données, divers problèmes se produiront pendant le processus de transmission des données. Cela entraîne une perte de paquets ou un ordre incorrect des paquets. Le protocole TCP permet aux processus sur deux hôtes de communiquer de manière fluide sans se soucier de la perte de paquets ou des paquets dans le désordre. TCP suit l'ordre des paquets et les réassemble dans le bon ordre s'ils sont erronés. Si le paquet est perdu, TCP demandera à l'hôte source de renvoyer le paquet.

Port

Le protocole TCP permet aux processus sur deux hôtes de communiquer en douceur, mais il y a plus d'un processus sur l'hôte. TCP utilise des ports pour distinguer les processus. Un port n'est pas un périphérique physique, mais une adresse logique utilisée pour identifier un processus. La plage de ports de l'ordinateur va de 0 à 65 535, parmi lesquels les ports 0 à 1 023 sont généralement attribués à certains services. Les détails sont les suivants :

服务	端口	协议
文件传输服务	21	FTP
远程登录服务	23	TELENET
邮件传输服务	25	SMTP
万维网超文本传输服务	80	HTTP
访问邮件远程邮件服务	110	POP3
互联网消息存取服务	143	IMAP4
安全的超文本传输服务	443	HTTPS
安全的远程登录服务	992	TELNETS
安全互联网消息存取服务	993	IMAPS

Java网络编程入门程序

Java网络程序都建立在TCP/IP协议基础上，在应用层实现。传输层向应用层提供了套接字Socket接口，Socket封装了下层的数据传细节，应用层的程序通过Socket来建立与远程主机的连接，以及数据传输，如下图所示：

在Java中，有3种套接字类：java.net.Socket、java.net.ServerSocket 和 java.net.DatagramSocket 。其中Socket 和 ServerSocket 建立在TCP协议上，DatagramSocket 类建立在UDP协议基础上。我们创建EchoServer和EchoClient两个类，我们通过ServerSocket和Socket来编写。

创建EchoServer类

在服务端通过一直监听端口，来接收客户程序的连接请求。在服务器程序中，先创建一个ServerSocket对象，在构造方法中指定监听的端口：

ServerSocket server = new ServerSocket(8080);

ServerSocket构造器负责在操作系统中将当前进程注册为服务进程。服务器程序调用ServerSocket的accept()方法来监听端口，等待客户端的连接，如果接收到连接，则accept()方法返回一个Socket对象，这个Socket对象与客户端的Socket对象形成了一条通信线路：

Socket socket = server.accept();

Socket提供了getInputStream()方法和getOutputStream()方法，分别返回输入流InputStream对象和输出流OutputStream对象。程序只需向输出流写入东西，就能向对方发送数据；只需从输入流读取数据，就能接收到数据。如下图：

EchoServer 类代码如下：

/**
 * 服务端 服务端类
 *
 */public class EchoServer {


    private ServerSocket serverSocket;    
    public EchoServer(int port) {        
    try {            this.serverSocket = new ServerSocket(port);
            System.out.println("start server success,start port:"+port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    /**
     * 获取BufferedReader包装类
     * 
     * @param socket
     * @return
     * @throws IOException
     */
    private BufferedReader getReader(Socket socket) throws IOException {        
    return new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }    /**
     * 获取PrintWriter包装类，
     * 
     * @param socket
     * @return
     * @throws IOException
     */
    private PrintWriter getWriter(Socket socket) throws IOException {        
    // 每写一行自动刷新
        return new PrintWriter(socket.getOutputStream(), true);
    }    public void service() {        while (true) {
            Socket socket = null;            try {
                socket = serverSocket.accept();
                System.out.println("new connect,address is:" + socket.getInetAddress() + " port is:" + socket.getPort());
                BufferedReader reader = getReader(socket);
                PrintWriter writer = getWriter(socket);
                String msg = null;                
                while ((msg = reader.readLine()) != null) {                    
                // 读取一行
                    System.out.println("client request  msg: " + msg);
                    writer.println(echo(msg));                    
                    if ("bye".equalsIgnoreCase(msg)) {                        
                    break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{                
            if(socket!=null){                    
            try {                        
            //关闭会话连接
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }    private String echo(String msg) {        return "get request msg is '" + msg+"'";
    }    public static void main(String[] args) {        new EchoServer(8080).service();
    }
}

EchoServer类的最主要的方法就是service()方法，它不断登录客户的连接请求。当serverSocket.accept()返回一个Socket对象时，表示与一个客户端建立了连接。

创建EchoClient类

在EchoClient程序中，为了与EchoClient通信，需要先创建一个Socket对象：

String host="localhost";int port = 8080;new Socket(host, port);

host表示Server进程所在服务器的地址，port表示Server进程监听的端口。当参数host为’localhost’时，表示服务端和客户端在同一台机器上。下面是EchoClient类的源码：

public class EchoClient {
    private Socket socket;    
    public EchoClient(String host,int port){        
    try {            this.socket = new Socket(host, port);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    /**
     * 获取BufferedReader包装类
     * 
     * @param socket
     * @return
     * @throws IOException
     */
    private BufferedReader getReader(Socket socket) throws IOException {        
    return new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }    /**
     * 获取PrintWriter包装类，
     * 
     * @param socket
     * @return
     * @throws IOException
     */
    private PrintWriter getWriter(Socket socket) throws IOException {        
    // 每写一行自动刷新
        return new PrintWriter(socket.getOutputStream(), true);
    }    public void talk(){        try {
            BufferedReader reader = getReader(socket);
            PrintWriter writer = getWriter(socket);
            BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
            String msg = null;            
            while((msg=localReader.readLine())!=null){
                writer.println(msg);
                System.out.println("server response msg:"+reader.readLine());                
                if("bye".equalsIgnoreCase(msg)){                    
                break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{            
        if(socket!=null){                
        try {
                    socket.close();
                    System.out.println("has been disconnected");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }    public static void main(String[] args) {        
    new EchoClient("localhost", 8080).talk();
    }
}

在EchoClient类中最重要的是talk()方法，该方法不断读取用户从控制台输入的字符串，然后将它发送到EchoServer，在把EchoServer返回的数据打印在控制台。如果输入’bye’字符串，就会结束与EchoServer的通信，调用socket.close()方法端口连接。
具体运行如下图，一个是服务端一个是客户端的控制台：

总结

简单介绍了一下网络的理论知识和TCP/IP协议。并使用Java实现了一个网络通信程序。

 以上就是Java网络编程由浅入深一图文详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！