`
vista_move
  • 浏览: 30091 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

通信框架netty5.0教程二:netty超时心跳机制

 
阅读更多
上一章已经讲了如何搭建一个简单的netty server,这一章讲一下netty超时心跳机制。

一般应用场景是client在一定时间未收到server端数据时给server端发送心跳请求,server收到心跳请求后发送一个心跳包给client端,以此维持通信。

发送心跳由client执行,server端反馈心跳就可以了,好了不多说了,上代码:


netty server代码:

import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
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.LengthFieldBasedFrameDecoder;
import io.netty.handler.timeout.IdleStateHandler;

public class NettyServerBootstrap {

	private static Logger logger = Logger.getLogger(NettyServerBootstrap.class);

	private int port;

	public NettyServerBootstrap(int port) {
		this.port = port;
		bind();
	}

	private void bind() {

		EventLoopGroup boss = new NioEventLoopGroup();
		EventLoopGroup worker = new NioEventLoopGroup();

		try {

			ServerBootstrap bootstrap = new ServerBootstrap();

			bootstrap.group(boss, worker);
			bootstrap.channel(NioServerSocketChannel.class);
			bootstrap.option(ChannelOption.SO_BACKLOG, 1024);
			bootstrap.option(ChannelOption.TCP_NODELAY, true);
			bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
			bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
				@Override
				protected void initChannel(SocketChannel socketChannel)
						throws Exception {
					ChannelPipeline p = socketChannel.pipeline();

					// 超时处理:参数分别为读超时时间、写超时时间、读和写都超时时间、时间单位
					p.addLast(new IdleStateHandler(15, 30, 30, TimeUnit.SECONDS));
					p.addLast(new NettyIdleStateHandler());

					p.addLast(new NettyServerHandler());
				}
			});
			ChannelFuture f = bootstrap.bind(port).sync();
			if (f.isSuccess()) {
				logger.debug("启动Netty服务成功,端口号:" + this.port);
			}
			// 关闭连接
			f.channel().closeFuture().sync();

		} catch (Exception e) {
			logger.error("启动Netty服务异常,异常信息:" + e.getMessage());
			e.printStackTrace();
		} finally {
			boss.shutdownGracefully();
			worker.shutdownGracefully();
		}
	}

}


server端NettyIdleStateHandler:
import org.apache.log4j.Logger;

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;

/**
 * 处理超时连接handler
 * 
 * @author Guo Kaixuan
 *
 */
public class NettyIdleStateHandler extends ChannelHandlerAdapter {

	private static Logger logger = Logger
			.getLogger(NettyIdleStateHandler.class);
	
	@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
			throws Exception {

		if (evt instanceof IdleStateEvent) {

			IdleStateEvent event = (IdleStateEvent) evt;

			if (event.state().equals(IdleState.READER_IDLE)) {

				logger.warn("Netty服务器在通道" + ctx.channel().id() + "上读超时,已将该通道关闭");

			} else if (event.state().equals(IdleState.WRITER_IDLE)) {
				
				logger.warn("Netty服务器在通道" + ctx.channel().id() + "上写超时,已将该通道关闭");
				
			} else if (event.state().equals(IdleState.ALL_IDLE)) {

				logger.warn("Netty服务器在通道" + ctx.channel().id()
						+ "上读&写超时,已将该通道关闭");
			}

			super.userEventTriggered(ctx, evt);
		}
	}

}


server端NettyServerHandler
import java.io.UnsupportedEncodingException;

import org.apache.log4j.Logger;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.socket.SocketChannel;

public class NettyServerHandler extends ChannelHandlerAdapter {

	private static Logger logger = Logger.getLogger(NettyServerHandler.class);
	
	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
		super.channelInactive(ctx);
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) {
		
		ByteBuf buf = (ByteBuf) msg;

		String recieved = getMessage(buf);  
		System.out.println("服务器接收到消息:" + recieved);

		try {		
			ctx.writeAndFlush(newPing("服务器已收到心跳包"));	
			
		} catch (Exception e) {
			ServiceLoggerUtils.error("通信异常");
			return;
		}
	}

	/*
	 * 从ByteBuf中获取信息 使用UTF-8编码返回
	 */
	private String getMessage(ByteBuf buf) {

		byte[] con = new byte[buf.readableBytes()];
		buf.readBytes(con);
		try {
			return new String(con, Constant.UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}
	}

	public static ByteBuf newPing(String message) {

		byte[] mes = message.getBytes();
		ByteBuf pingMessage = Unpooled.buffer();
		pingMessage.writeBytes(mes);

		return pingMessage;
	}
	
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
	}
}


client端代码:

import java.util.concurrent.TimeUnit;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.timeout.IdleStateHandler;

public class NettyClientBootstrap {

	/*
	 * 服务器端口号
	 */
	private int port;

	/*
	 * 服务器IP
	 */
	private String host;

	@SuppressWarnings("unused")
	private SocketChannel socketChannel;
	
	public NettyClientBootstrap(int port, String host)
			throws InterruptedException {
		this.port = port;
		this.host = host;
		start();
	}

	private void start() throws InterruptedException {
		
		EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
		
		try {
			
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.channel(NioSocketChannel.class);
			bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
			bootstrap.group(eventLoopGroup);
			bootstrap.remoteAddress(host, port);
			bootstrap.handler(new ChannelInitializer<SocketChannel>() {
				@Override
				protected void initChannel(SocketChannel socketChannel)
						throws Exception {
					
					//超时处理:参数分别为读超时时间、写超时时间、读和写都超时时间、时间单位
					socketChannel.pipeline().addLast(new IdleStateHandler(3, 8, 0, TimeUnit.SECONDS));
					socketChannel.pipeline().addLast(new NettyIdleStateHandler());
					
					socketChannel.pipeline().addLast(new NettyClientHandler());
				}
			});
			ChannelFuture future = bootstrap.connect(host, port).sync();
			if (future.isSuccess()) {
				socketChannel = (SocketChannel) future.channel();
				System.out.println("----------------connect server success----------------");
			}
			future.channel().closeFuture().sync();
		} finally {
			eventLoopGroup.shutdownGracefully();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		
		NettyClientBootstrap bootstrap = new NettyClientBootstrap(9999,
				"localhost");

	}
}


client端NettyIdleStateHandler:

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;

/**
 * 处理超时连接handler
 * 
 * @author
 *
 */
public class NettyIdleStateHandler extends ChannelHandlerAdapter {

	@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
			throws Exception {

		if (evt instanceof IdleStateEvent) {

			IdleStateEvent event = (IdleStateEvent) evt;

			if (event.state().equals(IdleState.READER_IDLE)) {

				String message = "心跳包";

				byte[] req = message.getBytes();
				ByteBuf pingMessage = Unpooled.buffer();
				pingMessage.writeBytes(req);
				
				ctx.writeAndFlush(pingMessage);
				System.out.println("客户端读超时,已发送心跳");

			} else if (event.state().equals(IdleState.WRITER_IDLE)) {
				System.out.println("客户端写超时");
			} else if (event.state().equals(IdleState.ALL_IDLE)) {
				System.out.println("客户端读&写超时");
			}

			super.userEventTriggered(ctx, evt);
		}
	}
}


client端NettyClientHandler:
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class NettyClientHandler extends ChannelHandlerAdapter  {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
	
	String result = getMessage((ByteBuf) msg);
	System.out.print("客户端收到服务器响应数据:" + result);
         
    }

    private String getMessage(ByteBuf buf) {

		byte[] con = new byte[buf.readableBytes()];
		buf.readBytes(con);
		try {
			return new String(con, Constant.UTF8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}
	}
}


以上代码需要引入netty5包和log4j包,netty包上一张有将如何加入,log4j请自行下载或者maven添加。如有问题欢迎留言。
分享到:
评论

相关推荐

    Netty5.0Jar包和4.03API文档

    这个压缩包包含两个重要的资源:Netty 5.0 的 JAR 包和 Netty 4.0.3 的 API 文档。 首先,让我们详细探讨 Netty 5.0 的 JAR 包。JAR (Java Archive) 文件是 Java 平台的标准归档格式,用于封装多个类文件和其他资源...

    netty5.0官方自带的demo

    Netty 是一个高性能、异步事件驱动的网络应用程序框架,用于快速开发可维护的高性能协议服务器和客户端。在本文中,我们将深入探讨Netty 5.0官方提供的示例(demo),这些示例是学习和理解Netty核心概念与功能的重要...

    Netty5.0架构剖析和源码解读.pdf

    本文档通过对Netty5.0架构剖析和源码解读,帮助读者了解Netty框架的架构、设计理念、实现细节等方面的知识点。Netty框架是一个功能强大且灵活的IO框架,广泛应用于各种分布式系统和网络应用中。

    Netty5.0架构剖析和源码解读.PDF

    Netty 是一个高性能、异步事件驱动的网络应用程序框架,用于快速开发可维护的高性能协议服务器和客户端。在深入探讨Netty 5.0的架构和源码之前,我们需要先理解NIO(非阻塞I/O)的概念。NIO与传统的阻塞I/O模型不同...

    Netty 入门与实战:仿写微信 IM 即时通讯系统.pdf

    1. **服务端与客户端的启动**:Netty提供了简单易用的API来启动服务端和客户端。 2. **数据载体ByteBuf**:用于高效地处理二进制数据。 3. **自定义协议设计**:为了满足特定的需求,可以设计符合业务逻辑的协议。 4...

    netty5.0源码包的依赖包

    Netty 是一个高性能、异步事件驱动的网络应用程序框架,用于快速开发可维护的高性能协议服务器和客户端。在深入探讨Netty 5.0的源码之前,我们首先需要了解Netty的基本架构和核心概念。 Netty的核心组件包括...

    netty5.0架构剖析和源码解读

    Netty5.0架构剖析和源码解读,旨在为读者提供深入理解Netty内部工作机制的途径,通过源码层面的分析帮助开发者更好地掌握Netty的应用和优化。 1. JAVA的IO演进 在Netty 5.0之前,Java IO主要经历了BIO到NIO的演进...

    Netty进阶之路:跟着案例学Netty 完整版.pdf

    《Netty进阶之路:跟着案例学Netty》中的案例涵盖了Netty的启动和停止、内存、并发多线程、性能、可靠性、安全等方面,囊括了Netty绝大多数常用的功能及容易让人犯错的地方。在案例的分析过程中,还穿插讲解了Netty...

    Netty5.0TCP/IP上传大文件

    Netty 是一个高性能、...总结起来,Netty5.0提供的TCP/IP上传大文件功能依赖于其强大的ByteBuf管理、拆包与合包机制、以及高效的文件传输技术。通过理解和运用这些知识点,开发者能够构建出稳定且高效的文件上传系统。

    高清Netty5.0架构剖析和源码解读

    Netty5.0 架构剖析和源码解读 作者:李林锋 版权所有 email neu_lilinfeng@ © Netty5.0 架构剖析和源码解读1 1. 概述2 1.1. JAVA 的IO演进2 1.1.1. 传统BIO通信的弊端2 1.1.2. Linux 的网络IO模型简介4 1.1.3. IO...

    Netty 入门与实战:仿写微信 IM 即时通讯系统.rar

    8.实战:Netty实现客户端登录 15 9.实战:实现客户端与服务端收发消息 16 10.Pipeline与ChannelHandler 17 11.实战:构建客户端与服务端 Pipeline 18 12.实战:拆包粘包理论与解决方案 20 13.ChannelHandler的生命周期 ...

    Netty 入门与实战:仿写微信 IM 即时通讯系统

    客户端同样需要配置ChannelPipeline,实现心跳机制以保持连接活跃,以及处理服务器发来的消息。 在Spring Boot集成Netty时,我们可以利用Spring的依赖注入和生命周期管理,将Netty服务器作为一个Spring Bean来创建...

    Netty 入门与实战:仿写微信 IM 即时通讯系统.zip

    《Netty 入门与实战:仿写微信 IM 即时通讯系统》是一份专为初学者设计的高质量教程,旨在帮助读者快速掌握Netty框架并应用到实际的即时通讯系统开发中,如仿写微信IM系统。Netty是Java领域内广泛使用的高性能、异步...

    Netty入门与实战:仿写微信IM即时通讯系统

    而Netty作为一个高性能的网络通信框架,在实现即时通讯系统时具有得天独厚的优势。本文将详细介绍如何利用Netty框架来实现一个简易版的微信即时通讯系统,包括单聊和群聊功能。 #### 二、Netty概述 Netty是一个...

    netty服务器通讯说明: 服务器条件NETTY框架编程: 服务器IP:192.168.2.106 端口8810

    服务器条件NETTY框架编程: 服务器IP:192.168.2.106 端口8810 数据传输的方式:从串口接收到一条完整的协议数据,计算出数据字节长度,打包成HtAlingProtocol类,并发送给服务器; package ...

    深入浅出Netty_netty5.0_

    《深入浅出Netty_netty5.0_》是针对Netty 5.0版本的一本详细教程,旨在帮助读者理解并熟练运用这一强大的网络编程框架。Netty是一个开源的Java框架,它为开发高效、稳定、可扩展的网络应用提供了全面的支持。在本文...

Global site tag (gtag.js) - Google Analytics