package websocketdemo.timeserver2;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
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.HttpServerCodec;
/**
* 通过端口调用关闭netty演示<br />
* 调用方法<br />
* new TimeServer(8080, 8081).run(); //8080, 正常工作商品, 8081, 关闭端口<br />
* http;//127.0.0.1:8081/close; //关闭netty
* @author lizw
*/
public class TimeServer {
private int port;
private int port_shutdown;
public TimeServer(int port) {
this.port = port;
}
public TimeServer(int port, int port_shutdown) {
this.port = port;
this.port_shutdown = port_shutdown;
}
public void run() throws Exception {
//用于常规端口的Group
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
//用于关闭端口的Group
EventLoopGroup bossGroup2 = new NioEventLoopGroup();
EventLoopGroup workerGroup2 = new NioEventLoopGroup();
try {
ServerBootstrap b=null; //常规netty服务
ServerBootstrap b2=null; //关闭netty服务
ChannelFuture f=null;
ChannelFuture f2=null;
{
//常规端口服务器建立
System.out.println("start regular netty server thread");
b = new ServerBootstrap(); // (2)
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class) // (3)
.childHandler(new ChannelInitializer<SocketChannel>() { // (4)
@Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new TimeServerHandler());
}
})
.option(ChannelOption.SO_BACKLOG, 128) // (5)
.childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
// Bind and start to accept incoming connections.
f = b.bind(port).sync(); // (7)
}
{
//关闭netty应用服务器建立
System.out.println("start shutdown netty server thread");
b2 = new ServerBootstrap();
b2.group(workerGroup2, bossGroup2);
b2.channel(NioServerSocketChannel.class);
final EventLoopGroup[] group={workerGroup, bossGroup, workerGroup2, bossGroup2};
b2.childHandler(new ChannelInitializer() {
@Override
protected void initChannel(Channel ch) throws Exception {
ch.pipeline().addLast(new HttpServerCodec());
ch.pipeline().addLast(new CloaseServerHandler(group));
}
});
f2 = b2.bind(port_shutdown).sync();
}
f.channel().closeFuture();
f2.channel().closeFuture();
System.out.println("netty服务器运行中");
} finally {
}
}
public static void main(String[] args) throws Exception {
System.out.println("main start");
int port=8080;
int port_shutdown=8081;
new TimeServer(port, port_shutdown).run();
System.out.println("main end");
}
}
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package websocketdemo.timeserver2;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.EventLoopGroup;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.DefaultHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import static io.netty.handler.codec.http.HttpHeaders.Names.ACCEPT_RANGES;
import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_LENGTH;
import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE;
import static io.netty.handler.codec.http.HttpHeaders.Names.DATE;
import static io.netty.handler.codec.http.HttpHeaders.Names.SERVER;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import java.io.UnsupportedEncodingException;
import java.util.Date;
/**
* 处理http请求, 用于判断 uri = "/close" 时关闭netty应用
* @author lizw
*/
public class CloaseServerHandler extends ChannelInboundHandlerAdapter {
EventLoopGroup[] group;
public CloaseServerHandler(EventLoopGroup[] group) {
this.group = group;
}
/**
* 处理http请求, 如果 uri = "/close" 则关闭服务器, 否则返回 404页面(BAD_GATEWAY)
* @param ctx
* @param msg
* @throws Exception
*/
@Override
public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
super.channelActive(ctx); //To change body of generated methods, choose Tools | Templates.
DefaultHttpRequest req=null;
FullHttpResponse response=null;
boolean isClose=false;
if(msg instanceof DefaultHttpRequest){
req=(DefaultHttpRequest)msg;
String uri=req.getUri();
if(0==uri.indexOf("/close"))
isClose=true;
}
response=closeNetty(isClose);
final ChannelFuture cf = ctx.writeAndFlush(response); // (3)
if(!isClose)
return;
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) {
ctx.close();
System.out.println("服务器马上关闭");
for (EventLoopGroup g : group) {
g.shutdownGracefully();
}
System.out.println("服务器马上完成");
}
});
}
/**
* 关闭netty请求的响应
* @param flag true - 关闭, false - 返回 404页面(BAD_GATEWAY)
* @param FullHttpResponse
*/
private FullHttpResponse closeNetty(boolean flag) throws UnsupportedEncodingException{
FullHttpResponse response=null;
if(flag){
String text=new String("服务器即将关闭");
ByteBuf buf = Unpooled.wrappedBuffer(text.getBytes("utf-8"));
response=new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
}else{
String text=new String("404");
ByteBuf buf = Unpooled.wrappedBuffer(text.getBytes("utf-8"));
response=new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_GATEWAY, buf);
}
response.headers().set(CONTENT_TYPE, "text/html;charset=utf-8");
response.headers().set(CONTENT_LENGTH, response.content().readableBytes());
response.headers().set(DATE, new Date().toString());
response.headers().set(SERVER, "netty-4.0.29-Final");
response.headers().set(ACCEPT_RANGES, "bytes");
return response;
}
}
分享到:
相关推荐
在"Netty数据转发工具"的场景中,描述提到的"Netty实现端口数据转发:3000进4000出"意味着通过Netty框架,我们可以构建一个服务器,将接收到的3000端口的数据转发到4000端口。这种数据转发功能在许多网络服务中都有...
通过Netty,我们可以优雅地实现DTU协议的TCP服务器,同时支持多端口通信和多种协议解析,这对于IoT应用和远程监控系统等场景非常有用。理解并掌握这些知识点,对于提升Java网络编程能力,特别是构建高性能网络应用...
通过这种方式,Netty 允许我们灵活地在同一端口上处理多种协议,简化了多协议服务的实现,减少了系统资源的占用。这种设计模式在构建复杂的分布式系统或微服务架构时特别有用,因为它允许服务提供多种通信接口,同时...
Netty服务端和客户端调用demo是一个基于Spring Boot和Maven构建的应用,它演示了如何使用Netty框架进行网络通信。Netty是一个高性能、异步事件驱动的网络应用框架,适用于开发服务器和客户端的Java应用。这个demo...
在基于Netty的实现中,服务提供者会启动一个Netty Server,监听特定端口,接收来自服务消费者的请求。服务消费者则通过Netty Client发送RPC请求到服务提供者。 1. **服务序列化与反序列化**:Dubbo支持多种序列化...
当有新的连接建立时,Netty 将自动调用这些处理器。 接着,我们来看看客户端(Client)。客户端也需要创建一个 `Bootstrap`,但它的目的是连接到服务器,而不是监听端口。同样,客户端也需要一个 `...
3. **绑定端口并启动服务**: 使用`Bootstrap.bind()`方法指定监听的IP地址和端口号,然后调用`sync()`启动服务。 ```java ChannelFuture f = b.bind("localhost", 12345).sync(); ``` 在`UdpServerHandler`中,你...
通过调用 `new Bootstrap()` 来创建。 2. **配置 Channel**:接着,我们指定通道类型为 `NioDatagramChannel`,这表示我们将使用非阻塞 I/O 模型处理 UDP 数据包。通过 `channelClass(NioDatagramChannel.class)` ...
串口通信,通常指的是通过串行端口进行的数据交换,广泛应用于工业自动化、物联网设备和嵌入式系统中。在Java中,处理串口通信并不像处理网络套接字那样常见,但Netty提供了一种方式来扩展其功能以支持这种通信模式...
NettyChannel是一个基于Netty框架的测试程序,它...通过分析和运行`NettyServer`和相应的客户端程序,可以深入了解Channel在实际操作中的行为,包括连接建立、数据交换和关闭流程,有助于开发者更好地掌握Netty框架。
2. 绑定端口:通过调用 bind() 方法,将服务器绑定到指定的 IP 和端口。 3. 配置 Pipeline:Pipeline 是 Netty 中处理 I/O 事件的数据通道,每个 Channel 对应一个 Pipeline。我们需要为 Pipeline 添加对应的处理器...
2. **绑定端口**:通过调用`bind()`方法,我们可以指定服务器监听的端口。这样,Netty就会开始监听该端口上的连接请求。 3. **定义Pipeline**:在服务器接受连接后,我们需要定义一个Pipeline,它将包含我们的业务...
1. **Bootstrap**:Bootstrap是Netty中启动服务器或客户端的入口,你可以通过它配置服务器或客户端的参数,比如绑定的端口、使用的事件循环组、处理协议的ChannelHandler等。 2. **Channel**:Channel是Netty中的...
本篇文章将深入探讨Netty的原理,并通过实例帮助你快速入门和提高。 1. **Netty的基本概念** - **NIO(Non-blocking I/O)**:Netty是基于Java NIO构建的,NIO允许单线程处理多个通道,减少了线程创建和销毁的开销...
- 绑定端口:调用bind方法启动监听。 **4. 创建客户端** - 初始化EventLoopGroup:创建一个ClientBootstrap的EventLoopGroup。 - 配置ClientBootstrap:设置Channel、Handler链等。 - 连接服务器:调用connect方法...
这个入门项目是学习WebSocket与Netty结合的一个好起点,通过实际操作,你可以更深入地理解WebSocket协议的工作原理,以及如何使用Netty构建高效稳定的WebSocket服务器。同时,对于前端开发人员,这也是一个了解...
5. 启动服务器:调用Netty的bind方法,启动服务器并监听指定端口。 这种架构的优势在于,它允许我们构建一个快速、轻便的REST服务,不需要像Tomcat这样的重量级容器。此外,由于Netty的高性能特性,它可以更好地...
5. 数据在网络中传输,Netty会调用相应的处理器方法处理I/O事件。 对于客户端,Netty提供了类似的过程,但通常从创建ClientBootstrap开始,然后连接到服务器,设置处理器链,发送和接收数据。 值得注意的是,Netty...