Java 网络编程

最新推荐文章于 2024-08-07 21:33:33 发布
最新推荐文章于 2024-08-07 21:33:33 发布
阅读量171 收藏
点赞数 1
分类专栏： Java SE 文章标签： java socket 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45692857/article/details/116676031
版权

概述

计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

JavaWeb：网页编程 B/S

网络编程：TCP/IP C/S

网路通信的要素

如何实现网络的通信？

通信双方地址：

  • IP
  • 端口号
  • 192.168.123.1:8080

规则：网络通信的协议

OSI 七层模型和TCP/IP参考模型：

小结

  1. 网络编程中有两个主要的问题

    • 如何准确的定位到网络上的一台或者多台主机
    • 找到主机之后如何进行通信

  2. 网络编程中的要素

    • IP和端口号
    • 网络通信写协议 udp tcp

  3. 万物皆对象

IP

IP地址：InetAddress

  • 唯一定位一台网络上计算机

  • 127.0.0.1：本机localhost

  • IP地址的分类

    • ipv4/ipv6

      • IPV4 127.0.0.1，4个字节组成。0~255，42亿。
      • IPV6 2001:0DB8:0000:0023:0008:0800:200C:417A，128位。8个无符号整数。

    • 公网（互联网）- 私网（局域网）

      • 192.168.xxx.xxx 局域网

      • IP地址分类

  • 域名：记忆IP问题

例子：

public class TestInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        //查询网站IP地址
        InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress1);
        //查询本地地址
        InetAddress inetAddress2 = InetAddress.getLocalHost();
        System.out.println(inetAddress2);
        //常用方法
        System.out.println(inetAddress1.getAddress());
        System.out.println(inetAddress1.getCanonicalHostName());//规范的名字
        System.out.println(inetAddress1.getHostAddress());//ip
        System.out.println(inetAddress1.getHostName());//域名，或者自己电脑的名字
    }
}

运行结果：

www.baidu.com/163.177.151.110
DESKTOP-QOS6ALD/192.168.123.7
[B@2f7a2457
163.177.151.110
163.177.151.110
www.baidu.com

端口

端口表示计算机上的一个程序的进程。

  • 不同的进程有不同的端口号！用来区分软件！

  • 被规定0~65535

  • TCP/UDP：65535*2 tcp：80，udp：80，单个协议下，端口号不能冲突！

  • 端口分类

    • 公有端口0~1023

      • HTTP：80
      • HTTPS：443
      • FTP：21
      • Telnet：23

    • 程序注册端口：2014~49151，分配用户或者程序

      • Tomcat：8080
      • MySQL：3306
      • Oracle：1521

    • 动态、私有：49152~65535

      netstat -ano#查看所有端口
netstat -ano|findstr "5900"#查看指定端口
tasklist|findstr "8696" #查看指定端口的进程

    • public class TestInetSocketAddress {
    public static void main(String[] args){
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());
        System.out.println(inetSocketAddress.getHostString());
    }
}

通信协议

网络通信协议： 速率、传输码率、代码结构、传输控制…

TCP/IP协议簇

重要：

  • TCP：用户传输协议
  • UDP：用户数据报协议

TCP 和 UDP 对比

TCP：打电话

  • 连接，稳定

  • 三次握手，四次挥手

    三次握手过程理解

    img

    第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

    第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

    第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。

    四次挥手过程理解

    img
    1）客户端进程发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
    2）服务器收到连接释放报文，发出确认报文，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT（关闭等待）状态。TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。
    3）客户端收到服务器的确认请求后，此时，客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最后的数据）。
    4）服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，FIN=1，ack=u+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。
    5）客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
    6）服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。

  • 客户端、服务端

  • 传输完成，释放连接，效率低

UDP：发短信

  • 不连接，不稳定
  • 客户端、服务端：没有明确的界限
  • 不管有没有准备好，都可以发给你

TCP

客户端

  1. 连接服务器Socket

  2. 发送信息

    import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

/**
 * ClassName:TcpClientDemo1
 * Package:com.company.network
 * Description:
 * 客户端
 *
 * @date:2021/3/18 22:44
 * @author:yt
 */

public class TcpClientDemo1 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.要知道服务器地址
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建Socket连接
            socket = new Socket(inetAddress, port);
            //3.发送消息IO流
            os = socket.getOutputStream();
            os.write("你好！".getBytes(StandardCharsets.UTF_8));
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器

  1. 建立服务端口ServerSocket

  2. 等待用户连接 accept

  3. 接受用户的消息

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

