netty做服务端支持ssl协议实现websocket的wss协议（客户端为浏览器）

最新推荐文章于 2024-10-18 19:00:46 发布
最新推荐文章于 2024-10-18 19:00:46 发布
阅读量1.8w 收藏 19
点赞数 2
分类专栏： Java 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/invadersf/article/details/80337380
版权

也是在网上查的资料，整理一下相互学习下

第一步：生成SSL证书：

    因为是测试，直接使用jdk自带的keytool工具生成自签名证书（注：自签名证书是不被浏览器认可的，只能用于测试），

    --打开cmd

   --输入命令（复制啊）：keytool -genkey -keysize 2048 -validity 365 -keyalg RSA -keypass netty123 -storepass netty123 -keystore wss.jks

第二步：在ChannelPipeline添加SslHandler:

    首先写个工具类：SslUtil配置SSLContext

	public static SSLContext createSSLContext(String type ,String path ,String password) throws Exception {
	    KeyStore ks = KeyStore.getInstance(type); /// "JKS"
	    InputStream ksInputStream = new FileInputStream(path); /// 证书存放地址
	    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;
	}

添加SslHandler（放在第一个）

        @Override
        public void initChannel(SocketChannel ch) throws Exception {
            SSLContext sslContext = SslUtil.createSSLContext("JKS","D://wss.jks","netty123");
            //SSLEngine 此类允许使用ssl安全套接层协议进行安全通信
            SSLEngine engine = sslContext.createSSLEngine(); 
            engine.setUseClientMode(false); 
            
            ch.pipeline().addLast(new SslHandler(engine));
            ch.pipeline().addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));    
            ch.pipeline().addLast("http-codec", new HttpServerCodec());            
            ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));  
            ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());    
            ch.pipeline().addLast(new AcceptorIdleStateTrigger());    
            ch.pipeline().addLast("handler", new WebSocketHandler());            
        }

 JS文件的URL：

var url = "wss://localhost:8000/ws";

第三步：运行

    运行服务端，在浏览器地址栏输入https://localhost:8000/  浏览器会提示这是不安全的连接（浏览器不信任自签名证书，如果有域名可以自己申请一个证书，网上有免费测试版的证书），添加例外信任，再在html页面上右键获得它的本地路径 在浏览器中运行   连接成功

补充：（因为发现一些小伙伴不清楚部分类的来源，特此补充）--2021.09.08

目录：

  

AcceptorIdleStateTrigger .java

package com.netty.wss;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;

@ChannelHandler.Sharable
public class AcceptorIdleStateTrigger extends ChannelInboundHandlerAdapter {
    private int unReceivedCounts=0;
   
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
    		throws Exception {
    	//有消息时归零
    	unReceivedCounts=0;
    	super.channelRead(ctx, msg);
    }
    
	@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
			throws Exception {
		if (evt instanceof IdleStateEvent) {
			//在这里并处理业务逻辑
			IdleState state = ((IdleStateEvent) evt).state();
			if (state == IdleState.READER_IDLE) {				
				unReceivedCounts++;
				System.out.println(unReceivedCounts);
				if (unReceivedCounts>10) {
					ctx.close();
					unReceivedCounts = 0;
				}				
			}
		} else {
			super.userEventTriggered(ctx, evt);
		}		
	}

}

SslUtil.java

package com.netty.wss;

import java.io.FileInputStream;
import java.io.InputStream;
import java.security.KeyStore;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;

public class SslUtil {
	
	public static SSLContext createSSLContext(String type ,String path ,String password) throws Exception {
	    KeyStore ks = KeyStore.getInstance(type); /// "JKS"
	    InputStream ksInputStream = new FileInputStream(path); /// 证书存放地址
	    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;
	}
}

WebSocketHandler.java

package com.netty.wss;


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
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;

/**
 * websocket 具体业务处理方法
 * 
 * */
public class WebSocketHandler extends ChannelInboundHandlerAdapter{
	private WebSocketServerHandshaker handshaker;
			
