BlogJava-Chan Chen Coding...-文章分类-Netty

Netty 4.0 源码分析（八）：Netty 4.0中的io.netty.buffer包

Chan Chen — Tue, 27 Nov 2012 03:34:00 GMT

摘要: Netty 4.0的源码结构与之前的3.X版本发生了较大的变化，以下是Netty 4.0源码的层次结构 netty/ common/ - utility and logging buffer/ - buffer API ... 阅读全文

Chan Chen 2012-11-27 11:34 发表评论

Netty 4.0 源码分析（七）：AbstractBootstrap抽象类

Chan Chen — Mon, 26 Nov 2012 02:57:00 GMT

AbstractBootstrap是一个帮助类，通过方法链（method chaining）的方式，提供了一个简单易用的方式来配置Bootstrap，然后启动一个Channel。在理解Netty源码中的AbstractBootstrap， ServerBootstrap和Bootstrap之前，应该先了解一下什么是method chaining。

Wiki上面对于method chaining的定义如下：

Method chaining, is a common technique for invoking multiple method calls in object-oriented programming languages. Each method returns an object (possibly the current object itself), allowing the calls to be chained together in a single statement.

在面向对象的编程语言中，method chaining是一种用于调用多个方法的常用技术。每个方法都会返回一个对象（可能是当前对象本身），这样做的好处就是，通过一条语句，就可以讲所有的方法调用链接在一起。

定义有一些抽象，那么可以通过实际的例子来进行理解和消化。

假设有一个StringBuffer的类，类中有一个append()方法

public class StringBuffer {
  public void append(String str) {
    //  useful code
  }
}

这个类有缺点就是说，在向StringBuffer对象追加新的字符串的时候，需要在多条语句中，不断的调用append()方法。

StringBuffer sb = new StringBuffer();
sb.append("Hello ");
sb.append(name);
sb.append("! Welcome!");

而method chaining的实现，就可以避免这个缺陷。

public class StringBuffer {
  public StringBuffer append(String str) {
    //  useful code 
    return this;
  }
}

现在我们就可以再一条语句中实现第一个例子的功能了。

StringBuffer sb = new StringBuffer();
sb.append("Hello ").append(name).append("! Welcome!");

AbstractBootstrap抽象类（部分代码）

package io.netty.bootstrap;

public abstract class AbstractBootstrapextends AbstractBootstrap> {
    private EventLoopGroup group;
    private ChannelFactory factory;
    private SocketAddress localAddress;
    private final Map, Object> options = new LinkedHashMap, Object>();
    private final Map, Object> attrs = new LinkedHashMap, Object>();
private ChannelHandler handler;

    @SuppressWarnings("unchecked")
    public B group(EventLoopGroup group) {
        if (group == null) {
            throw new NullPointerException("group");
        }
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        this.group = group;
        return (B) this;
    }
    public B channel(Classextends Channel> channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new BootstrapChannelFactory(channelClass));
    }
    @SuppressWarnings("unchecked")
    public B channelFactory(ChannelFactory factory) {
        if (factory == null) {
            throw new NullPointerException("factory");
        }
        if (this.factory != null) {
            throw new IllegalStateException("factory set already");
        }
        this.factory = factory;
        return (B) this;
    }
    @SuppressWarnings("unchecked")
    public B localAddress(SocketAddress localAddress) {
        this.localAddress = localAddress;
        return (B) this;
    }
    @SuppressWarnings("unchecked")
    public  B option(ChannelOption option, T value) {
        if (option == null) {
            throw new NullPointerException("option");
        }
        if (value == null) {
            options.remove(option);
        } else {
            options.put(option, value);
        }
        return (B) this;
    }
    public  B attr(AttributeKey key, T value) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        if (value == null) {
            attrs.remove(key);
        } else {
            attrs.put(key, value);
        }
        return (B) this;
    }
    @SuppressWarnings("unchecked")
    public B handler(ChannelHandler handler) {
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        this.handler = handler;
        return (B) this;
}
}

