MINA粘包断包专题研究

   (4)累积是什么意思

五、CumulativeProtocolDecoder源码

/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 *
 */
package org.apache.mina.filter.codec;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.service.TransportMetadata;
import org.apache.mina.core.session.AttributeKey;
import org.apache.mina.core.session.IoSession;

/**
 * A {@link ProtocolDecoder} that cumulates the content of received
 * buffers to a <em>cumulative buffer</em> to help users implement decoders.
 * <p>
 * If the received {@link IoBuffer} is only a part of a message.
 * decoders should cumulate received buffers to make a message complete or
 * to postpone decoding until more buffers arrive.
 * <p>
 * Here is an example decoder that decodes CRLF terminated lines into
 * <code>Command</code> objects:
 * <pre>
 * public class CrLfTerminatedCommandLineDecoder
 *         extends CumulativeProtocolDecoder {
 *
 *     private Command parseCommand(IoBuffer in) {
 *         // Convert the bytes in the specified buffer to a
 *         // Command object.
 *         ...
 *     }
 *
 *     protected boolean doDecode(
 *             IoSession session, IoBuffer in, ProtocolDecoderOutput out)
 *             throws Exception {
 *
 *         // Remember the initial position.
 *         int start = in.position();
 *
 *         // Now find the first CRLF in the buffer.
 *         byte previous = 0;
 *         while (in.hasRemaining()) {
 *             byte current = in.get();
 *
 *             if (previous == '\r' && current == '\n') {
 *                 // Remember the current position and limit.
 *                 int position = in.position();
 *                 int limit = in.limit();
 *                 try {
 *                     in.position(start);
 *                     in.limit(position);
 *                     // The bytes between in.position() and in.limit()
 *                     // now contain a full CRLF terminated line.
 *                     out.write(parseCommand(in.slice()));
 *                 } finally {
 *                     // Set the position to point right after the
 *                     // detected line and set the limit to the old
 *                     // one.
 *                     in.position(position);
 *                     in.limit(limit);
 *                 }
 *                 // Decoded one line; CumulativeProtocolDecoder will
 *                 // call me again until I return false. So just
 *                 // return true until there are no more lines in the
 *                 // buffer.
 *                 return true;
 *             }
 *
 *             previous = current;
 *         }
 *
 *         // Could not find CRLF in the buffer. Reset the initial
 *         // position to the one we recorded above.
 *         in.position(start);
 *
 *         return false;
 *     }
 * }
 * </pre>
 * <p>
 * Please note that this decoder simply forward the call to
 * {@link #doDecode(IoSession, IoBuffer, ProtocolDecoderOutput)} if the
 * underlying transport doesn't have a packet fragmentation.  Whether the
 * transport has fragmentation or not is determined by querying
 * {@link TransportMetadata}.
 *
 * @author <a href="http://mina.apache.org">Apache MINA Project</a>
 */
public abstract class CumulativeProtocolDecoder extends ProtocolDecoderAdapter {

    private final AttributeKey BUFFER = new AttributeKey(getClass(), "buffer");

    /**
     * Creates a new instance.
     */
    protected CumulativeProtocolDecoder() {
        // Do nothing
    }

