socketio编程

A. nodejs的socket.io的广播机制是怎样的

node.js提供了高效的服务端运行环境，但是由于浏览器端对HTML5的支持不一，为了兼容所有浏览器，提供卓越的实时的用户体验，并且为程序员提供客户端与服务端一致的编程体验，于是socket.io诞生。
socket.io设计的目标是支持任何的浏览器，任何Mobile设备。目前支持主流的PC浏览器 (IE,Safari,Chrome,Firefox,Opera等)，Mobile浏览器(iphone Safari/ipad Safari/android WebKit/WebOS WebKit等)。socket.io基于node.js并简化了WebSocket API，统一了通信的API。它支持：WebSocket, Flash Socket, AJAX long-polling, AJAX multipart streaming, Forever IFrame, JSONP polling。
socket.io解决了实时的通信问题，并统一了服务端与客户端的编程方式。启动了socket以后，就像建立了一条客户端与服务端的管道，两边可以互通有无。

B. Socket编程，为什么客户端无法接收来自服务器的数据

如题，我写了段Socket服务器\客户端通讯的程序，服务端能接收到客户端的数据，但是客户端就无法接收到服务端传回的数据，代码如下Server端import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; /** * @author Think * */ public class SocketServer { /** * @param args */ public static void main(String[] args) { new SocketServer().start(); } public void start(){ try { ServerSocket server = new ServerSocket(10086); while(true){ System.out.println("Waiting for a client..."); Socket client = server.accept(); new SocketServerThread(client).start(); } } catch (IOException e) { e.printStackTrace(); } } class SocketServerThread extends Thread{ Socket client = null; public SocketServerThread(Socket client){ this.client = client; } @Override public void run(){ try { // 得到CLIENT的输入流，从输入流出取出传输的数据 BufferedReader reader_from_client = new BufferedReader(new InputStreamReader(client.getInputStream())); String line = null; System.out.print("from client message:"); while((line = reader_from_client.readLine()) != null){ System.out.println(line); } // 得到CLIENT端的输入流，通过向CLIENT传输数据 PrintWriter writer_to_client = new PrintWriter(client.getOutputStream()); writer_to_client.println("Ok"); writer_to_client.flush(); reader_from_client.close(); writer_to_client.close(); client.close(); } catch (IOException e) { } } } } Client
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.InetAddress; import java.net.Socket; /** * @author Think * */ public class SocketClient { /** * @param args */ public static void main(String[] args) { try { Socket remoteServer = new Socket(InetAddress.getLocalHost(), 10086); // 得到SERVER端SOCKET的输出流，通过向输出流写入数据，与SERVER进行通信 PrintWriter write_to_server = new PrintWriter(remoteServer.getOutputStream(), true); write_to_server.write("Hello, what's you name?"); write_to_server.flush(); // 把下面这几行放开，SERVER端就收不到数据了，一直处于阻塞状态 // 得到SERVER端的输出流，从输出流中读取从SERVER传递来的数据 // BufferedReader reader_from_server = new BufferedReader(new InputStreamReader(remoteServer.getInputStream())); // String line = null; // while((line = reader_from_server.readLine()) != null){ // System.out.println(line); // } // reader_from_server.close(); write_to_server.close(); remoteServer.close(); } catch (IOException e) { e.printStackTrace(); } } }如果Client中的说明，只要是Client中放开了
BufferedReader reader_from_server = new BufferedReader(new InputStreamReader(remoteServer.getInputStream())); String line = null; while((line = reader_from_server.readLine()) != null){ System.out.println(line); } reader_from_server.close(); 这段代码，SERVER就阻塞在
while((line = reader_from_client.readLine()) != null){ 这行，不知道是哪个环节理解或处理错了，还望大家指点指点！
即使不关闭连接，也是取不到数据，看了下其它类似的提问，问题在于readLine()会导致阻塞，还在摸索解决的办法！ 问题补充：wgy_superpower 写道第一：Socket编程时，永远不要在关闭写(writer)之前关闭读(reader)
第二：不管是客户端还是服务端在通过Socket读取数据的时候，在你的数据传输完成后，发送一个结束标记(比如:end)，这样在你的 while循环里面判断一下数据是否已经传输完毕，完毕后跳出循环，否则由于你的程序就会一直阻塞在 readLine()这里，因为你的 socket还没有断开，会一直等待你写数据。
你说的有道理，经过后来的试验，确实是因为readLine()一直等待着客户端的输入，但此时客户端也在等待服务端的返回，所以导致两边都在那等待，就阻塞了。
一句话就是，一直【等待写数据】，但又没有数据写入，所以就卡住了。 问题补充：anranran 写道SocketServer : while((line = reader_from_client.readLine()) != null)
这个在socket没有关闭的时候是无法输出来的。
所以Server do not send any data to client嗯，也有道理，但主要不是socket没有关闭，而是没有向流中写数据，而readLine()又一直在那读取，所以就阻塞了！

C. socket编程到底是什么

socket 其实就是操作系统提供给程序员操作“网络协议栈”的接口，说人话就是，你能通过socket 的接口，来控制协议找工作，从而实现网络通信，达到跨主机通信。

协议栈的上半部分有两块，分别是负责收发数据的 TCP 和 UDP 协议，它们两会接受应用层的委托执行收发数据的操作。

协议栈的下面一半是用 IP 协议控制网络包收发操作，在互联网上传数据时，数据会被切分成一块块的网络包，而将网络包发送给对方的操作就是由 IP 负责的。这里需要注意的是，服务端调用 accept 时，连接成功了会返回一个已完成连接的 socket，后续用来传输数据。

所以，监听的 socket 和真正用来传送数据的 socket，是“两个” socket，一个叫作监听 socket，一个叫作已完成连接 socket。成功连接建立之后，双方开始通过 read 和 write 函数来读写数据，就像往一个文件流里面写东西一样。

D. 如何为可扩展系统进行Socket编程

Java I/O示例第部：HTTP客户端 通简短例看何执行HTTP GET获取HTTP服务HTTP比本例更加复杂熟我写客户端代码处理简单案例发请求服务器端获取资源同服务器端返响应并关闭流本案例所需步骤： 创建端口80中国络服务器所应客户端Socket 服务器端获取PrintStream同发送GET PATH HTTP/1.0请求其PATH服务器请求资源比假设想打中国站根目录path / 获取服务器端InputStream用BufferedReader其包装按行读取响应 列表1、 SimpleSocketClientExample.java package 中国.geekcap.javaworld.simplesocketclient; import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintStream; import java中国.Socket; public class SimpleSocketClientExample { public static void main( String[] args ) { if( args.length < 2 ) { System.out.println( "Usage: SimpleSocketClientExample " ); System.exit( 0 ); } String server = args[ 0 ]; String path = args[ 1 ]; System.out.println( "Loading contents of URL: " + server ); try { // 创建与端口80中国络服务器应客户端socket Socket socket = new Socket( server, 80 ); //服务器端获取PrintStream PrintStream out = new PrintStream( socket.getOutputStream() ); //获取服务器端InputStream用BufferedReader其包装 BufferedReader in = new BufferedReader( new InputStreamReader( socket.getInputStream() ) ); //发送GET PATH HTTP/1.0请求服务器端 out.println( "GET " + path + " HTTP/1.0" ); out.println(); //按行读取服务器端返响应数据 String line = in.readLine(); while( line != null ) { System.out.println( line ); line = in.readLine(); } // 关闭流 in.close(); out.close(); socket.close(); } catch( Exception e ) { e.printStackTrace(); } } } 列表1接受两命令行参数：需要连接服务器需要取资源创建Socket指向服务器端并且显式其指定端口号80接着程序指向命令： GET PATH HTTP/1.0 比 GET / HTTP/1.0 顶部 程发 准备web服务器获取中国页比 中国google中国 HTTP client利用DNS服务器获取服务器址：高域名服务器始查询中国域名哪存 中国google中国 权威域名服务器接着 HTTP client询问域名服务器 中国google中国 IP址接打Socket通向端口80服务器 HTTP Client执行特定HTTP比GET、POST、PUT、DELETE、HEAD 或者OPTI/ONS每种都自语述代码列表GET面依需要path、HTTP/版本号、空行想加入 HTTP headers我必须进入新行前完 列表1获取 OutputStream并用 PrintStream 包装我能容易执行基于文本命令 同 InputStream 获取代码InputStreamReader 包装流转化Reader再用 BufferedReader 包装我能用PrintStream执行GET用BufferedReader 按行读取响应直获取响应 null 结束关闭Socket 现我执行类传入参数： java 中国.geekcap.javaworld.simplesocketclient.SimpleSocketClientExample 中国javaworld中国 / 应该能够看类似面输： Loading contents of URL: 中国javaworld中国 HTTP/1.1 200 OK Date: Sun, 21 Sep 2014 22:20:13 GMT Server: Apache X-Gas_TTL: 10 Cache-Control: max-age=10 X-GasHost: gas2.usw X-Cooking-With: Gasoline-Local X-Gasoline-Age: 8 Content-Length: 168 Last-Modified: Tue, 24 Jan 2012 00:09:09 GMT Etag: "60001b-a8-4b73af4bf3340" Content-Type: text/html Vary: Accept-Encoding Connection: close

Success 本输显示JavaWorld中国站测试页面中国页HTTP version 1.1响应200 OK. Java I/O示例第二部：HTTP服务器 刚才我说客户端幸运服务器端通信容易简单视角看处理程: 创建ServerSocket并指定监听端口 调用 ServerSocket accept() 监听自客户端连接 旦客户端连接服务器accept() 通服务器与客户端通信返Socket客户端用同Socket类处理程相同获取 InputStream 读取客户端信息OutputStream 写数据客户端 服务器需要扩展需要Socket传给其线程处理服务器持续监听连接 再调用 ServerSocket accept() 监听其连接 所看NIO处理场景略同直接创建ServerSocket并端口号传给用于监听（关于 ServerSocketFactory 更信息面讨论）： ServerSocket serverSocket = new ServerSocket( port ); 通 accept() 接收传入连接： Socket socket = serverSocket.accept(); // 处理连接…… 顶部 线程Socket编程 列表2所服务器代码放起组更加健壮例本例线程处理请求服务器ECHO服务器说所接收消息返 列表2例复杂已经提前介绍部NIO内容线程代码花费些精力构建处理并发请求服务器 列表2、SimpleSocketServer.java package 中国.geekcap.javaworld.simplesocketclient; import java.io.BufferedReader; import java.io.I/OException; import java.io.InputStreamReader; import java.io.PrintWriter; import java中国.ServerSocket; import java中国.Socket; public class SimpleSocketServer extends Thread { private ServerSocket serverSocket; private int port; private boolean running = false; public SimpleSocketServer( int port ) { this.port = port; } public void startServer() { try { serverSocket = new ServerSocket( port ); this.start(); } catch (I/OException e) { e.printStackTrace(); } } public void stopServer() { running = false; this.interrupt(); } @Override public void run() { running = true; while( running ) { try { System.out.println( "Listening for a connection" ); // 调用 accept() 处理连接 Socket socket = serverSocket.accept(); // 向 RequestHandler 线程传递socket象进行处理 RequestHandler requestHandler = new RequestHandler( socket ); requestHandler.start(); } catch (I/OException e) { e.printStackTrace(); } } } public static void main( String[] args ) { if( args.length == 0 ) { System.out.println( "Usage: SimpleSocketServer " ); System.exit( 0 ); } int port = Integer.parseInt( args[ 0 ] ); System.out.println( "Start server on port: " + port ); SimpleSocketServer server = new SimpleSocketServer( port ); server.startServer(); // 1钟自关闭 try { Thread.sleep( 60000 ); } catch( Exception e ) { e.printStackTrace(); } server.stopServer(); } } class RequestHandler extends Thread { private Socket socket; RequestHandler( Socket socket ) { this.socket = socket; } @Override public void run() { try { System.out.println( "Received a connection" ); // 获取输入输流 BufferedReader in = new BufferedReader( new InputStreamReader( socket.getInputStream() ) ); PrintWriter out = new PrintWriter( socket.getOutputStream() ); // 向客户端写信息 out.println( "Echo Server 1.0" ); out.flush(); // 向客户端写信息直客户端关闭连接或者收空行 String line = in.readLine(); while( line != null && line.length() > 0 ) { out.println( "Echo: " + line ); out.flush(); line = in.readLine(); } // 关闭自连接 in.close(); out.close(); socket.close(); System.out.println( "Connection closed" ); } catch( Exception e ) { e.printStackTrace(); } } } 列表2我创建新 SimpleSocketServer 实例并启服务器继承 Thread SimpleSocketServer 创建新线程处理存于 run() 阻塞 accept() 调用 run() 存循环用接收客户端请求并创建RequestHandler线程处理些请求再强调相简单编程涉及相线程编程 RequestHandler 处理客户端通信代码与列表1相似：PrintStream 包装 OutputStream 更容易进行写操作同 BufferedReader 包装InputStream 更易于读取要服务器跑RequestHandler 客户端信息按行读取并返给客户端客户端发空行结束RequestHandler 关闭Socke

E. 什么是socket网络编程

使用socket套接字，利用TCP/IP或者UDP协议，实现几个机器之间的通信。一般使用C/S结构。
以TCP/IP为例:首先建立一个服务器，步骤如下:socket()创建一个socket，bind()绑定socket到一个端口，listen()监听端口，accept()等待客户端的连接。客户端程序:socket()创建一个socket，可以绑定也可以不绑定，然后connect()连接到服务器端。socket又分为阻塞式的和非阻塞式的。阻塞式的就是服务器端等待连接直到连接上，不然一直挂起。

F. 什么是socket编程

socket 就是插座， 你想啊一旦插上插座线路就通了， 信息就可以传送了， socket携带了你要发送的数据。
所谓socket编程， 就是调用系统提供的封装好的socket API 实现底层的网络通信， 具体的话您可以去看看这个：
http://ke..com/view/13870.htm

G. 怎样用C语言做socket网络编程

mfc只是对socket进行了一些封装，大部分人做网络编程都是用的原始的socket，比如如下接口都可以在c下进行调用
1.socket()
2.bind()
3.connect()
4.listen()
5.accept()
6.send() 和recv()
7.sendto() 和recvfrom()
8.close() 和shutdown()
9.getpeername()
10.gethostname()
这些接口是在Winsock2.h中定义的不是在mfc中定义的，你只需要包含Winsock2.h头文件和Ws2_32.lib库就可以了。

H. socket.io node.js 可以负载均衡吗

我们在用 Node.js 处理知乎主站的 web 实时推送。你现在看到的 Feed 、消息的实时更新，背后就是几个 node 进程扛起来的。

优点：

1. 处理高并发场景性能更高

在用 socket.io 之前，推送服务是用 ajax polling 做的。我们用 Tornado 和 Node.js 做过两个版本的推送服务。在当时的测试环境下，Node.js 的 CPU 时间是 Tornado 的三分之一，内存使用是 Tornado 的一半，代码行数只有 Tornado 的三分之一（Node.js 版是用 coffee 写的）。后来我们使用了 socket.io，CPU 开销进一步降低。

2. 函数式编程非常适合写异步回调链

用 Node.js 配合 CoffeeScript 写异步操作链非常便利，相比之下 Tornado 无论是写命名函数的回调，还是 yield 一个 Task 都没那么自然。

缺点：

1. 大量匿名函数使异常栈变得不好看。
2. 无法以 request 为单位 catch 异常，必须确保不要在不 catch 异常的第三方库的回调里的抛异常，这在一个异步操作链条里是一件比较麻烦的事。解决方法之一是对那些不 catch 异常的第三方库做一些封装，把所有的异常变成事件，改成 on('error') 形式的 API。

I. 请问Socket编程的基本步骤是怎样的最好能写一个简单的程序Java演示一下，主要是接受数据。谢谢！

SERVER端：
--------------------------------------------------------
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;

{
privateSocketclientSocket;

publicServer(SocketclientSocket){
this.clientSocket=clientSocket;
}

publicvoidrun(){
DataInputStreamdis=null;
DataOutputStreamdos=null;

try{
dis=newDataInputStream(clientSocket.getInputStream());
dos=newDataOutputStream(clientSocket.getOutputStream());

while(true){
Stringtemp=dis.readUTF();
if("over".equals(temp)){
break;
}
dos.writeUTF("fromserver:"+temp);
}

}catch(Exceptione){
e.printStackTrace();
}finally{
try{
if(dis!=null){
dis.close();
}
if(dis!=null){
dos.close();
}

if(clientSocket!=null){
clientSocket.close();
}
}catch(IOExceptione){
}
}
}

publicstaticvoidmain(String[]args)throwsException{
ServerSocketss=newServerSocket(8008);
while(true){
SocketclientSocket=ss.accept();
//针对每个客户端,启一个Server线程专门处理此客户端的请求。
Serverserver=newServer(clientSocket);
server.start();
}

}

}

CLIENT端：
----------------------------------------
importjava.io.BufferedReader;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.InputStreamReader;
importjava.net.Socket;

publicclassClient{

publicstaticvoidmain(String[]args)throwsException{
//输入流1,从键盘进入Client。
InputStreamReaderisr=newInputStreamReader(System.in);
BufferedReaderbr=newBufferedReader(isr);

SocketclientSocket=newSocket("127.0.0.1",8008);

//输入流2,从服务器端进入Client的流对象。
DataInputStreamdis=newDataInputStream(clientSocket.getInputStream());

//输出流,从Client出去,到服务器端。
DataOutputStreamdos=newDataOutputStream(clientSocket.getOutputStream());

while(true){
//从键盘输入读取
Stringmsg=br.readLine();

//将读取信息发送给服务器端
dos.writeUTF(msg);

//输入QUIT退出
if("QUIT".equals(msg)){
break;
}

//读取从服务器返回的信息
Stringtemp=dis.readUTF();
System.out.println(temp);
}

br.close();
dis.close();
dos.close();
clientSocket.close();
}
}