网络编程TCP/IP和UDP以及HTTP协议

版权声明：文章来源-苏亿_blog https://blog.csdn.net/qq_40325734/article/details/81940774

OSI的七层模型和TCP/IP的四层模型:

TCP/IP协议是从OSI的七层模型中简化出来的:

四层模型的详图:

什么是HTTP协议:

HTTP称为 超文本传输协议 是一种基于应用层的通信协议，它允许将超文本标记语言(HTML)文档从Web服务器传送到客户端的浏览器,

所有的WWW文件都必须遵守这个标准. 目前我们使用的是HTTP/1.1 版本.

通常，由HTTP客户端发起一个请求，建立一个到服务器指定端口（默认是80端口）的TCP连接。HTTP服务器则在那个端口监听客户端发送过来的请求。一旦收到请求，服务器（向客户端）发回一个状态行，比如"HTTP/1.1 200 OK"，和（响应的）消息，消息的消息体可能是请求的文件、错误消息、或者其它一些信息。

HTTP协议的网页

HTTP使用TCP而不是UDP的原因在于（打开）一个网页必须传送很多数据，而TCP协议提供传输控制，按顺序组织数据，和错误纠正。

什么是TCP/IP协议:

TCP协议是面向连接的通信协议，即在传输数据前先在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

追求安全、稳定或想控制流量的的时候可以使用TCP协议，如文件传输FTP，超文本链接HTTP。

在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

确认连接的三次握手:

第一次握手，客户端向服务器端发出连接请求，等待服务器确认，

第二次握手，服务器端向客户端回送响应确认，通知客户端收到了连接请求，

第三次握手，客户端再次向服务器端发送确认信息，确认连接。

整个交互过程如下图所示:

 服务端code:

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 实现TCP协议的服务器端
 * 便是服务器程序的类: java.net.ServerSocket
 * 构造方法:
 *    ServerSocket(int port) 传递端口号
 *
 * 服务端无法自己创建Socket类,需要获取到客户端的Socket套接字对象
 * (服务端接收到很多客户端链接申请,无法知道是那个客户端的申请,所以需要服务端获取到客户端的Socket套接字对象.来确定那个客户端的申请)
 * 方法:
 *   Socket accept()
 */
public class TCPServerSocket {
    public static void main(String []args)throws IOException {
        //创建服务器程序类.
        ServerSocket serversocket = new ServerSocket(7777);
        //使用服务器程序类Socket accept()方法获取客户端套接字Socket类对象
        Socket socket = serversocket.accept();
        //通过套接字获取到,字节输入流对象
        InputStream ips = socket.getInputStream();
        //创建字节数组,存储输入流读取客户端的字节数据
        byte[] bytes = new byte[1024];
        int len = ips.read(bytes);
        System.out.println(new String(bytes,0,len));
        //向客户端传递数据
        OutputStream pts = socket.getOutputStream();
        pts.write("服务器".getBytes());
        //关闭资源
        pts.close();
        ips.close();
        socket.close();
    }
}

客户端code:

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 此类实现TCP协议的客户端,链接到服务器
 * 和服务器实现数据交换
 * 实现TCP客户端程序类 java.net.Socket
 *
 * 构造方法:
 *   Socket(String host,int port) 传递服务器IP和端口号
 *   注意构造器一旦运行就会和服务器进行链接,链接失败,抛出异常
 *
 * 由于是在互联网传输数据使用的字节输出流和字节输入流必须使用Socket类的getxxxxx()方法返回的字节输出流和输入流对象
 * Socket 被称呼为套接字
 *
 * 输出流和输入方法:
 *    OutputStream getOutputStream() 返回套接字的输出流
 *    作用:将数据输出,输出到服务器 (服务器运行Socket方法获取到套接字输出流则输出到Socket对象客户端)
 *
 *    InputStream getInputStream() 返回套接字输入流
 *    作用:从服务端中读取数据 (服务器运行Socket方法获取到套接字输入流则读取客户端数据)
 */
