本文将带您了解关于Socket.IO1.0.x：按ID获取套接字的新内容，同时我们还将为您解释获取套接字地址长度的相关知识，另外，我们还将为您提供关于7.1套接字（socket）、Android进程通

本文将带您了解关于Socket.IO 1.0.x：按ID获取套接字的新内容，同时我们还将为您解释获取套接字地址长度的相关知识，另外，我们还将为您提供关于7.1 套接字（socket）、Android 进程通信套接字LocalSocket、C#之Socket(套接字)通信、C++根据SOCKET获取套接字IP、Port等信息的实用信息。

• Socket.IO 1.0.x：按ID获取套接字（获取套接字地址长度）
• 7.1 套接字（socket）
• Android 进程通信套接字LocalSocket
• C#之Socket(套接字)通信
• C++根据SOCKET获取套接字IP、Port等信息

Socket.IO 1.0.x：按ID获取套接字（获取套接字地址长度）

在0.9.x版本中，我们可以通过ID获得套接字，如下所示：

io.sockets.socket(socketId)

但是在1.0.x中我们不能。如何在1.0.x中按ID查找套接字？

答案1

对于socket.io 1.0，请使用：

io.sockets.connected[socketId]

对于0.9，其io.sockets.sockets [socketId]而不是io.sockets.socket [socketId]

7.1 套接字（socket）

套接字（socket）是计算机之间进行通信的一种技术，它允许不同主机上的进程之间进行数据交换。在Python中，我们可以使用socket模块来创建和使用套接字。

首先，我们需要导入socket模块：

import socket

在网络编程中，有两种主要类型的套接字：流套接字（Stream Sockets）和数据报套接字（Datagram Sockets）。流套接字使用传输控制协议（TCP）进行通信，而数据报套接字使用用户数据报协议（UDP）进行通信。我们将主要关注TCP套接字，因为它们更常用且提供了可靠的双向通信。

创建套接字

要创建一个TCP套接字，我们可以使用socket.socket()函数：

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

这里，socket.AF_INET表示我们使用IPv4地址，socket.SOCK_STREAM表示我们使用TCP协议。

绑定套接字

创建套接字后，我们需要将其绑定到一个地址和端口。这可以使用bind()方法完成：

address = (''localhost'', 12345)
s.bind(address)

这里，我们绑定了套接字到本地地址（''localhost''）和端口（12345）。

监听连接

在绑定套接字后，我们需要开始监听客户端的连接。我们可以使用listen()方法来实现这一点：

s.listen(5)

这里的数字5表示允许的最大连接数。

接受连接

当有客户端尝试连接时，我们可以使用accept()方法来接受连接。这将返回一个新的套接字对象和客户端地址：

client_socket, client_address = s.accept()

发送和接收数据

现在我们已经建立了连接，可以使用send()和recv()方法发送和接收数据。例如：

data = client_socket.recv(1024)  # 接收最多1024字节的数据
client_socket.send(b''Hello, client!'')  # 发送数据

请注意，我们需要使用字节类型的数据进行通信。

关闭套接字

通信完成后，我们需要关闭套接字以释放资源。我们可以使用close()方法来实现这一点：

client_socket.close()
s.close()

这就是一个简单的TCP套接字服务器的基本结构。为了让您更好地理解，这里有一个完整的示例：

TCP服务器示例

import socket

def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    address = (''localhost'', 12345)
    s.bind(address)
    s.listen(5)

    print("Waiting for connections...")
    client_socket, client_address = s.accept()
    print(f"Connected to {client_address}")

    data = client_socket.recv(1024)
    print(f"Received: {data}")

    client_socket.send(b''Hello, client!'')

    client_socket.close()
    s.close()

if __name__ == ''__main__'':
    main()

这个示例展示了如何创建一个简单的TCP服务器，它接受来自客户端的连接和数据，并向客户端发送一条消息。您可以根据自己的需求修改这个示例，以实现不同的功能。
推荐阅读：

https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA

https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g

Android 进程通信套接字LocalSocket

我们知道，Android上常见的多进程通讯有以下几种：

AIDL 进程通信接口

