Java MessageDecoderResult.NEED_DATA属性代码示例

public MessageDecoderResult decode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out)
        throws ProtocolCodecException {
    int messageCount = 0;
    while (parseMessage(in, out)) {
        messageCount++;
    }
    if (messageCount > 0) {
        // Mina will compact the buffer because we can't detect a header
        if (in.remaining() < HEADER_PATTERN.length) {
            position = 0;
        }
        return MessageDecoderResult.OK;
    } else {
        // Mina will compact the buffer
        position -= in.position();
        return MessageDecoderResult.NEED_DATA;
    }
}
 

/**
 * 解码并处理断包
 */
@Override
public MessageDecoderResult decode(IoSession session, IoBuffer buffer, ProtocolDecoderOutput output)
		throws Exception {
	int nRemainning = buffer.remaining();
	if (nRemainning < MessageCodec.HEAD_LENGTH) {// min length
		return MessageDecoderResult.NEED_DATA;
	} else {
		buffer.mark();// 标记位置mark=pos
		int nLen = buffer.getShort();// 包长（包括消息头）
		buffer.reset();// 重置位置pos=mark

		// 如果buffer中可读的长度小于包长说明断包返回 NEED_DATA
		if (nRemainning < nLen) {
			// buffer.reset();//重置位置pos=mark
			return MessageDecoderResult.NEED_DATA;
		}
		// buffer.reset();//重置位置pos=mark
	}

	Object proObj = decodeBody(session, buffer);
	output.write(proObj);// 解码后输出
	return MessageDecoderResult.OK;
}
 

static MessageDecoderResult checkDecodable(byte type, IoBuffer in) {
    if (in.remaining() < 1) {
        return MessageDecoderResult.NEED_DATA;
    }
    byte h1 = in.get();
    byte messageType = (byte) ((h1 & 0x00F0) >> 4);
    
    int remainingLength = Utils.decodeRemainingLenght(in);
    if (remainingLength == -1) {
        return MessageDecoderResult.NEED_DATA;
    }
    
    //check remaining length
    if (in.remaining() < remainingLength) {
        return MessageDecoderResult.NEED_DATA;
    }
    
    return messageType == type ? MessageDecoderResult.OK : MessageDecoderResult.NOT_OK;
}
 

public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
	// 长度检查
	if (in.remaining() < 12) {
		return MessageDecoderResult.NEED_DATA;
	}

	// 控制码检查(未实现)
	/*byte b = in.array();
	
	if (tag == (short) 0x0001 || tag == (short) 0x8001) {
		logger.info("请求标识符：" + tag);
	} else {
		logger.error("未知的解码类型....");
		return MessageDecoderResult.NOT_OK;
	}*/

	// 数据长度检查(未实现)
	/*int len = in.getInt();
	if (in.remaining() < len) {
		return MessageDecoderResult.NEED_DATA;
	}*/
	
	//校验代码

	return MessageDecoderResult.OK;
}
 

@Override
public MessageDecoderResult decodable(IoSession session, IoBuffer in)
{
	
	Context context = (Context) session.getAttribute(CONTEXT);
	if(context!=null){
		if(context.limit_data){
			in.buf().position(0);
		}
	}
	//表示数据不够，需要读到新的数据后，再次调用decode()方法。
	if (in.remaining() < 2){
		return MessageDecoderResult.NEED_DATA;
	}
	else{
			context = new Context();
			//获取一个字符表示新的数据开始 用于判断异常数据
			in.skip(1);//这个数据是十六进制的 01 也就是1
			//获取第一个字符用于判断是否可以被当前解码器解码
			context.dataType = in.getInt();
			
			if(context.dataType == BeanUtil.UPLOAD_STR){
				//读取标题长度
				context.strLength = in.getInt();
				//声明数组长度
				context.byteStr = new byte[context.strLength];
				//System.out.println("我收到2了");
				session.setAttribute(CONTEXT, context);
				//表示可以解码
				return MessageDecoderResult.OK;
			}else{
				//System.out.println("服务端收到意外数据");
				return MessageDecoderResult.NOT_OK;
			}
		}
}
 

@Override
public MessageDecoderResult decodable(IoSession session, IoBuffer buffer) {
	// 如果buffer中可读的长度还没达到消息头长度返回 NEED_DATA
	if (buffer.remaining() < MessageCodec.HEAD_LENGTH) {
		return MessageDecoderResult.NEED_DATA;
	} else {
		if (!MessageCodec.checkValid(buffer.buf())) { // 不符合解析条件
			return MessageDecoderResult.NOT_OK;
		}
	}
	return MessageDecoderResult.OK;
}
 

