Jetty

Jetty 用途、官方文档及使用指南

Jetty 是一个轻量级、高性能的开源 Java Web 服务器和 Servlet 容器，由 Eclipse Foundation 维护。它广泛应用于部署 Java Web 应用程序，支持 Servlet、JSP、WebSocket 等标准，适用于开发、测试和生产环境。以下我将逐步解释其用途、官方文档和使用指南，确保回答基于可靠信息（参考 Jetty 官方文档和社区实践）。

1. Jetty 的用途

Jetty 主要用于作为嵌入式服务器或独立服务器运行 Java Web 应用。其核心用途包括：

• Web 应用部署：作为 Servlet 容器，运行 WAR 文件（如 Spring Boot 或 Java EE 应用），支持动态内容处理。
• 嵌入式服务器：可集成到应用程序中（如 IDE 或微服务框架），提供轻量级 HTTP 服务，无需外部服务器。
• 协议支持：支持 HTTP/2、WebSocket、SSL/TLS 等，适用于实时通信（如聊天应用或游戏服务器）。
• 开发与测试：启动速度快、资源占用低，常用于本地开发和持续集成测试。
• 扩展性：通过插件机制支持自定义模块（如日志、安全），适合云原生和容器化部署。

Jetty 的优势在于其模块化设计和低内存开销，特别适合微服务架构和高并发场景。

2. 官方文档

Jetty 的官方文档由 Eclipse Foundation 提供，内容全面且更新及时。您可以通过以下方式访问：

• 官方网站：https://www.eclipse.org/jetty/
  这里包含入门指南、API 文档、配置手册和示例代码。
• 文档入口：
  • 用户指南：覆盖安装、配置、部署等基本操作。
  • API 参考：详细类和方法文档，适合开发者。
  • GitHub 仓库：提供源码和 issue 跟踪。
• 推荐资源：官方文档以英文为主，但社区有中文翻译（如部分博客），建议优先查看官方站点确保准确性。

3. 使用指南

Jetty 的使用灵活，支持多种部署方式（如命令行、嵌入式代码或构建工具）。以下是基本步骤和配置示例：

基本使用步骤

1. 安装 Jetty：

   • 下载二进制包从 Jetty 下载页，或通过 Maven/Gradle 依赖集成。
   • Maven 依赖示例：

     <dependency>
         <groupId>org.eclipse.jetty</groupId>
         <artifactId>jetty-server</artifactId>
         <version>11.0.20</version> <!-- 使用最新版本 -->
     </dependency>
     

2. 启动 Jetty 服务器：

   • 作为独立服务器：运行 java -jar start.jar（在 Jetty 安装目录下）。
   • 嵌入式方式（Java 代码示例）：

     import org.eclipse.jetty.server.Server;
     import org.eclipse.jetty.servlet.ServletContextHandler;
     
     public class JettyDemo {
         public static void main(String[] args) throws Exception {
             Server server = new Server(8080); // 设置端口
             ServletContextHandler context = new ServletContextHandler();
             context.setContextPath("/");
             context.addServlet(HelloServlet.class, "/*"); // 添加自定义 Servlet
             server.setHandler(context);
             server.start();
             server.join();
         }
     }
     

3. 部署 Web 应用：

   • 将 WAR 文件放入 webapps 目录，Jetty 自动部署。
   • 或通过配置文件（如 jetty.xml）指定上下文路径。

4. 常见配置：

   • 设置属性：如 ServletContext 属性，可在 Ant 或 XML 文件中配置（参考引用[1]）。

     <webApp war="path/to/foo.war" contextPath="/">
         <attributes>
             <attribute name="my.param" value="123"/>
         </attributes>
     </webApp>
     

   • 日志配置：通过 jetty-logging.properties 文件自定义日志级别（参考引用[2]）。

     org.eclipse.jetty.level=INFO
     

   • SSL/TLS 配置：在代码或配置文件中启用 HTTPS（参考引用[3]）。

     // 嵌入式示例（Clojure 类似）
     Server server = new Server();
     HttpConfiguration httpsConfig = new HttpConfiguration();
     httpsConfig.addCustomizer(new SecureRequestCustomizer());
     ServerConnector connector = new ServerConnector(server,
         new SslConnectionFactory(sslContextFactory, "http/1.1"),
         new HttpConnectionFactory(httpsConfig));
     connector.setPort(8443);
     server.addConnector(connector);
     

5. 优化与监控：

   • 使用 JMX 或 Admin Context 监控性能。
   • 调整线程池大小（在配置中设置 threadPool 参数）以提高并发。

