The Top 25 Jetty Interview Questions To Prepare For

Jetty is a popular open source HTTP server and Java Servlet container used in many web applications and services today. As a lightweight, scalable, and embeddable platform, Jetty is an excellent choice for building modern cloud-native and microservices-based systems.

With the rise of Jetty, interview questions about it have become increasingly common during Java web developer job interviews. To help you ace your next Jetty interview and land your dream job, I’ve put together this list of the top 25 Jetty interview questions and sample answers.

Whether you’re an aspiring Java developer looking to break into the field or an experienced pro brushing up on your Jetty skills, reviewing these questions can significantly boost your confidence and performance during the interview process. Let’s get started!

1. What is Jetty and what are its key features?

Jetty is an open source project that provides an HTTP server HTTP client and javax.servlet container developed as part of the Eclipse Foundation. Some of its key features include

• Lightweight and embeddable – Jetty has a small memory footprint and can be easily embedded into Java applications. This makes it ideal for cloud and microservices architectures.

• High performance – Jetty utilizes non-blocking I/O and asynchronous programming models to handle thousands of concurrent connections with minimal resource usage

• WebSockets and HTTP/2 support – Jetty implements the latest web technologies including WebSockets and HTTP/2 for modern web application development.

• Scalable thread pools – Jetty allows configuring thread pools to tune performance for specific workloads. This helps scale under increased traffic and load.

2. How does Jetty compare to Tomcat?

While both Tomcat and Jetty implement the Java Servlet specification, there are some key differences:

• Jetty is more lightweight and easier to embed within Java applications compared to the heavier Tomcat.

• Jetty utilizes non-blocking I/O while Tomcat uses blocking I/O making Jetty better suited for heavy workloads.

• Jetty has better support for the latest technologies like WebSockets and HTTP/2.

• Tomcat provides more out-of-the-box functionality like JNDI, JAAS, whereas Jetty requires additional configuration and dependencies.

• Jetty has a simpler codebase and API while Tomcat’s codebase is relatively complex.

3. Explain how Jetty utilizes non-blocking I/O.

Jetty leverages Java’s Non-blocking I/O APIs to implement asynchronous request processing. When a request comes in, instead of assigning it to a thread that blocks while waiting for the request to process, Jetty hands it off immediately to a worker thread from a thread pool.

If the request handler needs to wait for I/O – like data from a database – it returns control back to Jetty, freeing up the thread for other work. Once I/O resumes, Jetty assigns another thread to continue processing the original request.

This non-blocking approach allows Jetty to scale to handle many concurrent requests without incurring the overhead of extra threads waiting idly.

4. How does Jetty provide support for WebSockets?

Jetty includes native support for the WebSocket protocol, which enables bidirectional communication channels over a single TCP connection. Here’s how it works:

• Clients connect to a WebSocket endpoint on the Jetty server via an HTTP upgrade request.

• Jetty handles the protocol upgrade and responds to confirm the establishment of a WebSocket connection.

• All communication then occurs over this open WebSocket without additional HTTP requests. Messages can flow in both directions.

• Jetty provides WebSocket APIs to applications allowing them to directly work with native WebSocket events and frames.

5. How can you configure SSL/TLS for a Jetty server?

Here are the main steps to configure SSL/TLS for a Jetty server:

1. Generate a private key and X.509 certificate for your server.

2. Obtain the SSL certificate from a trusted Certificate Authority if needed.

3. Place keys and certificates within the ${jetty.base}/etc/ directory.

4. Create a jetty-ssl-context.xml file defining a SslContextFactory bean.

5. Set properties like keyStorePath, trustStorePath, setIncludeProtocols.

6. Create a connector in jetty.xml referencing the sslContextFactory.

7. Restart Jetty server to apply configuration.

Now Jetty will encrypt all communication over the connector using SSL/TLS.

6. How do you configure request logging in Jetty?

Jetty provides a RequestLog interface for logging HTTP requests/responses. To configure it:

• Implement a request log class like NCSARequestLog and set properties like filename pattern, timezone etc.

• Obtain a RequestLogHandler and set its requestLog property to the log instance created.

• Add the RequestLogHandler to the handlers chain for the server or a specific context.

• As requests pass through the handler chain, details will be logged according to the configuration.

• By default, logging occurs in the NCSA common log format but you can create a custom log format by implementing the RequestLog interface from scratch.

7. What is a Jetty ContextHandler and how is it used?

A ContextHandler in Jetty represents a context path that serves a specific web application. It is used to rapidly deploy webapps and configure parameters like context path, sessions, security, and handlers.

Some of the key things that can be done with a ContextHandler include:

• Setting a context path to access the web app on the server.

• Configuring session management and clustering.

• Adding security constraints to authentication protected resources.

• Setting a resource base directory where static resources and JSPs are loaded from.

• Adding servlets, filters and event listeners programmatically.

• Allowing hot deployment of webapps without restarting the server.

8. How can Jetty be integrated with Spring Boot?

Jetty can be easily embedded into Spring Boot applications to provide an embedded servlet container. Here’s how:

• Include the spring-boot-starter-jetty dependency in your project.

• Spring Boot will auto-configure a JettyServletWebServerFactory during startup.

• Developer configurable properties like port, thread pools etc. can be set in application.properties.

• The SpringDispatchServlet will handle all requests on the root path by default.

• Controllers can be implemented within the application and mapped to paths to build REST APIs and web apps.

• No need for an external Jetty deployment or WAR file creation.

9. How do you configure HTTPS in Jetty?

Follow these steps to enable HTTPS in Jetty:

1. Generate a private key and X.509 certificate for the server if you don’t already have one.

2. Place keys and certificates in ${jetty.base}/etc.

3. Define a SslContextFactory bean in jetty-ssl-context.xml configuring keyStorePath etc.

4. Create a SslConnectionFactory instance referencing the sslContextFactory.

5. Instantiate a SslSocketConnector using the SslConnectionFactory.

6. Set the port and host properties on the connector.

7. Add the SslSocketConnector to the Jetty server.

8. Update webapps to redirect requests to the HTTPS connector port.

After restarting Jetty, the server will now accept HTTPS requests on the secured connector port using the configured SSL certificate.

10. What is a Jetty Handler and how does it work?

A Handler in Jetty represents a component that processes an HTTP request and generates a response. The key steps are:

• The handler handles a request by implementing a handle() method.

• The handle method typically calls methods to process the request on other handlers.

• It may also read/modify the request attributes or set response attributes.

• Finally, it sets a response status code and writes the response via the handle() method.

• Multiple handlers are chained together to form a processing pipeline for each request.

• Jetty ships with prebuilt handlers like ContextHandler, ResourceHandler etc. for common use cases.

11. How do you configure thread pools in Jetty?

Jetty’s thread pools can be tuned for optimal performance. Here are the key steps:

1. Instantiate a QueuedThreadPool instance.

2. Set maxThreads to size the pool for expected load. Too few threads lead to congestion, too many cause resource wastage.

3. Optionally configure minThreads to retain core threads and maxQueueSize for incoming requests.