开源一个基于nio的java网络程序

因为最近要从公司离职，害怕用nio写的网络程序没有人能看懂（或许是因为写的不好吧），就调整成了mina（这样大家接触起来非常方便，即使没有socket基础，用起来也不难），所以之前基于nio写的网络程序就开放出来好了！

写的比较挫，大家见谅！

首先是PollServer类，主要处理select，做网络事件的监听和基于FutureTask的数据发送，代码如下：

　　

package gs.gate;

import gs.gate.handle.ClientHandle;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.FutureTask;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

import org.apache.log4j.Logger;

import door.HeartTimer;

public class PollServer implements Runnable
{
    private Logger log = Logger.getLogger(getClass());
    private Selector select = null;
    private ServerSocketChannel serverSocketChannel = null;
    private HeartTimer writerExpire = null;
    private volatile boolean run = true;

    private List<FutureTask<Integer>> writeTasks =
            new Vector<FutureTask<Integer>>();

    public PollServer(String host,int port) throws IOException
    {
        select = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().setReuseAddress(true);
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.socket().bind(new InetSocketAddress(host, port));
        serverSocketChannel.register(select, SelectionKey.OP_ACCEPT);
    }

    public Selector getSelector()
    {
        return this.select;
    }

    public void stop()
    {
        this.run = false;
    }

    public void run()
    {
        if(writerExpire == null)
        {
            writerExpire = new HeartTimer(50);
        }
        while(this.run)
        {

            try
            {
                this.listen();
            }
            catch (Exception e)
            {
                log.info("PollServer listen() err! " + e.toString());
            }

            try
            {
                List<FutureTask<Integer>> writeTasks_ = null;
                synchronized (writeTasks)
                {
                    writeTasks_ = new ArrayList<FutureTask<Integer>>(this.writeTasks);
                    this.writeTasks.clear();
                }

                for(FutureTask<Integer> task : writeTasks_)
                {
                    task.run();
                }
            }
            catch (Exception e)
            {
                log.error("PollServer processOutput() err" ,e);
            }
        }
    }

    public void listen() throws IOException
    {

        select.select(10);
        Set<SelectionKey> readyKeys = select.selectedKeys();
        Iterator<SelectionKey> itr = readyKeys.iterator();

        //处理接受
        while(itr.hasNext())
        {
            SelectionKey key = itr.next();
            itr.remove();

            if(key.isAcceptable())
            {
                SocketChannel newConnection = serverSocketChannel.accept();
                this.addClient(newConnection);
            }
            else if(key.isReadable())
            {
                ClientHandle handle = (ClientHandle)key.attachment();
                try
                {
                    if(handle.handleRead() <= 0)
                    {
                        log.info("if handleRead < 0");
                        this.removeClient(handle);
                    }
                }
                catch (Exception e)
                {
                    log.error("exception",e);
                    this.removeClient(handle);
                }
            }
            else if(key.isWritable())
            {
                ClientHandle handle = (ClientHandle)key.attachment();
                try
                {
                    handle.handleWrite();
                    if(handle.hasRemaining() == false)
                    {
                        key.cancel();
                    }
                }
                catch (Exception e)
                {
                    this.removeClient(handle);
                    log.error("if handleWrite error",e);
                }
            }

        }
    }

    public void addWriteTask(FutureTask<Integer> future)
    {
        this.writeTasks.add(future);
    }

    public void addClient(SocketChannel socket)
    {
        ClientHandle handle = new ClientHandle(socket,this);
        try
        {
            socket.socket().setTcpNoDelay(run);
            socket.configureBlocking(false);
            socket.register(select, SelectionKey.OP_READ,handle);
        }
        catch (Exception e)
        {
            try
            {
                log.error("create client err",e);
                socket.close();
            }
            catch (Exception  err)
            {}

        }
    }

    public void removeClient(ClientHandle handle)
    {
        if(handle == null)
        {
            return ;
        }

        log.info(" remove Client ");
        handle.handleDisConnected();
    }

}

主要函数: listen()；作用：基于网络事件处理接受新链接和消息的接收！

主要函数: processOutput()； 作用: 做统一的发送处理，在这篇 浅谈游戏服务器的发送数据处理 中有讲解！每个连接在发送的时候，将数据和连接封装成FutureTask，然后投递到Pollserver中的安全队列中，在这里统一将安全队列中的任务执行完毕！ 如果有数据没有发送完毕，就监听写时间，直到这个链接成为可写事件（即：写缓冲区中有空闲）。

下面是ClientHandle类的代码，做每个连接的处理，比如拆包分包，代码如下

package gs.gate.handle;

import gs.gate.PollServer;

import java.io.IOException;
import java.net.InetAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.concurrent.FutureTask;

import org.apache.log4j.Logger;

import dc.control.DCThread;
import dc.util.DcTask;
import door.IPlayer;
import senv.server.ServerKit;
import slib.net.ISession;
import slib.util.ByteBuffer;

public class ClientHandle implements ISession
{
    private Logger log = Logger.getLogger(getClass());
    public final static int RW_BUFFER_SIZE = 1024;
    private SocketChannel socket = null;

    private java.nio.ByteBuffer reader = java.nio.ByteBuffer.allocate(8*RW_BUFFER_SIZE);
    private java.nio.ByteBuffer writer = java.nio.ByteBuffer.allocate(10*RW_BUFFER_SIZE);

    private volatile IPlayer player = null;

    private PollServer poll = null;

    private boolean active = false;

    private boolean tgwProcessed = false;

    private String tgw = "tgw_l7_forward\r\nHost:" + ServerKit.ip+ ":" + ServerKit.port + "\r\n\r\n";

