Outline
Implement HTTP server
Implement WebSocket
Implemented message push system
(1) Description of the message push system based on WebSocket
(2) PushServer of the message push system
(3) Connection management encapsulation of message push system
(4) Ping-pong detection of message push system
(5) Full connection push of message push system
(6) HTTP response and handshake of message push system
(7) Operation client of message push system
(8) The operation client connects to PushServer
(9) Handler processor for operating the client
(10) The operation client sends push messages
(11) The browser client receives push messages
Implement HTTP server
(1) HTTP request message and response message
(2) Advantages of the HTTP protocol stack implemented by Netty
(3) The HTTP server implemented by Netty
(4) Request parsing processing and response encoding processing
(1) HTTP request message and response message
HTTP request message consists of three parts: request line, request header, and request body. HTTP response messages are also composed of three parts: response row, response header, and response body.
(2) Advantages of the HTTP protocol stack implemented by Netty
The HTTP protocol stack implemented by Netty performs excellently in terms of performance and reliability, and is very suitable for use in non-Web container scenarios. Compared with traditional web containers such as Tomcat and Jetty, it is lighter and compact, with better flexibility and customization.
(3) The HTTP server implemented by Netty
public class NettyHttpServer {
private static final Logger logger = ();
private static final int DEFAULT_PORT = 8998;
private int port;
public NettyHttpServer(int port) {
= port;
}
public void start() throws Exception {
("Netty Http Server is starting.");
EventLoopGroup bossEventLoopGroup = new NioEventLoopGroup();
EventLoopGroup workerEventLoopGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
(bossEventLoopGroup, workerEventLoopGroup)
.channel()
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
()
//The data comes in from top to bottom, and when the data goes back, the data comes in from bottom to top
.addLast("http-decoder", new HttpRequestDecoder())
.addLast("http-aggregator", new HttpObjectAggregator(65536))
.addLast("http-encoder", new HttpResponseEncoder())
.addLast("http-chunked", new ChunkedWriteHandler())
.addLast("netty-http-server-handler", new NettyHttpServerHandler());
}
});
ChannelFuture channelFuture = (port).sync();
("Netty Http Server is started, listened[" + port + "].");
().closeFuture().sync();
} finally {
();
();
}
}
public static void main(String[] args) throws Exception {
NettyHttpServer nettyHttpServer = new NettyHttpServer(DEFAULT_PORT);
();
}
}
public class NettyHttpServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private static final Logger logger = ();
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
(request);
}
}Start NettyHttpServer and access it in the browser, and you can see the output as follows:
Netty Http Server is starting.
Netty Http Server is started, listened[8998].
HttpObjectAggregator$AggregatedFullHttpRequest(decodeResult: success, version: HTTP/1.1, content: CompositeByteBuf(ridx: 0, widx: 0, cap: 0, components=0))
GET / HTTP/1.1
Host: localhost:8998
Connection: keep-alive
sec-ch-ua: ".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,id;q=0.7,ar;q=0.6
Cookie: _ga=GA1.1.629604539.1641093986
content-length: 0(4) Request parsing processing and response encoding processing
The most important thing for an HTTP server is the resolution processing of requests and the encoding processing of responses, such as adding different decoders and encoders to the ChannelPipeline.
First, add the HTTP request message decoder HttpRequestDecoder, because the browser will serialize the request data organized according to the HTTP protocol into a byte array and send it to the server. HttpRequestDecoder can read a complete request data from the received byte array according to the HTTP protocol.
Then add the HttpObjectAggregator decoder, which is used to convert multiple messages into a single FullHttpRequest or FullHttpResponse.
Then add the HTTP response message encoder HttpResponseEncoder, which is used to encode HTTP response messages.
And add ChunkedWriteHandler processor, which supports asynchronous transmission of large code streams and does not occupy too much memory, preventing memory overflow.
Finally, add the NettyHttpServerHandler processor to handle the response output of the HTTP server.
public class NettyHttpServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private static final Logger logger = ();
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
String method = ().name();
String uri = ();
("Receives Http Request: " + method + " " + uri + ".");
String html = "<html><body>Hello, I am Netty Http Server.</body></html>";
ByteBuf byteBuf = (html, CharsetUtil.UTF_8);
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, );
().set("content-type", "text/html;charset=UTF-8");
().writeBytes(byteBuf);
();
(response).addListener();
}
}
Implement WebSocket
(1) Disadvantages of HTTP protocol
(2) Ajax short poll for message push
(3) WebSocket for message push
(4) Establishment of WebSocket connection
(5) Develop NettyServer based on the WebSocket protocol
(6) Development of request data processing logic of WebSocketServer
(7) Analysis of HTTP and chunk processing of WebSocketServer
(8) WebSocket web client code development and implementation
(1) Disadvantages of HTTP protocol
1. HTTP protocol is half-duplex communication
Half-duplex communication means that data can be transmitted in both the client and the server, but cannot be transmitted at the same time. It means that at the same time, only data in one direction can be transmitted.
2. HTTP messages are lengthy and cumbersome
HTTP messages include message headers, message bodies, line breaks, etc., and are usually transmitted in text. Compared with other binary communication protocols, it is lengthy and cumbersome.
(2) Ajax short poll for message push
Ajax short polling is based on HTTP short connections. Specifically, a timer is used to issue an HTTP request to the server by the browser, and the server returns data to the client browser.
The code implementation of Ajax short polling is simple. However, since the HTTP request header is very verbose and the proportion of available data is very low, it occupies bandwidth and server resources, and data synchronization is not timely.
(3) WebSocket for message push
WebSocket is essentially a TCP connection, using full duplex communication.
In WebSocket, the browser and the server only need to make a handshake, and a fast channel will be formed between the two for direct data transmission. Since WebSocket is based on TCP bidirectional full duplex for message delivery, it can send messages or receive messages at the same time, which is better than HTTP half-duplex.
WebSocket keeps link activation through ping/pong frames, which is very real-time, but the browser support is low and the code implementation is complex.
(4) Establishment of WebSocket connection
When establishing a WebSocket connection, a handshake request needs to be issued through the client or browser. This handshake request is an HTTP request. The HTTP request contains the additional header "Upgrade:WebSocket", indicating that this is an HTTP request to apply for an agreement upgrade.
The server parses these additional header information and then generates the reply information and returns it to the client. In this way, the WebSocket connection between the client and the server is established, and both parties can freely transmit information through this connection channel, and the connection will continue until one party actively closes the connection.
(5) Develop NettyServer based on the WebSocket protocol
Netty can be used to develop client and server to communicate with each other based on the TCP protocol, but the problem of sticking to half-packet needs to be handled manually.
A HTTP server can be developed based on the HTTP protocol using Netty. After receiving the HTTP request sent by the browser, the server returns an HTTP response back to the browser.
You can also develop a Netty server based on the WebSocket protocol. At this time, the front-end HTML code will establish a long connection based on the socket protocol and the Netty server. In this way, the Netty server can establish a long connection with the HTML running in the browser through the WebSocket protocol, so that the Netty server can actively push data to the HTML page in the browser.
The underlying layer of the WebSocket protocol is also implemented based on the TCP protocol, but it encapsulates a higher-level WebSocket protocol based on the TCP protocol.
public class NettyWebSocketServer {
private static final Logger logger = ();
private static final int DEFAULT_PORT = 8998;
private int port;
public NettyWebSocketServer(int port) {
= port;
}
public void start() throws Exception {
("Netty WebSocket Server is starting.");
EventLoopGroup bossEventLoopGroup = new NioEventLoopGroup();
EventLoopGroup workerEventLoopGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
(bossEventLoopGroup, workerEventLoopGroup)
.channel()
.childHandler(new ChannelInitializer<SocketChannel>() {
protected void initChannel(SocketChannel ch) throws Exception {
()
.addLast(new HttpServerCodec())
.addLast(new ChunkedWriteHandler())
.addLast(new HttpObjectAggregator(1024 * 32))
.addLast(new WebSocketServerProtocolHandler("/websocket"))
.addLast("netty-web-socket-server-handler", new NettyWebSocketServerHandler());
}
});
ChannelFuture channelFuture = (port).sync();
("Netty WebSocket Server server is started, listened[" + port + "].");
().closeFuture().sync();
} finally {
();
();
}
}
public static void main(String[] args) throws Exception {
NettyWebSocketServer nettyHttpServer = new NettyWebSocketServer(DEFAULT_PORT);
();
}
}(6) Development of request data processing logic of WebSocketServer
public class NettyWebSocketServerHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
private static final Logger logger = ();
private static ChannelGroup webSocketClients = new DefaultChannelGroup();
protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
//The data sent from the WebSocket web page code
String request = ();
("Netty Server receives request: " + request + ".");
TextWebSocketFrame response = new TextWebSocketFrame("Hello, I am Netty Server.");
(response);
}
//If a web page WebSocket client establishes a connection with Netty Server, this method will be triggered
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
(());
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
("websocket client is closed, channel id: " + ().id().asLongText() + "[" + ().id().asShortText() + "]");
}
}(7) Analysis of HTTP and chunk processing of WebSocketServer
The browser runs HTML web code. WebSocket is to embed WebSocket code into HTML web code, which allows the HTML web code in the browser to establish a connection with NettyServer and send data based on a long connection.
The browser will organize the request data format according to the WebSocket protocol (the underlying HTTP protocol is based on the underlying HTTP protocol), and then serialize the data into a byte array, and then transmit the byte array to NettyServer through a network connection. NettyServer will process the received byte array data through a data processing chain.
protected void initChannel(SocketChannel ch) throws Exception {
()
//After the browser's byte array data comes in, the byte array data is first processed using the http protocol, and convert the byte array into an HttpRequest request object
//Before the last data is returned to the browser, the HttpResponse object will be encoded into a byte array
.addLast(new HttpServerCodec())
//chunked write is used for chunk blocks when a large number of data streams, that is, if the data is too large, you must score chunks if it is too large.
//When a large amount of data flows in, you can read it in chunk blocks; when a large amount of data flows out, you can write it in chunk blocks;
.addLast(new ChunkedWriteHandler())
//If you want to not split a lot of http into many segments, you can aggregate the complete request data together and then give it to it.
.addLast(new HttpObjectAggregator(1024 * 32))
// Based on the request data object that has been converted before, another processing will be done based on the WebSocket protocol here
//Because the transmission is based on the http protocol, and the encapsulated content is the http request data encapsulated according to the webSocket protocol
//So, the data in the http request must be extracted here, and then parsed according to the WebSocket protocol, and extracted the data as a data fragment of WebSocket
.addLast(new WebSocketServerProtocolHandler("/websocket"))
// When responding to data output, the order is inverse. The first step is that the original data must be converted by the WebSocket protocol first
//WebSocket protocol data must be processed by HTTP protocol, but will eventually encode encoded into an HTTP protocol response data
//Then the server transmits the byte array of HTTP response data serialized to the browser
//The browser deserializes the byte array, gets an HTTP protocol response data, extracts the content and processes it according to the WebSocket protocol.
//End the end, the normal data is given to the WebSocket code
.addLast("netty-web-socket-server-handler", new NettyWebSocketServerHandler());
}(8) WebSocket web client code development and implementation
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>websocket webpage</title>
</head>
<body onload="connectServer();">
<script type="text/javascript">
var websocket;
function connectServer() {
if ("WebSocket" in window) {
("Your browser supports websocket!");
websocket = new WebSocket("ws://localhost:8998/websocket");
= function() {
("Send request to netty server.");
("I am websocket client.");
}
= function(ev) {
var response = ;
("Receive response from netty server: " + response);
}
}
}
</script>
</body>
</html>Start Netty Server, then open the HTML to see the output of the console.
WebSocket and Netty Server work together to develop instructions:
If the server side actively pushes some notifications (push) to users who are browsing the web page, such as pushing products that users may be interested in and news that they are concerned about. Then after the user enters the web page, you can ask the user whether he is willing to receive xx prompts and notifications sent by the server. If the user wants, then the WebSocket on the web page can completely build a long connection with NettyServer. In this way, when necessary, NettyServer can push notifications to the user in reverse, and a push notification may pop up on the web page in the browser to notify the user of xx message.
Implemented message push system
(1) Description of the message push system based on WebSocket
(2) PushServer of the message push system
(3) Connection management encapsulation of message push system
(4) Ping-pong detection of message push system
(5) Full connection push of message push system
(6) HTTP response and handshake of message push system
(7) Operation client of message push system
(8) The operation client connects to PushServer
(9) Handler processor for operating the client
(10) The operation client sends push messages
(11) The browser client receives push messages
(1) Description of the message push system based on WebSocket
First, an operation system is required to establish a WebSocket long connection based on NettyClient and PushServer, and then the browser client must also establish a WebSocket long connection with PushServer. Then the operation system will ask NettyClient to send a Push push message to PushServer, and finally PushServer sends the push message to the browser client.
First, start PushServer, then open multiple web clients to view console, and then start the operator system to enter messages in the console, so that a complete message push interaction can be completed.
(2) PushServer of the message push system
public class NettyPushServer {
private static final Logger logger = ();
private static final int DEFAULT_PORT = 8998;
private int port;
public NettyPushServer(int port) {
= port;
}
public void start() throws Exception {
("Netty Push Server is starting.");
EventLoopGroup bossEventLoopGroup = new NioEventLoopGroup();
EventLoopGroup workerEventLoopGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
(bossEventLoopGroup, workerEventLoopGroup)
.channel()
.childHandler(new ChannelInitializer<SocketChannel>() {
protected void initChannel(SocketChannel ch) throws Exception {
()
.addLast("logging", new LoggingHandler("DEBUG"))
.addLast("http-codec", new HttpServerCodec())
.addLast("aggregator", new HttpObjectAggregator(65536))
.addLast("http-chunked", new ChunkedWriteHandler())
.addLast("netty-push-server-handler", new NettyPushServerHandler());
}
});
ChannelFuture channelFuture = (port).sync();
("Netty Push Server is started, listened[" + port + "].");
().closeFuture().sync();
} finally {
();
();
}
}
public static void main(String[] args) throws Exception {
NettyPushServer nettyHttpServer = new NettyPushServer(DEFAULT_PORT);
();
}
}
public class NettyPushServerHandler extends SimpleChannelInboundHandler<Object> {
private static final Logger logger = ();
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
("Client Connection Established: " + ());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
("Client Disconnected: " + ());
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof FullHttpRequest) {
handleHttpRequest(ctx, (FullHttpRequest) msg);
} else if(msg instanceof WebSocketFrame) {
handleWebSocketFrame(ctx, (WebSocketFrame) msg);
}
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
();
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame webSocketFrame) {
}
private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request) {
}
}(3) Connection management encapsulation of message push system
// Used to manage connections
public class ChannelManager {
private static ChannelGroup channelGroup = new DefaultChannelGroup();
private static ConcurrentHashMap<String, ChannelId> channelIds = new ConcurrentHashMap<String, ChannelId>();
public static void add(Channel channel) {
(channel);
(().asShortText(), ());
}
public static void remove(Channel channel) {
(channel);
(().asShortText());
}
public static Channel get(String id) {
return ((id));
}
public static void pushToAllChannels(TextWebSocketFrame webSocketFrame) {
(webSocketFrame);
}
}
public class NettyPushServerHandler extends SimpleChannelInboundHandler<Object> {
...
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
("Client Connection Established: " + ());
(());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
("Client Disconnected: " + ());
(());
}
...
}(4) Ping-pong detection of message push system
public class NettyPushServerHandler extends SimpleChannelInboundHandler<Object> {
...
private WebSocketServerHandshaker webSocketServerHandshaker;
...
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof FullHttpRequest) {
handleHttpRequest(ctx, (FullHttpRequest) msg);
} else if(msg instanceof WebSocketFrame) {
handleWebSocketFrame(ctx, (WebSocketFrame) msg);
}
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame webSocketFrame) {
//WebSocket web client sends a ping message, which will keep pinging the server to see if the long connection is alive and effective
if (webSocketFrame instanceof PingWebSocketFrame) {
("Receive ping frame from client: " + ());
WebSocketFrame pongWebSocketFrame = new PongWebSocketFrame(().retain());
().write(pongWebSocketFrame);
return;
}
//The WebSocket web client sends a request to close the WebSocket connection
if (webSocketFrame instanceof CloseWebSocketFrame) {
("Receive close WebSocket request from client: " + ());
((), ((CloseWebSocketFrame) webSocketFrame).retain());
return;
}
...
}
...
}(5) Full connection push of message push system
public class NettyPushServerHandler extends SimpleChannelInboundHandler<Object> {
...
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof FullHttpRequest) {
handleHttpRequest(ctx, (FullHttpRequest) msg);
} else if(msg instanceof WebSocketFrame) {
handleWebSocketFrame(ctx, (WebSocketFrame) msg);
}
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame webSocketFrame) {
//WebSocket web client sends a ping message, which will keep pinging the server to see if the long connection is alive and effective
if (webSocketFrame instanceof PingWebSocketFrame) {
("Receive ping frame from client: " + ());
WebSocketFrame pongWebSocketFrame = new PongWebSocketFrame(().retain());
().write(pongWebSocketFrame);
return;
}
//The WebSocket web client sends a request to close the WebSocket connection
if (webSocketFrame instanceof CloseWebSocketFrame) {
("Receive close WebSocket request from client: " + ());
((), ((CloseWebSocketFrame) webSocketFrame).retain());
return;
}
//WebSocket web client sends a request, but it is not a text text request
if (!(webSocketFrame instanceof TextWebSocketFrame)) {
("Netty Push Server only supports text frame, does not support other type frame.");
String errorMsg = ("%s type frame is not supported.", ().getName());
throw new UnsupportedOperationException(errorMsg);
}
//The WebSocket web client sends a text request, which is of type TextFrame
String request = ((TextWebSocketFrame)webSocketFrame).text();
("Receive text frame[" + request + "] from client: " + ());
//Build Response
TextWebSocketFrame response = new TextWebSocketFrame(request);
//Send to all connections, push all connections
(response);
}
...
}(6) HTTP response and handshake of message push system
public class NettyPushServerHandler extends SimpleChannelInboundHandler<Object> {
...
private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request) {
if (!().isSuccess() || (!"websocket".equals(().get("Upgrade")))) {
DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST);
sendHttpResponse(ctx, request, response);
return;
}
("Receive handshake request from client: " + ());
//Handshake creates
WebSocketServerHandshakerFactory factory = new WebSocketServerHandshakerFactory("ws://localhost:8998/push", null, false);
webSocketServerHandshaker = (request);
if (webSocketServerHandshaker == null) {
(());
} else {
((), request);
("Netty push server handshake with client: " + ());
}
}
//HTTP response
private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest request, DefaultFullHttpResponse response) {
if (().code() != RESPONSE_CODE_OK) {
ByteBuf byteBuf = (().toString(), CharsetUtil.UTF_8);
().writeBytes(byteBuf);
("Http Response is not ok: " + (CharsetUtil.UTF_8));
();
}
ChannelFuture channelFuture = ().writeAndFlush(response);
if (().code() != RESPONSE_CODE_OK) {
();
}
}
...
}(7) Operation client of message push system
public class OperationNettyClient {
private static final Logger logger = ();
private static final String WEB_SOCKET_SCHEME = "ws";
private static final String WSS_SCHEME = "wss";
private static final String LOCAL_HOST = "127.0.0.1";
private static final String PUSH_SERVER_URI = ("url", "ws://127.0.0.1:8998/push");
private static URI uri;
private static String scheme;
private static String host;
private static int port;
private static SslContext sslContext;
private EventLoopGroup eventLoopGroup;
public void start() throws Exception {
//...
}
public static void main(String[] args) throws Exception {
uri = new URI(PUSH_SERVER_URI);
scheme = getScheme(uri);
host = getHost(uri);
port = getPort(uri, scheme);
checkScheme(scheme);
initSslContext(scheme);
}
private static String getScheme(URI pushServerUri) {
return () == null ? WEB_SOCKET_SCHEME : ();
}
private static String getHost(URI pushServerUri) {
return () == null ? LOCAL_HOST : ();
}
private static int getPort(URI pushServerUri, String scheme) {
int port;
if (() == -1) {
if (WEB_SOCKET_SCHEME.equals(scheme)) {
port = 80;
} else if(WSS_SCHEME.equals(scheme)) {
port = 443;
} else {
port = -1;
}
} else {
port = ();
}
return port;
}
//Check whether the scheme is ws or wss
private static void checkScheme(String scheme) {
if (!WEB_SOCKET_SCHEME.equals(scheme) && !WSS_SCHEME.equals(scheme)) {
("Only Support ws or wss scheme.");
throw new RuntimeException("Only Support ws or wss scheme.");
}
}
//If WebSocket uses SSL, that is, wss, then initialize the corresponding sslContext
private static void initSslContext(String scheme) throws Exception {
boolean enableSSL = WSS_SCHEME.equals(scheme);
if (enableSSL) {
sslContext = ().trustManager().build();
} else {
sslContext = null;
}
}
}(8) The operation client connects to PushServer
public class OperationNettyClient {
private static final Logger logger = ();
private static final String WEB_SOCKET_SCHEME = "ws";
private static final String WSS_SCHEME = "wss";
private static final String LOCAL_HOST = "127.0.0.1";
private static final String PUSH_SERVER_URI = ("url", "ws://127.0.0.1:8998/push");
private static final String INPUT_MESSAGE_QUIT = "quit";
private static final String INPUT_MESSAGE_CLOSE = "close";
private static final String INPUT_MESSAGE_PING = "ping";
private static URI uri;
private static String scheme;
private static String host;
private static int port;
private static SslContext sslContext;
private EventLoopGroup eventLoopGroup;
public Channel start() throws Exception {
("Operation Netty Client is connecting.");
eventLoopGroup = new NioEventLoopGroup();
WebSocketClientHandshaker webSocketClientHandshaker = (uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders());
final OperationNettyClientHandler operationNettyClientHandler = new OperationNettyClientHandler(webSocketClientHandshaker);
Bootstrap bootstrap = new Bootstrap();
(eventLoopGroup)
.channel()
.handler(new ChannelInitializer<SocketChannel>() {
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline channelPipeline = ();
if (sslContext != null) {
(((), host, port));
}
(new HttpClientCodec())
.addLast(new HttpObjectAggregator(65536))
.addLast()
.addLast(operationNettyClientHandler);
}
});
Channel channel = ((), port).sync().channel();
("Operation Netty Client connected to push server.");
().sync();
return channel;
}
public void shutdownGracefully() {
();
}
public static void main(String[] args) throws Exception {
uri = new URI(PUSH_SERVER_URI);
scheme = getScheme(uri);
host = getHost(uri);
port = getPort(uri, scheme);
checkScheme(scheme);
initSslContext(scheme);
OperationNettyClient operationNettyClient = new OperationNettyClient();
try {
Channel channel = ();
} finally {
();
}
}
...
}(9) Handler processor for operating the client
public class OperationNettyClientHandler extends SimpleChannelInboundHandler<Object> {
private static final Logger logger = ();
private WebSocketClientHandshaker webSocketClientHandshaker;
private ChannelFuture channelFuture;
public OperationNettyClientHandler(WebSocketClientHandshaker webSocketClientHandshaker) {
= webSocketClientHandshaker;
}
public ChannelFuture channelFuture() {
return channelFuture;
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
channelFuture = ();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
(());
("Operation Netty Client send WebSocket handshake request.");
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
("netty client disconnected.");
}
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
Channel channel = ();
if (!()) {
try {
(channel, (FullHttpResponse) msg);
("Netty Client connected.");
((ChannelPromise)channelFuture).setSuccess();
} catch(WebSocketHandshakeException e) {
("WebSocket handshake failed.", e);
((ChannelPromise)channelFuture).setFailure(e);
}
return;
}
if (msg instanceof FullHttpResponse) {
FullHttpResponse response = (FullHttpResponse) msg;
throw new IllegalStateException("Not Supported HTTP Response.");
}
WebSocketFrame webSocketFrame = (WebSocketFrame) msg;
if (webSocketFrame instanceof TextWebSocketFrame) {
TextWebSocketFrame textWebSocketFrame = (TextWebSocketFrame) webSocketFrame;
("Receives text frame: " + ());
} else if(webSocketFrame instanceof PongWebSocketFrame) {
("Receives pong frame: " + webSocketFrame);
} else if(webSocketFrame instanceof CloseWebSocketFrame) {
("Receives close WebSocket frame, Netty Client is closing.");
();
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
("Operation Netty client handler exception caught.", cause);
if (!()) {
((ChannelPromise)channelFuture).setFailure(cause);
}
();
}
}(10) The operation client sends push messages
public class OperationNettyClient {
...
public void waitInputMessage(Channel channel) throws Exception {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader());
while(true) {
("Wait for input message.");
String message = ();
if (INPUT_MESSAGE_QUIT.equals(message)) {
break;
} else if(INPUT_MESSAGE_CLOSE.equals(message)) {
(new CloseWebSocketFrame());
().sync();
break;
} else if(INPUT_MESSAGE_PING.equals(message)) {
WebSocketFrame webSocketFrame = new PingWebSocketFrame((new byte[] {8, 1, 8, 1}));
(webSocketFrame);
} else {
WebSocketFrame webSocketFrame = new TextWebSocketFrame(message);
(webSocketFrame);
}
}
}
public static void main(String[] args) throws Exception {
uri = new URI(PUSH_SERVER_URI);
scheme = getScheme(uri);
host = getHost(uri);
port = getPort(uri, scheme);
checkScheme(scheme);
initSslContext(scheme);
OperationNettyClient operationNettyClient = new OperationNettyClient();
try {
Channel channel = ();
//Operation client sends message portal
(channel);
} finally {
();
}
}
...
}(11) The browser client receives push messages
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>websocket webpage</title>
</head>
<body onload="connectServer();">
<script type="text/javascript">
var websocket;
function connectServer() {
if ("WebSocket" in window) {
("your browser supports websocket!");
websocket = new WebSocket("ws://localhost:8998/push");
= function() {
("established connection with push server.");
}
= function(ev) {
var response = ;
("receives push message from netty server: " + response);
}
}
}
</script>
</body>
</html>