public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
	try {
		return messageComplete(in) ? MessageDecoderResult.OK
				: MessageDecoderResult.NEED_DATA;
	} catch (Exception ex) {
		ex.printStackTrace();
	}

	return MessageDecoderResult.NOT_OK;
}
 

public MessageDecoderResult decode(IoSession session, IoBuffer in,
		ProtocolDecoderOutput out) throws Exception {
	HttpRequestMessage m = decodeBody(in);

	// Return NEED_DATA if the body is not fully read.
	if (m == null) {
		return MessageDecoderResult.NEED_DATA;
	}

	out.write(m);

	return MessageDecoderResult.OK;

}
 

public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
    int rem = in.remaining();
    int fornumber;
    byte aa;
    if (notfirstmessage) {
        flag++;
        fornumber = rem + flag;
    } else {
        flag = 0;
        fornumber = rem + flag;
    }
    try {
        for (int i = flag; i < fornumber; i++) {
            aa = in.get(i);
            if (']' == aa) {
                flaglast = flag;
                flag = i;
                length = flag - flaglast;
                notfirstmessage = true;
                return MessageDecoderResult.OK;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    notfirstmessage = false;
    return MessageDecoderResult.NEED_DATA;
}
 

@Override
public MessageDecoderResult decode(IoSession session, IoBuffer in,ProtocolDecoderOutput outPut) throws Exception {
	//将客户端发来的对象进行封装
	//TODO  等待测试超长数据是否能正常解码 
	Context context = (Context) session.getAttribute(CONTEXT);
	//跳过第一个字节
	if(!context.init){
		in.buf().position(0);//由于分包之后mina不能让没有改变的缓冲数据返回正常,于是先移动了下游标,这里给归0
		context.init = true;
		in.skip(1);
		in.getInt();
		in.getInt();
	}
 
	int count = context.count;
	//System.out.println("这里是第一次COnut："+context.count);
	//System.out.println("一共有"+in.remaining()+"数据");
	while (in.hasRemaining()) {
		//System.out.println("循环里面的Count："+count);
		byte b = in.get();
		if(b == 1){
			//收到下一条的起始数据了,证明此条数据已经残缺 重置缓冲区 作废此信息
			in.buf().position(1);//移动游标,mina不允许不使用数据就返回
			context.reset();//重置
			context.limit_data = true;//用于判断是否是前一次包破损后遗留下的新数据包  decodable中判断
			session.setAttribute(CONTEXT, context);
			return MessageDecoderResult.OK;//给他返回个正常解码,然后才能继续解码
		}
		new String(context.byteStr,BeanUtil.charset);
		//如果标题没读完 继续读
		if(!context.isReadName){
			context.byteStr[count] = b;
			if(count == context.strLength-1){
				//标题读完  byte[]转换为字符串
				context.fileName = new String(context.byteStr,BeanUtil.charset);
				//System.out.println(context.fileName);
				//count = -1;
				context.isReadName = true;
				//跳出程序
				break;
			}
		}
		/*
		if(context.isReadName && count != -1){
			//如果读取完了标题那么读取其他内容
			//byteFile[count] = b;
		}
		//byteFile[count] = b;
		 */
		//这里并未判断是否后面还有数据就加了1
		if(in.buf().position()<=in.buf().limit())
		count++;
          }
 
	context.count = count;
	session.setAttribute(CONTEXT, context);
	//如果内容全部读完  那么就存入并返回数据
	//System.out.println("Count:"+context.count+";----StrLen:"+context.strLength);
	if(context.count == context.strLength-1){
		//这里就代表数据全部接收完了 返回出去
		
		BaseMessage message = new BaseMessage();
		message.setDataType(context.dataType);
		StringBean bean = new StringBean();
		bean.setFileName(context.fileName);
		bean.setStrLength(context.strLength);
		message.setData(bean);
		outPut.write(message);
		//重置
		context.reset();
 
	}else{
		return  MessageDecoderResult.NEED_DATA;
	}
	//this.finishDecode(session, outPut);
	
	return MessageDecoderResult.OK;
}
 

public MessageDecoderResult decodable(IoSession session, ByteBuffer in) {
    int headerOffset = indexOf(in, in.position(), HEADER_PATTERN);
    return headerOffset != -1 ? MessageDecoderResult.OK : MessageDecoderResult.NEED_DATA;
}