Java基础关键_034

目录

一、概述

二、网络编程三要素

1.IP 地址

2.端口号

3.通信协议

（1）说明

（2）OSI 七层参考模型

（3）TCP/IP 四层参考模型

三、网络编程基础类

1.InetAddress

2.URL

（1）说明

（2）实例

（3）openStream()

四、TCP 与 UDP 协议

1.Socket 套接字

2.TCP 协议

（1）说明

（2）三次握手（建立通道）

（3）四次挥手（关闭通道）

3.UDP 协议

4.TCP 与 UDP 区别

五、TCP 编程

1.说明

2.概览

3.Socket 类

4.ServerSocket 类

5.向服务器发送消息实例

6.向服务器发送图片实例

六、UDP 编程

1.说明

2.DatagramSocket 类

3.DatagramPacket 类

4. 实例

一、概述

网络编程：利用计算机网络实现程序之间通信的一种编程方式，程序需要通过网络协议进行通信，以实现不同计算机之间的数据传输和共享；
三个基本要素：
IP：定位网络中某台计算机；
port：定位计算机上的某个进程；
通信协议：通过【IP 地址】和【port 端口号】定位后，依靠通信协议保证数据高效可靠的传输。

二、网络编程三要素

1.IP 地址

IP 地址作为网络中每台计算机的唯一标识；
在 Internet 中，使用 IPv4 或 IPv6 地址表示 IP 地址；
通常 IPv4 地址格式为【xxx.xxx.xxx.xxx】，其中每一个【xxx】表示一个 8 位的二进制数，其取值范围是【0 ~ 255】，该组合可以表示【2^32】个不同的 IP 地址；
IPv4 的总数量有 4,294,967,296 个，但也是有使用限制的。IPv4 地址分为 网络地址 和主机地址，前 3 个字节表示网络地址，最后 1 个字节表示主机地址。由于一些 IP 地址被保留或私有机构占有，所以这些地址不能用于公网分配。还有一些地址用作多播地址，仅用于特定场景，所以 IPv6 地址开始普及；
IPv6 使用 16 个字节表示 IP 地址，即 128 位。IPv6 地址由 8 组16位的十六进制数组成，每组以【:】分割；
本机地址：127.0.0.1，主机名：localhost；
私有地址属于非注册地址，为组织机构内部使用，【192.168.0.0 ~ 192.168.255.255】为私有地址；
域名：是在 IP 地址上发展起来的符号化地址方案，用来替代数字型 IP 地址，每一个符号化的地址都与特定 IP 地址对应。这种字符型地址就是域名；
DNS（域名服务器）：在 Internet 上，域名与 IP 地址之间是一对一或多对一的，虽然域名便于记忆，但是机器间只能识别 IP 地址，其之间的转换称为域名解析。域名解析需要特定的域名解析服务器完成，DNS 全称 Domain Name Server。

2.端口号

不同应用程序是通过端口号区分的；
端口号是由 2 个字节表示的，取值范围是【0 ~ 65,535】；
分类：
公认端口：0 ~ 1023。被预先定义的服务通信占用，例如：HTTP 端口是 80，FTP 端口是 21 等；
注册端口：1024 ~ 49151。分配给用户进程或应用程序，例如：Tomcat 端口是 8080，MySQL 端口是 3306，Oracle 端口是 1521 等；
私有端口（动态端口）：49152 ~ 65535。

通常，服务器使用固定的端口号监听客户端请求，而客户端使用随机端口连接服务器；
必须同时指定 IP 地址和端口号才能正确发送数据。

3.通信协议

（1）说明

通过计算机网络可以连接多台计算机，位于同一网络下的计算机，其间的连接和通信需要遵守一定的规则。这些规则就是网络通信协议，它对数据的传输格式、传输速率、传输步骤等做出了统一规定，双方必须同时遵守才能完成数据交换；

常用的协议有：TCP、UDP、HTTP、FTP 等；

TCP 协议：传输控制协议。是一种可靠的面向连接协议，保证数据传输的完整性；

UDP 协议：用户数据报协议。是一种无连接的协议，传输效率高。

（2）OSI 七层参考模型

国际标准化组织 ISO 提出的不限定于具体的设备、系统、网络体系结构的模型，称为 Open System Interconnection 参考模型；

物理层：通过物理介质传输原始比特流（如网线、Wi-Fi 信号）；

数据链路层：管理直接相连设备间的数据传输（如 MAC 地址、交换机）；

网络层：在不同网络间路由数据（如 IP 地址、路由器）；

