【JavaEE】网络编程之TCP套接字、UDP套接字

这篇具有很好参考价值的文章主要介绍了【JavaEE】网络编程之TCP套接字、UDP套接字。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

1.网络编程的基本概念

1.1为什么需要网络编程 

1.2服务端与用户端

1.3网络编程五元组 

1.4套接字的概念

2.UDP套接字编程

2.1UDP套接字的特点

 2.2UDP套接字API

2.2.1DatagramSocket类

2.2.2DatagramPacket类 

2.2.3基于UDP的回显程序

2.2.4基于UDP的单词查询 

3.TCP套接字编程

3.1TCP套接字的特点

3.2TCP中的长短连接

3.3TCP套接字的API

3.3.2Socket类

3.3.3基于TCP的回显程序

3.3.4对TCP回显程序的优化


1.网络编程的基本概念

网络编程,指网络上的主机,通过不同的进程,以编程的方式实现网络通信(或称为网络数据传输)。对于我们程序员来说,我们比较关注应用层到传输层这一操作,我们代码的书写是发生在应用层的,然后通过传输层提供的API(UDP和TCP)进行包装,再由应用层发送给传输层。

1.1为什么需要网络编程 

 这个最为直接的说话莫过于人民需要他了,哪里有需求,哪里就提供响应嘛。

相比于本地的资源,网络上有这更为丰富的资源,而网络上的资源又需要通过网络编程来上传,因此就相互督促相互促进了对方的发展。

1.2服务端与用户端

服务端:在常见的网络数据传输场景下,把提供服务的一方进程,称为服务端,可以提供对外服务。
客户端:获取服务的一方进程,称为客户端。

简单的说,客户端会接收到客户的请求,再将客户的请求发送给服务端;服务端将请求按照业务逻辑完成响应,再将响应返回给客户端,客户端再将响应按照操作显示或者运作。

【JavaEE】网络编程之TCP套接字、UDP套接字

1.3网络编程五元组 

  1. 源IP:就是发送方IP.
  2. 源端口:发送方端口号, 服务器需要手动指定, 客户端让系统随机分配即可.
  3. 目的IP: 接收方IP, 包含在拿到的数据报中, 服务器响应时的目的IP就在客户端发来的数据报中, 客户端发送请求时的目的IP就是服务器的IP.
  4. 目的端口: 接收方端口号包含在数据报中, 服务器响应时的目的端口就在客户端发来的数据报中, 客户端发送请求时的目的端口就是服务器的端口号.
  5. 协议类型:如UDP/TCP.

1.4套接字的概念

Socket(套接字)可以看成是两个网络应用程序进行通信时,各自通信连接中的端点,这是一个逻辑上的概念。Socket是由IP地址和端口结合的,提供向应用层进程传送数据包的机制 

套接字的表示方法:Socket=Ip接口:端口号

2.UDP套接字编程

2.1UDP套接字的特点

特点如下:

  • 无连接:不关心和谁对话,也不会刻意留意对方。
  • 不可靠的:不关心他收没收到。
  • 面向数据报:以一个UDP数据报为单位。
  • 全双工通信:一条路径,但是路径两方都可以对话。(双向对话)

【JavaEE】网络编程之TCP套接字、UDP套接字

 2.2UDP套接字API

UDP套接字的API中主要包括两个类 :1.DatagramSocket 2.DatagramPacket。

下面就开始介绍这两个类

2.2.1DatagramSocket类

 DatagramSocket类就是实例一个UDP版本的套接字也是就数据包套接字。Socket对象对应到系统中的一个特殊文件(socket文件),socket文件不是数据存储区域的一部分,而是对应到网卡这个硬件设备,为什么对应到网卡呢?因为网卡是一个硬件,对于代码而已,不好直接操作,因此将它抽象成了一个文件进行间接操作。

DatagramSocket类构造方法:

