转载地址:http://wiki.eclipse.org/Jetty/Feature/SPDY
Introduction
Jetty supports both a client and a server implementation for the SPDY protocol, beginning with versions 7.6.2 and 8.1.2. To provide the best support possible for SPDY, the Jetty project also provides an implementation for NPN. Both the SPDY and the NPN implementation require OpenJDK 1.7 or greater.
A server deployed over TLS normally advertises the SPDY protocol, via the Next Protocol Negotiation TLS Extension (NPN).
Feature
Introducing SPDY Modules
Jetty's SPDY implementation consists of four modules:
-
spdy-core
– contains the SPDY API and a partial implementation. This module is independent of Jetty (the servlet container), and you can reuse it with other Java SPDY implementations. One of the goals of this module is to standardize the SPDY Java API. -
spdy-jetty
module – binds thespdy-core
module to Jetty's NIO framework to provide asynchronous socket I/O. This module uses Jetty internals, but Java SPDY client applications can also use it to communicate with a SPDY server. -
spdy-jetty-http
module – provides a server-side layering of HTTP over SPDY. This module allows any SPDY compliant browser, such as Chromium/Chrome, to talk SPDY to a Jetty server that deploys a standard web application made of servlets, filters and JSPs. This module performs the conversion SPDY to HTTP and vice versa so that for the web application it is as if a normal HTTP request has arrived, and a normal HTTP response is returned. -
spdy-jetty-http-webapp
module – provides a demo application for the aspdy-jetty-http
module.
Transparently Enabling HTTP over SPDY in Jetty
The spdy-jetty-http
module provides an out-of-the-box server connector that performs the SPDY to HTTP conversion and vice versa (HTTP over SPDY).You can use this connector instead of Jetty's SslSelectChannelConnector
(that only speaks HTTP), and it falls back to HTTPS if SPDY is not negotiated.
An example jetty-spdy.xml
file that you can use instead of jetty-ssl.xml
follows:
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure.dtd"> <br>
<Configure id=" Server" class=" org.eclipse.jetty.server.Server"><br>
<New id=" sslContextFactory" class=" org.eclipse.jetty.util.ssl.SslContextFactory"><br>
<Set name=" keyStorePath">your_keystore.jks</Set><br>
<Set name=" keyStorePassword">storepwd</Set><br>
<Set name=" protocol">TLSv1</Set><br>
</New><br>
<br>
<Call name=" addConnector"><br>
<Arg><br>
<New class="o rg.eclipse.jetty.spdy.http.HTTPSPDYServerConnector"><br>
<Arg><br>
<Ref id=" sslContextFactory" /><br>
</Arg><br>
<Set name=" Port">8443</Set><br>
</New><br>
</Arg><br>
</Call><br>
</Configure>
This is sufficient to enable your Jetty server to speak SPDY to browsers that support it.
Remember, however, that SPDY over SSL (as set up like the configuration above) requires that you set up NPN correctly; in particular, you need to start the JVM with the NPN boot jar in the boot classpath.
Follow the instructions at the NPN documentation page.
Using SPDY Client Applications
The spdy-jetty
module provides a SPDY client (that speaks pure SPDY, and not HTTP over SPDY), which you can use in this way:
SPDYClient.Factory clientFactory = new SPDYClient.Factory();
clientFactory.start();
// Create one SPDYClient instance
SPDYClient client = clientFactory.newSPDYClient(SPDY.V2);
// Obtain a Session instance to send data to the server that listens on port 8181
Session session = client.connect( new InetSocketAddress(" localhost", 8181), null).get(5, TimeUnit.SECONDS);
// Sends SYN_STREAM and DATA to the server
Stream stream = session.syn( new SynInfo(false), null).get(5, TimeUnit.SECONDS);
stream.data( new StringDataInfo(" Hello, World", true));
To listen to SPDY frames the server sends, you need to pass a StreamFrameListener
upon stream creation:
{
public void onReply(Stream stream, ReplyInfo replyInfo)
{
// Reply received from server, send DATA to the server
stream.data(new StringDataInfo("Hello, World", true));
}
public void onData(Stream stream, DataInfo dataInfo)
{
// Data received from server
String content = dataInfo.asString("UTF-8", true);
System.err.printf("SPDY content: %s%n", content);
}
};
// Sends SYN_STREAM to the server, adding headers
Headers headers = new Headers();
headers.put("url", "/echo");
Stream stream = session.syn(new SynInfo(headers, false), null).get(5, TimeUnit.SECONDS);
Using SPDY Server Applications
The spdy-jetty
module provides a server connector that speaks pure SPDY, and that you can use in conjunction with the SPDY client (see above).
You can start the SPDYServerConnector
in this way:
ServerSessionFrameListener application = new ServerSessionFrameListener.Adapter()
{
public StreamFrameListener onSyn(Stream stream, SynInfo synInfo)
{
// Reply upon receiving a SYN_STREAM
stream.reply(new ReplyInfo(false));
// Inspect the headers
Headers headers = synInfo.getHeaders();
if ("/echo".equals(headers.get("url").value()))
{
return new StreamFrameListener.Adapter()
{
public void onData(Stream stream, DataInfo dataInfo)
{
// Upon receiving hello data from the client, echo it back
String clientData = dataInfo.asString("UTF-8", true);
stream.data(new StringDataInfo("Echo for " + clientData, true));
}
};
}
return null;
}
};
// Wire up and start the connector
org.eclipse.jetty.server.Server server = new Server();
server.addConnector(new SPDYServerConnector(application));
server.start();
The ServerSessionFrameListener
can inspect the incoming SynInfo
and provide different execution paths depending on headers and/or data content.
Become familiar with the SPDY API to understand how to use it.