diff options
Diffstat (limited to 'jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java')
| -rw-r--r-- | jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java | 28 |
1 files changed, 14 insertions, 14 deletions
diff --git a/jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java b/jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java index 0c98d1d037..6e451be07c 100644 --- a/jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java +++ b/jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java @@ -49,7 +49,7 @@ import org.eclipse.jetty.util.thread.Scheduler; /** * <p>An abstract implementation of {@link Connector} that provides a {@link ConnectionFactory} mechanism - * for creating {@link Connection} instances for various protocols (HTTP, SSL, SPDY, etc).</p> + * for creating {@link Connection} instances for various protocols (HTTP, SSL, etc).</p> * * <h2>Connector Services</h2> * The abstract connector manages the dependent services needed by all specific connector instances: @@ -70,7 +70,7 @@ import org.eclipse.jetty.util.thread.Scheduler; * * <h2>Connection Factories</h2> * The connector keeps a collection of {@link ConnectionFactory} instances, each of which are known by their - * protocol name. The protocol name may be a real protocol (eg http/1.1 or spdy/3) or it may be a private name + * protocol name. The protocol name may be a real protocol (e.g. "http/1.1" or "h2") or it may be a private name * that represents a special connection factory. For example, the name "SSL-http/1.1" is used for * an {@link SslConnectionFactory} that has been instantiated with the {@link HttpConnectionFactory} as it's * next protocol. @@ -87,7 +87,7 @@ import org.eclipse.jetty.util.thread.Scheduler; * <p> * Each Connection factory type is responsible for the configuration of the protocols that it accepts. Thus to * configure the HTTP protocol, you pass a {@link HttpConfiguration} instance to the {@link HttpConnectionFactory} - * (or the SPDY factories that can also provide HTTP Semantics). Similarly the {@link SslConnectionFactory} is + * (or other factories that can also provide HTTP Semantics). Similarly the {@link SslConnectionFactory} is * configured by passing it a {@link SslContextFactory} and a next protocol name. * * <h4>Connection Factory Operation</h4> @@ -104,16 +104,16 @@ import org.eclipse.jetty.util.thread.Scheduler; * to run over the SSL connection. * <p> * {@link ConnectionFactory}s may also create temporary {@link Connection} instances that will exchange bytes - * over the connection to determine what is the next protocol to use. For example the NPN protocol is an extension - * of SSL to allow a protocol to be specified during the SSL handshake. NPN is used by the SPDY protocol to - * negotiate the version of SPDY or HTTP that the client and server will speak. Thus to accept a SPDY connection, the - * connector will be configured with {@link ConnectionFactory}s for "SSL-NPN", "NPN", "spdy/3", "spdy/2", "http/1.1" - * with the default protocol being "SSL-NPN". Thus a newly accepted connection uses "SSL-NPN", which specifies a - * SSLConnectionFactory with "NPN" as the next protocol. Thus an SslConnection instance is created chained to an NPNConnection - * instance. The NPN connection then negotiates with the client to determined the next protocol, which could be - * "spdy/3", "spdy/2" or the default of "http/1.1". Once the next protocol is determined, the NPN connection - * calls {@link #getConnectionFactory(String)} to create a connection instance that will replace the NPN connection as - * the connection chained to the SSLConnection. + * over the connection to determine what is the next protocol to use. For example the ALPN protocol is an extension + * of SSL to allow a protocol to be specified during the SSL handshake. ALPN is used by the HTTP/2 protocol to + * negotiate the protocol that the client and server will speak. Thus to accept a HTTP/2 connection, the + * connector will be configured with {@link ConnectionFactory}s for "SSL-ALPN", "h2", "http/1.1" + * with the default protocol being "SSL-ALPN". Thus a newly accepted connection uses "SSL-ALPN", which specifies a + * SSLConnectionFactory with "ALPN" as the next protocol. Thus an SSL connection instance is created chained to an ALPN + * connection instance. The ALPN connection then negotiates with the client to determined the next protocol, which + * could be "h2" or the default of "http/1.1". Once the next protocol is determined, the ALPN connection + * calls {@link #getConnectionFactory(String)} to create a connection instance that will replace the ALPN connection as + * the connection chained to the SSL connection. * <p> * <h2>Acceptors</h2> * The connector will execute a number of acceptor tasks to the {@link Exception} service passed to the constructor. @@ -128,7 +128,7 @@ import org.eclipse.jetty.util.thread.Scheduler; * </nl> * The default number of acceptor tasks is the minimum of 1 and half the number of available CPUs. Having more acceptors may reduce * the latency for servers that see a high rate of new connections (eg HTTP/1.0 without keep-alive). Typically the default is - * sufficient for modern persistent protocols (HTTP/1.1, SPDY etc.) + * sufficient for modern persistent protocols (HTTP/1.1, HTTP/2 etc.) */ @ManagedObject("Abstract implementation of the Connector Interface") public abstract class AbstractConnector extends ContainerLifeCycle implements Connector, Dumpable |