精华内容
下载资源
问答
  • 基于UDP协议的简单Socket通信实例(JAVA)

    服务器端收发代码:

    public static void main(String[] args) throws IOException {
            /*
             * 接收客户端发送的数据
             */
            // 1.创建服务器端DatagramSocket,指定端口 默认本地ip地址
            DatagramSocket socket = new DatagramSocket(12345);
            // 2.创建数据报,用于接收客户端发送的数据
            byte[] data = new byte[1024];// 创建字节数组,指定接收的数据包的大小
            DatagramPacket packet = new DatagramPacket(data, data.length);
            // 3.接收客户端发送的数据
            System.out.println("****服务器端已经启动,等待客户端发送数据");
            socket.receive(packet);// 此方法在接收到数据报之前会一直阻塞
            //*************此方法在接收到数据报之前会一直阻塞*************************
            // 4.读取数据
            String info = new String(data, 0, packet.getLength());
            System.out.println("我是服务器,客户端说:" + info);
    
            /*
             * 服务器向客户端响应数据
             */
            // 1.定义客户端的地址、端口号、数据
            InetAddress ip = packet.getAddress();//获取数据来源ip地址
            int port = packet.getPort();//获取数据来源端口
            byte[] data2 = "服务器测试数据".getBytes();
            // 2.创建数据报,包含响应的数据信息
            DatagramPacket packet2 = new DatagramPacket(data2, data2.length, ip, port);
            // 3.响应客户端
            socket.send(packet2);
            // 4.关闭资源
            socket.close();
        }

    控制台输出:

    ****服务器端已经启动,等待客户端发送数据
    我是服务器,客户端说:客户端测试数据
    
    Process finished with exit code 0

    2、客户端收发代码:

    public static void main(String[] args) throws IOException {
            InetAddress ip = InetAddress.getLocalHost(); //获取本地的ip地址
            int port = 12345;
    //        InetAddress ip = InetAddress.getByName(); //在给定主机名的情况下确定主机的IP地址.如果参数为null,获得的是本机的IP地址
            byte[] data = "客户端测试数据".getBytes();
            // 2.创建数据报,包含发送的数据信息
            DatagramPacket packet = new DatagramPacket(data, data.length, ip, port);
            // 3.创建DatagramSocket对象
            DatagramSocket socket = new DatagramSocket();
            // 4.向服务器端发送数据报
            socket.send(packet);
            //*****************开始向服务器发送数据,等待向应中*********************
    
            /*
             * 接收服务器端响应的数据
             */
            // 1.创建数据报,用于接收服务器端响应的数据
            byte[] data2 = new byte[1024];
            DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
            // 2.接收服务器响应的数据
            socket.receive(packet2);
            // 3.读取数据
            String reply = new String(data2, 0, packet2.getLength());
            System.out.println("我是客户端,服务器说:" + reply);
            // 4.关闭资源
            socket.close();
        }

    控制台输出:

    
    我是客户端,服务器说:服务器测试数据
    
    Process finished with exit code 0

    什么是Socket?

    • Socket就是为网络服务提供的一种机制。
    • 通讯的两端都有Sokcet
    • 网络通讯其实就是Sokcet间的通讯
    • 数据在两个Sokcet间通过IO传输。
    • TCP与UDP在概念上的区别:

    TCP与UDP在概念上的区别:

    UDP: a、是面向无连接, 将数据及源的封装成数据包中,不需要建立连接

              b、每个数据报的大小在限制64k内

              c、因无连接,是不可靠协议

              d、不需要建立连接,速度快

    TCP: a、建议连接,形成传输数据的通道.

              b、在连接中进行大数据量传输,以字节流方式

              c 通过三次握手完成连接,是可靠协议

              d 必须建立连接m效率会稍低

    展开全文
  • Linux C/C++ TCP Socket通信实例 - zkfopen - 博客园 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<errno.h> #include<sys/types.h> #include<sys/...

    Linux C/C++ TCP Socket通信实例 - zkfopen - 博客园

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<errno.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<unistd.h>
    
    #define MAXLINE 4096
    
    int main(int argc, char** argv){
        int  listenfd, connfd;
        struct sockaddr_in  servaddr;
        char  buff[4096];
        int  n;
    
        if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
            printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
    
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(6666);
    
        if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
            printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
    
        if( listen(listenfd, 10) == -1){
            printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
    
        printf("======waiting for client's request======\n");
        while(1){
            if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
                printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
                continue;
            }
            n = recv(connfd, buff, MAXLINE, 0);
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);
            close(connfd);
        }
        close(listenfd);
        return 0;
    }

    client

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<errno.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<unistd.h>
    #define MAXLINE 4096
    
    int main(int argc, char** argv){
        int   sockfd, n;
        char  recvline[4096], sendline[4096];
        struct sockaddr_in  servaddr;
    
        if( argc != 2){
            printf("usage: ./client <ipaddress>\n");
            return 0;
        }
    
        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
            printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
            return 0;
        }
    
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(6666);
        if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
            printf("inet_pton error for %s\n",argv[1]);
            return 0;
        }
    
        if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
            printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
            return 0;
        }
    
        printf("send msg to server: \n");
        fgets(sendline, 4096, stdin);
        if( send(sockfd, sendline, strlen(sendline), 0) < 0){
            printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
            return 0;
        }
        close(sockfd);
        return 0;
    }

    展开全文
  • python的socket通信实例

    2021-01-12 07:28:49
    一、socket简介1. 套接字套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象。它们允许程序接受并进行连接,如发送和接受数据。为了建立通信通道,网络...

    一、socket简介

    1. 套接字

    套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象。

    它们允许程序接受并进行连接,如发送和接受数据。为了建立通信通道,网络通信的每个端点拥有一个套接字对象极为重要。

    套接字为BSD UNIX系统核心的一部分,而且他们也被许多其他类似UNIX的操作系统包括Linux所采纳。

    许多非BSD UNIX系统(如ms-dos,windows,os/2,mac os及大部分主机环境)都以库形式提供对套接字的支持。

    三种最流行的套接字类型是:stream,datagram和raw。

    stream和datagram套接字可以直接与TCP协议进行接口,

    raw套接字则接口到IP协议。

    但套接字并不限于TCP/IP。

    2、套接字模块

    套接字模块是一个非常简单的基于对象的接口,它提供对低层BSD套接字样式网络的访问。

    使用该模块可以实现客户机和服务器套接字。

    要在python 中建立具有TCP和流套接字的简单服务器,需要使用socket模块。

    利用该模块包含的函数和类定义,可生成通过网络通信的程序。

    3. 一般来说,建立服务器连接需要六个步骤。

    第1步: 创建socket对象。

    调用socket构造函数。

    socket=socket.socket(familly,type)

    family的值可以是AF_UNIX(Unix域,用于同一台机器上的进程间通讯),也可以是AF_INET(对于IPV4协议的TCP和 UDP),

    至于type参数,SOCK_STREAM(流套接字)或者 SOCK_DGRAM(数据报文套接字),SOCK_RAW(raw套接字)。

    第2步: 是将socket绑定(指派)到指定地址上,socket.bind(address)

    address必须是一个双元素元组,((host,port)),主机名或者ip地址+端口号。

    如果端口号正在被使用或者保留,或者主机名或ip地址错误,则引发socke.error异常。

    第3步: 绑定后,必须准备好套接字,以便接受连接请求。

    socket.listen(backlog)

    backlog指定了最多连接数,至少为1,接到连接请求后,这些请求必须排队,如果队列已满,则拒绝请求。

    第4步: 服务器套接字通过socket的accept方法等待客户请求一个连接:

    connection,address=socket.accept()

    调用accept方法时,socket会进入'waiting'(或阻塞)状态。客户请求连接时,方法建立连接并返回服务器。

    accept方法返回一个含有俩个元素的元组,形如(connection,address)。

    第一个元素(connection)是新的socket对象,服务器通过它与客户通信;

    第二个元素(address)是客户的internet地址。

    第5步: 处理阶段,

    服务器和客户通过send和recv方法通信(传输数据)。

    服务器调用send,并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。

    服务器使用recv方法从客户接受信息。调用recv时,必须指定一个整数来控制本次调用所接受的最大数据量。

    recv方法在接受数据时会进入'blocket'状态,最后返回一个字符串,用它来表示收到的数据。

    如果发送的量超过recv所允许,数据会被截断。

    多余的数据将缓冲于接受端。以后调用recv时,多余的数据会从缓冲区删除。

    第6步: 传输结束,

    服务器调用socket的close方法以关闭连接。

    4. 建立一个简单客户连接则需要4个步骤。

    第1步,创建一个socket以连接服务器 socket=socket.socket(family,type)

    第2步,使用socket的connect方法连接服务器 socket.connect((host,port))

    第3步,客户和服务器通过send和recv方法通信。

    第4步,结束后,客户通过调用socket的close方法来关闭连接。

    5. python 编写server的步骤:

    第一步是创建socket对象。调用socket构造函数。如:

    socket = socket.socket( family, type )

    family参数代表地址家族,可为AF_INET或AF_UNIX。

    AF_INET家族包括Internet地址,AF_UNIX家族用于同一台机器上的进程间通信。

    type参数代表套接字类型,可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。

    第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的:

    socket.bind( address )

    由AF_INET所创建的套接字,address地址必须是一个双元素元组,格式是(host,port)。

    host代表主机,port代表端口号。

    如果端口号正在使用、主机名不正确或端口已被保留,bind方法将引发socket.error异常。

    第三步是使用socket套接字的listen方法接收连接请求。

    socket.listen( backlog )

    backlog指定最多允许多少个客户连接到服务器。它的值至少为1。

    收到连接请求后,这些请求需要排队,如果队列满,就拒绝请求。

    第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。

    connection, address = socket.accept()

    调 用accept方法时,socket会时入“waiting”状态。客户请求连接时,方法建立连接并返回服务器。

    accept方法返回一个含有两个元素的 元组(connection,address)。

    第一个元素connection是新的socket对象,服务器必须通过它与客户通信;

    第二个元素 address是客户的Internet地址。

    第五步是处理阶段,服务器和客户端通过send和recv方法通信(传输 数据)。

    服务器调用send,并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。

    调用recv 时,服务器必须指定一个整数,它对应于可通过本次方法调用来接收的最大数据量。

    recv方法在接收数据时会进入“blocked”状态,最后返回一个字符 串,用它表示收到的数据。

    如果发送的数据量超过了recv所允许的,数据会被截短。多余的数据将缓冲于接收端。

    以后调用recv时,多余的数据会从缓冲区 删除(以及自上次调用recv以来,客户可能发送的其它任何数据)。

    传输结束,服务器调用socket的close方法关闭连接。

    6.python编写client的步骤:

    创建一个socket以连接服务器:

    socket = socket.socket( family, type )

    使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下:

    socket.connect( (host,port) )

    host代表服务器主机名或IP,port代表服务器进程所绑定的端口号。

    如连接成功,客户就可通过套接字与服务器通信,如果连接失败,会引发socket.error异常。

    处理阶段,客户和服务器将通过send方法和recv方法通信。

    传输结束,客户通过调用socket的close方法关闭连接。

    二、socket通信的简单的例子

    1. TCP server端代码

    #!/usr/bin/env python

    #

    # -*- coding:utf-8 -*-

    #

    from socket import *

    from time import ctime

    HOST = ''

    PORT = 21567

    BUFSIZE=1024

    ADDR=(HOST, PORT)

    tcpSrvSock=socket(AF_INET, SOCK_STREAM)

    tcpSrvSock.bind(ADDR)

    tcpSrvSock.listen(5)

    while True:

    print 'waiting for connection ...'

    tcpCliSock,addr = tcpSrvSock.accept()

    print '... connected from:', addr

    while True:

    data=tcpCliSock.recv(BUFSIZE)

    if not data:

    break

    tcpCliSock.send('[%s] %s'%(ctime(), data))

    print [ctime()],':',data

    tcpCliSock.close()

    tcpSrvSock.close()

    2. TCP client端代码

    #!/usr/bin/env python

    #

    # -*- coding:utf-8 -*-

    #

    from socket import *

    HOST='localhost'

    PORT=21567

    BUFSIZE=1024

    ADDR=(HOST, PORT)

    tcpCliSock=socket(AF_INET, SOCK_STREAM)

    tcpCliSock.connect(ADDR)

    while True:

    data = raw_input('>')

    if not data:

    break

    tcpCliSock.send(data)

    data=tcpCliSock.recv(BUFSIZE)

    if not data:

    break

    print data

    tcpCliSock.close()

    三、使用SocketServer模块实现TCP和UDP通信

    SocketServer模块简化了网络服务器的开发。

    它提供了四个基本的服务器类:

    TCPServer : 用于TCP协议,它提供客户端与服务端之间连续的数据流通信;

    UDPServer : 用于UDP协议,它的数据封装包是无序的,且有可能会在传输中丢失;

    UnixStreamServer和UnixDatagramServer: 它们不经常用;

    这四个类处理同步请求,即只有当当前请求处理完成后,才能开始处理下一个请求。

    如果每个请求的处理需要很长时间才能完成,这种方式就不是很适合。

    因为它要求大量的计算,或因为它返回了大量的数据导致客户端处理很慢。

    解决办法是创建一个独立的进程或线程来处理每个请求,

    使用 ForkingMixIn和ThreadingMixIn mix-in类能实现异步方式;

    创建一个服务器有以下几个步骤,

    首先,创建一个BaseRequestHandler类的子类,并重写handle()方法,这个方法将处理输入的请求。

    然后,必须实例一个服务器类,并定义它的服务器地址和请求处理类;

    最后,调用这个服务器对象的request()或 serve_forever() 方法来处理一个或多个请求。

    当继承了ThreadingMixIn来线程化处理连接行为时,需要明确定义你的线程在遇到异常关闭的处理行为。

    ThreadingMixIn类定义了一个属性 daemon_threads, 它用来指示服务器是否要等线程线束。

    如果你希望线程行为自动处理,你需要显示设置这个标志。

    它的默认值是 False,意思是在由ThreadingMinIn创建的线程未退出前,主线程不会退出。

    1. TCP通信

    Server端

    #!/usr/bin/env python

    # -*- coding:utf-8 -*-

    #

    import SocketServer

    class MyTCPHandler(SocketServer.BaseRequestHandler):

    """

    The RequestHandler class for our server.

    It is instantiated once per connection to the server, and must

    override the handle() method to implement communication to the

    client.

    """

    def handle(self):

    # self.request is the TCP socket connected to the client

    self.data = self.request.recv(1024).strip()

    print "{} wrote:".format(self.client_address[0])

    print self.data

    # just send back the same data, but upper-cased

    self.request.sendall(self.data.upper())

    if __name__ == "__main__":

    HOST, PORT = "localhost", 21577

    # Create the server, binding to localhost on port 21577

    SocketServer.TCPServer.allow_reuse_address = True

    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    print " .... waiting for connection"

    # Activate the server; this will keep running until you

    # interrupt the program with Ctrl-C

    server.serve_forever()

    Client端

    #!/usr/bin/env python

    # -*- coding:utf-8 -*-

    #

    from socket import *

    HOST = 'localhost'

    PORT = 21577

    BUFSIZE=1024

    ADDR = (HOST, PORT)

    while True:

    tcpCliSock=socket(AF_INET, SOCK_STREAM)

    tcpCliSock.connect(ADDR)

    data=raw_input('>')

    if not data:

    break

    tcpCliSock.send('%s\r\n' % data)

    data=tcpCliSock.recv(BUFSIZE)

    if not data:

    break

    print data.strip()

    tcpCliSock.close()

    运行示例:

    Server

    $ python TCPServer.py

    127.0.0.1 wrote:

    hello world with TCP

    127.0.0.1 wrote:

    python is nice

    CLIENT:

    $ python TCPClient.py hello world with TCP

    Sent:     hello world with TCP

    Received: HELLO WORLD WITH TCP

    $ python TCPClient.py python is nice

    Sent:     python is nice

    Received: PYTHON IS NICE

    2. UDP通信

    SERVER端

    import SocketServer

    class MyUDPHandler(SocketServer.BaseRequestHandler):

    """

    This class works similar to the TCP handler class, except that

    self.request consists of a pair of data and client socket, and since

    there is no connection the client address must be given explicitly

    when sending data back via sendto().

    """

    def handle(self):

    data = self.request[0].strip()

    socket = self.request[1]

    print "{} wrote:".format(self.client_address[0])

    print data

    socket.sendto(data.upper(), self.client_address)

    if __name__ == "__main__":

    HOST, PORT = "localhost", 9999

    server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)

    server.serve_forever()

    CLIENT端:

    import socket

    import sys

    HOST, PORT = "localhost", 9999

    data = " ".join(sys.argv[1:])

    # SOCK_DGRAM is the socket type to use for UDP sockets

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # As you can see, there is no connect() call; UDP has no connections.

    # Instead, data is directly sent to the recipient via sendto().

    sock.sendto(data + "\n", (HOST, PORT))

    received = sock.recv(1024)

    print "Sent:     {}".format(data)

    print "Received: {}".format(received)

    四、 使用SocketServer处理多连接

    上面的例子一次只能连接一个客户机并出力它的请求,

    如果要处理多连接问题,那么有三种主要的方法能实现这个目的:

    分叉(forking)、

    线程(threading)以及

    异步I/O(asynchronous I/O)。

    通过对SocketServer服务器使用混入类(mix-in class),派生进程和线程很容易处理。

    即使要自己实现它们,这些方法也很容易使用。

    它们确实有缺点:

    分叉占据资源,并且如果有太多的客户端时分叉不能很好分叉

    (尽管如此,对于合理数量的客户端,分叉在现代的UNIX或者Linux系统中是很高效的,如果有一个多CPU系统,那系统效率会更高);

    线程处理能导致同步问题。

    使用SocketServer框架创建分叉或者线程服务器非常简单:

    1. 分叉SocketServer服务器:

    #!/usr/bin/env python

    from SocketServer import (TCPServer as TCP,

    StreamRequestHandler as SRH,

    ForkingMixIn as FMI)

    from time import ctime

    HOST = ''

    PORT = 12346

    ADDR = (HOST, PORT)

    class Server(FMI, TCP):

    pass

    class MyRequestHandler(SRH):

    def handle(self):

    print '...connected from:', self.client_address

    self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))

    tcpServ = Server(ADDR, MyRequestHandler)

    print 'waiting for connection...'

    tcpServ.serve_forever()

    2. 多线程SocketServer服务器:

    #!/usr/bin/env python

    from SocketServer import (TCPServer as TCP,

    StreamRequestHandler as SRH,

    ThreadingMixIn as TMI)

    from time import ctime

    HOST = ''

    PORT = 12346

    ADDR = (HOST, PORT)

    class Server(TMI, TCP):

    pass

    class MyRequestHandler(SRH):

    def handle(self):

    print '...connected from:', self.client_address

    self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))

    tcpServ = Server(ADDR, MyRequestHandler)

    print 'waiting for connection...'

    tcpServ.serve_forever()

    3. 异步的SocketServer服务器

    import socket

    import threading

    import SocketServer

    class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):

    data = self.request.recv(1024)

    cur_thread = threading.current_thread()

    response = "{}: {}".format(cur_thread.name, data)

    self.request.sendall(response)

    class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):

    pass

    def client(ip, port, message):

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.connect((ip, port))

    try:

    sock.sendall(message)

    response = sock.recv(1024)

    print "Received: {}".format(response)

    finally:

    sock.close()

    if __name__ == "__main__":

    # Port 0 means to select an arbitrary unused port

    HOST, PORT = "localhost", 0

    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)

    ip, port = server.server_address

    # Start a thread with the server -- that thread will then start one

    # more thread for each request

    server_thread = threading.Thread(target=server.serve_forever)

    # Exit the server thread when the main thread terminates

    server_thread.daemon = True

    server_thread.start()

    print "Server loop running in thread:", server_thread.name

    client(ip, port, "Hello World 1")

    client(ip, port, "Hello World 2")

    client(ip, port, "Hello World 3")

    server.shutdown()

    输出示例:

    $ python ThreadedTCPServer.py

    Server loop running in thread: Thread-1

    Received: Thread-2: Hello World 1

    Received: Thread-3: Hello World 2

    Received: Thread-4: Hello World 3

    阅读(2751) | 评论(0) | 转发(0) |

    展开全文
  • 环境:Linux 语言:C/C++ 通信方式:UDP 服务器端的步骤如下: ...close: 通信完成后关闭socket 客户端的步骤如下: 5. socket: 建立一个socket sendto: 向服务器的某个端口发起请求(AF_INET) clos

    环境:Linux

    语言:C/C++

    通信方式:UDP

    概念层级

    UDP中的服务器端和客户端没有连接

    UDP 不像 TCP,无需在连接状态下交换数据,因此基于 UDP 的服务器端和客户端也无需经过连接过程。也就是说,不必调用 listen() 和 accept() 函数。UDP 中只有创建套接字的过程和数据交换的过程。

    UDP服务器端和客户端均只需1个套接字

    TCP 中,套接字是一对一的关系。如要向 10 个客户端提供服务,那么除了负责监听的套接字外,还需要创建 10 套接字。但在 UDP 中,不管是服务器端还是客户端都只需要 1 个套接字。之前解释 UDP 原理的时候举了邮寄包裹的例子,负责邮寄包裹的快递公司可以比喻为 UDP 套接字,只要有 1 个快递公司,就可以通过它向任意地址邮寄包裹。同样,只需 1 个 UDP 套接字就可以向任意主机传送数据。

    基于UDP的接收和发送函数

    创建好 TCP 套接字后,传输数据时无需再添加地址信息,因为 TCP 套接字将保持与对方套接字的连接。换言之,TCP 套接字知道目标地址信息。但 UDP 套接字不会保持连接状态,每次传输数据都要添加目标地址信息,这相当于在邮寄包裹前填写收件人地址。

    代码层级

    服务器端的步骤如下:

    1. socket: 建立一个socket

    2. bind: 将这个socket绑定在某个端口上(AF_INET)

    3. recvfrom: 如果没有客户端发起请求,则会阻塞在这个函数里

    4. close: 通信完成后关闭socket

    客户端的步骤如下:
    5. socket: 建立一个socket

    1. sendto: 向服务器的某个端口发起请求(AF_INET)

    2. close: 通信完成后关闭socket

    基于UDP的接收和发送函数

    创建好 TCP 套接字后,传输数据时无需再添加地址信息,因为 TCP 套接字将保持与对方套接字的连接。换言之,TCP 套接字知道目标地址信息。但 UDP 套接字不会保持连接状态,每次传输数据都要添加目标地址信息,这相当于在邮寄包裹前填写收件人地址。

    int recvfrom(int sockfd, void * buf, size_t len, int flags, struct sockaddr * src_addr, socklen_t * addrlen);

    int sendto(int sockfd, const void * buf, size_t len, int flags, const struct sockaddr * dest_addr, socklen_t addrlen);

    UDP套接字不会保持连接状态,每次传输数据都要添加目标地址信息,这相当于在邮寄包裹前填写收件人地址。

    recvfrom用于接收数据,sendto用于发送数据

    recvfrom:

    • sockfd:用于接收UDP数据的套接字;
    • buf:保存接收数据的缓冲区地址;
    • len:可接收的最大字节数(不能超过buf缓冲区的大小);
    • flags:可选项参数,若没有可传递0;
    • src_addr:存有发送端地址信息的sockaddr结构体变量的地址;
    • addrlen:保存参数 src_addr的结构体变量长度的变量地址值。

    sendto:

    • sockfd:用于传输UDP数据的套接字;
    • buf:保存待传输数据的缓冲区地址;
    • len:带传输数据的长度(以字节计);
    • flags:可选项参数,若没有可传递0;
    • dest_addr:存有目标地址信息的 sockaddr 结构体变量的地址;
    • addrlen:传递给参数 dest_addr的地址值结构体变量的长度。

    UDP客户/服务器的套接字函数

    在这里插入图片描述

    Server.cpp

    #include <stdio.h>   
    #include <sys/types.h>   
    #include <sys/socket.h>   
    #include <netinet/in.h>   
    #include <unistd.h>   
    #include <errno.h>   
    #include <string.h>   
    #include <stdlib.h>   
      
    #define SERV_PORT   8000   
    int main()  
    {  
       /* sock_fd --- socket文件描述符 创建udp套接字*/  
      int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
      if(sock_fd < 0)  
      {  
        perror("socket");  
        exit(1);  
      }  
       
      /* 将套接字和IP、端口绑定 */  
      struct sockaddr_in addr_serv;  
      int len;  
      memset(&addr_serv, 0, sizeof(struct sockaddr_in));  //每个字节都用0填充
      addr_serv.sin_family = AF_INET;              //使用IPV4地址
      addr_serv.sin_port = htons(SERV_PORT);          //端口
      /* INADDR_ANY表示不管是哪个网卡接收到数据,只要目的端口是SERV_PORT,就会被该应用程序接收到 */  
      addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);  //自动获取IP地址
      len = sizeof(addr_serv);  
       /* 绑定socket */  
      if(bind(sock_fd, (struct sockaddr *)&addr_serv, sizeof(addr_serv)) < 0)  
      {  
         perror("bind error:");  
         exit(1);  
      }  
      
      int recv_num;  
      int send_num;  
      char send_buf[20] = "i am server!";  
      char recv_buf[20];  
      struct sockaddr_in addr_client;  
      
      while(1)  
      {  
        printf("server wait:\n");  
          
        recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_client, (socklen_t *)&len);  
          
        if(recv_num < 0)  
        {  
          perror("recvfrom error:");  
          exit(1);  
        }  
      
        recv_buf[recv_num] = '\0';  
        printf("server receive %d bytes: %s\n", recv_num, recv_buf);  
      
        send_num = sendto(sock_fd, send_buf, recv_num, 0, (struct sockaddr *)&addr_client, len);  
          
        if(send_num < 0)  
        {  
           perror("sendto error:");  
           exit(1);  
         }  
      }  
         
      close(sock_fd);  
         
       return 0;  
    }
    

    Client.cpp

    #include <stdio.h>   
    #include <string.h>   
    #include <errno.h>   
    #include <stdlib.h>   
    #include <unistd.h>   
    #include <sys/types.h>   
    #include <sys/socket.h>   
    #include <netinet/in.h>   
    #include <arpa/inet.h>   
      
    #define DEST_PORT 8000   
    #define DSET_IP_ADDRESS  "127.0.0.1"   
      
      
    int main()  
    {  
      /* socket文件描述符 */  
      int sock_fd;  
      
      /* 建立udp socket */  
      sock_fd = socket(AF_INET, SOCK_DGRAM, 0);  
      if(sock_fd < 0)  
      {  
        perror("socket");  
        exit(1);  
      }  
        
      /* 设置address */  
      struct sockaddr_in addr_serv;  
      int len;  
      memset(&addr_serv, 0, sizeof(addr_serv));  
      addr_serv.sin_family = AF_INET;  
      addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);  
      addr_serv.sin_port = htons(DEST_PORT);  
      len = sizeof(addr_serv);  
      
        
      int send_num;  
      int recv_num;  
      char send_buf[20] = "hey, who are you?";  
      char recv_buf[20];  
          
      printf("client send: %s\n", send_buf);  
        
      send_num = sendto(sock_fd, send_buf, strlen(send_buf), 0, (struct sockaddr *)&addr_serv, len);  
        
      if(send_num < 0)  
      {  
        perror("sendto error:");  
        exit(1);  
      }  
        
      recv_num = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&addr_serv, (socklen_t *)&len);  
        
      if(recv_num < 0)  
      {  
        perror("recvfrom error:");  
        exit(1);  
      }  
        
      recv_buf[recv_num] = '\0';  
      printf("client receive %d bytes: %s\n", recv_num, recv_buf);  
        
      close(sock_fd);  
        
      return 0;  
    }
    

    程序运行截图:
    在这里插入图片描述
    client向服务器发送了“hey, who are you?”的字符串,server返回"i am server!"的字符串。

    参考链接:
    https://blog.csdn.net/weixin_30530939/article/details/95822533?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

    展开全文
  • 简易socket通信实例

    2021-10-08 17:06:52
    简易socket通信实例tcp连接udp连接 tcp连接 服务端 import socket ADDRESS = "127.0.0.1" PORT = 8080 def start_server(): try: server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_...
  • qt TCP socket通信实例——网络聊天室 说明: 数据的传输使用json,实现了一些基本的聊天功能,服务端的禁言功能,在线用户的显示功能,我会把源码放在下面,但是要提前说明的是这个网络聊天室有一些很迷惑的bug,而以本人...
  • 好久没写博客了,前段时间忙于做项目,耽误了些时间,今天开始继续写起~今天来讲下关于Socket通信的简单应用,关于什么是Socket以及一些网络编程的基础,这里就不提了,只记录最简单易懂实用的东西。1、首先先来看下...
  • 基于Java语言实现Socket通信由于近日项目需求,需要在服务器中增加Socket通信的功能,接收硬件设备发送的心跳包和相关数据,因此又重新对Java的网络编程进行了复习,根据项目的实际情况做了简化的编程,实现了简单的...
  • 原标题:一个基于TCP协议的Socket通信实例 1. 前言一般接口对接多以http/https或webservice的方式,socket方式的对接比较少并且会有一些难度。正好前段时间完成了一个socket的接口的对接需求,现将实现的思路做一个...
  • 安卓Socket通信实例本文摘自:https://whatsblog.icu/index.php/Android/17.html1、Socket通信必须知道的地方1、首先,Socket通信采用TCP模式,客户端需要连接到服务端2、采用网络,需要打开Internet权限3、需要合理...
  • 本文实例讲述了python服务器与android客户端socket通信的方法。分享给大家供大家参考。具体实现方法如下:首先,服务器端使用python完成,下面为python代码:#server.pyimport socketdef getipaddrs(hostname):#只是...
  • java NIO socket 通信实例

    2021-02-28 06:55:39
    java Nio 通信与Bio通信主要不同点:1.Nio中的单个channel就可以支持读操作也能够支持写操作,而bio中读操作要用inputstream,写操作要outputstream.2.nio 採用byteBuffer 作为内存缓存区,向channel里写或者度操作,bio...
  • java代码(需要xsocket 下面有下载):test.java(主文件)packagetest;importorg.xsocket.connection.*;publicclasstest{protectedstaticIServersrv=null;publicstaticvoidmain(String[]args){try{srv=newServer(8...
  • 好久没写博客了,前段时间忙于做项目,耽误了些时间,今天开始继续写起~今天来讲下关于Socket通信的简单应用,关于什么是Socket以及一些网络编程的基础,这里就不提了,只记录最简单易懂实用的东西。1、首先先来看下...
  • Python与Java间Socket通信实例代码Python与Java间Socket通信之前做过一款Java的通讯工具,有发消息发文件等基本功能.可大家也都知道Java写的界面无论是AWT或Swing,那简直不是人看的,对于我们这些开发人员还好,如果是...
  • 好久没写博客了,前段时间忙于做项目,耽误了些时间,今天开始继续写起~今天来讲下关于Socket通信的简单应用,关于什么是Socket以及一些网络编程的基础,这里就不提了,只记录最简单易懂实用的东西。1、首先先来看下...
  • Xml代码xmlns:s="library://ns.adobe.com/flex/spark"xmlns:mx="library://ns.adobe.com/flex/mx"minWidth="955"minHeight="600">privatevarsocket:Socket=null;protectedfunctionbutton1_clickHandler(event...
  • C++ 中 socket编程实例详解sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW);基于TCP的socket编程是采用的流式套接字。在这个程序中,将两个工程添加到一个...
  • 现有工业视觉相机,通过利用Socket通信使相机和机器人相连接,任意旋转待检测物体后,相机拍照即可识别出物体的位置,视觉相机检测物体的位置通过Socket发送给机器人端,机器人根据发送过来的数据完成对被检测到物体...
  • 正好前段时间完成了一个socket的接口的对接需求,现将实现的思路做一个整理。 二、需求概述 1、需要提供一个socket服务端,实时接收三方传递过来的数据 2、实时报文规范说明 3、通讯及接口格式说明 通讯方式: ...
  • 本文实例讲述了Android Socket通信传输实现方法。分享给大家供大家参考,具体如下:1.开篇简介Socket本质上就是Java封装了传输层上的TCP协议(注:UDP用的是DatagramSocket类)。要实现Socket的传输,需要构建客户端和...
  • 如果有dalao读到这儿,希望能指出理解中的问题~谢谢Java提供了用于网络通信socket和serversocket包,然而实现方式是阻塞式的,同一时间点上只能进行一个连接,这会带来不好的体验。当然了,我们也可以通过不断创建...
  • 最近有个项目Zgbeen模块,需要用到TCP通讯,所以做了这个Demo Android安卓TCP通信客户端/服务端APP实现Demo源码
  • SOCKET s = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP); sockaddr_in sockaddr; sockaddr.sin_family = PF_INET; sockaddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); sockaddr.sin_port = htons...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,795
精华内容 40,318
关键字:

socket通信实例