HTTP协议,快速简单、灵活、无连接、无状态,同时具有如下弊端:
1> HTTP协议是半双工的协议,半双工协议是指可以在客户端和服务端两个方向上传输,但不能同时传输。这意味着同一时刻只有一个方向上的数据传输。
2> HTTP消息冗长而繁琐,包括消息头、消息体、换行符等。通常情况下采用文本方式传输,相比其他二进制的通信协议,冗长而繁琐。
3> 针对于服务器推送的黑客攻击,如长时间轮询,浏览器不断向服务器发出请求,然而HTTP request的Header是非常冗长的,里面包含的可用数据比例可能非常低,这会占用很多带宽资源和服务器资源。
附: HTTP1.1与HTTP1.0的比较: http://www.voidcn.com/blog/elifefly/article/p-1180220.html
Websocket,是一种浏览器与服务器进行全双工通信的网络协议,是HTML5中最让人兴奋的功能特性之一。在websocket API中,浏览器和服务器只需要做一个握手的动作,两者形成了一条快速通道,可以直接相互传送数据。具有以下特点:
1> 单一的TCP连接,采用全双工模式通信。
2> 无头部信息、cookie和身份验证
3> 无安全开销
4> 服务器可以主动传递消息给客户端,不需要客户端轮询
连接建立
通过HTTP协议建立握手连接,在接连建立后,真正的数据传输阶段是不需要HTTP协议参与的。典型的WebSocket握手如下:
这段HTTP请求较之普通的HTTP,多了Connection:Upgrade和Upgrade:websocket两个Request Header,表明这是一个升级版的HTTP——WebSocket
Sec-WebSocket-Key是一个base64 encode值,这个是浏览器随机生成的,服务器会根据这些数据构造一个SHA-1的信息摘要,将其值放入sec-websocket-accept中返回给客户端。服务器返回如上图Response Headers所示。表示成功建立Socket啦。
连接关闭
客户端和服务端通过一个安全的方法关闭底层TCP连接和TLS会话。底层的TCP连接,在正常情况下,应该首先由服务器关闭,异常情况下客户端可以发起TCP Close。当服务器被指使关闭websocket连接时,它应该立即发起一个TCP Close,客户端应等待服务器的TCP Close。
目前主流浏览器如Chrome、FireFox、IE10、Opera10、Safari等都已经支持WebSocket,服务端也出现了一些不错的WebSocket项目如Netty、Resin、Jetty7、pywebsocket等。下面的例子,通过Netty实现WebSocket服务端,用JavaScript实现WebSocket客户端。
WebSocket服务端
package demo.websocket;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;
public class WebSocketServer {
private final EventLoopGroup workerGroup = new NioEventLoopGroup();
private final EventLoopGroup bossGroup = new NioEventLoopGroup();
public void run() {
ServerBootstrap boot = new ServerBootstrap();
boot.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<Channel>() {
protected void initChannel(Channel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// 将请求和应答的消息编码或者解码为HTTP消息
pipeline.addLast("http-codec", new HttpServerCodec());
// 将HTTP消息的多个部分组合成一条完整的HTTP消息
pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
// 向客户端发送HTML5文件,主要用于支持浏览器和服务端进行websocket通信
pipeline.addLast("http-chunked", new ChunkedWriteHandler());
// 消息的Handler处理类
pipeline.addLast("handler", new WebSocketServerHandler());
}
});
try {
// 绑定端口来接受连接
ChannelFuture f = boot.bind(2048).sync();
System.out.println("websocket server start at port: 2048");
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
/**
* Main函数
*/
public static void main(String[] args) {
new WebSocketServer().run();
}
}
package demo.websocket;
import java.util.List;
import java.util.Map.Entry;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;
public class WebSocketServerHandler extends ChannelHandlerAdapter {
private WebSocketServerHandshaker handshaker;
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// HTTP接入,WebSocket第一次连接使用HTTP连接,用于握手
// HTTP握手完成后,才是WebSocket下的通信
if (msg instanceof FullHttpRequest) {
handleHttpRequest(ctx, (FullHttpRequest) msg);
}
// Websocket 接入
else if (msg instanceof WebSocketFrame) {
handleWebSocketFrame(ctx, (WebSocketFrame) msg);
}
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
HttpHeaders headers = req.headers();
List<Entry<CharSequence, CharSequence>> list = headers.entries();
for(Entry<CharSequence, CharSequence> entity : list){
System.out.println("header " + entity.getKey() + ": " + entity.getValue());
}
// WebSocket 通过"Upgrade handshake(升级握手)"从标准的 HTTP 或HTTPS 协议转为 WebSocket
// 屏蔽掉 不是 WebSocket握手的请求
if (!req.decoderResult().isSuccess() || !("websocket".equals(req.headers().get("Upgrade")))) {
sendHttpResponse(ctx, req,
new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
return;
}
WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://localhost:2048/ws",
null, false);
handshaker = wsFactory.newHandshaker(req);
// 无法处理的WebSocket版本
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
} else {
// 向客户端发送WebSocket握手,完成握手
// 客户端收到的status是101 Switching Protocols
handshaker.handshake(ctx.channel(), req);
}
}
private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, DefaultFullHttpResponse res) {
// 返回应答给客户端
if (res.status().code() != 200) {
ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(), CharsetUtil.UTF_8);
res.content().writeBytes(buf);
buf.release();
}
// 如果是非Keep-Alive,关闭连接
ChannelFuture f = ctx.channel().writeAndFlush(res);
if (!isKeepAlive(req) || res.status().code() != 200) {
f.addListener(ChannelFutureListener.CLOSE);
}
}
private static boolean isKeepAlive(FullHttpRequest req) {
return false;
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
// 判断是否关闭链路的指令
if (frame instanceof CloseWebSocketFrame) {
handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
return;
}
// 判断是否ping消息
if (frame instanceof PingWebSocketFrame) {
ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
return;
}
// 本例程不支持二进制消息
if (frame instanceof BinaryWebSocketFrame) {
throw new UnsupportedOperationException(
String.format("%s frame types not supported", frame.getClass().getName()));
}
// 文本消息
if (frame instanceof TextWebSocketFrame) {
// 返回应答消息
String request = ((TextWebSocketFrame) frame).text();
System.out.println("服务端收到: " + request);
ctx.channel().write(new TextWebSocketFrame("服务器收到并返回:" + request));
}
}
}
JavaScript客户端 websocket.html
运行Main方法,启动服务端,打开websocket.html,试一下效果。