    public ClientHandle(SocketChannel socket,PollServer poll)
    {
        this.socket = socket;
        this.writer.limit(this.writer.capacity());
        this.active = true;
        this.poll = poll;

        try
        {
            this.socket.socket().setSendBufferSize(10*RW_BUFFER_SIZE);
            this.socket.socket().setReceiveBufferSize(8*RW_BUFFER_SIZE);
            this.socket.socket().setTcpNoDelay(true);
            this.socket.socket().setSoLinger(true, 3600);
        }
        catch (Exception e)
        {
            log.error("err",e);
        }

    }

    public SocketChannel getSocketChannel()
    {
        return this.socket;
    }

    public int handleWrite() throws IOException
    {
        if (!this.isActive())
        {
            return -1;
        }

        this.writer.flip();
        this.socket.write(writer);
        if(this.writer.hasRemaining())
        {
            this.writer.compact();
        }
        else
        {
            this.writer.clear();
        }

        return 0;
    }

    public boolean hasRemaining()
    {
        return this.writer.position() > 0;
    }

    public Integer writeData(ByteBuffer data) throws IOException
    {
        if (!this.isActive())
        {
            return -1;
        }
        if(data == null)
        {
            return 0;
        }

        this.writer.putInt(data.length());
        this.writer.put(data.toByteArray(), 0, data.length());
        this.writer.flip();

        int result = this.socket.write(this.writer);

        if(this.writer.hasRemaining())
        {
            this.writer.compact();
        }
        else
        {
            this.writer.clear();
        }
        return result;
    }

    @SuppressWarnings("deprecation")
    public int handleRead() throws IOException
    {
        if(socket == null)
        {
            return -1;
        }
        if(!this.isActive())
        {
            return -1;
        }

        int r = this.socket.read(this.reader);
        if(r <= 0)
        {
            return r;
        }

        if(this.tgwProcessed == false)
        {
            //腾讯平台 你mb
            this.reader.flip();
            byte bytes[] = new byte[tgw.length()];
            this.reader.get(bytes);

            String vali = new String(bytes,"UTF-8");
            if(vali.equals(tgw))
            {
                log.info("tgw 校验成功");
            }
            else
            {
                log.info("tgw 校验失败");
            }
            this.tgwProcessed = true;
            this.reader.compact();
        }

        while(true)
        {
            this.reader.flip();
            ByteBuffer data = this.createBuffer();
            if(data == null)
            {
                break;
            }

            this.reader.get(data.getByteArray(), data.top(), data.capacity());
            this.processData(data);

            if(this.reader.hasRemaining())
            {
                this.reader.compact();
            }
            else
            {
                this.reader.clear();
                break;
            }
        }
        return 1;
    }

    public void processData(ByteBuffer data)
    {
        if(player == null)
        {
            DcTask task = new DcTask();
            task.object = this;
            task.data = data;
            DCThread.getInstance().insertTask(task);
        }
        else
        {
            player.insertData(data);
        }
    }

    public void handleDisConnected()
    {
        if(!this.isActive())
        {
            return ;
        }
        if(player != null)
        {
            this.player.setSession(null);
            this.player.logOut();
        }
        this.close();
        this.player = null;
    }

    private ByteBuffer createBuffer()
    {
        if(reader.remaining() < 4)
        {
            return null;
        }

        int len = reader.getInt();
        if(len > reader.remaining())
        {
            this.reader.rewind();
            this.reader.compact();
            return null;
        }

        if (len > 0 && len <= 10 * 1024)
        {
            return new ByteBuffer(len);
        }

        return null;
    }

    @Override
    public void close()
    {
        setActive(false);
        try
        {
            log.error("socket close !");
            this.socket.close();
            this.socket.keyFor(this.poll.getSelector()).cancel();
        }
        catch (Exception e)
        {
            log.error("err" , e);
        }
    }

    @Override
    public long getActiveTime()
    {
        return 0;
    }

    @Override
    public InetAddress getAddress()
    {
        return null;
    }

    @Override
    public String getCode()
    {
        return null;
    }

    @Override
    public int getPing()
    {
        return 0;
    }

    @Override
    public long getPingTime()
    {
        return 0;
    }

    @Override
    public int getPort()
    {
        return 0;
    }

    @Override
    public int getServerId()
    {
        return 0;
    }

    @Override
    public int getSessionId()
    {
        return 0;
    }

    @Override
    public Object getSource()
    {
        return this.player;
    }

    @Override
    public int getTimeout()
    {
        return 0;
    }

    @Override
    public boolean isActive()
    {
        return this.active;
    }

    @Override
    public void send(ByteBuffer data)
    {
        WriteTask task = new WriteTask(this,data);
        FutureTask<Integer> future = new FutureTask<Integer>(task);
        poll.addWriteTask(future);
    }

    @Override
    public void send(ByteBuffer arg0, ByteBuffer arg1)
    {

    }

    @Override
    public void setCode(String arg0)
    {

    }

    @Override
    public void setPing(int arg0)
    {

    }

    @Override
    public void setPingTime(long arg0)
    {

    }