传输层：确保端到端的可靠通信（如 TCP、UDP 协议）；

会话层：建立、管理和终止应用间的会话（如会话控制）；

表示层：转换数据格式（如加密、压缩、编码）；

应用层：面向用户的服务和协议（如 HTTP、FTP、电子邮件）。

（3）TCP/IP 四层参考模型

由于 OSI 模型和协议自身缺陷，没有推出成熟的产品。而 TCP/IP 模型在实践中不断完善并取得了成功；

TCP/IP 协议：传输控制协议/网际协议，是 Internet 最基本的协议，国际互联网的基础；

TCP/IP 协议是一个开放的网络协议簇，名字主要取自最重要的网络层 IP 协议和传输层 TCP 协议。

层级	核心功能	典型协议/技术	与OSI模型对应关系
应用层	提供用户接口和网络服务（如文件传输、邮件、网页浏览）	HTTP, FTP, SMTP, DNS, SSH, HTTPS	对应OSI的应用层、表示层、会话层
传输层	确保端到端的数据传输可靠性或效率	TCP（可靠连接）、UDP（高效无连接）	对应OSI的传输层
网络层（网际层）	负责逻辑寻址、路由选择和数据包转发	IP（IPv4/IPv6）, ICMP, ARP, BGP	对应OSI的网络层
网络接口层	管理物理网络连接、帧传输和硬件寻址	以太网（Ethernet）、Wi-Fi、MAC地址	对应OSI的数据链路层和物理层

三、网络编程基础类

1.InetAddress

java.net.InetAddress 类用来封装计算机的 IP 地址和 DNS（无端口信息），包括一个主机名和一个 IP 地址，是 Java 对 IP 地址的高层表示；
多数其他网络类都要使用此类，包括 Socket、ServerSocket、URL、DatagramSocket、DatagramPacket 等；
常用静态方法：
getLocalHost()：得到本机的 InetAddress 对象，其中封装了 IP 地址和主机名；
getByName(String host)：传入目标主机的名称或 IP 地址，得到对应的 InetAddress 对象，其中封装了 IP 地址和主机名，底层会自动连接 DNS 进行域名解析。

常用实例方法：
getHostAddress()：获取 IP 地址；
getHostName()：获取主机名称。

public class InetAddressTest {
    public static void main(String[] args) {
        try {
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println("localHost：" + localHost);
            String hostName = localHost.getHostName();
            System.out.println("hostName：" + hostName);
            String hostAddress = localHost.getHostAddress();
            System.out.println("hostAddress：" + hostAddress);

            InetAddress inetAddress =  InetAddress.getByName("www.jd.com");
            System.out.println("inetAddress：" + inetAddress);
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }
}

2.URL

（1）说明

统一资源定位器，是对从互联网上得到资源的位置和访问方法的一种简单表示，是互联网上标准资源的地址；
互联网上每一个文件都有唯一的 URL，包含的信息指出文件的位置以及浏览器应该如何处理；
组成：协议、存放资源的主机域名、端口号、资源文件名。若未指定端口号，则使用协议默认的端口；
格式：<协议>://<域名或 IP >:<端口>/<路径>。其中，<协议>://<域名或 IP > 是必需的，<端口>/<路径> 有时可省略；
java.net.URL 类中封装了大量复杂的涉及从远程站点获取信息的细节，可以使用它的方法对 URL 对象进行分割、合并等操作；
常用方法：如下实例。

（2）实例

public class URLTest {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.baidu.com:6666/index.html?naem=admin&password=admin123#tip");
            System.out.println("协议：" + url.getProtocol());
            System.out.println("主机：" + url.getHost());
            System.out.println("当前端口：" + url.getPort());
            System.out.println("默认端口：" + url.getDefaultPort());
            System.out.println("路径：" + url.getPath());
            System.out.println("提交给服务器的数据：" + url.getQuery());
            System.out.println("锚点：" + url.getRef());
            System.out.println("资源路径及数据：" + url.getFile());
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }
}

（3）openStream()

使用 URL 类的 openStream() 可以打开到此 URL 的连接，并返回一个用于从该连接读入的 InputStream，即实现最简单的网络爬虫。

