HTTPServer (solon.boot.jlhttp 1.6.37-m1 API)

java.lang.Object
- org.noear.solon.boot.jlhttp.HTTPServer

```
public class HTTPServer
extends Object
```
The HTTPServer class implements a light-weight HTTP server.
This server implements all functionality required by RFC 2616 ("Hypertext Transfer Protocol -- HTTP/1.1"), as well as some of the optional functionality (this is termed "conditionally compliant" in the RFC). In fact, a couple of bugs in the RFC itself were discovered (and fixed) during the development of this server.
Feature Overview
- RFC compliant - correctness is not sacrificed for the sake of size
- Virtual hosts - multiple domains and subdomains per server
- File serving - built-in handler to serve files and folders from disk
- Mime type mappings - configurable via API or a standard mime.types file
- Directory index generation - enables browsing folder contents
- Welcome files - configurable default filename (e.g. index.html)
- All HTTP methods supported - GET/HEAD/OPTIONS/TRACE/POST/PUT/DELETE/custom
- Conditional statuses - ETags and If-* header support
- Chunked transfer encoding - for serving dynamically-generated data streams
- Gzip/deflate compression - reduces bandwidth and download time
- HTTPS - secures all server communications
- Partial content - download continuation (a.k.a. byte range serving)
- File upload - multipart/form-data handling as stream or iterator
- Multiple context handlers - a different handler method per URL path
- @Context annotations - auto-detection of context handler methods
- Parameter parsing - from query string or x-www-form-urlencoded body
- A single source file - super-easy to integrate into any application
- Standalone - no dependencies other than the Java runtime
- Small footprint - standard jar is ~50K, stripped jar is ~35K
- Extensible design - easy to override, add or remove functionality
- Reusable utility methods to simplify your custom code
- Extensive documentation of API and implementation (>40% of source lines)
Use Cases
Being a lightweight, standalone, easily embeddable and tiny-footprint server, it is well-suited for
- Resource-constrained environments such as embedded devices. For really extreme constraints, you can easily remove unneeded functionality to make it even smaller (and use the -Dstripped maven build option to strip away debug info, license, etc.)
- Unit and integration tests - fast setup/teardown times, small overhead and simple context handler setup make it a great web server for testing client components under various server response conditions.
- Embedding a web console into any headless application for administration, monitoring, or a full portable GUI.
- A full-fledged standalone web server serving static files, dynamically-generated content, REST APIs, pseudo-streaming, etc.
- A good reference for learning how HTTP works under the hood.
Implementation Notes
The design and implementation of this server attempt to balance correctness, compliance, readability, size, features, extensibility and performance, and often prioritize them in this order, but some trade-offs must be made.
This server is multithreaded in its support for multiple concurrent HTTP connections, however most of its constituent classes are not thread-safe and require external synchronization if accessed by multiple threads concurrently.
Source Structure and Documentation
This server is intentionally written as a single source file, in order to make it as easy as possible to integrate into any existing project - by simply adding this single file to the project sources. It does, however, aim to maintain a structured and flexible design. There are no external package dependencies.
This file contains extensive documentation of its classes and methods, as well as implementation details and references to specific RFC sections which clarify the logic behind the code. It is recommended that anyone attempting to modify the protocol-level functionality become acquainted with the RFC, in order to make sure that protocol compliance is not broken.
Getting Started
For an example and a good starting point for learning how to use the API, see the main method at the bottom of the file, and follow the code into the API from there. Alternatively, you can just browse through the classes and utility methods and read their documentation and code.
从以下版本开始:

2008-07-24

作者:

Amichai Rothman

嵌套类概要

