socket

socket的英语读音是[u02c8su0252ku026at]。一、释义1、动词：把……装入插座；给……配插座。2、名词：（电源）插座；窝；（电器上的）插口，插孔，管座；托座；孔穴；槽；臼。二、例句1、Is the cable long enough to reach the socket?电线够得着插座吗？2、Connect the release switch to the remote control socket of the camera.把释放开关接到相机遥控插口。3、All new PCs now have USB sockets.新的个人计算机现在都有通用串行总线插孔。4、I haven"t yet met a newborn who could stretch her fingers into a socket from her crib.我还没有见过一个新生儿可以把她的手指伸进婴儿床的托座里。5、He put the electric plug into the socket.他把电插头插入插座。

承口，插座，窝，孔

　　 摘　要 　本文介绍了UDP Sockets的基本概念和IP多点传送的原理 详细讨论了Java中的相关类及使用方法 提供了一个IP多点传送的开发流程 　　 关键词 　Java　UDP Sockets　 　　 一 IP多点传送 　　　IP多点传送(multicast delivery)是针对点到点的传送和广播传送两种方式而言的 它是指在一定的组内对其成员进行的广播 是一种有限的广播 组中的某个成员发出的信息 组中的其它所有成员都能收到 它是UDP Sockets的一个分支 　　IP多点传送特别适合与高带宽的应用 例如在网络上发送视频和音频 随着网络带宽的不断提高和网络通讯质量的不断改善 IP多点传送还将广泛地被应用于网上聊天及网上会议 分布式数据存储 联机事务处理 交互式游戏等方面 另外 多点传送还可以被客户机用于在网络上寻找相应的服务器 客户机发送一个多点传送的请求 任何监听服务器都可以与客户机连接并开始一个事务 　　 二 UDP Socket基础 　　使用用户数据报协议(User Datagram Protocol 简称UDP)进行会话必须将信息装配成一定尺寸的小报文 当发送一条信息 接收方能否收到并返回信息永远是不确定的 如果无法收到返回信息 我们就无法确定我们发送的信息是否被接收——它可能在途中丢失 接收者返回的响应信息也可能丢失 另外 接收者也可能忽略我们的信息 因此 UDP被描述为不可靠的 无连接的和面向消息的 　　创建UDP sockets非常象创建一个邮箱 邮箱是使用地址来识别的 但是 我们不需要为每个发送信息的人构造一个新的邮箱 可以在含有发送信息的明信片上写上目的地址 将其放在邮箱中并发送出去 接收者可能会长久的等待 直到含有信息的明信片到达它的邮箱 而明信片上标识了发送者的返回地址 　　三 IP多点传送的原理 　　为了支持IP多点传送 某些范围的IP地址被单独留出专门用于这个目的 这些IP地址是D类地址 其地址的最高四比特的位模式为 即IP地址的范围在 和 之间 它们中的每一个IP地址都可以被引用作为一个多点传送组 任何以该IP地址编址的IP报文将被该组中的其它所有机器接收 也就是说 一个IP地址就相当于一个邮箱 另外 组中的成员是动态的并随时间而改变 　　对于IP多点传送 网间网组管理协议(Internet Group Management Protocol 简称IGMP) 用于管理多点传送组中的成员 支持多点传送的路由可以使用IGMP决定本地的机器是否赞成加入某个组 一个多点传送路由可以决定是否转发一个多点传送报文 　　影响多点传送报文的一个重要参数是time－to－live(TTL) TTL用于描述发送者希望传送的信息能通过多少不同的网络 当报文被路由器转发 报文中的TTL将减一 当TTL为零时 报文将不再向前发送 　　在实际使用中 我们必须注意下面几点 　　 这些IP地址只能作为信宿地址使用 绝对不能出现在任何信源地址域中 也不能出现在源路径或记录路径选项中 　　 由于IP多点传送是一对多的传送 因此 不能利用差错与控制报文协议(Internet Control Message Protocol 简称ICMP)产生出错报文 　　 发送一个信息到一个组 发送主机可以不是组中的成员 　　 一些组被Internet Assigned Numbers Authority(IANA)分配 保留用于特殊的目的 详情参见 ftp://ftp internic net/rfc/rfc txt 另外 避免使用一些保留组 从 到 仅限于本地子网使用 建议在 和 之间任意选取一个IP地址 　　 如果我们选取的组已经被使用 与其他机器的通讯将会混乱 一旦发生 可以退出应用 试试其他的地址 　　 当一个机器加入一个多点传送组 它将开始接收该IP多点传送地址的信息 如果多点传送报文分发到网络上 任何监听该信息的机器都会有机会接收它 对于IP多点传送 没有一个机制对相同网络上的机器能否加入该多点传送组加以限制 因此 安全性是我们必须考虑的问题之一 　　 选择的TTL参数应尽可能小 一个大的TTL值会不必要地占用Internet带宽 此外 还可能破坏不同区域使用相同组的其它的多点传送通讯 　　四 Java中与IP多点传送相关的类 　　java net包中含有UDP通讯所需要的工具 其中包括IP多点传送 　　1 DatagramPacket类 　　我们可以使用DatagramPacket类创建一个用于发送的数据报 而当接收UDP数据报时 可以使用DatagramPacket类读取数据报中的数据 发送者及其它信息 　　为了创建一个数据报并发送到远地系统 可以使用下面的构造器 　　Public DatagramPacket(byte ibuf int length InetAddress iaddr int iport ); 　　ibuf是编码信息数据的字节数组 它的长度length就是数据报放在其中的字节数组的长度 iaddr是一个InetAddress对象 存储著接收方的主机名和IP地址等信息 iport标识数据报发送到接收主机的端口 　　为了接收数据报 必须使用DatagramPacket构造器 其原型为 　　public DatagramPacket(byte ibuf int ilength);　　ibuf是指接收的数据报的数据部分 ilength是该部分数据的长度 如果 ilength 小于机器接收的UDP数据报的尺寸 多余的字节将被Java忽略 　　另外 类中有一些方法(method)可以让我们得到一些相关的信息 　　public int getLength();　　　//得到数据报中数据块的字节尺寸 　　public bytegetData();　　//得到接收数据报中的数据 　　public InetAddress getAddress();　　　//为发送者提供一个 InetAddress对象 　　public int getPort();　　　//得到UDP端口 　　值得注意的是 TCP sockets的编程中 我们无须将传送的数据分块 然而 当我们创建一个基于UDP的网络通讯应用程序时 必须创建一套方法 在运行时刻决定需分割的数据报的长度 对于TCP/IP 最大的数据报可以含有 字节的数据 然而 主机仅能接收最多 字节的数据 支持 字节的大数据报的平台是利用IP层对数据报进行分割的 如果在传送期间 任何含有IP报文的一个数据块丢失 都会造成整个UDP数据报的丢失 因此 我们在确定应用中数据报尺寸时 对其尺寸的合理性一定要谨慎 　　下面就是分割数据的一个例子 　　//循环地从输入流input中读一行数据 　　while((nextLine=input readLine())!=null){ 　　//定义一个空数据报 其尺寸为 　　mcastBuffer=new byte[ ]; 　　//如果读入的数据的长度大于定义的数据报的长度 　　//则使用定义的长度 否则使用读入数据的长度 　　if(nextLine length()>mcastBuffer length){ 　　sendLength=mcastBuffer length; 　　}else { 　　sendLenth=nextLine length(); 　　} 　　//将读入的数据转换为byte类型 　　lineData=nextLine getBytes(); 　　//将数据复制到用于创建数据报的byte数组 　　for(int i= ;i 　　mcastBuffer[i]=lineData[i]; 　　} 　　……创建数据报 发送或接收…… 　　} 　　2 MulticastSocket类 　　Java的 MulticastSocket类是实施IP多点传送网络特征的关键 它允许我们使用多点传送IP发送或接收UDP数据报 　　MulticastSocket的构造器为 　　public MulticastSocket () throws IOException;　　　　//创建一个多点传送socket 　　public MulticastSocket(int port)throws IOException;　　//在指定端口创建一个多点传送socket 　　另外 类中其它常用的方法有 　　public void joinGroup(InetAddress mcastaddr)throws IOException{} 　　//加入多点传送组 　　public void leaveGroup(InetAddress mcastaddr)throws IOException{} 　　//离开多点传送组 　　public synchronized void send(DatagramPacket p byte ttl) throws IOException{}　　　　//发送数据报 　　public synchronized void receive(DatagramPacket p byte ttl) throws IOException{} 　　//接收数据报 　　创建一个DatagramPacket对象之后 我们必须相应地创建一个 MulticastSocket对象 这样 数据报就可以使用send()方法发送了 下面的代码演示了如何创建 MulticastSocket 发送和接收IP多点传送数据报 　　int multiPort= ;　　　//定义端口号 非超级用户应使用 以上的端口 　　int ttl= ;　 //设定TTL值 　　InetAddress multiAddr=InetAddress getByName(″ ″) 　//设定多点传送IP 　　byteSmultiBytes={ H e O }; //定义一个内容为 Hello 的数据报 　　//创建多点传送数据报 　　DatagramPacket SmultiDatagram new Datagram　　　　　　　 　　Packet(SmultiBytes SmultiBytes length multiAddr multiPort); 　　MulticastSocket multiSocket=new MulticastSocket(); 　//创建多点传送socket 　　multiSocket send(SmultiDatagram ttl) 　//发送数据报(不加入到组中) 　　…… 　　byteRmultiBytes=new byte[ ];　//定义一个空数据报 长度为 字节 　　//创建接收数据报 　　DatagramPacket RmultiDatagram=new DatagramPacket(RmultiBytes RmultiBytes length); 　　multiSocket joinGroup(multiAddr);　//加入到多点传送组中 　　multiSocket receive(RmultiDatagram);//接收UDP数据报 　　…… 　　multiSocket leaveGroup(multiAddr);　//离开多点传送组 　　multiSocket close(); 　//关闭多点传送 socket 　　当调用joinGroup()方法时 机器将关注沿着网络传送属于特定多点传送组的任何IP报文 也就是说 机器拥有了一个邮箱 主机还应使用IGMP相应地报告组的使用 对于多IP地址的机器 应配置数据报发送的接口 setInterface(oneOfMyLocalAddrs); 　　在DatagramSocket中没有类似 setSo Timeout()的方法设置超时 　　五 IP多点传送应用程序的开发流程 　　由于IP多点传送主要用于同组中成员的交流 因此 应用程序的开发流程大体如下 　　 创建一个需发送的按规定编址的数据报DatagramPacket; 　　 建立一个用于发送和接收的MulticastSocket; 　　 加入一个多点传送组 　　 将数据报放入MulticastSocket中传送出去 　　 等待从MulticastSocket接收数据报 　　 解码数据报提取信息 　　 根据得到的信息作出回应 　　 重复 — 步 　　 离开该多点传送组 关闭MulticastSocket lishixinzhi/Article/program/Java/hx/201311/27230

