Netty框架入门

最新推荐文章于 2025-02-25 22:27:00 发布
最新推荐文章于 2025-02-25 22:27:00 发布
阅读量1.7k 收藏
点赞数
分类专栏： Netty 文章标签： Netty

1：下载netty的jar和官方文档：http://www.jboss.org/netty/。现在的稳定版netty-3.6.3.Final-dist.tar.bz2。

2：将一个jar(netty-3.6.3.Final.jar)加到项目中，另一个源码包(netty-3.6.3.Final-sources.jar)也可以加进去。

3：例子实现

《服务端程序》

(一)首先编写解码器

MessageDecoder.java

/**
 * 解码器的类
 */
package test;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.frame.FrameDecoder;

/**
 * @author 桑叶
 *
 */
public class MessageDecoder extends FrameDecoder{

	@Override
	protected Object decode(ChannelHandlerContext ctx, Channel channel,
			ChannelBuffer buffer) throws Exception {
		// TODO 自动生成的方法存根
		if (buffer.readableBytes() < 4) {
			return null;
		}
		int dataLength = buffer.getInt(buffer.readerIndex());
		if (buffer.readableBytes() < dataLength+4) {
			return null;
		}
		buffer.skipBytes(4);
		byte[] decoded = new byte[dataLength];
		buffer.readBytes(decoded);
		String msg = new String(decoded);
		return msg;
	}

	
}

MessageDecoder继承自FrameDecoder，FrameDecoder是Netty code包中的辅助类，它是个ChannelUpstreamHandler，decode方法是FrameDecoder子类需要实现的。在上面的代码中有：

（1）检查ChannelBuffer中的字节数，如果ChannelBuffer可读的字节数少于4，则返回null等待下次读事件。

（2）继续检查ChannelBuffer中的字节数，如果ChannelBuffer可读的字节数少于dataLength+4，则返回null等待下次读事件。

（3）越过dataLength的字节。

（4）构造解码的字符串返回。
(二)编码器

/**
 * 编码器
 */
package test;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.oneone.OneToOneEncoder;

/**
 * @author 桑叶
 *
 */
public class MessageEncoder extends OneToOneEncoder {

	@Override
	protected Object encode(ChannelHandlerContext ctx, Channel channel,
			Object msg) throws Exception {
		// TODO 自动生成的方法存根
		if (!(msg instanceof String)) {
			return msg;
		}
		String res = (String)msg;
		byte[] data = res.getBytes();
		int dataLength = data.length;
		ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
		buffer.writeInt(dataLength);
		buffer.writeBytes(data);
		return buffer;
	}
}



MessageEncoder是个ChannelDownstreamHandler。对该类的注解如下：

（1）如果编码的msg不是合法的类型，就直接返回该msg，之后OneToOneEncoder会调用ctx.sendDownstream(evt)；来调用下一个ChannelDownstreamHandler。对于该例子来说，这种情况不应该出现的。

（2）开发者创建ChannelBuffer的用武之地就是这儿了，通常使用dynamicBuffer即可，表示得到的ChannelBuffer可动态增加大小。

（3）返回编码后的ChannelBuffer之后，OneToOneEncoder会调用Channels.write将数据写回客户端。

(三)服务端业务处理

/**
 * 服务端业务处理
 */
package test;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;

/**
 * @author 桑叶
 *
 */
public class MessageServerHandler extends SimpleChannelUpstreamHandler {

	private static final Logger logger = Logger.getLogger(MessageServerHandler.class.getName());
	
	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
		if (!(e.getMessage() instanceof String)) {
			return ;
		}
		String msg = (String)e.getMessage();
		System.err.println("got msg:"+msg);
		e.getChannel().write(msg);
	}
	
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
		logger.log(
				Level.WARNING,
				"Unexpected exception from downstream.",
				e.getCause());
		e.getChannel().close();
	}
	
	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
		
	}
	
}


MessageServerHandler是服务端业务处理handler，其继承自SimpleChannelUpstreamHandler,并主要实现messageReceived事件。对该类的注解如下：