嵌套类
限定符和类型	类和说明
`static class`	`HTTPServer.ChunkedInputStream` The `ChunkedInputStream` decodes an InputStream whose data has the "chunked" transfer encoding applied to it, providing the underlying data.
`static class`	`HTTPServer.ChunkedOutputStream` The `ChunkedOutputStream` encodes an OutputStream with the "chunked" transfer encoding.
`static interface`	`HTTPServer.Context` The `Context` annotation decorates methods which are mapped to a context (path) within the server, and provide its contents.
`static interface`	`HTTPServer.ContextHandler` A `ContextHandler` serves the content of resources within a context.
`static class`	`HTTPServer.FileContextHandler` The `FileContextHandler` services a context by mapping it to a file or folder (recursively) on disk.
`static class`	`HTTPServer.Header` The `Header` class encapsulates a single HTTP header.
`static class`	`HTTPServer.Headers` The `Headers` class encapsulates a collection of HTTP headers.
`static class`	`HTTPServer.LimitedInputStream` The `LimitedInputStream` provides access to a limited number of consecutive bytes from the underlying InputStream, starting at its current position.
`static class`	`HTTPServer.MethodContextHandler` The `MethodContextHandler` services a context by invoking a handler method on a specified object.
`static class`	`HTTPServer.MultipartInputStream` The `MultipartInputStream` decodes an InputStream whose data has a "multipart/*" content type (see RFC 2046), providing the underlying data of its various parts.
`static class`	`HTTPServer.MultipartIterator` The `MultipartIterator` iterates over the parts of a multipart/form-data request.
`class`	`HTTPServer.Request` The `Request` class encapsulates a single HTTP request.
`class`	`HTTPServer.Response` The `Response` class encapsulates a single HTTP response.
`static class`	`HTTPServer.ResponseOutputStream` The `ResponseOutputStream` encompasses a single response over a connection, and does not close the underlying stream so that it can be used by subsequent responses.
`protected class`	`HTTPServer.SocketHandlerThread` The `SocketHandlerThread` handles accepted sockets.
`static class`	`HTTPServer.VirtualHost` The `VirtualHost` class represents a virtual host in the server.

字段概要

字段
限定符和类型	字段和说明
`protected static String[]`	`compressibleContentTypes` The MIME types that can be compressed (prefix/suffix wildcards allowed).
`protected static Map<String,String>`	`contentTypes` A mapping of path suffixes (e.g. file extensions) to their corresponding MIME types.
`static byte[]`	`CRLF` A convenience array containing the carriage-return and line feed chars.
`static String[]`	`DATE_PATTERNS` The SimpleDateFormat-compatible formats of dates which must be supported.
`protected static char[]`	`DAYS` Date format strings.
`protected Executor`	`executor`
`protected static TimeZone`	`GMT` A GMT (UTC) timezone instance.
`protected Map<String,HTTPServer.VirtualHost>`	`hosts`
`protected static int`	`MAX_BODY_SIZE`
`protected static int`	`MAX_HEADER_SIZE`
`protected static char[]`	`MONTHS` Date format strings.
`protected int`	`port`
`protected boolean`	`secure`
`protected ServerSocket`	`serv`
`protected ServerSocketFactory`	`serverSocketFactory`
`protected int`	`socketTimeout`
`protected static String[]`	`statuses` The HTTP status description strings.

构造器概要