public class OpenStreamTest {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.jd.com");
            InputStream inputStream = url.openStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            bufferedReader.close();
            inputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

四、TCP 与 UDP 协议

1.Socket 套接字

Socket 是传输层提供给应用层的编程接口；
网络应用程序位于应用层，TCP 和 UDP 属于传输层的两种协议，在应用层和传输层之间使用 Socket 分离。所以 Socket 编程分为 TCP 编程和 UDP 编程；
使用 Socket 编程可以开发客户机和服务器应用程序。可以在本地网络通信，也可以通过互联网在全球范围通信。

2.TCP 协议

（1）说明

使用 TCP 协议，必须建立 TCP 连接，形成传输数据通道；
传输前采用三次握手方式，属于点对点通信，面向连接，效率低；
仅支持单播传输，每条 TCP 传输连接只能有两个端点，即客户端、服务端；
两个端点的数据传输，采用的是字节流传输，属于可靠的数据传输；
传输完毕需要释放已建立的连接，开销大、速度慢，适用于文件等传输。

（2）三次握手（建立通道）

步骤：
客户端发送 SYN（同步）数据包，包含了客户端的初始序列号（ISN）；
服务器收到 SYN 数据包后，发送 SYN-ACK（同步确认）数据包，包含了服务器的初始序列号（ISN）和对客户端 ISN 的确认号 ACK；
客户端接收到 SYN-ACK 数据包后，发送 ACK（确认）数据包，包含了对服务器 ISN 的确认号 ACK。

三次握手完成后客户端和服务器就可以开始交换数据；
意义：
防止客户端和服务端同时发送数据，导致数据丢失；
防止客户端和服务端重复发送数据，导致数据重复；
防止客户端和服务端乱序发送数据，导致数据乱序。

（3）四次挥手（关闭通道）

步骤：
客户端发送 FIN（结束）数据包，表示客户端已经完成数据传输，希望关闭连接；
服务器收到 FIN 数据包后，发送 ACK（确认）数据包，表示服务器已经收到客户端的 FIN 数据包，同意关闭连接；
服务器发送 FIN 数据包，表示服务器已经完成数据传输，希望关闭连接；
客户端收到 FIN 数据包后，发送 ACK（确认）数据包，表示客户端已经收到服务器的 FIN 数据包，同意关闭连接。

四次挥手完成后，客户端与服务器之间的连接就关闭了；
意义：
防止客户端和服务端同时关闭连接，导致数据丢失；
防止客户端和服务端重复发送数据，导致数据重复；
防止客户端和服务端乱序发送数据，导致数据乱序。

3.UDP 协议

采用数据报方式传输，即源、数据、目的。无需建立连接；

每个数据报大小控制在 64 k 内，超过 64 k 可以分多个数据报发送；

可以广播发送，属于一对一、一对多、多对一的通信协议；

发送无论对方是否准备好，接收方收到也不确认，属于不可靠传输；

传输完毕无需释放资源，开销小、速度快，适用于视频、直播等传输。

4.TCP 与 UDP 区别

描述	TCP	UDP
是否建立连接	连接	不连接
传输可靠性	可靠	不可靠
连接对象个数	一对一	一对一、一对多、多对一
传输方式	字节流	报文
传输速度	慢	快
适用场景	文件、邮件等	视频、直播等

五、TCP 编程

1.说明

套接字是一种进程间的数据交换机制，利用套接字开发网络应用程序被广泛采用；成为了一种标准；
在网络通信中，第一次主动发起通讯的程序被称作客户端（Client），第一次通讯中等待连接的程序被称作服务端（Server）。一旦通讯建立，客户端和服务端没有本质区别；
套接字与主机地址和端口号相关联，主机地址是客户端或服务端程序所在的主机地址，端口地址是客户端或服务端使用的主机通信端口。在客户端和服务端分别创建 Socket，并通过 Socket 属性将两个 Socket 连接，由此客户端和服务端通过套接字建立连接并使用 IO 流进行通信。

2.概览

3.Socket 类

实现客户端套接字；
构造方法：
Socket(InetAddress a, int p)：创建套接字并连接到指定 IP 地址的指定端口。

实例方法：
getInetAddress()：返回此套接字连接到的远程 IP 地址；
getInputStream()：返回此套接字的输入流，接收网络消息；
getOutputStream()：返回此套接字的输出流，发送网络消息；
shutdownInput()：禁用此套接字的输入流；
shutdownOutput()：禁用此套接字的输出流；
close()：关闭此套接字，默认关闭 IO 流。

4.ServerSocket 类

实现服务端套接字，服务端套接字等待请求通过网络传入，基于该请求执行某些操作，然后可能向请求者返回结果；

构造方法：

ServerSocket(int port)

实例方法：

accept()：监听要连接到此套接字并接受；

getInetAddress返回此服务器套接字的本地地址；

close()：关闭此套接字。

5.向服务器发送消息实例

public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket clientSocket = null;
        BufferedReader in = null;
        int port = 6666;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("服务器启动，端口号" + port + "，等待客户端连接...");
            clientSocket = serverSocket.accept();
            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String message = null;
            while ((message = in.readLine()) != null) {
                System.out.println("客户端说：" + message);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class Client {
    public static void main(String[] args) throws UnknownHostException {
        Socket socket = null;
        BufferedWriter out = null;
        int port = 6666;
        InetAddress localHost = InetAddress.getLocalHost();
        try {
            socket = new Socket(localHost, port);
            System.out.println("客户端启动，端口号" + port + "，等待服务器响应...");
            out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("请向服务器发送消息：");
                String message = scanner.next();
                out.write(message + "\n");
                out.flush();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

6.向服务器发送图片实例

public class NewServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket clientSocket = null;
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        BufferedWriter writer = null;
        int port = 7777;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("服务器启动，端口号" + port + "，等待客户端连接...");
            clientSocket = serverSocket.accept();
            in = new BufferedInputStream(clientSocket.getInputStream());
            out = new BufferedOutputStream(new FileOutputStream(".\\testPhoto.jpg"));
            byte[] bytes = new byte[1024];
            int readCount = 0;
            while ((readCount = in.read(bytes)) != -1) {
                out.write(bytes, 0, readCount);
            }
            out.flush();
            writer = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
            writer.write("本宫已经收到你的图片了，可以退下了！\n");
            writer.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}

public class NewClient {
    public static void main(String[] args) {
        Socket clientSocket = null;
        BufferedOutputStream out = null;
        BufferedInputStream in = null;
        BufferedReader reader = null;
        int port = 7777;
        try {
            InetAddress localHost = InetAddress.getLocalHost();
            clientSocket = new Socket(localHost, port);
            System.out.println("客户端启动，端口号" + port + "，等待服务器响应...");
            out = new BufferedOutputStream(clientSocket.getOutputStream());
            in = new BufferedInputStream(new FileInputStream("D:\\swxg.jpg"));
            byte[] bytes = new byte[1024];
            int readCount = 0;
            while ((readCount = in.read(bytes)) != -1) {
                out.write(bytes, 0, readCount);
            }
            out.flush();
            clientSocket.shutdownOutput();
            reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String message = null;
            while ((message = reader.readLine()) != null) {
                System.out.println("服务器呼叫：" + message);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

六、UDP 编程

1.说明

在 UDP 协议下，两台计算机之间的数据交互不需要先建立连接。发送端直接向指定的 IP 和 port 上发送数据即可，但是不会保证对方何时收到，也并不能保证对方一定会收到；
java.net.DatagramSocket 和 java.net.DatagramPacket 是 UDP 编程里需要使用到的两个类。发送端和接收端都需要使用这两个类，并且发送端和接收端是两个独立运行的程序。

2.DatagramSocket 类

负责接收和发送数据，创建接收端时需要指定端口号；
构造方法：
DatagramSocket()：创建发送端的数据报套接字；
DatagramSocket(int port)：创建接收端的数据报套接，并指定端口号。

实例方法：
send(DatagramPacket p)：发送数据报；
receive(DatagramPacket p)：接收数据报；
close()：关闭数据报套接字。

3.DatagramPacket 类

负责将数据打包，打包类型为 byte 数组。创建发送端时需指定接收端的 IP 和 port；
构造方法：
DatagramPacket(byte buf[], int offset, int length)：创建接收端的数据报；
DatagramPacket(byte buf[], int offset, int length, InetAddress address, int port)：创建发送端的数据报，并指定接收端的 IP 和 port。

实例方法：
getData()：返回数据报中存储的数据；
getLength()：返回发送或接收数据报的长度。

4. 实例

public class Receive {
    public static void main(String[] args) {
        int port = 8888;
        try {
            DatagramSocket socket = new DatagramSocket(port);
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
            socket.receive(packet);
            String message = new String(bytes, 0, packet.getLength());
            System.out.println("接收到消息：" + message);
            socket.close();
        } catch (SocketException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Send {
    public static void main(String[] args) {
        int port = 8888;
        try {
            InetAddress localhost = InetAddress.getLocalHost();
            DatagramSocket socket = new DatagramSocket();
            byte[] bytes = "UDP 编程，我是发送方！".getBytes();
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, localhost, port);
            socket.send(packet);
            socket.close();
        } catch (SocketException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}