/**
 * ClassName:TcpServerDemo1
 * Package:com.company.network
 * Description:
 * 服务器
 *
 * @date:2021/3/18 22:45
 * @author:yt
 */

public class TcpServerDemo1 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);
            while (true) {
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的信息
                is = socket.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }
                System.out.println(baos.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (baos != null) {
                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 (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }


        }
    }
}

文件上传

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/**
 * ClassName:TcpClientDemo2
 * Package:com.company.network
 * Description:
 * 客户端
 * @date:2021/3/18 23:48
 * @author:yt
 */

public class TcpClientDemo2 {
    public static void main(String[] args) throws IOException {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个·输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件
        FileInputStream fis = new FileInputStream(new File("Thread1.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }
        //通知服务器，我已经结束了
        socket.shutdownOutput();
        //确定服务器接收完毕，才能断开连接
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while ((len = is.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
        }
        System.out.println(baos.toString());
        //5.关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}


import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * ClassName:TcpServerDemo2
 * Package:com.company.network
 * Description:
 * 服务器
 * @date:2021/3/18 23:57
 * @author:yt
 */

public class TcpServerDemo2 {
    public static void main(String[] args) throws IOException {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        //阻塞式监听，会一直等到客户端连接
        Socket socket = serverSocket.accept();
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        //通知客户端我接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes(StandardCharsets.UTF_8));
        //关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

UDP

发送数据，不用连接，需要对方的地址！

发送消息

客户端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;

/**
 * ClassName:UdpClientDemo1
 * Package:com.company.network
 * Description:
 * 客户端，不需要连接服务器
 * @date:2021/3/19 10:58
 * @author:yt
 */

public class UdpClientDemo1 {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();

        //2.建个包
        String msg="你好，服务器！";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        DatagramPacket packet = new DatagramPacket(msg.getBytes(StandardCharsets.UTF_8),0,msg.getBytes(StandardCharsets.UTF_8).length,localhost,port);

        //3.发送包
        socket.send(packet);
        //4.关闭资源
        socket.close();
    }


}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * ClassName:UdpServerDemo1
 * Package:com.company.network
 * Description:
 * 服务器，还是要等待客户端连接
 * @date:2021/3/19 10:59
 * @author:yt
 */

public class UdpServerDemo1 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        //阻塞接收
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //关闭连接
        socket.close();
    }
}

循环发送消息

发送端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;

/**
 * ClassName:UdpSenderDemo1
 * Package:com.company.network.chat
 * Description:
 * 发送端
 *
 * @date:2021/3/19 23:58
 * @author:yt
 */

public class UdpSenderDemo1 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);
        //准备数据：控制台读取 System.in
        Scanner sc = new Scanner(System.in);
        while (true) {
            String data = sc.nextLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
            socket.send(packet);
            if (data.equals("bye"))
            {
                break;
            }
        }
        socket.close();
        sc.close();
    }
}

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * ClassName:UdpReceiveDemo1
 * Package:com.company.network.chat
 * Description:
 * 接收端
 * @date:2021/3/19 23:59
 * @author:yt
 */

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

        while (true) {
            //准备接收数据
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            //阻塞式接收数据包
            socket.receive(packet);
            //断开连接 bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, packet.getLength());
            System.out.println(receiveData);
            if(receiveData.equals("bye")){
                break;
            }


        }
        socket.close();
    }
}

咨询

在线咨询：两个人都可以是发送方，也都可以是接收方！

发送端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Scanner;

/**
 * ClassName:TalkSend
 * Package:com.company.network.chat
 * Description:
 *
 * @date:2021/3/20 0:43
 * @author:yt
 */

public class TalkSend implements Runnable {
    DatagramSocket socket = null;
    Scanner sc = null;
    private int formPort;
    private String toIP;
    private int toPort;

    public TalkSend(int formPort, String toIP, int toPort) {
        this.formPort = formPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(formPort);
            sc = new Scanner(System.in);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        //准备数据：控制台读取 System.in

        while (true) {
            String data = sc.nextLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));
            try {
                socket.send(packet);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (data.equals("bye")) {
                break;
            }
        }
        socket.close();
        sc.close();
    }
}

接收端

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

/**
 * ClassName:TalkReceive
 * Package:com.company.network.chat
 * Description:
 *
 * @date:2021/3/20 0:51
 * @author:yt
 */