构造器
构造器和说明
`HTTPServer()` Constructs an HTTPServer which can accept connections on the default HTTP port 80.
`HTTPServer(int port)` Constructs an HTTPServer which can accept connections on the given port.

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`static void`	`addContentType(String contentType, String... suffixes)` Adds a Content-Type mapping for the given path suffixes.
`static void`	`addContentTypes(InputStream in)` Adds Content-Type mappings from a standard mime.types file.
`void`	`addVirtualHost(HTTPServer.VirtualHost host)` Adds the given virtual host to the server.
`static String`	`createIndex(File dir, String path)` Serves the contents of a directory as an HTML file index.
`protected ServerSocket`	`createServerSocket()` Creates the server socket used to accept connections, using the configured `ServerSocketFactory` and `port`.
`static String`	`detectLocalHostName()` Returns the local host's auto-detected name.
`static String`	`escapeHTML(String s)` Returns an HTML-escaped version of the given string for safe display within a web page.
`static String`	`formatDate(long time)` Formats the given time value as a string in RFC 1123 format.
`static byte[]`	`getBytes(String... strings)` Converts strings to bytes by casting the chars to bytes.
`static int`	`getConditionalStatus(HTTPServer.Request req, long lastModified, String etag)` Calculates the appropriate response status for the given request and its resource's last-modified time and ETag, based on the conditional headers present in the request.
`static String`	`getContentType(String path, String def)` Returns the content type for the given path, according to its suffix, or the given default content type if none can be determined.
`static String`	`getParentPath(String path)` Returns the parent of the given path.
`HTTPServer.VirtualHost`	`getVirtualHost(String name)` Returns the virtual host with the given name.
`Set<HTTPServer.VirtualHost>`	`getVirtualHosts()` Returns all virtual hosts.
`protected void`	`handleConnection(InputStream in, OutputStream out, Socket sock)` Handles communications for a single connection over the given streams.
`protected void`	`handleMethod(HTTPServer.Request req, HTTPServer.Response resp)` Handles a transaction according to the request method.
`void`	`handleTrace(HTTPServer.Request req, HTTPServer.Response resp)` Handles a TRACE method request.
`protected void`	`handleTransaction(HTTPServer.Request req, HTTPServer.Response resp)` Handles a single transaction on a connection.
`static boolean`	`isCompressible(String contentType)` Checks whether data of the given content type (MIME type) is compressible.
`static <T> String`	`join(String delim, Iterable<T> items)` Returns a string constructed by joining the string representations of the iterated objects (in order), with the delimiter inserted between them.
`static void`	`main(String[] args)` Starts a stand-alone HTTP server, serving files from disk.
`static boolean`	`match(boolean strong, String[] etags, String etag)` Matches the given ETag value against the given ETags.
`static Date`	`parseDate(String time)` Parses a date string in one of the supported `DATE_PATTERNS`.
`static List<String[]>`	`parseParamsList(String s)` Parses name-value pair parameters from the given "x-www-form-urlencoded" MIME-type string.
`static long[]`	`parseRange(String range, long length)` Returns the absolute (zero-based) content range value specified by the given range string.
`static long`	`parseULong(String s, int radix)` Parses an unsigned long value.
`protected boolean`	`preprocessTransaction(HTTPServer.Request req, HTTPServer.Response resp)` Preprocesses a transaction, performing various validation checks and required special header handling, possibly returning an appropriate response.
`static HTTPServer.Headers`	`readHeaders(InputStream in)` Reads headers from the given stream.
`static String`	`readLine(InputStream in)` Reads the ISO-8859-1 encoded string starting at the current stream position and ending at the first occurrence of the LF character.
`static String`	`readToken(InputStream in, int delim, String enc, int maxLength)` Reads the token starting at the current stream position and ending at the first occurrence of the given delimiter byte, in the given encoding.
`protected void`	`serve(HTTPServer.Request req, HTTPServer.Response resp)` Serves the content for a request by invoking the context handler for the requested context (path) and HTTP method.
`static int`	`serveFile(File base, String context, HTTPServer.Request req, HTTPServer.Response resp)` Serves a context's contents from a file based resource.
`static void`	`serveFileContent(File file, HTTPServer.Request req, HTTPServer.Response resp)` Serves the contents of a file, with its corresponding content type, last modification time, etc. conditional and partial retrievals are handled according to the RFC.
`void`	`setExecutor(Executor executor)` Sets the executor used in servicing HTTP connections.
`void`	`setPort(int port)` Sets the port on which this server will accept connections.
`void`	`setServerSocketFactory(ServerSocketFactory factory)` Sets the factory used to create the server socket.
`void`	`setSocketTimeout(int timeout)` Sets the socket timeout for established connections.
`static String[]`	`split(String str, String delimiters, int limit)` Splits the given string into its constituent non-empty trimmed elements, which are delimited by any of the given delimiter characters.
`static String[]`	`splitElements(String list, boolean lower)` Splits the given element list string (comma-separated header value) into its constituent non-empty trimmed elements.
`void`	`start()` Starts this server.
`void`	`stop()` Stops this server.
`static <K,V> Map<K,V>`	`toMap(Collection<? extends Object[]> pairs)` Converts a collection of pairs of objects (arrays of size two, each representing a key and corresponding value) into a Map.
`static String`	`toSizeApproxString(long size)` Returns a human-friendly string approximating the given data size, e.g. "316", "1.8K", "324M", etc.
`static void`	`transfer(InputStream in, OutputStream out, long len)` Transfers data from an input stream to an output stream.
`static String`	`trimDuplicates(String s, char c)` Trims duplicate consecutive occurrences of the given character within the given string, replacing them with a single instance of the character.
`static String`	`trimLeft(String s, char c)` Returns the given string with all occurrences of the given character removed from its left side.
`static String`	`trimRight(String s, char c)` Returns the given string with all occurrences of the given character removed from its right side.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - MAX_BODY_SIZE
```
protected static int MAX_BODY_SIZE
```
  - MAX_HEADER_SIZE
