java 网络编程总结

不念不忘少年蓝@ 2023-09-26 22:11 97阅读 0赞

**目录**

一、拾枝杂谈

1.网络通信 :

2.网络 :

3.IP :

4.IPv4的ip地址分类 :

5.域名和端口 :

6.网络协议 :

二、网络编程

1.InetAddress :

1° 常用方法 :

2° 代码演示 :

2.Socket :

1° 概述 :

2° 代码演示 :

eg1 : 客户端连接服务端

eg2 : 结束标记

eg3 : 网络传输文件

3.netstat:

4.UDP网络通信 :

--------------------

## 一、拾枝杂谈 ##

### 1.网络通信 : ###

> **网络通信是指，将一台设备（Host1）中的数据通过网络传输到另一台设备（Host2）**。**java.net包下提供了许多用于完成网络通信的类或接口**。
> 
> 相关流程图如下 :
> 
> ![5a3618480f424d649e52cbeb5dbf3a8c.png][]

### 2.网络 : ###

> **两台或两台以上的设备通过一定物理设备（交换机，网关服务器等等）连接起来构成了网络（强调多台计算机构成的网状结构）**。
> 
> 根据网络的覆盖范围及其复杂度的不同，**网络大致分为三类——**
> 
> **1° 局域网 :** 覆盖范围最小，可能是一个机房，一个公司的内网，也可能是一个学校的校园网。
> 
> **2° 城域网 :** 覆盖范围较大，可以覆盖整个城市。
> 
> **3° 广域网 :** 覆盖范围最大，可以覆盖整个国家，甚至覆盖全球。典型代表是万维网（World Wide Web，简称3w）。

### 3.IP : ###

> **IP全称Internet Protocol，网络协议；IP地址就是“IP address”。IP的作用是标识网络中的每台计算机（主机）**。
> 
> 在Windows操作系统下，可以在交互式命令接口（cmd）输入**ipconfig**指令来获取当前主机的ip地址。如下图所示 :
> 
> ![660ecb3f4569481f95f9e167ca8c4e67.png][]
> 
> ip又常见两种——IPv4和IPv6.
> 
> **1° IPv4协议****以“点分十进制（xx.xx.xx.xx)”表示ip地址**。即**用4个字节来表示4个数**，每个数的范围就是每个字节可以表示的范围（0~255）。
> 
> **IPv4协议下，ip地址由网络地址 + 主机地址组成**，比如上图画蓝线部分，“192.168.89.”表示网络地址，最后的“134”表示主机地址。
> 
> **2° IPv6协议**的诞生是为了**解决IPv4协议“网络地址资源受限”问题**，它是互联网工程任务组设计的**用于替代IPv4的下一代网络协议**（目前仍处于替代的过渡阶段）。IPv6的地址数量，号称可以为全世界的每一粒沙子编上一个地址。IPv6的诞生也解决了多种接入设备接入互联网的障碍。
> 
> IPv6协议下，ip地址一般由16进制表示，因此每两位就代表一个字节，**每个IPv6协议下的ip地址均有16个字节（128位）表示**，长度是IPv4协议下的四倍。

### 4.IPv4的ip地址分类 : ###

> IPv4协议下，ip地址由网络地址和主机地址构成，根据它们的权重不同，**IPv4协议的ip地址可分为A，B，C，D，E五类**。如下图所示 :
> 
> ![ebabd867933445eabafe7574f4a66417.png][]
> 
> PS : **127.0.0.1表示本机地址**。

### 5.域名和端口 : ###

>  **1° 域名**——公司拥有自己的主机，为了便于用户访问公司主机，**通过诸如HTTP协议将主机的ip地址映射为“域名”**。eg : "cn.bing.com"就是必应搜索的域名。域名相比ip地址更易记忆。
> 
>  **2° 端口**——**用于标注计算机上某个特定的网络程序（网络服务）的编号。不同的网络程序一般监听不同的端口**。
> 
> **端口以整数形式表示，表示范围是0~65535(2个字节表示，0~2^16 - 1)**。其中，**0~1024的端口已经被占用，因此，在网络开发中，不建议使用0~1024的端口**，eg：ssh--- 22，ftp(文件传输) --- 21，smtp(邮件) --- 25，http --- 80。
> 
> **常见网络程序的端口号——**
> 
>  ①mysql : 3306;
> 
>  ②sqlserver : 1433;
> 
>  ③oracle : 1521;
> 
>  ④tomcat : 8080;
> 
> **PS : 用户访问业务主机，实际是通过IP + 端口的形式访问的**；通过IP可以找到主机所在位置，通过端口可以使用主机上提供的对应网络服务。如下图所示 :
> 
> ![24838434889d4276a41045cea14c8465.png][]

