网游开发之socket的简单设计

对于普通应用的网络模块一般使用http文本协议，在android开发中使用http协议比较简单，sdk已经做了很好的封装了，具体使用方法可以参考我的这篇博文。而在游戏开发中，可以结合使用http和socket，当然了http协议底层也是基于tcp协议的。http协议是无连接、无状态的，每次连接只能处理一个请求，然后就断了，而且发一个请求需要附加额外信息(请求行、请求头),每次请求都需要重新建立连接；使用socket的好处是更高效和省流量，建立一次连接后，只要不手动或者出现异常断开，就可以一直互相发送数据，而且是直接以字节的形式发送，不需要额外的附加信息，缺点就是难度加大了，需要服务端和客户端很好的配合，保证发送和读取时数据的顺序一致。本文通过一个简单的demo介绍开发android网游时socket的使用方法，主要包括：android客户端和一个简单的使用java实现的server端，实现客户端和服务端互相发送数据的功能。
1.客户端代码实现
首先创建一个Android应用，名称:AndroidSocketTest
然后分别创建4个文件：BytesUtil.java、BytesReader.java、BytesWriter.java、TCPCommunication.java,下面分别介绍这几个文件的用处和源码：
BytesUtil.java：包含了一些静态工具方法：基本类型和字节数组的相互转换，字符串和字节数组的相互转换，字节数组的赋值和大小重置，对输入流进行读取保存等。比较简单，下面直接看源码：

/**
author:alexzhou
email :[email protected]
date  :2012-11-7
 **/

public final class BytesUtil {

    /**
     *整型转换成字节数组
     * @param value 要转换的整型值
     * @return
     */
    public static byte [] shortToBytes( int value) {
        byte []write = new byte [ 2 ];
        write[ 0 ] = ( byte )( (value >>> 8 ) & 0xFF );
        write[ 1 ] = ( byte )( (value >>> 0 ) & 0xFF );
        return write;
    }

    public static byte [] intToBytes( int value) {
        byte []write = new byte [ 4 ];
        write[ 0 ] = ( byte )( (value >>> 24 ) & 0xFF );
        write[ 1 ] = ( byte )( (value >>> 16 ) & 0xFF );
        write[ 2 ] = ( byte )( (value >>> 8 ) & 0xFF );
        write[ 3 ] = ( byte )( (value >>> 0 ) & 0xFF );
        return write;
    }

    public static byte [] longToBytes( long value) {
        byte []write = new byte [ 8 ];
        write[ 0 ] = ( byte )( (value >>> 56 ) & 0xFF );
        write[ 1 ] = ( byte )( (value >>> 48 ) & 0xFF );
        write[ 2 ] = ( byte )( (value >>> 40 ) & 0xFF );
        write[ 3 ] = ( byte )( (value >>> 32 ) & 0xFF );
        write[ 4 ] = ( byte )( (value >>> 24 ) & 0xFF );
        write[ 5 ] = ( byte )( (value >>> 16 ) & 0xFF );
        write[ 6 ] = ( byte )( (value >>> 8 ) & 0xFF );
        write[ 7 ] = ( byte )( (value >>> 0 ) & 0xFF );
        return write;
    }

    /**
     * 字节数组转换成整型
     * @param value
     * @return
     */
    public static int bytesToInt( byte []value) {
        int i1 = (value[ 0 ] & 0xFF ) << 24 ;
        int i2 = (value[ 1 ] & 0xFF ) << 16 ;
        int i3 = (value[ 2 ] & 0xFF ) << 8 ;
        int i4 = (value[ 3 ] & 0xFF ) << 0 ;
        return (i1 | i2 | i3 | i4);
    }

    public static short bytesToShort( byte [] value) {
        int s1 = (value[ 0 ] & 0xFF ) << 8 ;
        int s2 = (value[ 1 ] & 0xFF ) << 0 ;
        return ( short )(s1 | s2);
    }

    public static long bytesToLong( byte [] value) {
        long L1 = (value[ 0 ] & 0xFF ) << 56 ;
        long L2 = (value[ 1 ] & 0xFF ) << 48 ;
        long L3 = (value[ 2 ] & 0xFF ) << 40 ;
        long L4 = (value[ 3 ] & 0xFF ) << 32 ;
        long L5 = (value[ 4 ] & 0xFF ) << 24 ;
        long L6 = (value[ 5 ] & 0xFF ) << 16 ;
        long L7 = (value[ 6 ] & 0xFF ) << 8 ;
        long L8 = (value[ 7 ] & 0xFF ) << 0 ;
        return (L1 | L2 | L3 | L4 | L5 | L6 | L7 | L8);
    }

    /**
     * 从指定字节数组中拷贝部分数据
     * @param origin
     * @param from
     * @param to
     * @return
     */
    public static byte [] copyBytes( byte [] origin, int from, int to) {
        int len = to - from;
        if (len < 0 || origin.length - from <= 0 ) {
            throw new IllegalArgumentException( "copyBytes->error arguments:to=" +to+ ",from=" +from);
        }
        byte [] ret = new byte [len];
        if (len == 0 ) return ret;
        System.arraycopy(origin, from, ret, 0 , Math.min(len, origin.length - from));
        return ret;
    }