    /**
     * Cumulates content of <tt>in</tt> into internal buffer and forwards
     * decoding request to {@link #doDecode(IoSession, IoBuffer, ProtocolDecoderOutput)}.
     * <tt>doDecode()</tt> is invoked repeatedly until it returns <tt>false</tt>
     * and the cumulative buffer is compacted after decoding ends.
     *
     * @throws IllegalStateException if your <tt>doDecode()</tt> returned
     *                               <tt>true</tt> not consuming the cumulative buffer.
     */
    public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {

        if (!session.getTransportMetadata().hasFragmentation()) {
            while (in.hasRemaining()) {
            	// 判断是否符合解码要求，不符合则中断并返回
                if (!doDecode(session, in, out)) {
                    break;
                }
            }

            return;
        }

        boolean usingSessionBuffer = true;
        // 取得上次断包数据
        IoBuffer buf = (IoBuffer) session.getAttribute(BUFFER);
        // If we have a session buffer, append data to that; otherwise
        // use the buffer read from the network directly.
        if (buf != null) {// 如果有断包数据
            boolean appended = false;
            // Make sure that the buffer is auto-expanded.
            if (buf.isAutoExpand()) {
                try {
                	// 将断包数据和当前传入的数据进行拼接
                    buf.put(in);
                    appended = true;
                } catch (IllegalStateException e) {
                    // A user called derivation method (e.g. slice()),
                    // which disables auto-expansion of the parent buffer.
                } catch (IndexOutOfBoundsException e) {
                    // A user disabled auto-expansion.
                }
            }

            if (appended) {
                buf.flip();// 如果是拼接的数据，将buf置为读模式
            } else {
                // Reallocate the buffer if append operation failed due to
                // derivation or disabled auto-expansion.
            	//如果buf不是可自动扩展的buffer，则通过数据拷贝的方式将断包数据和当前数据进行拼接
                buf.flip();
                IoBuffer newBuf = IoBuffer.allocate(buf.remaining() + in.remaining()).setAutoExpand(true);
                newBuf.order(buf.order());
                newBuf.put(buf);
                newBuf.put(in);
                newBuf.flip();
                buf = newBuf;

                // Update the session attribute.
                session.setAttribute(BUFFER, buf);
            }
        } else {
            buf = in;
            usingSessionBuffer = false;
        }

        for (;;) {
            int oldPos = buf.position();
            boolean decoded = doDecode(session, buf, out);// 进行数据的解码操作
            if (decoded) {
            	// 如果符合解码要求并进行了解码操作，则当前position和解码前的position不可能一样
                if (buf.position() == oldPos) {
                    throw new IllegalStateException("doDecode() can't return true when buffer is not consumed.");
                }
                // 如果已经没有数据，则退出循环
                if (!buf.hasRemaining()) {
                    break;
                }
            } else {
            	// 如果不符合解码要求，则退出循环
                break;
            }
        }

        // if there is any data left that cannot be decoded, we store
        // it in a buffer in the session and next time this decoder is
        // invoked the session buffer gets appended to
        if (buf.hasRemaining()) {
            if (usingSessionBuffer && buf.isAutoExpand()) {
                buf.compact();
            } else {
            	//如果还有没处理完的数据（一般为断包），刚将此数据存入session中，以便和下次数据进行拼接。
                storeRemainingInSession(buf, session);
            }
        } else {
            if (usingSessionBuffer) {
                removeSessionBuffer(session);
            }
        }
    }

    /**
     * Implement this method to consume the specified cumulative buffer and
     * decode its content into message(s).
     *
     * @param in the cumulative buffer
     * @return <tt>true</tt> if and only if there's more to decode in the buffer
     *         and you want to have <tt>doDecode</tt> method invoked again.
     *         Return <tt>false</tt> if remaining data is not enough to decode,
     *         then this method will be invoked again when more data is cumulated.
     * @throws Exception if cannot decode <tt>in</tt>.
     */
    protected abstract boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception;

    /**
     * Releases the cumulative buffer used by the specified <tt>session</tt>.
     * Please don't forget to call <tt>super.dispose( session )</tt> when
     * you override this method.
     */
    @Override
    public void dispose(IoSession session) throws Exception {
        removeSessionBuffer(session);
    }

    private void removeSessionBuffer(IoSession session) {
        session.removeAttribute(BUFFER);
    }

    private void storeRemainingInSession(IoBuffer buf, IoSession session) {
        final IoBuffer remainingBuf = IoBuffer.allocate(buf.capacity()).setAutoExpand(true);

        remainingBuf.order(buf.order());
        remainingBuf.put(buf);

        session.setAttribute(BUFFER, remainingBuf);
    }
}

六、自定义SocketDecoder类的写法(我在项目中的解码类):

 
     1、思路梳理

 
      （1）当Socket长连接成功之后，客户端向服务器端发起接口调用，请求相关业务数据。

