Предельный размер потока

Question

Я работаю над проектом, где мой сервис получает поток, и мне нужно отправить массив byte [] в продукт антивирусной проверки. Я хочу ограничить размер данных, с которыми мне приходится иметь дело. Так, например, я хочу принимать только 2ГБ файлы в виде потоков. Текущий код работает от Reader и Writer и что механизм вызывается несколько раз в байтах буфера, а не все вместе. Я использовал класс CappedLengthInputStream, который говорит, что он ограничивает размер потока, но не уверен, как именно он это делает, и если я посылаю только байты буфера, он никогда не будет больше 2 ГБ. Обратите внимание, что этот код не мой, я просто пытаюсь поддерживать и обновлять его. Есть мысли или лучший подход к этому? Я разместил фрагменты кода ниже.

// If we are capping the size then wrap the input stream in our
        // observer
        // stream
        long maxDataBytes = 2147483648L;
        if ( maxDataBytes != -1 ) {
            inputStream = new CappedLengthInputStream( inputStream, maxDataBytes );
        }



Reader reader = (encoding == null) ? new InputStreamReader(inputStream ) : new InputStreamReader(inputStream , encoding);
Writer writer = (encoding == null) ? new OutputStreamWriter(dataOut) : new OutputStreamWriter(dataOut, encoding);

int len;
        char[] buff = new char[getStreamBufferSize()];

        try {
            byte[] buffByte;
            while ((len = reader.read(buff)) != -1) {
                buffByte = new String(buff).getBytes();
                // Write the bytes to engine
                request.send(buffByte, 0, len);
                // Also write the bytes to the disk
                writer.write(buff, 0, len);
            }

// ограниченный класс входного потока

public class CappedLengthInputStream extends InputStream {

    /** The wrapped stream. */
    protected InputStream wrappedStream;

    /** The bytes count. */
    protected long bytesCount;

    /** The max bytes size. */
    protected long maxBytesSize;

    /**
     * The Constructor.
     * 
     * @param wrappedStream
     *            the wrapped stream
     * @param maxBytesSize
     *            the max bytes size
     */
    public CappedLengthInputStream(InputStream wrappedStream, long maxBytesSize) {
        this.wrappedStream = wrappedStream;
        this.maxBytesSize = maxBytesSize;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#available()
     */
    public int available() throws IOException {
        return wrappedStream.available();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#close()
     */
    public void close() throws IOException {
        wrappedStream.close();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object obj) {
        return wrappedStream.equals(obj);
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#hashCode()
     */
    public int hashCode() {
        return wrappedStream.hashCode();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#mark(int)
     */
    public void mark(int readlimit) {
        wrappedStream.mark(readlimit);
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#markSupported()
     */
    public boolean markSupported() {
        return wrappedStream.markSupported();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#read()
     */
    public int read() throws IOException {
        int numBytes = wrappedStream.read();
        bytesCount += numBytes;
        if (bytesCount > maxBytesSize) {
            throw new CapExceededException(this);
        }
        return numBytes;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#read(byte[], int, int)
     */
    public int read(byte[] b, int off, int len) throws IOException {
        int numBytes = wrappedStream.read(b, off, len);
        bytesCount += numBytes;
        if (bytesCount > maxBytesSize) {
            throw new CapExceededException(this);
        }
        return numBytes;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#read(byte[])
     */
    public int read(byte[] b) throws IOException {
        int numBytes = wrappedStream.read(b);
        bytesCount += numBytes;
        if (bytesCount > maxBytesSize) {
            throw new CapExceededException(this);
        }
        return numBytes;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#reset()
     */
    public void reset() throws IOException {
        wrappedStream.reset();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.io.InputStream#skip(long)
     */
    public long skip(long n) throws IOException {
        return wrappedStream.skip(n);
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#toString()
     */
    public String toString() {
        return wrappedStream.toString();
    }

    /**
     * Gets the bytes count.
     * 
     * @return the bytes count
     */
    public long getBytesCount() {
        return bytesCount;
    }

    /**
     * Gets the max bytes size.
     * 
     * @return the max bytes size
     */
    public long getMaxBytesSize() {
        return maxBytesSize;
    }