## Servlet注解
@WebServlet是Java Servlet规范中的一个注解，用于将一个类标记为Servlet，并指定与该Servlet相关的配置信息。下面是对@WebServlet注解的详细解释：



1. 作用：
   @WebServlet注解用于将一个普通的Java类转变为Servlet，使其能够处理HTTP请求和响应。

2. 使用方式：
   @WebServlet注解可以直接放置在类的定义上，用于标记该类为Servlet。可以在注解的参数中指定相关的配置信息，例如URL映射、初始化参数等。

3. 参数说明：
   - name：指定Servlet的名称。
   - value：指定Servlet的URL映射，可以是一个字符串数组。
   - urlPatterns：与value参数功能相同，用于指定URL映射。
   - description：提供对Servlet的简要说明。
   - displayName：指定Servlet在管理工具中的显示名称。
   - initParams：指定Servlet的初始化参数，可以是一个数组。
   - asyncSupported：指定Servlet是否支持异步操作，默认为false。
   - loadOnStartup：指定Servlet的加载顺序，值越小越先加载。
   - smallIcon和largeIcon：指定Servlet在管理工具中的图标。

4. 示例：
   下面是一个使用@WebServlet注解的示例：
```java
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;

   @WebServlet(name = "MyServlet", urlPatterns = {"/myServlet"})
   public class MyServlet extends HttpServlet {
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
           response.getWriter().println("Hello, World!");
       }
   }
```


   
   在上述示例中，我们使用@WebServlet注解将类`MyServlet`标记为Servlet，并指定了URL映射为`/myServlet`。

通过使用@WebServlet注解，我们可以方便地将一个普通的Java类转变为Servlet，并且可以通过注解的参数配置Servlet的相关信息，简化了Servlet的配置和部署过程。

Tomcat源码学习4

## Servlet容器
Servlet 容器用来加载和管理业务类。HTTP 服务器不直接跟业务类打交道，而是把请求交给 Servlet 容器去处理，Servlet 容器会将请求转发到具体的 Servlet，如果这个 Servlet 还没创建，就加载并实例化这个 Servlet，然后调用这个 Servlet 的接口方法。因此 Servlet 接口其实是Servlet 容器跟具体业务类之间的接口。下面我们通过一张图来加深理解。




![image.png](/static/img/0ca0727df9c5da0639fb05dbe30e6358.image.webp)
图的左边表示 HTTP 服务器直接调用具体业务类，它们是紧耦合的。再看图的右边，HTTP 服务器不直接调用业务类，而是把请求交给容器来处理，容器通过 Servlet 接口调用业务类。因此 Servlet 接口和 Servlet 容器的出现，达到了 HTTP 服务器与业务类解耦的目的。

而 Servlet 接口和 Servlet 容器这一整套规范叫作 Servlet 规范。Tomcat 和 Jetty 都按照 Servlet 规范的要求实现了 Servlet 容器，同时它们也具有 HTTP 服务器的功能。作为 Java 程序员，如果我们要实现新的业务功能，只需要实现一个 Servlet，并把它注册到 Tomcat（Servlet 容器）中，剩下的事情就由 Tomcat 帮我们处理了。

客户请求某个资源时，HTTP 服务器会用一个 ServletRequest 对象把客户的请求信息封装起来，然后调用 Servlet 容器的 service 方法，Servlet 容器拿到请求后，根据请求的 URL 和 Servlet 的映射关系，找到相应的 Servlet，如果 Servlet 还没有被加载，就用反射机制创建这个 Servlet，并调用 Servlet 的 init 方法来完成初始化，接着调用 Servlet 的 service 方法来处理请求，把 ServletResponse 对象返回给 HTTP 服务器，HTTP 服务器会把响应发送给客户端。同样我通过一张图来帮助你理解。


![image.png](/static/img/32cf18b03a1f7db014ca921195498a86.image.webp)
## Servlet接口
图的左边表示 HTTP 服务器直接调用具体业务类，它们是紧耦合的。再看图的右边，HTTP 服务器不直接调用业务类，而是把请求交给容器来处理，容器通过 Servlet 接口调用业务类。因此 Servlet 接口和 Servlet 容器的出现，达到了 HTTP 服务器与业务类解耦的目的。