UDP Server程序1、编写UDP Server程序的步骤(1)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。(2)初始化sockaddr_in结构的变量，并赋值。sockaddr_in结构定义：struct sockaddr_in {uint8_t sin_len;sa_family_t sin_family;in_port_t sin_port;struct in_addr sin_addr;char sin_zero[8];};这里使用“08”作为服务程序的端口，使用“INADDR_ANY”作为绑定的IP地址即任何主机上的地址。(3)使用bind()把上面的socket和定义的IP地址和端口绑定。这里检查bind()是否执行成功，如果有错误就退出。这样可以防止服务程序重复运行的问题。(4)进入无限循环程序，使用recvfrom()进入等待状态，直到接收到客户程序发送的数据，就处理收到的数据，并向客户程序发送反馈。这里是直接把收到的数据发回给客户程序。2、udpserv.c程序内容：#include <sys/types.h>#include <sys/socket.h>#include <string.h>#include <netinet/in.h>#include <stdio.h>#include <stdlib.h>#define MAXLINE 80#define SERV_PORT 8888void do_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen){int n;socklen_t len;char mesg[MAXLINE];for(;;){len = clilen;/* waiting for receive data */n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);/* sent data back to client */sendto(sockfd, mesg, n, 0, pcliaddr, len);}}int main(void){int sockfd;struct sockaddr_in servaddr, cliaddr;sockfd = socket(AF_INET, SOCK_DGRAM, 0); /* create a socket *//* init servaddr */bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = htonl(INADDR_ANY);servaddr.sin_port = htons(SERV_PORT);/* bind address and port to socket */if(bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){perror("bind error");exit(1);}do_echo(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));return 0;}UDP Client程序1、编写UDP Client程序的步骤(1)初始化sockaddr_in结构的变量，并赋值。这里使用“8888”作为连接的服务程序的端口，从命令行参数读取IP地址，并且判断IP地址是否符合要求。(2)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。(3)使用connect()来建立与服务程序的连接。与TCP协议不同，UDP的connect()并没有与服务程序三次握手。上面我们说了UDP是非连接的，实际上也可以是连接的。使用连接的UDP，kernel可以直接返回错误信息给用户程序，从而避免由于没有接收到数据而导致调用recvfrom()一直等待下去，看上去好像客户程序没有反应一样。(4)向服务程序发送数据，因为使用连接的UDP，所以使用write()来替代sendto()。这里的数据直接从标准输入读取用户输入。(5)接收服务程序发回的数据，同样使用read()来替代recvfrom()。(6)处理接收到的数据，这里是直接输出到标准输出上。2、udpclient.c程序内容：#include <sys/types.h>#include <sys/socket.h>#include <string.h>#include <netinet/in.h>#include <stdio.h>#include <stdlib.h>#include <arpa/inet.h>#include <unistd.h>#define MAXLINE 80#define SERV_PORT 8888void do_cli(FILE *fp, int sockfd, struct sockaddr *pservaddr, socklen_t servlen){int n;char sendline[MAXLINE], recvline[MAXLINE + 1];/* connect to server */if(connect(sockfd, (struct sockaddr *)pservaddr, servlen) == -1){perror("connect error");exit(1);}while(fgets(sendline, MAXLINE, fp) != NULL){/* read a line and send to server */write(sockfd, sendline, strlen(sendline));/* receive data from server */n = read(sockfd, recvline, MAXLINE);if(n == -1){perror("read error");exit(1);}recvline[n] = 0; /* terminate string */fputs(recvline, stdout);}}int main(int argc, char **argv){int sockfd;struct sockaddr_in srvaddr;/* check args */if(argc != 2){printf("usage: udpclient <IPaddress> ");exit(1);}/* init servaddr */bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(SERV_PORT);if(inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){printf("[%s] is not a valid IPaddress ", argv[1]);exit(1);}sockfd = socket(AF_INET, SOCK_DGRAM, 0);do_cli(stdin, sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));return 0;}运行例子程序1、编译例子程序使用如下命令来编译例子程序：gcc -Wall -o udpserv udpserv.cgcc -Wall -o udpclient udpclient.c编译完成生成了udpserv和udpclient两个可执行程序。2、运行UDP Server程序执行./udpserv &命令来启动服务程序。我们可以使用netstat -ln命令来观察服务程序绑定的IP地址和端口，部分输出信息如下：Active Internet connections (only servers)Proto Recv-Q Send-Q Local Address Foreign Address Statetcp 0 0 0.0.0.0:32768 0.0.0.0:* LISTENtcp 0 0 0.0.0.0:111 0.0.0.0:* LISTENtcp 0 0 0.0.0.0:6000 0.0.0.0:* LISTENtcp 0 0 127.0.0.1:631 0.0.0.0:* LISTENudp 0 0 0.0.0.0:32768 0.0.0.0:*udp 0 0 0.0.0.0:8888 0.0.0.0:*udp 0 0 0.0.0.0:111 0.0.0.0:*udp 0 0 0.0.0.0:882 0.0.0.0:*可以看到udp处有“0.0.0.0:8888”的内容，说明服务程序已经正常运行，可以接收主机上任何IP地址且端口为8888的数据。如果这时再执行./udpserv &命令，就会看到如下信息：bind error: Address already in use说明已经有一个服务程序在运行了。3、运行UDP Client程序执行./udpclient 127.0.0.1命令来启动客户程序，使用127.0.0.1来连接服务程序，执行效果如下：Hello, World!Hello, World!this is a testthis is a test^d输入的数据都正确从服务程序返回了，按ctrl+d可以结束输入，退出程序。如果服务程序没有启动，而执行客户程序，就会看到如下信息：$ ./udpclient 127.0.0.1testread error: Connection refused说明指定的IP地址和端口没有服务程序绑定，客户程序就退出了。这就是使用connect()的好处，注意，这里错误信息是在向服务程序发送数据后收到的，而不是在调用connect()时。如果你使用tcpdump程序来抓包，会发现收到的是ICMP的错误信息。

UDP Server程序1、编写UDP Server程序的步骤(1)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。(2)初始化sockaddr_in结构的变量，并赋值。sockaddr_in结构定义：struct sockaddr_in {uint8_t sin_len;sa_family_t sin_family;in_port_t sin_port;struct in_addr sin_addr;char sin_zero[8];};这里使用“08”作为服务程序的端口，使用“INADDR_ANY”作为绑定的IP地址即任何主机上的地址。(3)使用bind()把上面的socket和定义的IP地址和端口绑定。这里检查bind()是否执行成功，如果有错误就退出。这样可以防止服务程序重复运行的问题。(4)进入无限循环程序，使用recvfrom()进入等待状态，直到接收到客户程序发送的数据，就处理收到的数据，并向客户程序发送反馈。这里是直接把收到的数据发回给客户程序。2、udpserv.c程序内容：#include <sys/types.h>#include <sys/socket.h>#include <string.h>#include <netinet/in.h>#include <stdio.h>#include <stdlib.h>#define MAXLINE 80#define SERV_PORT 8888void do_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen){int n;socklen_t len;char mesg[MAXLINE];for(;;){len = clilen;/* waiting for receive data */n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);/* sent data back to client */sendto(sockfd, mesg, n, 0, pcliaddr, len);}}int main(void){int sockfd;struct sockaddr_in servaddr, cliaddr;sockfd = socket(AF_INET, SOCK_DGRAM, 0); /* create a socket *//* init servaddr */bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = htonl(INADDR_ANY);servaddr.sin_port = htons(SERV_PORT);/* bind address and port to socket */if(bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){perror("bind error");exit(1);}do_echo(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));return 0;}UDP Client程序1、编写UDP Client程序的步骤(1)初始化sockaddr_in结构的变量，并赋值。这里使用“8888”作为连接的服务程序的端口，从命令行参数读取IP地址，并且判断IP地址是否符合要求。(2)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。(3)使用connect()来建立与服务程序的连接。与TCP协议不同，UDP的connect()并没有与服务程序三次握手。上面我们说了UDP是非连接的，实际上也可以是连接的。使用连接的UDP，kernel可以直接返回错误信息给用户程序，从而避免由于没有接收到数据而导致调用recvfrom()一直等待下去，看上去好像客户程序没有反应一样。(4)向服务程序发送数据，因为使用连接的UDP，所以使用write()来替代sendto()。这里的数据直接从标准输入读取用户输入。(5)接收服务程序发回的数据，同样使用read()来替代recvfrom()。(6)处理接收到的数据，这里是直接输出到标准输出上。2、udpclient.c程序内容：#include <sys/types.h>#include <sys/socket.h>#include <string.h>#include <netinet/in.h>#include <stdio.h>#include <stdlib.h>#include <arpa/inet.h>#include <unistd.h>#define MAXLINE 80#define SERV_PORT 8888void do_cli(FILE *fp, int sockfd, struct sockaddr *pservaddr, socklen_t servlen){int n;char sendline[MAXLINE], recvline[MAXLINE + 1];/* connect to server */if(connect(sockfd, (struct sockaddr *)pservaddr, servlen) == -1){perror("connect error");exit(1);}while(fgets(sendline, MAXLINE, fp) != NULL){/* read a line and send to server */write(sockfd, sendline, strlen(sendline));/* receive data from server */n = read(sockfd, recvline, MAXLINE);if(n == -1){perror("read error");exit(1);}recvline[n] = 0; /* terminate string */fputs(recvline, stdout);}}int main(int argc, char **argv){int sockfd;struct sockaddr_in srvaddr;/* check args */if(argc != 2){printf("usage: udpclient <IPaddress> ");exit(1);}/* init servaddr */bzero(&servaddr, sizeof(servaddr));servaddr.sin_family = AF_INET;servaddr.sin_port = htons(SERV_PORT);if(inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){printf("[%s] is not a valid IPaddress ", argv[1]);exit(1);}sockfd = socket(AF_INET, SOCK_DGRAM, 0);do_cli(stdin, sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));return 0;}运行例子程序1、编译例子程序使用如下命令来编译例子程序：gcc -Wall -o udpserv udpserv.cgcc -Wall -o udpclient udpclient.c编译完成生成了udpserv和udpclient两个可执行程序。2、运行UDP Server程序执行./udpserv &命令来启动服务程序。我们可以使用netstat -ln命令来观察服务程序绑定的IP地址和端口，部分输出信息如下：Active Internet connections (only servers)Proto Recv-Q Send-Q Local Address Foreign Address Statetcp 0 0 0.0.0.0:32768 0.0.0.0:* LISTENtcp 0 0 0.0.0.0:111 0.0.0.0:* LISTENtcp 0 0 0.0.0.0:6000 0.0.0.0:* LISTENtcp 0 0 127.0.0.1:631 0.0.0.0:* LISTENudp 0 0 0.0.0.0:32768 0.0.0.0:*udp 0 0 0.0.0.0:8888 0.0.0.0:*udp 0 0 0.0.0.0:111 0.0.0.0:*udp 0 0 0.0.0.0:882 0.0.0.0:*可以看到udp处有“0.0.0.0:8888”的内容，说明服务程序已经正常运行，可以接收主机上任何IP地址且端口为8888的数据。如果这时再执行./udpserv &命令，就会看到如下信息：bind error: Address already in use说明已经有一个服务程序在运行了。3、运行UDP Client程序执行./udpclient 127.0.0.1命令来启动客户程序，使用127.0.0.1来连接服务程序，执行效果如下：Hello, World!Hello, World!this is a testthis is a test^d输入的数据都正确从服务程序返回了，按ctrl+d可以结束输入，退出程序。如果服务程序没有启动，而执行客户程序，就会看到如下信息：$ ./udpclient 127.0.0.1testread error: Connection refused说明指定的IP地址和端口没有服务程序绑定，客户程序就退出了。这就是使用connect()的好处，注意，这里错误信息是在向服务程序发送数据后收到的，而不是在调用connect()时。如果你使用tcpdump程序来抓包，会发现收到的是ICMP的错误信息。