（2）服务器端响应，将业务数据write到IoSession的IoBuffer中。

（3）客户端考虑四种情况（第三大点中已经列出，不再累述）

（4）客户端从IP包包头中读取到响应数据的总长度

（5）接下来再通过调用IoBuffer类的remaining()方法，获取到IP包中数据的长度。

（6）判断IP包中数据的长度，是否等于数据的总长度，如果是小于响应数据的总长度，则说明还有IP包未收完全，因此return false，继续接收IP包，让其缓存进IoBuffer缓冲区中，进行数据拼接，直到将数据拼接成完整的服务器端响应的数据为止。

（7）当IoBuffer缓冲区中的数据长度等于服务器端响应数据的总长度，则开始按照协议文件对数据进行解析，解析完成之后，注意要返回true，返回true，表明结束当前数据的解析，也表明消费掉了IoBuffer缓中区中存放的数据。

说明一下：这里面的协议文件指的就是服务器端接口编写人员编写的名字xxx.proto的文件，这个文件里面规定了协议头、CRC校验码、接口请求的参数与响应的字段等等信息（这块儿可以与服务器端的人员好好沟通下）。

 
      2、示例代码

package com.goodwin.finance.net.socket;

import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.ArrayList;
import java.util.List;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;

import android.util.Log;

import com.goodwin.finance.protobuf.HqProtos.tagAnsHead;
import com.goodwin.finance.protobuf.HqProtos.tagCommon;
import com.goodwin.finance.protobuf.HqProtos.tagCommon.MF;
import com.goodwin.finance.protobuf.HqProtos.tagCommon.SF;
import com.goodwin.finance.protobuf.HqProtos.tagResponseDataArchitecture;
import com.goodwin.finance.protobuf.HqProtos.tagResponseHeartbeat;
import com.goodwin.finance.protobuf.HqProtos.tagResponseICSortFastData;
import com.goodwin.finance.protobuf.HqProtos.tagResponseL1StockMinuteData;
import com.goodwin.finance.util.DataUtil;
import com.google.protobuf.InvalidProtocolBufferException;

/**
 * 将行情服务器返回的数据进行解包处理，并重新编码
 * @author Administrator
 */
public class SocketDecoder extends CumulativeProtocolDecoder {
	// 日志输出标记
	private static final String TAG = "SocketDecoder";
	// 字符流转码对象
	private final CharsetDecoder charsetDecoder;
	// IP包包头的字节数
	public static final int MSG_HEADER_LENGTH = 4;
	// IP包中CRC的长度
	public static final int CRC_LENGTH = 2;

	public SocketDecoder(String charset) {
		this.charsetDecoder = Charset.forName(charset).newDecoder();
	}

	@Override
	protected synchronized boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
		//解析数据包头部信息，获取到该响应数据的总长度
		if (HqClient.time == -1) {
			deCodeHeader(session, in);
			HqClient.time = 1;
		}
		//1、开始接收第一个数据包
		int dataLength = in.remaining();

