tessl/maven-org-eclipse-jetty--jetty-server

Core server component of Eclipse Jetty web server providing HTTP server functionality, request handling, and connection management

—

Pending

Overview

Eval results

Files

Eclipse Jetty Server

Name: tessl/maven-org-eclipse-jetty--jetty-server
Author: tessl

Eclipse Jetty Server is the core HTTP server component of the Eclipse Jetty web server. It provides a comprehensive API for building HTTP servers, handling HTTP requests and responses, managing connections, and serving static and dynamic content. The server supports HTTP/1.1, HTTP/2, and HTTP/3 protocols with extensive configuration options and handler-based request processing.

Package Information

Package Name: org.eclipse.jetty:jetty-server
Package Type: maven
Language: Java
Installation: Add Maven dependency

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>12.0.21</version>
</dependency>

Core Imports

// Core server classes
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.HttpConfiguration;

// Handler interfaces and implementations
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.util.Callback;

// Context and resource handling
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ResourceHandler;

// Optional components
import org.eclipse.jetty.server.handler.gzip.GzipHandler;

Basic Usage

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.util.Callback;

public class SimpleJettyServer {
    public static void main(String[] args) throws Exception {
        // Create server instance
        Server server = new Server();
        
        // Create and configure HTTP connector
        ServerConnector connector = new ServerConnector(server);
        connector.setPort(8080);
        server.addConnector(connector);
        
        // Create a simple handler
        Handler handler = new Handler.Abstract() {
            @Override
            public boolean handle(Request request, Response response, Callback callback) 
                    throws Exception {
                response.setStatus(200);
                response.getHeaders().put("Content-Type", "text/plain");
                response.write(true, "Hello, Jetty!".getBytes(), callback);
                return true;
            }
        };
        
        server.setHandler(handler);
        
        // Start the server
        server.start();
        server.join(); // Wait for server to finish
    }
}

Architecture

Eclipse Jetty Server follows a component-based architecture with these key concepts:

Core Components

Server: Central coordinator that manages connectors, handlers, and lifecycle
Connector: Manages network connections and protocol support (HTTP/1.1, HTTP/2, HTTP/3)
Handler: Processes HTTP requests in a chain-of-responsibility pattern
Request/Response: Interfaces representing HTTP request and response with lifecycle callbacks

Request Processing Flow

Connection: Connector accepts network connections and creates protocol-specific connections
Request Parsing: Connection parses HTTP protocol into Request objects
Handler Chain: Server delegates requests through handler chain for processing
Response Generation: Handlers generate responses through Response interface
Completion: Callback mechanism signals request completion and cleanup

Threading Model

Acceptor Threads: Accept new connections (configurable count)
Selector Threads: Manage I/O operations on connections (NIO-based)
Handler Threads: Execute request processing logic (from thread pool)
Async Support: Non-blocking I/O with callback-based completion

Capabilities

Server Core

Core server functionality including server lifecycle, connector management, and basic configuration.

public final class Server extends Handler.Wrapper implements Attributes {
    // Constructors
    public Server();
    public Server(int port);
    public Server(InetSocketAddress addr);
    public Server(ThreadPool threadPool);
    
    // Core server operations
    public static String getVersion();
    public URI getURI();
    public void join() throws InterruptedException;
    
    // Connector management
    public Connector[] getConnectors();
    public void addConnector(Connector connector);
    public void setConnectors(Connector[] connectors);
    
    // Handler management  
    public void setHandler(Handler handler);
    public Handler getHandler();
    public Request.Handler getErrorHandler();
    public void setErrorHandler(Request.Handler errorHandler);
}

Server Core APIs

Request and Response Processing

HTTP request and response interfaces with content handling, headers, and lifecycle management.

public interface Request extends Attributes, Content.Source {
    String getId();
    String getMethod();
    HttpURI getHttpURI();
    HttpFields getHeaders();
    List<HttpCookie> getCookies();
    Session getSession(boolean create);
    Context getContext();
    ConnectionMetaData getConnectionMetaData();
    
    interface Handler {
        boolean handle(Request request, Response response, Callback callback) throws Exception;
    }
}

public interface Response extends Content.Sink {
    Request getRequest();
    int getStatus();
    void setStatus(int code);
    HttpFields.Mutable getHeaders();
    void write(boolean last, ByteBuffer byteBuffer, Callback callback);
}

Request and Response APIs

Handler Framework

Flexible handler system for processing HTTP requests with support for wrapping, containers, and conditional processing.

public interface Handler extends LifeCycle, Destroyable, Request.Handler {
    Server getServer();
    void setServer(Server server);
    
    interface Container extends Handler {
        List<Handler> getHandlers();
        boolean insertHandler(Handler handler);
        boolean removeHandler(Handler handler);
    }
    
    abstract class Abstract extends AbstractLifeCycle implements Handler {
        protected abstract boolean handle(Request request, Response response, Callback callback) throws Exception;
    }
}

Handler System

Connection Management

Network connection handling with protocol factories, SSL support, and connection lifecycle management.

public interface Connector extends LifeCycle, Container, Graceful {
    Server getServer();
    Executor getExecutor();
    Scheduler getScheduler();
    ByteBufferPool getByteBufferPool();
    ConnectionFactory getConnectionFactory(String protocol);
    Collection<ConnectionFactory> getConnectionFactories();
}

public class ServerConnector extends AbstractNetworkConnector {
    public ServerConnector(Server server);
    public ServerConnector(Server server, ConnectionFactory... factories);
    
    public void setPort(int port);
    public int getPort();
    public void setHost(String host);
    public String getHost();
}

