Java-网络编程

小悟空GK

于 2023-08-16 20:35:28 发布

阅读量102

点赞数

分类专栏： Java 文章标签： java 网络开发语言

本文链接：https://blog.csdn.net/qq_48114126/article/details/132327303

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1 网络基础

计算机网络：把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。
网络编程的目的：直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
网络编程中有两个主要的问题：
- 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
- 找到主机后如何可靠高效地进行数据传输

2 网络协议

2.1 网络协议

通信双方地址
- IP
- 端口号
一定的规则：不同的硬件、操作系统之间的通信，所有的这一切都需要一种规则。而我们就把这种规则称为协议，即网络通信协议。
- OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
- TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。

报文的封装和复用

2.2 TCP/IP协议

TCP/IP（Transmission Control Protocol/Internet Protocol）是一组网络通信协议（传输控制协议(TCP)和网络互联协议(IP)），用于在互联网和许多私有网络中进行数据传输和通信。TCP/IP协议族包含多个层级，每个层级都具有特定的功能和责任。

以下是TCP/IP协议族的主要层级：

网络接口层（Network Interface Layer）：负责将数据帧从物理媒体传输到网络，并提供与硬件设备的接口。它处理诸如以太网、Wi-Fi等底层物理连接的细节。
互联网层（Internet Layer）：处理主机之间的逻辑寻址和路由。该层使用IP协议来唯一标识和寻址不同的设备，并根据网络拓扑决定最佳路径进行数据包传输。
传输层（Transport Layer）：提供端到端的数据传输服务。其中最常用的协议是TCP（Transmission Control Protocol），它提供可靠的、面向连接的通信，并处理数据分段、流量控制等功能。另一个常见的协议是UDP（User Datagram Protocol），它提供不可靠的、无连接的通信，适用于对实时性要求较高的应用。
应用层（Application Layer）：支持特定应用程序和服务的协议集合。例如，HTTP（超文本传输协议）用于在Web浏览器和Web服务器之间传输信息，SMTP（简单邮件传输协议）用于电子邮件传输，FTP（文件传输协议）用于文件传输等。

TCP/IP协议族提供了一种通用的网络通信框架，使得不同类型的设备和应用能够相互通信，并在全球范围内实现互联网的连接。它是互联网基础设施的核心协议，被广泛应用于各种网络环境和应用场景中。

TCP报文段的首部格式：

TCP协议：打电话
- 使用TCP协议前，须先建立TCP连接，形成传输数据通道
- 传输前，采用“三次握手” 方式，点对点通信，是可靠的
- TCP协议进行通信的两个应用进程：客户端、服务端。
- 在连接中可进行大数据量的传输
- 传输完毕，需释放已建立的连接，效率低
UDP协议：发信息
- 将数据、源、目的封装成数据包，不需要建立连接
- 每个数据报的大小限制在64K内
- 发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
- 可以广播发送
- 发送数据结束时无需释放资源，开销小，速度快

2.3 三次握手

TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

第一次握手，客户端向服务器端发起TCP连接的请求
第二次握手，服务器端发送针对客户端TCP连接请求的确认
第三次握手，客户端发送确认的确认

1、客户端会随机一个初始序列号seq=x，设置SYN=1 ，表示这是SYN握手报文。然后就可以把这个 SYN 报文发送给服务端了，表示向服务端发起连接，之后客户端处于同步已发送状态。

2、服务端收到客户端的 SYN 报文后，也随机一个初始序列号(seq=y)，设置ack=x+1，表示收到了客户端的x之前的数据，希望客户端下次发送的数据从x+1开始。
设置 SYN=1 和 ACK=1。表示这是一个SYN握手和ACK确认应答报文。最后把该报文发给客户端，该报文也不包含应用层数据，之后服务端处于同步已接收状态。

3、客户端收到服务端报文后，还要向服务端回应最后一个应答报文，将ACK置为 1 ，表示这是一个应答报文
ack=y+1 ，表示收到了服务器的y之前的数据，希望服务器下次发送的数据从y+1开始。
最后把报文发送给服务端，这次报文可以携带数据，之后客户端处于连接已建立状态。服务器收到客户端的应答报文后，也进入连接已建立状态。

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