AbstractBootstrap声明了六个私有的成员变量，EventLoopGroup对象，ChannelFacotry对象，SockteAddress对象，Map,Object>对象，Map,Object>对象，ChannelHandler对象。并且有相对应的方法，来设置这些对象，如

public B group(EventLoopGroup group) {
        if (group == null) {
            throw new NullPointerException("group");
        }
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        this.group = group;
        return (B) this;
}

通过传进来的group对象，然后将AbstractBootstrap中的group指向传进来的group。最终返回的还是AbstractBootstrap这个当前对象。

六个对象的作用

EventLoopGroup group	用于处理将要被创建的所有event
ChannelFactory factory	建立一个工厂，用于以后的Channel创建
SocketAddress localAddress;	用于绑定本地的网络地址
Map, Object> options	指定所创建Channel的选项，如TCP_NODELAY，AIO_READ_TIMEOUT
Map, Object> attrs	指定所创建Channel的属性
ChannelHandler handler	用于处理各类请求

AbstractBootstrap抽象类的接口

AbstractBootstrap抽象类UML图

ServerBootstrap和Bootstrap

在Netty 4.0中，ServerBootstrap用于为服务器启动ServerChannel，Bootstrap用于为客服端启动Channel。这两个类是AbstractBootstrap的具体实现。

备注:因为笔者开始写Netty源码分析的时候，Netty 4.0还是处于Alpha阶段，之后的API可能还会有改动，笔者将会及时更改。使用开源已经有好几年的时间了，一直没有时间和精力来具体研究某个开源项目的具体实现，这次是第一次写开源项目的源码分析，如果文中有错误的地方，欢迎读者可以留言指出。对于转载的读者，请注明文章的出处。

希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-26 10:57 发表评论

Netty 4.0 源码分析（六）：EventLoop和EventLoopGroup

Chan Chen — Sun, 25 Nov 2012 13:49:00 GMT

EventLoop相当于一个Thread线程，而EventLoopGroup则是管理这些EventLoop的Thread线程池

EventLoop接口

package io.netty.channel;

public interface EventLoop extends EventExecutor, EventLoopGroup {
@Override
EventLoopGroup parent();
}

EventLoop接口UML图

parent()方法

返回管理这个EventLoop的EventLoopGroup。

EventLoopGroup接口

package io.netty.channel;
public interface EventLoopGroup extends EventExecutorGroup {
    @Override
    EventLoop next();
    ChannelFuture register(Channel channel);
    ChannelFuture register(Channel channel, ChannelFuture future);
}

EventLoopGroup接口UML图

next()

返回下一个EventLoop

register(Channel channel)

指定一个EventLoopGroup来注册某个Channel。

希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-25 21:49 发表评论

Netty 4.0 源码分析（四）：ByteBuf

Chan Chen — Sun, 25 Nov 2012 12:44:00 GMT

Netty是基于流的消息传递机制。Netty框架中，所有消息的传输都依赖于ByteBuf接口，ByteBuf是Netty NIO框架中的缓冲区。ByteBuf接口可以理解为一般的Byte数组，不过Netty对Byte进行了封装，增加了一些实用的方法。

ChannelBuf接口

package io.netty.buffer;
public interface ChannelBuf {
ChannelBufType type();
boolean isPooled();
}

ByteBuf接口