Connection Management

HTTP Configuration

HTTP protocol configuration including buffer sizes, timeouts, security settings, and protocol customizers.

public class HttpConfiguration implements Dumpable {
    public HttpConfiguration();
    public HttpConfiguration(HttpConfiguration config);
    
    public void addCustomizer(Customizer customizer);
    public List<Customizer> getCustomizers();
    public int getOutputBufferSize();
    public void setOutputBufferSize(int outputBufferSize);
    public int getRequestHeaderSize();
    public void setRequestHeaderSize(int requestHeaderSize);
    public boolean getSendServerVersion();
    public void setSendServerVersion(boolean sendServerVersion);
    
    interface Customizer {
        Request customize(Request request, HttpConfiguration configuration);
    }
}

HTTP Configuration

Context and Resource Handling

Context-based request routing with virtual hosts, resource serving, and servlet-like contexts.

public class ContextHandler extends Handler.Wrapper implements Attributes, AliasCheck {
    public String getContextPath();
    public void setContextPath(String contextPath);
    public Resource getBaseResource();
    public void setBaseResource(Resource resource);
    public List<String> getVirtualHosts();
    public void setVirtualHosts(String... vhosts);
    public ClassLoader getClassLoader();
    public void setClassLoader(ClassLoader classLoader);
}

public class ResourceHandler extends Handler.Wrapper {
    public Resource getBaseResource();
    public void setBaseResource(Resource baseResource);
    public List<String> getWelcomeFiles();
    public void setWelcomeFiles(String... welcomeFiles);
}

Context and Resources

Session Management

HTTP session management with creation, invalidation, and attribute storage.

public interface Session extends Attributes {
    String getId();
    Context getContext();
    long getCreationTime();
    long getLastAccessedTime();
    void setMaxInactiveInterval(int interval);
    int getMaxInactiveInterval();
    void invalidate();
    boolean isNew();
}

Session Management

Request Logging

Comprehensive request logging with customizable formats, file rotation, and SLF4J integration.

public interface RequestLog {
    void log(Request request, Response response);
    
    interface Writer {
        void write(String requestEntry) throws IOException;
    }
}

public class CustomRequestLog extends ContainerLifeCycle implements RequestLog {
    public CustomRequestLog(RequestLog.Writer writer, String format);
    public void setLogFormat(String format);
    public String getLogFormat();
}

Request Logging

Security and SSL

SSL/TLS support, security customizers, and connection encryption.

public class SslConnectionFactory extends AbstractConnectionFactory 
        implements ConnectionFactory.Detecting, ConnectionFactory.Configuring {
    public SslConnectionFactory(SslContextFactory.Server sslContextFactory, String nextProtocol);
    public SslContextFactory.Server getSslContextFactory();
}

public class SecureRequestCustomizer implements HttpConfiguration.Customizer {
    public void setSniRequired(boolean sniRequired);
    public void setStsMaxAge(long stsMaxAge);
    public void setStsIncludeSubDomains(boolean stsIncludeSubDomains);
}

Security and SSL

Utility Handlers

Specialized handlers for common functionality like GZIP compression, CORS, statistics, and error handling.

public class GzipHandler extends Handler.Wrapper implements GzipFactory {
    public int getMinGzipSize();
    public void setMinGzipSize(int minGzipSize);
    public int getCompressionLevel();
    public void setCompressionLevel(int compressionLevel);
    public Set<String> getIncludedMimeTypes();
    public void setIncludedMimeTypes(String... types);
}

public class StatisticsHandler extends EventsHandler {
    public int getRequests();
    public int getRequestsActive();
    public long getBytesReceived();
    public long getBytesSent();
}

Utility Handlers

Types

// Core callback interface for async operations
public interface Callback {
    void succeeded();
    void failed(Throwable x);
    
    static Callback NOOP = new Callback() {
        public void succeeded() {}
        public void failed(Throwable x) {}
    };
}

// HTTP URI representation
public interface HttpURI {
    String getScheme();
    String getHost();
    int getPort();
    String getPath();
    String getQuery();
    String getFragment();
}

// HTTP fields for headers
public interface HttpFields extends Iterable<HttpField> {
    HttpField getField(String name);
    String get(String name);
    List<String> getValuesList(String name);
    int size();
    
    interface Mutable extends HttpFields {
        HttpField put(String name, String value);
        HttpField add(String name, String value);
        boolean remove(String name);
        void clear();
    }
}

// Context for request processing
public interface Context extends Attributes, Decorator, Executor {
    String getContextPath();
    ClassLoader getClassLoader();
    Resource getBaseResource();
    List<String> getVirtualHosts();
    MimeTypes getMimeTypes();
    void run(Runnable runnable);
    Request.Handler getErrorHandler();
}

// Thread pool interface
public interface ThreadPool extends Executor {
    void join() throws InterruptedException;
    int getThreads();
    int getIdleThreads();
    boolean isLowOnThreads();
}

// Graceful shutdown interface
public interface Graceful {
    CompletableFuture<Void> shutdown();
    boolean isShutdown();
}

// Resource abstraction
public interface Resource {
    String getName();
    boolean exists();
    boolean isDirectory();
    long length();
    long lastModified();
    InputStream newInputStream() throws IOException;
    ReadableByteChannel newReadableByteChannel() throws IOException;
}

Install with Tessl CLI

npx tessl i tessl/maven-org-eclipse-jetty--jetty-server

Workspace: tessl
Visibility: Public
Created: 6 months ago
Last updated: about 1 month ago
Describes: pkg:maven/org.eclipse.jetty/jetty-server@12.0.x