而 Servlet 接口和 Servlet 容器这一整套规范叫作 Servlet 规范。Tomcat 和 Jetty 都按照 Servlet 规范的要求实现了 Servlet 容器，同时它们也具有 HTTP 服务器的功能。作为 Java 程序员，如果我们要实现新的业务功能，只需要实现一个 Servlet，并把它注册到 Tomcat（Servlet 容器）中，剩下的事情就由 Tomcat 帮我们处理了。

引入了 Servlet 规范后，你不需要关心 Socket 网络通信、不需要关心 HTTP 协议，也不需要关心你的业务类是如何被实例化和调用的，因为这些都被 Servlet 规范标准化了，你只要关心怎么实现的你的业务逻辑。

## web应用
Servlet 规范里定义了ServletContext这个接口来对应一个 Web 应用。Web 应用部署好后，Servlet 容器在启动时会加载 Web 应用，并为每个 Web 应用创建唯一的 ServletContext 对象。你可以把 ServletContext 看成是一个全局对象，一个 Web 应用可能有多个 Servlet，这些 Servlet 可以通过全局的 ServletContext 来共享数据，这些数据包括 Web 应用的初始化参数、Web 应用目录下的文件资源等。由于 ServletContext 持有所有 Servlet 实例，你还可以通过它来实现 Servlet 请求的转发。

## Filter和Lister
Servlet 规范提供了两种扩展机制：Filter和Listener。

Filter是过滤器，这个接口允许你对请求和响应做一些统一的定制化处理，比如你可以根据请求的频率来限制访问，或者根据国家地区的不同来修改响应内容。过滤器的工作原理是这样的：Web 应用部署完成后，Servlet 容器需要实例化 Filter 并把 Filter 链接成一个 FilterChain。当请求进来时，获取第一个 Filter 并调用 doFilter 方法，doFilter 方法负责调用这个 FilterChain 中的下一个 Filter。

Listener是监听器，这是另一种扩展机制。当 Web 应用在 Servlet 容器中运行时，Servlet 容器内部会不断的发生各种事件，如 Web 应用的启动和停止、用户请求到达等。 Servlet 容器提供了一些默认的监听器来监听这些事件，当事件发生时，Servlet 容器会负责调用监听器的方法。当然，你可以定义自己的监听器去监听你感兴趣的事件，将监听器配置在 web.xml 中。比如 Spring 就实现了自己的监听器，来监听 ServletContext 的启动事件，目的是当 Servlet 容器启动时，创建并初始化全局的 Spring 容器。

## 总结
Servlet 本质上是一个接口，实现了 Servlet 接口的业务类也叫 Servlet。Servlet 接口其实是 Servlet 容器跟具体 Servlet 业务类之间的接口。Servlet 接口跟 Servlet 容器这一整套规范叫作 Servlet 规范，而 Servlet 规范使得程序员可以专注业务逻辑的开发，同时 Servlet 规范也给开发者提供了扩展的机制 Filter 和 Listener。

总结一下 Filter 和 Listener 的本质区别：

- Filter 是干预过程的，它是过程的一部分，是基于过程行为的。
- 
- Listener 是基于状态的，任何行为改变同一个状态，触发的事件是一致的。




:::danger{title="重点"}

Tomcat&Jetty在启动时给每个Web应用创建一个全局的上下文环境，这个上下文就是ServletContext，其为后面的Spring容器提供宿主环境。

Tomcat&Jetty在启动过程中触发容器初始化事件，Spring的ContextLoaderListener会监听到这个事件，它的contextInitialized方法会被调用，在这个方法中，Spring会初始化全局的Spring根容器，这个就是Spring的IoC容器，IoC容器初始化完毕后，Spring将其存储到ServletContext中，便于以后来获取。

Tomcat&Jetty在启动过程中还会扫描Servlet，一个Web应用中的Servlet可以有多个，以SpringMVC中的DispatcherServlet为例，这个Servlet实际上是一个标准的前端控制器，用以转发、匹配、处理每个Servlet请求。

Servlet一般会延迟加载，当第一个请求达到时，Tomcat&Jetty发现DispatcherServlet还没有被实例化，就调用DispatcherServlet的init方法，DispatcherServlet在初始化的时候会建立自己的容器，叫做SpringMVC 容器，用来持有Spring MVC相关的Bean。同时，Spring MVC还会通过ServletContext拿到Spring根容器，并将Spring根容器设为SpringMVC容器的父容器，请注意，Spring MVC容器可以访问父容器中的Bean，但是父容器不能访问子容器的Bean， 也就是说Spring根容器不能访问SpringMVC容器里的Bean。说的通俗点就是，在Controller里可以访问Service对象，但是在Service里不可以访问Controller对象。