package io.netty.buffer;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
public interface ByteBuf extends ChannelBuf, Comparable {
    int capacity();
    ByteBuf capacity(int newCapacity);
    int maxCapacity();
    ByteOrder order();
    ByteBuf order(ByteOrder endianness);
    boolean isDirect();
    int readerIndex();
    ByteBuf readerIndex(int readerIndex);
    int writerIndex();
    ByteBuf writerIndex(int writerIndex);
    ByteBuf setIndex(int readerIndex, int writerIndex);
    int readableBytes();
    int writableBytes();
    boolean readable();
    boolean writable();
    ByteBuf clear();
    ByteBuf markReaderIndex();
    ByteBuf resetReaderIndex();
    ByteBuf markWriterIndex();
    ByteBuf resetWriterIndex();
    ByteBuf discardReadBytes();
    ByteBuf ensureWritableBytes(int minWritableBytes);
    int ensureWritableBytes(int minWritableBytes, boolean force);
    boolean getBoolean(int index);
    byte  getByte(int index);
    short getUnsignedByte(int index);
    short getShort(int index);
    int getUnsignedShort(int index);
    int   getMedium(int index);
    int   getUnsignedMedium(int index);
    int   getInt(int index);
    long  getUnsignedInt(int index);
    long  getLong(int index);
    char  getChar(int index);
    float getFloat(int index);
    double getDouble(int index);
    ByteBuf getBytes(int index, ByteBuf dst);
    ByteBuf getBytes(int index, ByteBuf dst, int length);
    ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length);
    ByteBuf getBytes(int index, byte[] dst);
    ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length);
    ByteBuf getBytes(int index, ByteBuffer dst);
    ByteBuf getBytes(int index, OutputStream out, int length) throws IOException;
    int getBytes(int index, GatheringByteChannel out, int length) throws IOException;
    ByteBuf setBoolean(int index, boolean value);
    ByteBuf setByte(int index, int value);
    ByteBuf setShort(int index, int value);
    ByteBuf setMedium(int index, int   value);
    ByteBuf setInt(int index, int   value);
    ByteBuf setLong(int index, long  value);
    ByteBuf setChar(int index, int value);
    ByteBuf setFloat(int index, float value);
    ByteBuf setDouble(int index, double value);
    ByteBuf setBytes(int index, ByteBuf src);
    ByteBuf setBytes(int index, ByteBuf src, int length);
    ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length);
    ByteBuf setBytes(int index, byte[] src);
    ByteBuf setBytes(int index, byte[] src, int srcIndex, int length);
    ByteBuf setBytes(int index, ByteBuffer src);
    int setBytes(int index, InputStream in, int length) throws IOException;
    int  setBytes(int index, ScatteringByteChannel in, int length) throws IOException;
    ByteBuf setZero(int index, int length);
     boolean readBoolean();
    byte  readByte();
    short readUnsignedByte();
    short readShort();
    int   readUnsignedShort();
    int   readMedium();
    int   readUnsignedMedium();
    int   readInt();
    long  readUnsignedInt();
    long  readLong();
    char  readChar();
    float readFloat();
    double readDouble();
    ByteBuf readBytes(int length);
    ByteBuf readSlice(int length);
    ByteBuf readBytes(ByteBuf dst);
    ByteBuf readBytes(ByteBuf dst, int length);
    ByteBuf readBytes(ByteBuf dst, int dstIndex, int length);
    ByteBuf readBytes(byte[] dst);
    ByteBuf readBytes(byte[] dst, int dstIndex, int length);
    ByteBuf readBytes(ByteBuffer dst);
    ByteBuf readBytes(OutputStream out, int length) throws IOException;
    int  readBytes(GatheringByteChannel out, int length) throws IOException;
    ByteBuf skipBytes(int length);
    ByteBuf writeBoolean(boolean value);
    ByteBuf writeByte(int value);
    ByteBuf writeShort(int value);
    ByteBuf writeMedium(int   value);
    ByteBuf writeInt(int   value);
    ByteBuf writeLong(long  value);
    ByteBuf writeChar(int value);
    ByteBuf writeFloat(float value);
    ByteBuf writeDouble(double value);
    ByteBuf writeBytes(ByteBuf src);
    ByteBuf writeBytes(ByteBuf src, int length);
    ByteBuf writeBytes(ByteBuf src, int srcIndex, int length);
    ByteBuf writeBytes(byte[] src);
    ByteBuf writeBytes(byte[] src, int srcIndex, int length);
    ByteBuf writeBytes(ByteBuffer src);
    int  writeBytes(InputStream in, int length) throws IOException;
    int  writeBytes(ScatteringByteChannel in, int length) throws IOException;
    ByteBuf writeZero(int length);
    int indexOf(int fromIndex, int toIndex, byte value);
    int indexOf(int fromIndex, int toIndex, ByteBufIndexFinder indexFinder);
    int bytesBefore(byte value);
    int bytesBefore(ByteBufIndexFinder indexFinder);
    int bytesBefore(int length, byte value);
    int bytesBefore(int length, ByteBufIndexFinder indexFinder);
    int bytesBefore(int index, int length, byte value);
    int bytesBefore(int index, int length, ByteBufIndexFinder indexFinder);
    ByteBuf copy();
    ByteBuf copy(int index, int length);
    ByteBuf slice();
    ByteBuf slice(int index, int length);
    ByteBuf duplicate();
    boolean hasNioBuffer();
    ByteBuffer nioBuffer();
    ByteBuffer nioBuffer(int index, int length);
    boolean hasNioBuffers();
    ByteBuffer[] nioBuffers();
    ByteBuffer[] nioBuffers(int offset, int length);
    boolean hasArray();
    byte[] array();
    int arrayOffset();
    String toString(Charset charset);
    String toString(int index, int length, Charset charset);
    @Override
    int hashCode();
    @Override
    boolean equals(Object obj);
    @Override
    int compareTo(ByteBuf buffer);
    @Override
    String toString();
    Unsafe unsafe();
    interface Unsafe {
        ByteBuffer nioBuffer();
        ByteBuffer[] nioBuffers();
        ByteBuf newBuffer(int initialCapacity);
        void discardSomeReadBytes();
        void acquire();
        void release();
    }
}