		if (dataLength >= MSG_HEADER_LENGTH + CRC_LENGTH) {
			//如果当前读取的缓冲区中的数据，小于响应数据的总长度，则让缓冲区继续累积数据，一直累积到数据接收完成，即缓冲区中数据的长度等于响应数据的总长度时，则开始解析.
			if (dataLength < HqClient.contentSize) {
				Log.i(TAG, "=======================缓冲数据区缓冲大小:" + dataLength + "=====================");
				return false;//接收下一数据包，累积至缓冲区，直至接收完成.
			} else {//如果当前缓冲区的数据等于 发送内容的长度，则开始解析数据,否则继续缓冲
				byte[] dataB = new byte[dataLength];
				in.get(dataB);
				HqClient.dataBuf.put(dataB);

				HqClient.dataBuf.flip();
				byte[] headSizeB = new byte[4];
				HqClient.dataBuf.get(headSizeB);

				byte[] crcB = new byte[2];
				HqClient.dataBuf.get(crcB);

				int headsize = DataUtil.byteArray2int(headSizeB);
				byte[] headBytes = new byte[headsize];// 请求头tagReqHead
				HqClient.dataBuf.get(headBytes);

				tagAnsHead reqHead = tagAnsHead.parseFrom(headBytes);
				tagCommon comm = reqHead.getComm();
				int contentsize = comm.getContentsize();

				byte[] contentBytes = new byte[contentsize];// 请求内容
				HqClient.dataBuf.get(contentBytes);

				List<Object> hqDatas = new ArrayList<Object>();
				if (comm.getMainFunction().equals(MF.Stock)) {
					if (comm.getSubFunction().equals(SF.dat_architecture)) {// 数据框架
						tagResponseDataArchitecture dataArchitecture = tagResponseDataArchitecture.parseFrom(contentBytes);
						hqDatas.add(dataArchitecture);
					} else if (comm.getSubFunction().equals(SF.baojialiebiao)) {//报价列表
						tagResponseICSortFastData icSortFastData = tagResponseICSortFastData.parseFrom(contentBytes);
						hqDatas.add(icSortFastData);
					} else if (comm.getSubFunction().equals(SF.l1RealTime)) {//多个股票分时线
						tagResponseL1StockMinuteData l1StockMinuteData = tagResponseL1StockMinuteData.parseFrom(contentBytes);
						hqDatas.add(l1StockMinuteData);
					} else if (comm.getSubFunction().equals(SF.heartbeat)) {
						tagResponseHeartbeat heartbeat = tagResponseHeartbeat.parseFrom(contentBytes);
						hqDatas.add(heartbeat);
					}
				} else if (comm.getMainFunction().equals(MF.Notify)) {
					hqDatas.add(reqHead);
				}

				HqClient.totalLength = -1;
				HqClient.contentSize = -1;
				HqClient.time = -1;//
				HqClient.dataBuf.flip();//极限设为位置，位置设为0。
				HqClient.dataBuf.clear();//不改变极限，位置设为0。

				out.write(hqDatas);
				Log.i(TAG, "=======================缓冲区数据解析完毕:" + dataLength + "=====================");
				return true;
			}
		}
		return false;
	}

	/**
	 * 解析包头
	 * @throws InvalidProtocolBufferException
	 */
	private void deCodeHeader(IoSession session, IoBuffer in) throws InvalidProtocolBufferException {
		if (in.remaining() >= MSG_HEADER_LENGTH + CRC_LENGTH) {

			int totalLength = HqClient.totalLength;

			byte[] headSizeB = new byte[4];
			in.get(headSizeB);
			HqClient.dataBuf.put(headSizeB);

			byte[] crcB = new byte[2];
			in.get(crcB);
			HqClient.dataBuf.put(crcB);

			int headsize = DataUtil.byteArray2int(headSizeB);
			byte[] headBytes = new byte[headsize];
			in.get(headBytes);
			HqClient.dataBuf.put(headBytes);

			tagAnsHead reqHead = tagAnsHead.parseFrom(headBytes);
			tagCommon comm = reqHead.getComm();
			int contentsize = comm.getContentsize();
			totalLength = 4 + 2 + headsize + contentsize;
			HqClient.contentSize = contentsize;
			HqClient.totalLength = totalLength;

			Log.i(TAG, "===================================信息头长度为:" + headsize + "===================================");
			Log.i(TAG, "===================================信息内容长度为:" + contentsize + "===================================");
			Log.i(TAG, "===================================信息总长度为:" + totalLength + "===================================");
		}
	}
}

七、后记

文章写得较为散乱，但却是总结了多篇文章之精华，结合自己的实践提炼而成。如有不足之处，敬请各位IT精英们指正。

结尾之余想到一点东东：服务器端为什么会将数据分割成多个IP包进行发送?这个涉及到网络相关的东东，小的概念上捣腾的不是十分清楚，需要大家自己查寻，或者是复习下《计算机网络》相关的东东，呵呵，多扯了！！！