### 6.网络协议 : ###

> **网络通信协议，通常指TCP/IP协议（全称“Transmission Control Protocol / Internet Protocol协议”）。中文是“传输控制协议 / 因特网互联协议”，又叫网络通信协议**。**TCP/IP协议是Internet最基本的协议，是Internet国际互联网络的基础**。简单地说，就是由网络层的IP协议和传输层的TCP协议组成。
> 
> **关于TCP和UDP的区别——**
> 
> **1° TCP : 传输控制协议**
> 
> **①**使用TCP协议前，需要建立TCP连接，形成数据传输通道;
> 
> **②**传输数据前进行了**"三次握手"**,因此是**可靠**的.
> 
> **③**在连接中可进行大量数据的传输;
> 
> **④**数据传输完毕后, 需释放掉已建立的连接,因此**效率低.**
> 
>  **eg : call**
> 
>  **2° UDP : 用户数据报协议**
> 
> **①**不需要建立连接, 而是将数据, 源, 目的封装成数据报;
> 
> **②**每个数据报的大小限制在了64kb内, 不适合大量数据的传输;
> 
> **③**因无需连接, 因此**不可靠**;
> 
> **④**数据传输完毕后, 无需释放资源(因为不面向连接), 因此**速度快.**
> 
>  **eg : message**

--------------------

## 二、网络编程 ##

### 1.InetAddress : ###

#### 1° **常用方法 :**  ####

>  **①getLocalHost : 获取当前主机的InetAddress对象，直接打印InetAddress对象默认输出结果为当前主机名 + 当前主机的ip地址（IPv4协议）。**
> 
>  **②getByName : 通过指定主机名获取对应的InetAddress对象。**
> 
>  **③getByName : 同上；也可以通过指定域名来获取对应的InetAddress对象。**
> 
>  **④getHostAddress : 返回当前InetAddress对象的IP地址。**
> 
>  **⑤getHostName : 返回当前InetAddress对象的主机名/域名。**

#### 2° **代码演示 :**  ####

以InetAddress\_Demo类为演示类，**代码如下 :**

package csdn.advanced.netEX;
    
    import java.io.IOException;
    import java.net.InetAddress;
    
    public class InetAddress_Demo {
        public static void main(String[] args) throws IOException {
            //1. 获取本机的InetAddress对象（静态方法getLocalHost())
            /*
                输出结果 : 当前主机名 + 当前主机的ip地址（IPv4协议）
             */
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println(localHost);
            System.out.println("==================");
    
            //2. 获取本机的InetAddress对象, 但通过指定主机名
            InetAddress localHost_copy = InetAddress.getByName("Cyan-RA9");
            System.out.println(localHost);
            System.out.println("==================");
    
            //3. 根据指定域名，给出对应的InetAddress对象
            InetAddress bingHost = InetAddress.getByName("cn.bing.com");
            InetAddress baiduHost = InetAddress.getByName("www.baidu.com");
            System.out.println(bingHost);
            System.out.println(baiduHost);
            System.out.println("==================");
    
            //4. 根据InetAddress对象，获取对应主机的IP地址
            String address = bingHost.getHostAddress();
            String address_ = baiduHost.getHostAddress();
            System.out.println(address);
            System.out.println(address_);
            System.out.println("==================");
    
            //5. 根据InetAddress对象，获取对应主机的主机名/域名（最终获取到的结果取决于主机的配置）
            String hostName = bingHost.getHostName();
            String hostName_ = baiduHost.getHostName();
            System.out.println(hostName);
            System.out.println(hostName_);
        }
    }

**运行结果 :**

![88c93bb0ba30413ab41e1cfb899a3807.png][]

### 2.Socket : ###

#### 1° 概述 : ####

> **Socket在网络编程中被称为“套接字”**；Socket在开发网络应用程序中被广泛采用，因此成为了事实上的标准。
> 
> **Socket是两台机器间实现通信的端点（比喻为"接口"），通信的两端都要有Socket。网络通信其实就是Socket间的通信**。
> 
> **Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。一般主动发起通信的的应用程序属于客户端；等待通信请求的属于服务端**。（**客户端程序和服务端程序一般位于不同的主机上**）。
> 
> **服务端要先运行起来**, 等待客户端的连接。

#### 2° 代码演示 : ####

#### **eg1 : 客户端连接服务端** ####

Server\_01**代码如下 :**