ByteBuf Index

ByteBuf通过两个指针来协助I/O的读写操作，读操作的readIndex和写操作的writeIndex

readerIndex和writerIndex都是一开始都是0，随着数据的写入writerIndex会增加，读取数据会使readerIndex增加，但是他不会超过writerIndx，在读取之后，0-readerIndex的就被视为discard的.调用discardReadBytes方法,可以释放这部分空间,他的作用类似ByeBuffer的compact方法;

读和写的时候Index是分开的，因此也就没必要再每次读完以后调用flip方法，另外还有indexOf、bytesBefore等一些方便的方法；

ByteBuf的几个重要方法

discardReadBytes()
丢弃已读的内容。其执行过程如下：
调用discardReadBytes()之前：

调用 discardReadBytes()方法后

clear()
丢弃所有的数据，并将readerIndex和writerIndex重置为0。

调用clear()之前

调用clear()之后

希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-25 20:44 发表评论

Netty 4.0 源码分析（五）：ChannelHandlerContext和ChannelHandler

Chan Chen — Sun, 25 Nov 2012 08:51:00 GMT

ChannelHandlerContext接口

1 package io.netty.channel;
2 import io.netty.buffer.ByteBuf;
3 import io.netty.buffer.MessageBuf;
4 import io.netty.util.AttributeMap;
5 import java.nio.channels.Channels;
6 import java.util.Set;
7 public interface ChannelHandlerContext
8          extends AttributeMap, ChannelFutureFactory,
9                  ChannelInboundInvoker, ChannelOutboundInvoker {
10     Channel channel();
11     ChannelPipeline pipeline();
12     EventExecutor executor();
13     String name();
14     ChannelHandler handler();
15     Set types();
16     boolean hasInboundByteBuffer();
17     boolean hasInboundMessageBuffer();
18     ByteBuf inboundByteBuffer();
19      MessageBuf inboundMessageBuffer();
20     boolean hasOutboundByteBuffer();
21     boolean hasOutboundMessageBuffer();
22     ByteBuf outboundByteBuffer();
23      MessageBuf outboundMessageBuffer();
24     ByteBuf replaceInboundByteBuffer(ByteBuf newInboundByteBuf);
25      MessageBuf replaceInboundMessageBuffer(MessageBuf newInboundMsgBuf);
26     ByteBuf replaceOutboundByteBuffer(ByteBuf newOutboundByteBuf);
27      MessageBuf replaceOutboundMessageBuffer(MessageBuf newOutboundMsgBuf);
28     boolean hasNextInboundByteBuffer();
29     boolean hasNextInboundMessageBuffer();
30     ByteBuf nextInboundByteBuffer();
31     MessageBuf nextInboundMessageBuffer();
32     boolean hasNextOutboundByteBuffer();
33     boolean hasNextOutboundMessageBuffer();
34     ByteBuf nextOutboundByteBuffer();
35     MessageBuf nextOutboundMessageBuffer();
36     boolean isReadable();
37     void readable(boolean readable);
38 }

