本文详细介绍了Twitter如何利用Scala和Netty实现高效网络通信。通过使用Netty作为通信模块，结合Scala的特性，实现了简洁且强大的网络事件处理。重点展示了NettyHandler、MemcacheHandler和TextHandler的实现，以及如何通过泛型简化协议处理。最后，提供了一个Netty服务器压测代码示例，展示了如何在实际场景中应用。
Twitter的核心队列Kestrel使用Netty作为通信模块，从另一个角度证明了Netty的性能和健壮。
Netty是否比MINA强？从底层实现，两者几乎差不多，但Netty的优势是从架构上采用事件通知机制，真正的将异步模式引入来解决各种场景。响应时间可能会加长，但优势在于系统之间的依赖减弱，自身处理能力的决定因素自封闭（瓶颈可以直接根据自身业务处理资源消耗情况估计出来）
我们看看Twitter是怎么用Netty。Twitter很多项目都是用scala写的，scala是很简洁的语言，直接运行在jvm上。可以直接调用Java类。下边的代码都是来自Twitter的核心队列项目Kestrel。这个项目很有意思，可能以后还会讨论，这里先说说怎么用Netty。
NettyHandler.scala是处理Netty网络事件的基类，其他具体协议实现类，MemcacheHandler和TextHandler都继承NettyHandler。NettyHandler应用Netty的ChannelUpStreamHandler接口，这个接口处理上行请求。同时继承KestrelHandler。KestrelHandler处理Kestrel消息队列的行为，包括getItem、setItem等等。
NettyHandler主要方法是handleUpstream。处理上行请求：MessageEvent，ChannelStatEvent，等等。这些实现基本上参照Netty官网给的sample很容易实现。方法不长，才40多行，用scala写出来，有点小清新：）
def handleUpstream(context: ChannelHandlerContext, event: ChannelEvent) {
event match {
case m: MessageEvent =>
// 具体实现由协议实现类MemcacheHandler等实现
handle(m.getMessage().asInstanceOf[M])
case e: ExceptionEvent =>
// 异常处理
e.getCause() match {
case _: ProtocolError =>
handleProtocolError()
case e: ClosedChannelException =>
finish()
case e: IOException =>
log.debug("I/O Exception on session %d: %s", sessionId, e.toString)
case e =>
log.error(e, "Exception caught on session %d: %s", sessionId, e.toString)
handleException(e)
}
e.getChannel().close()
case s: ChannelStateEvent =>
// 目前状态为connected但statevent.getValue is null，中断连接
if ((s.getState() == ChannelState.CONNECTED) && (s.getValue() eq null)) {
finish()
} else if ((s.getState() == ChannelState.OPEN) && (s.getValue() == true)) {
// 创建连接
channel = s.getChannel()
remoteAddress = channel.getRemoteAddress.asInstanceOf[InetSocketAddress]
if (clientTimeout.isDefined) {
channel.getPipeline.addFirst("idle", new IdleStateHandler(Kestrel.kestrel.timer, 0, 0, clientTimeout.get.inSeconds.toInt))
}
channelGroup.add(channel)
// don't use `remoteAddress.getHostName` because it may do a DNS lookup.
log.debug("New session %d from %s:%d", sessionId, remoteAddress.getAddress.getHostAddress, remoteAddress.getPort)
}
case i: IdleStateEvent =>
// 增加idel监控
log.debug("Idle timeout on session %s", channel)
channel.close()
case e =>
// 其他消息继续发出upstream事件
context.sendUpstream(e)
}
}
MemcacheHandler和TextHandler是协议具体的实现。继承NettyHandler。因为Memcached协议比较简单，所以协议实现类就不多说了。阅读这些代码主要的障碍还是在于Java程序员对于某些scala的语法不习惯。我这里介绍个简单但是常用的：Scala的泛型。Scala创始人Martin Odersky曾说过，泛型正是他想要创建Scala语言的最重要因素之一。当然Java1.5以后已经引入了泛型，我们对这个东东已经很熟悉了。看看Twitter怎么使用Scala泛型。比教科书上生动很多。和Java使用<>指定泛型类似，NettyHandler中Scala的泛型M，放在[]里。
abstract class NettyHandler[M](
val channelGroup: ChannelGroup,
queueCollection: QueueCollection,
maxOpenTransactions: Int,
clientTimeout: Option[Duration])
extends KestrelHandler(queueCollection, maxOpenTransactions) with
ChannelUpstreamHandler {
...
def handleUpstream(context: ChannelHandlerContext, event: ChannelEvent) {
event match {
case m: MessageEvent =>
handle(m.getMessage().asInstanceOf[M])
}
...
}
在NettyHandler中，任何MessageEvent都被转换为泛型M，并交给子类处理。TextHandler和MemcacheHandler是这样给自己的泛型定义的。
class TextHandler( ...) extends NettyHandler[TextRequest](...)
class MemcacheHandler(...) extends NettyHandler[MemcacheRequest](...)
接下来我们自己写一个Scala程序。
Netty服务器压测代码网上有不少版本，基本思路就是实现一个简单的echo handler。还可以添加了一个server主动push的部分。代码用scala实现，可以作为朋友们学习scala的例子。
import org.jboss.netty.channel._
import org.jboss.netty.buffer._
import org.jboss.netty.bootstrap.ServerBootstrap
import java.util._
import java.util.concurrent._
import java.io._
import java.net._
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import scala.collection.mutable
object NettyLoadServer {
def main(args: Array[String]): Unit = {
val testServer = new NettyLoadServer();
testServer.loadTest();
}
}
class NettyLoadServer {
var channel: Channel = null
private var remoteAddress: InetSocketAddress = null
val channels = new mutable.ListBuffer[Channel];
var number = 0;
class LoadTestHandler extends SimpleChannelHandler with ChannelUpstreamHandler {
override def exceptionCaught(ctx: ChannelHandlerContext, e: ExceptionEvent)
{
e.getCause().printStackTrace();
channels -= e.getChannel()
e.getChannel().close();
}
override def messageReceived(ctx: ChannelHandlerContext, e: MessageEvent) {
e.getChannel().write(e.getMessage());
}
override def handleUpstream(ctx: ChannelHandlerContext, e: ChannelEvent) {
e match {
case s: ChannelStateEvent =>
if ((s.getState() == ChannelState.OPEN) && (s.getValue() == true)) {
channel = s.getChannel()
remoteAddress = channel.getRemoteAddress.asInstanceOf[InetSocketAddress]
channels += channel
System.out.println("New session from " + remoteAddress.getAddress.getHostAddress +
":" + remoteAddress.getPort)
}
case e =>
// ignore
}
super.handleUpstream(ctx, e);
}
}
class ChannelManagerThread extends Thread {
override def run() {
while (true) {
try {
System.out.println("channels.size() = " + channels.count(c => c.isInstanceOf[Channel]));
for(s <- channels) {
var cb = new DynamicChannelBuffer(256);
cb.writeBytes("abcd1234".getBytes());
s.write(cb);
}
Thread.sleep(500);
}
catch {
case e => e.printStackTrace();
}
}
}
}
def loadTest() {
try {
val factory = new NioServerSocketChannelFactory(Executors
.newCachedThreadPool(), Executors.newCachedThreadPool());
val bootstrap = new ServerBootstrap(factory);
val handler = new LoadTestHandler();
val pipeline = bootstrap.getPipeline();
pipeline.addLast("loadtest", handler);
bootstrap.setOption("child.tcpNoDelay", true);
bootstrap.setOption("child.keepAlive", true);
bootstrap.bind(new InetSocketAddress(8007));
val cmt = new ChannelManagerThread();
cmt.start();
}
catch {
case e => e.printStackTrace();
}
}
}
附件里是我的scala sbt工程。
压测client推荐使用Jboss自己的Benchmark：
http://anonsvn.jboss.org/repos/netty/subproject/benchmark/
用ab也可以：
ab -n 20000 -c 20000 -k -t 999999999 -r http://192.168.1.2:8007/
补充：Twitter还有很多很有意思的项目，希望有兴趣的朋友一起来研究学习。
扫一扫
1278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