方法签名 方法说明
DatagramSocket() 创建一个UDP数据报套接字的Socket,绑定到本机任意一个随机端口
(一般用于客户端)
DatagramSocket(int
port)
创建一个UDP数据报套接字的Socket,绑定到本机指定的端口(一般用
于服务端)

我们一般使用第二个方法,我们知道端口号是在一个计算机中寻找一个程序的“门牌号”。实际操作时,如果端口号是系统随机绑定的话,我们就不知道我们服务端服务于哪一个客户端了,就没有办法找到客户端的家了。

DatagramSocket类方法:

方法签名 方法说明
void
receive(DatagramPacket p)
从此套接字接收数据报(如果没有接收到数据报,该方法会阻
塞等待)
void send(DatagramPacket
p)
从此套接字发送数据报包(不会阻塞等待,直接发送)
void close() 关闭此数据报套接字

第一个receive方法它的参数需要准备一个空的DatagramPacket对象(对象需要给予存储空间),它把DatagramPacket实例对象再装入到准备好的空的DatagramPacket对象中去 ,为什么这样做呢?就像我们平常接收东西时,我们需要一个载体来承接这个物件,举个例子吧,当我们盛饭时,我们不能够直接用手去捧着饭,而是需要一个空饭盒去接打的饭。

第二个send方法他是DatagramPacket实例对象载入到接收缓冲区。

第三个close方法,因为DatagramSocket类属于文件资源,当我们不用的时候,我们需要将它给手动关闭了。

2.2.2DatagramPacket类 

DatagramPacket是UDP Socket发送和接收的数据报。 

DatagramPacket类构造方法

方法签名 方法说明
DatagramPacket(byte[]
buf, int length)
构造一个DatagramPacket以用来接收数据报,接收的数据保存在
字节数组(第一个参数buf)中,接收指定长度(第二个参数
length)
DatagramPacket(byte[]
buf, int offset, int length,
SocketAddress address)
构造一个DatagramPacket以用来发送数据报,发送的数据为字节
数组(第一个参数buf)中,从0到指定长度(第二个参数
length)。address指定目的主机的IP和端口号

这两个构造方法都会使用到,第一个构造方法:他就是我们上方说的空的DatagramPacket对象也就是我们举例说的“空饭盒”,第二个构造方法是在我们将接收到的请求进行封装时使用的,假设我们接收到的请求是字符串,我们就要将它转化成byte数组,再算出长度,并且需要指定它要发送到那里去也就是SockerAddress类的一个子类InetSocketAddress类它里面包含目的ip和目的端口号。

DatagramPacket类方法:

方法签名 方法说明
InetAddress
getAddress()
从接收的数据报中,获取发送端主机IP地址;或从发送的数据报中,获取
接收端主机IP地址
int getPort() 从接收的数据报中,获取发送端主机的端口号;或从发送的数据报中,获
取接收端主机端口号
byte[] getData() 获取数据报中的数据

2.2.3基于UDP的回显程序

UDP服务端:

服务器设计逻辑: 

  1.  创建DatagramSocket对象,指定服务器端口号。
  2. 服务器启动了,我们需要一个DatagramPacket实例运来当作载体,当没有请求时,在这里就会发生阻塞,有请求时,就写入到DatagramPacket实例好的载体中。
  3. 接收到数据后,我们将数据拆分成我们需要的格式,因为我们是一个回显,故我们只需将它改成字符串就行了,再调用process方法,在这里完成业务需求,我们这里只需返回字符串就像了。
  4. 将处理好的请求,再封装一下,封装成DatagramPacket实例对象,将这个响应发生使用send方法发送给客户端即可。
package UdpNetWork;

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

//服务器端
public class UdpEchoServer {