调用bzero函数，第一个参数是那个结构变量，第二个参数是该结构变量的占用内存大小(字节数)

UDP Server程序x0dx0a1、编写UDP Server程序的步骤x0dx0a(1)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。x0dx0a(2)初始化sockaddr_in结构的变量，并赋值。sockaddr_in结构定义：x0dx0astruct sockaddr_in {x0dx0auint8_t sin_len;x0dx0asa_family_t sin_family;x0dx0ain_port_t sin_port;x0dx0astruct in_addr sin_addr;x0dx0achar sin_zero[8];x0dx0a};x0dx0a这里使用“08”作为服务程序的端口，使用“INADDR_ANY”作为绑定的IP地址即任何主机上的地址。x0dx0a(3)使用bind()把上面的socket和定义的IP地址和端口绑定。这里检查bind()是否执行成功，如果有错误就退出。这样可以防止服务程序重复运行的问题。x0dx0a(4)进入无限循环程序，使用recvfrom()进入等待状态，直到接收到客户程序发送的数据，就处理收到的数据，并向客户程序发送反馈。这里是直接把收到的数据发回给客户程序。x0dx0ax0dx0a2、udpserv.c程序内容：x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0ax0dx0a#define MAXLINE 80x0dx0a#define SERV_PORT 8888x0dx0ax0dx0avoid do_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)x0dx0a{x0dx0aint n;x0dx0asocklen_t len;x0dx0achar mesg[MAXLINE];x0dx0ax0dx0afor(;;)x0dx0a{x0dx0alen = clilen;x0dx0a/* waiting for receive data */x0dx0an = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);x0dx0a/* sent data back to client */x0dx0asendto(sockfd, mesg, n, 0, pcliaddr, len);x0dx0a}x0dx0a}x0dx0ax0dx0aint main(void)x0dx0a{x0dx0aint sockfd;x0dx0astruct sockaddr_in servaddr, cliaddr;x0dx0ax0dx0asockfd = socket(AF_INET, SOCK_DGRAM, 0); /* create a socket */x0dx0ax0dx0a/* init servaddr */x0dx0abzero(&servaddr, sizeof(servaddr));x0dx0aservaddr.sin_family = AF_INET;x0dx0aservaddr.sin_addr.s_addr = htonl(INADDR_ANY);x0dx0aservaddr.sin_port = htons(SERV_PORT);x0dx0ax0dx0a/* bind address and port to socket */x0dx0aif(bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)x0dx0a{x0dx0aperror("bind error");x0dx0aexit(1);x0dx0a}x0dx0ax0dx0ado_echo(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));x0dx0ax0dx0areturn 0;x0dx0a}x0dx0ax0dx0aUDP Client程序x0dx0a1、编写UDP Client程序的步骤x0dx0a(1)初始化sockaddr_in结构的变量，并赋值。这里使用“8888”作为连接的服务程序的端口，从命令行参数读取IP地址，并且判断IP地址是否符合要求。x0dx0a(2)使用socket()来建立一个UDP socket，第二个参数为SOCK_DGRAM。x0dx0a(3)使用connect()来建立与服务程序的连接。与TCP协议不同，UDP的connect()并没有与服务程序三次握手。上面我们说了UDP是非连接的，实际上也可以是连接的。使用连接的UDP，kernel可以直接返回错误信息给用户程序，从而避免由于没有接收到数据而导致调用recvfrom()一直等待下去，看上去好像客户程序没有反应一样。x0dx0a(4)向服务程序发送数据，因为使用连接的UDP，所以使用write()来替代sendto()。这里的数据直接从标准输入读取用户输入。x0dx0a(5)接收服务程序发回的数据，同样使用read()来替代recvfrom()。x0dx0a(6)处理接收到的数据，这里是直接输出到标准输出上。x0dx0ax0dx0a2、udpclient.c程序内容：x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0a#include x0dx0ax0dx0a#define MAXLINE 80x0dx0a#define SERV_PORT 8888x0dx0ax0dx0avoid do_cli(FILE *fp, int sockfd, struct sockaddr *pservaddr, socklen_t servlen)x0dx0a{x0dx0aint n;x0dx0achar sendline[MAXLINE], recvline[MAXLINE + 1];x0dx0ax0dx0a/* connect to server */x0dx0aif(connect(sockfd, (struct sockaddr *)pservaddr, servlen) == -1)x0dx0a{x0dx0aperror("connect error");x0dx0aexit(1);x0dx0a}x0dx0ax0dx0awhile(fgets(sendline, MAXLINE, fp) != NULL)x0dx0a{x0dx0a/* read a line and send to server */x0dx0awrite(sockfd, sendline, strlen(sendline));x0dx0a/* receive data from server */x0dx0an = read(sockfd, recvline, MAXLINE);x0dx0aif(n == -1)x0dx0a{x0dx0aperror("read error");x0dx0aexit(1);x0dx0a}x0dx0arecvline[n] = 0; /* terminate string */x0dx0afputs(recvline, stdout);x0dx0a}x0dx0a}x0dx0ax0dx0aint main(int argc, char **argv)x0dx0a{x0dx0aint sockfd;x0dx0astruct sockaddr_in srvaddr;x0dx0ax0dx0a/* check args */x0dx0aif(argc != 2)x0dx0a{x0dx0aprintf("usage: udpclient ");x0dx0aexit(1);x0dx0a}x0dx0ax0dx0a/* init servaddr */x0dx0abzero(&servaddr, sizeof(servaddr));x0dx0aservaddr.sin_family = AF_INET;x0dx0aservaddr.sin_port = htons(SERV_PORT);x0dx0aif(inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)x0dx0a{x0dx0aprintf("[%s] is not a valid IPaddress ", argv[1]);x0dx0aexit(1);x0dx0a}x0dx0ax0dx0asockfd = socket(AF_INET, SOCK_DGRAM, 0);x0dx0ax0dx0ado_cli(stdin, sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));x0dx0ax0dx0areturn 0;x0dx0a}x0dx0ax0dx0a运行例子程序x0dx0a1、编译例子程序x0dx0a使用如下命令来编译例子程序：x0dx0agcc -Wall -o udpserv udpserv.cx0dx0agcc -Wall -o udpclient udpclient.cx0dx0a编译完成生成了udpserv和udpclient两个可执行程序。x0dx0ax0dx0a2、运行UDP Server程序x0dx0a执行./udpserv &命令来启动服务程序。我们可以使用netstat -ln命令来观察服务程序绑定的IP地址和端口，部分输出信息如下：x0dx0aActive Internet connections (only servers)x0dx0aProto Recv-Q Send-Q Local Address Foreign Address Statex0dx0atcp 0 0 0.0.0.0:32768 0.0.0.0:* LISTENx0dx0atcp 0 0 0.0.0.0:111 0.0.0.0:* LISTENx0dx0atcp 0 0 0.0.0.0:6000 0.0.0.0:* LISTENx0dx0atcp 0 0 127.0.0.1:631 0.0.0.0:* LISTENx0dx0audp 0 0 0.0.0.0:32768 0.0.0.0:*x0dx0audp 0 0 0.0.0.0:8888 0.0.0.0:*x0dx0audp 0 0 0.0.0.0:111 0.0.0.0:*x0dx0audp 0 0 0.0.0.0:882 0.0.0.0:*x0dx0a可以看到udp处有“0.0.0.0:8888”的内容，说明服务程序已经正常运行，可以接收主机上任何IP地址且端口为8888的数据。x0dx0a如果这时再执行./udpserv &命令，就会看到如下信息：x0dx0abind error: Address already in usex0dx0a说明已经有一个服务程序在运行了。x0dx0ax0dx0a3、运行UDP Client程序x0dx0a执行./udpclient 127.0.0.1命令来启动客户程序，使用127.0.0.1来连接服务程序，执行效果如下：x0dx0aHello, World!x0dx0aHello, World!x0dx0athis is a testx0dx0athis is a testx0dx0a^dx0dx0a输入的数据都正确从服务程序返回了，按ctrl+d可以结束输入，退出程序。x0dx0a如果服务程序没有启动，而执行客户程序，就会看到如下信息：x0dx0a$ ./udpclient 127.0.0.1x0dx0atestx0dx0aread error: Connection refusedx0dx0a说明指定的IP地址和端口没有服务程序绑定，客户程序就退出了。这就是使用connect()的好处，注意，这里错误信息是在向服务程序发送数据后收到的，而不是在调用connect()时。如果你使用tcpdump程序来抓包，会发现收到的是ICMP的错误信息。

可以用SoapUI!SoapUI是测webservice的专业工具,不仅可以测试结果的正确性,还可以测试webservice的性能如果你用的是myeclipse我知道,myeclipse也可以测.webservice访问实际上就是一次http请求,那么也就是请求和响应.1.向webservice地址发送soap请求报文,2.webservice服务器返回soap结果报文.所以说测试也就是发送报文,然后看返回结果报文,返回正确,那么测试就成功了

socket协议的接口测试方法1.loadrunner使用socket协议写C调用底层socket协议数据2.jmeter添加websocket相关依赖包，可以添加websocket协议的sampler3.专门的socket协议测试工具，比如socket工具，tcpudptest等工具。tcpudptest无法设置并发数据量，不方便，而socket工具可以设置并发数据量，而且有相关的数据发送接收包的图像实时图，8583报文可用此方式。4.socket外面套一层http协议，http协议走socket管道，直接使用jmeter的http请求压测。

Connected属性是表示当前是否为连接状态你发送数据之前是False,发送中就应该变成true了

socket关闭——应该说是TCP关闭，需要进行4次握手，一方close后只表示自己不在发送数据（也不能发送了），这个通道要等到对方返回一个fin-ack才会真正关闭。TCP还是UDP??? ==>UDP没有连接的说法一方断了,别一方也会断的啊.... ==>完全错误的说法，这需要程序自己来控制的查断点看看Socket对象的属性啥情况 ==>这个你能看得到吗？socket是内核维护的，用户程序只有一个句柄，也就是一个int而已，如果你有办法在断点查看socket属性

socket关闭——应该说是TCP关闭，需要进行4次握手，一方close后只表示自己不在发送数据（也不能发送了），这个通道要等到对方返回一个fin-ack才会真正关闭。TCP还是UDP??? ==>UDP没有连接的说法一方断了,别一方也会断的啊.... ==>完全错误的说法，这需要程序自己来控制的查断点看看Socket对象的属性啥情况 ==>这个你能看得到吗？socket是内核维护的，用户程序只有一个句柄，也就是一个int而已，如果你有办法在断点查看socket属性

socket（计算机专业术语）：网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。queue（线性表）：队列是一种特殊的线性表，是一种先进先出（FIFO）的数据结构。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。而其在C++中的应用语法：queue类是为程序员提供了一个队列的功能的容器适配器，具体而言，一个FIFO（先入先出）的数据结构；在头文件<queue>中定义（在程序开头输入#include <queue>，切记不可写为#include <queue.h>）。望采纳

nipple 带外螺纹的直通管件socket 是承插的意思