2.4 四次挥手

TCP协议中，在发送数据结束后，释放连接时需要经过四次挥手。

第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。

1、客户端打算断开连接，向服务器发送FIN报文(FIN标记位被设置为1，1表示为FIN，0表示不是)，FIN报文中会指定一个序列号，之后客户端进入FIN_WAIT_1状态。也就是客户端发出连接释放报文段(FIN报文)，指定序列号seq = u，主动关闭TCP连接，等待服务器的确认。

2、服务器收到连接释放报文段(FIN报文)后，就向客户端发送ACK应答报文，以客户端的FIN报文的序列号 seq+1 作为ACK应答报文段的确认序列号ack = seq+1 = u + 1。接着服务器进入CLOSE_WAIT(等待关闭)状态，此时的TCP处于半关闭状态(下面会说什么是半关闭状态)，客户端到服务器的连接释放。客户端收到来自服务器的ACK应答报文段后，进入FIN_WAIT_2状态。

3、服务器也打算断开连接，向客户端发送连接释放(FIN)报文段，之后服务器进入LASK_ACK(最后确认)状态，等待客户端的确认。服务器的连接释放(FIN)报文段的FIN=1，ACK=1，序列号seq=m，确认序列号ack=u+1。

4、客户端收到来自服务器的连接释放(FIN)报文段后，会向服务器发送一个ACK应答报文段，以连接释放(FIN)报文段的确认序号 ack 作为ACK应答报文段的序列号 seq，以连接释放(FIN)报文段的序列号 seq+1作为确认序号ack。

之后客户端进入TIME_WAIT(时间等待)状态，服务器收到ACK应答报文段后，服务器就进入CLOSE(关闭)状态，到此服务器的连接已经完成关闭。客户端处于TIME_WAIT状态时，此时的TCP还未释放掉，需要等待2MSL后，客户端才进入CLOSE状态。

2.5 Wireshark抓包

2.6 Netstat

Netstat是⼀款命令⾏⼯具，⽤于列出系统中所有的TCP/IP的连接情况，包括TCP、UDP以

及UNIX套接字，⽽且，该⼯具也能列出处于监听状态的服务端监听套接字。

总体来说，Netstat是⼀个的⾮常有⽤的⼯具，可以⽤于查看路由表、实际的⽹络连接、甚⾄

每⼀个⽹络接⼝设备的状态信息。举个例⼦，使⽤netstat -ant指令查看当前Linux系统中所有的

TCP/IP⽹络的连接信息，⼤致的结果如下：

对以上netstat -ant命令的展示结果中的列，具体的介绍如下：

（1）Proto列表示套接字所使⽤的协议，⽐如tcp、udp、udpl、raw等。

（2）Recv-Q列、Send-Q列分别表示⽹络接收队列、发送队列中的字节数，其中的字⺟Q是Queue的缩写。具体来说，Recv-Q表示套接字连接的本地接收缓冲区中没有被应⽤进程取⾛的字节数，其统计单位是字节，该值表示套接字总共还有多少字节的数据，没有从内核空间的套接字缓存区拷⻉到⽤户空间缓冲区。Send-Q表示套接字连接的发送队列中，对⽅没有收到的数据或者说没有被对⽅确认（Ack）的数据，其统计单位也是字节。

（3）Local Address、Foreign Address两列⽤于展示套接字连接的本地地址、对端地址，地址中包含了套接字的IP和端⼝号。如果netstat命令中使⽤了-n（–numeric）选项，地址和端⼝会以数字的形式展示，否则，地址将被解析为规范主机名（FQDN），并且⼀些默认的端⼝号将被解析为相应的协议名称，例如，地址127.0.0.1会被解析为localhost，端⼝80会被解析为http。

（4）State列⽤于展示套接字连接的状态，如果是TCP连接，此列将展示TCP连接的11

种状态的其中的某种状态。