Spring容器是管理service和dao的，

SpringMVC容器是管理controller对象的，
:::



## 参考
https://blog.csdn.net/zhanglf02/article/details/89791797

Tomcat源码阅读3

Ant 是一个用于自动化构建 Java 项目的构建工具。它是由 Apache 软件基金会开发的，是一种基于 XML 的构建脚本语言。

Ant 提供了一组任务（tasks），可以用于编译 Java 代码、运行单元测试、打包应用程序、生成文档等等。通过编写 Ant 构建脚本，你可以定义一系列任务和它们之间的依赖关系，从而实现自动化的构建过程。



Ant 的构建脚本使用 XML 格式编写，其中定义了一系列目标（targets），每个目标包含一系列任务。任务可以执行各种操作，例如编译源代码、复制文件、运行外部工具等。通过指定目标和任务的依赖关系，Ant 可以按照指定的顺序执行任务，完成项目的构建过程。

Ant 是一种跨平台的构建工具，可以在不同的操作系统上运行，如 Windows、Linux、Mac 等。它被广泛用于 Java 项目的构建和自动化部署过程中，尤其在传统的 Java 项目中，Ant 的使用非常常见。

然而，随着时间的推移，Ant 逐渐被其他构建工具如 Maven 和 Gradle 所取代，这些工具提供了更强大、更灵活的构建能力，并且更适合用于大型和复杂的项目。尽管如此，Ant 仍然是一个有价值的工具，特别是对于那些仍在使用它的项目来说。

## What is SPDK
The Storage Performance Development Kit (SPDK) provides a set of tools and libraries for writing high performance, scalable, user-mode storage applications. It achieves high performance through the use of a number of key techniques:



- Moving all of the necessary drivers into userspace, which avoids syscalls and enables zero-copy access from the application.
- Polling hardware for completions instead of relying on interrupts, which lowers both total latency and latency variance.
- Avoiding all locks in the I/O path, instead relying on message passing.


The bedrock of SPDK is a user space, polled-mode, asynchronous, lockless NVMe driver. This provides zero-copy, highly parallel access directly to an SSD from a user space application. The driver is written as a C library with a single public header. See NVMe Driver for more details.

SPDK further provides a full block stack as a user space library that performs many of the same operations as a block stack in an operating system. This includes unifying the interface between disparate storage devices, queueing to handle conditions such as out of memory or I/O hangs, and logical volume management. See Block Device User Guide for more information.

Finally, SPDK provides NVMe-oF, iSCSI, and vhost servers built on top of these components that are capable of serving disks over the network or to other processes. The standard Linux kernel initiators for NVMe-oF and iSCSI interoperate with these targets, as well as QEMU with vhost. These servers can be up to an order of magnitude more CPU efficient than other implementations. These targets can be used as examples of how to implement a high performance storage target, or used as the basis for production deployments.


:::info{title="中文翻译"}
Storage Performance Development Kit（SPDK）提供了一组工具和库，用于编写高性能、可扩展的用户态存储应用程序。它通过使用一些关键技术实现高性能：

- 将所有必要的驱动程序移至用户空间，避免系统调用，实现应用程序对数据的零拷贝访问。
- 使用轮询硬件完成而不是依赖中断，降低总延迟和延迟变化。
- 在I/O路径中避免使用锁，而是依赖消息传递。

SPDK的基础是一个用户空间、轮询模式、异步、无锁的NVMe驱动程序。它可以使用户态应用程序直接从固态硬盘（SSD）进行零拷贝、高并发访问。该驱动程序以C库的形式编写，并有一个公共头文件。有关更多详细信息，请参阅NVMe驱动程序。

此外，SPDK还提供了一个完整的块栈作为用户态库，执行与操作系统中的块栈类似的操作。这包括统一不同存储设备之间的接口、队列处理（处理内存不足或I/O挂起等情况）和逻辑卷管理。有关更多信息，请参阅块设备用户指南。

最后，SPDK还提供了基于这些组件构建的NVMe-oF、iSCSI和vhost服务器，可通过网络或向其他进程提供磁盘服务。标准的Linux内核NVMe-oF和iSCSI initiator与这些目标进行互操作，以及使用vhost的QEMU。与其他实现相比，这些服务器的CPU效率可提高一个数量级。这些目标可以用作实现高性能存储目标的示例，或用作生产部署的基础。
:::