    public void enableWriteEvent()
    {
        try
        {
            this.socket.register(this.poll.getSelector(), SelectionKey.OP_WRITE, this);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public void shutdownWriteEvent()
    {

    }

    @Override
    public void setSource(Object arg0)
    {
        this.player = (IPlayer) arg0;
    }

    protected void setActive(boolean b)
    {
        this.active = b;
    }

}

重要的几个函数：  send(ByteBuffer data) 将发送处理包装成FutureTask，投递到PollServer中进行处理，就是PollServer::processOutput中处理

handleRead() 这里处理接受数据事件，做了拆包，将二进制数据，按照 长度-内容 的格式进行解析，拆分成一个个ByteBuffer（定义见下文）包，然后进行处理。

ClientHandle继承自ISession接口，其实这个无所谓，大家可以自己定义。我这里因为要和之前的系统兼容，所以才继承了这个。这里一不小心居然用到了适配器模式，我以为这辈子只会用到创建者模式呢？ 个人还是觉得，这些设计模式还是为了解决问题用到的，而不是为了多变的需求而想太多用到的；设计模式用得多用的频繁，反而增加代码的可读性！

最后看下WriteTask的封装

package gs.gate.handle;

import java.util.concurrent.Callable;
import slib.util.ByteBuffer;

public class WriteTask implements Callable<Integer>
{

    private ClientHandle client = null;

    private ByteBuffer data = null;

    public WriteTask(ClientHandle handle,ByteBuffer data)
    {
        client = handle;
        this.data = data;
    }

    @Override
    public Integer call() throws Exception
    {
        return this.client.writeData(data);
    }

}

这个就不多解析了！

缺陷1： 没有做空闲连接的处理，后来的mina库，提供了这个功能！有兴趣的同学自己写个吧！

缺陷2： 自定义的消息包，用了ByteBuffer类，和nio提供的ByteBuffer 重复！

给出自定义的ByteBuffer的处理：

package slib.util;

/**
 * 类说明：字节缓存类，字节操作高位在前，低位在后
 *
 * @version 1.0
 * @author fxxxysh <hanshuang@linekong.com>
 */

public class ByteBuffer
{

    /* static fields */
    /** 默认的初始容量大小 */
    public static final int CAPACITY = 32;

    /** 默认的动态数据或文字的最大长度，400k */
    public static final int MAX_DATA_LENGTH = 400 * 1024;

    /* fields */
    /** 字节数组 */
    byte[] bytes;

    /** 字节缓存的长度 */
    int top;

    /** 字节缓存的偏移量 */
    int offset;

    /* constructors */
    /** 按默认的大小构造一个字节缓存对象 */
    public ByteBuffer()
    {
        this(CAPACITY);
    }

    /** 按指定的大小构造一个字节缓存对象 */
    public ByteBuffer(int capacity)
    {
        if (capacity < 1)
            throw new IllegalArgumentException(getClass().getName()
                    + " <init>, invalid capatity:" + capacity);
        bytes = new byte[capacity];
        top = 0;
        offset = 0;
    }

    /** 按指定的字节数组构造一个字节缓存对象 */
    public ByteBuffer(byte[] data)
    {
        if (data == null)
            throw new IllegalArgumentException(getClass().getName()
                    + " <init>, null data");
        bytes = data;
        top = data.length;
        offset = 0;
    }

    /** 按指定的字节数组构造一个字节缓存对象 */
    public ByteBuffer(byte[] data, int index, int length)
    {
        if (data == null)
            throw new IllegalArgumentException(getClass().getName()
                    + " <init>, null data");
        if (index < 0 || index > data.length)
            throw new IllegalArgumentException(getClass().getName()
                    + " <init>, invalid index:" + index);
        if (length < 0 || data.length < index + length)
            throw new IllegalArgumentException(getClass().getName()
                    + " <init>, invalid length:" + length);
        bytes = data;
        top = index + length;
        offset = index;
    }

    /* properties */
    /** 得到字节缓存的容积 */
    public int capacity()
    {
        return bytes.length;
    }

    /** 设置字节缓存的容积，只能扩大容积 */
    public void setCapacity(int len)
    {
        int c = bytes.length;
        if (len <= c)
            return;
        for (; c < len; c = (c << 1) + 1)
            ;
        byte[] temp = new byte[c];
        System.arraycopy(bytes, 0, temp, 0, top);
        bytes = temp;
    }

    /** 得到字节缓存的长度 */
    public int top()
    {
        return top;
    }

    /** 设置字节缓存的长度 */
    public void setTop(int top)
    {
        if (top < offset)
            throw new IllegalArgumentException(this + " setTop, invalid top:"
                    + top);
        if (top > bytes.length)
            setCapacity(top);
        this.top = top;
    }

    /** 得到字节缓存的偏移量 */
    public int offset()
    {
        return offset;
    }

    /** 设置字节缓存的偏移量 */
    public void setOffset(int offset)
    {
        if (offset < 0 || offset > top)
            throw new IllegalArgumentException(this
                    + " setOffset, invalid offset:" + offset);
        this.offset = offset;
    }

    /** 得到字节缓存的使用长度 */
    public int length()
    {
        return top - offset;
    }

    /** 得到字节缓存的字节数组，一般使用toArray()方法 */
    public byte[] getByteArray()
    {
        return bytes;
    }

    /* methods */
    /* byte methods */
    /** 得到指定偏移位置的字节 */
    public byte read(int pos)
    {
        return bytes[pos];
    }

    /** 设置指定偏移位置的字节 */
    public void write(int b, int pos)
    {
        bytes[pos] = (byte) b;
    }

    /* read methods */
    /**
     * 按当前偏移位置读入指定的字节数组
     *
     * @param data
     *            指定的字节数组
     * @param pos
     *            指定的字节数组的起始位置
     * @param len
     *            读入的长度
     */
    public void read(byte[] data, int pos, int len)
    {
        System.arraycopy(bytes, offset, data, pos, len);
        offset += len;
    }

    /** 读出一个布尔值 */
    public boolean readBoolean()
    {
        return (bytes[offset++] != 0);
    }

    /** 读出一个字节 */
    public byte readByte()
    {
        return bytes[offset++];
    }

    /** 读出一个无符号字节 */
    public int readUnsignedByte()
    {
        return bytes[offset++] & 0xff;
    }

    /** 读出一个字符 */
    public char readChar()
    {
        return (char) readUnsignedShort();
    }

    /** 读出一个短整型数值 */
    public short readShort()
    {
        return (short) readUnsignedShort();
    }

    /** 读出一个无符号的短整型数值 */
    public int readUnsignedShort()
    {
        int pos = offset;
        offset += 2;
        return (bytes[pos + 1] & 0xff) + ((bytes[pos] & 0xff) << 8);
    }

    /** 读出一个整型数值 */
    public int readInt()
    {
        int pos = offset;
        offset += 4;
        return (bytes[pos + 3] & 0xff) + ((bytes[pos + 2] & 0xff) << 8)
                + ((bytes[pos + 1] & 0xff) << 16) + ((bytes[pos] & 0xff) << 24);
    }

    /** 读出一个浮点数值 */
    public float readFloat()
    {
        return Float.intBitsToFloat(readInt());
    }

    /** 读出一个长整型数值 */
    public long readLong()
    {
        int pos = offset;
        offset += 8;
        return (bytes[pos + 7] & 0xffL) + ((bytes[pos + 6] & 0xffL) << 8)
                + ((bytes[pos + 5] & 0xffL) << 16)
                + ((bytes[pos + 4] & 0xffL) << 24)
                + ((bytes[pos + 3] & 0xffL) << 32)
                + ((bytes[pos + 2] & 0xffL) << 40)
                + ((bytes[pos + 1] & 0xffL) << 48)
                + ((bytes[pos] & 0xffL) << 56);
    }

    /** 读出一个双浮点数值 */
    public double readDouble()
    {
        return Double.longBitsToDouble(readLong());
    }

    /**
     * 读出动态长度， 数据大小采用动态长度，整数类型下，最大为512M 1xxx,xxxx表示（0~0x80） 0~128B
     * 01xx,xxxx,xxxx,xxxx表示（0~0x4000） 0~16K
     * 001x,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx表示（0~0x20000000） 0~512M
     */
    public int readLength()
    {
        int n = bytes[offset] & 0xff;
        if (n >= 0x80)
        {
            offset++;
            return n - 0x80;
        }
        else if (n >= 0x40)
            return readUnsignedShort() - 0x4000;
        else if (n >= 0x20)
            return readInt() - 0x20000000;
        else
            throw new IllegalArgumentException(this
                    + " readLength, invalid number:" + n);
    }

    /** 读出一个指定长度的字节数组，可以为null */
    public byte[] readData()
    {
        int len = readLength() - 1;
        if (len < 0)
            return null;
        if (len > MAX_DATA_LENGTH)
            throw new IllegalArgumentException(this
                    + " readData, data overflow:" + len);
        byte[] data = new byte[len];
        read(data, 0, len);
        return data;
    }

    /** 读出一个短字节数组，长度不超过254 */
    public byte[] readShortData()
    {
        int len = readUnsignedByte();
        if (len == 255)
            return null;
        byte[] data = new byte[len];
        if (len != 0)
            read(data, 0, len);
        return data;
    }

    /** 读出一个指定长度的字符串 */
    public String readString(int len)
    {
        byte[] data = new byte[len];
        if (len == 0)
            return "";
        read(data, 0, len);
        return new String(data);
    }

    /** 读出一个短字符串，长度不超过254 */
    public String readShortString()
    {
        int len = readUnsignedByte();
        if (len == 255)
            return null;
        return readString(len);
    }

    /** 读出一个字符串，长度不超过65534 */
    public String readString()
    {
        int len = readUnsignedShort();
        if (len == 65535)
            return null;
        return readString(len);
    }

    /** 读出一个指定长度和编码类型的字符串 */
    public String readUTF(String charsetName)
    {
        int len = readLength() - 1;
        if (len < 0)
            return null;
        if (len > MAX_DATA_LENGTH)
            throw new IllegalArgumentException(this
                    + " readUTF, data overflow:" + len);
        byte[] data = new byte[len];
        read(data, 0, len);
        if (charsetName == null)
            return new String(data);
        try
        {
            return new String(data, charsetName);
        }
        catch (Exception e)
        {
            throw new IllegalArgumentException(this
                    + " readUTF, invalid charsetName:" + charsetName);
        }
    }

    /** 读出一个指定长度的utf字符串 */
    public String readUTF()
    {
        int len = readLength() - 1;
        if (len < 0)
            return null;
        if (len == 0)
            return "";
        if (len > MAX_DATA_LENGTH)
            throw new IllegalArgumentException(this
                    + " readUTF, data overflow:" + len);
        StringBuffer sb = new StringBuffer(len);
        int pos = ByteKit.readUTF(bytes, offset, len, sb);
        if (pos > 0)
            throw new IllegalArgumentException(this
                    + " readUTF, format err, len=" + len + ", pos:" + pos);
        offset += len;
        return sb.toString();
    }

    /* write methods */
    /**
     * 写入指定字节数组
     *
     * @param data
     *            指定的字节数组
     * @param pos
     *            指定的字节数组的起始位置
     * @param len
     *            写入的长度
     */
    public void write(byte[] data, int pos, int len)
    {
        if (bytes.length < top + len)
            setCapacity(top + len);
        System.arraycopy(data, pos, bytes, top, len);
        top += len;
    }

    /** 写入一个布尔值 */
    public void writeBoolean(boolean b)
    {
        if (bytes.length < top + 1)
            setCapacity(top + CAPACITY);
        bytes[top++] = (byte) (b ? 1 : 0);
    }

    /** 写入一个字节 */
    public void writeByte(int b)
    {
        if (bytes.length < top + 1)
            setCapacity(top + CAPACITY);
        bytes[top++] = (byte) b;
    }

    /** 写入一个字符 */
    public void writeChar(int c)
    {
        writeShort(c);
    }

    /** 写入一个短整型数值 */
    public void writeShort(int s)
    {
        int pos = top;
        if (bytes.length < pos + 2)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) (s >>> 8);
        bytes[pos + 1] = (byte) s;
        top += 2;
    }

    /** 在指定位置写入一个短整型数值，length不变 */
    public void writeShort(int s, int pos)
    {
        if (bytes.length < pos + 2)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) (s >>> 8);
        bytes[pos + 1] = (byte) s;
    }