对上命令结果中各列的具体含义，还可以通过Linux命令man netstat 查看。

netstat 命令的选项⽐较多，⼤致如下表所示：

-a或–all

显示所有Socket套接字连接，包括服务端监听套接字。

-c或–continuous

持续列出Socket套接字连接的状态。

-e或–extend

显示Socket套接字连接其他相关信息。

-g或–groups

显示多重⼴播功能群组中的成员名单。

-h或–help

显示该命令的在线帮助。

-i或–interfaces

显示⽹络接⼝（⽹卡）信息。

-l或–listening

显示监听中的服务端监听Socket套接字。

-n或–numeric

直接以数字的形式展示IP地址和端⼝。如果不加该选项，地址将被解析为规范。主机名（FQDN），⼀些默认的IP地址和端⼝号将被解析为相应的规范名称，例如127.0.0.1会被解析为localhost， 80端⼝会被解析为http。

-o或–timers

显示计时器。

-p或–programs

显示正在使⽤Socket套接字的PID（）进程ID和进程名称。

-r或–route

显示路由表。

-s或–statistice

显示⽹络统计信息。

-t或–tcp

显示TCP传输协议的连接信息。

-u或–udp

显示UDP传输协议的连接信息。

-w或–raw

显示RAW传输协议的连线信息。

⼀般情况，可以使⽤netstat -antp指令，去查看TCP的连接信息，包含其进程的PID和名称。在实际的连接状态查看的过程中，有⼀个持续查看的过程，会⽤到Shell脚本中的while循环。

3 网络编程API

3.1 InetAddress类

IP 地址：InetAddress

唯一的标识 Internet 上的计算机（通信实体）
本地回环地址(hostAddress)： 127.0.0.1 主机名(hostName)： localhost
IP地址分类方式1： IPV4 和 IPV6
- IPV4： 4个字节组成， 4个0-255。大概42亿， 30亿都在北美，亚洲4亿。 2011年初已经用尽。以点分十进制表示，如192.168.0.1
- IPV6： 128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号（：）分开，如： 3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
IP地址分类方式2：公网地址(万维网使用)和私有地址(局域网使用)。 192.168.开头的就是私有址址，范围即为192.168.0.0–192.168.255.255，专门为组织机构内部使用
Internet上的主机有两种方式表示地址：
- 域名(hostName)： www.baidu.com
- IP 地址(hostAddress)： 202.108.35.210
InetAddress类主要表示IP地址，两个子类： Inet4Address、 Inet6Address。
InetAddress 类对象含有一个 Internet 主机地址的域名和 IP 地址：www.baidu.com 和 202.108.35.210。
域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。 -------域名解析
域名解析的过程：先找本机hostsC:\Windows\System32\drivers\etc\hosts，是否有输入的域名地址，没有的话，再通过DNS服务器，找主机。

API:

InetAddress类主要表示IP地址，两个子类：Inet4Address、Inet6Address。

InetAddress 类没有提供公共的构造器，而是提供了如下几个静态方法来获取InetAddress 实例

public static InetAddress getLocalHost()
public static InetAddress getByName(String host)
public static InetAddress getByAddress(byte[] addr)

InetAddress 提供了如下几个常用的方法

public String getHostAddress() ：返回 IP 地址字符串（以文本表现形式）
public String getHostName() ：获取此 IP 地址的主机名
public boolean isReachable(int timeout)：测试是否可以达到该地址

端口号标识正在计算机上运行的进程（程序）:

不同的进程有不同的端口号
被规定为一个 16 位的整数 0~65535。
端口分类：
- 公认端口： 0~1023。被预先定义的服务通信占用（如： HTTP占用端口80， FTP占用端口21， Telnet占用端口23）
- 注册端口： 1024~49151。分配给用户进程或应用程序。（如： Tomcat占用端口8080， MySQL占用端口3306， Oracle占用端口1521等）。
- 动态/私有端口： 49152~65535。
端口号与IP地址的组合得出一个网络套接字： Socket。

public class InetAddressTest {
 
