Java BasicLineParser类代码示例

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
/**
 * Creates an instance of this class.
 *
 * @param buffer the session input buffer.
 * @param parser the line parser.
 * @param params HTTP parameters.
 */
public AbstractMessageParser(
        final SessionInputBuffer buffer,
        final LineParser parser,
        final HttpParams params) {
    super();
    if (buffer == null) {
        throw new IllegalArgumentException("Session input buffer may not be null");
    }
    if (params == null) {
        throw new IllegalArgumentException("HTTP parameters may not be null");
    }
    this.sessionBuffer = buffer;
    this.maxHeaderCount = params.getIntParameter(
            CoreConnectionPNames.MAX_HEADER_COUNT, -1);
    this.maxLineLen = params.getIntParameter(
            CoreConnectionPNames.MAX_LINE_LENGTH, -1);
    this.lineParser = (parser != null) ? parser : BasicLineParser.DEFAULT;
    this.headerLines = new ArrayList<CharArrayBuffer>();
    this.state = HEAD_LINE;
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
private void acceptClient(@NotNull Socket client) throws IOException {
  final SessionInputBuffer inputBuffer = wrapInputStream(client.getInputStream());
  final HttpMessageParser<HttpRequest> parser = new DefaultHttpRequestParser(inputBuffer,
      new BasicLineParser(),
      new DefaultHttpRequestFactory(),
      MessageConstraints.DEFAULT
  );
  final SessionOutputBuffer outputBuffer = wrapOutputStream(client.getOutputStream());
  final HttpMessageWriter<HttpResponse> writer = new DefaultHttpResponseWriter(outputBuffer);
  while (!socket.isClosed()) {
    try {
      service(inputBuffer, outputBuffer, parser, writer);
    } catch (ConnectionClosedException ignored) {
      break;
    } catch (HttpException e) {
      log.error(e.getMessage(), e);
      break;
    }
  }
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
public DefaultHttpResponseParserFactory(
        final LineParser lineParser,
        final HttpResponseFactory responseFactory) {
    super();
    this.lineParser = lineParser != null ? lineParser : BasicLineParser.INSTANCE;
    this.responseFactory = responseFactory != null ? responseFactory
            : DefaultHttpResponseFactory.INSTANCE;
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
public static HttpRequest parseRecordedRequest(String reqstring, MessageMetadata messdata) throws IOException, HttpException{
	MessageStringInputBuffer buf = new MessageStringInputBuffer(reqstring);
	DefaultHttpRequestParser parser = new DefaultHttpRequestParser(buf, 
			new BasicLineParser(), 
			new RecordedHttpRequestFactory(messdata), 
			new BasicHttpParams());
	HttpRequest request = parser.parse();
	if(request instanceof HttpEntityEnclosingRequest){
		parseEntity((HttpEntityEnclosingRequest)request, buf);
	}
	return request;
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
public static HttpResponse parseRecordedResponse(String respstring, MessageMetadata messdata) throws IOException, HttpException {
	MessageStringInputBuffer buf = new MessageStringInputBuffer(respstring);
	DefaultHttpResponseParser parser = new DefaultHttpResponseParser(buf, 
			new BasicLineParser(), 
			new RecordedHttpResponseFactory(messdata), 
			new BasicHttpParams());
	HttpResponse response = parser.parse();
	parseEntity(response, buf);
	return response;
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
private StatusLine parseStatusLine(String line) {
  if (TextUtils.isEmpty(line)) {
    return null;
  }
  return BasicLineParser.parseStatusLine(line, new BasicLineParser());
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
private Header parseHeader(String line) {
  return BasicLineParser.parseHeader(line, new BasicLineParser());
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
private StatusLine parseStatusLine(String line) {
    if (TextUtils.isEmpty(line)) {
        return null;
    }
    return BasicLineParser.parseStatusLine(line, new BasicLineParser());
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
private Header parseHeader(String line) {
    return BasicLineParser.parseHeader(line, new BasicLineParser());
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
/**
 * <p>Returns an HTTP response object parsed from the ARC record payload.<p>
 * <p>Note: The payload is parsed on-demand, but is only parsed once.  The
 * parsed data is saved for subsequent calls.</p>
 *
 * @return The ARC record payload as an HTTP response object.  See the Apache
 * HttpComponents project.
 */
public HttpResponse getHttpResponse()
    throws IOException, HttpException {

  if (this._httpResponse != null) {
      return this._httpResponse;
  }

  if (this._payload == null) {
    LOG.error("Unable to parse HTTP response: Payload has not been set"); return null;
  }

  if (this._url != null && !this._url.startsWith("http://") && !this._url.startsWith("https://")) {
    LOG.error("Unable to parse HTTP response: URL protocol is not HTTP"); return null;
  }

  this._httpResponse = null;

  // Find where the HTTP headers stop
  int end = this._searchForCRLFCRLF(this._payload);

  if (end == -1) {
    LOG.error("Unable to parse HTTP response: End of HTTP headers not found"); return null;
  }

  // Parse the HTTP status line and headers
  DefaultHttpResponseParser parser =
    new DefaultHttpResponseParser(
      new ByteArraySessionInputBuffer(this._payload, 0, end),
      new BasicLineParser(),
      new DefaultHttpResponseFactory(),
      new BasicHttpParams()
    );

  this._httpResponse = parser.parse();

  if (this._httpResponse == null) {
    LOG.error("Unable to parse HTTP response"); return null;
  }

  // Set the reset of the payload as the HTTP entity.  Use an InputStreamEntity
  // to avoid a memory copy.
  //trim trailing '\n' if it exists
  int entityLength = _payload.length-end;
  if (_payload.length > 0 && _payload[_payload.length-1]=='\n') {
    entityLength--;
  }
  InputStreamEntity entity = new InputStreamEntity(new ByteArrayInputStream(this._payload, end, entityLength), entityLength);
  entity.setContentType(this._httpResponse.getFirstHeader("Content-Type"));
  entity.setContentEncoding(this._httpResponse.getFirstHeader("Content-Encoding"));
  this._httpResponse.setEntity(entity);

  return this._httpResponse;
}
 

import org.apache.http.message.BasicLineParser; //导入依赖的package包/类
/**
 * Parses HTTP headers from the data receiver stream according to the generic
 * format as given in Section 3.1 of RFC 822, RFC-2616 Section 4 and 19.3.
 *
 * @param inbuffer Session input buffer
 * @param maxHeaderCount maximum number of headers allowed. If the number
 *  of headers received from the data stream exceeds maxCount value, an
 *  IOException will be thrown. Setting this parameter to a negative value
 *  or zero will disable the check.
 * @param maxLineLen maximum number of characters for a header line,
 *  including the continuation lines. Setting this parameter to a negative
 *  value or zero will disable the check.
 * @return array of HTTP headers
 * @param parser line parser to use. Can be <code>null</code>, in which case
 *  the default implementation of this interface will be used.
 *
 * @throws IOException in case of an I/O error
 * @throws HttpException in case of HTTP protocol violation
 */
public static Header[] parseHeaders(
        final SessionInputBuffer inbuffer,
        int maxHeaderCount,
        int maxLineLen,
        LineParser parser)
    throws HttpException, IOException {
    if (parser == null) {
        parser = BasicLineParser.DEFAULT;
    }
    List<CharArrayBuffer> headerLines = new ArrayList<CharArrayBuffer>();
    return parseHeaders(inbuffer, maxHeaderCount, maxLineLen, parser, headerLines);
}