    /** 写入一个整型数值 */
    public void writeInt(int i)
    {
        int pos = top;
        if (bytes.length < pos + 4)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) (i >>> 24);
        bytes[pos + 1] = (byte) (i >>> 16);
        bytes[pos + 2] = (byte) (i >>> 8);
        bytes[pos + 3] = (byte) i;
        top += 4;
    }

    /** 在指定位置写入一个整型数值，length不变 */
    public void writeInt(int i, int pos)
    {
        if (bytes.length < pos + 4)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) (i >>> 24);
        bytes[pos + 1] = (byte) (i >>> 16);
        bytes[pos + 2] = (byte) (i >>> 8);
        bytes[pos + 3] = (byte) i;
    }

    /** 写入一个浮点数值 */
    public void writeFloat(float f)
    {
        writeInt(Float.floatToIntBits(f));
    }

    /** 写入一个长整型数值 */
    public void writeLong(long l)
    {
        int pos = top;
        if (bytes.length < pos + 8)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) (l >>> 56);
        bytes[pos + 1] = (byte) (l >>> 48);
        bytes[pos + 2] = (byte) (l >>> 40);
        bytes[pos + 3] = (byte) (l >>> 32);
        bytes[pos + 4] = (byte) (l >>> 24);
        bytes[pos + 5] = (byte) (l >>> 16);
        bytes[pos + 6] = (byte) (l >>> 8);
        bytes[pos + 7] = (byte) l;
        top += 8;
    }

    /** 写入一个双浮点数值 */
    public void writeDouble(double d)
    {
        writeLong(Double.doubleToLongBits(d));
    }

    /** 写入动态长度 */
    public void writeLength(int len)
    {
        if (len >= 0x20000000 || len < 0)
            throw new IllegalArgumentException(this
                    + " writeLength, invalid len:" + len);
        if (len >= 0x4000)
            writeInt(len + 0x20000000);
        else if (len >= 0x80)
            writeShort(len + 0x4000);
        else
            writeByte(len + 0x80);
    }

    /** 写入一个字节数组，可以为null */
    public void writeData(byte[] data)
    {
        writeData(data, 0, (data != null) ? data.length : 0);
    }

    /** 写入一个字节数组，可以为null */
    public void writeData(byte[] data, int pos, int len)
    {
        if (data == null)
        {
            writeLength(0);
            return;
        }
        writeLength(len + 1);
        write(data, pos, len);
    }

    /** 写入一个字符串，可以为null */
    public void writeString(String s)
    {
        if (s != null)
        {
            byte[] temp = s.getBytes();
            if (temp.length > 65534)
                throw new IllegalArgumentException(getClass().getName()
                        + " writeString, invalid s:" + s);
            writeShort(temp.length);
            if (temp.length != 0)
                write(temp, 0, temp.length);
        }
        else
            writeShort(65535);
    }

    /** 写入一个字符串，以指定的字符进行编码 */
    public void writeUTF(String str, String charsetName)
    {
        if (str == null)
        {
            writeLength(0);
            return;
        }
        byte[] data;
        if (charsetName != null)
        {
            try
            {
                data = str.getBytes(charsetName);
            }
            catch (Exception e)
            {
                throw new IllegalArgumentException(this
                        + " writeUTF, invalid charsetName:" + charsetName);
            }
        }
        else
            data = str.getBytes();
        writeLength(data.length + 1);
        write(data, 0, data.length);
    }

    /** 写入一个utf字符串，可以为null */
    public void writeUTF(String str)
    {
        writeUTF(str, 0, (str != null) ? str.length() : 0);
    }

    /** 写入一个utf字符串中指定的部分，可以为null */
    public void writeUTF(String str, int index, int length)
    {
        if (str == null)
        {
            writeLength(0);
            return;
        }
        int len = ByteKit.getUTFLength(str, index, length);
        writeLength(len + 1);
        int pos = top;
        if (bytes.length < pos + len)
            setCapacity(pos + len);
        ByteKit.writeUTF(str, index, length, bytes, pos);
        top += len;
    }

    /** 检查是否为相同类型的实例 */
    public boolean checkClass(Object obj)
    {
        return (obj instanceof ByteBuffer);
    }

    /** 在指定位置写入一个字节，length不变 */
    public void writeByte(int b, int pos)
    {
        if (bytes.length < pos + 1)
            setCapacity(pos + CAPACITY);
        bytes[pos] = (byte) b;
    }

    /** 得到字节缓存当前长度的字节数组 */
    public byte[] toByteArray()
    {
        byte[] data = new byte[top - offset];
        System.arraycopy(bytes, offset, data, 0, data.length);
        return data;
    }

    /** 清除字节缓存对象 */
    public void clear()
    {
        top = 0;
        offset = 0;
    }

    /* common methods */
    public int hashCode()
    {
        int hash = 17;
        for (int i = top - 1; i >= 0; i--)
            hash = 65537 * hash + bytes[i];
        return hash;
    }

    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (!checkClass(obj))
            return false;
        ByteBuffer bb = (ByteBuffer) obj;
        if (bb.top != top)
            return false;
        if (bb.offset != offset)
            return false;
        for (int i = top - 1; i >= 0; i--)
        {
            if (bb.bytes[i] != bytes[i])
                return false;
        }
        return true;
    }

    public String toString()
    {
        return super.toString() + "[" + top + "," + offset + "," + bytes.length
                + "] ";
    }

}