    private DatagramSocket socket=null;
    public UdpEchoServer(int port) throws SocketException {
        this.socket=new DatagramSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
            //requestPacket是一个载体,receive方法会将发送过来的数据放入到这个载体中
            DatagramPacket requestPacket=new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            //将发来的数据拆解
            String request=new String(requestPacket.getData(),0, requestPacket.getLength());
            //做出响应
            String response=process(request);
            //将做出的响应包装起来,发给客户端
            DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //打印日志
            System.out.printf("[%s:%d] req:%s,resp:%s\n",requestPacket.getAddress().toString(),requestPacket.getPort(),
                    request,response);
        }
    }

    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer udpEchoServer=new UdpEchoServer(9090);
        udpEchoServer.start();
    }
}

 UDP客户端:

 客户端设计逻辑:

  1.  客户端需要知道服务端的位置,因此我们需要服务端的ip地址和端口号,故成员变量包含Ipserver、serverPort以及一个DatagramSocket对象(可以理解为整合ip和端口号)。
  2. 开始运行客户端,通过Scaner接收客户的请求。
  3. 拿到请求后,我们需要将它封装成DatagramPacket对象,发送给服务端。
  4. 发送完就等待服务端返回响应。
  5. 等到拿到响应之后,我们就可以对响应做出操作了,因为我们这里是回显,我们只需将返回过来的字符串打印出来即可。
package UdpNetWork;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

//客户端
public class UdpEchoClient {
    private DatagramSocket socket=null;
    private int serverPort;
    private String IpServer;

    public UdpEchoClient(int port, String ipServer) throws SocketException {
        socket=new DatagramSocket();
        this.serverPort=port;
        this.IpServer=ipServer;
    }
    public void start() throws IOException {
        Scanner sc=new Scanner(System.in);
        while (true) {
            System.out.print("输入字符->");
            String request=sc.next();
            //将输入的指令打包
            DatagramPacket requestPacket=new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(IpServer),serverPort);
            //发送给服务器端
            socket.send(requestPacket);
            DatagramPacket responsePacket=new DatagramPacket(new byte[4096], 4096);
            //接收服务器端的响应结果
            socket.receive(responsePacket);
            //打印服务端的响应
            String response=new String(responsePacket.getData(),0,responsePacket.getLength());
            //打印日志
            System.out.printf("req:%s,resp:%s\n",request,response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient udpEchoClient=new UdpEchoClient(9090,"127.0.0.1");
        udpEchoClient.start();
    }
}

2.2.4基于UDP的单词查询 

对于这个服务端,我们不需要再写一边start方法了,我们可以直接让它继承udpEchoServer类,并且,我们在上方服务端,我们将对请求处理的部分拿出来当作了一个单独的函数,我们在将上方的函数进行重写就行了,还有就是,我们需要一个存储单词,并且它还方便查询的东西,我们就想到一个数据结构就是Map,刚好可以适合这个系统。

package UdpNetWork;

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

public class UdpDictServer extends UdpEchoServer{
    //字典表
    private Map<String, String> dict = new HashMap<>();

    public UdpDictServer(int port) throws SocketException {
        super(port);

        dict.put("dog", "小狗");
        dict.put("cat", "小猫");
        dict.put("fuck", "卧槽");
        // ........... 可以无限的添加很多很多数据. 有道词典和咱们相比, 就是人家的这个表更大!!
    }

    @Override
    public String process(String request) {
        return dict.getOrDefault(request, "该单词没有查到!");
    }

    public static void main(String[] args) throws IOException {
        UdpDictServer udpDictServer = new UdpDictServer(9090);
        udpDictServer.start();
    }
}

3.TCP套接字编程

3.1TCP套接字的特点

特点如下:

  1. 有链接:双方通信,都需要可以留意对方信息。
  2. 可靠传输:尽可能的将数据传输给对方,但也不能保证100%。
  3. 面向字节流:以一个字节传输为基本单位。
  4. 全双工:双方都可以向对方发送信息。

3.2TCP中的长短连接

TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
长连接:不关闭连接,一直保持连接状态,双方不停的收发数据,即是长连接。也就是说,长连接可以多次收发数据。

长连接与短链接的区别:

  • 建立连接、关闭连接的耗时:短连接每次请求、响应都需要建立连接,关闭连接;而长连接只需要第一次建立连接,之后的请求、响应都可以直接传输。相对来说建立连接,关闭连接也是要耗时的,长连接效率更高。
  • 主动发送请求不同:短连接一般是客户端主动向服务端发送请求;而长连接可以是客户端主动发送请求,也可以是服务端主动发。
  • 两者的使用场景有不同:短连接适用于客户端请求频率不高的场景,如浏览网页等。长连接适用于客户端与服务端通信频繁的场景,如聊天室,实时游戏等。

3.3TCP套接字的API

TCP套接字的API中主要包含两个类:1.ServerSocket 2.Socket

下面介绍这两个类

3.3.1ServerSocket类

这个类是在看名字就很好理解,它主要用于服务端,它的作用是创建一个服务端套接字。

 ServerSocket类构造方法:

方法签名 方法说明
ServerSocket(int port) 创建一个服务端流套接字Socket,并绑定到指定端口

在实例对象时,我们就将端口号传进来,完成实例。

 ServerSocket类方法:

方法签
方法说明
Socket
accept()
开始监听指定端口(创建时绑定的端口),有客户端连接后,返回一个服务端Socket
对象,并基于该Socket建立与客户端的连接,否则阻塞等待
void
close()
关闭此套接字

 第一个accept方法它是接收客户端的信息,如果客户端没有请求,那它就会阻塞等待,如果有请求,就会建立连接,它的返回值是一个套接字。

3.3.2Socket类

 这个类就是创建一个套接字实例对象,他的成员变量有两个:IP与端口号。

Socket类构造方法:

方法签名 方法说明
Socket(String host, int
port)
创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的
进程建立连接

Socket类方法:

方法签名 方法说明
InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

 3.3.3基于TCP的回显程序

服务端 

 服务器设计逻辑:

  1. 创建一个ServerSocket类对象,指定服务器端口号。
  2. 开始运行服务端;通过第一步实例好的对象调用accept方法,如果有无请求,就阻塞,如果有请求,就发到下面进行处理。
  3. 进入处理请求方法,将请求通过读接收缓冲区写入,再将写入的请求发给处理程序进行处理。
  4. 处理完毕后,将响应发给客服端。
package TcpNetWork;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    private ServerSocket serverSocket=null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
            //接收到客服端请求
            Socket clientSocket=serverSocket.accept();
            //将请求发给解决请求的方法
            processConnection(clientSocket);
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线了\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        try (InputStream inputStream=clientSocket.getInputStream();
             OutputStream outputStream=clientSocket.getOutputStream()){
            // 没有这个 scanner 和 printWriter, 完全可以!! 但是代价就是得一个字节一个字节扣, 找到哪个是请求的结束标记 \n
            // 不是不能做, 而是代码比较麻烦.
            // 为了简单, 把字节流包装好了更方便的字符流~~
            Scanner sc=new Scanner(inputStream);
            PrintWriter printWriter=new PrintWriter(outputStream);
            while (true) {
                //1.接到客服端请求
                if (!sc.hasNext()) {
                    System.out.printf("[%s:%d] 客户端下线了\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                String request=sc.next();
                //2.对请求做出响应
                String response=process(request);
                //3.把响应返回给客户端
                printWriter.println(response);
                printWriter.flush();
                System.out.printf("[%s:%d] request:%s response:%s ",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer=new TcpEchoServer(9999);
        tcpEchoServer.start();
    }
}

客户端

客户端设计逻辑:

  1. 创建一个Socket实例,指定服务器的ip和端口号。
  2. 开启客户端,输入请求,并刷新接收缓存区。
  3. 等到服务端给出响应,接收响应,对响应做出动作。
package TcpNetWork;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
   private Socket socket=null;

    public TcpEchoClient(int port, String serverIp) throws IOException {
        socket=new Socket(serverIp,port);
    }

    public void start() {
        Scanner sc=new Scanner(System.in);
        try(InputStream inputStream=socket.getInputStream();
            OutputStream outputStream=socket.getOutputStream()) {
            Scanner scannerFromSocket=new Scanner(inputStream);
            PrintWriter printWriter=new PrintWriter(outputStream);
            while (true) {
                //1.从键盘上读取请求
                System.out.print("输入指令->");
                String request=sc.next();
                //2.将请求发送给服务器端,并刷新接收缓存区
                printWriter.println(request);
                printWriter.flush();
                //3.接收服务器端的信息
                String response=scannerFromSocket.next();
                //4.把信息打印到控制台
                System.out.printf("request:%s response:%s\n",request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient tcpEchoClient=new TcpEchoClient(9999,"127.0.0.1");
        tcpEchoClient.start();
    }
}

3.3.4对TCP回显程序的优化

在上方的程序中,我们只能对一个客户端进行提供服务,这是因为我们在接收的部分给写成了死循环,如果出现第二个客户端时,第二个客户端只能进行等待。我们如何修改这个程序呢?这是我们就不得不提到多线程了,如果写成多线程的话,就可以处理多个程序了。

程序代码如下(服务端): 

package TcpNetWork;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    private ServerSocket serverSocket=null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
            //接收到客服端请求
            Socket clientSocket=serverSocket.accept();
            //将请求发给解决请求的方法
            Thread t=new Thread(()->{
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线了\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        try (InputStream inputStream=clientSocket.getInputStream();
             OutputStream outputStream=clientSocket.getOutputStream()){
            // 没有这个 scanner 和 printWriter, 完全可以!! 但是代价就是得一个字节一个字节扣, 找到哪个是请求的结束标记 \n
            // 不是不能做, 而是代码比较麻烦.
            // 为了简单, 把字节流包装好了更方便的字符流~~
            Scanner sc=new Scanner(inputStream);
            PrintWriter printWriter=new PrintWriter(outputStream);
            while (true) {
                //1.接到客服端请求
                if (!sc.hasNext()) {
                    System.out.printf("[%s:%d] 客户端下线了\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                String request=sc.next();
                //2.对请求做出响应
                String response=process(request);
                //3.把响应返回给客户端
                printWriter.println(response);
                printWriter.flush();
                System.out.printf("[%s:%d] request:%s response:%s ",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
                System.out.println();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            clientSocket.close();
        }
    }

    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer=new TcpEchoServer(9999);
        tcpEchoServer.start();
    }
}

如果我们想要去验证这个程序是否可以对多个客户端提供服务,我们还需要对其修改一点配置,不然我们不能将同一个类运行两次。

 1.右键鼠标,选择修改运行配置 

【JavaEE】网络编程之TCP套接字、UDP套接字 2.点开之后,点击修改选项 

【JavaEE】网络编程之TCP套接字、UDP套接字 3.将允许多个实例打勾,这一我们就可以同时运行多个实例了。

【JavaEE】网络编程之TCP套接字、UDP套接字


写在最后:

🐣🐣🐣以上就是本文全部内容,如果对你有所帮助,希望能留下你的点赞+关注,我会更加努力的更新内容!非常感谢🧡🧡🧡

若本篇文章有错误的地方,欢迎大佬们指正!

【JavaEE】网络编程之TCP套接字、UDP套接字文章来源地址https://www.toymoban.com/news/detail-419416.html

到了这里,关于【JavaEE】网络编程之TCP套接字、UDP套接字的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 网络编程【TCP流套接字编程】

    目录 TCP流套接字编程 1.ServerSocket API 2.Socket API 3.TCP中的长短连接 4.回显程序(短连接) 5.服务器和客户端它们的交互过程 6.运行结果及修改代码   ❗❗两个核心: ServerSocket     Socket 1.ServerSocket API ✨ ServerSocket 是创建 TCP服务端Socket的API ServerSocket 构造方法: ServerSocket 方法 :

    2023年04月12日
    浏览(128)
  • 网络编程套接字( TCP )

    目录 1、实现一个TCP网络程序(单进程版)         1.1、服务端serverTcp.cc文件                  服务端创建套接字                  服务端绑定                  服务端监听                  服务端获取连接                  服务

    2024年01月17日
    浏览(215)
  • 【JaveEE】网络编程之TCP套接字、UDP套接字

    目录 1.网络编程的基本概念 1.1为什么需要网络编程  1.2服务端与用户端 1.3网络编程五元组  1.4套接字的概念 2.UDP套接字编程 2.1UDP套接字的特点  2.2UDP套接字API 2.2.1DatagramSocket类 2.2.2DatagramPacket类  2.2.3基于UDP的回显程序 2.2.4基于UDP的单词查询  3.TCP套接字编程 3.1TCP套接字的特

    2023年04月13日
    浏览(141)
  • 【网络编程】网络编程套接字(三)TCP网络程序

    与前边的UDP网络程序相同,创建套接字的接口都是socket,下边对socket接口进行介绍: 协议家族选择AF_INET,因为我们要进行网络通信。 而第二个参数,为服务类型,传入SOCK_STREAM,我们编写TCP程序,所以要选择流式的服务。 第三个参数默认传入0,由前两个参数就可以推出这是

    2024年02月16日
    浏览(56)
  • 【Linux网络】网络编程套接字(TCP)

    目录 地址转换函数 字符串IP转整数IP 整数IP转字符串IP 关于inet_ntoa 简单的单执行流TCP网络程序 TCP socket API 详解及封装TCP socket  服务端创建套接字  服务端绑定  服务端监听  服务端获取连接  服务端处理请求 客户端创建套接字 客户端连接服务器 客户端发起请求 服务器测试

    2024年03月21日
    浏览(67)
  • 【Linux】网络---->套接字编程(TCP)

    TCP的编程流程:大致可以分为五个过程,分别是准备过程、连接建立过程、获取新连接过程、消息收发过程和断开过程。 1.准备过程:服务端和客户端需要创建各自的套接字,除此之外服务端还需要绑定自己的地址信息和进行监听。注意:服务端调用listen函数后,处理监听状

    2024年02月04日
    浏览(61)
  • Linux网络编程——tcp套接字

    本章Gitee仓库:tcp套接字 客户端: 客户端: 关于构造和初始化,可以直接在构造的时候,将服务器初始化,那为什么还要写到 init 初始化函数里面呢? 构造尽量简单一点,不要做一些“有风险”的操作。 tcp 是面向连接的,通信之前要建立连接,服务器处于等待连接到来的

    2024年02月20日
    浏览(52)
  • 网络编程套接字之三【TCP】

    目录 1. ServerSocket API(给服务器端使用的类) 2. Socket API(既给服务器使用,也给客户端使用) 3. 写TCP回显—服务器 4. 使用线程池后的TCP服务器代码(最终) 5. 写回显-客户端 6. TCP回显—客户端代码 7. 运行回显服务器和客户端 TCP流套接字编程  ServerSocket 是创建TCP服务端Socket的

    2024年01月19日
    浏览(54)
  • 网络编程套接字(2)——简单的TCP网络程序

    我们将TCP服务器封装成一个类,当我们定义出一个服务器对象后需要马上对服务器进行初始化,而初始化TCP服务器要做的第一件事就是创建套接字。 TCP服务器在调用socket函数创建套接字时,参数设置如下: 协议家族选择 AF_INET ,因为我们要进行的是网络通信。 创建套接字时

    2024年02月06日
    浏览(54)
  • 【Linux网络编程】网络编程套接字(TCP服务器)

    作者:爱写代码的刚子 时间:2024.4.4 前言:本篇博客主要介绍TCP及其服务器编码 只介绍基于IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP地址 但是我们通常用点分十进制的字符串表示IP地址,以下函数可以在字符串表示和in_addr表示之间转换 字符串转in

    2024年04月14日
    浏览(74)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包