Netty实现WebSocket通信

最新推荐文章于 2024-07-31 20:40:14 发布
最新推荐文章于 2024-07-31 20:40:14 发布
阅读量5.1k 收藏 4
点赞数
分类专栏： java websocket 文章标签： netty  websocket

服务端要实现websocket，编解码器中必须加入对websocket的支持

ChannelInitializer的initChannel方法实现

@Override
protected void initChannel(SocketChannel channel) throws Exception {
	try {
		ChannelPipeline pipeline = channel.pipeline();
		pipeline.addLast("httpServerCodec", new HttpServerCodec());
		pipeline.addLast("chunkedWriteHandler", new ChunkedWriteHandler());
		pipeline.addLast("httpObjectAggregator", new HttpObjectAggregator(8192));
		pipeline.addLast("webSocketServerProtocolHandler",
				(ChannelHandler) new WebSocketServerProtocolHandler("/ws"));
		pipeline.addLast((ChannelOutboundHandlerAdapter) (自己的消息编码器));
		pipeline.addLast(消息处理器);
	} catch (Exception e) {
		e.printStackTrace();
		throw e;
	}
}

WebSocketServerProtocolHandler中实现了对websocket的封装，不用我们去考虑握手的问题，构造器要传入一个路径参数，客户端访问时要加入这个参数，如ws://ip:port/ws

如果要求部署在https环境下，则服务端要加入对ssl链接的支持

	@Override
	protected void initChannel(SocketChannel channel) throws Exception {
		try {
			ChannelPipeline pipeline = channel.pipeline();
			if (sslFilePath != null) {
				SSLContext sslContext = SslUtil.createSSLContext(keyType, sslFilePath, keyPassword);
				// SSLEngine 此类允许使用ssl安全套接层协议进行安全通信
				SSLEngine engine = sslContext.createSSLEngine();
				engine.setUseClientMode(false);
				pipeline.addLast("ssl",new SslHandler(engine));
//				pipeline.addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));
			}
			pipeline.addLast("httpServerCodec", new HttpServerCodec());
			pipeline.addLast("chunkedWriteHandler", new ChunkedWriteHandler());
			pipeline.addLast("httpObjectAggregator", new HttpObjectAggregator(8192));
			pipeline.addLast("webSocketServerProtocolHandler", .....
	/**
	 * 创建 SSL上下文
	 * @param type 证书类型， java中它的值是JKS
	 * @param path 证书的本地路径，jks文件路径
	 * @param password 证书密钥
	 * @return
	 * @throws Exception
	 */
	public static SSLContext createSSLContext(String type ,String path ,String password) throws Exception {
	    KeyStore ks = KeyStore.getInstance(type); /// "JKS"
	    InputStream ksInputStream = new FileInputStream(path); /// 证书存放地址
	    try{
		    ks.load(ksInputStream, password.toCharArray());
		 	//KeyManagerFactory充当基于密钥内容源的密钥管理器的工厂。
		    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());//getDefaultAlgorithm:获取默认的 KeyManagerFactory 算法名称。
		    kmf.init(ks, password.toCharArray());
		    //SSLContext的实例表示安全套接字协议的实现，它充当用于安全套接字工厂或 SSLEngine 的工厂。
		    SSLContext sslContext = SSLContext.getInstance("TLS");
		    sslContext.init(kmf.getKeyManagers(), null, null);
		    return sslContext;
	    }finally{
	    	if(ksInputStream != null){
	    		try{
	    			ksInputStream.close();
	    		}catch(Exception e){}
	    	}
	    }
	}
}

 阿里云申请的证书中有这些文件

需要把pfx文件转化成.jks文件

 

将PFX格式证书转换为JKS格式

您可以使用JDK中自带的Keytool工具，将PFX格式证书文件转换成JKS格式。例如，您可以执行以下命令将 server.pfx证书文件转换成 server.jks证书文件：

keytool -importkeystore -srckeystore D:\server.pfx -destkeystore D:\server.jks
        -srcstoretype PKCS12 -deststoretype JKS

证书介绍

websocket服务器的访问地址会有变化, wss://ip:port/ws

 

netty客户端实现websocket通信

netty也有对websocket客户端封装好的解码器，但不会用，这里通过netty自带的demo实现websocket客户端

demo代码：

public final class WebSocketClient {
 
    static final String URL = System.getProperty("url", "ws://127.0.0.1:8080/websocket");
 
    public static void main(String[] args) throws Exception {
        URI uri = new URI(URL);
        String scheme = uri.getScheme() == null? "ws" : uri.getScheme();
        final String host = uri.getHost() == null? "127.0.0.1" : uri.getHost();
        final int port;
        if (uri.getPort() == -1) {
            if ("ws".equalsIgnoreCase(scheme)) {
                port = 80;
            } else if ("wss".equalsIgnoreCase(scheme)) {
                port = 443;
            } else {
                port = -1;
            }
        } else {
            port = uri.getPort();
        }
 
        if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
            System.err.println("Only WS(S) is supported.");
            return;
        }
 
        final boolean ssl = "wss".equalsIgnoreCase(scheme);
        final SslContext sslCtx;
        if (ssl) {
            sslCtx = SslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
            sslCtx = null;
        }
 
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            final WebSocketClientHandler handler =
                    new WebSocketClientHandler(
                            WebSocketClientHandshakerFactory.newHandshaker(
                                    uri, WebSocketVersion.V13, null, false, new DefaultHttpHeaders()));
 
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .handler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc(), host, port));
                     }
                     p.addLast(
                             new HttpClientCodec(),
                             new HttpObjectAggregator(8192),
                             handler);
                 }
             });
 
            Channel ch = b.connect(uri.getHost(), port).sync().channel();
            handler.handshakeFuture().sync();
 
            BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String msg = console.readLine();
                if (msg == null) {
                    break;
                } else if ("bye".equals(msg.toLowerCase())) {
                    ch.writeAndFlush(new CloseWebSocketFrame());
                    ch.closeFuture().sync();
                    break;
                } else if ("ping".equals(msg.toLowerCase())) {
                    WebSocketFrame frame = new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[] { 8, 1, 8, 1 }));
                    ch.writeAndFlush(frame);
                } else {
                    WebSocketFrame frame = new TextWebSocketFrame(msg);
                    ch.writeAndFlush(frame);
                }
            }
        } finally {
            group.shutdownGracefully();
        }
    }
}