public class TalkReceive implements Runnable {
    DatagramSocket socket = null;
    private int port;
    private String msgForm;

    public TalkReceive(int port, String msgForm) {
        this.port = port;
        this.msgForm = msgForm;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {
            try {
                //准备接收数据
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                //阻塞式接收数据包
                socket.receive(packet);
                //断开连接 bye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, packet.getLength());
                System.out.println(msgForm+"： "+receiveData);
                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }


        }
        socket.close();
    }
}

例子：

学生

public class TalkStudent {
    public static void main(String[] args){
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

老师

public class TalkTeacher {
    public static void main(String[] args){
        //开启两个线程
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

URL

https://www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源。

DNS域名解析：www.baidu.com xxx.xxx.xxx.xxx

协议：//ip地址:端口/项目名/资源

例子：

public class URLDemo1 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:9090/ROOT/index.jsp");
        //协议
        System.out.println(url.getProtocol());
        //主机ip
        System.out.println(url.getHost());
        //端口
        System.out.println(url.getPort());
        //路径
        System.out.println(url.getPath());
        //文件
        System.out.println(url.getFile());
        //参数
        System.out.println(url.getQuery());

    }
}

下载网络资源

例子：

public class URLDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("http://localhost:9090/yt/yt.txt");
        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("yt.txt");
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        fos.close();
        is.close();
        urlConnection.disconnect();
    }
}
拒绝平庸yt
关注
专栏目录
Python实现TCP通信
qq_35372699的博客
05-17 5631
服务器 监听端口，等待客户端连接 发送消息给客户端 接受客户端的消息 import threading import socket class TcpServer: def __init__(self): self.ip = '127.0.0.1' self.port = 985 self.tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp
网络编程之TCP模型
鹰击长空KO的博客
10-13 522
网络编程之TCP模型
(客户端)python实现tcp通信
09-26
(客户端)python实现tcp通信
1.网络通信
qq_43252908的博客
12-09 325
javaweb ：网页编程 B/S 网络编程：TCP/IP C/S 1.网络通信地址 1.1通信双方的地址： ip 端口号 即可定位至一个计算机上的一个具体的应用 1.2规则：网络通信协议 osi为理想化模型，实际应用更多的是tcp/ip协议 # 1.3 ip ...
Java - 网络编程
最新发布
心如冰清，天塌不惊
08-07 831
即双方进行传输数据，得按照一定的组织形式也就是一定的规则，当对方接收的时候，才能正确读取数据信息，也才能按照相应的规则，响应你要的数据信息。在本机的9999端口监听，等待连接；中文译名为传输控制协议，网络通讯协议，这个协议是Internet最基本的协议，Internet国际互联网络的基础。到达对方的时候，就是包装好的数据(以太网帧)，之后再根据协议，逐渐拆包，得到用户数据。6.当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP 来分配的，是不确定的，是随机的。
python实现TCP通信
零丁若叹
03-01 8288
1.TCP是一种面向连接的可靠地协议，在一方发送数据之前，必须在双方之间建立一个连接，建立的过程需要经过三次握手，通信完成后要拆除连接，需要经过四次握手，这是由ＴＣＰ的半关闭造成的，一方在完成数据发送后要发送一个ＦＩＮ来终止这个方向的连接，一个TCP连接在收到一个FIN后仍能发送数据，但应用程序很少这么做，下面是TCP连接建立和拆除的过程： 2.python可以实现ＴＣＰ服务器和客户端的编程，
python tcp通讯
雪剑封心
03-26 3662
服务端 """ TCP服务端函数示例 """ from socket import * # 创建tcp套接字 # 1.3.3 TCP客户端 tcp_socket = socket(AF_INET, SOCK_STREAM) # 绑定地址 tcp_socket.bind(("192.168.3.11", 8888)) # 设置为监听套接字 (等待队列数) tcp_socket.listen(5) # 等待客户端连接 while True: print("等待客户端连接...") # 返回值
java网络编程
03-03
在本资料中，《Java网络编程》第三版提供了深入浅出的讲解，旨在帮助开发者提升对这一领域的理解。 1. **基础概念**： - **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络...
Java网络编程案例教程习题参考答案 .pdf
12-28
Java网络编程案例教程习题参考答案 Java_network_programming是Java编程语言中一个基础组件，用于实现网络通信。以下是Java网络编程案例教程习题参考答案中涉及到的知识点： 1. Socket编程：Socket是Java网络编程...
Java网络编程期末考试复习题库+答案
07-06
Java网络编程是计算机科学中的一个重要领域，特别是在软件开发中，它涉及到如何通过网络进行数据传输和通信。在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这...
Java网络编程/Java网络编程实例
11-29
Java网络编程是Java开发中的重要领域，它涵盖了网络应用程序的设计、实现和调试。在这个主题下，我们可以探讨多个关键知识点： 1. **Java Socket编程**：Java的Socket类提供了基于TCP/IP协议的网络通信能力。通过...
嵌入式 Linux网络编程（二）——TCP编程模型
weixin_34306593的博客
07-10 341
嵌入式 Linux网络编程（二）——TCP编程模型一、TCP编程模型TCP编程的一般模型如下图：TCP编程模型分为客户端和服务器端编程，两者编程流程如下：TCP服务器端编程流程：A、创建套接字；B、绑定套接字；C、设置套接字为监听模式，进入被动接受连接状态；D、接受请求，建立连接；E、读写数据；F、终止连接。...
python TCP网络通信
qq_42585108的博客
08-18 804
python TCP网络通信一、概念二、客户端构建流程三、服务器端构建流程 tcp通信模型 udp通信模型中，在通信开始之前，不需要建立相关的链接，只需要发送数据即可，类似于生活中，“写信"” tcp通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，“打电话”" 一、概念 tcp客户端和服务端 所谓的服务器端：就是提供服务的一方，而客户端，就是需要被服务的一方 （顺序是先打开服务器，在打开客户端） 二、客户端构建流程 TCP客户端端流程 1、创建socket 2、配置服务器端口
基于TCP协议的通信模型
不积跬步，无以至千里
03-10 1048
服务器端 （1）创建socket，使用socket函数 （2）准备通信地址，使用结构体类型 （3）绑定socket和通信地址，使用bind函数 （4）进行监听，使用listen函数 （5）响应客户端的连接请求，使用accept函数 （6）进行通信，使用read/write函数 （7）关闭socket，使用close函数 例子： //基于socket的本地通信 #in
TCP.01.基础通信模型
老毛的博客
06-24 3531
试看：https://www.bilibili.com/video/BV1cb411w7sZ?p=1 购买：https://study.163.com/course/introduction.htm?courseId=1006358018 先试看一下，做点笔记 作者是C3程序猿 以下简介搬运之原课程介绍 课程章节： 第一章 c/s模型的讲解以及代码实现 第二章 select模型的讲解以及代码实现 第三章 异步选择模型的讲解以及代码实现 第四章 事件选择模型的讲解以及代码实现 第五章 重叠i/o模型的讲解以及
TCP Socket通讯模型
Mao的博客
08-02 375
TCP Socket通讯模型   TCP Socket通讯模型 应用举例： TestServer.java TestCilent.java   TestServer.java /* 范例名称：简单的client/server程序 * 源文件名称：TestClient.java/TestServer.java * 要 点： * 1. Java Socket编...
基于TCP协议的网络通信模型
weixin_53333929的博客
07-08 761
基于TCP协议的网络通信模型是TCP/IP协议族中的一部分，该模型主要用于确保数据在网络中能够可靠、有序地传输。传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它由IETF的RFC 793定义，用于在不可靠的互联网络上提供可靠的端到端字节流传输。TCP协议通过三次握手建立连接，通过四次挥手断开连接，并利用序列号、确认应答、重发控制、连接管理以及窗口控制等机制实现可靠传输。TCP协议提供的面向连接的、可靠的传输服务。
python中网络tcp
房东的猫咪的博客
12-25 222
python中网络tcp 1. tcp简介"" TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是一种面 向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。 TCP通信需要经过创建连接、数据传送、终止连接三个步骤。 TCP通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，...
Python网络 tcp
阿鹏的博客
04-07 279
TCP TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是⼀ 种⾯向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。 TCP通信需要经过创建连接、数据传送、终⽌连接三个步骤。 TCP通信模型中，在通信开始之前，⼀定要先建⽴相关的链接，才能发送数据，类似于⽣ 活中，"打电话"需要建立链接，确认发送结果，安全传输...
Java网络编程深入解析
总体来说，《Java网络高级编程》是一本全面覆盖Java网络技术的教材，适合对Java网络编程有深入学习需求的大学生、研究生，以及对此领域感兴趣的自学者。通过阅读本书，读者可以系统地掌握Java在网络环境中的高级应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值