package csdn.advanced.netEX.tcp_1;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
        TCP InputStream / OutputStream No.1
     */
    public class Server_01 {
        public static void main(String[] args) throws IOException {
            //1.ServerSocket可以监听指定的端口（要求该端口没有被其他服务端程序监听）
            ServerSocket serverSocket = new ServerSocket(6666);
            System.out.println("服务端正监听6666端口，等待连接中......");
    
            //2.当有客户端连接被监听的端口时，返回Socket对象，程序继续运行。
            /*
                ServerSocket可通过accept方法返回多个Socket对象，
                适用于多个服务器连接客户端时的并发。
             */
            Socket socket = serverSocket.accept();
            System.out.println("Server's socket = " + socket);
    
            //3.若有客户端成功连接该服务端，读取客户端写入到数据通道中的数据, 并显示在控制台
            InputStream inputStream = socket.getInputStream();
    
            byte[] data = new byte[1024];
            int len;
            while ((len = inputStream.read(data)) != -1) {
                System.out.println(new String(data, 0, len));   //String类的一个带参构造！
            }
    
            //4.必须关闭流（服务端比客户端多关一个）
            inputStream.close();
            socket.close();
            serverSocket.close();
        }
    }

Client\_01**代码如下 :**

package csdn.advanced.netEX.tcp_1;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
        TCP InputStream / OutputStream No.1
     */
    public class Client_01 {
        public static void main(String[] args) throws IOException {
            /*
                1.通过“IP + 端口” 连接服务端。
                2.若连接成功，返回Socket对象。
             */
            Socket socket = new Socket(InetAddress.getLocalHost(), 6666);
            System.out.println("Client's socket = " + socket);
            /*
                3.连接成功后，通过Socket类对象的getOutputStream()方法，
                  获取和socket对象关联的字节输出流对象。
             */
            OutputStream outputStream = socket.getOutputStream();
            /*
                4.利用获取到的的字节输出流对象，将指定内容输出到数据传输流中。
             */
            outputStream.write("Cyan_RA9".getBytes());  //一次写入一个字节数组
            System.out.println("客户端退出......");
    
            //5.必须关闭流。
            outputStream.close();
            socket.close();
        }
    }

**运行效果 :**

![bf7412c022fb46359b85aee509ca49c3.png][]

#### **eg2 :**  结束标记 ####

Server\_02**代码如下 :**

package csdn.advanced.netEX.tcp_2;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
        TCP InputStreamReader / OutputStreamWriter No.2
     */
    public class Server_02 {
        public static void main(String[] args) throws IOException {
            //1.设置服务端程序的监听端口为8888
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务端程序正在监听8888端口，等待客户端连接......");
    
            //2.当有客户端连接成功时，通过accept方法返回Socket类对象
            Socket socket = serverSocket.accept();
            System.out.println("Server's socket = " + socket);
    
            //3.获取与socket对象关联的字节输入流对象，并利用转换流将其转换为字符输入流。
            InputStream inputStream = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(inputStream);
    
            //4.利用转换得到的字符输入流，读取客户端写入到数据通道中的数据。
            int data;
            while ((data = isr.read()) != -1) {
                System.out.print((char)data);
            }
    
            //5.获取与socket对象关联的字节输出流对象，并利用转换流将其转换为字符输出流。
            OutputStream outputStream = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(outputStream);
    
            //6.利用转换得到的字符输出流对象，将数据写入到数据通道中。
            osw.write("Hello, Client? ");
            //若使用字符流，需要使用flush方法手动刷新，否则数据无法写入数据通道！
            osw.flush();
            socket.shutdownOutput();    //设置写入结束标记
    
            //7.关闭流
            //osw.close();
            isr.close();
            socket.close();
            serverSocket.close();
    
            System.out.println("\n服务端退出......");
        }
    }

Client\_02**代码如下 :**

package csdn.advanced.netEX.tcp_2;
    
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
        TCP InputStreamReader / OutputStreamWriter No.2
     */
    public class Client_02 {
        public static void main(String[] args) throws IOException {
            //1.通过“IP + 端口”连接服务端，若连接成功，返回Socket类对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
            System.out.println("Client's socket = " + socket);
    
            //2.获取与socket对象关联的字节输出流对象，并利用转换流，将其转换为字符输出流。
            OutputStreamWriter osw =
                    new OutputStreamWriter(socket.getOutputStream());
            /**
             * 也可以使用BufferedWriter再包装一层,
             * 使用处理流之后，可以使用newLine方法作为结束的标志，但要求读取使用readLine方法。
             *  */
    
            //3.利用转换得到的字符输出流对象，向数据通道中写入数据。
            osw.write("Hello, Server?");
            osw.flush();
            /*
                若使用字符流，需要使用flush方法手动刷新，否则数据无法写入数据通道！
                shutdownOutput() 方法可以告诉服务端，发送的信息到此为止了。
             */
            socket.shutdownOutput();
    
            //4.获取与socket对象关联的字节输入流对象，并利用转换流，将其转换为字符输入流。
            InputStreamReader isr =
                    new InputStreamReader(socket.getInputStream());
    
            //5.利用转换得到的字符输入流对象，读取服务端写入到数据通道中的数据。
            char[] data = new char[1024];
            int cnt;
            while ((cnt = isr.read(data)) != -1) {
                String string = new String(data, 0, cnt);
                System.out.println(string);
            }
    
            //6.关闭流
            isr.close();
            //osw.close();
            socket.close();
    
            System.out.println("客户端退出......");
        }
    }