相应的ByteKit类代码：

/**
 * Copyright 2001 by seasky <www.seasky.cn>.
 */

package slib.util;

/**
 * 类说明： 字节及字节数组的方法操作库
 *
 * @version 1.0
 * @author zminleo <zmin@seasky.cn>
 */

public final class ByteKit
{

    /* static fields */
    /** 库信息 */
    public static final String toString=ByteKit.class.getName();

    /* static methods */
    /** 在字节数组中指定位置读出一个布尔值 */
    public static boolean readBoolean(byte[] bytes,int pos)
    {
        return bytes[pos]!=0;
    }
    /** 在字节数组中指定位置读出一个字节 */
    public static byte readByte(byte[] bytes,int pos)
    {
        return bytes[pos];
    }
    /** 在字节数组中指定位置读出一个无符号字节 */
    public static int readUnsignedByte(byte[] bytes,int pos)
    {
        return bytes[pos]&0xff;
    }
    /** 在字节数组中指定位置读出一个字符 */
    public static char readChar(byte[] bytes,int pos)
    {
        return (char)readUnsignedShort(bytes,pos);
    }
    /** 在字节数组中指定位置读出一个字符，低位在前，高位在后 */
    public static char readChar_(byte[] bytes,int pos)
    {
        return (char)readUnsignedShort_(bytes,pos);
    }
    /** 在字节数组中指定位置读出一个短整型数值 */
    public static short readShort(byte[] bytes,int pos)
    {
        return (short)readUnsignedShort(bytes,pos);
    }
    /** 在字节数组中指定位置读出一个短整型数值，低位在前，高位在后 */
    public static short readShort_(byte[] bytes,int pos)
    {
        return (short)readUnsignedShort_(bytes,pos);
    }
    /** 在字节数组中指定位置读出一个无符号短整型数值 */
    public static int readUnsignedShort(byte[] bytes,int pos)
    {
        return (bytes[pos+1]&0xff)+((bytes[pos]&0xff)<<8);
    }
    /** 在字节数组中指定位置读出一个无符号短整型数值，低位在前，高位在后 */
    public static int readUnsignedShort_(byte[] bytes,int pos)
    {
        return ((bytes[pos+1]&0xff)<<8)+(bytes[pos]&0xff);
    }
    /** 在字节数组中指定位置读出一个整型数值 */
    public static int readInt(byte[] bytes,int pos)
    {
        return ((bytes[pos+3]&0xff))+((bytes[pos+2]&0xff)<<8)
            +((bytes[pos+1]&0xff)<<16)+((bytes[pos]&0xff)<<24);
    }
    /** 在字节数组中指定位置读出一个整型数值，低位在前，高位在后 */
    public static int readInt_(byte[] bytes,int pos)
    {
        return ((bytes[pos+3]&0xff)<<24)+((bytes[pos+2]&0xff)<<16)
            +((bytes[pos+1]&0xff)<<8)+((bytes[pos]&0xff));
    }
    /** 在字节数组中指定位置读出一个浮点数值 */
    public static float readFloat(byte[] bytes,int pos)
    {
        return Float.intBitsToFloat(readInt(bytes,pos));
    }
    /** 在字节数组中指定位置读出一个浮点数值，低位在前，高位在后 */
    public static float readFloat_(byte[] bytes,int pos)
    {
        return Float.intBitsToFloat(readInt_(bytes,pos));
    }
    /** 在字节数组中指定位置读出一个长整型数值 */
    public static long readLong(byte[] bytes,int pos)
    {
        return (bytes[pos+7]&0xffL)+((bytes[pos+6]&0xffL)<<8)
            +((bytes[pos+5]&0xffL)<<16)+((bytes[pos+4]&0xffL)<<24)
            +((bytes[pos+3]&0xffL)<<32)+((bytes[pos+2]&0xffL)<<40)
            +((bytes[pos+1]&0xffL)<<48)+((bytes[pos]&0xffL)<<56);
    }
    /** 在字节数组中指定位置读出一个长整型数值，低位在前，高位在后 */
    public static long readLong_(byte[] bytes,int pos)
    {
        return ((bytes[pos+7]&0xffL)<<56)+((bytes[pos+6]&0xffL)<<48)
            +((bytes[pos+5]&0xffL)<<40)+((bytes[pos+4]&0xffL)<<32)
            +((bytes[pos+3]&0xffL)<<24)+((bytes[pos+2]&0xffL)<<16)
            +((bytes[pos+1]&0xffL)<<8)+(bytes[pos]&0xffL);
    }
    /** 在字节数组中指定位置读出一个双浮点数值 */
    public static double readDouble(byte[] bytes,int pos)
    {
        return Double.longBitsToDouble(readLong(bytes,pos));
    }
    /** 在字节数组中指定位置读出一个双浮点数值，低位在前，高位在后 */
    public static double readDouble_(byte[] bytes,int pos)
    {
        return Double.longBitsToDouble(readLong_(bytes,pos));
    }
    /** 写入一个布尔值在字节数组中指定位置 */
    public static void writeBoolean(boolean b,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)(b?1:0);
    }
    /** 写入一个字节在字节数组中指定位置 */
    public static void writeByte(int b,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)b;
    }
    /** 在字节数组中指定位置写入一个字符 */
    public static void writeChar(int c,byte[] bytes,int pos)
    {
        writeShort(c,bytes,pos);
    }
    /** 写入一个字符在字节数组中指定位置，低位在前，高位在后 */
    public static void writeChar_(int c,byte[] bytes,int pos)
    {
        writeShort_(c,bytes,pos);
    }
    /** 写入一个短整型数值在字节数组中指定位置 */
    public static void writeShort(int s,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)(s>>>8);
        bytes[pos+1]=(byte)s;
    }
    /** 写入一个短整型数值在字节数组中指定位置，低位在前，高位在后 */
    public static void writeShort_(int s,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)s;
        bytes[pos+1]=(byte)(s>>>8);
    }
    /** 写入一个整型数值在字节数组中指定位置 */
    public static void writeInt(int i,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)(i>>>24);
        bytes[pos+1]=(byte)(i>>>16);
        bytes[pos+2]=(byte)(i>>>8);
        bytes[pos+3]=(byte)i;
    }
    /** 在字节数组中指定位置写入一个整型数值，低位在前，高位在后 */
    public static void writeInt_(int i,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)i;
        bytes[pos+1]=(byte)(i>>>8);
        bytes[pos+2]=(byte)(i>>>16);
        bytes[pos+3]=(byte)(i>>>24);
    }
    /** 写入一个浮点数值在字节数组中指定位置 */
    public static void writeFloat(float f,byte[] bytes,int pos)
    {
        writeInt(Float.floatToIntBits(f),bytes,pos);
    }
    /** 写入一个浮点数值在字节数组中指定位置，低位在前，高位在后 */
    public static void writeFloat_(float f,byte[] bytes,int pos)
    {
        writeInt_(Float.floatToIntBits(f),bytes,pos);
    }
    /** 写入一个长整型数值在字节数组中指定位置 */
    public static void writeLong(long l,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)(l>>>56);
        bytes[pos+1]=(byte)(l>>>48);
        bytes[pos+2]=(byte)(l>>>40);
        bytes[pos+3]=(byte)(l>>>32);
        bytes[pos+4]=(byte)(l>>>24);
        bytes[pos+5]=(byte)(l>>>16);
        bytes[pos+6]=(byte)(l>>>8);
        bytes[pos+7]=(byte)l;
    }
    /** 写入一个长整型数值在字节数组中指定位置，低位在前，高位在后 */
    public static void writeLong_(long l,byte[] bytes,int pos)
    {
        bytes[pos]=(byte)l;
        bytes[pos+1]=(byte)(l>>>8);
        bytes[pos+2]=(byte)(l>>>16);
        bytes[pos+3]=(byte)(l>>>24);
        bytes[pos+4]=(byte)(l>>>32);
        bytes[pos+5]=(byte)(l>>>40);
        bytes[pos+6]=(byte)(l>>>48);
        bytes[pos+7]=(byte)(l>>>56);
    }
    /** 写入一个双浮点数值在字节数组中指定位置 */
    public static void writeDouble(double d,byte[] bytes,int pos)
    {
        writeLong(Double.doubleToLongBits(d),bytes,pos);
    }
    /** 写入一个双浮点数值在字节数组中指定位置，低位在前，高位在后 */
    public static void writeDouble_(double d,byte[] bytes,int pos)
    {
        writeLong_(Double.doubleToLongBits(d),bytes,pos);
    }
    /** 将指定的字节数据转换为ISO-8859-1格式的字符串 */
    public static String readISO8859_1(byte[] data)
    {
        return readISO8859_1(data,0,data.length);
    }
    /** 将指定的字节数据转换为ISO-8859-1格式的字符串 */
    public static String readISO8859_1(byte[] data,int pos,int len)
    {
        char[] array=new char[len];
        for(int i=pos+len-1,j=array.length-1;i>=pos;i--,j--)
            array[j]=(char)data[i];
        return new String(array);
    }
    /** 将指定的字符串转换为ISO-8859-1格式的字节数据 */
    public static byte[] writeISO8859_1(String str)
    {
        return writeISO8859_1(str,0,str.length());
    }
    /** 将指定的字符串转换为ISO-8859-1格式的字节数据 */
    public static byte[] writeISO8859_1(String str,int index,int len)
    {
        byte[] data=new byte[len];
        writeISO8859_1(str,index,len,data,0);
        return data;
    }
    /** 将指定的字符串转换为ISO-8859-1格式的字节数据 */
    public static void writeISO8859_1(String str,int index,int len,
        byte[] data,int pos)
    {
        int c;
        for(int i=index+len-1,j=pos+len-1;i>=index;i--,j--)
        {
            c=str.charAt(i);
            data[j]=(c>256)?63:(byte)c;
        }
    }
    /** 将指定的字符数组转换为ISO-8859-1格式的字节数据 */
    public static void writeISO8859_1(char[] chars,int index,int len,
        byte[] data,int pos)
    {
        int c;
        for(int i=index+len-1,j=pos+len-1;i>=index;i--,j--)
        {
            c=chars[i];
            data[j]=(c>256)?63:(byte)c;
        }
    }
    /** 将指定的UTF8格式的字节数据转换为字符串，返回null表示失败 */
    public static String readUTF(byte[] data)
    {
        StringBuffer sb=new StringBuffer(data.length);
        int pos=readUTF(data,0,data.length,sb);
        return (pos==0)?sb.toString():null;
    }
    /**
     * 将指定的UTF8格式的字节数据转换为字符串， 返回0表示成功，否则表示失败位置
     */
    public static int readUTF(byte[] data,StringBuffer sb)
    {
        return readUTF(data,0,data.length,sb);
    }
    /**
     * 将指定的UTF8格式的字节数据转换为字符串， 返回0表示成功，否则表示失败位置
     */
    public static int readUTF(byte[] data,int pos,int len,StringBuffer sb)
    {
        int i,c,cc,ccc;
        int end=pos+len;
        while(pos<end)
        {
            c=data[pos]&0xff;
            i=c>>4;
            if(i<8)
            {
                // 0xxx xxxx
                pos++;
                sb.append((char)c);
            }
            else if(i==12||i==13)
            {
                // 110x xxxx 10xx xxxx
                pos+=2;
                if(pos>end) return pos;
                cc=data[pos-1];
                if((cc&0xC0)!=0x80) return pos;
                sb.append((char)(((c&0x1f)<<6)|(cc&0x3f)));
            }
            else if(i==14)
            {
                // 1110 xxxx 10xx xxxx 10xx
                // xxxx
                pos+=3;
                if(pos>end) return pos;
                cc=data[pos-2];
                ccc=data[pos-1];
                if(((cc&0xC0)!=0x80)||((ccc&0xC0)!=0x80)) return pos;
                sb.append((char)(((c&0x0f)<<12)|((cc&0x3f)<<6)|(ccc&0x3f)));
            }
            else
                // 10xx xxxx 1111 xxxx
                return pos;
        }
        return 0;
    }
    /** 获得指定的字符串转换为UTF8格式的字节数据的长度 */
    public static int getUTFLength(String str,int index,int len)
    {
        int utfLen=0;
        int c;
        for(int i=index;i<len;i++)
        {
            c=str.charAt(i);
            if((c>=0x0001)&&(c<=0x007f))
                utfLen++;
            else if(c>0x07ff)
                utfLen+=3;
            else
                utfLen+=2;
        }
        return utfLen;
    }
    /** 在字节数组中指定位置写入一个短整型数值 */
    public static void writeShort(byte[] bytes,int pos,int s)
    {
        bytes[pos]=(byte)(s>>>8);
        bytes[pos+1]=(byte)s;
    }
    /** 在字节数组中指定位置写入一个字节 */
    public static void writeByte(byte[] bytes,int pos,int b)
    {
        bytes[pos]=(byte)b;
    }
    /** 获得指定的字符数组转换为UTF8格式的字节数据的长度 */
    public static int getUTFLength(char[] chars,int index,int len)
    {
        int utfLen=0;
        int c;
        for(int i=index;i<len;i++)
        {
            c=chars[i];
            if((c>=0x0001)&&(c<=0x007f))
                utfLen++;
            else if(c>0x07ff)
                utfLen+=3;
            else
                utfLen+=2;
        }
        return utfLen;
    }
    /** 将指定的字符串转换为UTF8格式的字节数据 */
    public static byte[] writeUTF(String str)
    {
        return writeUTF(str,0,str.length());
    }
    /** 将指定的字符串转换为UTF8格式的字节数据 */
    public static byte[] writeUTF(String str,int index,int len)
    {
        byte[] data=new byte[getUTFLength(str,index,len)];
        writeUTF(str,index,len,data,0);
        return data;
    }
    /** 将指定的字符串转换为UTF8格式的字节数据 */
    public static void writeUTF(String str,int index,int len,byte[] data,
        int pos)
    {
        int c;
        for(int i=index;i<len;i++)
        {
            c=str.charAt(i);
            if((c>=0x0001)&&(c<=0x007f))
            {
                data[pos++]=(byte)c;
            }
            else if(c>0x07ff)
            {
                data[pos++]=(byte)(0xe0|((c>>12)&0x0f));
                data[pos++]=(byte)(0x80|((c>>6)&0x3f));
                data[pos++]=(byte)(0x80|(c&0x3f));
            }
            else
            {
                data[pos++]=(byte)(0xc0|((c>>6)&0x1f));
                data[pos++]=(byte)(0x80|(c&0x3f));
            }
        }
    }
    /** 将指定的字符数组转换为UTF8格式的字节数据 */
    public static void writeUTF(char[] chars,int index,int len,byte[] data,
        int pos)
    {
        int c;
        for(int i=index;i<len;i++)
        {
            c=chars[i];
            if((c>=0x0001)&&(c<=0x007f))
            {
                data[pos++]=(byte)c;
            }
            else if(c>0x07ff)
            {
                data[pos++]=(byte)(0xe0|((c>>12)&0x0f));
                data[pos++]=(byte)(0x80|((c>>6)&0x3f));
                data[pos++]=(byte)(0x80|(c&0x3f));
            }
            else
            {
                data[pos++]=(byte)(0xc0|((c>>6)&0x1f));
                data[pos++]=(byte)(0x80|(c&0x3f));
            }
        }
    }

    /* constructors */
    private ByteKit()
    {
    }

}

使用方法：

for(Map.Entry<String, Map<String, String>> entry : gateConfig.entrySet())
{
    String host = entry.getValue().get("host");
    String port = entry.getValue().get("port");

    PollServer poll = new PollServer(host,Integer.parseInt(port));
    Thread gateThread = new Thread(poll);
    gateThread.setName(entry.getKey());
    gateThread.start();
}

可能调整成mina库，还有其他的一个原因，就是在服务器端会无辜收到一个rst标识导致服务器断开。起初以为是代码问题，后来经过很长时间的排查和咨询，发现服务器用的是南方电信的网络，而一些北方网通的客户端在访问的时候，就会随机出现rst 连接复位现象！查询了好久，最后还是运维的大哥给的思维！当然在起初解决这个问题的时候，我还是本着代码的问题；顺便还去专门研究了Tcp/ip协议详解，翻出了大学里面学的计算机网络这本书。无论如何解决了就好！欢迎拍砖！