（1）该upstream事件流中，首先经过MessageDecoder，其会将decoder返回的解码后的数据结构造成MessageEvent.getMessage()，所以在handler上下文关系中，MessageEvent.getMessage()并不一定都返回ChannelBuffer
（2）MessageServerHandler只是简单的将得到的msg再写回给客户端。

e.getChannel().write(msg);操作将触发DownstreamMessageEvent事件，也就是调用上面的MessageEncoder将编码的数据返回给客户端。

(三)服务端主程序

/**
 * 服务端
 */
package test;

import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;

/**
 * @author 桑叶
 *
 */
public class MessageServer {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		ServerBootstrap bootstrap = new ServerBootstrap(
				new NioServerSocketChannelFactory(
						Executors.newCachedThreadPool(),
						Executors.newCachedThreadPool()));
		
		bootstrap.getPipeline().addLast("decoder", new MessageDecoder());
		bootstrap.getPipeline().addLast("encoder", new MessageEncoder());
		bootstrap.getPipeline().addLast("handler", new MessageServerHandler());
		
		bootstrap.bind(new InetSocketAddress(9550));
	}
}


（1）启动服务端主程序

（2）创建了3个ChannelHandler，需要将他们注册到ChannelPipeline，而ChannelPipeline又是和Channel对应的（是全局单例还是每个Channel对应一个ChannelPipline实例依赖于实现）。

（3）可以实现ChannelPipline的工厂接口ChannelPiplineFactory实现该目的。
（4）最后绑定端口号

《客户端程序》

(一)客户端处理

/**
 * 客户端处理
 */
package test;


import java.util.logging.Level;
import java.util.logging.Logger;


import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;


/**
 * @author 桑叶
 *
 */
public class MessageClientHandler extends SimpleChannelUpstreamHandler {


<span style="white-space:pre">	</span>private static final Logger logger = Logger.getLogger(MessageClientHandler.class.getName());
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
<span style="white-space:pre">		</span>String message = "hello kafka0102";
<span style="white-space:pre">		</span>e.getChannel().write(message);
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
<span style="white-space:pre">		</span>System.out.println("messageReceived send message "+e.getMessage());
<span style="white-space:pre">		</span>try {
<span style="white-space:pre">			</span>Thread.sleep(3000);
<span style="white-space:pre">		</span>} catch (InterruptedException ex) {
<span style="white-space:pre">			</span>// TODO: handle exception
<span style="white-space:pre">			</span>ex.printStackTrace();
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>e.getChannel().write(e.getMessage());
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
<span style="white-space:pre">		</span>logger.log(
<span style="white-space:pre">				</span>Level.WARNING,
<span style="white-space:pre">				</span>"Unexpected exception from downstream.",
<span style="white-space:pre">				</span>e.getCause());
<span style="white-space:pre">		</span>e.getChannel().close();
<span style="white-space:pre">	</span>}
}


（1）客户端是先发送数据到服务端（downstream事件流），然后是处理从服务端接收的数据（upstream事件流）。

（2）这里有个问题是，怎么把需要发送的数据送到downstream事件流里呢？

这就用到了ChannelUpstreamHandler的channelConnected事件了。
(二)客户端主程序

/**
 * 客户端
 */
package test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;

/**
 * @author 桑叶
 *
 */
public class MessageClient {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		// TODO 自动生成的方法存根
		create();
	}
	
	public static void create() {
		String host = "127.0.0.1";
		int port = 9550;
		//实例化一个客户端Bootstrap实例，其中NioClientSocketChannelFactory实例由Netty提供
		ClientBootstrap bootstrap = new ClientBootstrap(
				new NioClientSocketChannelFactory(
						Executors.newCachedThreadPool(),
						Executors.newCachedThreadPool()));
		//设置PipelineFactory,由客户端自己实现
		bootstrap.getPipeline().addLast("decoder", new MessageDecoder());
		bootstrap.getPipeline().addLast("encoder", new MessageEncoder());
		bootstrap.getPipeline().addLast("handler", new MessageClientHandler());
		
		//开始请求连接
		ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));
		//等待连接关闭 或 请求连接失败
		future.getChannel().getCloseFuture().awaitUninterruptibly();
		
		//释放外部资源
		bootstrap.releaseExternalResources();
	}
}


