Java socket 以byte[]简单分片传送数据("UTF-8"编码)

我们选用的流是DataOutputStream和DataInputStream，下次再详解java中的各种流的区别。

1.我们先创建对象：

    private DataOutputStream outputStream = null;
    private DataInputStream inputStream = null;

2.然后可在构造方法中使用传入的socket对刚创建的对象定义：

    public ClientHandleThread(Socket socket) {
        this.socket = socket;
        this.initTimer();
        try {
            // socket.setSoTimeout(10000);
//            writer = new BufferedWriter(new OutputStreamWriter(
//                    this.socket.getOutputStream(), "UTF-8"));
//            reader = new BufferedReader(new InputStreamReader(
//                    this.socket.getInputStream(), "UTF-8"));
            
            outputStream = new DataOutputStream(this.socket.getOutputStream());
            inputStream = new DataInputStream(this.socket.getInputStream());
            

        } catch (Exception e) {
            e.printStackTrace();
            LogUtil.ERROR(e.getMessage());
        }
    }

3.发送方法定义：

简单的分片格式为：

　　定义一个byte数组　　byte[] buffer = new byte[1024];

　　该数据中第一个byte作为分片定义格式存储：

                 /**
                  * 00000000
                  * 最高位代表是否是第一个分片，为‘1’代表是第一个分片
                  * 次高位代表是否是最后一个分片，为‘1’代表为最后一个分片
                  */
                 buffer[0] |= 0X80;//表示是第一个分片
　　　　　　　　　　buffer[0] |= 0X40;//表示是最后一个分片
当然，还可以依据需要加上具体的定义，可以参考网络协议的报头进行设计，有需要可以查看《计算机网络》一书。

该方法分为三种走向：

　　当数据byte数组bytes的大小->   0<bytes.length<=1023 时：不用分片，直接定义该片为最后一片buffer[0] |= 0X40;//表示是最后一个分片，直接发送

　　当数据byte数组bytes的大小->   1023<bytes.length<=2046时，需要分为两片

　　当数据byte数组bytes的大小->   2046<bytes.length时，首先要切出首片(1023大小)，然后依据while(remainSize>bufferSize)循环切出中间片，最后剩下的数据量大小<=1023,这作为最后一个分片。

具体的可以参考下列代码：

    // 发送
    public void send(String data) {
        try {
            //需要设置"UTF-8"编码，避免中文造成的乱码        
            byte[] bytes = (data + "
").getBytes("UTF-8");
            int posotion = 0;
            int remainSize = bytes.length;//剩余数据量大小
            int bufferSize = 1023;//缓冲区数据量大小+1
            if(remainSize > bufferSize)
            {
                remainSize -=bufferSize;
                byte[] buffer = new byte[1024];
                buffer[0] = 0;//初始化
                /**
                 * 00000000
                 * 最高位代表是否是第一个分片，为‘1’代表是第一个分片
                 * 次高位代表是否是最后一个分片，为‘1’代表为最后一个分片
                 */
                buffer[0] |= 0X80;//表示是第一个分片
                System.arraycopy(bytes, posotion, buffer, 1, bufferSize);    
                posotion += bufferSize;
                this.outputStream.write(buffer);
                this.outputStream.flush();
                
            }
            while (remainSize>bufferSize) {
                remainSize -= bufferSize;
                byte[] buffer = new byte[1024];
                buffer[0] = 0;//初始化
//                buffer[0] |= 0X80;//表示是第一个分片
//                buffer[0] |= 0X40;//表示是最后一个分片
                System.arraycopy(bytes, posotion, buffer, 1, bufferSize);
                posotion += bufferSize;
                this.outputStream.write(buffer);
                this.outputStream.flush();
                
            }
            if(remainSize > 0)
            {
                byte[] buffer = new byte[remainSize+1];
                buffer[0] = 0;//初始化
//                buffer[0] |= 0X80;//表示是第一个分片
                buffer[0] |= 0X40;//表示是最后一个分片
                System.arraycopy(bytes, posotion, buffer, 1, remainSize);
                this.outputStream.write(buffer);
                this.outputStream.flush();
            }
            
//            this.writer.write(data + "
");
//            this.writer.flush();
            System.out.println("发送"+data);
        } catch (IOException e) {
            LogUtil.ERROR(e.getMessage());
            e.printStackTrace();
        }

    }

4.下面是接收处理代码：

需要表达的一点是，socket会依据切片的顺序发送，一般不会造成切片的顺序颠倒，当然严谨一些更好，最好增加数据包的序列号和编号。

下面只是一个简单示例：

            try {
                // System.out.println(RunFlag);

                //char chars[] = new char[1024];
                byte bytes[] = new byte[1024];
                int len = 0;
                StringBuilder jsonBuffer = new StringBuilder();
                String temp = null;
                int index = 0;
//                while ((len = reader.read(chars)) != -1) {
//                    temp = new String(chars, 0, len);
//                    if ((index = temp.indexOf("
")) != -1) {// 遇到
时就结束接收
//                        jsonBuffer.append(temp.substring(0, index));
//                        break;
//                    }
//                    jsonBuffer.append(temp);
//                }
                
                
                while ((len = inputStream.read(bytes)) != -1) {
                    temp = new String(bytes, 1, len-1,"UTF-8");
                    if ((index = temp.indexOf("
")) != -1 && (bytes[0] &= 0X40)==0X40) {// 遇到
时就结束接收和最后一个分片
                        jsonBuffer.append(temp.substring(0, index));
                        break;
                    }
                    jsonBuffer.append(temp);
                }
                

                String jsonString = jsonBuffer.toString();

　　　　　　　　　　　　......


            } catch (Exception e) {
                LogUtil.ERROR(e.toString());
            }

这里只是简单的判断一下是否为最后一个分片，可以在此基础上加上更严谨的判断。

谢谢您的阅读，希望对您有些帮助。