1. Overview
In this article, we’ll talk about creating and configuring a Jetty instance programmatically.
Jetty is an HTTP server and servlet container designed to be lightweight and easily embeddable. We’ll take a look at how to setup and configure one or more instances of the server.
2. Maven Dependencies
To start off, we want to add Jetty 9 with the following Maven dependencies into our pom.xml:
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-server</artifactId>
<version>9.4.8.v20171121</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-webapp</artifactId>
<version>9.4.8.v20171121</version>
</dependency>
3. Creating a Basic Server
Spinning up an embedded server with Jetty is as easy as writing:
Server server = new Server();
server.start();
Shutting it down is equally simple:
server.stop();
4. Handlers
Now that our server is up and running, we need to instruct it on what to do with the incoming requests. This can be performed using the Handler interface.
We could create one ourselves but Jetty already provides a set of implementations for the most common use cases. Let’s take a look at two of them.
4.1. WebAppContext
The WebAppContext class allows you to delegate the request handling to an existing web application. The application can be provided either as a WAR file path or as a webapp folder path.
If we want to expose an application under the “myApp” context we would write:
Handler webAppHandler = new WebAppContext(webAppPath, "/myApp");
server.setHandler(webAppHandler);
4.2. HandlerCollection
For complex applications, we can even specify more than one handler using the HandlerCollection class.
Suppose we have implemented two custom handlers. The first one performs only logging operations meanwhile the second one creates and sends back an actual response to the user. We want to process each incoming request with both of them in this order.
Here’s how to do it:
Handler handlers = new HandlerCollection();
handlers.addHandler(loggingRequestHandler);
handlers.addHandler(customRequestHandler);
server.setHandler(handlers);
5. Connectors
The next thing we want to do is configuring on which addresses and ports the server will be listening and adding an idle timeout.
The Server class declares two convenience constructors that may be used to bind to a specific port or address.
Although this may be ok when dealing with small applications, it won’t be enough if we want to open multiple connections on different sockets.
In this situation, Jetty provides the Connector interface and more specifically the ServerConnector class which allows defining various connection configuration parameters:
ServerConnector connector = new ServerConnector(server);
connector.setPort(80);
connector.setHost("169.20.45.12");
connector.setIdleTimeout(30000);
server.addConnector(connector);
With this configuration, the server will be listening on 169.20.45.12:80. Each connection established on this address will have a timeout of 30 seconds.
If we need to configure other sockets we can add other connectors.
6. Conclusion
In this quick tutorial, we focused on how to set up an embedded server with Jetty. We also saw how to perform further configurations using Handlers and Connectors.
As always, all the code used here can be found over on GitHub.
