netty udp server demo

之前在工作中已经用netty写了tcp服务，感觉还不错，就又简单的写了个Udp服务，防止以后工作中用到，到时就不用再到处翻了，拿来就用O(∩_∩)O~

说明：我用的是netty是3.5.3 ，截止目前3.x最新稳定版，看官网已经有4.0的alpha版了，不过4.0和3.x是不兼容的，改动比较大，等4.0稳定后再尝试尝试

/**
 * @author Jadic
 * @created 2012-8-10 
 */
package com.jadic;

import java.net.InetSocketAddress;

import org.jboss.netty.bootstrap.ConnectionlessBootstrap;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.socket.DatagramChannelFactory;
import org.jboss.netty.channel.socket.nio.NioDatagramChannelFactory;

/**
 * @author Jadic
 *
 */
public class UdpServer {

    private ConnectionlessBootstrap udpBootstrap;
    
    public UdpServer(int port) {
        DatagramChannelFactory channelFactory = new NioDatagramChannelFactory();
        udpBootstrap = new ConnectionlessBootstrap(channelFactory);
        udpBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() throws Exception {
                return Channels.pipeline(new UdpEventHandler());
            }
        });
        udpBootstrap.bind(new InetSocketAddress("192.168.6.19", port));
        System.out.println("udp server started, listening on port:" + port);
    }

    public static void main(String[] args) {
        new UdpServer(6803);
    }
    
}

 

Udp数据handler，其中主要重写下messageReceived和exceptionCaught方法就可以了

/**
 * @author Jadic
 * @created 2012-8-10 
 */
package com.jadic;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;

/**
 * @author Jadic
 *
 */
public class UdpEventHandler extends SimpleChannelUpstreamHandler {
    
    private void log(Object msg) {
        System.out.println(msg);
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
            throws Exception {
        log("messageReceived");
        ChannelBuffer buffer = (ChannelBuffer)e.getMessage();
        log("recvd " + buffer.readableBytes() + " bytes [" + KKTool.channelBufferToHexStr(buffer) + "]");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
            throws Exception {
        log("exceptionCaught");
    }

}

 

有个小细节，在打印udp数据日志时，有用到ChannelBuffer.array()获取字节内容，在tcp服务中，通过channelBuffer.array()获取的就是真实收到的数据，而在udp服务中，则不是，跟了下源码，tcp服务在接收数据时，是根据收到的字节数来新建一个ChannelBuffer的，而udp服务则是有根据默认接收缓存区大小新建一个ByteBuffer

如下分别是Netty Udp和Tcp服务中底层读取数据方法的源码，两个类分别是NioDatagramWorker和NioWorker

 1　　  @Override
    protected boolean read(final SelectionKey key) {
        final NioDatagramChannel channel = (NioDatagramChannel) key.attachment();
        ReceiveBufferSizePredictor predictor =
            channel.getConfig().getReceiveBufferSizePredictor();
        final ChannelBufferFactory bufferFactory = channel.getConfig().getBufferFactory();
        final DatagramChannel nioChannel = (DatagramChannel) key.channel();

        // Allocating a non-direct buffer with a max udp packge size.
        // Would using a direct buffer be more efficient or would this negatively
        // effect performance, as direct buffer allocation has a higher upfront cost
        // where as a ByteBuffer is heap allocated.//此处分配ByteBuffer大小时用的是Udp接收一包最大的数据大小，默认是768
        final ByteBuffer byteBuffer = ByteBuffer.allocate(
                predictor.nextReceiveBufferSize()).order(bufferFactory.getDefaultOrder());

        boolean failure = true;
        SocketAddress remoteAddress = null;
        try {
            // Receive from the channel in a non blocking mode. We have already been notified that
            // the channel is ready to receive.
            remoteAddress = nioChannel.receive(byteBuffer);
            failure = false;
        } catch (ClosedChannelException e) {
            // Can happen, and does not need a user attention.
        } catch (Throwable t) {
            fireExceptionCaught(channel, t);
        }

        if (remoteAddress != null) {
            // Flip the buffer so that we can wrap it.
            byteBuffer.flip();

            int readBytes = byteBuffer.remaining();
            if (readBytes > 0) {
                // Update the predictor.
                predictor.previousReceiveBufferSize(readBytes);

                // Notify the interested parties about the newly arrived message.  此处将bytebuffer封装成ChannelBuffer继续向后触发事件
                fireMessageReceived(
                        channel, bufferFactory.getBuffer(byteBuffer), remoteAddress);
            }
        }

Tcp的

    @Override
    protected boolean read(SelectionKey k) {
        final SocketChannel ch = (SocketChannel) k.channel();
        final NioSocketChannel channel = (NioSocketChannel) k.attachment();

        final ReceiveBufferSizePredictor predictor =
            channel.getConfig().getReceiveBufferSizePredictor();
        final int predictedRecvBufSize = predictor.nextReceiveBufferSize();

        int ret = 0;
        int readBytes = 0;
        boolean failure = true;

        ByteBuffer bb = recvBufferPool.acquire(predictedRecvBufSize);
        try {
            while ((ret = ch.read(bb)) > 0) {
                readBytes += ret;
                if (!bb.hasRemaining()) {
                    break;
                }
            }
            failure = false;
        } catch (ClosedChannelException e) {
            // Can happen, and does not need a user attention.
        } catch (Throwable t) {
            fireExceptionCaught(channel, t);
        }

        if (readBytes > 0) {
            bb.flip();

            final ChannelBufferFactory bufferFactory =
                channel.getConfig().getBufferFactory();
            final ChannelBuffer buffer = bufferFactory.getBuffer(readBytes);//这就是tcp服务中获取到的ChannelBuffer，大小就是读取到的字节数 readBytes
            buffer.setBytes(0, bb);
            buffer.writerIndex(readBytes);

            recvBufferPool.release(bb);

            // Update the predictor.
            predictor.previousReceiveBufferSize(readBytes);

            // Fire the event.
            fireMessageReceived(channel, buffer);
        } else {
            recvBufferPool.release(bb);
        }

        if (ret < 0 || failure) {
            k.cancel(); // Some JDK implementations run into an infinite loop without this.
            close(channel, succeededFuture(channel));
            return false;
        }

        return true;
    }