public class TCPSocket {
    public static void main(String []args)throws IOException{
        //创建Socket类对象,链接服务器
        Socket socket = new Socket("127.0.0.1",7777);
        //通过客户端套接字对象Socket方法,获取字节输出流,将数据写入服务器
        OutputStream ops = socket.getOutputStream();
        //字节输出流,传递只能是字节,传递字节数组
        ops.write("客户端".getBytes());
        //读取服务器传递的数据
        InputStream ips = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = ips.read(bytes);
        System.out.println(new String(bytes,0,len));
        //关闭资源
        ips.close();
        ops.close();
        socket.close();
    }
}

断开连接的四次挥手

由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。原则是主动关闭的一方（如已传输完所有数据等原因）发送一个FIN报文来表示终止这个方向的连接，收到一个FIN意味着这个方向不再有数据流动，但另一个方向仍能继续发送数据，直到另一个方向也发送FIN报文。四次挥手的具体过程如下：

• 客户端发送一个FIN报文（报文4）给服务器，表示我将关闭客户端到服务器端这个方向的连接。
• 服务器收到报文4后，发送一个ACK报文（报文5）给客户端，序号为报文4的序号加1。
• 服务器发送一个FIN报文（报文6）给客户端，表示自己也将关闭服务器端到客户端这个方向的连接。
• 客户端收到报文6后，发回一个ACK报文（报文7）给服务器，序号为报文6的序号加1。

简述:

第一次挥手: 客户端请求断开连接,等待服务器端确认(FIN)

第二次挥手: 服务端向客户端响应一个确认(ACK)

第三次挥手: 服务端向客户端发送断开连接,等待客户端确认,(FIN)

第四次挥手: 客户端响应给服务端确认(ACK)

什么是UDP协议:

UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

 在Java代码上实现:

UDP是一种面向无连接的协议，因此，在通信时发送端和接收端不用建立连接。UDP通信的过程就像是货运公司在两个码头间发送货物一样。在码头发送和接收货物时都需要使用集装箱来装载货物，UDP通信也是一样，发送和接收的数据也需要使用“集装箱”进行打包，为此JDK中提供了一个DatagramPacket类，该类的实例对象就相当于一个集装箱，用于封装UDP通信中发送或者接收的数据。

DatagramPacket 集装箱

DatagramPacket 集装箱的构造器:

• 使用该构造方法在创建DatagramPacket对象时，指定了封装数据的字节数组和数据的大小，没有指定IP地址和端口号。很明显，这样的对象只能用于接收端，不能用于发送端。因为发送端一定要明确指出数据的目的地(ip地址和端口号)，而接收端不需要明确知道数据的来源，只需要接收到数据即可。 

• 使用该构造方法在创建DatagramPacket对象时，不仅指定了封装数据的字节数组和数据的大小，还指定了数据包的目标IP地址（addr）和端口号（port）。该对象通常用于发送端，因为在发送数据时必须指定接收端的IP地址和端口号，就好像发送货物的集装箱上面必须标明接收人的地址一样。 

DatagramPacket 集装箱的函数:

 DatagramSocket 码头:

然而运输货物只有“集装箱”是不够的，还需要有码头。在程序中需要实现通信只有DatagramPacket数据包也同样不行，为此JDK中提供的一个DatagramSocket类。DatagramSocket类的作用就类似于码头，使用这个类的实例对象就可以发送和接收DatagramPacket数据包，发送数据的过程如下图所示。

DatagramSocket 码头的构造器:

• 该构造方法用于创建发送端的DatagramSocket对象，在创建DatagramSocket对象时，并没有指定端口号，此时，系统会分配一个没有被其它网络程序所使用的端口号。

• 该构造方法既可用于创建接收端的DatagramSocket对象，又可以创建发送端的DatagramSocket对象，在创建接收端的DatagramSocket对象时，必须要指定一个端口号，这样就可以监听指定的端口。

DatagramSocket 码头的函数:

发送端code:

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * 实现UDP协议的发送端
 *  UDP发送端和接收端必须有DatagramPacket类对象和DatagramSocket类对象
 *  发送端使用DatagramPacket类封装数据包使用DatagramSocket类发送数据包
 *  接收端需要DatagramSocket类接收数据包使用DatagramPacket类拆封数据包
 *
 *      实现封装数据类 java.net.DatagramPacket  将数据封装为数据包
 *      实现数据包传输类 java.net.DatagramSocket 将数据包发出去
 *
 * 实现步骤:
 *  1.创建DatagramPacket 对象封装数据,接收的地址和端口
 *  2.创建DatagramSocket 对象
 *  3.调用DatagramSocket 类send(DatagramPacket dp)方法传递数据包,发送数据包
 *  4.关闭资源close();
 *
 *  DatagramPacket构造方法:
 *     DatagramPacket(byte[] buf,int length,InetAddress address,int port)
 *     buf: 字节数组
 *     length: 需要传递的数组元素个数
 *     address: 需要发送的主机地址
 *     port: 端口号
 *
 *  DatagramSocket构造方法:
 *     DatagramSocket()
 *     方法:send(DatagramPacket dp)
 */
public class UDPSend {
    public static void main(String []args)throws IOException{
        //创建数据包对象,封装要发送的数据,接收端ip,端口
        byte[] data = "UDP发送".getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");//ip: 127.0.0.1 是指本机
        //封装数据包
        DatagramPacket dp = new DatagramPacket(data,data.length,address,6000);
        //创建发送数据包
        DatagramSocket ds = new DatagramSocket();
        //调用发送数据包方法传递数据包对象
        ds.send(dp);
        //关闭资源
        ds.close();
    }
}

接收端code:

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * 实现UDP接收端
 *      实现拆封数据包 java.net.DatagramPacket 调用方法对数据包拆包
 *      实现接收数据包 java.net.DatagramSocket 接收数据包端口调用方法封装数据包到DatagramPacket类对象
 *
 * 实现步骤:
 *   1.创建DatagramSocket对象,绑定端口号  必须要和发送端(发送数据包到的端口号)一致
 *   2.创建字节数组,接收发来的数据
 *   3.创建DatagramPacket类对象
 *   4.调用DatagramSocket对象方法  receive(DatagramPacket dp) 接收数据,将数据封装到数据包对象中
 *   5.拆包
 *      发送端ip地址
 *        数据包对象DatagramPacket类方法getAddress()返回封装ip地址对象
 *      接收到的字节个数
 *        数据包对象DatagramPacket类方法getLength() 返回数据包中的字节数组长度
 *      发送方的端口
 *        数据包对象DatagramPacket类方法getport() 返回发送或接收端的端口号
 *   6.关闭资源
 */
public class UDPReceive {
    public static void main(String []args)throws IOException{
        //在构造方法中指定端口号
        DatagramSocket ds = new DatagramSocket(6000);
        //由于是接收,所以只指定数组长度 一般指定数组长度为 64kb(也就是1024*64)
        byte[] bytes = new byte[1024];//但是由于我们发送的信息少所以数组长度指定为1kb
        //第一个参数传递字节数组用于接收拆封数据包后的数据 第二个参数传递需要接收的数组长度
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
        //调用接收端方法接收数据,传递封装数据包对象
        ds.receive(dp);

        //调用getAddress() 返回主机地址对象(数据包中封装了发送端的主机ip和名字)
        InetAddress ip = dp.getAddress();
        System.out.println(ip.getHostAddress()+"  "+ip.getHostName());

        //获取接收到的字节个数
        int length = dp.getLength();
        System.out.println(length);
        //获取发送方的端口号
        int port = dp.getPort();
        System.out.println(port);

        //使用字符串格式打印字节数组
        System.out.println(new String(bytes,0,length));//由于我们接收端的数组长度过长造成资源浪费所以使用字符串的构造方法指定数组中间段的数据
        //关闭资源
        ds.close();
    }
}