当我们使用像 nproc或者 lscpu等命令 来在CPU级别上获取计算机的架构和性能的时候，我们常常会发现我们不能够正确的解释这些命令的结果，原因在于我们搞不清楚一些术语的含义，例如： 物理CPU (physical CPU)、 逻辑CPU(logical CPU)、虚拟CPU(virtual CPU)、核数(core)、线程数(thread)、颗数(socket)等。如果再加上 超线程（不要与多线程搞混了）的概念，我们就完全搞不清楚我们的机器是多少核（Core）的了,比如说，我们明明购买的是一个配置为 4核处理器的机器，使用htop命令的结果却显示我们有8个cpu。总而言之，真是一团乱麻 o(╯□╰)o。 为了阐述清楚这些问题，我将使用一组简单的图表，希望能够让你容易地明白上面这些概念，从此不再困惑。 让我们回到奔腾(Pentium)处理器的年代，那时候诸如 多核(multi-core)、虚拟CPU(virtual CPU)、逻辑CPU(virtual CPU)的概念还不存在，绝大多数的计算机在它们的主板上仅仅安装 单独的一块大容量芯片，我们称之为 微处理器、处理器或者 简单的CPU（microprocessor, processor or simply CPU）。只有少数的一些企业级计算机或者是大型的服务器因为对更大处理性能的需要才会在同一块主板上存在两块或更多的CPU芯片：我们把这样的机器称作是多处理器系统（multiprocessor systems）。这些芯片与主板上的其他组件通过一个连接器（connector）或者 插槽（socket）通信。 这样的话计算cpu的个数就很简单了： 主板上存在多少个这样的连接器（connector）或 插槽（socket）,那么这台计算机就有多少个cpu。如果希望获得更强大的处理性能，一是在主板上安装更多的cpu，二是提高每一个cpu自身的处理能力。 但是后来Intel意识到 在一台多处理器的机器上不同处理器之间的通信非常的低效，因为这样的通信必须经过系统总线（the system bus），而系统总线通常速度都很慢。这样就常常会造成性能瓶颈，无法充分利用每一个CPU提供的计算能力。 为了应对上面提到的问题，发明了超线程技术（HyperThreading）， 超线程的原理是在同一个cpu芯片内部有些内部组件会存在多份，比如 寄存器或者一级缓存，这样同一个cpu就可以用来执行多个线程或者进程，并且它们之间的通信是在cpu内部，不会造成因为要经由系统总线通信而造成的性能瓶颈。如果一个进程因为等待一个中断而阻塞，那另一个进程就可以继续使用这个cpu来计算（注： 所以实际上超线程并不能真正意义上实现并行）。 这种方式的确可能加速多个计算进程，并提供比传统的处理器更为强大的整体性能。某种程度上来说，此时的操作系统是被欺骗了的，因为超线程实际上仅仅提供了两个虚拟或者逻辑CPU（LCPU）就让操作系统可以"同时"执行两个进程了（注：注意 同时 加了引号）。需要重点指出的是： 使用超线程技术的处理器 是无法提供一个传统处理器两倍的计算能力的，也不能够实现真正意义上的并行计算。（注： 这就是前面 同时 加了引号的原因） 因此，从Linux或者其他操作系统的角度来看：一个单核处理器却展现出拥有两个处理器的能力。 只不过这两个逻辑cpu运行在同一个物理cpu内部而已。 下面这张图说明了 超线程的实现原理： 注: 说一些对这张图的理解，在一个物理cpu内部，存在两组 寄存器，分别属于一个 逻辑CPU， 但是只存在一组ALU（算数逻辑单元），如果每一个逻辑cpu上运行一个进程，那么这两个进程间的通信就完全在CPU内部，无需通过系统总线，但是 从唯一的ALU上我们也能看出来 实际上是无法真正意义上同时执行两个进程的。 就像前面说的那样，尽管超线程技术提供了更强的处理性能，但是终究无法像两个独立的物理处理器那样。所以进一步的改进是 将所有处理器组件做的更小，实现在同一个芯片上可以同时存在多个处理器。在同一个芯片上的每一个处理器我们称之为 核（Core），同一个芯片上的多个核也无需通过慢速的系统总线通信，因为在这个芯片内部存在内部总线。 注： 我们常说的几颗几核的含义： Core（核） 代表一个独立的Cpu， Socket（颗） 本意是插槽， 代表一个主板上的芯片，多核架构就是在一个芯片上放多个处理器，就像上面说的那样， 所以如果我们说 2颗4核， 代表主板上有2个芯片插槽，每个芯片上存在4个cpu，所以我们有8个物理cpu，如果存在超线程，我们还可能多出8个逻辑cpu，总共16个逻辑cpu 下面这张图展示了一个 四核CPU，并且使用了超线程技术，我们可以看到这四个核都存在于同一个芯片上（CPU chip），它们通过内部的BUS INTERFACE通信。 与超线程技术不同，现在我们完全拥有了成倍的处理能力。而且从性能上来说， 一个一颗四核的处理器要更优于四个一颗一核（也就是传统的单核CPU）的处理器。 在操作系统层面上来看，一个物理的四核处理器将被看做四个独立的处理器。如果提供了超线程，那么可能会再多出4个逻辑处理器（LCPU），这样的话我们通过命令行查看的话就会显示出有8个cpu，但是就像我们前面已经指出的那样，因为超线程才拥有的这8个cpu肯定比不上 一个没有超线程的物理的8核处理器。 有时候我们会发现处理器标称每核有4线程，2线程或类似的说法，简单来说这就是指每核cpu上能够“同时”运行的线程或进程数（注意同时依旧加了引号）,基本上就是一个逻辑cpu（LCPU）能运行一个进程或线程。如果每核能执行2个或更多的线程，那么一定使用了超线程技术，否则每一核就只能运行一个线程或进程。 虚拟CPU基本等同于逻辑CPU，但是存在一点不同：虚拟CPU更多的是限定在 计算虚机化的语境内。虚拟CPU映射到 虚拟化底层的宿主机硬件资源，通常来说，一个宿主机上的逻辑cpu就映射为一个虚拟机内部的虚拟CPU，所以他们基本上是同一个术语。 注： 最后附上我的一台环境的cpu信息，这是一个运行虚拟机的宿主机，我们看到它有40个逻辑cpu， 我在虚拟化管理台上给一个虚拟机分配40个cpu的时候会报错，39个就能成功创建，某种程度上证明了上面关于虚拟cpu的说法： 翻译自： http://www.daniloaz.com/en/differences-between-physical-cpu-vs-logical-cpu-vs-core-vs-thread-vs-socket/

如果你是客户端，那么可以调用connect进行连接。 如果你是服务器端，那么无法进行重连（只能等待客户端发来的连接请求）。

如果你是客户端，那么可以调用connect进行连接。 如果你是服务器端，那么无法进行重连（只能等待客户端发来的连接请求）。

socket一旦断开，就无法再重新连接了（相关资源已被释放掉了）。只能重新创建新的socket去连接。

你可以查看一下SOAP，简单对象访问协议，采用这种方式来操作，看看可否。

法一：当recv()返回值小于等于0时，socket连接断开。但是还需要判断errno是否等于EINTR，如果errno==EINTR则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。法二：structtcp_infoinfo;intlen=sizeof(info);getsockopt(sock,IPPROTO_TCP,TCP_INFO,&info,(socklen_t*)&len);if((info.tcpi_state==TCP_ESTABLISHED))则说明未断开else断开法三：若使用了select等系统函数，若远端断开，则select返回1，recv返回0则断开。其他注意事项同法一。法四：intkeepAlive=1;//开启keepalive属性intkeepIdle=60;//如该连接在60秒内没有任何数据往来,则进行探测intkeepInterval=5;//探测时发包的时间间隔为5秒intkeepCount=3;//探测尝试的次数.如果第1次探测包就收到响应了,则后2次的不再发.setsockopt(rs,SOL_SOCKET,SO_KEEPALIVE,(void*)&keepAlive,sizeof(keepAlive));setsockopt(rs,SOL_TCP,TCP_KEEPIDLE,(void*)&keepIdle,sizeof(keepIdle));setsockopt(rs,SOL_TCP,TCP_KEEPINTVL,(void*)&keepInterval,sizeof(keepInterval));setsockopt(rs,SOL_TCP,TCP_KEEPCNT,(void*)&keepCount,sizeof(keepCount));设置后，若断开，则在使用该socket读写时立即失败，并返回ETIMEDOUT错误法五：自己实现一个心跳检测，一定时间内未收到自定义的心跳包则标记为已断开。

法一：当recv()返回值小于等于0时，socket连接断开。但是还需要判断 errno是否等于 EINTR，如果errno == EINTR 则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。法二： struct tcp_info info; int len=sizeof(info); getsockopt(sock, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&len); if((info.tcpi_state==TCP_ESTABLISHED)) 则说明未断开 else 断开法三：若使用了select等系统函数，若远端断开，则select返回1，recv返回0则断开。其他注意事项同法一。法四：int keepAlive = 1; // 开启keepalive属性int keepIdle = 60; // 如该连接在60秒内没有任何数据往来,则进行探测 int keepInterval = 5; // 探测时发包的时间间隔为5 秒int keepCount = 3; // 探测尝试的次数.如果第1次探测包就收到响应了,则后2次的不再发.setsockopt(rs, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepAlive, sizeof(keepAlive));setsockopt(rs, SOL_TCP, TCP_KEEPIDLE, (void*)&keepIdle, sizeof(keepIdle));setsockopt(rs, SOL_TCP, TCP_KEEPINTVL, (void *)&keepInterval, sizeof(keepInterval));setsockopt(rs, SOL_TCP, TCP_KEEPCNT, (void *)&keepCount, sizeof(keepCount));设置后，若断开，则在使用该socket读写时立即失败，并返回ETIMEDOUT错误

。

JDK 中的，有这个 void setSoTimeout(int timeout) Enable/disable SO_TIMEOUT with the specified timeout, in milliseconds.

不同的系统不一样的，windows一般是通过改注册表来改变keepalivetime的值。linux或unix下这个值也是基于整个内核的，它的改变会影响本机所有设置了这个选项的socket。

法一：当recv()返回值小于等于0时，socket连接断开。但是还需要判断 errno是否等于 EINTR，如果errno == EINTR 则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。法二：struct tcp_info info;int len=sizeof(info);getsockopt(sock, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&len);if((info.tcpi_state==TCP_ESTABLISHED)) 则说明未断开 else 断开法三：若使用了select等系统函数，若远端断开，则select返回1，recv返回0则断开。其他注意事项同法一。法四：int keepAlive = 1; // 开启keepalive属性int keepIdle = 60; // 如该连接在60秒内没有任何数据往来,则进行探测 int keepInterval = 5; // 探测时发包的时间间隔为5 秒int keepCount = 3; // 探测尝试的次数.如果第1次探测包就收到响应了,则后2次的不再发.setsockopt(rs, SOL_SOCKET, SO_KEEPALIVE, (void *)&keepAlive, sizeof(keepAlive));setsockopt(rs, SOL_TCP, TCP_KEEPIDLE, (void*)&keepIdle, sizeof(keepIdle));setsockopt(rs, SOL_TCP, TCP_KEEPINTVL, (void *)&keepInterval, sizeof(keepInterval));setsockopt(rs, SOL_TCP, TCP_KEEPCNT, (void *)&keepCount, sizeof(keepCount));设置后，若断开，则在使用该socket读写时立即失败，并返回ETIMEDOUT错误法五：自己实现一个心跳检测，一定时间内未收到自定义的心跳包则标记为已断开。