```
protected static int MAX_HEADER_SIZE
```
  - DATE_PATTERNS
```
public static final String[] DATE_PATTERNS
```
    The SimpleDateFormat-compatible formats of dates which must be supported. Note that all generated date fields must be in the RFC 1123 format only, while the others are supported by recipients for backwards-compatibility.
  - GMT
```
protected static final TimeZone GMT
```
    A GMT (UTC) timezone instance.
  - DAYS
```
protected static final char[] DAYS
```
    Date format strings.
  - MONTHS
```
protected static final char[] MONTHS
```
    Date format strings.
  - CRLF
```
public static final byte[] CRLF
```
    A convenience array containing the carriage-return and line feed chars.
  - statuses
```
protected static final String[] statuses
```
    The HTTP status description strings.
  - contentTypes
```
protected static final Map<String,String> contentTypes
```
    A mapping of path suffixes (e.g. file extensions) to their corresponding MIME types.
  - compressibleContentTypes
```
protected static String[] compressibleContentTypes
```
    The MIME types that can be compressed (prefix/suffix wildcards allowed).
  - port
```
protected volatile int port
```
  - socketTimeout
```
protected volatile int socketTimeout
```
  - serverSocketFactory
```
protected volatile ServerSocketFactory serverSocketFactory
```
  - secure
```
protected volatile boolean secure
```
  - executor
```
protected volatile Executor executor
```
  - serv
```
protected volatile ServerSocket serv
```
  - hosts
```
protected final Map<String,HTTPServer.VirtualHost> hosts
```
- 构造器详细资料
  - HTTPServer
```
public HTTPServer(int port)
```
    Constructs an HTTPServer which can accept connections on the given port. Note: the start() method must be called to start accepting connections.
    
    参数:
    
    port - the port on which this server will accept connections
  - HTTPServer
```
public HTTPServer()
```
    Constructs an HTTPServer which can accept connections on the default HTTP port 80. Note: the start() method must be called to start accepting connections.
- 方法详细资料
  - setPort
```
public void setPort(int port)
```
    Sets the port on which this server will accept connections.
    
    参数:
    
    port - the port on which this server will accept connections
  - setServerSocketFactory
```
public void setServerSocketFactory(ServerSocketFactory factory)
```
    Sets the factory used to create the server socket. If null or not set, the default ServerSocketFactory.getDefault() is used. For secure sockets (HTTPS), use an SSLServerSocketFactory instance. The port should usually also be changed for HTTPS, e.g. port 443 instead of 80.
    If using the default SSLServerSocketFactory returned by SSLServerSocketFactory.getDefault(), the appropriate system properties must be set to configure the default JSSE provider, such as javax.net.ssl.keyStore and javax.net.ssl.keyStorePassword.
    
    参数:
    
    factory - the server socket factory to use
  - setSocketTimeout
```
public void setSocketTimeout(int timeout)
```
    Sets the socket timeout for established connections.
    
    参数:
    
    timeout - the socket timeout in milliseconds
  - setExecutor
```
public void setExecutor(Executor executor)
```
    Sets the executor used in servicing HTTP connections. If null, a default executor is used. The caller is responsible for shutting down the provided executor when necessary.
    
    参数:
    
    executor - the executor to use
  - getVirtualHost
```
public HTTPServer.VirtualHost getVirtualHost(String name)
```
    Returns the virtual host with the given name.
    
    参数:
    
    name - the name of the virtual host to return, or null for the default virtual host
    
    返回:
    
    the virtual host with the given name, or null if it doesn't exist
  - getVirtualHosts
```
public Set<HTTPServer.VirtualHost> getVirtualHosts()
```
    Returns all virtual hosts.
    
    返回:
    
    all virtual hosts (as an unmodifiable set)
  - addVirtualHost
```
public void addVirtualHost(HTTPServer.VirtualHost host)
```
    Adds the given virtual host to the server. If the host's name or aliases already exist, they are overwritten.
    
    参数:
    
    host - the virtual host to add
  - createServerSocket
```
protected ServerSocket createServerSocket()
                                   throws IOException
```
    Creates the server socket used to accept connections, using the configured ServerSocketFactory and port.
    Cryptic errors seen here often mean the factory configuration details are wrong.
    
    返回:
    
    the created server socket
    
    抛出:
    
    IOException - if the socket cannot be created
  - start