**运行结果 :**

![c894b64b36314d4d872a10e775523e03.png][]

#### **eg3 : 网络传输文件** ####

**以传入某图片为例**，**如下所示 :**

![7793561502e64cc9a1c67b99d2b64f9d.png][]

Server\_03类**代码如下 :**

package csdn.advanced.netEX.tcp_3;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
        TCP --- network transmission
        advanced --- BufferedXxx
     */
    public class Server_03 {
        public static void main(String[] args) throws IOException {
            //1.客户端监听端口
            ServerSocket serverSocket = new ServerSocket(7777);
            System.out.println("服务端正监听7777端口，等待客户端连接...");
    
            Socket socket = serverSocket.accept();
            System.out.println("Server's socket = " + socket);
    
            //2.获取与socket对象关联的字节输入流，读取客户端写入到数据通道中的数据。
            InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();//4.步骤
            BufferedOutputStream bos =
                    new BufferedOutputStream(new FileOutputStream("D:\\JAVA\\IDEA\\fileEX\\demo2.jpg"));
    
            byte[] data = new byte[1024];
            int cnt;
    
            //3.将读取到的图片写入到本地
            while ((cnt = inputStream.read(data)) != -1) {
                bos.write(data, 0, cnt);
            }
    
            //4.向客户端发送“收到图片”，并退出服务端。
            outputStream.write("Received the picture".getBytes());
            socket.shutdownOutput();    //结束标记
    
            //5.不要忘记关闭流（后打开的流先关闭）
            bos.close();
            outputStream.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
    
            System.out.println("服务端退出...");
        }
    }

Client\_03类**代码如下 :**

package csdn.advanced.netEX.tcp_3;
    
    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * TCP --- network transmission
     */
    public class Client_03 {
        public static void main(String[] args) throws IOException {
            //1.通过“IP + 端口”，连接服务端。
            Socket socket = new Socket(InetAddress.getLocalHost(), 7777);
            System.out.println("Client's socket = " + socket);
    
            //2.向服务端发送一张图片(把从客户端读取到的文件写入到数据通道中)
            BufferedInputStream bis =
                    new BufferedInputStream(new FileInputStream("D:\\JAVA\\IDEA\\fileEX\\demo.jpg"));
            InputStream inputStream = socket.getInputStream();//3.步骤
            OutputStream outputStream = socket.getOutputStream();
    
            byte[] data = new byte[1024];
            int cnt;
    
            while ((cnt = bis.read(data)) != -1) {
                outputStream.write(data, 0, cnt);
            }
            socket.shutdownOutput();    //结束标记
    
            //3.获取与socket对象关联的字节输入流，读取服务端写入到数据通道中的信息
            byte[] message = new byte[1024];
            while ((cnt = inputStream.read(message)) != -1) {
                String s = new String(message, 0, cnt);
                System.out.println(s);
            }
    
            //4.关闭流，客户端退出
            outputStream.close();
            inputStream.close();
            bis.close();
            socket.close();
    
            System.out.println("客户端退出...");
        }
    }

**运行效果 :**

![295cfe2ff283442ba82b008dde9ed7d2.png][]

![7d517f4f72f5498681324b5cbeabde5e.png][]

![6c9fa455edc4439ca8faff69a7250a68.png][]

### 3.netstat: ###

> **netstat -an** 指令可以**查看当前网络情况**，包括**端口监听和网络连接**情况；
> 
> **netstat -an | more** 指令可以**分页查看**当前网络情况（按下空格翻页，直到显示完毕，也可以通过**Ctrl + c快捷键**直接退出指令）。
> 
> **netstat指令需要在DOS系统下执行**（小黑框）。
> 
> 如下图所示 :
> 
> ![db00696d76084d2f8e7dc7cb93e56b29.png][]
> 
> 其中——
> 
> **①****Proto = Protocol，表示当前端口的协议。** 
> 
> **②****Local Address 和 Foreign Address 分别表示本机地址（服务端）和外部地址（客户端）， 前四位表示IP，第五位表示监听的端口**。
> 
> **③****State表示状态**，**Listening表示当前程序正在指定端口进行监听，等待客户端连接**；**Established表示当前程序监听的端口已有客户端连接**。