     public static void main(String[] args) {
 
         try {
             //File file = new File("hello.txt");
             InetAddress inet1 = InetAddress.getByName("192.168.10.14");
 
             System.out.println(inet1);
 
             InetAddress inet2 = InetAddress.getByName("www.baidu.com");
             System.out.println(inet2);
 
             InetAddress inet3 = InetAddress.getByName("127.0.0.1");
             System.out.println(inet3);
 
             //获取本地ip
             InetAddress inet4 = InetAddress.getLocalHost();
             System.out.println(inet4);
 
             //getHostName()
             System.out.println(inet2.getHostName());
             //getHostAddress()
             System.out.println(inet2.getHostAddress());
 
         } catch (UnknownHostException e) {
             e.printStackTrace();
         }
     }
 }

3.2 Socket类

网络上具有唯一标识的IP地址和端口号组合在一起构成唯一能识别的标识符套接字（Socket）。
利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。网络通信其实就是Socket间的通信。
通信的两端都要有Socket，是两台机器间通信的端点。
Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
Socket分类：
- 流套接字（stream socket）：使用TCP提供可依赖的字节流服务
  - ServerSocket：此类实现TCP服务器套接字。服务器套接字等待请求通过网络传入。
  - Socket：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
- 数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务
  - DatagramSocket：此类表示用来发送和接收UDP数据报包的套接字。
Socket分类：
- 流套接字（stream socket）：使用TCP提供可依赖的字节流服务
- 数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务
Socket类的常用构造器：
- public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
- public Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号。
Socket类的常用方法：
- public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息
- public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息
- public InetAddress getInetAddress()此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
- public InetAddress getLocalAddress()获取套接字绑定的本地地址。即本端的IP地址
- public int getPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
- public int getLocalPort()返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1。即本端的端口号。
- public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
- public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据。
- public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。即不能通过此套接字的输出流发送任何数据。

4 TCP 编程

Java语言的基于套接字编程分为服务端编程和客户端编程，其通信模型如图所示：

4.1 客户端Socket的工作过程包含以下四个基本的步骤：

- 创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
- 打开连接到 Socket 的输入/出流：使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输
- 按照一定的协议对 Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
- 关闭 Socket：断开客户端到服务器的连接，释放线路
客户端程序可以使用Socket类创建对象，创建的同时会自动向服务器方发起连接。 Socket的构造器是：
- Socket(String host,int port)throws UnknownHostException,IOException：向服务器(域名是host。端口号为port)发起TCP连接，若成功，则创建Socket对象，否则抛出异常。
- Socket(InetAddress address,int port)throws IOException：根据InetAddress对象所表示的IP地址以及端口号port发起连接。

4.2 服务器程序的工作过程包含以下四个基本的步骤：

- 调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
- 调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
- 调用该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
- 关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。
ServerSocket 对象负责等待客户端请求建立套接字连接，类似邮局某个窗口中的业务员。也就是说，服务器必须事先建立一个等待客户请求建立套接字连接的ServerSocket对象。
所谓“接收”客户的套接字请求，就是accept()方法会返回一个 Socket 对象

案例

服务器端

public class ServerDemo {