```
public void start()
           throws IOException
```
    Starts this server. If it is already started, does nothing. Note: Once the server is started, configuration-altering methods of the server and its virtual hosts must not be used. To modify the configuration, the server must first be stopped.
    
    抛出:
    
    IOException - if the server cannot begin accepting connections
  - stop
```
public void stop()
```
    Stops this server. If it is already stopped, does nothing. Note that if an Executor was set, it must be closed separately.
  - handleConnection
```
protected void handleConnection(InputStream in,
                                OutputStream out,
                                Socket sock)
                         throws IOException
```
    Handles communications for a single connection over the given streams. Multiple subsequent transactions are handled on the connection, until the streams are closed, an error occurs, or the request contains a "Connection: close" header which explicitly requests the connection be closed after the transaction ends.
    
    参数:
    
    in - the stream from which the incoming requests are read
    
    out - the stream into which the outgoing responses are written
    
    sock - the connected socket
    
    抛出:
    
    IOException - if an error occurs
  - handleTransaction
```
protected void handleTransaction(HTTPServer.Request req,
                                 HTTPServer.Response resp)
                          throws IOException
```
    Handles a single transaction on a connection.
    Subclasses can override this method to perform filtering on the request or response, apply wrappers to them, or further customize the transaction processing in some other way.
    
    参数:
    
    req - the transaction request
    
    resp - the transaction response (into which the response is written)
    
    抛出:
    
    IOException - if and error occurs
  - preprocessTransaction
```
protected boolean preprocessTransaction(HTTPServer.Request req,
                                        HTTPServer.Response resp)
                                 throws IOException
```
    Preprocesses a transaction, performing various validation checks and required special header handling, possibly returning an appropriate response.
    
    参数:
    
    req - the request
    
    resp - the response
    
    返回:
    
    whether further processing should be performed on the transaction
    
    抛出:
    
    IOException - if an error occurs
  - handleMethod
```
protected void handleMethod(HTTPServer.Request req,
                            HTTPServer.Response resp)
                     throws IOException
```
    Handles a transaction according to the request method.
    
    参数:
    
    req - the transaction request
    
    resp - the transaction response (into which the response is written)
    
    抛出:
    
    IOException - if and error occurs
  - handleTrace
```
public void handleTrace(HTTPServer.Request req,
                        HTTPServer.Response resp)
                 throws IOException
```
    Handles a TRACE method request.
    
    参数:
    
    req - the request
    
    resp - the response into which the content is written
    
    抛出:
    
    IOException - if an error occurs
  - serve
```
protected void serve(HTTPServer.Request req,
                     HTTPServer.Response resp)
              throws IOException
```
    Serves the content for a request by invoking the context handler for the requested context (path) and HTTP method.
    
    参数:
    
    req - the request
    
    resp - the response into which the content is written
    
    抛出:
    
    IOException - if an error occurs
  - addContentType
```
public static void addContentType(String contentType,
                                  String... suffixes)
```
    Adds a Content-Type mapping for the given path suffixes. If any of the path suffixes had a previous Content-Type associated with it, it is replaced with the given one. Path suffixes are considered case-insensitive, and contentType is converted to lowercase.
    
    参数:
    
    contentType - the content type (MIME type) to be associated with the given path suffixes
    
    suffixes - the path suffixes which will be associated with the contentType, e.g. the file extensions of served files (excluding the '.' character)
  - addContentTypes
```
public static void addContentTypes(InputStream in)
                            throws IOException
```
    Adds Content-Type mappings from a standard mime.types file.
    
    参数:
    
    in - a stream containing a mime.types file
    
    抛出:
    
    IOException - if an error occurs
    
    FileNotFoundException - if the file is not found or cannot be read
  - getContentType
```
public static String getContentType(String path,
                                    String def)
```
    Returns the content type for the given path, according to its suffix, or the given default content type if none can be determined.
    
    参数:
    
    path - the path whose content type is requested
    
    def - a default content type which is returned if none can be determined
    
    返回:
    
    the content type for the given path, or the given default
  - isCompressible
```
public static boolean isCompressible(String contentType)
```
    Checks whether data of the given content type (MIME type) is compressible.
    
    参数:
    
    contentType - the content type
    
    返回:
    
    true if the data is compressible, false if not
  - detectLocalHostName