    /**
     * 重置字节数组的大小，然后把原内容复制到新的字节数组中
     * @param origin
     * @param newSize
     * @return
     */
    public static byte [] resizeBytes( byte [] origin, int newSize) {
        if (newSize < 0 ) {
            throw new IllegalArgumentException( "resizeBytes->newSize must >= 0" );
        }
        byte [] ret = new byte [newSize];
        if (newSize == 0 ) return ret;
        System.arraycopy(origin, 0 ,ret, 0 ,Math.min(origin.length, newSize));
        return ret;
    }

    /**
     * 读取输入流中字节,并保存到指定的字节数组中
     * @param is
     * @param data
     * @param off
     * @param len
     */
    public static void readData(InputStream is, byte data[], int off, int len) {
        int hasRead = 0 ;
        final int BUFFER = 1024 ;
        while (hasRead < len) {
            try {
                int remain = len - hasRead;
                int count = is.read(data, off + hasRead, remain > BUFFER ? BUFFER : remain);
                if (count < 0 ) throw new IOException( "readData->read data error" );
                hasRead += count;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BytesReader.java：从服务端接收数据时使用，定义了一个字节数组类型的成员变量，用来保存从输入流中读取的数据。封装了一些从该字节数组中读取相应数据类型的函数，源码如下：

/**
 * 接受服务端数据时，读取字节并转换到相应类型
author:alexzhou
email :[email protected]
date  :2012-11-7
 **/

public final class BytesReader {

    private final byte []data;
    //字节数组的大小
    private final int size;
    //当前读取的位置
    private int position;

    public BytesReader( byte []data) {
        this .data = data;
        this .size = data.length;
        this .position = 0 ;
    }

    public byte [] read( int len) {
        if (len < 0 ) return null ;
        byte [] value = BytesUtil.copyBytes(data, position, position + len);
        this .position += len;
        return value;
    }

    public int getSize() {
        return size;
    }

    public boolean isAvailable() {
        return size - position > 0 ;
    }

    public short readShort() {
        byte [] value = read( 2 );
        return BytesUtil.bytesToShort(value);
    }

    public int readInt() {
        byte [] value = read( 4 );
        return BytesUtil.bytesToInt(value);
    }

    public long readLong() {
        byte [] value = read( 8 );
        return BytesUtil.bytesToLong(value);
    }

    public byte readByte() {
        int value = this .isAvailable() ? ( 0xFF & data[position++]) : - 1 ;
        return ( byte )value;
    }

    public byte [] readBytes() {
        int len = readShort();
        //读取大数据
        if (len >= 0xFFFF ) {
            len = this .readInt();
        }
        return len == 0 ? null : read(len);
    }

    public String readUTF() {
        byte [] bytes = readBytes();
        if ( null != bytes) {
            try {
                return new String(bytes, "UTF-8" );
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return null ;
    }
}

BytesWriter.java：向服务端发送数据时使用，跟BytesReader.java对应，也是把需要发送的数据保存到字节数组中，然后一次性发送给服务器。源码如下：

/**
author:alexzhou
email :[email protected]
date  :2012-11-9
 **/

public final class BytesWriter {

    private byte [] data;
    private int count;

    public BytesWriter() {
        this ( 64 );
    }

    public BytesWriter( int size) {
        this .data = new byte [size];
    }

    public byte [] getBytes() {
        return this .data.length == count ? data : count == 0 ? null : BytesUtil.resizeBytes( this .data, count);
    }

    public void write( byte [] value) {
        this .write(value, 0 , value == null ? 0 : value.length);
    }

    public void write( byte [] d, int offset, int len) {
        if (d == null || len == 0 ) return ;
        int newCount = count + len;
        if (newCount > this .data.length) {
            int newSize = Math.max( this .data.length << 1 , newCount);
            this .data = BytesUtil.resizeBytes( this .data, newSize);
        }
        System.arraycopy(d, offset, this .data, this .count, len);
        this .count = newCount;
    }

    public void writeInt( int value) {
        this .write(BytesUtil.intToBytes(value));
    }

    public void writeShort( int value) {
        this .write(BytesUtil.shortToBytes(value));
    }

    public void writeLong( long value) {
        this .write(BytesUtil.longToBytes(value));
    }

    public void writeByte( byte value) {
        int newCount = count + 1 ;
        if (newCount > this .data.length) {
            int newSize = Math.max( this .data.length << 1 , newCount);
            this .data = BytesUtil.resizeBytes( this .data, newSize);
        }
        this .data[count] = value;
        this .count = newCount;
    }

    public void writeBytes( byte [] value) {
        int length = (value == null ? 0 : value.length);
        //发送大数据时
        if (length >= 0xFFFF ) {
            this .writeShort( 0xFFFF );
            this .writeInt(length);
        } else {
            //告诉服务端发送的数据的大小
            this .writeShort(length);
        }
        this .write(value);
    }

    public void writeUTF(String value) {
        if (value == null || value.length() == 0 ) {
            this .writeShort( 0 );
        }
        byte [] bytes = null ;
        try {
            bytes = value.getBytes( "UTF-8" );
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        this