Java——网络编程（TCP/IP三次握手、TCP编程、UDP编程）

SaMorri

已于 2022-07-23 22:24:53 修改

阅读量355

点赞数

分类专栏： Java基础文章标签：网络 socket java linux 网络协议

于 2020-08-14 10:55:06 首次发布

本文链接：https://blog.csdn.net/m0_38140207/article/details/107966426

版权

Java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

2.1.2 端口号

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

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

2.2 TCP、UDP协议

概述

① 传输层协议中有两个非常重要的协议：

传输控制协议TCP(Transmission Control Protocol)
用户数据报协议UDP(User Datagram Protocol)

② IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信

③ TCP/IP以其两个主要协议：传输控制协议（TCP）和网络互联协议（IP）而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议

TCP 和 UDP 区别

TCP协议：

使用TCP协议前，须先建立TCP连接，形成传输数据通道
传输前，采用 “三次握手” 方式，点对点通信，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端
在连接中可进行大数据量的传输
传输完毕，需释放已建立的连接，效率低

UDP协议：

将数据、源、目的封装成数据包，不需要建立连接
每个数据报的大小限制在64K内
发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
可以广播发送
发送数据结束时无需释放资源，开销小，速度快

TCP三次握手
三次握手（Three-Way Handshake）即建立 TCP 连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。整个流程如下图所示：
在这里插入图片描述
① 第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。

② 第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。

③ 第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

简单来说，就是：

① 建立连接时，客户端发送SYN包（SYN=i）到服务器，并进入到SYN-SEND状态，等待服务器确认

② 服务器收到SYN包，必须确认客户的SYN（ack=i+1）,同时自己也发送一个SYN包（SYN=k）,即SYN+ACK包，此时服务器进入SYN-RECV状态

③ 客户端收到服务器的SYN+ACK包，向服务器发送确认报ACK（ack=k+1）,此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手，客户端与服务器开始传送数据。

TCP四次挥手
四次挥手（Four-Way Wavehand）即终止TCP连接，就是指断开一个TCP连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程可由客户端或服务端任一方发起，流程如下图所示：
在这里插入图片描述
由于TCP连接时全双工的，因此，每个方向都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。

（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。

（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。

（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。

（4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。

为什么是四次挥手

因为TCP是全双工通信的

（1）第一次挥手因此当主动方发送断开连接的请求（即FIN报文）给被动方时，仅仅代表主动方不会再发送数据报文了，但主动方仍可以接收数据报文。

（2）第二次挥手被动方此时有可能还有相应的数据报文需要发送，因此需要先发送ACK报文，告知主动方“我知道你想断开连接的请求了”。这样主动方便不会因为没有收到应答而继续发送断开连接的请求（即FIN报文）。

（3）第三次挥手被动方在处理完数据报文后，便发送给主动方FIN报文；这样可以保证数据通信正常可靠地完成。发送完FIN报文后，被动方进入LAST_ACK阶段（超时等待）。

（4）第四挥手如果主动方及时发送ACK报文进行连接中断的确认，这时被动方就直接释放连接，进入可用状态。

3. TCP网络编程

3.1 Socket

概述

网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标
识符套接字。
通信的两端都要有Socket，是两台机器间通信的端点。
网络通信其实就是Socket间的通信。
Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
Socket分类：
- 流套接字（stream socket）：使用TCP提供可依赖的字节流服务
- 数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务

例子1：客户端发送内容给服务端，服务端将内容打印到控制台上

	//客户端
    @Test
    public void client()  {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("192.168.14.100");
            socket = new Socket(inet,8899);
            //2.获取一个输出流，用于输出数据
            os = socket.getOutputStream();
            //3.写出数据的操作
            os.write("你好，我是客户端mm".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    //服务端
    @Test
    public void server()  {

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.创建服务器端的ServerSocket，指明自己的端口号
            ss = new ServerSocket(8899);
            //2.调用accept()表示接收来自于客户端的socket
            socket = ss.accept();
            //3.获取输入流
            is = socket.getInputStream();
            
            //4.读取输入流中的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while((len = is.read(buffer)) != -1){
                baos.write(buffer,0,len);
            }

            System.out.println(baos.toString());

            System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(baos != null){
                //5.关闭资源
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(ss != null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

例子2：从客户端发送文件给服务端，服务端保存到本地，并返回“发送成功”给
客户端。并关闭相应的连接。

	//客户端
	@Test
    public void client(){
        Socket socket = null;
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        OutputStream os;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            socket = new Socket("127.0.0.1",9090);
            os = socket.getOutputStream();
            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            fis = new FileInputStream(new File("薪资.png"));
            bis = new BufferedInputStream(fis);
            int len;

            byte[] buffer = new byte[5];

            while ((len = bis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }
            socket.shutdownOutput();

            int len1;
            System.out.println("开始接受响应");
            byte[] buffer1 = new byte[5];
            while ((len1 = is.read(buffer1))!=-1){
                baos.write(buffer1,0,len1);
            }
            System.out.println(baos.toString());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(socket!=null) socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bis!=null) bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

	//服务器端
	@Test
    public void server(){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        OutputStream os = null;

        try {
            serverSocket = new ServerSocket(9090);
            socket = serverSocket.accept();
            is = socket.getInputStream();
            os = socket.getOutputStream();
            fos = new FileOutputStream(new File("薪资1.png"));
            bos = new BufferedOutputStream(fos);

            int len;
            byte[] buffer = new byte[5];
            while ((len = is.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
            System.out.println("图片传输完成");

            os.write("已收到！！！！".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3. UDP网络编程

3.1 概述

① 类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。

② UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证
UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

③ DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP
地址和端口号以及接收端的IP地址和端口号。

④ UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和
接收方的连接。如同发快递包裹一样。

例子：

@Test
    public void sender() throws IOException {
        DatagramSocket socket = new DatagramSocket();

        String str = "hello,UPD!";
        byte[] data = str.getBytes();
        InetAddress inet = InetAddress.getByName("127.0.0.1");

        DatagramPacket datagramPacket = new DatagramPacket(data,data.length,inet,9090);
        socket.send(datagramPacket);

        socket.close();
    }

    @Test
    public void receiver() throws IOException {
        DatagramSocket socket = new DatagramSocket(9090);

        byte[] buffer = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buffer,0,buffer.length);

        socket.receive(datagramPacket);

        System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));

        socket.close();
    }

SaMorri

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java——网络编程（TCP/IP三次握手、TCP编程、UDP编程）

1. 概述①网络编程的目的：直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯②网络编程中有两个主要的问题：如何准确地定位网络的主机、定位主机上的特定的应用找到主机后如何可靠高效地进行数据传输2. 网络通信要素............
复制链接

扫一扫

专栏目录