```
public static String detectLocalHostName()
```
    Returns the local host's auto-detected name.
    
    返回:
    
    the local host name
  - parseParamsList
```
public static List<String[]> parseParamsList(String s)
```
    Parses name-value pair parameters from the given "x-www-form-urlencoded" MIME-type string. This is the encoding used both for parameters passed as the query of an HTTP GET method, and as the content of HTML forms submitted using the HTTP POST method (as long as they use the default "application/x-www-form-urlencoded" encoding in their ENCTYPE attribute). UTF-8 encoding is assumed.
    The parameters are returned as a list of string arrays, each containing the parameter name as the first element and its corresponding value as the second element (or an empty string if there is no value).
    The list retains the original order of the parameters.
    
    参数:
    
    s - an "application/x-www-form-urlencoded" string
    
    返回:
    
    the parameter name-value pairs parsed from the given string, or an empty list if there are none
  - toMap
```
public static <K,V> Map<K,V> toMap(Collection<? extends Object[]> pairs)
```
    Converts a collection of pairs of objects (arrays of size two, each representing a key and corresponding value) into a Map. Duplicate keys are ignored (only the first occurrence of each key is considered). The map retains the original collection's iteration order.
    
    类型参数:
    
    K - the key type
    
    V - the value type
    
    参数:
    
    pairs - a collection of arrays, each containing a key and corresponding value
    
    返回:
    
    a map containing the paired keys and values, or an empty map
  - parseRange
```
public static long[] parseRange(String range,
                                long length)
```
    Returns the absolute (zero-based) content range value specified by the given range string. If multiple ranges are requested, a single range containing all of them is returned.
    
    参数:
    
    range - the string containing the range description
    
    length - the full length of the requested resource
    
    返回:
    
    the requested range, or null if the range value is invalid
  - parseULong
```
public static long parseULong(String s,
                              int radix)
                       throws NumberFormatException
```
    Parses an unsigned long value. This method behaves the same as calling Long.parseLong(String, int), but considers the string invalid if it starts with an ASCII minus sign ('-') or plus sign ('+').
    
    参数:
    
    s - the String containing the long representation to be parsed
    
    radix - the radix to be used while parsing s
    
    返回:
    
    the long represented by s in the specified radix
    
    抛出:
    
    NumberFormatException - if the string does not contain a parsable long, or if it starts with an ASCII minus sign or plus sign
  - parseDate
```
public static Date parseDate(String time)
```
    Parses a date string in one of the supported DATE_PATTERNS.
    Received date header values must be in one of the following formats: Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036 Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
    
    参数:
    
    time - a string representation of a time value
    
    返回:
    
    the parsed date value
    
    抛出:
    
    IllegalArgumentException - if the given string does not contain a valid date format in any of the supported formats
  - formatDate
```
public static String formatDate(long time)
```
    Formats the given time value as a string in RFC 1123 format.
    
    参数:
    
    time - the time in milliseconds since January 1, 1970, 00:00:00 GMT
    
    返回:
    
    the given time value as a string in RFC 1123 format
  - splitElements
