socket

大哥那些API函数有时候是不管用的，你直接用线程的方法解决不好么？ Thead.sleep(60000)

TCP连接断开的时候调用closesocket函数，已经讨论过有优雅的断开和强制断开，那么如何设置断开连接的方式呢？是通过设置socket描述符一个linger结构体属性。linger结构体数据结构如下：struct linger{ int l_onoff; int l_linger;};有三种组合方式：第一种 l_onoff = 0; l_linger忽略 这种方式下，就是在closesocket的时候立刻返回，底层会将未发送完的数据发送完成后再释放资源，也就是优雅的退出。第二种 l_onoff非零 l_linger = 0; 这种方式下，在调用closesocket的时候同样会立刻返回，但不会发送未发送完成的数据，而是通过一个REST包强制的关闭socket描述符，也就是强制的退出。第三种 l_onoff非零 l_linger > 0 这种方式下，在调用closesocket的时候不会立刻返回，内核会延迟一段时间，这个时间就由l_linger得值来决定。如果超时时间到达之前，发送完未发送的数据(包括FIN包)并得到另一端的确认，closesocket会返回正确，socket描述符优雅性退出。否则，closesocket会直接返回错误值，未发送数据丢失，socket描述符被强制性退出。需要注意的时，如果socket描述符被设置为非堵塞型，则closesocket会直接返回值。 关于TCP的退出暂时了解这些，遇到问题再具体分析解决。

第一个请求（注意，上面图片路径应该为/socket.io/?EIO=3&transport=polling 少了个问号==!）第二个请求注意，上面图片路径应该为/socket.io/?EIO=3&transport=polling 少了个问号==!注意第二个请求中的${sid},这个是在第一个请求里面获取的，所有需要在第一个请求里面增加一个后置处理器-->正则表达式提取器。现在我到chrome里面查看第3个请求的详细信息，我们可以发现，第三个请求的URL变成了ws,参数transport也变成了websocket。并且多了一个frames栏目。Frames如下图所示：现在我们新建一个Websocket sampler来模拟socket链接。并发送2probe给服务器：添加一个观察结果树，运行就可以看到请求的结果，相应数据为3probe后面我们继续模拟socket.io的后续链接，也就是Frams里面的绿色部分，而白色部分就是服务器的响应。注意，最后要使用循环控制器间隔发送2给服务器保持连接。我的整个流程如下（上面下载的jmeter的example文件夹中的room-chat-test-010.jxm）：

刚才看错了MSDN上的解释是这样的CSocket::Create Call the Create member function after constructing a socket object to create the Windows socket and attach it.BOOL Create( UINT nSocketPort = 0, int nSocketType = SOCK_STREAM, LPCTSTR lpszSocketAddress = NULL );ParametersnSocketPortA particular port to be used with the socket, or 0 if you want MFC to select a port.nSocketTypeSOCK_STREAM or SOCK_DGRAM.lpszSocketAddressA pointer to a string containing the network address of the connected socket, a dotted number such as "128.56.22.8". Return ValueNonzero if the function is successful; otherwise 0, and a specific error code can be retrieved by calling GetLastError.RemarksCreate then calls Bind to bind the socket to the specified address. The following socket types are supported: SOCK_STREAM Provides sequenced, reliable, two-way, connection-based byte streams. Uses Transmission Control Protocol (TCP) for the Internet address family.SOCK_DGRAM Supports datagrams, which are connectionless, unreliable buffers of a fixed (typically small) maximum length. Uses User Datagram Protocol (UDP) for the Internet address family. To use this option, you must not use the socket with a CArchive object. Note The Accept member function takes a reference to a new, empty CSocket object as its parameter. You must construct this object before you call Accept. Keep in mind that if this socket object goes out of scope, the connection closes. Do not call Create for this new socket object.----------------------sendtoThe sendto function sends data to a specific destination.int sendto( SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen);Parameterss [in] Descriptor identifying a (possibly connected) socket. buf [in] Buffer containing the data to be transmitted. len [in] Length of the data in buf, in bytes. flags [in] Indicator specifying the way in which the call is made. to [in] Optional pointer to a sockaddr structure that contains the address of the target socket. tolen [in] Size of the address in to, in bytes. Return ValuesIf no error occurs, sendto returns the total number of bytes sent, which can be less than the number indicated by len. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code can be retrieved by calling WSAGetLastError.Error code Meaning WSANOTINITIALISED A successful WSAStartup call must occur before using this function. WSAENETDOWN The network subsystem has failed. WSAEACCES The requested address is a broadcast address, but the appropriate flag was not set. Call setsockopt with the SO_BROADCAST parameter to allow the use of the broadcast address. WSAEINVAL An unknown flag was specified, or MSG_OOB was specified for a socket with SO_OOBINLINE enabled. WSAEINTR A blocking Windows Sockets 1.1 call was canceled through WSACancelBlockingCall. WSAEINPROGRESS A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function. WSAEFAULT The buf or to parameters are not part of the user address space, or the tolen parameter is too small. WSAENETRESET The connection has been broken due to keep-alive activity detecting a failure while the operation was in progress. WSAENOBUFS No buffer space is available. WSAENOTCONN The socket is not connected (connection-oriented sockets only). WSAENOTSOCK The descriptor is not a socket. WSAEOPNOTSUPP MSG_OOB was specified, but the socket is not stream-style such as type SOCK_STREAM, OOB data is not supported in the communication domain associated with this socket, or the socket is unidirectional and supports only receive operations. WSAESHUTDOWN The socket has been shut down; it is not possible to sendto on a socket after shutdown has been invoked with how set to SD_SEND or SD_BOTH. WSAEWOULDBLOCK The socket is marked as nonblocking and the requested operation would block. WSAEMSGSIZE The socket is message oriented, and the message is larger than the maximum supported by the underlying transport. WSAEHOSTUNREACH The remote host cannot be reached from this host at this time. WSAECONNABORTED The virtual circuit was terminated due to a time-out or other failure. The application should close the socket as it is no longer usable. WSAECONNRESET The virtual circuit was reset by the remote side executing a hard or abortive close. For UPD sockets, the remote host was unable to deliver a previously sent UDP datagram and responded with a "Port Unreachable" ICMP packet. The application should close the socket as it is no longer usable. WSAEADDRNOTAVAIL The remote address is not a valid address, for example, ADDR_ANY. WSAEAFNOSUPPORT Addresses in the specified family cannot be used with this socket. WSAEDESTADDRREQ A destination address is required. WSAENETUNREACH The network cannot be reached from this host at this time. WSAEHOSTUNREACH A socket operation was attempted to an unreachable host. WSAETIMEDOUT The connection has been dropped, because of a network failure or because the system on the other end went down without notice. RemarksThe sendto function is used to write outgoing data on a socket. For message-oriented sockets, care must be taken not to exceed the maximum packet size of the underlying subnets, which can be obtained by using getsockopt to retrieve the value of socket option SO_MAX_MSG_SIZE. If the data is too long to pass atomically through the underlying protocol, the error WSAEMSGSIZE is returned and no data is transmitted.The to parameter can be any valid address in the socket"s address family, including a broadcast or any multicast address. To send to a broadcast address, an application must have used setsockopt with SO_BROADCAST enabled. Otherwise, sendto will fail with the error code WSAEACCES. For TCP/IP, an application can send to any multicast address (without becoming a group member).Note If a socket is opened, a setsockopt call is made, and then a sendto call is made, Windows Sockets performs an implicit bind function call.If the socket is unbound, unique values are assigned to the local association by the system, and the socket is then marked as bound. An application can use getsockname to determine the local socket name in this case.The successful completion of a sendto does not indicate that the data was successfully delivered.The sendto function is normally used on a connectionless socket to send a datagram to a specific peer socket identified by the to parameter. Even if the connectionless socket has been previously connected to a specific address, the to parameter overrides the destination address for that particular datagram only. On a connection-oriented socket, the to and tolen parameters are ignored, making sendto equivalent to send.这些你可以查看MSDN，上面都有很详细的解释的。

1.TCP流式套接字的编程步骤在使用之前须链接库函数：工程->设置->Link->输入ws2_32.lib，OK！SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创建套接字（socket）。SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//转换Unsigned short为网络字节序的格式addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);客户端代码如下：#include <Winsock2.h>#include <stdio.h>void main(){WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );加载套接字库if ( err != 0 ) {return;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup()( );return; }SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);创建套接字（socket）。SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));向服务器发出连接请求（connect）。char recvBuf[100];和服务器端进行通信（send/recv）。recv(sockClient,recvBuf,100,0);printf("%s ",recvBuf);send(sockClient,"This is lisi",strlen("This is lisi")+1,0);closesocket(sockClient);关闭套接字。WSACleanup()();//必须调用这个函数清除参数}

socket screw 英[u02c8su0254kit skru:] 美[u02c8sɑku026at skru] [释义] 承接螺丝，凹头螺钉; 来自百度翻译

应指阀门两端连接，通常是2“以下小口径阀， Socket是SW端-承插焊， Screw，螺纹连接（应是英标，欧洲市场）；北美以NPT螺纹为主

socket weld承插焊接; [英][u02c8su0254kit weld][美][u02c8sɑku026at wu025bld]

　　有的。WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。　　在浏览器中通过http仅能实现单向的通信，comet可以一定程度上模拟双向通信，但效率较低，并需要服务器有较好的支持; flash中的socket和xmlsocket可以实现真正的双向通信，通过 flex ajax bridge，可以在javascript中使用这两项功能. 可以预见，如果websocket一旦在浏览器中得到实现，将会替代上面两项技术，得到广泛的使用.面对这种状况，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽并达到实时通讯。

抓包分析了，wiresharke

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.") 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();

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 = nil endlocal function wsSendTextError(strData)print("sendText Error was fired") end Lua的消息注册不同于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) 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();

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.") 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();

访问错误的地址，导致返回的是已经移走的资源————————————————————

