`

netty 通过端口调用关闭

 
阅读更多
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数据转发工具"的场景中,描述提到的"Netty实现端口数据转发:3000进4000出"意味着通过Netty框架,我们可以构建一个服务器,将接收到的3000端口的数据转发到4000端口。这种数据转发功能在许多网络服务中都有...

    Java采用Netty实现基于DTU的TCP服务器 + 多端口 + 多协议

    通过Netty,我们可以优雅地实现DTU协议的TCP服务器,同时支持多端口通信和多种协议解析,这对于IoT应用和远程监控系统等场景非常有用。理解并掌握这些知识点,对于提升Java网络编程能力,特别是构建高性能网络应用...

    Netty一个端口支持tcp和websocket

    通过这种方式,Netty 允许我们灵活地在同一端口上处理多种协议,简化了多协议服务的实现,减少了系统资源的占用。这种设计模式在构建复杂的分布式系统或微服务架构时特别有用,因为它允许服务提供多种通信接口,同时...

    Netty服务端和客户端调用demo

    Netty服务端和客户端调用demo是一个基于Spring Boot和Maven构建的应用,它演示了如何使用Netty框架进行网络通信。Netty是一个高性能、异步事件驱动的网络应用框架,适用于开发服务器和客户端的Java应用。这个demo...

    基于Netty实现了dubbo rpc

    在基于Netty的实现中,服务提供者会启动一个Netty Server,监听特定端口,接收来自服务消费者的请求。服务消费者则通过Netty Client发送RPC请求到服务提供者。 1. **服务序列化与反序列化**:Dubbo支持多种序列化...

    netty实现的聊天代码

    当有新的连接建立时,Netty 将自动调用这些处理器。 接着,我们来看看客户端(Client)。客户端也需要创建一个 `Bootstrap`,但它的目的是连接到服务器,而不是监听端口。同样,客户端也需要一个 `...

    java实现基于netty 的udp字节数据接收服务

    3. **绑定端口并启动服务**: 使用`Bootstrap.bind()`方法指定监听的IP地址和端口号,然后调用`sync()`启动服务。 ```java ChannelFuture f = b.bind("localhost", 12345).sync(); ``` 在`UdpServerHandler`中,你...

    基于netty4 的udp字节数据接收服务

    通过调用 `new Bootstrap()` 来创建。 2. **配置 Channel**:接着,我们指定通道类型为 `NioDatagramChannel`,这表示我们将使用非阻塞 I/O 模型处理 UDP 数据包。通过 `channelClass(NioDatagramChannel.class)` ...

    JAVA netty 获取串口数据并且下发数据

    串口通信,通常指的是通过串行端口进行的数据交换,广泛应用于工业自动化、物联网设备和嵌入式系统中。在Java中,处理串口通信并不像处理网络套接字那样常见,但Netty提供了一种方式来扩展其功能以支持这种通信模式...

    NettyChannel

    NettyChannel是一个基于Netty框架的测试程序,它...通过分析和运行`NettyServer`和相应的客户端程序,可以深入了解Channel在实际操作中的行为,包括连接建立、数据交换和关闭流程,有助于开发者更好地掌握Netty框架。

    netty http client & server

    2. 绑定端口:通过调用 bind() 方法,将服务器绑定到指定的 IP 和端口。 3. 配置 Pipeline:Pipeline 是 Netty 中处理 I/O 事件的数据通道,每个 Channel 对应一个 Pipeline。我们需要为 Pipeline 添加对应的处理器...

    netty之hello world

    2. **绑定端口**:通过调用`bind()`方法,我们可以指定服务器监听的端口。这样,Netty就会开始监听该端口上的连接请求。 3. **定义Pipeline**:在服务器接受连接后,我们需要定义一个Pipeline,它将包含我们的业务...

    Netty In Action中文版

    1. **Bootstrap**:Bootstrap是Netty中启动服务器或客户端的入口,你可以通过它配置服务器或客户端的参数,比如绑定的端口、使用的事件循环组、处理协议的ChannelHandler等。 2. **Channel**:Channel是Netty中的...

    netty原理及例子

    本篇文章将深入探讨Netty的原理,并通过实例帮助你快速入门和提高。 1. **Netty的基本概念** - **NIO(Non-blocking I/O)**:Netty是基于Java NIO构建的,NIO允许单线程处理多个通道,减少了线程创建和销毁的开销...

    Android基于Netty框架实现通信

    - 绑定端口:调用bind方法启动监听。 **4. 创建客户端** - 初始化EventLoopGroup:创建一个ClientBootstrap的EventLoopGroup。 - 配置ClientBootstrap:设置Channel、Handler链等。 - 连接服务器:调用connect方法...

    WebSocket利用netty连接入门项目

    这个入门项目是学习WebSocket与Netty结合的一个好起点,通过实际操作,你可以更深入地理解WebSocket协议的工作原理,以及如何使用Netty构建高效稳定的WebSocket服务器。同时,对于前端开发人员,这也是一个了解...

    resteasy使用netty

    5. 启动服务器:调用Netty的bind方法,启动服务器并监听指定端口。 这种架构的优势在于,它允许我们构建一个快速、轻便的REST服务,不需要像Tomcat这样的重量级容器。此外,由于Netty的高性能特性,它可以更好地...

    Netty5学习指南

    5. 数据在网络中传输,Netty会调用相应的处理器方法处理I/O事件。 对于客户端,Netty提供了类似的过程,但通常从创建ClientBootstrap开始,然后连接到服务器,设置处理器链,发送和接收数据。 值得注意的是,Netty...

Global site tag (gtag.js) - Google Analytics