Binder接口

Messenger通信框架

BroadCastReciever 广播

ContentObserver/ContentProvider

FileObserver(http://blog.csdn.net/happy_6678/article/details/7095012)

网络，(http网络中转，rpc,dwr,jms,xmpp)

Intent通信

当然，我们还有另一种方案

LocalSocket 是Unix进程通信的基础

认识几个常用的函数：

客户端：

     LocalSocket客户端使用，创建套接字

     LocalSocketAddress 套接字地址，其实就是文件描述符（主要是服务器的地址，当然也可以客户端自个绑定地址）

setSoTimeout设置超时

connect客户端主动向服务端请求连接

服务端：

LocalServerSocket服务端使用，创建套接字同时指定文件描述符

accept等待客户端连接（阻塞）

共同：

getInputStream获取套接字输入流

getOutputStream获取套接字输出流

close关闭套接字，客户服务都需要

关于套接字的通信直接就是对java输入输出流的操作了，但是有一点很重要：对于套接字获取的各种输入或者输出流，如果调用close函数关闭了对应的流，那么套接字也会自动关闭了，再次对其获取输入输出流的时候会提示 socket not creat 。这点不同于C下socket的 shutdown函数，我也因为这折腾了很久。

下面不多说上代码，我对在客户端对其做了小小的封装：

class ClientConnect {  
    private static final String TAG = "ClientConnect";  
    private static final String name = "com.repackaging.localsocket";  
    private LocalSocket Client = null;  
    private PrintWriter os = null;  
    private BufferedReader is = null;  
    private int timeout = 30000;  
      
    public void connect(){    
        try {  
            Client = new LocalSocket();  
            Client.connect(new LocalSocketAddress(name));  
            Client.setSoTimeout(timeout);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
              
    public void send(String[] data) {  
        try {  
            os = new PrintWriter(Client.getOutputStream());  
            for(int i = 0 ; i < data.length ; i ++){  
                os.println(data[0]);  
            }  
            os.println(FLAG);  
            os.flush();  
            Log.d(TAG,"send");  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
    public String recv() {  
        Log.d(TAG,"recv");  
        String result = null;  
        try {  
            is = new BufferedReader(new InputStreamReader(Client.getInputStream()));  
            result = is.readLine();  
            Log.d(TAG, result);  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
        }  
        return result;  
    }  
      
    public void close() {  
        try {  
            is.close();  
            os.close();  
            Client.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

由于是在Android代码上使用，为了防止ANR，对于服务端，肯定是放到线程中去的。对于阻塞模式的客户端（recv等函数），也必须放在线程中。

服务端线程：

class ServerThread implements Runnable {  
  
    @Override  
    public void run() {  
        LocalServerSocket server = null;  
        BufferedReader mBufferedReader = null;  
        PrintWriter os = null;  
        LocalSocket connect = null;  
        String readString =null;  
        try {  
            server = new LocalServerSocket("com.repackaging.localsocket");        
            while (true) {  
                connect = server.accept();  
                Credentials cre = connect.getPeerCredentials();  
                Log.i(TAG,"accept socket uid:"+cre.getUid());  
                mBufferedReader = new BufferedReader(new InputStreamReader  
                        (connect.getInputStream()));  
                while((readString=mBufferedReader.readLine())!=null){  
                    if(readString.equals("finish")) break;  
                    Log.d(TAG,readString);  
                }  
                os = new PrintWriter(connect.getOutputStream());  
                os.println("allow");  
                os.flush();  
                Log.d(TAG,"send allow");  
            }     
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        finally{  
            try {  
                mBufferedReader.close();  
                os.close();  
                connect.close();  
                server.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
      
}

C#之Socket(套接字)通信

一、socket是什么

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

二、套接字的工作流程

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

三、服务端

private void btnListen_Click(object sender, EventArgs e)
{
    IPEndPoint point = new IPEndPoint(IPAddress.Any, 13000);//IPAddress.Any本机任何网卡IP。本机端口查看netstat -an
    //服务端Socket定义
    Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    socket.Bind(point); //绑定IP
    socket.Listen(10);//启动监听。最大监听数,同一个时间点过来10个客户端，排队
    ShowMsg("服务器开始监听");

    Thread thread = new Thread(AcceptInfo);
    thread.Start(socket);

}

//记录通信用的Socket
Dictionary<string, Socket> dic = new Dictionary<string, Socket>();

// private Socket client;
void AcceptInfo(object o)
{
    Socket socket = o as Socket;
    while (true)
    {
        //通信用socket
        try
        {
            Socket clientSocket = socket.Accept();//如果客户端有请求，生成一个新的Socket
            string point = clientSocket.RemoteEndPoint.ToString();
            ShowMsg(point + "连接客户端成功！");
            dic.Add(point, clientSocket);
            //接收消息
            Thread th = new Thread(ReceiveMsg);
            th.Start(clientSocket);
        }
        catch (Exception ex)
        {
            break;
        }
    }
    socket.Close();
}
//接收消息
void ReceiveMsg(object socket)
{
    Socket clientSocket = socket as Socket;
    while (true)
    {
        //接收客户端发送过来的数据
        try
        {
            //定义byte数组存放从客户端接收过来的数据
            byte[] buffer = new byte[1024 * 1024];
            
           int n = clientSocket.Receive(buffer);//将接收过来的数据放到buffer中，并返回实际接受数据的长度

            //将字节转换成字符串
            string words = Encoding.Unicode.GetString(buffer, 0, n);
            Console.WriteLine(clientSocket.RemoteEndPoint.ToString() + ":" + words);
            byte[] msg = Encoding.Unicode.GetBytes(words);
            clientSocket.Send(msg);//发送数据，字节数组
        }
        catch (Exception ex)
        {
            break;
        }
    }
    clientSocket.Shutdown(SocketShutdown.Both);//禁止发送和接受数据
    clientSocket.Close();//关闭socket,释放资源
}

四、客户端

Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint point = new IPEndPoint("127.0.0.1", 13000));//连接到的服务端IP
clientSocket.Connect(point);//连接到服务器
ShowMsg("连接成功");
ShowMsg("服务器" + client.RemoteEndPoint.ToString());
ShowMsg("客户端:" + client.LocalEndPoint.ToString());
Thread th = new Thread(ReceiveMsg);//连接成功后，就可以接收服务器发送的信息了
th.IsBackground = true;
th.Start();

clientSocket.Shutdown(SocketShutdown.Both);//禁止发送和接受数据
clientSocket.Close();//关闭socket,释放资源

五、Socket对象的成员

1、属性

2、方法

Accept

Connect

Disconnect

Receive

ReceiveFrom

ReceiveMessageFrom

Send

SendFile

SendTo

其它

到此这篇关于C#之Socket(套接字)通信的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

C++根据SOCKET获取套接字IP、Port等信息

下面是小编 jb51.cc 通过网络收集整理的代码片段。

小编小编现在分享给大家，也给大家做个参考。

//通过套接字获取IP、Port等地址信息
bool GetAddressBySocket(SOCKET m_socket,SOCKADDR_IN &m_address)
{
    memset(&m_address,sizeof(m_address));
    int nAddrLen = sizeof(m_address);
  
    //根据套接字获取地址信息
    if(::getpeername(m_socket,(SOCKADDR*)&m_address,&nAddrLen) != 0)
    {
        printf("Get IP address by socket Failed!n");
        return false;
    }
      
    //读取IP和Port
    cout<<"IP: "<<::inet_ntoa(m_address.sin_addr)<<"  PORT: "<<ntohs(m_address.sin_port)<<endl;
    return true;
}

以上是小编(jb51.cc)为你收集整理的全部代码内容，希望文章能够帮你解决所遇到的程序开发问题。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给程序员好友。

我们今天的关于Socket.IO 1.0.x：按ID获取套接字和获取套接字地址长度的分享已经告一段落，感谢您的关注，如果您想了解更多关于7.1 套接字（socket）、Android 进程通信套接字LocalSocket、C#之Socket(套接字)通信、C++根据SOCKET获取套接字IP、Port等信息的相关信息，请在本站查询。