ChannelHandlerContext接口UML类

ChannelHandlerContext接口的几个重要方法

ChannelPipeline pipeline();

返回属于当前ChannelHandlerContext的ChannelPipeline。

EventExecutor executor();

EnventExcutor用于调度EventLoop中的event，这个方法返回当前的EventExecutor。

一个Handler可以有多个Context

一个Handler可以被添加到多个ChannelPipeline。这就意味着一个ChannelHandler可以有多个ChannelHandlerContext。

ChannelHandler接口

1 package io.netty.channel;
2
3 import io.netty.channel.group.ChannelGroup;
4 import java.lang.annotation.Documented;
5 import java.lang.annotation.ElementType;
6 import java.lang.annotation.Inherited;
7 import java.lang.annotation.Retention;
8 import java.lang.annotation.RetentionPolicy;
9 import java.lang.annotation.Target;
10 import java.nio.channels.Channels;
11
12 public interface ChannelHandler {
13     void beforeAdd(ChannelHandlerContext ctx) throws Exception;
14     void afterAdd(ChannelHandlerContext ctx) throws Exception;
15     void beforeRemove(ChannelHandlerContext ctx) throws Exception;
16     void afterRemove(ChannelHandlerContext ctx) throws Exception;
17     void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;
18     void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception;
19     @Inherited
20     @Documented
21     @Target(ElementType.TYPE)
22     @Retention(RetentionPolicy.RUNTIME)
23     @interface Sharable {
24         // no value
25     }
26 }

ChannelHandler类UML图

ChannelHandler中的几个重要方法

ChannelHandler有两个子接口，ChannelUpstreamHandler和ChannelDownstreamHandler。

1. ChannelUpstreamHandler用于处理和拦截upstream中的ChannelEvent

2. ChannelDownstreamHandler用于处理和拦截downstream中的ChannelEvent

状态信息

ChannelHandler一般需要存储一些状态信息，以下是【官方推荐】的方法，使用成员变量。

public class DataServerHandler extends SimpleChannelHandler {
     private boolean loggedIn;
     @Override
     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
         Channel ch = e.getChannel();
         Object o = e.getMessage();
         if (o instanceof LoginMessage) {
             authenticate((LoginMessage) o);
             loggedIn = true;
         } else (o instanceof GetDataMessage) {
             if (loggedIn) {
                 ch.write(fetchSecret((GetDataMessage) o));
             } else {
                 fail();
             }
         }
     }

}

// Create a new handler instance per channel.
// See ClientBootstrap#setPipelineFactory(ChannelPipelineFactory).
public class DataServerPipelineFactory implements ChannelPipelineFactory {
     public ChannelPipeline getPipeline() {
         return Channels.pipeline(new DataServerHandler());
     }
}

或者使用ChannelLocal，代码如下

public final class DataServerState {
     public static final ChannelLocal loggedIn = new ChannelLocal<>() {
         protected Boolean initialValue(Channel channel) {
             return false;
         }
     }
     
}

 @Sharable
 public class DataServerHandler extends SimpleChannelHandler {
     @Override
     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
         Channel ch = e.getChannel();
         Object o = e.getMessage();
         if (o instanceof LoginMessage) {
             authenticate((LoginMessage) o);
             DataServerState.loggedIn.set(ch, true);
         } else (o instanceof GetDataMessage) {
             if (DataServerState.loggedIn.get(ch)) {
                 ctx.getChannel().write(fetchSecret((GetDataMessage) o));
             } else {
                 fail();
             }
         }
     }
     
}


 // Print the remote addresses of the authenticated clients:
 ChannelGroup allClientChannels = ;
 for (Channel ch: allClientChannels) {
     if (DataServerState.loggedIn.get(ch)) {
         System.out.println(ch.getRemoteAddress());
     }
 }