public class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> {
 
    private final WebSocketClientHandshaker handshaker;
    private ChannelPromise handshakeFuture;
 
    public WebSocketClientHandler(WebSocketClientHandshaker handshaker) {
        this.handshaker = handshaker;
    }
 
    public ChannelFuture handshakeFuture() {
        return handshakeFuture;
    }
 
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        handshakeFuture = ctx.newPromise();
    }
 
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        handshaker.handshake(ctx.channel());
    }
 
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        System.out.println("WebSocket Client disconnected!");
    }
 
    @Override
    public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel ch = ctx.channel();
        if (!handshaker.isHandshakeComplete()) {
            handshaker.finishHandshake(ch, (FullHttpResponse) msg);
            System.out.println("WebSocket Client connected!");
            handshakeFuture.setSuccess();
            return;
        }
 
        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            throw new IllegalStateException(
                    "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                            ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
        }
 
        WebSocketFrame frame = (WebSocketFrame) msg;
        if (frame instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            System.out.println("WebSocket Client received message: " + textFrame.text());
        } else if (frame instanceof PongWebSocketFrame) {
            System.out.println("WebSocket Client received pong");
        } else if (frame instanceof CloseWebSocketFrame) {
            System.out.println("WebSocket Client received closing");
            ch.close();
        }
    }
 
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (!handshakeFuture.isDone()) {
            handshakeFuture.setFailure(cause);
        }
        ctx.close();
    }
}

将demo封装成一个解码器


public class WSClientHandler extends MessageToMessageDecoder<Object> {

    private final WebSocketClientHandshaker handshaker;
    private ChannelPromise handshakeFuture;
 
    public WSClientHandler(WebSocketClientHandshaker shaker) {
        this.handshaker = shaker;
    }
 
    public ChannelFuture handshakeFuture() {
        return handshakeFuture;
    }
 
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        handshakeFuture = ctx.newPromise();
    }
 
    @Override
    public void channelActive(ChannelHandlerContext ctx)  throws Exception{
    	handshaker.handshake(ctx.channel());
    	super.channelActive(ctx);
    }
 
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        System.out.println("WebSocket Client disconnected!");
    }
 
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (!handshakeFuture.isDone()) {
            handshakeFuture.setFailure(cause);
        }
        ctx.close();
    }

	@Override
	protected void decode(ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
        Channel ch = ctx.channel();
        if (!handshaker.isHandshakeComplete()) {
            handshaker.finishHandshake(ch, (FullHttpResponse) msg);
            handshakeFuture.setSuccess();
            //发送握手完成事件
            ctx.fireUserEventTriggered(EventConst.USER_EVENT_HANDSHAKER);
            return;
        }
 
        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            throw new IllegalStateException(
                    "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                            ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
        }
 
        TextWebSocketFrame frame = (TextWebSocketFrame) msg;
        out.add(frame.text());
	}

}