当使用 select()函数测试一个socket是否可读时，如果select()函数返回值为1，且使用recv()函数读取的数据长度为0 时，就说明该socket已经断开。为了更好的判定socket是否断开，我判断当recv()返回值小于等于0时，socket连接断开。但是还需要判断 errno是否等于 EINTR 。如果errno == EINTR 则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。

开始--运行--cmd 进入命令提示符 输入netstat -ano 即可看到所有连接的PID 之后在任务管理器中找到这个PID所对应的程序如果任务管理器中没有PID这一项，可以在任务管理器中选"查看"-"选择列" 经常，我们在启动应用的时候发现系统需要的端口被别...

楼主，这个范围太范了！~。你应该比较系统的学习一些资料！等你了解了之后，你会知道 其实Socket用法很简单，就是Scoekt、TcpClient和TcpListener这几个的运用。。我收藏了一些资料，我分享给你，希望能帮助你：C# Socket编程笔记http://www.cnblogs.com/stg609/archive/2008/11/15/1333889.html网络编程系列http://www.cnblogs.com/zhili/category/397082.htmlTCP实现聊天室http://www.cnblogs.com/holyknight-zld/archive/2012/07/18/WebFormSocket.html较高级的那些年，我们一起追寻的异步编程http://www.cnblogs.com/heyuquan/archive/2013/04/26/3045827.html为了证明我不是随便给你的，我截图一下 哈哈。。加油！ 有问题 可以在讨论哈。

关于websocket服务如何启动，代码如下：@ServerEndpoint(value = "/chat-room-channel")public class ChatRoomChannel {Logger logger = LoggerFactory.getLogger(ChatRoomChannel.class);public static final Set<Session> SESSIONS = Collections.synchronizedSet(new HashSet<Session>());public static void notifyAll(String message) {synchronized (SESSIONS) {final Iterator<Session> i = SESSIONS.iterator();while (i.hasNext()) {final Session session = i.next();if (session.isOpen()) {session.getAsyncRemote().sendText(message);}}}}@OnOpenpublic void onConnect(final Session session){SESSIONS.add(session);HashMap<String, Object> msgMap = new HashMap<String, Object>();msgMap.put(Commom.TYPE, Commom.ONLINE);msgMap.put(Commom.MESSAGE, SESSIONS.size());String messgae = new JSONObject(msgMap).toString();logger.debug(messgae);notifyAll(messgae);}}

二进制的消息大小69711超过最大限制65536

multi socket ---多用插座请采纳

代码执行时间过长，超时了

事件 或者 action 做回调

我也是花了半天时间学习，花半天时间封装自己的Server类。还是建议你自己动手写，写了你就明白了，明白后就会知道也不是很复杂

socketerrorcode:11001,socketerrorinfo:不知道这样的主机。 表示您的计算机无法连上服务器，请检查您的Proxy设定以及Proxy相关账号，或暂时取消您防毒软件的「个人防火墙」。 2、出现网络联机错误Socketerror#11004 socketerrorcode:11004,socketerrorinfo:请求的名称有效，但是找不到请求的类型的数据。 应该是网络联机状态问题，请用户检查网络联机是否正常。 3、出现网络联机错误Socketerror#10060 Connection Timed Out socketerrorcode:10060,socketerrorinfo:由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。 表示您与服务器发生联机逾时错误，请检查您的Proxy相关设定，以及Proxy Server是否已将SSL 443 port打开。 4、出现网络联机错误Socketerror#10061 socketerrorcode:10061,socketerrorinfo:由于目标计算机积极拒绝，无法连接。

Socket closed套接字关闭啊... 是你连数据库的问题

Socket是插座、插线板，例如公牛插座这类东西。Plug是插头，连接电线的那个两孔或三孔插头。

呃，楼主，我觉得slive是笔误，应该是Sleeve吧。Sleeve就是所谓的”套管”plug 通常是管塞socket 是接头，通常是外接头。不管怎样，楼主最好看了实物再确定，有时候项目上的人员知道实物是什么，但是报给我们的名称却错的一塌糊涂。希望能帮到楼主！:)

被插 和 插

进程通讯中的socket和port的区别　　port：一种接口,数据通过它在计算机和其它设备(如打印机、鼠标、键盘或监视器)之间、网络之间或和其它直接连接的计算机之间传递。　　什么是socket 所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。　　IP是英文Internet Protocol的缩写，意思是“网络之间互连的协议”，也就是为计算机网络相互连接进行通信而设计的协议。在因特网中，它是能使连接到网上的所有计算机网络实现相互通信的一套规则，规定了计算机在因特网上进行通信时应当遵守的规则。

　　port：一种接口,数据通过它在计算机和其它设备(如打印机、鼠标、键盘或监视器)之间、网络之间或和其它直接连接的计算机之间传递。　　什么是socket 所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。　　IP是英文Internet Protocol的缩写，意思是“网络之间互连的协议”，也就是为计算机网络相互连接进行通信而设计的协议。在因特网中，它是能使连接到网上的所有计算机网络实现相互通信的一套规则，规定了计算机在因特网上进行通信时应当遵守的规则。