	/**
	 * 当客户端连接成功，返回个成功信息
	 * */
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
	
	}
		
	/**
	 * 当客户端断开连接
	 * */
	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
	}

	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.flush();
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		// 传统的HTTP接入
		if(msg instanceof FullHttpRequest){	
			handleHttpRequest(ctx,(FullHttpRequest)msg);						
		}else if(msg instanceof WebSocketFrame){
			handlerWebSocketFrame(ctx,(WebSocketFrame)msg);				

		}
		super.channelRead(ctx, msg);
	}
			
	public void handlerWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception{
		//关闭请求
		if(frame instanceof CloseWebSocketFrame){		
			handshaker.close(ctx.channel(), (CloseWebSocketFrame)frame.retain());
			return;		
		}
		//只支持文本格式，不支持二进制消息
		if(!(frame instanceof TextWebSocketFrame)){			
			throw new Exception("仅支持文本格式");
		}
	}
	
	//第一次请求是http请求，请求头包括ws的信息
	public void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req){
		if(!req.decoderResult().isSuccess()){
			sendHttpResponse(ctx,req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
			return;
		}		
		// 构造握手响应返回
		WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws:/"+ctx.channel()+ "/ws",null,false);		
		handshaker = wsFactory.newHandshaker(req);
		// 请求头不合法, 导致handshaker没创建成功 
		if(handshaker == null){
			WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
		}else{
			handshaker.handshake(ctx.channel(), req);
		}
	}
	
	public 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;
    }
   
    //异常处理，netty默认是关闭channel
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		//输出日志
		 cause.printStackTrace();
		 ctx.close();
	}
	

}

WebsocketServer.java (启动类)

package com.netty.wss;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
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.ssl.SslHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;

public class WebsocketServer {
	public static   WebsocketServer instance;
	
	public static final WebsocketServer getInstance(){
		return instance;
	}
	
	private int port;
	public WebsocketServer(int port) {
		if(instance!=null){
			return;
		}
		
		this.port = port;
		try {
			this.start();
			instance=this;			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	private void start() throws Exception{
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup);
			b.channel(NioServerSocketChannel.class); 
			b.childHandler(new myChannelInitializer());
			b.option(ChannelOption.SO_BACKLOG, 128);
			b.childOption(ChannelOption.SO_KEEPALIVE, true);
			ChannelFuture f = b.bind(port); 
			System.out.println("Netty Websocket is start .........");
			f.channel().closeFuture().sync();
		} finally {
			workerGroup.shutdownGracefully();
			bossGroup.shutdownGracefully();
		}
	}
	
	private class  myChannelInitializer extends  ChannelInitializer<SocketChannel>{
		@Override
		public void initChannel(SocketChannel ch) throws Exception {
			SSLContext sslContext = SslUtil.createSSLContext("JKS","D://wss.jks","netty123");
			//SSLEngine 此类允许使用ssl安全套接层协议进行安全通信
			SSLEngine engine = sslContext.createSSLEngine(); 
			engine.setUseClientMode(false); 
			
			ch.pipeline().addLast(new SslHandler(engine));
			ch.pipeline().addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));	
			ch.pipeline().addLast("http-codec", new HttpServerCodec());			
			ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));  
			ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());	
			ch.pipeline().addLast(new AcceptorIdleStateTrigger());	
			ch.pipeline().addLast("handler", new WebSocketHandler());			
		}
	}
	
	public static void main(String[] args) throws Exception {
		try {
			new WebsocketServer(8000);	
		} catch (Exception e) {
			// TODO: handle exception
		}

	}
}

源码地址：点击打开链接

参考：http://www.360doc.com/content/17/1228/16/51390869_717156716.shtml；

           https://www.cnblogs.com/guogangj/p/5209330.html