    public static void main(String[] args) {
        System.out.println("服务器启动");
        //定义在外面，便于关流
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try {
            serverSocket = new ServerSocket(8999);
            socket = serverSocket.accept();//io阻塞状态，等待客户端传输socket
            in = socket.getInputStream();

            out = new ByteArrayOutputStream();

            //得到客户端输入
            int length = -1;
            byte[] buffer = new byte[5];
            while ((length = in.read(buffer)) != -1) {
                out.write(buffer, 0, length);
            }
            System.out.println(socket.getInetAddress() + "\t" + out.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                socket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }

}

执行后服务端IO阻塞，等待客户端Socket对象

客户端

public class ClientDemo {

    public static void main(String[] args) {
        Socket socket = null;
        OutputStream out = null;
        try {
            InetAddress address = InetAddress.getByName("127.0.0.1");
            socket = new Socket(address, 8999);
            out = socket.getOutputStream();
            out.write("hello socket".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                socket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

}

服务器反馈案例

服务端：

public class ServerDemo {

    public static void main(String[] args) {
        System.out.println("服务器启动");
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        BufferedOutputStream out = null;
        BufferedWriter out2 = null;
        try {
            serverSocket = new ServerSocket(8999);
            socket = serverSocket.accept();//io阻塞状态，等待客户端传输socket
            in = socket.getInputStream();
            out = new BufferedOutputStream(System.out);
            out2 = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            //得到客户端输入
            int length = -1;
            byte[] buffer = new byte[1024];
            while ((length = in.read(buffer)) != -1) {
                out.write(buffer, 0, length);
            }

            socket.shutdownInput();

            out2.write("file upload success");

//            System.out.println(socket.getInetAddress() + "\t" + out.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                out2.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                in.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                socket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

        }

    }

}

客户端：

public class ClientDemo {

    public static void main(String[] args) {
        Socket socket = null;
        OutputStream out = null;
        BufferedInputStream in = null;
        BufferedReader in2 = null;
        try {
            InetAddress address = InetAddress.getByName("127.0.0.1");
            socket = new Socket(address, 8999);
            in = new BufferedInputStream(new FileInputStream("ClientDemo.java"));
            out = socket.getOutputStream();
            in2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            int length = -1;
            byte[] buffer = new byte[1024];
            while ((length = in.read(buffer)) != -1) {
                out.write(buffer, 0, length);
            }
            //当没有输出，关闭输出
//            out.flush();
            socket.shutdownOutput();

            //得到服务的反馈结果
            String line = null;
            while ((line = in2.readLine()) != null) {
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                socket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

}

5 UDP 编程

TCP网络模型类似打电话，UDP模型类似于发短信
TCP编程-服务端
- ServerSocket（端口号）：监听客户端输入
- socket = ServerSocket.accept：接收客户端socket
- socket.getInputSteam()，socket.getOutputSteam()的IO操作进行网络通讯
TCP编程的客户端
- Socket(InetAdress（ip地址），端口号)
- socket.getInputSteam()，socket.getOutputSteam()的IO操作进行网络通讯
类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。
UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。

5.1 DatagramSocket 类的常用方法

public DatagramSocket(int port) 创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址， IP 地址由内核来选择。
public DatagramSocket(int port,InetAddress laddr) 创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址， IP 地址由内核选择。
public void close() 关闭此数据报套接字。
public void send(DatagramPacket p) 从此套接字发送数据报包。 DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。
public void receive(DatagramPacket p) 从此套接字接收数据报包。当此方法返回时， DatagramPacket的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。
public InetAddress getLocalAddress() 获取套接字绑定的本地地址。
public int getLocalPort() 返回此套接字绑定的本地主机上的端口号。
public InetAddress getInetAddress() 返回此套接字连接的地址。如果套接字未连接，则返回 null。
public int getPort() 返回此套接字的端口。如果套接字未连接，则返回 -1。

5.2 DatagramPacket类的常用方法

- public DatagramPacket(byte[] buf,int length) 构造 DatagramPacket，用来接收长度为 length 的数据包。 length 参数必须小于等于 buf.length。
- public DatagramPacket(byte[] buf,int length,InetAddress address,int port) 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。 length参数必须小于等于 buf.length。
- public InetAddress getAddress() 返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
- public int getPort() 返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
- public byte[] getData() 返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续 length 长度。
- public int getLength() 返回将要发送或接收到的数据的长度。

5.3 UDP网络通讯流程：

- DatagramSocket与DatagramPacket
- 建立发送端，接收端
- 建立数据包
- 调用Socket的发送、接收方法
- 关闭Socket

public class UDPServerDemo {

    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(10086);

        while (true) {
            //创建接收数据包
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
            socket.receive(packet); //IO阻塞

            System.out.println(packet.getAddress() + " " + packet.getPort() + " " + new String(packet.getData(),0, packet.getLength()));
        }
    }

}

public class UDPClientDemo {

    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket();
        Scanner sc = new Scanner(System.in);
        String line = null;
        while ((line = sc.nextLine()) != null) {
            if ("88".equals(line)) {
                break;
            }
            DatagramPacket packet = new DatagramPacket(line.getBytes(), line.getBytes().length, InetAddress.getByName("127.0.0.1"), 10086);
            socket.send(packet);
        }
        socket.close();
    }

}

6 URL编程

URL

●URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址。

●它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。

●通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www， ftp站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

●URL的基本结构由5部分组成：<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

○例如: http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

●为了表示URL， java.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象：

○public URL (String spec)：通过一个表示URL地址的字符串可以构造一个URL对象。例如： URL url = new URL (“http://www. baidu.com/”);

○public URL(URL context, String spec)：通过基 URL 和相对 URL 构造一个 URL 对象。例如： URL downloadUrl = new URL(url, “download.html")

○public URL(String protocol, String host, String file); 例如： new URL(“http”,“www.baidu.com”, “download. html");

○public URL(String protocol, String host, int port, String file); 例如: URL gamelan = new URL(“http”, “www.baidu.com”, 80, “download.html");

●一个URL对象生成后，其属性是不能被改变的，但可以通过它给定的方法来获取这些属性：

○public String getProtocol( ) 获取该URL的协议名

○public String getHost( ) 获取该URL的主机名

○public String getPort( ) 获取该URL的端口号

○public String getPath( ) 获取该URL的文件路径

○public String getFile( ) 获取该URL的文件名

○public String getQuery( ) 获取该URL的查询名

1URLConnection类

●URLConnection：表示到URL所引用的远程对象的连接。当与一个URL建立连接时，首先要在一个 URL 对象上通过方法 openConnection() 生成对应的 URLConnection对象。如果连接过程失败，将产生IOException.

○URL netchinaren = new URL (“http://www.baidu.com/index.shtml”);

○URLConnectonn u = netchinaren.openConnection( );

●通过URLConnection对象获取的输入流和输出流，即可以与现有的CGI程序进行交互。

○public Object getContent( ) throws IOException

○public int getContentLength( )

○public String getContentType( )

○public long getDate( )

○public long getLastModified( )

○public InputStream getInputStream( )throws IOException

○public OutputSteram getOutputStream( )throws IOException

1URI、 URL和URN的区别

●URI，是uniform resource identifier，统一资源标识符，用来唯一的标识一个资源。

●URL是uniform resource locator，统一资源定位符，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。

●URN， uniform resource name，统一资源命名，是通过名字来标识资源，比如mailto:java-net@java.sun.com。也就是说， URI是以一种抽象的，高层次概念定义统一资源标识，而URL和URN则是具体的资源标识的方式。 URL和URN都是一种URI。

●在Java的URI中，一个URI实例可以代表绝对的，也可以是相对的，只要它符合URI的语法规则。而URL类则不仅符合语义，还包含了定位该资源的信息，因此它不能是相对的。

案例

1下载安装tomcat

2拷贝一个图片d:\tmp\apache-tomcat-8.5.92\webapps\ROOT\

3启动tomcat

cd d:\tmp\apache-tomcat-8.5.92\bin\
startup

浏览器访问http://localhost:8080/target.jpg，得到图片
代码发送http请求，得到响应
http协议，请求和响应

public class HttpDemo {

    /**
     * java的HTTP框架
     *   - http-client apache
     *   - ok-http
     *   - HttpURLConnection：官方
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        URL url = new URL("http://localhost:8080/target.jpg");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(); //打开链接
        connection.connect(); //发送请求

        BufferedInputStream in = new BufferedInputStream(connection.getInputStream());
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("target.jpg"));

        int length = -1;
        byte[] buffer = new byte[1024];
        while ((length = in.read(buffer)) != -1) {
            out.write(buffer, 0, length);
        }
        out.flush();
        in.close();
        out.close();
        connection.disconnect();

    }

}

面试题

1. 为什么关闭连接需要四次挥手，而建立连接却只要三次握手

关闭连接时，被动断开方在收到对方的FIN结束请求报文时，很可能业务数据没有发送完成，并不能立即关闭连接，被动方只能先回复一个ACK响应文件，告诉主动断开方：“你发的FIN报文我收到了，只有等到我所有的业务报文都发送完了，我才能真正的结束，在结束之前，我会发你FIN+ACK报文的，你先等着。”所以，被动断开方的确认报文，需要拆开成为两步，故总体就需要四次挥手。

而在建立连接的场景中，Server端的应答可以稍微简单一些。当Server端收到Client端的SYN连接请求报文后，其中ACK报文表示对请求报文的应答，SYN报文用来表示服务端的连接也已经同步开启了，而ACK报文和SYN报文之间，不会有其他报文需要发送，故而可以合二为一，可以直接发送一个SYN+ACK报文。所以，在建立连接时，只需要三次握手即可。

2. 为什么连接建立的时候是三次握手，可以改成两次握手吗

三次握手完成两个重要的功能：一是双方都做好发送数据的准备工作，而且双方都知道对方已经准备好；二是双方完成初始SN序列号的协商，双方的SN序列号在握手的过程中被发送和确认。

如果把三次握手改成两次握手，可能发送死锁，两次握手的话，缺失了Client的二次确认ACK帧，假想的TCP建立的连接时二次握手，如图：

在假想的TCP建立的连接时二次握手的过程中，Client发送一个SYN请求帧到Server，Server收到后反馈一个SYN+ACK帧，按照假想两次握手的协定，Server会认为连接已经成功建立，可以开始发送数据帧。这个过程中，如果确认应答SYN+ACK帧在传输过程中丢失，Client认为连接还没建立成功，将会忽略Server发来的数据帧，会一直等待Server的SYN+ACK应答帧。而Server在发送数据帧后，一直没有收到Client发来的ACK确认帧后会产生超时。重复发送同样的数据帧，这样就发生了死锁

3. 为什么主动断开方在TIME-WAIT状态必须等待2MSL的时间

主动断开方在 TIME-WAIT 状态必须等待 2MSL 的时间是为了确保网络中所有的数据报文都被准确地传递到对端，并且对端已经收到并处理完这些数据。

MSL（Maximum Segment Lifetime）是 TCP 协议中定义的一个参数，表示一个数据报文在网络中最长的存活时间。而 2MSL 则是两倍的 MSL，即一个较长的时间段。

在 TCP 的连接关闭过程中，主动断开方发送了最后一个确认报文（ACK），然后进入 TIME-WAIT 状态。这样做的目的是为了确保对端收到 ACK 报文，以防止对端在接收到 ACK 后立即关闭连接，导致主动断开方无法接收到对端可能重传的数据。

等待 2MSL 的时间可以让网络中任何滞留的数据报文完全消失。这段时间也允许旧的连接状态在网络中彻底消失，以避免与同一端口的新连接产生冲突。这是因为如果旧的连接状态仍然存在，而新的连接使用相同的源 IP 地址和源端口号，网络可能会将该数据报文误认为属于旧的连接，从而引发问题。

因此，等待 2MSL 的时间是为了提供足够的缓冲期，以保证网络中所有残留的数据都能够正确处理，同时避免旧的连接状态对新连接造成干扰。这是 TCP 协议设计中的一种保护机制。

4. 如果已经建立了连接，但是Client端突然出现故障了怎么办

TCP还设有一个保活计时器，客户端如果出现故障，服务器端不能一直等下去，这样会浪费系统资源。服务器端每次收到一次客户端的数据帧后，都会将保活计时器复位，计时器超时时间通常设置为2小时，如果2小时后还么有收到客户端的任何数据帧，服务器端会发送一个探测报文段，以后每隔75秒发送一次，若一连发送10个探测报文仍然没有翻译，服务器端会自动认为客户端出现了故障，接着就关闭连接。如果觉得保活计时器两个小时间隔太长，可以自行调整TCP保活参数

小悟空GK

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java-网络编程

计算机网络：把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。网络编程的目的：直接或间接地通过网络协议与其它计算机实现，进行通讯。
复制链接

扫一扫