Java ContentLengthStrategy.IDENTITY属性代码示例

public HttpRequest receiveRequest() throws HttpException, IOException {
    HttpRequest request = (HttpRequest) this.requestParser.parse();
    if (HEADERLOG.isDebugEnabled()) {
        HEADERLOG.debug(">> " + request.getRequestLine().toString());
        for (HeaderIterator it = request.headerIterator(); it.hasNext(); ) {
            HEADERLOG.debug(">> " + it.nextHeader().toString());
        }
    }
    
    // Prepare input stream
    this.in = null;
    if (request instanceof HttpEntityEnclosingRequest) {
        long len = this.contentLenStrategy.determineLength(request);
        if (len == ContentLengthStrategy.CHUNKED) {
            this.in = new ChunkedInputStream(this.inbuffer);
        } else if (len == ContentLengthStrategy.IDENTITY) {
            this.in = new IdentityInputStream(this.inbuffer);                            
        } else {
            this.in = new ContentLengthInputStream(inbuffer, len);
        }
    }
    return request;
}
 

/**
 * Creates a {@link BasicHttpEntity} based on properties of the given
 * message. The content of the entity is created by wrapping
 * {@link SessionInputBuffer} with a content decoder depending on the
 * transfer mechanism used by the message.
 * <p>
 * This method is called by the public
 * {@link #deserialize(SessionInputBuffer, HttpMessage)}.
 *
 * @param inbuffer the session input buffer.
 * @param message the message.
 * @return HTTP entity.
 * @throws HttpException in case of HTTP protocol violation.
 * @throws IOException in case of an I/O error.
 */
protected BasicHttpEntity doDeserialize(
        final SessionInputBuffer inbuffer,
        final HttpMessage message) throws HttpException, IOException {
    BasicHttpEntity entity = new BasicHttpEntity();

    long len = this.lenStrategy.determineLength(message);
    if (len == ContentLengthStrategy.CHUNKED) {
        entity.setChunked(true);
        entity.setContentLength(-1);
        entity.setContent(new ChunkedInputStream(inbuffer));
    } else if (len == ContentLengthStrategy.IDENTITY) {
        entity.setChunked(false);
        entity.setContentLength(-1);
        entity.setContent(new IdentityInputStream(inbuffer));
    } else {
        entity.setChunked(false);
        entity.setContentLength(len);
        entity.setContent(new ContentLengthInputStream(inbuffer, len));
    }

    Header contentTypeHeader = message.getFirstHeader(HTTP.CONTENT_TYPE);
    if (contentTypeHeader != null) {
        entity.setContentType(contentTypeHeader);
    }
    Header contentEncodingHeader = message.getFirstHeader(HTTP.CONTENT_ENCODING);
    if (contentEncodingHeader != null) {
        entity.setContentEncoding(contentEncodingHeader);
    }
    return entity;
}
 

public long determineLength(final HttpMessage message) throws HttpException {
    long result = this.contentLengthStrategy.determineLength(message);
    if (result == ContentLengthStrategy.IDENTITY) {
        throw new ProtocolException("Identity transfer encoding cannot be used");
    }
    return result;
}
 

public long determineLength(final HttpMessage message) throws HttpException {
    final long result = this.contentLengthStrategy.determineLength(message);
    if (result == ContentLengthStrategy.IDENTITY) {
        throw new ProtocolException("Identity transfer encoding cannot be used");
    }
    return result;
}
 

protected OutputStream createOutputStream(
        final long len,
        final SessionOutputBuffer outbuffer) {
    if (len == ContentLengthStrategy.CHUNKED) {
        return new ChunkedOutputStreamHC4(2048, outbuffer);
    } else if (len == ContentLengthStrategy.IDENTITY) {
        return new IdentityOutputStreamHC4(outbuffer);
    } else {
        return new ContentLengthOutputStreamHC4(outbuffer, len);
    }
}
 

protected InputStream createInputStream(
        final long len,
        final SessionInputBuffer inbuffer) {
    if (len == ContentLengthStrategy.CHUNKED) {
        return new ChunkedInputStreamHC4(inbuffer);
    } else if (len == ContentLengthStrategy.IDENTITY) {
        return new IdentityInputStreamHC4(inbuffer);
    } else {
        return new ContentLengthInputStreamHC4(inbuffer, len);
    }
}
 

protected HttpEntity prepareInput(final HttpMessage message) throws HttpException {
    final BasicHttpEntityHC4 entity = new BasicHttpEntityHC4();

    final long len = this.incomingContentStrategy.determineLength(message);
    final InputStream instream = createInputStream(len, this.inbuffer);
    if (len == ContentLengthStrategy.CHUNKED) {
        entity.setChunked(true);
        entity.setContentLength(-1);
        entity.setContent(instream);
    } else if (len == ContentLengthStrategy.IDENTITY) {
        entity.setChunked(false);
        entity.setContentLength(-1);
        entity.setContent(instream);
    } else {
        entity.setChunked(false);
        entity.setContentLength(len);
        entity.setContent(instream);
    }

    final Header contentTypeHeader = message.getFirstHeader(HTTP.CONTENT_TYPE);
    if (contentTypeHeader != null) {
        entity.setContentType(contentTypeHeader);
    }
    final Header contentEncodingHeader = message.getFirstHeader(HTTP.CONTENT_ENCODING);
    if (contentEncodingHeader != null) {
        entity.setContentEncoding(contentEncodingHeader);
    }
    return entity;
}
 

/**
 * Creates a transfer codec based on properties of the given HTTP message
 * and returns {@link OutputStream} instance that transparently encodes
 * output data as it is being written out to the output stream.
 * <p>
 * This method is called by the public
 * {@link #serialize(SessionOutputBuffer, HttpMessage, HttpEntity)}.
 *
 * @param outbuffer the session output buffer.
 * @param message the HTTP message.
 * @return output stream.
 * @throws HttpException in case of HTTP protocol violation.
 * @throws IOException in case of an I/O error.
 */
protected OutputStream doSerialize(
        final SessionOutputBuffer outbuffer,
        final HttpMessage message) throws HttpException, IOException {
    long len = this.lenStrategy.determineLength(message);
    if (len == ContentLengthStrategy.CHUNKED) {
        return new ChunkedOutputStream(outbuffer);
    } else if (len == ContentLengthStrategy.IDENTITY) {
        return new IdentityOutputStream(outbuffer);
    } else {
        return new ContentLengthOutputStream(outbuffer, len);
    }
}