《调试》

首先运行 MessageServer 服务端程序，然后再运行 MessageClient 客户端程序.

结果如下：

messageReceived send message hello kafka0102
messageReceived send message hello kafka0102
messageReceived send message hello kafka0102

......


1.Netty框架入门
大李出奇迹的博客
03-05 397
Netty框架入门 首先声明在学习的过程中参考了netty5的user guide。在此非常感谢netty的贡献者社区。在本篇博客中，将会基于netty5实现最简单的读取和发送数据的功能。代码中有一些自己的理解，以注释形式给出。 参考手册地址：http://ifeve.com/netty5-user-guide/ ...
Netty框架入门-ChannelPipeline 详细使用
码农杰森
08-04 892
前言 上篇讲解ChannelHandler的使用以及相关子类的使用，这一篇继续来讲讲ChannelPipeline与ChannelHandlerContext，它们三者的有效组合让Netty在处理业务逻辑上得心应手。在讲ChannelHandlerContext之前先来讲讲ChannelPipeline。 ChannalPipeline Pipeline 可以翻译成管道，在Netty中ChannelPipeline的作用也如同一条管道，通过这条管道处理入站与出站的数据、事件；通过ChannelPipelin
netty整理
最新发布
u012201744的博客
02-25 1062
Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端注意 ：如果使用传统NIO，其工作量大，bug 多Netty 对 API 进行增强，使之更易用，如 2、客户端代码 3、调用流程图 EventLoop 本质是一个 单线程执行器 （同时 维护了一个 Selector ），里面有 run 方法处理一个或多个 Channel 上源源不断的 io 事件它的继承关系如下EventLoopGroup 是一组 EventLoop，Channel 一般会调用 EventL
2.Netty框架入门案例总结
大李出奇迹的博客
03-05 266
总结概述 结合netty的手册和第一个例子以及相关的实验。总结一部分内容，放在这个博客中。 归纳 在每个server端都是使用一样的模板代码，根据业务场景配置一下参数。具体的处理逻辑都是写在handler中。 channel的write方法并没有给你发数据，flush之后才会发出。所以正式开发中使用集成方法：writeAndFlush(buf)。 如果写代码时出现了write方法，netty会自...
Netty-Netty入门实例
J三石的博客
06-07 466
Netty入门实例-TCP服务 实例要求 Netty服务器在6668端口监听，客户端能发送消息给服务器“hello，服务器” 服务器可以回复消息给客户端“hello，客户端” 步骤 服务端步骤 创建了两个NIOEventLoopGroup线程组，BossGroup和WorkerGroup BossGroup只处理连接请求，真正的客户端的业务处理会交给WorkerGroup 两个NioEventLoopGroup都是无限循环的 创建服务端的启动对象（根据服务端启动引导类ServerBoo
Netty框架入门：构建简单客户端与服务端
标题中提到的“netty框架最简单的客户端服务端代码”，指的是Netty框架实现的最基本的网络通信模型。Netty是一个高性能、异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。Netty广泛用于...
Netty框架入门篇 - 初识Netty及第一款Netty应用程序
wzljiayou的博客
11-25 3536
文章目录初识NettyNetty简介为什么用NettyNetty特性总结异步和事件驱动Netty核心组件简介Channel事件和ChannelHandlerChannelFutureEventLoop、EventLoopGroup总结 初识Netty Netty简介 Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。在网络编程领域，Netty是Java的卓越框架，它驾驭了Java高级API的能力，并将其隐藏在一个易于使用的API之后，通过Netty
超详细Netty入门，看这篇就够了！
weixin_43139183的博客
05-07 1912
在前面介绍Channel时，我们知道可以在channel中装配ChannelHandler流水线处理器，那一个channel不可能只有一个channelHandler处理器，肯定是有很多的，既然是很多channelHandler在一个流水线工作，肯定是有顺序的。稍微在本地调试过，用起来和Nio有一些不同，是阻塞的，所以API调用也不一样。Netty中的Selector也和NIO的Selector是一样的，就是用于监听事件，管理注册到Selector中的channel，实现多路复用器。
Netty框架入门-目录整理(已完结)
码农杰森
08-03 255
前言 用一个月的时间完成了Netty框架入门文章，文章总共8篇；这次的入门使用一个使用Netty框架完成的一个包含服务端与客户端通信功能的小例子。再围绕这个例子介绍Netty的Bytebuf、ChannelHandler、ChannelPipeline、Bootstrap等组件的使用及相关原理，并没有细讲实现的原理有些可能会过一下，文章中大多会使用服务端与客户端的例子重复的进行说明、拆解等。通过这一系列文章你可以掌握这些知识与技能： 如何使用Netty框架 Netty框架有那些主要组件 Bytebuf中常
Netty （netty-netty-5.0.0.Alpha2.tar.gz）
06-07
Netty （netty-netty-5.0.0.Alpha2.tar.gz）是一个 NIO 客户端服务器框架，可以快速轻松地开发协议服务器和客户端等网络应用程序。它极大地简化和流线了网络编程，例如 TCP 和 UDP 套接字服务器。 “快速和简单”并不意味着生成的应用程序会受到可维护性或性能问题的影响。Netty 是根据从实现许多协议（如 FTP、SMTP、HTTP 以及各种二进制和基于文本的旧协议）中获得的经验精心设计的。因此，Netty 成功地找到了一种方法，可以在不妥协的情况下实现易于开发、性能、稳定性和灵活性。
netty-4.1.42.Final.tar.bz2
10-12
linux下netty包，用来作网络爬虫测试，通过netty来实现每秒1000+次请求，这个是netty包，为了方便把他传上来
Netty 5.0.0.Alpha2 版本 Netty 5.0 jar包下载 【Jar包 + 源代码 + Netty API文档】
02-11
Netty 5.0.0.Alpha2 版本，包含：Jar包+源代码+API文档。 官网Netty 5.0版本已经废弃，所以发布出来，方便大家下载。 《Netty权威指南》一书使用的就是Netty 5.0
Netty源码分析（三）--- 新连接进来如何初始化NioSocketChannel
醒不来的梦的博客
12-26 308
一、NioSocketChannel的初始化 从NioEventLoop开始说起 我们在服务端启动后，boss线程组会启动一个NioEventLoop线程，它会在run方法中无限循环接收感兴趣的事件//1. NioEventLoop //新连接进来会触发ACCEPT事件 @Override protected void run() { for (;;) { try { ...
elasticsearch 报错： No value specified for terms query
Angus
01-15 2687
Failed to execute phase [dfs], all shards failed; shardFailures {[felf1bKUSY6sbP3-1ZJCoQ][test_index][0]: RemoteTransportException[[node-3][172.20.21.37:9300][indices:data/read/search[phase/dfs]]]; nested: SearchParseException[failed to parse search sour..
利用Netty的ChannelBuffer自定义序列化
simba_1986的专栏
07-23 3083
利用Netty的ChannelBuffer自定义序列化 先定义ChannelBuffer工厂 package com.shux.common.serializer; import org.jboss.netty.buffer.ChannelBuffer; import org.jboss.netty.buffer.ChannelBuffers; /** * ChannelBuffer工
Netty实现通信的步骤及代码
weixin_36802143的博客
02-26 602
1.创建两个NIO线程组,一个专用于网络事件处理(接受客户端的连接),另一个 则进行网络通信的读写 2.创建一个ServerBootstrap对象,设置Netty的一系列参数,例如接受传输数据的缓存大小等 3.创建一个实际处理数据的类ChannelInitializer,进行初始化准备工作,设置接受数据的字符集,格式,已实际处理数据的接口 4.绑定端口,执行同步阻塞方法等待服务器端启动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值