- SPDK：存储性能开发工具包（Storage Performance Development Kit）。
- tools：工具，指用于完成特定任务或操作的软件或硬件工具。
- libraries：库，指一组可重用的代码和功能，用于帮助开发人员实现特定的任务或解决特定的问题。
- high performance：高性能，指在速度、吞吐量或响应时间等方面表现出优异的性能。
- scalable：可扩展的，指能够适应不断增长的需求和负载的能力。
- user-mode：用户态，指在用户空间执行的应用程序。
- storage applications：存储应用程序，指用于处理和管理存储数据的软件应用程序。
- Moving：移动，指将某些组件或驱动程序放入用户空间。
- necessary：必要的，指在特定环境中不可或缺的。
- drivers：驱动程序，指用于控制和管理硬件设备的软件组件。
- userspace：用户空间，指操作系统中的一部分，用于执行用户应用程序而不涉及内核功能。
- syscalls：系统调用，应用程序通过操作系统提供的接口访问操作系统功能的方法。
- zero-copy：零拷贝，指在数据传输过程中避免不必要的数据拷贝，提高性能。
- access：访问，指获取或使用某个资源或服务的能力。
- application：应用程序，指为特定目的而开发的软件程序。
- Polling：轮询，通过主动查询的方式获取硬件操作的完成状态，而不依赖中断。
- hardware：硬件，指计算机系统中的物理设备和电子元件。
- completions：完成，指某个操作或任务的结束或完成。
- relying：依赖，指依靠或依赖于某个因素或组件。
- lowers：降低，指减少或降低某个指标或属性的程度。
- total：总的，指涉及所有相关方面的。
- latency：延迟，指从发起请求到获得响应之间的时间间隔。
- variance：差异，指在一系列测量值中的差异程度。
- Avoiding：避免，指不使用或规避某个特定的方法或操作。
- locks：锁，用于同步多个线程对共享资源的访问。
- I/O path：输入/输出路径，指数据在应用程序和存储设备之间传输的路径。
- relying：依赖，指依靠或依赖于某个因素或组件。
- message passing：消息传递，指进程或线程之间通过发送和接收消息进行通信的机制。
- bedrock：基础，指某个系统或框架的核心或基础。
- user space：用户空间，指操作系统中的一部分，用于执行用户应用程序而不涉及内核功能。
- polled-mode：轮询模式，指通过主动查询的方式进行操作和处理的模式。
- asynchronous：异步的，指操作或任务在启动后可以独立于主程序进行执行。
- lockless：无锁的，指在并发环境下无需使用锁进行同步的特性。
- NVMe：非易失性内存快速存储（Non-Volatile Memory Express），一种高性能存储接口协议。
- driver：驱动程序，指用于控制和管理硬件设备的软件组件。
- C library：C 库，指用 C 语言编写的可重用的函数和数据结构的集合。
- public header：公共头文件，指对外公开的用于访问库的函数和结构的头文件。
- block stack：块堆栈，指在操作系统中处理块设备的软件层次结构。
- operating system：操作系统，指管理计算机硬件和软件资源的系统软件。
- unifying：统一，指将多个不同的元素或接口整合为一个统一的整体。
- interface：接口，指两个系统、设备或组件之间进行通信和交互的边界或方法。
- disparate：不同的，指不同类型或性质的事物。
- queueing：排队，指将任务或数据按照一定的顺序进行排列的操作。
- conditions：条件，指影响或触发某个操作或行为的因素。
- out of memory：内存不足，指系统无法分配足够的内存资源以满足需求。
- hangs：挂起，指某个操作或任务因为某种原因而停滞或无法继续。
- logical volume management：逻辑卷管理，用于管理逻辑卷（如磁盘分区、RAID等）的软件技术。
- NVMe-oF：NVMe over Fabrics，一种通过网络传输 NVMe 命令和数据的技术。
- iSCSI：Internet Small Computer System Interface，一种用于在 IP 网络上传输 SCSI 命令和数据的协议。
- vhost：虚拟主机，指在虚拟化环境中提供虚拟设备服务的软件模块。
- servers：服务器，指提供特定服务的计算机硬件或软件。
- capable：能够，指具备某种能力或功能。
- serving：提供，指为客户或其他系统提供所需的服务或资源。
- disks：磁盘，指用于存储和读取数据的物理存储设备。
- network：网络，指连接多个计算机和设备的通信系统。
- processes：进程，指计算机系统中正在运行的程序实例。
- Linux kernel：Linux 内核，指 Linux 操作系统的核心组件。
- initiators：发起者，指在存储网络中发起请求的设备或应用程序。
- interoperate：互操作，指不同系统、设备或程序之间相互交互和协同工作。
- targets：目标，指在存储网络中接收请求并提供存储服务的设备或应用程序。
- QEMU：Quick Emulator，一种用于虚拟化的开源软件。