思维导图

Jetty 技术深度解析

1. 技术原理与核心机制

Jetty 基于事件驱动模型和非阻塞I/O实现高性能，核心原理包括：

• Selector多路复用：使用 java.nio.channels.Selector 监听多个通道事件，单线程可处理数千连接
• 异步处理链：请求通过可扩展的处理器链（Handler）处理，每个组件专注单一职责
• 零拷贝优化：通过 ByteBufferPool 复用内存缓冲区，减少GC压力
• 线程池模型：QueuedThreadPool 使用任务队列（BlockingQueue）和工作者线程池分离I/O与业务逻辑

2. 关键算法与数据结构

3. 核心架构组件

graph TB
Server --> Connector
Server --> Handler
Server --> ThreadPool

subgraph Connector
  SelectorManager
  ConnectionFactory
  Scheduler
end

subgraph Handler
  ContextHandler
  ServletHandler
  WebSocketHandler
end

ThreadPool --> WorkerThreads

组件功能：

1. Server：总控制器，管理生命周期
2. Connector：处理网络I/O，支持HTTP/1.x/2, HTTP/3
3. Handler：模块化处理链，支持嵌套组合
4. ByteBufferPool：内存管理核心，减少GC暂停
5. WebAppContext：Servlet容器实现，加载WAR文件

4. 优缺点分析

✅ 优点：

• 轻量高效：基础JAR仅1.5MB，启动时间<1秒
• 嵌入式友好：API设计简洁，易于集成
• 高并发：NIO模型支持10K+并发连接
• 热部署：类加载器隔离实现秒级热更新

❌ 缺点：

• 学习曲线陡峭（相比Tomcat）
• JMX监控功能较弱
• 集群管理需依赖外部组件

5. Java代码示例（嵌入式服务器）

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;

public class JettyEmbeddedDemo {

    public static void main(String[] args) throws Exception {
        // 创建服务器实例，使用默认配置
        Server server = new Server();
        
        // 创建连接器（非阻塞I/O核心）
        ServerConnector connector = new ServerConnector(server);
        connector.setPort(8080);          // 监听端口
        connector.setIdleTimeout(30000);  // 空闲超时(ms)
        server.addConnector(connector);   // 添加到服务器

        // 创建Servlet上下文处理器
        ServletContextHandler context = new ServletContextHandler();
        context.setContextPath("/");      // 设置根路径
        
        // 注册Servlet并映射路径
        context.addServlet(
            new ServletHolder(new HelloServlet()),  // 自定义Servlet
            "/*"                                    // 映射所有路径
        );
        
        // 设置服务器处理器
        server.setHandler(context);
        
        // 启动服务器（非阻塞调用）
        server.start();
        server.join();  // 等待服务器停止
    }
    
    // 自定义Servlet实现
    static class HelloServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws IOException {
            
            // 设置响应类型
            resp.setContentType("text/html; charset=utf-8");
            
            // 响应内容
            PrintWriter out = resp.getWriter();
            out.println("<h1>Jetty 工作正常!</h1>");
            out.printf("<p>请求URI: %s</p>", req.getRequestURI());
        }
    }
}

6. 性能优化建议

1. 线程池调优：

   QueuedThreadPool threadPool = new QueuedThreadPool();
   threadPool.setMaxThreads(200);     // 最大工作线程
   threadPool.setMinThreads(20);      // 核心线程数
   server.setThreadPool(threadPool);
   

2. 缓冲区配置：

   ArrayByteBufferPool bufferPool = new ArrayByteBufferPool(
        64,      // 最小buffer大小
        4096,    // 基础buffer大小
        64 * 1024// 最大buffer大小
   );
   connector.setByteBufferPool(bufferPool);
   

3. 启用HTTP/2：

   HttpConnectionFactory http1 = new HttpConnectionFactory();
   HTTP2ServerConnectionFactory http2 = new HTTP2ServerConnectionFactory();
   connector.addConnectionFactory(new ALPNServerConnectionFactory());
   connector.addConnectionFactory(http2);
   

以上实现展示了Jetty的核心技术原理，通过NIO事件驱动模型和模块化处理器链实现高性能Web服务。

思维导图

Jetty 深度解析与对比实践指南

1. Jetty 与 Tomcat 架构对比分析

核心差异：Jetty 采用Reactor模式实现真正的非阻塞I/O，而 Tomcat 的 NIO 实现本质是模拟非阻塞（8.5+版本优化）