invadersf
关注
专栏目录
netty做服务端支持ssl协议实现websocket的wss协议（java）
05-16
在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳,,在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳
Netty配置SSL证书加密
qq_47741012的博客
09-14 858
使用 OpenSSL 生成 CA、服务端和客户端的证书。在 Netty 中，配置SslContext来加载证书，并将其应用到中。通过 Netty 的SslHandler实现安全的加密数据传输，确保数据在传输过程中是加密的。
WebSocket Secure (WSS)
最新发布
qq 117791303
10-18 389
WebSocket Secure (WSS)
【netty客户端】通过netty实现封装websocket客户端
iaoyou1的博客
12-31 7519
现在网上有很多netty实现的websocket服务端，但是客户端实现的不多，或者说是写的比较散，现写下。
使用netty搭建Websocket客户端
weixin_44384647的博客
10-19 959
使用netty搭建Websocket客户端
netty-websocket服务器配置阿里云SSL证书安全访问配置，亲测有效
qq_53058639的博客
03-01 1450
背景：java 微服务包括https访问和websocket访问，当https接口访问ws请求时报错,因为https能访问wss。申请阿里云免费证书后，搜索各种教程比如nginx配置方式、netty访问证书等。走了不少弯路，终于走通一种。关键点：1、因为使用了netty，nginx配置wss的方式没有走通。需要将证书放到netty启动的方式启动才可以。2、网上教程大多数是pkcs12的证书生成方式。但是netty仅仅支持pkcs8 的版本，所以需要生成pkcs12之后再转pkcs8.
基于Netty实现WebSocket客户端
u013771019的专栏
05-25 2409
握手事件是在自定义的Handler中实现的，这里为了方便使用CountDownLatch，使用了匿名内部类SimpleChannelInboundHandler的方式。这里我们不手动进行握手，由Netty通过WebSocketClientProtocolHandler进行握手，但是我们要知道何时握手完成了。测试的时候，我们可以看到，当客户端发送ping的时候，服务端会自动回pong，这个是有Netty实现的服务端自带的心跳机制。】，测试用的WebSocket服务端也是用Netty实现的，参考【
java实现websocket的wss协议，netty做服务端支持ssl协议
04-27
基于netty的websocket服务，配置阿里云ssl证书，实现正式服务器的wss访问；适用于JAVA服务器部署访问；对应生成博客地址https://mp.csdn.net/mp_blog/creation/editor/130410613
websocket+tomcat+jetty+netty
12-29
Netty提供了对WebSocket协议的全面支持，包括WS和WSS（WebSocket over SSL/TLS）。通过Netty，开发者可以轻松地实现WebSocket服务器和客户端，而且Netty的API设计得非常直观，有助于提高开发效率。 在实际应用中，...
Tomcat WebSocket
06-05
WebSocket是Web交互技术的一种革新，它为客户端和服务器之间提供了全双工的通信渠道，意味着数据可以在两者之间双向实时传输，而不仅仅局限于HTTP协议的请求-响应模式。在标题"Tomcat WebSocket"中，我们讨论的是...
websocket_for_linux.rar_educationcrz_linux WebSocket_websocket_w
07-14
WebSocket是一种在客户端和服务器之间建立持久连接的协议，它允许双方进行全双工通信，即数据可以在任意方向上流动，而无需为每个消息发起新的HTTP请求。在Linux环境下实现WebSocket通信，可以为实时应用，如在线...
netty/websocket服务器配置阿里云SSL证书安全访问配置，亲测有效
yaya_jn的博客
04-27 3737
配置完了，发现ws不能使用了，还在研究，各位大神有办法，可以留言，互相学习。下面是下载的别人的案例，然后改了下我的案例，可以做下参考。3、因为netty仅仅支持pkcs8，所以将server.key 通过OpenSSl 生成pkcs8的版本。2、下载类型Tomcat的pfx 证书，在jdk的路径下cmd命令生成server.key文件。将证书放到外面，方便后期更换，毕竟免费的证书是一年一申请的，用InputStream读取。1、启动的start方法，增加server8.key和pem文件的读取。
Netty框架介绍并编写WebSocket服务端与客户端
喵酱
04-07 2819
Netty框架介绍并编写WebSocket服务端与客户端
基于Netty实现安全认证的WebSocket（wss）服务端
u013771019的专栏
05-27 2041
4.1生成mystore.jks后，不导入证书，直接启动服务端使用；选择证书存储为【受信任的根证书颁发机构】，完成即可。】中基本一样，只是把服务端地址的协议头修改为wss。或者导入证书后不手动信任，客户端进行连接时候，会报错。启动服务端，然后启动客户端，连接和接发数据都正常。双机上面生成的证书文件mystore.cer，4.2 客户端连接服务端的地中，协议头还是ws。可以看到证书此时不受信任，点击【安装证书】JavaScript客户端代码，也是和 【再次双击原证书，可以看到证书已经受信任了。
netty整合websockte并将ws升级wss
Mr. Wu's blog
03-28 2065
netty整合websocket，并实现ws升级wss
利用netty开发webScoketClient（支持wss协议，客户端、服务端心跳实现）
风团团
12-27 5326
最近在使用 netty这个框架来开发 webScoketClient用来获取一些流式的数据，之后咱家的前端采用长连接和咱保持联系，咱们后端就是一个中转站，既要编写一个webScoketServer供咱家的前端有奶喝，也要编写一个webScoketClient去挤奶，同时为了保证这个奶是澳大利亚纯装牛奶，还需要用巴氏消毒法对奶做一个品质管控。这样咱家的公司才能有希望做大做强，我才有肉吃。而这也是我为什么写下本文的原因
netty整合websocket（完美教程）
m0_63251896的博客
11-20 9765
WebSocket是一种在网络通信中的协议，它是独立于HTTP协议的。该协议基于TCP/IP协议，可以提供双向通讯并保有状态。这意味着客户端和服务器可以进行实时响应，并且这种响应是双向的。WebSocket协议端口通常是80，443。WebSocket的出现使得浏览器具备了实时双向通信的能力。与HTTP这种非持久单向响应应答的协议相比，WebSocket是一个持久化的协议。举例来说，即使在关闭网页或者浏览器后，WebSocket的连接仍然保持，用户也可以继续接收到服务器的消息。
Netty服务端支持wss请求并处理-通过netty书写wss客户端进行链接
qq_38215042的博客
07-12 3754
netty服务端支持wss,客户端链接支持wss
【netty】java如何作为websocket客户端 对服务端发起请求
孟秋与你的博客
03-14 5908
为什么会使用java作为websocket客户端？虽说websocket协议 本意是web与服务端之间的通讯协议，那假设有一天 我们的供应商 或者是甲方大爷 只提供了websocket接口呢？如果直接让前端去对接，再把数据传给后端，那从前端对接到后端入库的步骤，万一出现数据丢失呢？总之把数据处理放在后端，是相对可靠的长链接有两点值得注意的，一是心跳机制 二是重连机制如果不发送心跳包，可能过会儿连接就断开了；重新机制就比较好理解了，不管是服务端还是客户端的断开，作为客户端都需要能够重连。
netty实现websocket服务端主动向客户端推送消息
07-16
要在 Netty 中实现 WebSocket 服务端主动向客户端推送消息，可以使用 `ChannelGroup` 来管理连接到服务器的 WebSocket 客户端的 `Channel`，然后通过遍历 `ChannelGroup` 并将消息写入每个 `Channel` 来实现消息的推送。 下面是一个示例代码，演示了如何在 Netty 中实现 WebSocket 服务端主动向客户端推送消息： ```java public class WebSocketServerHandler extends SimpleChannelInboundHandler<WebSocketFrame> { private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE); @Override protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception { // 处理 WebSocket 请求 if (frame instanceof TextWebSocketFrame) { // 处理文本消息 String text = ((TextWebSocketFrame) frame).text(); System.out.println("Received message: " + text); // 推送消息给所有连接的客户端 channelGroup.writeAndFlush(new TextWebSocketFrame("Server: " + text)); } else { // 其他类型的消息，如二进制消息、Ping/Pong 消息等 // ... } } @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { // 当有客户端连接时，将其添加到 ChannelGroup 中 Channel channel = ctx.channel(); channelGroup.add(channel); } @Override public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { // 当有客户端断开连接时，将其从 ChannelGroup 中移除 Channel channel = ctx.channel(); channelGroup.remove(channel); } // 主动向客户端推送消息的方法 public void pushMessageToClients(String message) { channelGroup.writeAndFlush(new TextWebSocketFrame("Server: " + message)); } } ``` 在上述示例中，我们创建了一个静态的 `ChannelGroup` 对象 `channelGroup`，用于存储连接到服务器的 WebSocket 客户端的 `Channel`。当有客户端连接时，将其添加到 `channelGroup` 中；当客户端断开连接时，将其从 `channelGroup` 中移除。 在处理 WebSocket 请求时，如果收到文本消息，我们可以通过调用 `channelGroup.writeAndFlush()` 方法将消息写入每个客户端的 `Channel` 中，实现消息的推送。 此外，我们还添加了一个名为 `pushMessageToClients()` 的方法，用于在服务端主动向所有客户端推送消息。 你可以在适当的时候调用 `pushMessageToClients()` 方法来推送消息给所有连接的客户端。例如，可以在定时任务或其他事件触发的地方调用该方法来主动向客户端推送消息。 希望对你有所帮助！如果还有其他问题，请继续提问。
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值