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 + "\r\n").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 + "\r\n");
//            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("\n")) != -1) {// 遇到\n時就結束接收
//                        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("\n")) != -1 && (bytes[0] &= 0X40)==0X40) {// 遇到\n時就結束接收和最后一個分片
                        jsonBuffer.append(temp.substring(0, index));
                        break;
                    }
                    jsonBuffer.append(temp);
                }
                

                String jsonString = jsonBuffer.toString();

　　　　　　　　　　　　......


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

這里只是簡單的判斷一下是否為最后一個分片，可以在此基礎上加上更嚴謹的判斷。

謝謝您的閱讀，希望對您有些幫助。