```
public static String[] splitElements(String list,
                                     boolean lower)
```
    Splits the given element list string (comma-separated header value) into its constituent non-empty trimmed elements. (RFC2616#2.1: element lists are delimited by a comma and optional LWS, and empty elements are ignored).
    
    参数:
    
    list - the element list string
    
    lower - specifies whether the list elements should be lower-cased
    
    返回:
    
    the non-empty elements in the list, or an empty array
  - split
```
public static String[] split(String str,
                             String delimiters,
                             int limit)
```
    Splits the given string into its constituent non-empty trimmed elements, which are delimited by any of the given delimiter characters. This is a more direct and efficient implementation than using a regex (e.g. String.split()), trimming the elements and removing empty ones.
    
    参数:
    
    str - the string to split
    
    delimiters - the characters used as the delimiters between elements
    
    limit - if positive, limits the returned array size (remaining of str in last element)
    
    返回:
    
    the non-empty elements in the string, or an empty array
  - join
```
public static <T> String join(String delim,
                              Iterable<T> items)
```
    Returns a string constructed by joining the string representations of the iterated objects (in order), with the delimiter inserted between them.
    
    类型参数:
    
    T - the item type
    
    参数:
    
    delim - the delimiter that is inserted between the joined strings
    
    items - the items whose string representations are joined
    
    返回:
    
    the joined string
  - getParentPath
```
public static String getParentPath(String path)
```
    Returns the parent of the given path.
    
    参数:
    
    path - the path whose parent is returned (must start with '/')
    
    返回:
    
    the parent of the given path (excluding trailing slash), or null if given path is the root path
  - trimRight
```
public static String trimRight(String s,
                               char c)
```
    Returns the given string with all occurrences of the given character removed from its right side.
    
    参数:
    
    s - the string to trim
    
    c - the character to remove
    
    返回:
    
    the trimmed string
  - trimLeft
```
public static String trimLeft(String s,
                              char c)
```
    Returns the given string with all occurrences of the given character removed from its left side.
    
    参数:
    
    s - the string to trim
    
    c - the character to remove
    
    返回:
    
    the trimmed string
  - trimDuplicates
```
public static String trimDuplicates(String s,
                                    char c)
```
    Trims duplicate consecutive occurrences of the given character within the given string, replacing them with a single instance of the character.
    
    参数:
    
    s - the string to trim
    
    c - the character to trim
    
    返回:
    
    the given string with duplicate consecutive occurrences of c replaced by a single instance of c
  - toSizeApproxString
```
public static String toSizeApproxString(long size)
```
    Returns a human-friendly string approximating the given data size, e.g. "316", "1.8K", "324M", etc.
    
    参数:
    
    size - the size to display
    
    返回:
    
    a human-friendly string approximating the given data size
  - escapeHTML
```
public static String escapeHTML(String s)
```
    Returns an HTML-escaped version of the given string for safe display within a web page. The characters '&', '>' and '<' must always be escaped, and single and double quotes must be escaped within attribute values; this method escapes them always. This method can be used for generating both HTML and XHTML valid content.
    
    参数:
    
    s - the string to escape
    
    返回:
    
    the escaped string
    
    另请参阅:
    
    The W3C FAQ
  - getBytes
```
public static byte[] getBytes(String... strings)
```
    Converts strings to bytes by casting the chars to bytes. This is a fast way to encode a string as ISO-8859-1/US-ASCII bytes. If multiple strings are provided, their bytes are concatenated.
    
    参数:
    
    strings - the strings to convert (containing only ISO-8859-1 chars)
    
    返回:
    
    the byte array
  - transfer
```
public static void transfer(InputStream in,
                            OutputStream out,
                            long len)
                     throws IOException
```
    Transfers data from an input stream to an output stream.
    
    参数:
    
    in - the input stream to transfer from
    
    out - the output stream to transfer to (or null to discard output)
    
    len - the number of bytes to transfer. If negative, the entire contents of the input stream are transferred.
    
    抛出:
    
    IOException - if an IO error occurs or the input stream ends before the requested number of bytes have been read
  - readToken
```
public static String readToken(InputStream in,
                               int delim,
                               String enc,
                               int maxLength)
                        throws IOException
```
    Reads the token starting at the current stream position and ending at the first occurrence of the given delimiter byte, in the given encoding. If LF is specified as the delimiter, a CRLF pair is also treated as one.
    
    参数:
    
    in - the stream from which the token is read
    
    delim - the byte value which marks the end of the token, or -1 if the token ends at the end of the stream
    
    enc - a character-encoding name
    
    maxLength - the maximum length (in bytes) to read
    
    返回:
    
    the read token, excluding the delimiter
    
    抛出:
    
    UnsupportedEncodingException - if the encoding is not supported
    
    EOFException - if the stream end is reached before a delimiter is found
    
    IOException - if an IO error occurs, or the maximum length is reached before the token end is reached
  - readLine
```
public static String readLine(InputStream in)
                       throws IOException
```
    Reads the ISO-8859-1 encoded string starting at the current stream position and ending at the first occurrence of the LF character.
    
    参数:
    
    in - the stream from which the line is read
    
    返回:
    
    the read string, excluding the terminating LF character and (if exists) the CR character immediately preceding it
    
    抛出:
    
    EOFException - if the stream end is reached before an LF character is found
    
    IOException - if an IO error occurs, or the line is longer than 8192 bytes
    
    另请参阅:
    
    readToken(InputStream, int, String, int)
  - readHeaders
```
public static HTTPServer.Headers readHeaders(InputStream in)
                                      throws IOException
```
    Reads headers from the given stream. Headers are read according to the RFC, including folded headers, element lists, and multiple headers (which are concatenated into a single element list header). Leading and trailing whitespace is removed.
    
    参数:
    
    in - the stream from which the headers are read
    
    返回:
    
    the read headers (possibly empty, if none exist)
    
    抛出:
    
    IOException - if an IO error occurs or the headers are malformed or there are more than 100 header lines
  - match
```
public static boolean match(boolean strong,
                            String[] etags,
                            String etag)
```
    Matches the given ETag value against the given ETags. A match is found if the given ETag is not null, and either the ETags contain a "*" value, or one of them is identical to the given ETag. If strong comparison is used, tags beginning with the weak ETag prefix "W/" never match. See RFC2616#3.11, RFC2616#13.3.3.
    
    参数:
    
    strong - if true, strong comparison is used, otherwise weak comparison is used
    
    etags - the ETags to match against
    
    etag - the ETag to match
    
    返回:
    
    true if the ETag is matched, false otherwise
  - getConditionalStatus
```
public static int getConditionalStatus(HTTPServer.Request req,
                                       long lastModified,
                                       String etag)
```
    Calculates the appropriate response status for the given request and its resource's last-modified time and ETag, based on the conditional headers present in the request.
    
    参数:
    
    req - the request
    
    lastModified - the resource's last modified time
    
    etag - the resource's ETag
    
    返回:
    
    the appropriate response status for the request
  - serveFile
```
public static int serveFile(File base,
                            String context,
                            HTTPServer.Request req,
                            HTTPServer.Response resp)
                     throws IOException
```
    Serves a context's contents from a file based resource.
    The file is located by stripping the given context prefix from the request's path, and appending the result to the given base directory.
    Missing, forbidden and otherwise invalid files return the appropriate error response. Directories are served as an HTML index page if the virtual host allows one, or a forbidden error otherwise. Files are sent with their corresponding content types, and handle conditional and partial retrievals according to the RFC.
    
    参数:
    
    base - the base directory to which the context is mapped
    
    context - the context which is mapped to the base directory
    
    req - the request
    
    resp - the response into which the content is written
    
    返回:
    
    the HTTP status code to return, or 0 if a response was sent
    
    抛出:
    
    IOException - if an error occurs
  - serveFileContent
```
public static void serveFileContent(File file,
                                    HTTPServer.Request req,
                                    HTTPServer.Response resp)
                             throws IOException
```
    Serves the contents of a file, with its corresponding content type, last modification time, etc. conditional and partial retrievals are handled according to the RFC.
    
    参数:
    
    file - the existing and readable file whose contents are served
    
    req - the request
    
    resp - the response into which the content is written
    
    抛出:
    
    IOException - if an error occurs
  - createIndex
```
public static String createIndex(File dir,
                                 String path)
```
    Serves the contents of a directory as an HTML file index.
    
    参数:
    
    dir - the existing and readable directory whose contents are served
    
    path - the displayed base path corresponding to dir
    
    返回:
    
    an HTML string containing the file index for the directory
  - main
```
public static void main(String[] args)
```
    Starts a stand-alone HTTP server, serving files from disk.
    
    参数:
    
    args - the command line arguments

类 HTTPServer

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

MAX_BODY_SIZE

MAX_HEADER_SIZE

DATE_PATTERNS

GMT

DAYS

MONTHS

CRLF

statuses

contentTypes

compressibleContentTypes

port

socketTimeout

serverSocketFactory

secure

executor

serv

hosts

构造器详细资料

HTTPServer

HTTPServer

方法详细资料

setPort

setServerSocketFactory

setSocketTimeout

setExecutor

getVirtualHost

getVirtualHosts

addVirtualHost

createServerSocket

start

stop

handleConnection

handleTransaction

preprocessTransaction

handleMethod

handleTrace

serve

addContentType

addContentTypes

getContentType

isCompressible

detectLocalHostName

parseParamsList

toMap

parseRange

parseULong

parseDate

formatDate

splitElements

split

join

getParentPath

trimRight

trimLeft

trimDuplicates

toSizeApproxString

escapeHTML

getBytes

transfer

readToken

readLine

readHeaders

match

getConditionalStatus

serveFile

serveFileContent

createIndex

main