io.netty.handler.codec.serialization.ObjectDecoderInputStream Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* Copyright 2012 The Netty Project
*
* The Netty Project 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:
*
* https://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 io.netty.handler.codec.serialization;
import io.netty.util.internal.ObjectUtil;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.StreamCorruptedException;
/**
* An {@link ObjectInput} which is interoperable with {@link ObjectEncoder}
* and {@link ObjectEncoderOutputStream}.
*/
public class ObjectDecoderInputStream extends InputStream implements
ObjectInput {
private final DataInputStream in;
private final int maxObjectSize;
private final ClassResolver classResolver;
/**
* Creates a new {@link ObjectInput}.
*
* @param in
* the {@link InputStream} where the serialized form will be
* read from
*/
public ObjectDecoderInputStream(InputStream in) {
this(in, null);
}
/**
* Creates a new {@link ObjectInput}.
*
* @param in
* the {@link InputStream} where the serialized form will be
* read from
* @param classLoader
* the {@link ClassLoader} which will load the class of the
* serialized object
*/
public ObjectDecoderInputStream(InputStream in, ClassLoader classLoader) {
this(in, classLoader, 1048576);
}
/**
* Creates a new {@link ObjectInput}.
*
* @param in
* the {@link InputStream} where the serialized form will be
* read from
* @param maxObjectSize
* the maximum byte length of the serialized object. if the length
* of the received object is greater than this value,
* a {@link StreamCorruptedException} will be raised.
*/
public ObjectDecoderInputStream(InputStream in, int maxObjectSize) {
this(in, null, maxObjectSize);
}
/**
* Creates a new {@link ObjectInput}.
*
* @param in
* the {@link InputStream} where the serialized form will be
* read from
* @param classLoader
* the {@link ClassLoader} which will load the class of the
* serialized object
* @param maxObjectSize
* the maximum byte length of the serialized object. if the length
* of the received object is greater than this value,
* a {@link StreamCorruptedException} will be raised.
*/
public ObjectDecoderInputStream(InputStream in, ClassLoader classLoader, int maxObjectSize) {
ObjectUtil.checkNotNull(in, "in");
ObjectUtil.checkPositive(maxObjectSize, "maxObjectSize");
if (in instanceof DataInputStream) {
this.in = (DataInputStream) in;
} else {
this.in = new DataInputStream(in);
}
classResolver = ClassResolvers.weakCachingResolver(classLoader);
this.maxObjectSize = maxObjectSize;
}
@Override
public Object readObject() throws ClassNotFoundException, IOException {
int dataLen = readInt();
if (dataLen <= 0) {
throw new StreamCorruptedException("invalid data length: " + dataLen);
}
if (dataLen > maxObjectSize) {
throw new StreamCorruptedException(
"data length too big: " + dataLen + " (max: " + maxObjectSize + ')');
}
return new CompactObjectInputStream(in, classResolver).readObject();
}
@Override
public int available() throws IOException {
return in.available();
}
@Override
public void close() throws IOException {
in.close();
}
// Suppress a warning since the class is not thread-safe
@Override
public void mark(int readlimit) { // lgtm[java/non-sync-override]
in.mark(readlimit);
}
@Override
public boolean markSupported() {
return in.markSupported();
}
// Suppress a warning since the class is not thread-safe
@Override
public int read() throws IOException { // lgtm[java/non-sync-override]
return in.read();
}
@Override
public final int read(byte[] b, int off, int len) throws IOException {
return in.read(b, off, len);
}
@Override
public final int read(byte[] b) throws IOException {
return in.read(b);
}
@Override
public final boolean readBoolean() throws IOException {
return in.readBoolean();
}
@Override
public final byte readByte() throws IOException {
return in.readByte();
}
@Override
public final char readChar() throws IOException {
return in.readChar();
}
@Override
public final double readDouble() throws IOException {
return in.readDouble();
}
@Override
public final float readFloat() throws IOException {
return in.readFloat();
}
@Override
public final void readFully(byte[] b, int off, int len) throws IOException {
in.readFully(b, off, len);
}
@Override
public final void readFully(byte[] b) throws IOException {
in.readFully(b);
}
@Override
public final int readInt() throws IOException {
return in.readInt();
}
/**
* @deprecated Use {@link BufferedReader#readLine()} instead.
*/
@Override
@Deprecated
public final String readLine() throws IOException {
return in.readLine();
}
@Override
public final long readLong() throws IOException {
return in.readLong();
}
@Override
public final short readShort() throws IOException {
return in.readShort();
}
@Override
public final int readUnsignedByte() throws IOException {
return in.readUnsignedByte();
}
@Override
public final int readUnsignedShort() throws IOException {
return in.readUnsignedShort();
}
@Override
public final String readUTF() throws IOException {
return in.readUTF();
}
@Override
public void reset() throws IOException {
in.reset();
}
@Override
public long skip(long n) throws IOException {
return in.skip(n);
}
@Override
public final int skipBytes(int n) throws IOException {
return in.skipBytes(n);
}
}