Java tutorial
/* * Copyright 2013 the original author or authors. * * Licensed 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.springframework.yarn.integration.ip.mind; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.StringReader; import java.util.HashMap; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.core.serializer.Deserializer; import org.springframework.core.serializer.Serializer; import org.springframework.integration.ip.tcp.serializer.SoftEndOfStreamException; /** * Spring {@link Serializer} and {@link Deserializer} interfaces * for mind protocol. * * @author Janne Valkealahti * */ public class MindRpcSerializer implements Serializer<MindRpcMessageHolder>, Deserializer<MindRpcMessageHolder> { private final static Log log = LogFactory.getLog(MindRpcSerializer.class); protected int maxMessageSize = 20000; /** * @see org.springframework.core.serializer.Deserializer#deserialize(java.io.InputStream) */ @Override public MindRpcMessageHolder deserialize(InputStream inputStream) throws IOException { int lenghts[] = readHeader(inputStream); if (log.isDebugEnabled()) { log.debug("rpc lenghts: " + lenghts[0] + "/" + lenghts[1]); } Map<String, String> headers = readHeaders(inputStream, lenghts[0]); byte[] content = readBytes(inputStream, lenghts[1]); if (log.isDebugEnabled()) { log.debug("deserialize: " + content); } return new MindRpcMessageHolder(headers, content); } /** * @see org.springframework.core.serializer.Serializer#serialize(java.lang.Object, java.io.OutputStream) */ @Override public void serialize(MindRpcMessageHolder object, OutputStream outputStream) throws IOException { if (log.isDebugEnabled()) { log.debug("serialize length=" + object.toBytes().length + " :" + new String(object.toBytes())); } outputStream.write(object.toBytes()); outputStream.flush(); } /** * Sets the max message size for transport. * * @param maxMessageSize the length of max message */ public void setMaxMessageSize(int maxMessageSize) { this.maxMessageSize = maxMessageSize; } /** * Reads the first line as a protocol header and parses sizes of * underlying headers and content. * * @param inputStream the input stream * @return int array containing sizes of headers and content * @throws IOException if read error occured */ protected int[] readHeader(InputStream inputStream) throws IOException { int[] ret = new int[] { 0, 0 }; byte[] buffer = new byte[20]; int n = 0; int bite; while (true) { bite = inputStream.read(); if (bite < 0 && n == 0) { throw new SoftEndOfStreamException("Stream closed between payloads"); } checkClosure(bite); if (n > 0 && bite == '\n' && buffer[n - 1] == '\r') { break; } buffer[n++] = (byte) bite; if (n >= 20) { throw new IOException("CRLF not found before max message length: " + this.maxMessageSize); } } byte[] assembledData = new byte[n - 1]; System.arraycopy(buffer, 0, assembledData, 0, n - 1); String header = new String(assembledData); if (log.isDebugEnabled()) { log.debug("Mind rpc header:" + header); } String[] respBytes = header.split(" "); ret[0] = Integer.parseInt(respBytes[1]); ret[1] = Integer.parseInt(respBytes[2]); if (log.isDebugEnabled()) { log.debug("Mind rpc parsed sizes: head=" + ret[0] + " content=" + ret[1]); } return ret; } /** * Reads a message headers from inputstream with a given length. * * @param inputStream the input stream * @param length how much to read from a stream * @return Map of headers * @throws IOException if error occured */ protected Map<String, String> readHeaders(InputStream inputStream, int length) throws IOException { Map<String, String> map = new HashMap<String, String>(); byte[] bytes = readBytes(inputStream, length); BufferedReader reader = new BufferedReader(new StringReader(new String(bytes))); String line; while ((line = reader.readLine()) != null) { if (log.isDebugEnabled()) { log.debug("deserialize header: " + line); } String[] split = line.split(":"); if (split != null & split.length == 2) { map.put(split[0], split[1]); } } return map; } /** * Helper method to read bytes from a stream. * * @param inputStream the input stream * @param length how much to read * @return bytes to read * @throws IOException if error occured */ protected byte[] readBytes(InputStream inputStream, int length) throws IOException { byte[] buffer = new byte[length]; int lengthRead = 0; while (lengthRead < length) { int len; len = inputStream.read(buffer, lengthRead, length - lengthRead); if (len < 0) { throw new IOException("Stream closed after " + lengthRead + " of " + length); } lengthRead += len; } return buffer; } protected void checkClosure(int bite) throws IOException { if (bite < 0) { if (log.isDebugEnabled()) { log.debug("Socket closed during message assembly"); } throw new IOException("Socket closed during message assembly"); } } }