websocket(三)进阶!netty框架实现websocket达到⾼并发引⾔:
在前⾯两篇⽂章中,我们对原⽣websocket进⾏了了解,且⽤demo来简单的讲解了其⽤法。但是在实际项⽬中,那样的⽤法是不可取的,理由是tomcat对⾼并发的⽀持不怎么好,特别是tomcat9之前,可以测试发现websocket连接达到的数量很低,且容易断开。
所以有现在的第三篇,对websocket的⼀种进阶⽅法。
什么是Netty
Netty是业界最流⾏的NIO框架之⼀,它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是⾸屈⼀指的,它已经得到成百上千的商⽤项⽬验证,例如Hadoop的RPC框架Avro就使⽤了Netty作为底层通信框架,其他还有业界主流的RPC框架,也使⽤Netty来构建⾼性能的异步通信能⼒。
通过对Netty的分析,我们将它的优点总结如下:
API使⽤简单,开发门槛低;
功能强⼤,预置了多种编解码功能,⽀持多种主流协议;
定制能⼒强,可以通过ChannelHandler对通信框架进⾏灵活地扩展;
性能⾼,通过与其他业界主流的NIO框架对⽐,Netty的综合性能最优;
成熟、稳定,Netty修复了已经发现的所有JDK NIO BUG,业务开发⼈员不需要再为NIO的BUG⽽烦恼;
社区活跃,版本迭代周期短,发现的BUG可以被及时修复,同时,更多的新功能会加⼊;
经历了⼤规模的商业应⽤考验,质量得到验证。Netty在互联⽹、⼤数据、⽹络游戏、企业应⽤、电信软件等众多⾏业已经得到了成功商⽤,证明它已经完全能够满⾜不同⾏业的商业应⽤了。
基于Netty的websocket压⼒测试
Demo详解
1.导⼊netty包
<!-- netty -->
<dependency>
<groupId>ioty</groupId>
<artifactId>netty-all</artifactId>
<version>5.0.0.Alpha1</version>
</dependency>
2.server启动类
以下,注解是标注spring启动时启动的注解,新开⼀个线程去开启netty服务器端⼝。
package comtywebsocket;
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Service;
import ioty.bootstrap.ServerBootstrap;
import ioty.channel.Channel;
import ioty.channel.EventLoopGroup;
import ioty.channel.nio.NioEventLoopGroup;
import ioty.channel.socket.nio.NioServerSocketChannel;
/**
* ClassName:NettyServer 注解式随spring启动
* Function: TODO ADD FUNCTION.
* @author hxy
*/
@Service
public class NettyServer {
public static void main(String[] args) {
new NettyServer().run();
}
@PostConstruct
public void initNetty(){
new Thread(){
public void run() {
new NettyServer().run();
}
}.start();
}
public void run(){
System.out.println("===========================Netty端⼝启动========");
/
/ Boss线程:由这个线程池提供的线程是boss种类的,⽤于创建、连接、绑定socket,(有点像门卫)然后把这些socket传给worker线程池。
// 在服务器端每个监听的socket都有⼀个boss线程来处理。在客户端,只有⼀个boss线程来处理所有的socket。
EventLoopGroup bossGroup = new NioEventLoopGroup();
// Worker线程:Worker线程执⾏所有的异步I/O,即处理操作
EventLoopGroup workGroup = new NioEventLoopGroup();
try {
// ServerBootstrap 启动NIO服务的辅助启动类,负责初始话netty服务器,并且开始监听端⼝的socket请求
ServerBootstrap b = new ServerBootstrap();
/
/ 设置⾮阻塞,⽤它来建⽴新accept的连接,⽤于构造serversocketchannel的⼯⼚类
b.channel(NioServerSocketChannel.class);
// ChildChannelHandler 对出⼊的数据进⾏的业务操作,其继承ChannelInitializer
b.childHandler(new ChildChannelHandler());
System.out.println("服务端开启等待客户端连接 ... ...");
Channel ch = b.bind(7397).sync().channel();
ch.closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
}finally{
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
}
}
}
3.channle注册类
package comtywebsocket;
import ioty.channel.ChannelInitializer;
import ioty.channel.socket.SocketChannel;
import dec.http.HttpObjectAggregator;
import dec.http.HttpServerCodec;
import dec.http.websocketx.WebSocketServerProtocolHandler;
import ioty.handler.stream.ChunkedWriteHandler;
/**
* ClassName:ChildChannelHandler
* Function: TODO ADD FUNCTION.
* @author hxy
*/
public class ChildChannelHandler extends ChannelInitializer<SocketChannel>{
@Override
protected void initChannel(SocketChannel e) throws Exception {
// 设置30秒没有读到数据,则触发⼀个READER_IDLE事件。
// pipeline.addLast(new IdleStateHandler(30, 0, 0));
/
/ HttpServerCodec:将请求和应答消息解码为HTTP消息
e.pipeline().addLast("http-codec",new HttpServerCodec());
// HttpObjectAggregator:将HTTP消息的多个部分合成⼀条完整的HTTP消息
e.pipeline().addLast("aggregator",new HttpObjectAggregator(65536));
// ChunkedWriteHandler:向客户端发送HTML5⽂件
e.pipeline().addLast("http-chunked",new ChunkedWriteHandler());
// 在管道中添加我们⾃⼰的接收数据实现⽅法
e.pipeline().addLast("handler",new MyWebSocketServerHandler());
}
}
4.存储类
以下类是⽤来存储访问的channle,channelGroup的原型是set集合,保证channle的唯⼀,如需根据参数标注存储,可以使⽤currentHashMap来存储。
package comtywebsocket;
import up.ChannelGroup;
import up.DefaultChannelGroup;
import urrent.GlobalEventExecutor;
/**
* ClassName:Global
* Function: TODO ADD FUNCTION.
* @author hxy
*/
public class Global {
public static ChannelGroup group = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
}
5.实际处理类
以下处理类虽然做了注释,但是在这⾥还是详细讲解下。
1. 这个类是单例的,每个线程处理会新实例化⼀个类。
2. 每个成功的线程访问顺序:channelActive(开启连接)-handleHttpRequest(http握⼿处理)-messageReceived(消息接收处理)-
handlerWebSocketFrame(实际处理,可以放到其他类⾥⾯分业务进⾏)
3. 注意:这个demo中我做了路由功能,在handleHttpRequest中对每个channel连接的时候对每个连接的url进⾏绑定参数,然后在
messageReceived中获取绑定的参数进⾏分发处理(handlerWebSocketFrame或handlerWebSocketFrame2),同时也获取了uri后置参数,有注释。
4. 针对第三点路由分发,还有⼀种⽅法就是handshaker的uri()⽅法,看源码即可,简单好⽤。
5. 发的时候遍历集合或者map的时候,必须每个channle都实例化⼀个TextWebSocketFrame对象,否则会报错或者发不出。
package comtywebsocket;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import ioty.buffer.ByteBuf;
import ioty.buffer.Unpooled;
import ioty.channel.ChannelFuture;
import ioty.channel.ChannelFutureListener;
import ioty.channel.ChannelHandlerContext;
import ioty.channel.SimpleChannelInboundHandler;
import dec.http.DefaultFullHttpResponse;
import dec.http.FullHttpRequest;
import dec.http.HttpHeaders;
import dec.http.HttpMethod;
import dec.http.HttpResponseStatus;
import dec.http.HttpVersion;
import dec.http.QueryStringDecoder;
import dec.http.websocketx.CloseWebSocketFrame;
import dec.http.websocketx.PingWebSocketFrame;
import dec.http.websocketx.PongWebSocketFrame;
import dec.http.websocketx.TextWebSocketFrame;
import dec.http.websocketx.WebSocketFrame;
import dec.http.websocketx.WebSocketServerHandshaker;
import dec.http.websocketx.WebSocketServerHandshakerFactory;
import ioty.util.AttributeKey;
import ioty.util.CharsetUtil;
/**
* ClassName:MyWebSocketServerHandler Function: TODO ADD FUNCTION.
*
* @author hxy
*/
public class MyWebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
private static final Logger logger = Logger(Name());
private WebSocketServerHandshaker handshaker;
/**
* channel 通道 action 活跃的当客户端主动链接服务端的链接后,这个通道就是活跃的了。也就是客户端与服务端建⽴了通信通道并且可以传输数据
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// 添加
System.out.println("客户端与服务端连接开启:" + ctx.channel().remoteAddress().toString());
}
/**
* channel 通道 Inactive 不活跃的当客户端主动断开服务端的链接后,这个通道就是不活跃的。也就是说客户端与服务端关闭了通信通道并且不可以传输数据
*/
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
// 移除
System.out.println("客户端与服务端连接关闭:" + ctx.channel().remoteAddress().toString());
}
/**
* 接收客户端发送的消息 channel 通道 Read 读简⽽⾔之就是从通道中读取数据,也就是服务端接收客户端发来的数据。但是这个数据在不进⾏解码时它是ByteBuf类型的*/
@Override
protected void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
// 传统的HTTP接⼊
if (msg instanceof FullHttpRequest) {
handleHttpRequest(ctx, ((FullHttpRequest) msg));
// WebSocket接⼊
} else if (msg instanceof WebSocketFrame) {
System.out.println(handshaker.uri());
if("anzhuo".equals(ctx.attr(AttributeKey.valueOf("type")).get())){
handlerWebSocketFrame(ctx, (WebSocketFrame) msg);
}else{
handlerWebSocketFrame2(ctx, (WebSocketFrame) msg);
}
}
}
/**
* channel 通道 Read 读取 Complete 完成在通道读取完成后会在这个⽅法⾥通知,对应可以做刷新操作 ctx.flush()
*/
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
private void handlerWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
// 判断是否关闭链路的指令
if (frame instanceof CloseWebSocketFrame) {
System.out.println(1);
handshaker.close(ctx.channel(), (CloseWebSocketFrame) ain());
return;
}
// 判断是否ping消息
if (frame instanceof PingWebSocketFrame) {
ctx.channel().write(new t().retain()));
return;
}
// 本例程仅⽀持⽂本消息,不⽀持⼆进制消息
if (!(frame instanceof TextWebSocketFrame)) {
System.out.println("本例程仅⽀持⽂本消息,不⽀持⼆进制消息");
throw new UnsupportedOperationException(
String.format("%s frame types not supported", Class().getName()));
}
// 返回应答消息
String request = ((TextWebSocketFrame) frame).text();
System.out.println("服务端收到:" + request);
if (logger.isLoggable(Level.FINE)) {websocket和socket
logger.fine(String.format("%s received %s", ctx.channel(), request));
}
TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString() + ctx.channel().id() + ":" + request); // 发
// 返回【谁发的发给谁】
// ctx.channel().writeAndFlush(tws);
}
private void handlerWebSocketFrame2(ChannelHandlerContext ctx, WebSocketFrame frame) {
// 判断是否关闭链路的指令
if (frame instanceof CloseWebSocketFrame) {
handshaker.close(ctx.channel(), (CloseWebSocketFrame) ain());
return;
}
// 判断是否ping消息
if (frame instanceof PingWebSocketFrame) {
ctx.channel().write(new t().retain()));
return;
}
// 本例程仅⽀持⽂本消息,不⽀持⼆进制消息
if (!(frame instanceof TextWebSocketFrame)) {
System.out.println("本例程仅⽀持⽂本消息,不⽀持⼆进制消息");
throw new UnsupportedOperationException(
String.format("%s frame types not supported", Class().getName()));
}
// 返回应答消息
String request = ((TextWebSocketFrame) frame).text();
System.out.println("服务端2收到:" + request);
if (logger.isLoggable(Level.FINE)) {
logger.fine(String.format("%s received %s", ctx.channel(), request));
}
TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString() + ctx.channel().id() + ":" + request); // 发
// 返回【谁发的发给谁】
// ctx.channel().writeAndFlush(tws);
}
private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
// 如果HTTP解码失败,返回HHTP异常
if (!DecoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) { sendHttpResponse(ctx, req,
new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
return;
}
//获取url后置参数
HttpMethod Method();
String Uri();
QueryStringDecoder queryStringDecoder = new QueryStringDecoder(uri);
Map<String, List<String>> parameters = queryStringDecoder.parameters();
System.out.("request").get(0));
if(method==HttpMethod.GET&&"/webssss".equals(uri)){
//....处理
ctx.attr(AttributeKey.valueOf("type")).set("anzhuo");
}else if(method==HttpMethod.GET&&"/websocket".equals(uri)){
/
/...处理
ctx.attr(AttributeKey.valueOf("type")).set("live");
}
// 构造握⼿响应返回,本机测试
WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
"ws://"+req.headers().get(HttpHeaders.Names.HOST)+uri, null, false);
handshaker = wHandshaker(req);
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
} else {
handshaker.handshake(ctx.channel(), req);
}
}
private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, DefaultFullHttpResponse res) {
// 返回应答给客户端
if (Status().code() != 200) {
ByteBuf buf = Status().toString(), CharsetUtil.UTF_8);
}
// 如果是⾮Keep-Alive,关闭连接
ChannelFuture f = ctx.channel().writeAndFlush(res);
if (!HttpHeaders.isKeepAlive(req) || Status().code() != 200) {
f.addListener(ChannelFutureListener.CLOSE);
}
}
/**
* exception 异常 Caught 抓住抓住异常,当发⽣异常的时候,可以做⼀些相应的处理,⽐如打印⽇志、关闭链接
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
以上就是netty-websocket的Demo了,应该已经解释的很详细了,同时应对的并发量也满⾜⼀般企业⽤于websocket的连接,如果需要不够,可以⽤nginx负载均衡增加。
最后给⼤家⼀条建议,在实际项⽬中,别让这种长连接⼀直保持,在nginx中可以设置连接⽆交流超时断开,⼤概设置10分钟左右,然后每8分钟定时从服务端发送⼀条⼼跳,具体想法就看你们喽~
版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198,我们将在24小时内删除。
发表评论