> **如果想查看正在监听端口的具体程序，需要使用管理员权限运行DOS，然后使用netstat -anb指令，****如下图所示 :** 
> 
> ![163839edd4ed425f98241a79bcf38b95.png][]

> **PS : 在客户端与服务端连接期间调用netstat指令，可以得到结论——**
> 
> **当客户端连接到服务器端后，实际上客户端也是通过一个端口与服务端进行通讯的，这个端口是TCP/IP协议来自动分配的**。

### 4.UDP网络通信 : ###

> **DatagramSocket类 和 DatagramPacket(数据报)类实现了基于UDP协议的网络通讯。UDC数据报是通过DatagramSocket套接字的send和receive方法来进行发送和接收的**；系统不保证数据报具体的发送情况。（一个数据报最大64kb）
> 
>  **DatagramPacket对象中封装了数据报，其中包含了数据、发送端的IP + 端口以及接收端的IP + 端口**。正因为每个数据报中都给出了完整的地址信息，因此UDP无需像TCP一样建立连接。**DatagramPacket类构造器如下 :** 
> 
> ![324c5badba3b42529d828a5738921e3b.png][]
> 
> **PS :** 
> 
> **1°** 在UDP网络通信中不再有服务端和客户端的概念，而是数据的发送端和接收端，并且**发送端和接收端不是固定的**。
> 
>  **2°** UDP编程中，接收数据(**receive**) 和 发送数据(**send**) 是通过DatagramSocket对象来完成的。
> 
> **3°** **在发送数据时，会先将数据打包到DatagramPacket对象中**；**在接收数据时，需要先对DatagramPacket对象进行拆包**。(**拆包**——getLength()，getData()，String带参构造)
> 
>  **4°** DatagramPacket对象可以指定端口来接收数据。
> 
> **5°** 最后需要**关闭DatagramSocket**。

**System.out.println("END---------------------------------------------------------------------------");**

[5a3618480f424d649e52cbeb5dbf3a8c.png]: https://img-blog.csdnimg.cn/5a3618480f424d649e52cbeb5dbf3a8c.png
[660ecb3f4569481f95f9e167ca8c4e67.png]: https://img-blog.csdnimg.cn/660ecb3f4569481f95f9e167ca8c4e67.png
[ebabd867933445eabafe7574f4a66417.png]: https://img-blog.csdnimg.cn/ebabd867933445eabafe7574f4a66417.png
[24838434889d4276a41045cea14c8465.png]: https://img-blog.csdnimg.cn/24838434889d4276a41045cea14c8465.png
[88c93bb0ba30413ab41e1cfb899a3807.png]: https://img-blog.csdnimg.cn/88c93bb0ba30413ab41e1cfb899a3807.png
[bf7412c022fb46359b85aee509ca49c3.png]: https://img-blog.csdnimg.cn/bf7412c022fb46359b85aee509ca49c3.png
[c894b64b36314d4d872a10e775523e03.png]: https://img-blog.csdnimg.cn/c894b64b36314d4d872a10e775523e03.png
[7793561502e64cc9a1c67b99d2b64f9d.png]: https://img-blog.csdnimg.cn/7793561502e64cc9a1c67b99d2b64f9d.png
[295cfe2ff283442ba82b008dde9ed7d2.png]: https://img-blog.csdnimg.cn/295cfe2ff283442ba82b008dde9ed7d2.png
[7d517f4f72f5498681324b5cbeabde5e.png]: https://img-blog.csdnimg.cn/7d517f4f72f5498681324b5cbeabde5e.png
[6c9fa455edc4439ca8faff69a7250a68.png]: https://img-blog.csdnimg.cn/6c9fa455edc4439ca8faff69a7250a68.png
[db00696d76084d2f8e7dc7cb93e56b29.png]: https://img-blog.csdnimg.cn/db00696d76084d2f8e7dc7cb93e56b29.png
[163839edd4ed425f98241a79bcf38b95.png]: https://img-blog.csdnimg.cn/163839edd4ed425f98241a79bcf38b95.png
[324c5badba3b42529d828a5738921e3b.png]: https://img-blog.csdnimg.cn/324c5badba3b42529d828a5738921e3b.png