undefined reference to `WSAStartup@8" 你编译的好像不对，你把前面这个解决了。代码是C语言的。

页面跳转时，这ServerSocket 应该是保持原来的诊听状态的吧。所以，程序决定退出时，一定要释放资源，否则，仍诊听状态，再运行会出错：端口已绑定。

重装系统吧

Socket error 0 - Directly send error Socket error 10004 - Interrupted function //call 操作被终止 Socket error 10013 - Permission denied //c访问被拒绝 Socket error 10014 - Bad address //c地址错误 Socket error 10022 - Invalid argument //参数错误 Socket error 10024 - Too many open files // 打开太多的sockets Socket error 10035 - Resource temporarily unavailable // 没有可以获取的资料 Socket error 10036 - Operation now in progress // 一个阻塞操作正在进行中 Socket error 10037 - Operation already in progress // 操作正在进行中 Socket error 10038 - Socket operation on non-socket //非法的socket对象在操作 Socket error 10039 - Destination address required //目标地址错误 Socket error 10040 - Message too long //数据太长 Socket error 10041 - Protocol wrong type for socket //协议类型错误 Socket error 10042 - Bad protocol option // 错误的协议选项 Socket error 10043 - Protocol not supported //协议不被支持 Socket error 10044 - Socket type not supported //socket类型不支持 Socket error 10045 - Operation not supported //不支持该操作 Socket error 10046 - Protocol family not supported //协议族不支持 Socket error 10047 - Address family not supported by protocol family//使用的地址族不在支持之列 Socket error 10048 - Address already in use //地址已经被使用 Socket error 10049 - Cannot assign requested address //地址设置失败 Socket error 10050 - Network is down //网络关闭 Socket error 10051 - Network is unreachable //网络不可达 Socket error 10052 - Network dropped connection on reset //网络被重置 Socket error 10053 - Software caused connection abort //软件导致连接退出 Socket error 10054 - connection reset by peer //连接被重置 Socket error 10055 - No buffer space available //缓冲区不足 Socket error 10056 - Socket is already connected // socket已经连接 Socket error 10057 - Socket is not connected //socket没有连接 Socket error 10058 - Cannot send after socket shutdown //socket已经关闭 Socket error 10060 - Connection timed out //超时 Socket error 10061 - Connection refused //连接被拒绝 Socket error 10064 - Host is down //主机已关闭 Socket error 10065 - No route to host // 没有可达的路由 Socket error 10067 - Too many processes //进程太多 Socket error 10091 - Network subsystem is unavailable //网络子系统不可用 Socket error 10092 - WINSOCK.DLL version out of range //winsock.dll版本超出范围 Socket error 10093 - Successful WSAStartup not yet performed //没有成功执行WSAStartup Socket error 10094 - Graceful shutdown in progress // Socket error 11001 - Host not found //主机没有找到 Socket error 11002 - Non-authoritative host not found // 非授权的主机没有找到 Socket error 11003 - This is a non-recoverable error //这是个无法恢复的错误 Socket error 11004 - Valid name, no data record of requested type //请求的类型的名字或数据错误 WSAEADDRINUSE (10048) Address already in use WSAECONNABORTED (10053) Software caused connection abort WSAECONNREFUSED (10061) Connection refused WSAECONNRESET (10054) Connection reset by peer WSAEDESTADDRREQ (10039) Destination address required WSAEHOSTUNREACH (10065) No route to host WSAEMFILE (10024) Too many open files WSAENETDOWN (10050) Network is down WSAENETRESET (10052) Network dropped connection WSAENOBUFS (10055) No buffer space available WSAENETUNREACH (10051) Network is unreachable WSAETIMEDOUT (10060) Connection timed out WSAHOST_NOT_FOUND (11001) Host not found WSASYSNOTREADY (10091) Network sub-system is unavailable WSANOTINITIALISED (10093) WSAStartup() not performed WSANO_DATA (11004) Valid name, no data of that type WSANO_RECOVERY (11003) Non-recoverable query error WSATRY_AGAIN (11002) Non-authoritative host found WSAVERNOTSUPPORTED (10092) Wrong WinSock DLL version

int socket(int domain, int type, int protocol); domain指明所使用的协议族，通常为PF_INET/AF_INET，表示互联网协议族（TCP/IP协议族）；type参数指 定socket的类型：SOCK_STREAM （TCP）或SOCK_DGRAM（UDP），Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值"0"。Socket()调用返回一个整型socket描述符，你可以在后面 的调用使用它。

Input和Output1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：1.1 以字节为导向的stream以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：1) input stream：1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用2) StringBufferInputStream：把一个String对象作为InputStream3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作4) PipedInputStream：实现了pipe的概念，主要在线程中使用5) SequenceInputStream：把多个InputStream合并为一个InputStream2) Out stream1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中2) FileOutputStream：把信息存入文件中3) PipedOutputStream：实现了pipe的概念，主要在线程中使用4) SequenceOutputStream：把多个OutStream合并为一个OutStream1.2 以Unicode字符为导向的stream以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：1) Input Stream1) CharArrayReader：与ByteArrayInputStream对应2) StringReader：与StringBufferInputStream对应3) FileReader：与FileInputStream对应4) PipedReader：与PipedInputStream对应2) Out Stream1) CharArrayWrite：与ByteArrayOutputStream对应2) StringWrite：无与之对应的以字节为导向的stream3) FileWrite：与FileOutputStream对应4) PipedWrite：与PipedOutputStream对应以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。1.3 两种不现导向的stream之间的转换InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。2. stream添加属性2.1 “为stream添加属性”的作用运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。如果我们要往一个文件中写入数据，我们可以这样操作：FileOutStream fs = new FileOutStream(“test.txt”);然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。2.2 FilterInputStream的各种类型2.2.1 用于封装以字节为导向的InputStream1) DataInputStream：从stream中读取基本类型（int、char等）数据。2) BufferedInputStream：使用缓冲区3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)4) PushbackInputStream：很少用到，一般用于编译器开发2.2.2 用于封装以字符为导向的InputStream1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream2) BufferedReader：与BufferedInputStream对应3) LineNumberReader：与LineNumberInputStream对应4) PushBackReader：与PushbackInputStream对应2.3 FilterOutStream的各种类型2.2.3 用于封装以字节为导向的OutputStream1) DataIOutStream：往stream中输出基本类型（int、char等）数据。2) BufferedOutStream：使用缓冲区3) PrintStream：产生格式化输出2.2.4 用于封装以字符为导向的OutputStream1) BufferedWrite：与对应2) PrintWrite：与对应3. RandomAccessFile1) 可通过RandomAccessFile对象完成对文件的读写操作2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写3) 可以直接跳到文件中指定的位置4. I/O应用的一个例子import java.io.*;public class TestIO{public static void main(String[] args)throws IOException{//1.以行为单位从一个文件读取数据BufferedReader in = new BufferedReader(new FileReader("F:\nepalon\TestIO.java"));String s, s2 = new String();while((s = in.readLine()) != null)s2 += s + " ";in.close();//1b. 接收键盘的输入BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter a line:");System.out.println(stdin.readLine());//2. 从一个String对象中读取数据StringReader in2 = new StringReader(s2);int c;while((c = in2.read()) != -1)System.out.println((char)c);in2.close();//3. 从内存取出格式化输入try{DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(s2.getBytes()));while(true)System.out.println((char)in3.readByte()); }catch(EOFException e){System.out.println("End of stream");}//4. 输出到文件try{BufferedReader in4 =new BufferedReader(new StringReader(s2));PrintWriter out1 =new PrintWriter(new BufferedWriter(new FileWriter("F:\nepalon\ TestIO.out")));int lineCount = 1;while((s = in4.readLine()) != null)out1.println(lineCount++ + "：" + s);out1.close();in4.close();}atch(EOFException ex){System.out.println("End of stream");}//5. 数据的存储和恢复try{DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("F:\nepalon\ Data.txt")));out2.writeDouble(3.1415926);out2.writeChars(" Thas was pi:writeChars ");out2.writeBytes("Thas was pi:writeByte ");out2.close();DataInputStream in5 =new DataInputStream(new BufferedInputStream(new FileInputStream("F:\nepalon\ Data.txt")));BufferedReader in5br =new BufferedReader(new InputStreamReader(in5));System.out.println(in5.readDouble());System.out.println(in5br.readLine());System.out.println(in5br.readLine());}catch(EOFException e){System.out.println("End of stream");}//6. 通过RandomAccessFile操作文件RandomAccessFile rf =new RandomAccessFile("F:\nepalon\ rtest.dat", "rw");for(int i=0; i<10; i++)rf.writeDouble(i*1.414);rf.close();rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "r");for(int i=0; i<10; i++)System.out.println("Value " + i + "：" + rf.readDouble());rf.close();rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "rw");rf.seek(5*8);rf.writeDouble(47.0001);rf.close();rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "r");for(int i=0; i<10; i++)System.out.println("Value " + i + "：" + rf.readDouble());rf.close();}}关于代码的解释（以区为单位）：1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。5 区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读 取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正 确显示。也要以基本类型的形式进行读取。6区是通过RandomAccessFile类对文件进行操作。补充：用下面的方式就应该可以了BufferedReader in = new BufferedReader(new FileReader("b.txt")); 如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！vaela

bind，是绑定一个本地的端口，listen是侦听一个远程的连接端口

成v吧

淘宝购买shadowsocket节点的方法：1、添加账户，不想手动输入账号的话，可以点击左上角的方框来扫描账户二维码。2、账户添加完成后，点击主界面右上角的Type，再添加节点，添加的时候将类型改为Subscribe，复制订阅地址到URL中，完成后点击右上角来保存。3、在账户中选择购买shadowsocket节点即可。

1、 WebService到底是什么？ 2、 Web service是什么？ 3、 什么是WEBService，实现WEBService有哪些框架，为什么WEBService经常被认为太重了，只有银行和大型国企才会使用的更多有一些？4、 理解RESTful架构 5、 WebService入门介绍

功能实现就行了

建议你使用 Kaptcha 验证码插件，详细访问http://code.google.com/p/kaptcha/ 这里，很简单实用。

当你写入一个被关闭的连接内容时，通常是用户取消或者下载的时候会发生这种异常。

dfdfdffdfdsfdfdfd

socket hang up是说你能连上对方，但对方没有在规定时间内结束通信。可能是你的网不好，也可能是对方服务器写的不好。你的程序里处理这个错误的时候可以等一段时间重试

当然，ip地址都变了 socket 咋会不断呢除非搞mobile ip

workerman的特性Workerman是一款纯PHP开发的开源的高性能的PHP socket 异步框架。被广泛的用于移动通讯、手游服务端、网络游戏服务器、聊天室服务器、硬件通讯服务器、智能家居、车联网、物联网等领域的开发。 支持Websocket、HTTP等协议，支持自定义协议。基于workerman开发者可以更专注于业务逻辑开发，不必再为PHP Socket底层开发而烦恼。workerman诸多的不同寻常的特性，使得PHP开发者可以开发出不同寻常的应用程序。

　　前台实现　　1 connect:function() {　　2 var webSocketIP = window.CRM_CONFIG.WebSocketIP;　　3 var target = "ws://"+webSocketIP+"/websocket";　　4 if ("WebSocket" in window) {　　5 ws = new WebSocket(target);　　6 } else if ("MozWebSocket" in window) {　　7 ws = new MozWebSocket(target);　　8 } else {　　9 return;　　10 }　　11 ws.onopen = function () {　　12 console.log("Info: WebSocket connection opened.");　　13 document.getElementById("wsMsg").style.display = "block";　　14 };　　15 var self = this;　　16 ws.onmessage = function (event) {　　17 if("您有如下工单需要及时处理："!= event.data) {　　18 self.setState({wsMessage: event.data})　　19 document.getElementById("wsMsg").style.display = "block";　　20 }else{　　21 document.getElementById("wsMsg").style.display = "none";　　22 }　　23 };　　24　　25 <div id="wsMsg" className="msgDialog msgDiv">　　26 <div className="msgContent" ><a onClick ={this.closeMsg}> X </a></div>　　27 {this.state.wsMessage}　　28 </div>　　2、pom.xml依赖　　1 <!--spring-websocket-->　　2 <dependency>　　3 <groupId>javax.servlet</groupId>　　4 <artifactId>javax.servlet-api</artifactId>　　5 <version>3.1.0</version>　　6 </dependency>　　7 <dependency>　　8 <groupId>org.springframework</groupId>　　9 <artifactId>spring-websocket</artifactId>　　10 <version>${spring.version}</version>　　11 </dependency>　　3、spring.xml配置　　<!--websocket 配置-->　　<bean id="websocket" class="com.oasis.crm.controller.websocket.WebsocketEndPoint"/>　　<websocket:handlers allowed-origins="*">　　<websocket:mapping path="/websocket" handler="websocket"/>　　<websocket:handshake-interceptors>　　<bean class="com.oasis.crm.controller.websocket.HandshakeInterceptor"/>　　</websocket:handshake-interceptors>　　</websocket:handlers>　　4、java代码　　package com.oasis.crm.controller.websocket;　　import com.oasis.crm.dao.biz.user.UserDao;　　import com.oasis.crm.model.biz.user.User;　　import com.oasis.crm.service.biz.order.AcceptedWorkOrderService;　　import org.springframework.beans.factory.annotation.Autowired;　　import org.springframework.web.bind.annotation.RequestMapping;　　import org.springframework.web.socket.CloseStatus;　　import org.springframework.web.socket.TextMessage;　　import org.springframework.web.socket.WebSocketSession;　　import org.springframework.web.socket.handler.TextWebSocketHandler;　　import java.util.Timer;　　import java.util.TimerTask;　　/**　　* 推送即将要处理完成的受理单给处理人　　*/　　@RequestMapping("/websocket")　　public class WebsocketEndPoint extends TextWebSocketHandler {　　@Autowired　　private AcceptedWorkOrderService acceptedWorkOrderService;　　@Autowired　　private UserDao userDao;　　private Timer timer;　　@Override　　protected void handleTextMessage(WebSocketSession session,　　TextMessage message) throws Exception {　　if(!session.isOpen()){　　timer.cancel();　　return;　　}　　super.handleTextMessage(session, message);　　session.sendMessage(message);　　}　　@Override　　public void afterConnectionEstablished(WebSocketSession session) throws Exception {　　String loginUserName = session.getPrincipal().getName();　　User user = userDao.findUserByLoginName(loginUserName);　　timer = new Timer(true);　　long delay = 0;　　OrderTimeTask orderTimeTask = new OrderTimeTask(user,session);　　timer.schedule(orderTimeTask,delay, 60000);// 设定指定的时间time,此处为1分钟　　}　　class OrderTimeTask extends TimerTask{　　private User user;　　private WebSocketSession session;　　public OrderTimeTask(User user,WebSocketSession session){　　this.user = user;　　this.session = session;　　}　　@Override　　public void run() {　　try {　　String reminder = acceptedWorkOrderService.getLastReminderOrder(user.getId());　　TextMessage textMessage = new TextMessage(reminder);　　handleMessage(session,textMessage);　　} catch (Exception e){　　e.printStackTrace();　　}　　}　　}　　@Override　　public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {　　System.out.println("Connection Closed！");　　}　　}　　package com.oasis.crm.controller.websocket;　　import org.springframework.http.server.ServerHttpRequest;　　import org.springframework.http.server.ServerHttpResponse;　　import org.springframework.web.socket.WebSocketHandler;　　import org.springframework.web.socket成都软件开发公司http://www.yingtaow.com?server.support.HttpSessionHandshakeInterceptor;　　import java.util.Map;　　public class HandshakeInterceptor extends HttpSessionHandshakeInterceptor {　　@Override　　public boolean beforeHandshake(ServerHttpRequest request,　　ServerHttpResponse response, WebSocketHandler wsHandler,　　Map<String, Object> attributes) throws Exception {　　return super.beforeHandshake(request, response, wsHandler, attributes);　　}　　@Override　　public void afterHandshake(ServerHttpRequest request,　　ServerHttpResponse response, WebSocketHandler wsHandler,　　Exception ex) {　　super.afterHandshake(request, response, wsHandler, ex);　　}　　}　　================　　或者前台拉定时取消息　　setInterval(()=> {　　this.getReminders();　　}, 300000);　　getReminders(){　　$.getJSON(Remote.acceptedWorkOrder.reminderOrders,packVo=>{　　this.setState({　　wsMessage:packVo.vo　　});　　});　　if("您有如下工单需要及时处理："!= this.state.wsMessage&&""!=this.state.wsMessage){　　document.getElementById("wsMsg").style.display = "block";　　}else{　　document.getElementById("wsMsg").style.display = "none";　　}　　}

WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。Cocos2d-x引擎集成libwebsockets，并在libwebsockets的客户端API基础上封装了一层易用的接口，使得引擎在C++, JS, Lua层都能方便的使用WebSocket来进行游戏网络通讯。引擎支持最新的WebSocket Version 13。在C++中使用详细代码可参考引擎目录下的/samples/Cpp/TestCpp/Classes/ExtensionsTest/NetworkTest/WebSocketTest.cpp文件。头文件中的准备工作首先需要include WebSocket的头文件。#include "network/WebSocket.h"cocos2d::network::WebSocket::Delegate定义了使用WebScocket需要监听的回调通知接口。使用WebSocket的类，需要public继承这个Delegate。class WebSocketTestLayer : public cocos2d::Layer, public cocos2d::network::WebSocket::Delegate并Override下面的4个接口：virtual void onOpen(cocos2d::network::WebSocket* ws);virtual void onMessage(cocos2d::network::WebSocket* ws, const cocos2d::network::WebSocket::Data& data);virtual void onClose(cocos2d::network::WebSocket* ws);virtual void onError(cocos2d::network::WebSocket* ws, const cocos2d::network::WebSocket::ErrorCode& error);后面我们再详细介绍每个回调接口的含义。新建WebSocket并初始化WebSocket.org 提供了一个专门用来测试WebSocket的服务器"ws://echo.websocket.org"。 测试代码以链接这个服务器为例，展示如何在Cocos2d-x中使用WebSocket。新建一个WebSocket：cocos2d::network::WebSocket* _wsiSendText = new network::WebSocket();init第一个参数是delegate，设置为this，第二个参数是服务器地址。 URL中的"ws://"标识是WebSocket协议，加密的WebSocket为"wss://"._wsiSendText->init(*this, "ws://echo.websocket.org")WebSocket消息监听在调用send发送消息之前，先来看下4个消息回调。onOpeninit会触发WebSocket链接服务器，如果成功，WebSocket就会调用onOpen，告诉调用者，客户端到服务器的通讯链路已经成功建立，可以收发消息了。void WebSocketTestLayer::onOpen(network::WebSocket* ws){if (ws == _wsiSendText){_sendTextStatus->setString("Send Text WS was opened.");}}onMessagenetwork::WebSocket::Data对象存储客户端接收到的数据， isBinary属性用来判断数据是二进制还是文本，len说明数据长度，bytes指向数据。void WebSocketTestLayer::onMessage(network::WebSocket* ws, const network::WebSocket::Data& data){if (!data.isBinary){_sendTextTimes++;char times[100] = {0};sprintf(times, "%d", _sendTextTimes);std::string textStr = std::string("response text msg: ")+data.bytes+", "+times;log("%s", textStr.c_str());_sendTextStatus->setString(textStr.c_str());}}onClose不管是服务器主动还是被动关闭了WebSocket，客户端将收到这个请求后，需要释放WebSocket内存，并养成良好的习惯：置空指针。void WebSocketTestLayer::onClose(network::WebSocket* ws){if (ws == _wsiSendText){_wsiSendText = NULL;}CC_SAFE_DELETE(ws);}onError客户端发送的请求，如果发生错误，就会收到onError消息，游戏针对不同的错误码，做出相应的处理。void WebSocketTestLayer::onError(network::WebSocket* ws, const network::WebSocket::ErrorCode& error){log("Error was fired, error code: %d", error);if (ws == _wsiSendText){char buf[100] = {0};sprintf(buf, "an error was fired, code: %d", error);_sendTextStatus->setString(buf);}}send消息到服务器在init之后，我们就可以调用send接口，往服务器发送数据请求。send有文本和二进制两中模式。发送文本_wsiSendText->send("Hello WebSocket, I"m a text message.");发送二进制数据(多了一个len参数)_wsiSendBinary->send((unsigned char*)buf, sizeof(buf));主动关闭WebSocket这是让整个流程变得完整的关键步骤, 当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接。close会触发onClose消息，而后onClose里面，我们释放内存。_wsiSendText->close();在Lua中使用详细代码可参考引擎目录下的/samples/Lua/TestLua/Resources/luaScript/ExtensionTest/WebProxyTest.lua文件。创建WebSocket对象脚本接口相对C++要简单很多，没有头文件，创建WebSocket对象使用下面的一行代码搞定。 参数是服务器地址。wsSendText = WebSocket:create("ws://echo.websocket.org")定义并注册消息回调函数回调函数是普通的Lua function，4个消息回调和c++的用途一致，参考上面的说明。local function wsSendTextOpen(strData)sendTextStatus:setString("Send Text WS was opened.")endlocal function wsSendTextMessage(strData)receiveTextTimes= receiveTextTimes + 1local strInfo= "response text msg: "..strData..", "..receiveTextTimessendTextStatus:setString(strInfo)endlocal function wsSendTextClose(strData)print("_wsiSendText websocket instance closed.")sendTextStatus = nilwsSendText = nilendlocal function wsSendTextError(strData)print("sendText Error was fired")endLua的消息注册不同于C++的继承 & Override，有单独的接口registerScriptHandler。 registerScriptHandler第一个参数是回调函数名，第二个参数是回调类型。 每一个WebSocket实例都需要绑定一次。if nil ~= wsSendText thenwsSendText:registerScriptHandler(wsSendTextOpen,cc.WEBSOCKET_OPEN)wsSendText:registerScriptHandler(wsSendTextMessage,cc.WEBSOCKET_MESSAGE)wsSendText:registerScriptHandler(wsSendTextClose,cc.WEBSOCKET_CLOSE)wsSendText:registerScriptHandler(wsSendTextError,cc.WEBSOCKET_ERROR)endsend消息Lua中发送不区分文本或二进制模式，均使用下面的接口。wsSendText:sendString("Hello WebSocket中文, I"m a text message.")主动关闭WebSocket当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接，以释放服务器和客户端的资源。close会触发cc.WEBSOCKET_CLOSE消息。wsSendText:close()在JSB中使用详细代码可参考引擎目录下的/samples/Javascript/Shared/tests/ExtensionsTest/NetworkTest/WebSocketTest.js文件。创建WebSocket对象脚本接口相对C++要简单很多，没有头文件，创建WebSocket对象使用下面的一行代码搞定。 参数是服务器地址。this._wsiSendText = new WebSocket("ws://echo.websocket.org");设置消息回调函数JSB中的回调函数是WebSocket实例的属性，使用匿名函数直接赋值给对应属性。可以看出JS语言的特性，让绑定回调函数更加优美。四个回调的含义，参考上面c++的描述。this._wsiSendText.onopen = function(evt) {self._sendTextStatus.setString("Send Text WS was opened.");};this._wsiSendText.onmessage = function(evt) {self._sendTextTimes++;var textStr = "response text msg: "+evt.data+", "+self._sendTextTimes;cc.log(textStr);self._sendTextStatus.setString(textStr);};this._wsiSendText.onerror = function(evt) {cc.log("sendText Error was fired");};this._wsiSendText.onclose = function(evt) {cc.log("_wsiSendText websocket instance closed.");self._wsiSendText = null;};send消息发送文本，无需转换，代码如下：this._wsiSendText.send("Hello WebSocket中文, I"m a text message.");发送二进制，测试代码中，使用_stringConvertToArray函数来转换string为二进制数据，模拟二进制的发送。 new Uint16Array创建一个16位无符号整数值的类型化数组，内容将初始化为0。然后，循环读取字符串的每一个字符的Unicode编码，并存入Uint16Array，最终得到一个二进制对象。_stringConvertToArray:function (strData) {if (!strData)returnnull;var arrData = new Uint16Array(strData.length);for (var i = 0; i < strData.length; i++) {arrData[i] = strData.charCodeAt(i);}return arrData;},send二进制接口和send文本没有区别，区别在于传入的对象，JS内部自己知道对象是文本还是二进制数据，然后做不同的处理。var buf = "Hello WebSocket中文, I"m a binary message.";var binary = this._stringConvertToArray(buf);this._wsiSendBinary.send(binary.buffer);主动关闭WebSocket当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接，以释放服务器和客户端的资源。close会触发onclose消息。onExit: function() {if (this._wsiSendText)this._wsiSendText.close();}

WebSocket protocol 是HTML5一种新的协议(protocol)。它是实现了浏览器与服务器全双工通信(full-duplex)。现在，很多网站为了实现即时通讯(real-time)，所用的技术都是轮询(polling)。轮询是在特定的的时间间隔(time interval)（如每1秒），由浏览器对服务器发出HTTP request，然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request d的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求(request)，然而HTTP request 的header是非常长的，里面包含的数据可能只是一个很小的值，这样会占用很多的带宽。而最比较新的技术去做轮询的效果是Comet – 用了AJAX。但这种技术虽然可达到全双工通信，但依然需要发出请求(reuqest)。在 WebSocket API，浏览器和服务器只需要要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。在此WebSocket 协议中，为我们实现即使服务带来了两大好处：1. Header互相沟通的Header是很小的-大概只有 2 Bytes2. Server Push服务器可以主动传送数据给客户端下面实现一个简单PUSH例子如下：服务端代码：public class InitServlet extends HttpServlet {/*** */private static final long serialVersionUID = 1L;private static List<MessageInbound> socketList;public void init(ServletConfig config) throws ServletException {InitServlet.socketList = new ArrayList<MessageInbound>();super.init(config);System.out.println("Server start============");}public static List<MessageInbound> getSocketList() {return InitServlet.socketList;}}public class TestWebSocketServlet extends WebSocketServlet{private static final Logger log = Logger.getLogger(TestWebSocketServlet.class);/*** */private static final long serialVersionUID = 1L;//存储链接的容器private static List<WebSocketMessageInbound> connsList = new ArrayList<WebSocketMessageInbound>();@Overrideprotected StreamInbound createWebSocketInbound(String subProtocol,HttpServletRequest request) {// TODO Auto-generated method stubreturn new WebSocketMessageInbound();}public class WebSocketMessageInbound extends MessageInbound{@Overrideprotected void onClose(int status) {// InitServlet.getSocketList().remove(this); super.onClose(status); log.debug("onClose");InitServlet.getSocketList().remove(this);}@Overrideprotected void onOpen(WsOutbound outbound) {log.debug("onOpen");super.onOpen(outbound);InitServlet.getSocketList().add(this);} @Overrideprotected void onBinaryMessage(ByteBuffer message) throws IOException {// TODO Auto-generated method stublog.debug("onBinaryMessage");}@Overrideprotected void onTextMessage(CharBuffer message) throws IOException {// TODO Auto-generated method stublog.debug("onTextMessage="+message);// this.getWsOutbound().writeTextMessage(CharBuffer.wrap("===="));// this.getWsOutbound().writeTextMessage(message);//发送给所有链接的for (MessageInbound messageInbound : InitServlet.getSocketList()) {CharBuffer buffer = CharBuffer.wrap(message);WsOutbound outbound = messageInbound.getWsOutbound();outbound.writeTextMessage(buffer);outbound.flush();} }}}web.xml配置<!-- WebSocket --><servlet><servlet-name>initServlet</servlet-name><servlet-class>com.demo.websocket.InitServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet><servlet-name>websocket</servlet-name><servlet-class>com.demo.websocket.TestWebSocketServlet</servlet-class></servlet><servlet-mapping><servlet-name>websocket</servlet-name><url-pattern>/websocket</url-pattern></servlet-mapping>前台代码：<html><head><title>WebSoket Demo</title><script type="text/javascript">//验证浏览器是否支持WebSocket协议if (!window.WebSocket) {alert("WebSocket not supported by this browser!");}var ws;function display() {//var valueLabel = document.getElementById("valueLabel");//valueLabel.innerHTML = "";ws=new WebSocket("ws://localhost:8082/springmvc/websocket");//监听消息ws.onmessage = function(event) {//valueLabel.innerHTML+ = event.data;log(event.data);};// 打开WebSocketws.onclose = function(event) {//WebSocket Status:: Socket Closed};// 打开WebSocketws.onopen = function(event) {//WebSocket Status:: Socket Open//// 发送一个初始化消息ws.send("Hello, Server!");};ws.onerror =function(event){//WebSocket Status:: Error was reported};}var log = function(s) {if (document.readyState !== "complete") {log.buffer.push(s);} else {document.getElementById("contentId").innerHTML += (s + " ");} }function sendMsg(){var msg=document.getElementById("messageId");//alert(msg.value);ws.send(msg.value);}</script></head><body onload="display();"><div id="valueLabel"></div><textarea rows="20" cols="30" id="contentId"></textarea><br/><input name="message" id="messageId"/><button id="sendButton" onClick="javascript:sendMsg()" >Send</button></body> < /html>

　　WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。　　Cocos2d-x引擎集成libwebsockets，并在libwebsockets的客户端API基础上封装了一层易用的接口，使得引擎在C++, JS, Lua层都能方便的使用WebSocket来进行游戏网络通讯。　　引擎支持最新的WebSocket Version 13。　　在C++中使用　　详细代码可参考引擎目录下的/samples/Cpp/TestCpp/Classes/ExtensionsTest/NetworkTest/WebSocketTest.cpp文件。　　头文件中的准备工作　　首先需要include WebSocket的头文件。　　#include "network/WebSocket.h"　　cocos2d::network::WebSocket::Delegate定义了使用WebScocket需要监听的回调通知接口。使用WebSocket的类，需要public继承这个Delegate。　　class WebSocketTestLayer : public cocos2d::Layer, public cocos2d::network::WebSocket::Delegate　　并Override下面的4个接口：　　virtual void onOpen(cocos2d::network::WebSocket* ws);　　virtual void onMessage(cocos2d::network::WebSocket* ws, const cocos2d::network::WebSocket::Data& data);　　virtual void onClose(cocos2d::network::WebSocket* ws);　　virtual void onError(cocos2d::network::WebSocket* ws, const cocos2d::network::WebSocket::ErrorCode& error);　　后面我们再详细介绍每个回调接口的含义。　　新建WebSocket并初始化　　WebSocket.org 提供了一个专门用来测试WebSocket的服务器"ws://echo.websocket.org"。 测试代码以链接这个服务器为例，展示如何在Cocos2d-x中使用WebSocket。　　新建一个WebSocket：　　cocos2d::network::WebSocket* _wsiSendText = new network::WebSocket();　　init第一个参数是delegate，设置为this，第二个参数是服务器地址。 URL中的"ws://"标识是WebSocket协议，加密的WebSocket为"wss://".　　_wsiSendText->init(*this, "ws://echo.websocket.org")　　WebSocket消息监听　　在调用send发送消息之前，先来看下4个消息回调。　　onOpen　　init会触发WebSocket链接服务器，如果成功，WebSocket就会调用onOpen，告诉调用者，客户端到服务器的通讯链路已经成功建立，可以收发消息了。　　void WebSocketTestLayer::onOpen(network::WebSocket* ws)　　{　　if (ws == _wsiSendText)　　{　　_sendTextStatus->setString("Send Text WS was opened.");　　}　　}　　onMessage　　network::WebSocket::Data对象存储客户端接收到的数据， isBinary属性用来判断数据是二进制还是文本，len说明数据长度，bytes指向数据。　　void WebSocketTestLayer::onMessage(network::WebSocket* ws, const network::WebSocket::Data& data)　　{　　if (!data.isBinary)　　{　　_sendTextTimes++;　　char times[100] = {0};　　sprintf(times, "%d", _sendTextTimes);　　std::string textStr = std::string("response text msg: ")+data.bytes+", "+times;　　log("%s", textStr.c_str());　　_sendTextStatus->setString(textStr.c_str());　　}　　}　　onClose　　不管是服务器主动还是被动关闭了WebSocket，客户端将收到这个请求后，需要释放WebSocket内存，并养成良好的习惯：置空指针。　　void WebSocketTestLayer::onClose(network::WebSocket* ws)　　{　　if (ws == _wsiSendText)　　{　　_wsiSendText = NULL;　　}　　CC_SAFE_DELETE(ws);　　}　　onError　　客户端发送的请求，如果发生错误，就会收到onError消息，游戏针对不同的错误码，做出相应的处理。　　void WebSocketTestLayer::onError(network::WebSocket* ws, const network::WebSocket::ErrorCode& error)　　{　　log("Error was fired, error code: %d", error);　　if (ws == _wsiSendText)　　{　　char buf[100] = {0};　　sprintf(buf, "an error was fired, code: %d", error);　　_sendTextStatus->setString(buf);　　}　　}　　send消息到服务器　　在init之后，我们就可以调用send接口，往服务器发送数据请求。send有文本和二进制两中模式。　　发送文本　　_wsiSendText->send("Hello WebSocket, I"m a text message.");　　发送二进制数据(多了一个len参数)　　_wsiSendBinary->send((unsigned char*)buf, sizeof(buf));　　主动关闭WebSocket　　这是让整个流程变得完整的关键步骤, 当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接。close会触发onClose消息，而后onClose里面，我们释放内存。　　_wsiSendText->close();　　在Lua中使用　　详细代码可参考引擎目录下的/samples/Lua/TestLua/Resources/luaScript/ExtensionTest/WebProxyTest.lua文件。　　创建WebSocket对象　　脚本接口相对C++要简单很多，没有头文件，创建WebSocket对象使用下面的一行代码搞定。 参数是服务器地址。　　wsSendText = WebSocket:create("ws://echo.websocket.org")　　定义并注册消息回调函数　　回调函数是普通的Lua function，4个消息回调和c++的用途一致，参考上面的说明。　　local function wsSendTextOpen(strData)　　sendTextStatus:setString("Send Text WS was opened.")　　end　　local function wsSendTextMessage(strData)　　receiveTextTimes= receiveTextTimes + 1　　local strInfo= "response text msg: "..strData..", "..receiveTextTimes　　sendTextStatus:setString(strInfo)　　end　　local function wsSendTextClose(strData)　　print("_wsiSendText websocket instance closed.")　　sendTextStatus = nil　　wsSendText = nil　　end　　local function wsSendTextError(strData)　　print("sendText Error was fired")　　end　　Lua的消息注册不同于C++的继承 & Override，有单独的接口registerScriptHandler。 registerScriptHandler第一个参数是回调函数名，第二个参数是回调类型。 每一个WebSocket实例都需要绑定一次。　　if nil ~= wsSendText then　　wsSendText:registerScriptHandler(wsSendTextOpen,cc.WEBSOCKET_OPEN)　　wsSendText:registerScriptHandler(wsSendTextMessage,cc.WEBSOCKET_MESSAGE)　　wsSendText:registerScriptHandler(wsSendTextClose,cc.WEBSOCKET_CLOSE)　　wsSendText:registerScriptHandler(wsSendTextError,cc.WEBSOCKET_ERROR)　　end　　send消息　　Lua中发送不区分文本或二进制模式，均使用下面的接口。　　wsSendText:sendString("Hello WebSocket中文, I"m a text message.")　　主动关闭WebSocket　　当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接，以释放服务器和客户端的资源。close会触发cc.WEBSOCKET_CLOSE消息。　　wsSendText:close()　　在JSB中使用　　详细代码可参考引擎目录下的/samples/Javascript/Shared/tests/ExtensionsTest/NetworkTest/WebSocketTest.js文件。　　创建WebSocket对象　　脚本接口相对C++要简单很多，没有头文件，创建WebSocket对象使用下面的一行代码搞定。 参数是服务器地址。　　this._wsiSendText = new WebSocket("ws://echo.websocket.org");　　设置消息回调函数　　JSB中的回调函数是WebSocket实例的属性，使用匿名函数直接赋值给对应属性。可以看出JS语言的特性，让绑定回调函数更加优美。四个回调的含义，参考上面c++的描述。　　this._wsiSendText.onopen = function(evt) {　　self._sendTextStatus.setString("Send Text WS was opened.");　　};　　this._wsiSendText.onmessage = function(evt) {　　self._sendTextTimes++;　　var textStr = "response text msg: "+evt.data+", "+self._sendTextTimes;　　cc.log(textStr);　　self._sendTextStatus.setString(textStr);　　};　　this._wsiSendText.onerror = function(evt) {　　cc.log("sendText Error was fired");　　};　　this._wsiSendText.onclose = function(evt) {　　cc.log("_wsiSendText websocket instance closed.");　　self._wsiSendText = null;　　};　　send消息　　发送文本，无需转换，代码如下：　　this._wsiSendText.send("Hello WebSocket中文, I"m a text message.");　　发送二进制，测试代码中，使用_stringConvertToArray函数来转换string为二进制数据，模拟二进制的发送。 new Uint16Array创建一个16位无符号整数值的类型化数组，内容将初始化为0。然后，循环读取字符串的每一个字符的Unicode编码，并存入Uint16Array，最终得到一个二进制对象。　　_stringConvertToArray:function (strData) {　　if (!strData)　　returnnull;　　var arrData = new Uint16Array(strData.length);　　for (var i = 0; i < strData.length; i++) {　　arrData[i] = strData.charCodeAt(i);　　}　　return arrData;　　},　　send二进制接口和send文本没有区别，区别在于传入的对象，JS内部自己知道对象是文本还是二进制数据，然后做不同的处理。　　var buf = "Hello WebSocket中文, I"m a binary message.";　　var binary = this._stringConvertToArray(buf);　　this._wsiSendBinary.send(binary.buffer);　　主动关闭WebSocket　　当某个WebSocket的通讯不再使用的时候，我们必须手动关闭这个WebSocket与服务器的连接，以释放服务器和客户端的资源。close会触发onclose消息。　　onExit: function() {　　if (this._wsiSendText)　　this._wsiSendText.close();　　}

FTP 有两种连接方式，一种是主动连接，另一种是被动连接。你修改一下 FTP 软件的设置，采用另一种连接方式试试。

你用的是虚拟主机吧；一台服务器同时可以放几十个网站；错误 = #10054 一般来说就是服务器用户过多，服务器拒绝连接

分类: 电脑/网络 >> 互联网 问题描述: 我用的是FlashFXP 老提示这个 WinSock 2.0 [右] 正在连接到 211.144.32.200 -> IP=211.144.32.200 PORT=21[右] 正在连接到 211.144.32.200 [右] 220 Serv-U FTP Server v5.2 for WinSock ready... [右] USER pdu2008 [右] 331 User name okay, need password. [右] PASS (隐藏) [右] 230 User logged in, proceed. [右] SYST [右] 215 UNIX Type: L8 [右] FEAT [右] 211-Extension supported [右] CLNT [右] MDTM [右] MDTM YYYYMMDDHHMMSS[+-TZ];filename [右] SIZE [右] SITE PSWD;EXEC;SET;INDEX;ZONE;CHMOD;MSG [右] REST STREAM [右] XCRC filename;start;end [右] MODE Z [右] 211 End [右] CLNT FlashFXP 3.0.1003 [右] 200 Noted. [右] PWD [右] 257 "/d:" is current directory. [右] TYPE A [右] 200 Type set to A. [右] PASV [右] 227 Entering Passive Mode (211,144,32,200,13,223) [右] 正打开数据连接 IP: 211.144.32.200 端口: 3551 [右] 数据 Socket 错误: 连接失败 [右] 列表错误 [右] PASV [右] 227 Entering Passive Mode (211,144,32,200,13,224) [右] 正打开数据连接 IP: 211.144.32.200 端口: 3552 [右] 数据 Socket 错误: 连接失败 [右] 列表错误 [右] NOOP [右] 200 Command okay. 而且我改完被动那个好象也没什么用啊，还是什么反应动没有，只不过不提示数据Socket连接失败了 解析: 用的是SERVER-U架设的这是登陆保护 过1-2分钟再登陆就好