2. Spring Boot 集成 Jetty

步骤1：排除 Tomcat 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

步骤2：添加 Jetty 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

步骤3：性能调优配置

server:
  jetty:
    threads:
      max: 200     # 最大工作线程数
      min: 20      # 核心线程数
    connection-idle-timeout: 30000  # 连接空闲超时(ms)
    acceptors: 2   # 接收器线程数(通常=CPU核心数)

3. WebSocket 支持实现

服务端配置

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        // 注册WebSocket处理器并指定路径
        registry.addHandler(new MyWebSocketHandler(), "/ws")
                .setAllowedOrigins("*"); // 允许跨域
    }

    // 自定义WebSocket处理器
    class MyWebSocketHandler extends TextWebSocketHandler {
        @Override
        protected void handleTextMessage(WebSocketSession session, TextMessage message) {
            // 收到消息处理逻辑
            String payload = message.getPayload();
            try {
                // 回传消息给客户端
                session.sendMessage(new TextMessage("ECHO: " + payload));
            } catch (IOException e) {
                // 异常处理
            }
        }
    }
}

原理：Jetty 通过WebSocketServerFactory创建端点，使用WebSocketConnection管理全双工通信通道

4. 非阻塞 I/O 与线程模型

核心机制：

关键代码实现：

// 创建非阻塞服务器
Server server = new Server();

// 配置线程池
QueuedThreadPool threadPool = new QueuedThreadPool();
threadPool.setMaxThreads(200);  // 最大工作线程
server.setThreadPool(threadPool);

// 创建连接器（NIO核心）
ServerConnector connector = new ServerConnector(server,
    null,  // executor
    null,  // scheduler
    null,  // buffer pool
    2,     // acceptors数
    4,     // selectors数
    new HttpConnectionFactory() // HTTP协议工厂
);
connector.setPort(8080);
server.addConnector(connector);

线程模型优势：

• 1个Acceptor线程处理新连接
• N个Selector线程($N=CPU核心数$)处理I/O事件
• Worker线程池处理业务逻辑
  实现$10K+$并发连接

5. Handler 处理器链机制

工作流程：

自定义处理器示例：

public class CustomHandler extends AbstractHandler {
    @Override
    public void handle(String target, Request baseRequest, 
                       HttpServletRequest request, 
                       HttpServletResponse response) 
            throws IOException {
        
        // 1. 前置处理（如身份验证）
        if (!checkAuth(request)) {
            response.sendError(401, "Unauthorized");
            baseRequest.setHandled(true); // 标记已处理
            return;
        }

        // 2. 传递给下一个处理器
        if (!baseRequest.isHandled()) {
            getServer().handle(target, baseRequest, request, response);
        }

        // 3. 后置处理（如响应日志）
        logResponse(response);
    }
    
    private boolean checkAuth(HttpServletRequest req) {
        // 实现认证逻辑
        return req.getHeader("Authorization") != null;
    }
}

// 注册到服务器
server.setHandler(new HandlerCollection(
    new CustomHandler(),
    new DefaultHandler()  // 默认处理器
));

6. SSL/TLS 配置实现 HTTPS

生成密钥库：

keytool -genkeypair -alias jetty -keyalg RSA -keystore keystore.jks -keysize 2048

Java 配置：

Server server = new Server();

// 创建SSL上下文工厂
SslContextFactory.Server ssl = new SslContextFactory.Server();
ssl.setKeyStorePath("keystore.jks");
ssl.setKeyStorePassword("changeit");
ssl.setKeyManagerPassword("changeit");

// 创建HTTPS连接器
ServerConnector sslConnector = new ServerConnector(server,
    new SslConnectionFactory(ssl, "http/1.1"),
    new HttpConnectionFactory()
);
sslConnector.setPort(8443);
server.addConnector(sslConnector);

Spring Boot 配置：

server:
  port: 8443
  ssl:
    key-store: classpath:keystore.jks
    key-store-password: changeit
    key-password: changeit
    key-alias: jetty

7. 性能对比数据

数据来源：4核8G云服务器，Spring Boot 2.7.x 压测结果

总结建议

• 选 Jetty：需要嵌入式部署/高并发/低延迟场景
• 选 Tomcat：传统企业应用/需要完善管理界面
• 关键优化：
  1. 根据CPU核心数设置Selector线程数：$N_{selectors}=N_{cores}$
  2. Worker线程数：$W_{max}=200\times N_{cores}$（I/O密集型）
  3. 启用HTTP/2提升传输效率

思维导图