参考
https://zhuanlan.zhihu.com/p/663871727

SPDK高性能存储套件

## 传统IO过程


![image.png](/static/img/eaed11f830f10ba547c2a3ca4b0559c3.image.webp)

- 应用程序先发起读操作，准备读取数据了；
- 内核将数据从硬盘或外部存储读取到内核缓冲区；
- 内核将数据从内核缓冲区拷贝到用户缓冲区；
- 应用程序读取用户缓冲区的数据进行处理加工；




![image.png](/static/img/56582b2e5463d365e1d88116d3b47bfb.image.webp)


##  磁盘缓冲区
磁盘缓冲区是计算机内存中用于暂存从磁盘读取的数据或将数据写入磁盘之前的临时存储区域。它是一种优化磁盘 I/O 操作的机制，通过利用内存的快速访问速度，减少对慢速磁盘的频繁访问，提高数据读取和写入的性能和效率。

## 读
- 首先应用程序向内核发起读请求，这时候进行一次模式切换了，从用户态切换到内核态；
- 内核向外部存储或网络套接字发起读操作；
- 将数据写入磁盘缓冲区；
- 系统内核将数据从磁盘缓冲区拷贝到内核缓冲区，顺便再将一份（或者一部分）拷贝到 PageCache；
- 内核将数据拷贝到用户缓冲区，供应用程序处理。此时又进行一次模态切换，从内核态切换回用户态；


## 写 
应用程序向内核发起写请求，这时候进行一次模式切换了，从用户态切换到内核态；
内核将要写入的数据从用户缓冲区拷贝到 PageCache，同时将数据拷贝到内核缓冲区；
然后内核将数据写入到磁盘缓冲区，从而写入磁盘，或者直接写入网络套接字。


## DMA直接内存访问
![image.png](/static/img/6de02dc1f7a1f9b972135613db8dd5fc.image.webp)

![image.png](/static/img/7c67a5f5786e1a8e63e497d946f859a2.image.webp)
![image.png](/static/img/3368d29942675ed058008cce9ceb6c29.image.webp)
## 共享内存

![image.png](/static/img/e7ffca187c44f92598655954d2a83de7.image.webp)

## sendfile
它的前两个参数分别是目的端和源端的文件描述符，后面两个参数是源端的偏移量和复制数据的长度，返回值是实际复制数据的长度。

首先，它可以替代前面的 read() 和 write() 这两个系统调用，这样就可以减少一次系统调用，也就减少了 2 次上下文切换的开销。



![image.png](/static/img/6b9ef872d6c03411d4575a1badd597e7.image.webp)

## 带有 scatter/gather 的 sendfile 方式
![image.png](/static/img/007d50369b8936add1f178d3d7be3607.image.webp)


![image.png](/static/img/bb611002caf10d021bd69de9d9bd5d60.image.webp)

```c
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    int source_fd = open("source_file.txt", O_RDONLY);
    if (source_fd == -1) {
        perror("Failed to open source file");
        exit(EXIT_FAILURE);
    }

    int destination_fd = open("destination_file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (destination_fd == -1) {
        perror("Failed to open destination file");
        exit(EXIT_FAILURE);
    }

    struct stat source_stat;
    if (fstat(source_fd, &source_stat) == -1) {
        perror("Failed to get source file information");
        exit(EXIT_FAILURE);
    }

    off_t offset = 0;
    ssize_t bytes_sent = sendfile(destination_fd, source_fd, &offset, source_stat.st_size);
    if (bytes_sent == -1) {
        perror("Failed to send file");
        exit(EXIT_FAILURE);
    }

    printf("Successfully sent %zd bytes\n", bytes_sent);

    close(source_fd);
    close(destination_fd);

    return 0;
}

```

参考:https://mp.weixin.qq.com/s/ULVCvSLIGvj3VtY5prtxGw

https://mp.weixin.qq.com/s/j1KjR5bRQV6oGrU5tsyHgg