代码解释：

ChannelPromise handshakeFuture; 表示握手的状态

    @Override
    public void channelActive(ChannelHandlerContext ctx)  throws Exception{
    	handshaker.handshake(ctx.channel());
    	super.channelActive(ctx);
    }

当连接上了服务器后，发送握手消息，这里要把super.channelActive(ctx)加上，不加的话，在它之后的解码器都收到不active事件了，如果不加，那么后面decode方法里也要加，在decode里加这样会好些，因为不用传自定义事件了。

@Override
	protected void decode(ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
        Channel ch = ctx.channel();
        if (!handshaker.isHandshakeComplete()) {
            handshaker.finishHandshake(ch, (FullHttpResponse) msg);
            handshakeFuture.setSuccess();
            //发送握手完成事件
            ctx.fireUserEventTriggered(EventConst.USER_EVENT_HANDSHAKER);
            return;
        }
 
        if (msg instanceof FullHttpResponse) {
            FullHttpResponse response = (FullHttpResponse) msg;
            throw new IllegalStateException(
                    "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                            ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
        }
 
        TextWebSocketFrame frame = (TextWebSocketFrame) msg;
        out.add(frame.text());
	}

这段代码的意思是：当收到一条消息时，如果没有完成握手，那这条消息就是握手的响应消息，设置为完成握手状态，并发出一个自定义的事件（握手完成事件，在之后的解码器中要捕获这个事件，若channelAcive中没有写super.channelAcive,这里可以改成super.channelActive,这样比较好吧）；如果完成的握手，则表示是正常消息，把消息解码成字符串String格式，交给下一个解码器处理.

 

使用这个解码器：

ChannelInitializer实现类中

	@Override
	protected void initChannel(SocketChannel ch) throws Exception {
		ChannelPipeline pipeline = ch.pipeline();
        if (ssl) {
            sslCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
            sslCtx = null;
        }
        if(sslCtx != null){
        	pipeline.addLast(sslCtx.newHandler(ch.alloc(), hostUri.getHost(), hostUri.getPort()));
        }
		pipeline.addLast("httpClientCodec", new HttpClientCodec());
		pipeline.addLast("chunkedWriteHandler", new ChunkedWriteHandler());
		pipeline.addLast("httpObjectAggregator", new HttpObjectAggregator(8192));
		pipeline.addLast("webSocketclientProtocolHandler", (ChannelHandler) new WSClientHandler(shaker));
		pipeline.addLast((ChannelOutboundHandlerAdapter) new WSMsgEncoder());
		//这里加上自己的消息处理器对象
	}

实例化WSClientHandler时，要传入一个WebSocketClientHandshaker,

	private final WebSocketClientHandshaker shaker;
	
	private SslContext sslCtx;
	
	private boolean ssl = false;
	
	private URI hostUri;
shaker = WebSocketClientHandshakerFactory.newHandshaker(hostUri,WebSocketVersion.V13, null, false, new DefaultHttpHeaders());

 

windskymr
关注
专栏目录
Netty实现WebSocket聊天功能
11-08
websocket是基于长连接的通讯技术,而netty是一个专门实现websocket的框架,使得搭建websocket更简单稳定.这里介绍了如何用netty框架实现websocket的聊天功能,文档中含有具体源码及详细说明
netty+websocket实现心跳和断线重连
03-06
综上所述，通过 Netty 实现 WebSocket 服务，并结合心跳检测和断线重连机制，我们可以构建出健壮、可靠的实时通信系统。在实际项目中，还需要根据业务需求进行调整和优化，确保系统的稳定性和用户体验。
使用netty实现WebSocket协议通信
dream_xin2013的专栏
11-21 728
介绍netty实现websocket协议，实现服务端和浏览器双向通信
Netty详解
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-31 2175
Netty是一个高性能、异步的网络应用框架，用于开发高效的网络通信程序。它是JavaNIO的一个抽象，简化了网络编程的复杂性，并提供了一系列高级功能，使网络编程变得更简单。Netty是一个高效的网络框架，专注于处理大量并发连接。它通过异步IO处理来避免阻塞，这让它在处理高并发时表现出色。Netty还利用了优化的内存管理和零拷贝技术，降低了性能开销。框架的灵活性也很高，开发者可以通过管道机制自定义数据处理流程，API和文档丰富，帮助简化网络编程。不过，Netty。
Netty——WebSocket开发
吴声子夜歌的博客
07-29 1792
WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通信的网络技术，WebSocket通信协议于2011年被IETF定为RFC6455，WebSockeet API被W3C定为标准。在WebSocket API中，浏览器和服务器只需要做一个握手动作，然后浏览器和服务器之间就行程了一条快速通道，两者就可以直接相互传送数据了。WebSocket基于TCP双向全双工进行消息传递，在同一时刻，既可以发送消息，，也可以接收消息，相比HTTP的半双工协议，性能得到很大提升。
Netty 实现 websocket
weixin_30416871的博客
05-11 78
现在网上网站为了实现推送基本都采用轮询的方式，比较新的轮询技术是comet，采用ajax，但是还是得发送请求，为了解决html效率低下的问题，html5定义了websocket协议。 服务端代码： import java.util.concurrent.TimeUnit; import org.apache.activemq.util.TimeUtils; import io....
Netty-使用websocket进行通讯
zongx的博客
01-06 991
WebSocket WebSocket是HTML5开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接...
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
8. **错误处理和异常捕获**：在WebSocket和Netty的实现中，需要妥善处理各种可能出现的错误和异常，例如网络中断、消息解析错误等，以保证系统的稳定性和健壮性。 综上所述，Spring Boot与Netty的结合使用，能够...
Spring+Netty+WebSocket实例
12-06
在现代Web开发中，实时通信已经成为一个不可或缺的功能，Spring、Netty和WebSocket的结合为构建高性能、低延迟的实时应用提供了强大的解决方案。本实例将详细探讨如何利用这三种技术进行集成，实现高效的双向通信。 ...
springboot+netty+websocket+redis
03-08
它提供了一套强大的事件处理机制，使得开发者可以轻松地处理TCP、UDP和HTTP协议，包括WebSocket通信。Netty底层基于NIO（非阻塞I/O）模型，提高了网络通信的性能。 ### 3. WebSocket - 实时消息传输 WebSocket是一...
netty-websocket-demo:一个简单的netty实现的websocket
05-18
在本文中，我们将深入探讨如何使用 Netty 实现 WebSocket 协议，这是一个基于 TCP 的低延迟、全双工通信协议，广泛应用于实时数据传输，如在线聊天、股票行情更新等场景。 首先，我们需要理解 WebSocket 协议的基本...
Netty实现websocket
04-07
使用了eclipse基于Netty开发的websocket样例。直接在eclipse中运行后端，将html拖动到浏览器中即可使用。
用Netty实现Websocket（包含服务器代码和客户端网页）
05-06
用Netty实现Websocket（包含服务器代码和客户端网页）
netty-websocket.zip
08-12
需求：服务端主动向客户端推送消息，服务端配置心跳，根据读写设置心跳时间，定时判断客户端是否有消息互动，客户端定时推送消息至服务端，如果时间段内未推送，则判断为网络断开或其他原因，服务端将长连接断开。
Netty整合webSocket
07-20
Netty整合webSocket，Netty整合webSocket，Netty整合webSocket，Netty整合webSocket，Netty整合webSocket
Netty笔记(2)-实现Websocket之间通信
xiaoko81
02-12 225
当我们搭建起来服务器之后，我们就开始尝试着去构建一个简单的聊天室的功能 WsServer的实现 服务器实现与第一节的实现基本相一致 public static void main(String[] args) { //主线程组 EventLoopGroup mainGroup = new NioEventLoopGroup(); //子线程组 ...
netty对websocket协议的实现
mahao25的博客
10-20 7371
websocket协议简单介绍与netty对websocket协议的内部实现逻辑
netty之WebSocket
spring_live_in的博客
09-12 259
WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信--允许服务器主动发送信息给客户端. 今天我们来看一些netty的一种长连接的通信方式-WebSocket通信 首先我们的服务器代码为： package netty.Demo04WebSocket; import io.netty.bootstrap.ServerBootstr...
Netty之WebSocket
猎户星座
12-08 1332
WebSocket 简介 WebSocket 协议最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于服务器推送技术的一种。 WebSocket的通信建立——握手过程 WebSocket的握手使用HTTP来实现，客户端发送带有Upgrade头的HTTP Request消息。服务端根据请求，做Response。 请求报文： GET w...
Java Netty实现WebSocket实时聊天系统
"Java互联网实时聊天系统通过使用Netty作为核心框架，结合WebSocket通信协议，构建了一个类似微信网页版的实时聊天平台。该系统具备单发、群发和文件发送功能，并与Spring整合，便于扩展和开源使用。开发工具包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值