备注:因为笔者开始写Netty源码分析的时候，Netty 4.0还是处于Alpha阶段，之后的API可能还会有改动，笔者将会及时更改。使用开源已经有好几年的时间了，一直没有时间和精力来具体研究某个开源项目的具体实现，这次是第一次写开源项目的源码分析，如果文中有错误的地方，欢迎读者可以留言指出。对于转载的读者，请注明文章的出处。 希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-25 16:51 发表评论

Netty 4.0 源码分析（三）：Channel和ChannelPipeline

Chan Chen — Sun, 25 Nov 2012 06:53:00 GMT

摘要: Client和server通过Channel连接，然后通过ByteBuf进行传输。每个Channel有自己的Pipeline，Pipeline上面可以添加和定义Handler和Event。 Channel类 1 package io.netty.channel; 2 import io.netty.buffer.Byte... 阅读全文

Chan Chen 2012-11-25 14:53 发表评论

Netty 4.0 源码分析（二）：Echo Server

Chan Chen — Sat, 24 Nov 2012 04:38:00 GMT

Netty项目中，自带了很多使用的例子，对于刚刚开始接触和学习Netty源码的开发者来说，可以通过例子来更好的理解Netty的具体实现。源码可以再netty 4.0的example找到。

1 public class EchoServerHandler extends ChannelInboundByteHandlerAdapter {
2     private static final Logger logger = Logger.getLogger(
3             EchoServerHandler.class.getName());
4
5     @Override
6     public void inboundBufferUpdated(ChannelHandlerContext ctx, ByteBuf in) {
7         ByteBuf out = ctx.nextOutboundByteBuffer();
8         out.discardReadBytes();
9         out.writeBytes(in);
10         ctx.flush();
11     }
12
13     @Override
14     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
15         // Close the connection when an exception is raised.
16         logger.log(Level.WARNING, "Unexpected exception from downstream.", cause);
17         ctx.close();
18     }
19 }

Line 1: 声明一个EchoServerHandler, 并且继承了ChannelInboundByteHandlerAdapter。这样EchoServerHandler就可以处理client发送过来的request。

Line 6: 重写inboundBufferUpdated方法，对client发送过来的request进行对ByteBuffer对象的操作。关于ByteBuffer的概念将在以后章节讨论。

Line 7: ctx.nextOutboundByteBuffer()将返回一个ByteBuffer对象。如果该对象不存在，那么抛出UnsupportedOperationException异常。

Line 14: 重写exceptionCaught在server端捕获异常。

1 public class EchoServer {
2
3     private final int port;
4
5     public EchoServer(int port) {
6         this.port = port;
7     }
8
9     public void run() throws Exception {
10         // Configure the server.
11         ServerBootstrap b = new ServerBootstrap();
12         try {
13             b.group(new NioEventLoopGroup(), new NioEventLoopGroup())
14              .channel(NioServerSocketChannel.class)
15              .option(ChannelOption.SO_BACKLOG, 100)
16              .localAddress(new InetSocketAddress(port))
17              .childOption(ChannelOption.TCP_NODELAY, true)
18              .handler(new LoggingHandler(LogLevel.INFO))
19              .childHandler(new ChannelInitializer() {
20                  @Override
21                  public void initChannel(SocketChannel ch) throws Exception {
22                      ch.pipeline().addLast(
23                              new LoggingHandler(LogLevel.INFO),
24                              new EchoServerHandler());
25                  }
26              });
27
28             // Start the server.
29             ChannelFuture f = b.bind().sync();
30
31             // Wait until the server socket is closed.
32             f.channel().closeFuture().sync();
33         } finally {
34             // Shut down all event loops to terminate all threads.
35             b.shutdown();
36         }
37     }
38
39     public static void main(String[] args) throws Exception {
40         int port;
41         if (args.length > 0) {
42             port = Integer.parseInt(args[0]);
43         } else {
44             port = 8080;
45         }
46         new EchoServer(port).run();
47     }
48 }

Line 11: 通过ServerBootStrap对象，来启动服务器

Line 13: 通过group方法，来绑定EventLoopGroup，EventLoopGroup用来处理SocketChannel和Channel上面的所有时间和IO。

Line 16: localAddress方法用于绑定服务器地址和端口。