通过上面的原理分析可以知道，需要发送到后台的数据很简单，就是用户信息，聊天信息，和所在的空间信息，因为是一个简单的例子，所以bean就设计的比较简单了：[java] view plain copy public class UserChatCommand {private String name;private String chatContent;private String coordinationId; public String getName() {return name;}

你先看看socket的原理

知道websocket的原理就好解决：websocket是html5出的东西（协议），也就是说http协议没有变化，或者说没关系，但http是不支持持久连接的（长连接，循环连接的不算）首先http有1.1和1.0之说，也就是所谓的keep-alive，把多个http请求合并为一个，但是websocket其实是一个新协议，跟http协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是http协议上的一种补充另外html5是指的一系列新的api，或者说新规范，新技术。http协议本身只有1.0和1.1，而且跟html本身没有直接关系。。通俗来说，你可以用http协议传输非html数据，就是这样=。=再简单来说，层级不一样。

知道WebSocket的原理就好解决：WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）首先HTTP有1.1和1.0之说，也就是所谓的keep-alive，把多个HTTP请求合并为一个，但是Websocket其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=再简单来说，层级不一样。

知道WebSocket的原理就好解决：WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）首先HTTP有1.1和1.0之说，也就是所谓的keep-alive，把多个HTTP请求合并为一个，但是Websocket其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=再简单来说，层级不一样。

知道WebSocket的原理就好解决：WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）首先HTTP有1.1和1.0之说，也就是所谓的keep-alive，把多个HTTP请求合并为一个，但是Websocket其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=再简单来说，层级不一样。

启动php sever服务client新建一个websocket对象连接后端client发送数据给后端服务器接受数据后返回数据client接收到返回数据继续下一步我这边有个聊天室的demo就是这样做的，很简答

知道WebSocket的原理就好解决：WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）首先HTTP有1.1和1.0之说，也就是所谓的keep-alive，把多个HTTP请求合并为一个，但是Websocket其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=再简单来说，层级不一样。

、TCP连接手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在逗无差别地的网络之上。建立起一个TCP连接需要经过逗三次握手地：第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过逗四次握手地（过程就不细写了，就是服务器和客户端交互，最终确定断开）2、HTTP连接HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为逗一次连接地。1）在HTTP 1.0中，客户端的每次请求都要求建立一次单独的连接，在处理完本次请求后，就自动释放连接。2）在HTTP 1.1中则可以在一次连接中处理多个请求，并且多个请求可以重叠进行，不需要等待一个请求结束后再发送下一个请求。由于HTTP在每次请求结束后都会主动释放连接，因此HTTP连接是一种逗短连接地，要保持客户端程序的在线状态，需要不断地向服务器发起连接请求。通常的做法是即时不需要获得任何数据，客户端也保持每隔一段固定的时间向服务器发送一次逗保持连接地的请求，服务器在收到该请求后对客户端进行回复，表明知道客户端逗在线地。若服务器长时间无法收到客户端的请求，则认为客户端逗下线地，若客户端长时间无法收到服务器的回复，则认为网络已经断开。3、SOCKET原理3.1套接字（socket）概念套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。应用层通过传输层进行数据通信时，TCP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了套接字(Socket)接口。应用层可以和传输层通过Socket接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务

你可以把 WebSocket 看成是 HTTP 协议为了支持长连接所打的一个大补丁，它和 HTTP 有一些共性，是为了解决 HTTP 本身无法解决的某些问题而做出的一个改良设计。在以前 HTTP 协议中所谓的 keep-alive connection 是指在一次 TCP 连接中完成多个 HTTP 请求，但是对每个请求仍然要单独发 header；所谓的 polling 是指从客户端（一般就是浏览器）不断主动的向服务器发 HTTP 请求查询是否有新数据。这两种模式有一个共同的缺点，就是除了真正的数据部分外，服务器和客户端还要大量交换 HTTP header，信息交换效率很低。它们建立的“长连接”都是伪.长连接，只不过好处是不需要对现有的 HTTP server 和浏览器架构做修改就能实现。WebSocket 解决的第一个问题是，通过第一个 HTTP request 建立了 TCP 连接之后，之后的交换数据都不需要再发 HTTP request了，使得这个长连接变成了一个真.长连接。但是不需要发送 HTTP header就能交换数据显然和原有的 HTTP 协议是有区别的，所以它需要对服务器和客户端都进行升级才能实现。在此基础上 WebSocket 还是一个双通道的连接，在同一个 TCP 连接上既可以发也可以收信息。此外还有 multiplexing 功能，几个不同的 URI 可以复用同一个 WebSocket 连接。这些都是原来的 HTTP 不能做到的。另外说一点技术细节，因为看到有人提问 WebSocket 可能进入某种半死不活的状态。这实际上也是原有网络世界的一些缺陷性设计。上面所说的 WebSocket 真.长连接虽然解决了服务器和客户端两边的问题，但坑爹的是网络应用除了服务器和客户端之外，另一个巨大的存在是中间的网络链路。一个 HTTP/WebSocket 连接往往要经过无数的路由，防火墙。你以为你的数据是在一个“连接”中发送的，实际上它要跨越千山万水，经过无数次转发，过滤，才能最终抵达终点。在这过程中，中间节点的处理方法很可能会让你意想不到。比如说，这些坑爹的中间节点可能会认为一份连接在一段时间内没有数据发送就等于失效，它们会自作主张的切断这些连接。在这种情况下，不论服务器还是客户端都不会收到任何提示，它们只会一厢情愿的以为彼此间的红线还在，徒劳地一边又一边地发送抵达不了彼岸的信息。而计算机网络协议栈的实现中又会有一层套一层的缓存，除非填满这些缓存，你的程序根本不会发现任何错误。这样，本来一个美好的 WebSocket 长连接，就可能在毫不知情的情况下进入了半死不活状态。而解决方案，WebSocket 的设计者们也早已想过。就是让服务器和客户端能够发送 Ping/Pong Frame（RFC 6455 - The WebSocket Protocol）。这种 Frame 是一种特殊的数据包，它只包含一些元数据而不需要真正的 Data Payload，可以在不影响 Application 的情况下维持住中间网络的连接状态。

它的工作原理是Pub-Sub（发布和订阅）。它适用于发送者将数据（发布者）发送给抽象数量的收件人（订阅者），而无需指定他们是谁。根据定义，WebSocket是通过单个TCP连接提供全双工（双向通信）通信信道的计算机通信协议。此WebSocket API可在用户的浏览器和服务器之间进行双向通信。用户可以向服务器发送消息并接收事件驱动的响应，而无需轮询服务器。它可以让多个用户连接到同一个实时服务器，并通过API进行通信并立即获得响应。WebSockets允许用户和服务器之间的流连接，并允许即时信息交换。在聊天应用程序的示例中，通过套接字汇集消息，可以实时与一个或多个用户交换，具体取决于谁在服务器上“监听”（连接）。WebSockets不仅限于聊天／消息传递应用程序。它们适用于需要实时更新和即时信息交换的任何应用程序。一些示例包括但不限于：现场体育更新，股票行情，多人游戏，聊天应用，社交媒体等等。WebSockets还会考虑代理和防火墙等危险，使得任何连接都可以进行流式传输。它支持单个连接的上游和下游通信。它还减轻了服务器的负担，允许现有机器支持同时连接。

一、socket协议的简介 WebSocket是什么，有什么优点 WebSocket是一个持久化的协议，这是相对于http非持久化来说的。应用层协议 举个简单的例子，http1.0的生命周期是以request作为界定的，也就是一个request，一个response，对于http来说，本次client与server的会话到此结束；而在http1.1中，稍微有所改进，即添加了keep-alive，也就是在一个http连接中可以进行多个request请求和多个response接受操作。然而在实时通信中，并没有多大的作用，http只能由client发起请求，server才能返回信息，即server不能主动向client推送信息，无法满足实时通信的要求。而WebSocket可以进行持久化连接，即client只需进行一次握手，成功后即可持续进行数据通信，值得关注的是WebSocket实现client与server之间全双工通信，即server端有数据更新时可以主动推送给client端。 二、介绍client与server之间的socket连接原理 1、下面是一个演示client和server之间建立WebSocket连接时握手部分 2、client与server建立socket时握手的会话内容，即request与response a、client建立WebSocket时向服务器端请求的信息 GET /chat HTTP/1.1 　　Host: server.example.com 　　Upgrade: websocket //告诉服务器现在发送的是WebSocket协议 　　Connection: Upgrade 　　Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw== //是一个Base64 encode的值，这个是浏览器随机生成的，用于验证服务器端返回数据是否是WebSocket助理 　　Sec-WebSocket-Protocol: chat, superchat 　　Sec-WebSocket-Version: 13 　　Origin: http://example.com b、服务器获取到client请求的信息后，根据WebSocket协议对数据进行处理并返回，其中要对Sec-WebSocket-Key进行加密等操作 HTTP/1.1 101 Switching Protocols 　　Upgrade: websocket //依然是固定的，告诉客户端即将升级的是Websocket协议，而不是mozillasocket，lurnarsocket或者shitsocket 　　Connection: Upgrade 　　Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk= //这个则是经过服务器确认，并且加密过后的 Sec-WebSocket-Key,也就是client要求建立WebSocket验证的凭证 　　Sec-WebSocket-Protocol: chat 3、socket建立连接原理图： 三、PHP中建立websocket的过程讲解 SocketService.php: web.html:

写在最前面：由于现在游戏基本上采用全球大区的模式，全球玩家在同一个大区进行游戏，传统的单服模式已经不能够满足当前的服务需求，所以现在游戏服务器都在往微服务架构发展。当前我们游戏也是利用微服务架构来实现全球玩家同服游戏。 玩家每次断线（包括切换网络/超时断线）后应该会重新连接服务器，重连成功的话可以继续当前情景继续游戏，但是之前写的底层重连机制一直不能生效，导致每次玩家断线后重连都失败，要从账号登陆开始重新登陆，该文章写在已经定位了重连问题是由SLB引起后，提出的解决方案。 每次重连后，客户端向SLB发送建立连接，SLB都会重新分配一个网关节点，导致客户端连接到其他网关，重连失败。 会话保持的作用是什么？ 开启SLB会话保持功能后，SLB会记录客户端的IP地址，在一定时间内，自动将同一个IP的连接转发到上次连接的网关。 在网络不稳定的情况下，游戏容易心跳或者发包超时，开启会话保持，能解决大部分情况下的重连问题。 但是在切换网络的时候，手机网络从Wifi切换成4G，自身IP会变，这时候连接必定和服务器断开，需要重新建立连接。由于IP已经变化，SLB不能识别到是同一个客户端发出的请求，会将连接转发到其他网关节点。所以使用TCP连接的情况下，SLB开启会话保持并不能解决所有的重连问题。 另外某些时刻，手机频繁开启和断开WI-FI，有时候可能不会断开网络，这并不是因为4G切换WI-FI时网络没断开，从4G切换到Wi-Fi网络，因为IP变了，服务器不能识别到新的IP，连接肯定是断开的。这时候网络没断开，主要是因为现在智能手机会对4G和Wi-Fi网络做个权重判断，当Wi-Fi网络频繁打开关闭时，手机会判断Wi-Fi网络不稳定，所有流量都走4G。所以网络没断开是因为一直使用4G连接，才没有断开。想要验证，只需要切换Wi-Fi时，把4G网络关闭，这样流量就必定走Wi-Fi。 上面说过，四层的TCP协议主要是基于IP来实现会话保持。但是切换网络的时候客户端的IP会变。所以要解决切换网络时的重连问题，只有两个方法：1. 当客户端成功连接网关节点后，记录下网关节点的IP，下次重连后不经过SLB，直接向网关节点发送连接请求。2.使用 SLB的七层（HTTP）转发服务。 当客户端经过SLB将连接转发到网关时，二次握手验证成功后向客户端发送自己节点的IP，这样客户端下次连接的时候就能直接连接网关节点。但是这样会暴露网关的IP地址，为安全留下隐患。 如果不希望暴露网关的IP地址，就需要增加一层代理层，SLB将客户端请求转发到代理层，代理层再根据客户端带有的key，转发到正确的网关节点上。增加一层代理层，不仅会增加请求的响应时间，还会增加整体框架的复杂度。 阿里云的七层SLB会话保持服务，主要是基于cookie的会话保持。客户端在往服务器发送HTTP请求后，服务器会返回客户端一个Response，SLB会在这时候，将经过的Response插入或者重写cookie。客户端获取到这个cookie，下次请求时会带上cookie，SLB判断Request的Headers里面有cookie，就将连接转发到之前的网关节点。 HTTP是短链接，我们游戏是长连接，所以用HTTP肯定不合适。但是可以考虑基于HTTP的WebSocket。 什么是WebSocket？ WSS（Web Socket Secure）是WebSocket的加密版本。 SLB对WebSocket的支持 查看阿里云SLB文档对WS的支持，说明SLB是支持WS协议的，并且SLB对于WS无需配置，只需要选用HTTP监听时，就能够转发WS协议。说明WS协议在SLB这边看来就是一个HTTP，这样WS走的也是七层的转发服务。只要SLB能够正常识别WS握手协议里Request的cookie和正常识别服务器返回的Response并且往里面插入cookie，就可以利用会话保持解决重连问题。 Go语言实现WS服务器有两种方法，一种是利用golang.org/x/net下的websocket包，另外一种方法就是自己解读Websocket协议来实现，由于WS协议一样是基于TCP协议之上，完全可以通过监听TCP端口来实现。 客户端发送Request消息 服务器返回Response消息 其中服务器返回的Sec-WebSocket-Accept字段，主要是用于客户端需要验证服务器是否支持WS。RFC6455文档中规定，在WebSocket通信协议中服务端为了证实已经接收了握手，它需要把两部分的数据合并成一个响应。一部分信息来自客户端握手的Sec-WebSocket-Keyt头字段：Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==。对于这个字段，服务端必须得到这个值（头字段中经过base64编码的值减去前后的空格）并与GUID"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"组合成一个字符串，这个字符串对于不懂WebSocket协议的网络终端来说是不能使用的。这个组合经过SHA-1掩码，base64编码后在服务端的握手中返回。如果这个Sec-WebSocket-Accept计算错误浏览器会提示：Sec-WebSocket-Accept dismatch 如果返回成功，Websocket就会回调onopen事件 游戏服务器的使用的TCP协议，是在协议的包头使用4Byte来声明本协议长度，然后将协议一次性发送。但是在WS协议是通过Frame形式发送的，会将一条消息分为几个frame，按照先后顺序传输出去。这样做会有几个好处： websocket的协议格式： 参数说明如下： 阿里云的SLB开启HTTP监听后，会检查过往的Request和Response请求，收到服务器返回的Response后，会往Response插入一个Cookie 客户端收到服务器的Response后，可以在Header中查到有个“Set-Cookie”字段，里面是SLB插入的Cookie值 客户端断开连接后，下次发送请求需要往Headers插入Cookie字段 分别在阿里云的两台ECS实例上部署WS服务器，打开8000端口，开启一个SLB服务，SLB服务选择HTTP方式监听，并且打开会话保持功能，Cookie处理方式选择植入Cookie。Demo服务器没有做HTTP健康监听的处理，健康检查这块可以先关掉。 在两台ECS上启动WS服务器，然后本地运行客户端，分别测试两台服务器是否能正常连接，测试完毕后，测试SLB能否正常工作。服务器和SLB都正常的情况下，运行客户端，客户端会得到以下结果 收到的三次Cookie都相同，说明Cookie是有正常植入工作的，并且三次都被SLB正确抓取了。 收到的三次serverId也都是同样的值，说明三次都是同一个ECS上的服务器响应。 至此，验证成功。 Websocket+SLB会话保持能够解决超时重连和切换网络时重连的问题。 参考： 阿里云会话保持 解答Wi-Fi与4G网络切换的困惑 WebSocket的实现原理 阿里云SLB对WebSocket的支持 HTTP Headers和Cookie

疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列 【 博客园总入口 】 架构师成长+面试必备之 高并发基础书籍 【 Netty Zookeeper Redis 高并发实战 】 很多项目，都需要基于 Websocket 协议做在线客服、在线推送、在线聊天，虽然 Tomcat 内置支持 Websocket 协议，但是由于 Tomcat 的吞吐量、连接数都很低，作为测试是可以的。 在生产环境，一定需要使用高吞吐量、高连接数的 Netty 服务器进行替代 。 之所以 Netty 性能高，因为其使用的是 Reactor 反应器模式。关于反应器模式原理，请参见 《Netty Zookeeper Redis 高并发实战》 一书。 聊天过程gif 演示： 聊天示意图： Netty搭建的服务器基本上都是差不多的写法： 绑定主线程组和工作线程组，这部分对应架构图中的事件循环组。其原理，，请参见 《Netty Zookeeper Redis 高并发实战》 一书。 重点就是ChannelInitializer的配置，以异步的方式启动，最后是结束的时候关闭线程组。 下面是用websocket做聊天室的逻辑： 源码网址： Java 高并发研习社群 【 博客园 总入口 】 疯狂创客圈 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 面试必备 + 面试必备

在网速快速提升的时代，浏览器已经成为我们访问各种服务的入口，很难想象如果离开了浏览器，我们的网络世界应该如何运作。现在恨不得把操作系统都搬上浏览器。但是并不是所有的应用都需要浏览器来执行，比如服务器和服务器之间的通信，就需要使用到自建客户端来和服务器进行交互。 本文将会介绍使用netty客户端连接websocket的原理和具体实现。 在介绍netty客户端之前，我们先看一个简单的浏览器客户端连接websocket的例子： 这里使用了浏览器最通用的语言javascript，并使用了浏览器提供的websocket API进行操作，非常的简单。 那么用netty客户端实现websocket的连接是否和javascript使用一样呢？我们一起来 探索 。 先看看netty对websocket的支持类都有哪些，接着我们看下怎么具体去使用这些工具类。 和websocket server一样，client中最核心的类也是handshaker，这里叫做WebSocketClientHandshaker。这个类有什么作用呢？一起来看看。 这个类主要实现的就是client和server端之间的握手。 我们看一下它的最长参数的构造类： 参数中有websocket连接的URI，像是：”ws://flydean.com/mypath”。 有请求子协议的类型subprotocol，有自定义的HTTP headers：customHeaders，有最大的frame payload的长度：maxFramePayloadLength，有强制timeout关闭的时间，有使用HTTP协议进行升级的URI地址。 怎么创建handshaker呢？同样的，netty提供了一个WebSocketClientHandshakerFactory方法。 WebSocketClientHandshakerFactory提供了一个newHandshaker方法，可以方便的创建各种不同版本的handshaker: 可以看到，根据传入协议版本的不同，可以分为WebSocketClientHandshaker13、WebSocketClientHandshaker08、WebSocketClientHandshaker07、WebSocketClientHandshaker00这几种。 通常来说，对于webSocket协议，为了提升传输的性能和速度，降低网络带宽占用量，在使用过程中通常会带上额外的压缩扩展。为了处理这样的压缩扩展，netty同时提供了服务器端和客户端的支持。 对于服务器端来说对应的handler叫做WebSocketServerCompressionHandler，对于客户端来说对应的handler叫做WebSocketClientCompressionHandler。 通过将这两个handler加入对应pipline中，可以实现对websocket中压缩协议扩展的支持。 对于协议的扩展有两个级别分别是permessage-deflate和perframe-deflate，分别对应PerMessageDeflateClientExtensionHandshaker和DeflateFrameClientExtensionHandshaker。 至于具体怎么压缩的，这里就不详细进行讲解了， 感兴趣的小伙伴可以自行了解。 前面讲解了netty对websocket客户端的支持之后，本节将会讲解netty到底是如何使用这些工具进行消息处理的。 首先是按照正常的逻辑创建客户端的Bootstrap，并添加handler。这里的handler就是专门为websocket定制的client端handler。 除了上面提到的WebSocketClientCompressionHandler，就是自定义的handler了。 在自定义handler中，我们需要处理两件事情，一件事情就是在channel ready的时候创建handshaker。另外一件事情就是具体websocket消息的处理了。 首先使用WebSocketClientHandshakerFactory创建handler： 然后在channel active的时候使用handshaker进行握手连接： 然后在进行消息接收处理的时候还需要判断handshaker的状态是否完成，如果未完成则调用handshaker.finishHandshake方法进行手动完成： 当handshake完成之后，就可以进行正常的websocket消息读写操作了。 websocket的消息处理比较简单，将接收到的消息转换成为WebSocketFrame进行处理即可。 本文讲解了netty提供的websocket客户端的支持和具体的对接流程，大家可以再次基础上进行扩展，以实现自己的业务逻辑。 本文的例子可以参考：learn-netty4

双屏互动原理描述：现在多数双屏互动的实现方式主要是依靠浏览器的WebSocket即时通信技术，包括国外许多案例，在以前传统的网站为了实现这种技术基本都是轮询，在一个特定的时间内，由客户端向服务端发出请求，之后服务器返回到浏览器，这种传统的实现方法需要客户端不停的向服务端请求数据，而且其传输的数据可能是一个很小的值。在 WebSocket API中，浏览器和服务器只需要要做一个握手的动作，然后浏览器和服务器之间就形成了一条快速通道，两者之间就可以直接实时的互相传送数据。采用websocket技术的页面不同于普通页面，而是需要特殊的服务器环境支持。 服务器环境的搭建：目前支持WebSocket环境有很多方式，比如PHP、Java、.Net、Tomcat、Nodejs等，还有html5 的websocket方案，但是目前在我国浏览器使用情况上，IE用户还占有50%左右的市场份额，html5 的websocket只能支持IE10+和其他高端浏览器，在兼容性方面socket.io做的很好，所以对于前端工程师，我们优先选Nodejs和socket.io来搭建WebSocket服务器端。前期我们可以在自己电脑搭建与服务器一致的环境来测试，本地搭建的方法:1. 下载官方Node.js，安装可以一直下一步，我个人习惯都会自定义安装软件2. 安装Nodejs 的模块管理器npm（官网最新版Nodejs已集成，无需单独安装）3. 命令窗口模式安装 socket.io（npm install socket.io）（这里如果遇到安装不成功情况，注意考虑设置一下代理，设置方法：npm config set proxy=地址:端口号，运气实在不好的话从其他电脑复制同版本文件夹也一样）4. 最后查看安装的模块及版本：npm list

Socket，WebSocket，Http，Tcp等这些我们已经听的耳朵有茧了，但是用得时候还是复习一下吧。 大学学习网络基础的时候老师讲过，网络由下往上分为物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。通过初步的了解，我知道IP协议对应于网络层，TCP协议对应于传输层，而HTTP协议对应于应用层，三者从本质上来说没有可比性，socket则是对TCP/IP协议的封装和应用（程序员层面上）。也可以说，TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。关于TCP/IP和HTTP协议的关系，网络有一段比较容易理解的介绍： “我们在传输数据时，可以只使用（传输层）TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有很多，比如HTTP、FTP、TELNET等，也可以自己定义应用层协议。WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TCP/IP做传输层协议将它发到网络上。” 而我们平时说的最多的socket是什么呢，实际上socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。实际上，Socket跟TCP/IP协议没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以说，Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口，比如create、listen、connect、accept、send、read和write等等。网络有一段关于socket和TCP/IP协议关系的说法比较容易理解： “TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。这个就像操作系统会提供标准的编程接口，比如win32编程接口一样，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。” 关于TCP/IP协议的相关只是，用博大精深来讲我想也不为过，单单查一下网上关于此类只是的资料和书籍文献的数量就知道，这个我打算会买一些经典的书籍（比如《TCP/IP详解：卷一、卷二、卷三》）进行学习，今天就先总结一些基于基于TCP/IP协议的应用和编程接口的知识，也就是刚才说了很多的HTTP和Socket。 CSDN上有个比较形象的描述： HTTP是轿车，提供了封装或者显示数据的具体形式； Socket是发动机，提供了网络通信的能力。 实际上，传输层的TCP是基于网络层的IP协议的，而应用层的HTTP协议又是基于传输层的TCP协议的，而Socket本身不算是协议，就像上面所说，它只是提供了一个针对TCP或者UDP编程的接口。 下面是一些经常在笔试或者面试中碰到的重要的概念，特在此做摘抄和总结。一什么是TCP连接的三次握手第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）二利用Socket建立网络连接的步骤建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket，另一个运行于服务器端，称为ServerSocket。套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。1、服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。2、客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。3、连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。三HTTP链接的特点 HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。 HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。四、TCP和UDP的区别（考得最多。。快被考烂了我觉得）1、TCP是面向链接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上（实际上也很大程度上保证了）保证了连接的可靠性；而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重发，所以说UDP是无连接的、不可靠的一种数据传输协议。2、也正由于1所说的特点，使得UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。知道了TCP和UDP的区别，就不难理解为何采用TCP传输协议的MSN比采用UDP的QQ传输文件慢了，但并不能说QQ的通信是不安全的，因为程序员可以手动对UDP的数据收发进行验证，比如发送方对每个数据包进行编号然后由接收方进行验证啊什么的，即使是这样，UDP因为在底层协议的封装上没有采用类似TCP的“三次握手”而实现了TCP所无法达到的传输效率。 简单总结：HTTP协议：简单对象访问协议，对应于应用层 ，HTTP协议是基于TCP连接的。TCP协议： 对应于传输层。IP协议： 对应于网络层。TCP/IP是传输层协议，主要解决数据如何在网络中传输；而HTTP是应用层协议，主要解决如何包装数据。Socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。HTTP连接：HTTP连接就是所谓的短连接，即客户端向服务器端发送一次请求，服务器端响应后连接即会断掉；Socket连接：Socket连接就是所谓的长连接，理论上客户端和服务器端一旦建立起连接将不会主动断掉；但是由于各种环境因素可能会是连接断开，比如说：服务器端或客户端主机down了，网络故障，或者两者之间长时间没有数据传输，网络防火墙可能会断开该连接以释放网络资源。所以当一个Socket连接中没有数据的传输，那么为了维持连接需要发送心跳消息~~具体心跳消息格式是开发者自己定义的。WebSocket WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。 WebSocket通信协定于2011年被IETF定为标准 RFC 6455，WebSocketAPI被W3C定为标准。 在WebSocket API中，浏览器和服务器只需要要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。现在，很多网站为了实现推送技术，所用的技术都是轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP request，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而HTTP request的header是非常长的，里面包含的数据可能只是一个很小的值，这样会占用很多的带宽和服务器资源。 而比较新的技术去做轮询的效果是Comet，使用了AJAX。但这种技术虽然可达到双向通信，但依然需要发出请求，而且在Comet中，普遍采用了长链接，这也会大量消耗服务器带宽和资源。 面对这种状况，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽并达到实时通讯。握手协议在实现Websocket连线过程中，需要透过浏览器发出Websocket连线请求，然后服务器发出回应，这个过程通常称为“握手” (handshaking)。PS:后期的版本大多属于功能上的扩充，例如使用第7版的握手协议同样也适用于第8版的握手协议。浏览器请求GET / HTTP/1.1Upgrade: websocketConnection: UpgradeHost: example.comOrigin: nullSec-WebSocket-Key: sN9cRrP/n9NdMgdcy2VJFQ==Sec-WebSocket-Version: 13服务器回应HTTP/1.1 101 Switching ProtocolsUpgrade: websocketConnection: UpgradeSec-WebSocket-Accept: fFBooB7FAkLlXgRSz0BT3v4hq5s=Sec-WebSocket-Origin: nullSec-WebSocket-Location: ws://example.com/原理在请求中的“Sec-WebSocket-Key”是随机的，服务器端会用这些数据来构造出一个SHA-1的信息摘要。把“Sec-WebSocket-Key”加上一个魔幻字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”。使用 SHA-1 加密，之后进行 BASE-64编码，将结果做为“Sec-WebSocket-Accept”头的值，返回给客户端。客户端的Websocket对象一共绑定了四个事件：1、onopen：连接建立时触发；2、onmessage：收到服务端消息时触发；3、onerror：连接出错时触发；4、onclose：连接关闭时触发；有了这4个事件，我们就可以很容易很轻松的驾驭websocket，并且需要说明的是websocket支持二进制数据的传输，因此，它远不止聊天室应用这么简单。WebSocket API是下一代客户端-服务器的异步通信方法。该通信取代了使用ws或wss协议的单个的TCP套接字，可用于任意的客户端和服务器程序WebSocket API最伟大之处在于在任意时刻服务器和客户端可以相互推送信息。WebSocket并不限于以Ajax(或XHR)方式通信，Ajax技术需要客户端发起请求，而WebSocket服务器和客户端可以彼此相互推送信息；XHR受到域的限制，而WebSocket是允许跨域通信。

g因为http有同步和异步发送，我在刷新浏览器的时候，是可以捕获到浏览器刷新时间，向服务器发送请求，这时候是发送同步请求，如果服务端不响应，我不关闭浏览器，就是保证这个请求不中断，但是用websokcet发送不出去，因为浏览器刷新，请求中断了，

WebSocket的出现是基于Web应用的实时性需要而产生的。这种实时的Web应用大家应该不陌生，在生活中都应该用到过，比如新浪微博的评论、私信的通知，腾讯的WebQQ等。让我们来回顾下实时 Web 应用的窘境吧。在WebSocket出现之前，一般通过两种方式来实现Web实时用：轮询机制和流技术；其中轮询有不同的轮询，还有一种叫Comet的长轮询。轮询：这是最早的一种实现实时 Web 应用的方案。客户端以一定的时间间隔向服务端发出请求，以频繁请求的方式来保持客户端和服务器端的同步。这种同步方案的缺点是，当客户端以固定频率向服务 器发起请求的时候，服务器端的数据可能并没有更新，这样会带来很多无谓的网络传输，所以这是一种非常低效的实时方案。长轮询：是对定时轮询的改进和提高，目地是为了降低无效的网络传输。当服务器端没有数据更新的时候，连接会保持一段时间周期直到数据或状态改变或者 时间过期，通过这种机制来减少无效的客户端和服务器间的交互。当然，如果服务端的数据变更非常频繁的话，这种机制和定时轮询比较起来没有本质上的性能的提 高。流：常就是在客户端的页面使用一个隐藏的窗口向服务端发出一个长连接的请求。服务器端接到这个请求后作出回应并不断更新连接状态以保证客户端和服务 器端的连接不过期。通过这种机制可以将服务器端的信息源源不断地推向客户端。这种机制在用户体验上有一点问题，需要针对不同的浏览器设计不同的方案来改进 用户体验，同时这种机制在并发比较大的情况下，对服务器端的资源是一个极大的考验。上述方式其实并不是真正的实时技术，只是使用了一种技巧来实现的模拟实时。在每次客户端和服务器端交互的时候都是一次 HTTP 的请求和应答的过程，而每一次的 HTTP 请求和应答都带有完整的 HTTP 头信息，这就增加了每次传输的数据量。但这些方式最痛苦的是开发人员，因为不论客户端还是服务器端的实现都很复杂，为了模拟比较真实的实时效果，开发人员 往往需要构造两个HTTP连接来模拟客户端和服务器之间的双向通讯，一个连接用来处理客户端到服务器端的数据传输，一个连接用来处理服务器端到客户端的数 据传输，这不可避免地增加了编程实现的复杂度，也增加了服务器端的负载，制约了应用系统的扩展性。基于上述弊端，实现Web实时应用的技术出现了，WebSocket通过浏览器提供的API真正实现了具备像C/S架构下的桌面系统的实时通讯能 力。其原理是使用JavaScript调用浏览器的API发出一个WebSocket请求至服务器，经过一次握手，和服务器建立了TCP通讯，因为它本质 上是一个TCP连接，所以数据传输的稳定性强和数据传输量比较小。WebSocket 协议WebSocket 协议本质上是一个基于 TCP 的协议。为了建立一个 WebSocket 连接，客户端浏览器首先要向服务器发起一个 HTTP 请求，这个请求和通常的 HTTP 请求不同，包含了一些附加头信息，其中附加头信息”Upgrade: WebSocket”表明这是一个申请协议升级的 HTTP 请求，服务器端解析这些附加的头信息然后产生应答信息返回给客户端，客户端和服务器端的 WebSocket 连接就建立起来了，双方就可以通过这个连接通道自由的传递信息，并且这个连接会持续存在直到客户端或者服务器端的某一方主动的关闭连接。下面我们来详细介绍一下 WebSocket 协议，由于这个协议目前还是处于草案阶段，版本的变化比较快，我们选择目前最新的 draft-ietf-hybi-thewebsocketprotocol-17 版本来描述 WebSocket 协议。因为这个版本目前在一些主流的浏览器上比如 Chrome,、FireFox、Opera 上都得到比较好的支持。通过描述可以看到握手协议客户端发到服务器的内容: 代码如下 复制代码 GET /chat HTTP/1.1 Host: server.example.com Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ== Origin: http://example.com Sec-WebSocket-Protocol: chat, superchat Sec-WebSocket-Version: 13从服务器到客户端的内容: 代码如下 复制代码 HTTP/1.1 101 Switching Protocols Upgrade: websocket Connection: Upgrade Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo= Sec-WebSocket-Protocol: chat这些请求和通常的 HTTP 请求很相似，但是其中有些内容是和 WebSocket 协议密切相关的。我们需要简单介绍一下这些请求和应答信息，”Upgrade:WebSocket”表示这是一个特殊的 HTTP 请求，请求的目的就是要将客户端和服务器端的通讯协议从 HTTP 协议升级到 WebSocket 协议。其中客户端的Sec-WebSocket-Key和服务器端的Sec-WebSocket-Accept就是重要的握手认证信息了，这些内容将在服 务器端实现的博文中讲解。相信通过上文的讲解你应该对WebSocket有了个初步认识了，如果有任何疑问欢迎交流。 客户端如概念篇中介绍的握手协议，客户端是由浏览器提供了API，所以只要使用JavaScript来简单调用即可，而服务器端是要自己实现的，服务器端将在下个博文来讲。 代码如下 复制代码 WebSocket JavaScript 接口定义:[Constructor(in DOMString url, optional in DOMString protocol)]interface WebSocket {readonly attribute DOMString URL;// ready stateconst unsigned short CONNECTING = 0;const unsigned short OPEN = 1;const unsigned short CLOSED = 2;readonly attribute unsigned short readyState;readonly attribute unsigned long bufferedAmount; // networkingattribute Function onopen;attribute Function onmessage;attribute Function onclose;boolean send(in DOMString data);void close();};WebSocket implements EventTarget; 简单了解下接口方法和属性：readyState表示连接有四种状态：CONNECTING (0)：表示还没建立连接；OPEN (1)： 已经建立连接，可以进行通讯；CLOSING (2)：通过关闭握手，正在关闭连接；CLOSED (3)：连接已经关闭或无法打开；url是代表 WebSocket 服务器的网络地址，协议通常是”ws”或“wss(加密通信)”,send 方法就是发送数据到服务器端；close 方法就是关闭连接；onopen连接建立，即握手成功触发的事件；onmessage收到服务器消息时触发的事件；onerror异常触发的事件；onclose关闭连接触发的事件；JavaScript调用浏览器接口实例如下： 代码如下 复制代码 var wsServer = "ws://localhost:8888/Demo"; //服务器地址var websocket = new WebSocket(wsServer); //创建WebSocket对象websocket.send("hello");//向服务器发送消息alert(websocket.readyState);//查看websocket当前状态websocket.onopen = function (evt) {//已经建立连接};websocket.onclose = function (evt) {//已经关闭连接};websocket.onmessage = function (evt) {//收到服务器消息，使用evt.data提取};websocket.onerror = function (evt) {//产生异常};

如果遇见了一个全新的协议，怎么从零开始，完成接口测试？以 WebSocket 为例。 WebSocket 协议在2008年诞生，2011年成为国际标准。现在所有浏览器都已经支持了。WebSocket 的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话。 WebSocket 的其他特点： 1. 建立在 TCP 协议之上，服务器端的实现比较容易。 2. 与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。 3. 数据格式比较轻量，性能开销小，通信高效。 4. 可以发送文本，也可以发送二进制数据。 5. 没有同源限制，客户端可以与任意服务器通信。 6. 协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。 · ws–>http（未加密） 无证书 · wss–>https（加密） 有证书 第一步： 很多时候第一反应向开发工程师求助，因为开发工程师基于新协议已经完成了接口开发，向开发工程师求助显然是最好的办法。找到一些学习脉络，包含了协议的说明文档、代码开发文档、实现代码等内容，了解协议的原理。向开发求助是个方法。 那么 WebSocket 用 Fiddler 怎么搞定？，其实主要就是修改了 Fiddler 中 Rules 下的 Customize Rules，如果感兴趣可以自己去搜一下。当面对陌生技术问题的时候，应该使用最熟悉的技术去尝试解决问题。虽然 Fiddler 截获 WebSocket 接口的办法，所截获的全部消息都在日志里面，根本无法操作。但是，可以借助 Fiddler 分析 WebSocket 的接口，一开始给 Fiddler 这款工具的定位一样，那就是通过它辅助分析我们的被测接口。处理HTTP、HTTPS，推荐用Fiddler。 但是在处理TCP,UDP 就用WireShark。Websocket是应用层协议，建立在 TCP 协议之上，服务器端的实现比较容易。因为应用层是在传输层的基础上包装数据，所以我们还是从底层开始了解Websocket到底是个啥?是如何工作的? 可以通过---- wireshark（网络封包分析软件）抓包工具抓到WebSocket接口 wireshark下载地址：https://www.wireshark.org/download.html 以下是python实现的websocket 接口连接。

java 后台做 websocket 服务端。 页面使用js的websocket客户端 连接上 服务端 就能实时通信了。

一些参考内容: 用户的需求通常是: 希望web页面更具交互性. 而解决方案就是使用javascript. 而这一切的推动力又是Ajax. Ajax是异步javascript和xml的缩写(Asynchronous Javascript and XML), 利用这种技术, 可以让远程服务器和客户端保持数据同步. 但在这个机制中XML并非必须的, 它只是作为数据传递的载体, 实际很多时候是使用JSON来进行传递(很多时候又叫AJAJ). 使用Ajax的最大好处是: 客户端不必刷新整个页面就可以实现同服务器的数据交换, 而这种交换对于用户来说可以是透明的. 但这样也造成一个难题: 由于客户端是主动从服务器获取新数据, 但客户端怎么获知数据的更新呢? 过去14年间(2000年开始算起), 针对上面的问题, 出现了各种各样的解决方案. 主要有四种形式的解决办法: 1999年的时候, 在HTTP1.1规范内就提供了一种功能, 可以用在任何HTTP数据交流过程中的功能, 叫做HTTP Upgrade. 作用原理如下: HTTP Upgrade最好的地方是: 指定的协议几乎可以是任意的. 当HTTP握手结束后就会释放掉之前的HTTP连接. 理论上讲, 使用HTTP Upgrade, 可以建立起任意的两端点间的任意TCP Socket连接(甚至可以是持久的, 全双工的TCP socket连接), 并且连接上工作的协议可以是你自己设计的. 当然, 浏览器不可能将客户端程序员推入到TCP协议栈的深渊让他们自己针对HTTP Upgrade开发自己的协议. 所以由专门机构开发了一些协议出来, 而WebSockets协议正是其中之一. WebSocket连接的建立过程: 使用WebSocket协议的好处很多, 主要和它的实现有关: 虽然原理很复杂, 但是已经有现成的API了, 要做的就是在上面构建你自己的应用即可... 而WebSocket的API又分为客户端API和服务端API. 不同点只是对不同工作内容的支持不同而已. 用途基本上没有任何限制, 比如浏览器应用, 以及任何支持平台上的客户端应用.下面是一些典型用途: 和HTTP协议一样, 由于是信息交流的规范或标准. 所以使用WebSocket建立的不同应用理论上说都可以相互通信, 不管是哪个平台, 什么类型的. 正是因为如此, 所以大多数WebSocket的实现中都将自己分为客户端和服务器端工具两个部分. 比如Java或.net. 而Javascript中只是有客户端工具的部分, 因为它本身就是用作客户端脚本的. 下面先来使用JavaScript的客户端工具建立客户端, 然后再转到Java的服务端(当然Java也有客户端的API,只是使用Java实现客户端还是交给android中去吧...) W3C规定将浏览器中的WebSocket支持接口作为HTML5的扩展. 故虽然使用的是Javascript来实现WebSocket的交流, 但实际上WebSocket接口是HTML5的组成部分.任何浏览器都可以通过WebSocket接口的implementation来实现WebSocket通信.(早期的Ajax通信则是不同浏览器有不同的类和不同的方法来做Ajax请求, 比起现在可以说复杂很多) 下面就来建立客户端. WebSocket API是从Java EE7开始加入进来的, 在规范JSR 356可以查到. 它里面包含了客户端以及服务端的API. 客户端API是基础API: 包含了一个WebSocket端所必须的基本类和接口(在javax.websocket包中). 服务端API: 建立在客户端API之上并对客户端API进行了扩展(javax.websocket.server包中). 所以针对Java的WebSocket API, 有两大部分组件: 仅用于客户端的API或完整版API(服务端API). API的详细使用需要查看Java EE7的API文档. 下面分别来看看这两个部分的API. 关于Tomcat中WebSocket连接数的限制, 实际就是TCP连接的最大数目: TO reach the max alive websocket connection in Tomcat, following config changes need to be done. Change this to from 50 till 65535. The above configuration changes allows around ~50k live connections in a 2GB Intel Core i5 machine provided the server and client are running in different machines. 下面是一些连接数限制的尝试: https://blog.krecan.net/2010/05/02/cool-tomcat-is-able-to-handle-more-than-13000-concurrent-connections/ http://grokbase.com/t/tomcat/users/132d14c1q0/achieve-large-number-of-concurrent-websocket-connections-40000-50000 https://github.com/rstoyanchev/spring-websocket-portfolio/issues/52 https://support.appharbor.com/discussions/problems/26648-websockets-max-concurrent-connections-request-queue-limit https://mrotaru.wordpress.com/2013/10/10/scaling-to-12-million-concurrent-connections-how-migratorydata-did-it/ 经典做法

Http协议是无状态的，只能由客户端主动发起，服务端再被动响应，服务端无法向客户端主动推送内容，并且一旦服务器响应结束，链接就会断开所以无法进行实时通信。WebSocket协议正是为解决客户端与服务端实时通信而产生的技术，现在已经被主流浏览器支持。目前 Flutter也提供了专门的包来支持WebSocket协议。 web_socket_channel package 提供了我们需要连接到WebSocket服务器的工具。该package提供了一个 WebSocketChannel 允许我们既可以监听来自服务器的消息，又可以将消息发送到服务器的方法。 执行flutter pub get 命令，即可 1. 连接到WebSocket服务器 2. 监听来自服务器的消息 使用一个 StreamBuilder 来监听新消息， 并用一个Text来显示它们 工作原理 WebSocketChannel 提供了一个来自服务器的消息 Stream 。该 Stream 类是 dart:async 包中的一个基础类。它提供了一种方法来监听来自数据源的异步事件。与 Future 返回单个异步响应不同， Stream 类可以随着时间推移传递很多事件。该 StreamBuilder 组件将连接到一个 Stream ， 并在每次收到消息时通知Flutter重新构建界面 3. 将数据发送到服务器 为了将数据发送到服务器，我们会add消息给WebSocketChannel提供的sink。 WebSocketChannel 提供了一个 StreamSink ，它将消息发给服务器 StreamSink 类提供了给数据源同步或异步添加事件的一般方法 4. 关闭WebSocket连接 思考: 假如我们想通过WebSocket传输二进制数据应该怎么做（比如要从服务器接收一张图片）？我们发现StreamBuilder和Stream都没有指定接收类型的参数，并且在创建WebSocket链接时也没有相应的配置，貌似没有什么办法……其实很简单，要接收二进制数据仍然使用StreamBuilder，因为WebSocket中所有发送的数据使用帧的形式发送，而帧是有固定格式，每一个帧的数据类型都可以通过Opcode字段指定，它可以指定当前帧是文本类型还是二进制类型（还有其它类型），所以客户端在收到帧时就已经知道了其数据类型，所以flutter完全可以在收到数据后解析出正确的类型，所以就无需开发者去关心，当服务器传输的数据是指定为二进制时，StreamBuilder的snapshot.data的类型就是List<int>，是文本时，则为String。 https://book.flutterchina.club/chapter11/websocket.html

长连接： 一个链接上可以连续发送多个数据包，在链接期间，如果没有数据包发送，需要双方发链路检查包 TCP/IP: TCP/IP 属于传输层，主要解决网络中的数据传输问题，只管传输数据。但这样对传输的数据没有一个规范的封装、解析等处理。使得传输的数据难以识别，所以才有了应用层协议对数据进行的封装、解析等，如http协议。 HTTP: HTTP协议是应用层协议，用于分装解析传输数据。 从HTTP1.1开始其实就默认开启了长链接，也就是请求头header中可以看到Connection:Keep-alive。但是长连接只是说保持了（服务器可以告诉客户端保持时间Keep-Alive:timeout=20;max=20;）这个TCP通道，并采用服务器和客户端应答模式（Request-Response）,不需要再创建一个链接通道，做到一个性能优化。 socket: 与HTTP协议不一样，socket不是协议，他是在程序层面上对传输层协议（像TCP/IP）的接口封装。我们知道传输层的协议，是解决数据在网络中传输的问题的，那么socket(套接字)就是传输通道两端的接口。 Websocket: WebSocket是包装成了一个应用层协议作为socket,从而能够让客户端和远程服务端通过web建立全双工通信。 WebSocket API 是HTML5 推出的东西。在客户端我们可以通过HTML5 所提供的API 对websocket 进行创建、发送数据、监听信息、监听报错等功能( HTML5 WebSocket ) 我们知道WebSocket 是在Socket的基础上实现的，所以我们要做的是对现有的Socket协议进行升级。 步骤： 客户端发送websocket请求-->服务端接受并识别该请求-->对该请求协议进行升级--> 返回给客户端 --> websocket 通道建立 --> 客户端/服务端发送数据 协议升级 在这里需要注意的是头部信息和头部信息中的Sec-Websocket-Accept的值。 该值需要是一个通过base64加密的哈希值（sha1）。 而该加密所用的数据是客户端传过来的sec-websocket-key的值和MAGIC_STRINC内的固定值。 对MAGIC_STRINC的说明 Webscoket 中传输的数据是 数据帧（frame） 数据帧有多种类型 主要有：文本型、二进制数据 数据帧结构 每一列代表一个字节，一个字节8位，每一位又代表一个二进制数。 创建数据帧 解数据帧 心跳检查 由于websocket 不进行交互会关闭通道所以，才有了心跳检查。 websocket与和他http的区别 基于node实现websocket协议 使用nodeJS在HTTP上实现WebSocket 如何让我的服务器返回正确的Sec-WebSocket-Accept标头值 学习WebSocket协议—从顶层到底层的实现原理 websocket 协议帧 解析 nodejs实现Websocket的数据接收发送

WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算） 首先HTTP有 1.1 和 1.0 之说，也就是所谓的 keep-alive，把多个HTTP请求合并为一个，但是 Websocket 其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充 他们有交集，但是并不是全部。 另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。= 再简单来说，层级不一样。 首先，Websocket是一个持久化的协议，相对于HTTP这种非持久的协议来说。简单的举个例子吧，用目前应用比较广泛的PHP生命周期来解释。 HTTP的生命周期通过 Request 来界定，也就是一个 Request 一个 Response ，那么在 HTTP1.0 中，这次HTTP请求就结束了。 在HTTP1.1中进行了改进，使得有一个keep-alive，也就是说，在一个HTTP连接中，可以发送多个Request，接收多个Response。但是请记住 Request = Response ， 在HTTP中永远是这样，也就是说一个request只能有一个response。而且这个response也是被动的，不能主动发起。 教练，你BB了这么多，跟Websocket有什么关系呢？ (:з」∠) 好吧，我正准备说Websocket呢。。 首先Websocket是基于HTTP协议的，或者说借用了HTTP的协议来完成一部分握手。 首先我们来看个典型的 Websocket 握手（借用Wikipedia的。。） 熟悉HTTP的童鞋可能发现了，这段类似HTTP协议的握手请求中，多了几个东西。我会顺便讲解下作用。 这个就是Websocket的核心了，告诉 Apache 、 Nginx 等服务器：注意啦，我发起的是Websocket协议，快点帮我找到对应的助理处理~不是那个老土的HTTP。 首先， Sec-WebSocket-Key 是一个 Base64 encode 的值，这个是浏览器随机生成的，告诉服务器：泥煤，不要忽悠窝，我要验证尼是不是真的是Websocket助理。 然后， Sec_WebSocket-Protocol 是一个用户定义的字符串，用来区分同URL下，不同的服务所需要的协议。简单理解：今晚我要服务A，别搞错啦~ 最后， Sec-WebSocket-Version 是告诉服务器所使用的 Websocket Draft（协议版本），在最初的时候，Websocket协议还在 Draft 阶段，各种奇奇怪怪的协议都有，而且还有很多期奇奇怪怪不同的东西，什么Firefox和Chrome用的不是一个版本之类的，当初Websocket协议太多可是一个大难题。。不过现在还好，已经定下来啦 大家都使用的一个东西 脱水： 服务员，我要的是13岁的噢→_→ 然后服务器会返回下列东西，表示已经接受到请求， 成功建立Websocket啦！ 这里开始就是HTTP最后负责的区域了，告诉客户，我已经成功切换协议啦~ Upgrade: websocket Connection: Upgrade 依然是固定的，告诉客户端即将升级的是 Websocket 协议，而不是mozillasocket，lurnarsocket或者shitsocket。 然后， Sec-WebSocket-Accept 这个则是经过服务器确认，并且加密过后的 Sec-WebSocket-Key 。 服务器：好啦好啦，知道啦，给你看我的ID CARD来证明行了吧。。 后面的， Sec-WebSocket-Protocol 则是表示最终使用的协议。 至此，HTTP已经完成它所有工作了，接下来就是完全按照Websocket协议进行了。具体的协议就不在这阐述了。 ——————技术解析部分完毕—————— 你TMD又BBB了这么久，那到底Websocket有什么鬼用， http long poll ，或者ajax轮询 不都可以实现实时信息传递么。 好好好，年轻人，那我们来讲一讲Websocket有什么用。来给你吃点胡（苏）萝（丹）卜（红） 在讲Websocket之前，我就顺带着讲下 long poll 和 ajax轮询 的原理。 ajax轮询 ajax轮询的原理非常简单，让浏览器隔个几秒就发送一次请求，询问服务器是否有新信息。 场景再现： long poll long poll 其实原理跟 ajax轮询 差不多，都是采用轮询的方式，不过采取的是阻塞模型（一直打电话，没收到就不挂电话），也就是说，客户端发起连接后，如果没消息，就一直不返回Response给客户端。直到有消息才返回，返回完之后，客户端再次建立连接，周而复始。 场景再现： 从上面可以看出其实这两种方式，都是在不断地建立HTTP连接，然后等待服务端处理，可以体现HTTP协议的另外一个特点，被动性。 何为被动性呢，其实就是，服务端不能主动联系客户端，只能有客户端发起。 简单地说就是，服务器是一个很懒的冰箱（这是个梗）（不会、不能主动发起连接），但是上司有命令，如果有客户来，不管多么累都要好好接待。 说完这个，我们再来说一说上面的缺陷（原谅我废话这么多吧OAQ） 从上面很容易看出来，不管怎么样，上面这两种都是非常消耗资源的。 ajax轮询 需要服务器有很快的处理速度和资源。（速度）long poll 需要有很高的并发，也就是说同时接待客户的能力。（场地大小） 所以 ajax轮询 和 long poll 都有可能发生这种情况。 言归正传，我们来说Websocket吧 通过上面这个例子，我们可以看出，这两种方式都不是最好的方式，需要很多资源。 一种需要更快的速度，一种需要更多的"电话"。这两种都会导致"电话"的需求越来越高。 哦对了，忘记说了HTTP还是一个状态协议。 通俗的说就是，服务器因为每天要接待太多客户了，是个健忘鬼，你一挂电话，他就把你的东西全忘光了，把你的东西全丢掉了。你第二次还得再告诉服务器一遍。 所以在这种情况下出现了，Websocket出现了。他解决了HTTP的这几个难题。首先，被动性，当服务器完成协议升级后（HTTP->Websocket），服务端就可以主动推送信息给客户端啦。所以上面的情景可以做如下修改。 就变成了这样，只需要经过一次HTTP请求，就可以做到源源不断的信息传送了。（在程序设计中，这种设计叫做回调，即：你有信息了再来通知我，而不是我傻乎乎的每次跑来问你 ） 这样的协议解决了上面同步有延迟，而且还非常消耗资源的这种情况。那么为什么他会解决服务器上消耗资源的问题呢？ 其实我们所用的程序是要经过两层代理的，即HTTP协议在Nginx等服务器的解析下，然后再传送给相应的Handler（PHP等）来处理。简单地说，我们有一个非常快速的 接线员（Nginx） ，他负责把问题转交给相应的 客服（Handler） 。 本身接线员基本上速度是足够的，但是每次都卡在客服（Handler）了，老有客服处理速度太慢。，导致客服不够。Websocket就解决了这样一个难题，建立后，可以直接跟接线员建立持久连接，有信息的时候客服想办法通知接线员，然后接线员在统一转交给客户。 这样就可以解决客服处理速度过慢的问题了。 同时，在传统的方式上，要不断的建立，关闭HTTP协议，由于HTTP是非状态性的，每次都要重新传输 identity info （鉴别信息），来告诉服务端你是谁。 虽然接线员很快速，但是每次都要听这么一堆，效率也会有所下降的，同时还得不断把这些信息转交给客服，不但浪费客服的处理时间，而且还会在网路传输中消耗过多的流量/时间。 但是Websocket只需要一次HTTP握手，所以说整个通讯过程是建立在一次连接/状态中，也就避免了HTTP的非状态性，服务端会一直知道你的信息，直到你关闭请求，这样就解决了接线员要反复解析HTTP协议，还要查看identity info的信息。 同时由客户主动询问，转换为服务器（推送）有信息的时候就发送（当然客户端还是等主动发送信息过来的。。），没有信息的时候就交给接线员（Nginx），不需要占用本身速度就慢的客服（Handler）了 ——————– 至于怎么在不支持Websocket的客户端上使用Websocket。。答案是： 不能 但是可以通过上面说的 long poll 和 ajax 轮询 来 模拟出类似的效果

踩着年末的尾巴，提前布局来年，为来年的工作做个好的铺垫，所以就开始了面试历程，因为项目中使用到了 WebSocket ，面试官在深挖项目经验的时候，也难免提到 WebSocket 相关的知识点，因为之前并没有考虑这么深，所以，回答的还是有所欠缺，因此，赶紧趁热再熟悉熟悉，也借此机会，整理出来供大家咀嚼，每个项目都有其值得挖掘的闪光点，要用有爱的眼睛去发现。 WebSocket 是一种在单个TCP连接上进行全双工通信的协议。 WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。 在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接， 并进行双向数据传输。（维基百科） WebSocket 本质上一种计算机网络应用层的协议，用来弥补 http 协议在持久通信能力上的不足。 WebSocket 协议在2008年诞生，2011年成为国际标准。现在最新版本浏览器都已经支持了。 它的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于服务器推送技术的一种。 WebSocket 的其他特点包括： 我们已经有了 HTTP 协议，为什么还需要另一个协议？它能带来什么好处？ 因为 HTTP 协议有一个缺陷：通信只能由客户端发起，不具备服务器推送能力。 举例来说，我们想了解查询今天的实时数据，只能是客户端向服务器发出请求，服务器返回查询结果。HTTP 协议做不到服务器主动向客户端推送信息。 这种单向请求的特点，注定了如果服务器有连续的状态变化，客户端要获知就非常麻烦。我们只能使用"轮询"：每隔一段时候，就发出一个询问，了解服务器有没有新的信息。最典型的场景就是聊天室。轮询的效率低，非常浪费资源（因为必须不停连接，或者 HTTP 连接始终打开）。 在 WebSocket 协议出现以前，创建一个和服务端进双通道通信的 web 应用，需要依赖HTTP协议，进行不停的轮询，这会导致一些问题： http 协议本身是没有持久通信能力的，但是我们在实际的应用中，是很需要这种能力的，所以，为了解决这些问题， WebSocket 协议由此而生，于2011年被IETF定为标准RFC6455，并被RFC7936所补充规范。并且在 HTML5 标准中增加了有关 WebSocket 协议的相关 api ，所以只要实现了 HTML5 标准的客户端，就可以与支持 WebSocket 协议的服务器进行全双工的持久通信了。 WebSocket 与 HTTP 的关系图： 下面一张图说明了 HTTP 与 WebSocket 的主要区别： 不同点： 与http协议一样， WebSocket 协议也需要通过已建立的TCP连接来传输数据。具体实现上是通过http协议建立通道，然后在此基础上用真正 WebSocket 协议进行通信，所以WebSocket协议和http协议是有一定的交叉关系的。首先， WebSocket 是一个持久化的协议，相对于 HTTP 这种非持久的协议来说。简单的举个例子吧，用目前应用比较广泛的 PHP 生命周期来解释。 HTTP 的生命周期通过 Request 来界定，也就是一个 Request 一个 Response ，那么在 HTTP1.0 中，这次 HTTP 请求就结束了。 在 HTTP1.1 中进行了改进，使得有一个 keep-alive，也就是说，在一个 HTTP 连接中，可以发送多个 Request，接收多个 Response。但是请记住 Request = Response， 在 HTTP 中永远是这样，也就是说一个 Request 只能有一个 Response。而且这个 Response 也是被动的，不能主动发起。首先 WebSocket 是基于 HTTP 协议的，或者说借用了 HTTP 协议来完成一部分握手。 首先我们来看个典型的 WebSocket 握手 熟悉 HTTP 的童鞋可能发现了，这段类似 HTTP 协议的握手请求中，多了这么几个东西。 这个就是 WebSocket 的核心了，告诉 Apache 、 Nginx 等服务器：注意啦，我发起的请求要用 WebSocket 协议，快点帮我找到对应的助理处理~而不是那个老土的 HTTP 。 这里开始就是 HTTP 最后负责的区域了，告诉客户，我已经成功切换协议啦~ 依然是固定的，告诉客户端即将升级的是 WebSocket 协议，而不是 mozillasocket ，lurnarsocket 或者 shitsocket 。 然后， Sec-WebSocket-Accept 这个则是经过服务器确认，并且加密过后的 Sec-WebSocket-Key 。服务器：好啦好啦，知道啦，给你看我的 ID CARD 来证明行了吧。后面的， Sec-WebSocket-Protocol 则是表示最终使用的协议。至此，HTTP 已经完成它所有工作了，接下来就是完全按照 WebSocket 协议进行了。总结， WebSocket 连接的过程是： 优点： 缺点： 心跳就是客户端定时的给服务端发送消息，证明客户端是在线的， 如果超过一定的时间没有发送则就是离线了。 当客户端第一次发送请求至服务端时会携带唯一标识、以及时间戳，服务端到db或者缓存去查询改请求的唯一标识，如果不存在就存入db或者缓存中， 第二次客户端定时再次发送请求依旧携带唯一标识、以及时间戳，服务端到db或者缓存去查询改请求的唯一标识，如果存在就把上次的时间戳拿取出来，使用当前时间戳减去上次的时间， 得出的毫秒秒数判断是否大于指定的时间，若小于的话就是在线，否则就是离线； 通过查阅资料了解到 nginx 代理的 websocket 转发，无消息连接会出现超时断开问题。网上资料提到解决方案两种，一种是修改nginx配置信息，第二种是 websocket 发送心跳包。下面就来总结一下本次项目实践中解决的 websocket 的断线 和 重连 这两个问题的解决方案。主动触发包括主动断开连接，客户端主动发送消息给后端 主动断开连接，根据需要使用，基本很少用到。 下面主要讲一下客户端也就是前端如何实现心跳包： 首先了解一下心跳包机制 跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活着。事实上这是为了保持长连接，至于这个包的内容，是没有什么特别规定的，不过一般都是很小的包，或者只包含包头的一个空包。 在 TCP 的机制里面，本身是存在有心跳包的机制的，也就是 TCP 的选项： SO_KEEPALIVE 。系统默认是设置的2小时的心跳频率。但是它检查不到机器断电、网线拔出、防火墙这些断线。而且逻辑层处理断线可能也不是那么好处理。一般，如果只是用于保活还是可以的。 心跳包一般来说都是在逻辑层发送空的 echo 包来实现的。下一个定时器，在一定时间间隔下发送一个空包给客户端，然后客户端反馈一个同样的空包回来，服务器如果在一定时间内收不到客户端发送过来的反馈包，那就只有认定说掉线了。 在长连接下，有可能很长一段时间都没有数据往来。理论上说，这个连接是一直保持连接的，但是实际情况中，如果中间节点出现什么故障是难以知道的。更要命的是，有的节点(防火墙)会自动把一定时间之内没有数据交互的连接给断掉。在这个时候，就需要我们的心跳包了，用于维持长连接，保活。 心跳检测步骤： 针对这种异常的中断解决方案就是处理重连，下面我们给出的重连方案是使用js库处理：引入 reconnecting-websocket.min.js ，ws建立链接方法使用js库api方法： 断网监测支持使用js库： offline.min.js 以上方案，只是抛砖引玉，如果大家有更好的解决方案欢迎评论区分享交流。 WebSocket 是为了在 web 应用上进行双通道通信而产生的协议，相比于轮询HTTP请求的方式，WebSocket 有节省服务器资源，效率高等优点。WebSocket 中的掩码是为了防止早期版本中存在中间缓存污染攻击等问题而设置的，客户端向服务端发送数据需要掩码，服务端向客户端发送数据不需要掩码。WebSocket 中 Sec-WebSocket-Key 的生成算法是拼接服务端和客户端生成的字符串，进行SHA1哈希算法，再用base64编码。WebSocket 协议握手是依靠 HTTP 协议的，依靠于 HTTP 响应101进行协议升级转换。

一个小数，

目前要实现消息实时推送，有两种方法，一种是ajax轮询，由客户端不停地请求服务器端，查询有没有新消息，然后再由服务器返回结果；另外一种就是long poll,通过一次请求，询问服务器有没有新消息更新，如果没有新消息时，会保持长连接，就一直不返回Response给客户端。直到有消息才返回，返回完之后，客户端再次建立连接，周而复始。这两种都是单向链接，需要被动的请求服务器，而不是由服务器自动发给客户端。从上面可以看出其实这两种方式，都是在不断地建立HTTP连接，然后等待服务端处理，可以体现HTTP协议的另外一个特点，被动性。何为被动性呢，其实就是，服务端不能主动联系客户端，只能有客户端发起。简单地说就是，服务器是一个很懒的冰箱（这是个梗）（不会、不能主动发起连接），但是上司有命令，如果有客户来，不管多么累都要好好接待。

还得有个后端服务器（固定IP地址）做websocket消息转发，只靠vue websocket搞不了的

WebSocket是html5新增加的一种通信协议，目前流行的浏览器都支持这个协议，例如Chrome，Safari，Firefox，Opera，IE等等，对该协议支持最早的应该是chrome，从chrome12就已经开始支持，随着协议草案的不断变化，各个浏览器对协议的实现也在不停的更新。该协议还是草案，没有成为标准，不过成为标准应该只是时间问题了，从WebSocket草案的提出到现在已经有十几个版本了，目前最新的是版本17，所对应的协议版本号为13，目前对该协议支持最完善的浏览器应该是chrome，毕竟WebSocket协议草案也是Google发布的。1. WebSocket API简介首先看一段简单的javascript代码，该代码调用了WebSockets的API。[javascript] view plaincopyvar ws = new WebSocket(“ws://echo.websocket.org”); ws.onopen = function(){ws.send(“Test!”); }; ws.onmessage = function(evt){console.log(evt.data);ws.close();}; ws.onclose = function(evt){console.log(“WebSocketClosed!”);}; ws.onerror = function(evt){console.log(“WebSocketError!”);}; 这份代码总共只有5行，现在简单概述一下这5行代码的意义。第一行代码是在申请一个WebSocket对象，参数是需要连接的服务器端的地址，同http协议使用http://开头一样，WebSocket协议的URL使用ws://开头，另外安全的WebSocket协议使用wss://开头。第二行到第五行为WebSocket对象注册消息的处理函数，WebSocket对象一共支持四个消息 onopen, onmessage, onclose和onerror，当Browser和WebSocketServer连接成功后，会触发onopen消息；如果连接失败，发送、接收数据失败或者处理数据出现错误，browser会触发onerror消息；当Browser接收到WebSocketServer发送过来的数据时，就会触发onmessage消息，参数evt中包含server传输过来的数据；当Browser接收到WebSocketServer端发送的关闭连接请求时，就会触发onclose消息。咱们可以看出所有的操作都是采用消息的方式触发的，这样就不会阻塞UI，使得UI有更快的响应时间，得到更好的用户体验。

跟普通编程里的socket没啥区别吧，不是之前的我请求你再回应，变成了彼此都能请求对方了，

本篇文章主要讲述以下几点： WebSocket协议分为两部分：握手和数据传输 下面通过客户端和服务端交互的报文对比WebSocket通讯与传统HTTP的不同点，主要关注握手阶段。 根据上面的例子，运行之后，new WebSocket实例化一个新的WebSocket客户端对象，请求WebSocket URL为 ws://localhost:8000 的服务器，打开控制台的NetWork，客户端WebSocket对象会自动解析并识别为WebSocket请求，连接服务端端口，执行双方握手过程，来自客户端握手发送数据格式如下：至此，HTTP已经完成它所有工作，接下来就是完全按照Websocket协议进行了。 通过查看WebSocket的原理，与HTTP对比，得出结论： HTTP长连接中，每次数据交换除了真正的数据部分外，服务器和客户端还要大量交换HTTP header，信息交换效率很低。Websocket协议通过第一个请求建立了TCP连接之后，之后交换的数据都不需要发送 HTTP header就能交换数据，这显然和原有的HTTP协议有区别，所以它需要对服务器和客户端都进行升级才能实现（主流浏览器都已支持HTML5）。此外还有 multiplexing、不同的URL可以复用同一个WebSocket连接等功能。这些都是HTTP长连接不能做到的。 我们在使用WebSocket协议时通常不会使用它的API来实现，而是借助于Socket.io，Socket.io是一个WebSocket库，包括客户端的js和服务端的nodejs，它的目标是构建可以在不同浏览器和移动设备上使用的实时应用。它会自动根据浏览器从WebSocket、AJAX长轮询等各种方式中选择最佳的方式来实现网络实时应用，也就是说如果浏览器对WebSocket兼容性差，Socket.io会自动选择最佳方式实现实时通信，非常方便和人性化。 Socket.io 官方文档： https://socket.io/get-started/chat/ WebSocket兼容几乎所有现代浏览器，IE 10+ Edge Firefox 4+ Chrome 4+ Safari 5+ Opera 11.5+ socket.io对浏览器做了很好的兼容。 下一篇讲述Socket.io客户端API 参考文档： https://www.zhihu.com/question/20215561

Websocket是应用层第七层上的一个应用层协议，它必须依赖 HTTP 协议进行一次握手 ，握手成功后，数据就直接从 TCP 通道传输，与 HTTP 无关了。即：websocket分为握手和数据传输阶段，即进行了HTTP握手 + 双工的TCP连接。 下面我们分别来看一下这两个阶段的具体实现原理： 客户端发送消息： 服务端返回消息： 这里值得注意的是 Sec-WebSocket-Accept的计算方法 ： base64(hsa1(sec-websocket-key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11)) 如果这个Sec-WebSocket-Accept计算错误浏览器会提示：Sec-WebSocket-Accept dismatch 如果返回成功，Websocket就会回调onopen事件 Websocket的数据传输是frame形式传输的，比如会将一条消息分为几个frame，按照先后顺序传输出去。这样做会有几个好处： websocket传输使用的协议如下图： 参数说明如下： 我们了解了websocket的实现原理之后，请看以下golang的实现案例： html和js使用案例：

目前来说换成5200+就不错,不过换不换的,没什么意思,性能差不了很多的.

是不是这个阿?Windows socket error:(10065). on API "connect 是不是"API",应该不是"ABT"阿!!!!!!如果是"API"你到这里看看吧!! WSAEHOSTUNREACH (10065) No route to host A socket operation was attempted to an unreachable host. This error also occurs when your ISP is intentionally blocking port 25 (the SMTP port) in an attempt to reduce spamming through their systems. See WSAENETUNREACH (10051) 请重新输入密码试试看!!!

这个可能是你注册表出问题了 你首先试下看能ping通不 如果是通的建议你把损坏的注册表删除 方法第 1 步：删除损坏的注册表项1. 单击“开始”，然后单击“运行”。 2. 在“打开”框中，键入“regedit”，然后单击“确定”。 3. 在注册表编辑器中，找到以下注册表项，右键单击每一项，然后单击“删除”：HKEY_LOCAL_MACHINESystemCurrentControlSetServicesWinsockHKEY_LOCAL_MACHINESystemCurrentControlSetServicesWinsock2 4. 当提示您确认删除时，单击“是”。 注意：删除 Winsock 注册表项后请重新启动计算机。这样做可以让 Windows XP 操作系统为这两个注册表项创建新的 shell 条目。如果在删除 Winsock 注册表项后未重新启动计算机，则下一步将无法正常进行。第 2 步：安装 TCP/IP1. 右键单击网络连接，然后单击“属性”。 2. 单击“安装”。 3. 单击“协议”，然后单击“添加”。 4. 单击“从磁盘安装”。 5. 键入 C:Windowsinf，然后单击“确定”。 6. 在可用协议列表中，单击“Internet 协议 (TCP/IP)”，然后单击“确定”。 7. 重新启动计算机。

X4 631 X4 641 X4 651A4A6A8 多个型号APU

CAsyncSocket::OnReceiveCalled by the framework to notify this socket that there is data in the buffer that can be retrieved by calling the Receive member function.virtual void OnReceive( int nErrorCode );ParametersnErrorCode The most recent error on a socket. The following error codes apply to the OnReceive member function: 0 The function executed successfully. WSAENETDOWN The Windows Sockets implementation detected that the network subsystem failed. RemarksFor more information, see Windows Sockets: Socket Notifications.Examplevoid CMyAsyncSocket::OnReceive(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ static int i=0; i++; TCHAR buff[4096]; int nRead; nRead = Receive(buff, 4096); switch (nRead) { case 0: Close(); break; case SOCKET_ERROR: if (GetLastError() != WSAEWOULDBLOCK) { AfxMessageBox ("Error occurred"); Close(); } break; default: buff[nRead] = 0; //terminate the string CString szTemp(buff); m_strRecv += szTemp; // m_strRecv is a CString declared // in CMyAsyncSocket if (szTemp.CompareNoCase("bye") == 0 ) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}

cookie 和session 的区别：1、cookie数据存放在客户的浏览器上，session数据放在服务器上。2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗 考虑到安全应当使用session。3、session会在一定时间内保存在服务器上。当访问增多，会比较占用服务器的性能 考虑到减轻服务器性能方面，应当使用COOKIE。4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。cookie 和session 的联系：session是通过cookie来工作的session和cookie之间是通过$_COOKIE["PHPSESSID"]来联系的，通过$_COOKIE["PHPSESSID"]可以知道session的id，从而获取到其他的信息。在购物网站中通常将用户加入购物车的商品联通session_id记录到数据库中，当用户再次访问是，通过sessionid就可以查找到用户上次加入购物车的商品。因为sessionid是唯一的，记录到数据库中就可以根据这个查找了。

首先：我们认为众拳蓝精灵调试软件这个助手是可靠的，不存在问题。其次：下位作为客户端和有些串口调试助手也是不能连接的，但是作为服务器是能连接上。可见下位机中TCP客户端模式存在通信故障，TCP服务器模式工作正常，UDP通信正常；然后：上位机是否有问题，需要众拳蓝精灵调试软件直接与上位机连接进行测试。故，结论为下位机肯定存在问题，上位机需要进一步测试。

同意楼上

Slot 插槽是P2时代的了.才出P3时好象有少部分,过后就没的确Slot 插槽的板子了.Socket 插座 就是现在的CPU接口.P3和P4大部分是这种接口Slot 插槽是在Socket 插座后面世的,但没过多久就淘汰了,CPU接口又回归到Socket

BUS=总线Socket在这里应该择时插座型连接器， 例如装CPU的 CPU socket。Slot在这里应该指插槽型连接器。Connector连接器。

Slot是插槽，Socket是插座。目前新的CPU基本没有采用SLOT结构链接的，应为针脚数不够

Slot 1 Slot 1的出现彻底改变了Intel的CPU插座一贯的形状。Intel原来的CPU都是四方的，管脚在芯片的底部，安装时CPU插在主板的插座上。而Pentium II不再是四方的了，处理器芯片焊在一块电路板上，然后这块电路板再插到主板的插槽中，这个插槽就是Slot 1。采用这种设计处理器内核和L2缓存之间的通信速度更快。Slot 1有242个脚，工作电压为2.8-3.3V。Slot 1主要用于P2，P3 和Celeron（赛扬），另外还有Socket 8的转接卡用来安装Pentium Pro。 Slot 2 Slot 2是Slot 1的改进，主要用于Xeon系列处理器。Slot 2有330个脚，它和Slot 1之间最大的区别就在于Slot 1的CPU和L2缓存只能以CPU工作频率的一半进行通信，而Slot 2允许CPU和L2缓存以CPU工作频率进行通信。 Socket 370 从名字就可以看出Socket 370插座有370个管脚。在Intel找到了把处理器内核和L2缓存很便宜的做在一起的方法之后，它的CPU插座从Slot回到了Socket。Socket 370是基于Socket 7的，它不过只是在插座的四边每一边加了一排管脚。首先采用Socket 370的是PPGA封装的Celeron，接着是FC-PGA封装的Pentium III和Celeron II。同样也有Socket 370到Slot 1的转接卡。目前Intel的主流CPU都是Socket 370类型的。 Slot A 由于Intel给Slot 1申请了很全面的专利，AMD不能象从前那样照搬Intel的插座，所以AMD独立开发了Slot A，Slot A是AMD拥有独立知识产权的CPU插座，主要用于Athlon系列处理器。它的设计和Slot 1类似，但采用的协议不一样，它用的是EV6总线协议。采用EV6总线协议，CPU和内存之间的工作频率可以达到200MHz。目前随着Athlon处理器越来越流行，Slot A的主板也越来越多。 Socket A 当Intel从Slot转回Socket时，AMD也亦步亦趋，从Slot A转回了Socket A。0.18微米的Athlon和Duron都采用Socket A插座，它也支持200MHz 以及266MhHz的EV6总线。与Socket 370不同的是，Socket 370 CPU可以直接用Socket 7的散热器，而Socket A的散热器要稍作修改。另外AMD没有提供Socket A到Slot A的转接卡。Socket A有462个脚，它与Socket 370不兼容。目前AMD的主流CPU都是Socket A类型的。 Slockets 所谓的Slocket是Slot和Socket的结合体，从它的拼法上就可以看出。它实质上是一个Slot 1到Socket 370的转接卡，在不同的电平和接口之间进行转换。有的Slocket可以插两个CPU，还有的Slocket可以去除CPU的锁频，使超频更容易。

3

这篇文章主要介绍了nodejs结合socket.io实现websocket通信功能的方法,结合实例形式分析了nodejs结合socket.io实现websocket通信的具体步骤与相关操作技巧,需要的朋友可以参考下本文实例讲述了nodejs结合socket.io实现websocket通信功能的方法。分享给大家供大家参考，具体如下：因为项目中有需要实时获取后台数据的场景，之前一直是使用http心跳请求的方法。因为websocket与此模式相比有很大的性能提升，而且可以提高实时性，所以对websocket作了一些研究。这里是使用nodejs+socket.io来实现的。达成目标将原来心跳请求后台数据的方式，修改为通过socket连接后台统一推送的方式。后台的数据由别的进程写入文件或写入redis，这里实现的是读取文件的方式。前期准备安装nodejs(略)服务器端新建一个项目目录，这里是sockettest进入sockettest目录，安装express模块和socketio模块npm install --save express@4.10.2npm install --save socket.io新建package.json文件，在其中写入如下内容：{ "name": "socket-test", "version": "0.0.1", "description": "my first socket.io app", "dependencies": { "express": "^4.10.2", "socket.io": "^1.7.2" }}新建index.html，用于作为默认的访问显示页面，因为这里不会用到它，内容随意；新建trends.js文件，在其中写入内容：var app = require("express")();var http = require("http").Server(app);var io = require("socket.io")(http);var fs = require("fs");#默认打开文件app.get("/", function(req, res){ res.sendfile("index.html");});#用于存储所有socket以广播数据var iolist = [];#定义socket on connection（连入）事件行为io.on("connection", function(socket){ #将连入socket加入列表 iolist.push(socket); #记录index，在disconnect（断开连接）发生时将对应的socket删除 var sockex = iolist.indexOf(socket); #定义on disconnect事件行为 socket.on("disconnect", function(){ #将断开连接的socket从广播列表里删除 iolist.splice(sockex, 1); });});# 数据广播进程:每1秒钟广播一次setInterval(function() { # 如果没有正在连接的socket，直接返回； if (iolist.length <= 0) return; var trends = fs.readFileSync("./data/trends.json","utf-8");#trends数据 var coins = fs.readFileSync("./data/coins.json","utf-8");#coins数据 #向所有socket连接发送数据 for (i in iolist) { # 向客户端发送trends数据 iolist[i].emit("trends", trends); # 向客户端发送coins数据 iolist[i].emit("coins", coins); }}, 1000);# 服务器侦听在sockettest.com的3000端口上http.listen(3000, function(){ # 输出到标准输出 console.log("listening on sockettest.com:3000");});新建data目录，并在下面新建两个文件trends与coins，用于存放socket服务器将要读取的数据。新建public目录，在其中新建一个文件index.html，文件内容如下：<!--引入必要的js文件--><script type="text/javascript" src="http://sockettest:3000/socket.io/socket.io.js"></script><script type="text/javascript"> //新建socket var socket = io("http://sockettest.com:3000"); socketdata(socket); function socketdata() { #定义接收到coins类型数据时的行为 socket.on("coins", function(msg){ console.log(msg); } #定义接收到trends类型数据时的行为 socket.on("trends", function(msg){ console.log(msg); } }</script>代码部署刚才之所以要建两个index.html文件，是为了能够方便地在既有的web项目中使用nodejs提供的socket服务。这样我们把public/index.html可以部署在别的服务器中，比如nginx或tomcat之类，然后在根目下启动socket的服务器，为其提供socket服务。 首先在刚才的项目根目录下执行node ./trends.js并保持终端运行，然后再把项目部署在nginx里，通过chrome下访问nginx提供的web服务：http://hostname/public/index.html打开开发者模式，就能在console里看到每隔一秒便会收到来自node服务器的socket推送消息了。通过修改data目录下的两个文件，可以看到写入到文件的数据也会实时地推送到客户端这里来。上面是我整理给大家的，希望今后会对大家有帮助。相关文章：在vue中使用cli如何实现重构多页面脚手架在JS中实现点击下拉菜单内容同步输入框实现输入框与下拉框联动使用parcel.js打包出错的问题详细解读vue重构技术

使用异步方式，OnReceive（）函数是自动接收

CliSock.Create(0,SOCK_STREAM,FD_CONNECT|FD_READ);

服务端有调用CSocket::Receive吗?

要把socket设为允许读才可以。

ActiveX控件用于Web的过程是将控件嵌入主页中，用户通过浏览器访问该主页时，将主页中的控件下载，并在用户机器上注册，以后就可在用户的浏览器上运行。控件下载一次后就驻留在用户本地机器上，下次再访问相同的主页时，可不再下载该控件，而是直接运行用户本地的控件。这里控件容器就是浏览器，用户不需要通过浏览器调用控件的属性或方法。因此，开发面向Web的ActiveX控件比开发桌面的控件还要简单些，所复杂的是如何将该控件很好地嵌入主页，使用户能正常浏览。

重载CAsyncSocket::OnReceive添加代码char buf[10];int len=receive(buf,10);if(len>0){//你想扎存那就存那}

重载CAsyncSocket::OnReceive添加代码char buf[10];int len=receive(buf,10);if(len>0){//你想扎存那就存那}

CAsyncSocket::OnReceiveCalled by the framework to notify this socket that there is data in the buffer that can be retrieved by calling the Receive member function.virtual void OnReceive( int nErrorCode );ParametersnErrorCode The most recent error on a socket. The following error codes apply to the OnReceive member function: 0 The function executed successfully. WSAENETDOWN The Windows Sockets implementation detected that the network subsystem failed. RemarksFor more information, see Windows Sockets: Socket Notifications.Examplevoid CMyAsyncSocket::OnReceive(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ static int i=0; i++; TCHAR buff[4096]; int nRead; nRead = Receive(buff, 4096); switch (nRead) { case 0: Close(); break; case SOCKET_ERROR: if (GetLastError() != WSAEWOULDBLOCK) { AfxMessageBox ("Error occurred"); Close(); } break; default: buff[nRead] = 0; //terminate the string CString szTemp(buff); m_strRecv += szTemp; // m_strRecv is a CString declared // in CMyAsyncSocket if (szTemp.CompareNoCase("bye") == 0 ) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}由以上可知， 这个参数是输出参数，如果函数成功接收数据，则该参数为0,否则输出为错误代码。能否讲一下什么是函数的输出参数?////////////////////////////////如果说这样的函数:void add(int & value){ value++;}int n = 5;add(n);n就变成6了。///////////////////////////////////////我看错了，呵呵，不是输出参数，因为函数原型是：virtual void OnReceive( int nErrorCode );nErrorCode是int，不是int &或者int *,所以不是输出参数。我查看了一下MSDN和CAsyncSocket的源码：/////////////////////////////////////////////////////////////////////////////// CAsyncSocket Overridable callbacksvoid CAsyncSocket::OnReceive(int /*nErrorCode*/){}这个函数什么都没做。我估计当框架接收到数据到来的消息后，就调用CAsyncSocket::OnReceive，而nErrorCode这个参数也是框架自己提供的，表示当前网络的状态。程序员不用管它，只须在自己的socket类中重载该函数，并在函数体内实现自己的接收代码就可以了。

SO_VRF是指附加Linux Virtual Routing and Forwarding功能。

如果从核心架构看，由好到次依次为：酷睿2(Penryn) 酷睿2(Merom Socket P) 酷睿2(Merom Socket M)奔腾双核（Merom） 酷睿双核(Yonah) ，其中酷睿2(Socket P)是针对965的主板设计的，酷睿2(Socket M)则是针对945主板设计的。但是CPU的性能是由核心架构、主频、二级缓存、前端总线等因素共同决定的，因此新一代的低档型号可能不如旧一代的高档型号。如果是同等级别的，那好坏的排序就如上，而奔腾双核由于在核心架构上比酷睿先进，因而虽然前端总线和二级缓存低于酷睿，但总体性能跟酷睿持平。

Q是比较老的产品，也是现在大型机里面应用比较普遍的产品，在Q之后开发出性价比比较高的产品L系列和性能更高的产品R系列，Q将逐步退出历史舞台！Q和L的区别：在中型系统的单机设备应用上，L系列比较适合。像伺服控制、模拟输入输出、高速计数、串行通讯、输入输出等功能上基本和Q一致，但在Q的功能里面，有以下功能L实现不了：1、多CPU系统(L只有通用CPU)；2、与其他品牌的工业网络的兼容性(如PROFIBUS)；3、CC-Link IE Control网络(L只支持CC-Link和CC-Link IE Field)。再说下R系列产品：R是Q的升级产品，以后各种新功能模块的开发也只会在R系列增加，R的产品阵容相对Q更全面，更方便。例如多CPU系统里面如下：运动CPU中，R16MT、R32MT、R64MT支持的轴更多，功能更强大(授权支持G代码和简易4轴机械手控制)；安全CPU的对应选型和应用相对Q更简洁方便(安全CPU加IE网络和远程安全模块)；冗余CPU的对应也更方便和全面(CPU、电源、模块冗余)；通用CPU里面增加了网络一体的CPU(自带3网口，可做通用以太网口或者IE Field网络，最重要的是加量不加价)；所以如果需要配置CC-Link IE的网络，R的性价比比Q要高。另外就是各种模块的升级和增加，例如网络支持PROFINET等。还有就是编程软件的升级，CPU和模块都有自带的FB(好像三菱的FB一致是个槽点)，标签不占用软元件等。另外三菱的通讯，首先看看通讯的分类：硬件连接分类：1、串口(232，485等)2、网线 3、光纤通讯类型分类：1、标准协议(modbus rtu cp)；2、专用网络(CC-Link系列，DP，PN，EIP，DeviceNet，CANopen等)；3、三菱专用协议(MC，SLMP，变频器通讯)；4、无顺序协议(串口RS，socket等)。通讯设备分类：1、PLC和PLC；2、PLC和上位机；3、PLC和机械手；4、PLC和变频；5、PLC和仪表；6、PLC和相机；7、PLC和RFID；8、PLC和伺服；9、PLC和各种智能传感器等(不足的大家继续补充)下面说一个典型的通讯案例，PLC之间数据交换或者组网：通过专用网络(CC-Link，CC-Link IE Field，CC-Link IE Control)，CC-Link是基于串口的网络，支持三菱全系列PLC和最多的第三方设备(机械手、电磁阀等);Field是基于网线的网络，支持FX5U(智能做从站)往上的PLC系列；Control是基于光纤的网络(R系列也可以支持网线)，仅支持Q和R系列PLC。专用网络一般需要增加模块，成本高，速度快，数据量大，稳定性好，错误检测方便。通过本体自带通讯口，FX系列可以通过485实现简单数据交换(支持8台)；中大型PLC可以通过本体自带的以太网口实现数据交换(如两边都是socket，那两边都要做收发程序；一个socket一个MC，那socket一方做收发程序；或者走Modbus/tcp)；最方便的是，如果有L和QUDV系列PLC，那可以采用简单plc通讯和三菱带网口的cpu或者模块轻松的实现plc数据交换。这种自带通讯口的通讯不需要增加模块，成本低，数据量小，速度慢，数据不好校验，稳定性差。至于PLC和其他的产品通讯，原理都差不多。专用网络都是有标准的设置和模式。Modbus rtu/tcp也有自己标准的报文，自带网口的cpu(除QUDE外)都支持Modbus tcp客户端(主站)，FX5U是客户端和服务器(主从)都支持的。如果网口无顺序协议，那就是TCP和UDP socket，之后是active、unpassive、fullpassive了。说到cpu本体自带的以太网口，另外说下其支持的CC-Link IE Field Basic网络(QUDE和FX3除外)，不增加成本的前提下支持伺服连接(JE-CJ4-GF)支持变频器连接(-E)支持远程IO 连接等。FX5U支持7站，L支持16站，QUDV和R支持64站。简单CPU数据交换，L的基本可以和现在所有的以太网cpu或者模块连接本体以太网支持通讯种类CC-Link IE Field Basic网络

因为要再这个文件中设置域名指向自己的主机，才能查看自己本地环境的网站。hosts是一个没有扩展名的系统文件，可以用记事本等工具打开，其作用就是将一些常用的网址域名与其对应的IP地址建立一个关联“数据库”，当用户在浏览器中输入一个需要登录的网址时，系统会首先自动从Hosts文件中寻找对应的IP地址，一旦找到，系统会立即打开对应网页，如果没有找到，则系统会再将网址提交DNS域名解析服务器进行IP地址的解析。

1. 简介首先是Socket.IO的官方网站：http://socket.io官网非常简洁，甚至没有API文档，只有一个简单的“How to use”可以参考。因为Socket.IO就跟官网一样简洁好用易上手。那么Socket.IO到底是什么呢？Socket.IO是一个WebSocket库，包括了客户端的js和服务器端的nodejs，它的目标是构建可以在不同浏览器和移动设备上使用的实时应用。它会自动根据浏览器从WebSocket、AJAX长轮询、Iframe流等等各种方式中选择最佳的方式来实现网络实时应用，非常方便和人性化，而且支持的浏览器最低达IE5.5，应该可以满足绝大部分需求了。2. 安装部署2.1 安装首先安装非常简单，在node.js环境下只要一句：复制代码 代码如下:npm install socket.io2.2 结合express来构建服务器express是一个小巧的Node.js的Web应用框架，在构建HTTP服务器时经常使用到，所以直接以Socket.IO和express为例子来讲解。复制代码 代码如下:var express = require("express") , app = express() , server = require("http").createServer(app) , io = require("socket.io").listen(server);server.listen(3001);若不使用express，请参考socket.io/#how-to-use3. 基本使用方法主要分为服务器端和客户端两段代码，都非常简单。Server（app.js）：复制代码 代码如下://接上面的代码app.get("/", function (req, res) { res.sendfile(__dirname + "/index.html");});io.sockets.on("connection", function (socket) { socket.emit("news", { hello: "world" }); socket.on("other event", function (data) { console.log(data); });});首先io.sockets.on函数接受字符串"connection"作为客户端发起连接的事件，当连接成功后，调用带有socket参数的回调函数。我们在使用socket.IO的时候，基本上都在这个回调函数里面处理用户的请求。socket最关键的是emit和on两个函数，前者提交（发出）一个事件（事件名称用字符串表示），事件名称可以自定义，也有一些默认的事件名称，紧接着是一个对象，表示向该socket发送的内容；后者接收一个事件（事件名称用字符串表示），紧接着是收到事件调用的回调函数，其中data是收到的数据。在上面的例子中，我们发送了news事件和收到了other event事件，那么客户端应该会有对应的接收和发送事件。没错，客户端代码和服务器正好相反，而且非常相似。Client（client.js）复制代码 代码如下:<script src="/socket.io/socket.io.js"></script><script> var socket = io.connect("http://localhost"); socket.on("news", function (data) { console.log(data); socket.emit("other event", { my: "data" }); });</script>有两点要注意的：socket.io.js路径要写对，这个js文件实际放在了服务器端的node_modules文件夹中，在请求这个文件时会重定向，因此不要诧异服务器端不存在这个文件但为什么还能正常工作。当然，你可以把服务器端的socket.io.js这个文件拷贝到本地，使它成为客户端的js文件，这样就不用每次都向Node服务器请求这个js文件，增强稳定性。第二点是要用var socket = io.connect("网站地址或ip");来获取socket对象，接着就可以使用socket来收发事件。关于事件处理，上面的代码表示收到“news”事件后，打印收到的数据，并向服务器发送“other event”事件。注：内置默认的事件名例如“disconnect”表示客户端连接断开，“message”表示收到消息等等。自定义的事件名称，尽量不要跟Socket.IO中内置的默认事件名重名，以免造成不必要的麻烦。4. 其他常用API1).向所有客户端广播：socket.broadcast.emit("broadcast message");2).进入一个房间（非常好用！相当于一个命名空间，可以对一个特定的房间广播而不影响在其他房间或不在房间的客户端）：socket.join("your room name");3).向一个房间广播消息（发送者收不到消息）：socket.broadcast.to("your room name").emit("broadcast room message");4).向一个房间广播消息（包括发送者都能收到消息）（这个API属于io.sockets）：io.sockets.in("another room name").emit("broadcast room message");5).强制使用WebSocket通信：（客户端）socket.send("hi")，（服务器）用socket.on("message", function(data){})来接收。5. 使用Socket.IO构建一个聊天室最后，我们通过一个简单的实例来结束本篇。用Socket.IO构建一个聊天室就是50行左右的代码的事情，实时聊天效果也非常好。以下贴出关键代码：Server（socketChat.js）复制代码 代码如下://一个客户端连接的字典，当一个客户端连接到服务器时，//会产生一个唯一的socketId，该字典保存socketId到用户信息（昵称等）的映射var connectionList = {};exports.startChat = function (io) { io.sockets.on("connection", function (socket) { //客户端连接时，保存socketId和用户名 var socketId = socket.id; connectionList[socketId] = { socket: socket }; //用户进入聊天室事件，向其他在线用户广播其用户名 socket.on("join", function (data) { socket.broadcast.emit("broadcast_join", data); connectionList[socketId].username = data.username; }); //用户离开聊天室事件，向其他在线用户广播其离开 socket.on("disconnect", function () { if (connectionList[socketId].username) { socket.broadcast.emit("broadcast_quit", { username: connectionList[socketId].username }); } delete connectionList[socketId]; }); //用户发言事件，向其他在线用户广播其发言内容 socket.on("say", function (data) { socket.broadcast.emit("broadcast_say",{ username: connectionList[socketId].username, text: data.text }); }); })};Client(socketChatClient.js)复制代码 代码如下:var socket = io.connect("http://localhost");//连接服务器完毕后，马上提交一个“加入”事件，把自己的用户名告诉别人socket.emit("join", { username: "Username hehe"});//收到加入聊天室广播后，显示消息socket.on("broadcast_join", function (data) { console.log(data.username + "加入了聊天室");});//收到离开聊天室广播后，显示消息socket.on("broadcast_quit", function(data) { console.log(data.username + "离开了聊天室");});//收到别人发送的消息后，显示消息socket.on("broadcast_say", function(data) { console.log(data.username + "说: " + data.text);});//这里我们假设有一个文本框textarea和一个发送按钮.btn-send//使用jQuery绑定事件$(".btn-send").click(function(e) { //获取文本框的文本 var text = $("textarea").val(); //提交一个say事件，服务器收到就会广播 socket.emit("say", { username: "Username hehe" text: text });});

.pro文件里添加QT+=network

工程中使用tcp长连接来和服务端进行数据传输，在IOS平台上，由于苹果的后台机制，会有以下问题：当程序退到后台的时候，所有线程被挂起，系统会回收所有的socket资源，那么socket连接就会被关闭，因此无法再进行数据的传输：解决方法：通过设置以下属性可以保持socket连接和数据的继续传输1.需要在Info.plist文件中添加UIBackgroundModes中的VOIP键值；2.设置流属性CFReadStreamRef和CFWriteStreamRef通过如下方法设置kCFStreamNetworkServiceType属性为kCFStreamNetworkServiceTypeVoIP；CFReadStreamSetProperty(theReadStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);CFWriteStreamSetProperty(theWriteStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);NSInputStream 和NSOutputStream通过如下方法设置NSStreamNetworkServiceType属性为NSStreamNetworkServiceTypeVoIP；[self.stream setProperty: NSStreamNetworkServiceTypeVoIP forKey:NSStreamNetworkServiceType];3.这里有一个问题，就是客户端是通过心跳来和服务端保持连接，心跳是由定时器触发的，当我退到后台以后，定时器方法被挂起，那么通过如下设置来在后台运行定时器?123456789101112131415161718192021- (void)applicationDidEnterBackground:(UIApplication*)application{UIApplication* app = [UIApplication sharedApplication]; __block UIBackgroundTaskIdentifier bgTask; bgTask= [app beginBackgroundTaskWithExpirationHandler:^{ dispatch_async(dispatch_get_main_queue(),^{ if(bgTask != UIBackgroundTaskInvalid) { bgTask= UIBackgroundTaskInvalid; } }); }]; dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{ dispatch_async(dispatch_get_main_queue(),^{ if(bgTask != UIBackgroundTaskInvalid) { bgTask= UIBackgroundTaskInvalid; } }); });}

这些是判断当前状态用的，指示 Socket 是否已关闭、已连接、已绑定...如果一个 Socket 只能connect,bound,disconnect,unbound...你觉得它实用吗？程序中对 Socket 的运行状态是很关注的is前缀都是获取某种状态的只读属性

1.现在的主板设计的时候都支持大硬盘，1T或者2T都可以。2.在京东买是可以的，没有社么优劣势之分，只要会看参数就行了。 如果是买西部数据的盘，不要买绿色的就行了。

可以支持。这个主板最初版本的BIOS是23年3月，是最近出的主板，可以直接使用1-5代锐龙处理器，包括R5 5600G在内。这个主板建议搭配8核心及以内CPU合适，12、16核的R9还是不建议用这类入门级主板搭配的。

我在这一步就有问题了ioctlsocket，一直返回-1