Line 18,19: handler方法和childhandler方法用于指定各种ChannelHandler对象，指定的ChannelHandler对象将用于处理client端来的request。

Line 21: 初始化一个Channel对象，并且绑定之前定义的EchoServerHandler类。

Line 22: 将EchoServerHandler添加到Pipeline中。

Line 29: ServerBootstrap对象准备就绪，启动server，

Line 32: 等待直到server socket关闭

public class EchoClientHandler extends ChannelInboundByteHandlerAdapter {

    private static final Logger logger = Logger.getLogger(
            EchoClientHandler.class.getName());

    private final ByteBuf firstMessage;

    /**
     * Creates a client-side handler.
     */
    public EchoClientHandler(int firstMessageSize) {
        if (firstMessageSize <= 0) {
            throw new IllegalArgumentException("firstMessageSize: " + firstMessageSize);
        }
        firstMessage = Unpooled.buffer(firstMessageSize);
        for (int i = 0; i < firstMessage.capacity(); i ++) {
            firstMessage.writeByte((byte) i);
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.write(firstMessage);
    }

    @Override
    public void inboundBufferUpdated(ChannelHandlerContext ctx, ByteBuf in) {
        ByteBuf out = ctx.nextOutboundByteBuffer();
        out.discardReadBytes();
        out.writeBytes(in);
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // Close the connection when an exception is raised.
        logger.log(Level.WARNING, "Unexpected exception from downstream.", cause);
        ctx.close();
    }
}

EchoClientHandler类的实现与EchoServerHandler类似，也都继承了ChannelInboundByteHandlerAdapter。不同在于重写了channelActive()方法。

1 public class EchoClient {
2
3     private final String host;
4     private final int port;
5     private final int firstMessageSize;
6
7     public EchoClient(String host, int port, int firstMessageSize) {
8         this.host = host;
9         this.port = port;
10         this.firstMessageSize = firstMessageSize;
11     }
12
13     public void run() throws Exception {
14         // Configure the client.
15         Bootstrap b = new Bootstrap();
16         try {
17             b.group(new NioEventLoopGroup())
18              .channel(NioSocketChannel.class)
19              .option(ChannelOption.TCP_NODELAY, true)
20              .remoteAddress(new InetSocketAddress(host, port))
21              .handler(new ChannelInitializer() {
22                  @Override
23                  public void initChannel(SocketChannel ch) throws Exception {
24                      ch.pipeline().addLast(
25                              new LoggingHandler(LogLevel.INFO),
26                              new EchoClientHandler(firstMessageSize));
27                  }
28              });
29
30             // Start the client.
31             ChannelFuture f = b.connect().sync();
32
33             // Wait until the connection is closed.
34             f.channel().closeFuture().sync();
35         } finally {
36             // Shut down the event loop to terminate all threads.
37             b.shutdown();
38         }
39     }
40
41     public static void main(String[] args) throws Exception {
42         // Print usage if no argument is specified.
43         if (args.length < 2 || args.length > 3) {
44             System.err.println(
45                     "Usage: " + EchoClient.class.getSimpleName() +
46                     "   []");
47             return;
48         }
49
50         // Parse options.
51         final String host = args[0];
52         final int port = Integer.parseInt(args[1]);
53         final int firstMessageSize;
54         if (args.length == 3) {
55             firstMessageSize = Integer.parseInt(args[2]);
56         } else {
57             firstMessageSize = 256;
58         }
59
60         new EchoClient(host, port, firstMessageSize).run();
61     }
62 }

Line 20: 指定远程服务器的地址和端口（localhost:8080）

希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-24 12:38 发表评论

Netty 4.0 源码分析（一）：配置环境

Chan Chen — Thu, 22 Nov 2012 13:21:00 GMT

Netty 源码分析（一）：配置环境
1. 下载jdk + elipse + egit
2. 相关jar包下载
3. cynwin + telnet/ssh (setup.exe keywork:inetutils / ssh )
3. 从example包开始阅读

希望和广大的开发者/开源爱好者进行交流，欢迎大家的留言和讨论。

Chan Chen 2012-11-22 21:21 发表评论