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



利用层序遍历，每次都保存上一个节点指针。当且仅当prev不为null才更新next

```cpp
#include <queue>

struct Node {
    int val;
    Node* left;
    Node* right;
    Node* next;
};

Node* connect(Node* root) {
    if (root == nullptr) {
        return nullptr;
    }

    std::queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
        int levelSize = q.size();
        Node* prev = nullptr;

        for (int i = 0; i < levelSize; i++) {
            Node* node = q.front();
            q.pop();

            if (prev != nullptr) {
                prev->next = node;
            }

            prev = node;

            if (node->left != nullptr) {
                q.push(node->left);
            }
            if (node->right != nullptr) {
                q.push(node->right);
            }
        }
    }

    return root;
}
```

每日一题11.2

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



这题思路比较简单，我开始的思路是map<int,set<char>>,value是一个去重的set,后面就想着怎么优化。状态压缩，最后直接用一个int数组就好

```cpp
class Solution {
public:
    int countPoints(string rings) {
        int sticks[10] = {0}; // 数组大小为10，索引从0到9

        for (int i = 0; i < rings.length(); i += 2) {
            char color = rings[i];
            int stick = rings[i + 1] - '0';

            if (color == 'R') {
                sticks[stick] |= (1 << 0); // 设置最低位为1，表示红色
            } else if (color == 'G') {
                sticks[stick] |= (1 << 1); // 设置次低位为1，表示绿色
            } else if (color == 'B') {
                sticks[stick] |= (1 << 2); // 设置再次低位为1，表示蓝色
            }
        }

        int count = 0;
        for (int i = 0; i < 10; i++) {
            if (sticks[i] == 7) { // 7的二进制表示为111，表示三个颜色都存在
                count++;
            }
        }

        return count;
    }
};

```

每日一题11.3

![image.png](/static/img/540916a21af12278404b96976629edff.image.webp)
#### MapElement
```java
    protected abstract static class MapElement<T> {

        public final String name;
        public final T object;

        public MapElement(String name, T object) {
            this.name = name;
            this.object = object;
        }
    }




    // ------------
    
```
#### ContextVersion
```java
 protected static final class ContextVersion extends MapElement<Context> {
        public final String path;
        public final int slashCount;
        public final WebResourceRoot resources;
        public String[] welcomeResources;
        public MappedWrapper defaultWrapper = null;
        public MappedWrapper[] exactWrappers = new MappedWrapper[0];
        public MappedWrapper[] wildcardWrappers = new MappedWrapper[0];
        public MappedWrapper[] extensionWrappers = new MappedWrapper[0];
        public int nesting = 0;
        private volatile boolean paused;

        public ContextVersion(String version, String path, int slashCount, Context context, WebResourceRoot resources,
                String[] welcomeResources) {
            super(version, context);
            this.path = path;
            this.slashCount = slashCount;
            this.resources = resources;
            this.welcomeResources = welcomeResources;
        }

        public boolean isPaused() {
            return paused;
        }

        public void markPaused() {
            paused = true;
        }
    }

```

#### MappedHost
```java
protected static final class MappedHost extends MapElement<Host> {

        public volatile ContextList contextList;

        /**
         * Link to the "real" MappedHost, shared by all aliases.
         */
        private final MappedHost realHost;

        /**
         * Links to all registered aliases, for easy enumeration. This field is available only in the "real" MappedHost.
         * In an alias this field is <code>null</code>.
         */
        private final List<MappedHost> aliases;

        /**
         * Constructor used for the primary Host
         *
         * @param name The name of the virtual host
         * @param host The host
         */
        public MappedHost(String name, Host host) {
            super(name, host);
            realHost = this;
            contextList = new ContextList();
            aliases = new CopyOnWriteArrayList<>();
        }

        /**
         * Constructor used for an Alias
         *
         * @param alias    The alias of the virtual host
         * @param realHost The host the alias points to
         */
        public MappedHost(String alias, MappedHost realHost) {
            super(alias, realHost.object);
            this.realHost = realHost;
            this.contextList = realHost.contextList;
            this.aliases = null;
        }

        public boolean isAlias() {
            return realHost != this;
        }

        public MappedHost getRealHost() {
            return realHost;
        }

        public String getRealHostName() {
            return realHost.name;
        }

        public Collection<MappedHost> getAliases() {
            return aliases;
        }

        public void addAlias(MappedHost alias) {
            aliases.add(alias);
        }

        public void addAliases(Collection<? extends MappedHost> c) {
            aliases.addAll(c);
        }

        public void removeAlias(MappedHost alias) {
            aliases.remove(alias);
        }
    }

```


#### MappedContext
```java
    protected static final class MappedContext extends MapElement<Void> {
        public volatile ContextVersion[] versions;

        public MappedContext(String name, ContextVersion firstVersion) {
            super(name, null);
            this.versions = new ContextVersion[] { firstVersion };
        }
    }
    
```

#### MappedWarpper
```java
  protected static class MappedWrapper extends MapElement<Wrapper> {

        public final boolean jspWildCard;
        public final boolean resourceOnly;

        public MappedWrapper(String name, Wrapper wrapper, boolean jspWildCard, boolean resourceOnly) {
            super(name, wrapper);
            this.jspWildCard = jspWildCard;
            this.resourceOnly = resourceOnly;
        }
    }
    
```

这四个类是包含关系，一条链。

Mapper 的构建过程是在 MapperListener 中完成的， MapperListener 实现了 Tomcat 的生命周期接口，在 StandardService 启动的时候会调用 MapperListener 的 start 方法，这里会去构建 Mapper. MapperListener 也实现了 ContainerListener 和 LifecycleListener 接口，在发生容器事件和生命周期事件的时候，会往 Mapper 中添加或删除一些映射。


```java
@Override
public void containerEvent(ContainerEvent event) {
    // 处理容器事件的方法

    if (Container.ADD_CHILD_EVENT.equals(event.getType())) {
        // 如果是添加子容器事件
        Container child = (Container) event.getData();
        addListeners(child);
        // 如果子容器已经启动，则在这里注册子容器（根据子容器类型执行不同的注册操作）
        if (child.getState().isAvailable()) {
            if (child instanceof Host) {
                // 如果子容器是 Host 类型
                registerHost((Host) child);
            } else if (child instanceof Context) {
                // 如果子容器是 Context 类型
                registerContext((Context) child);
            } else if (child instanceof Wrapper) {
                // 如果子容器是 Wrapper 类型
                // 只有当 Context 已经启动时才注册 Wrapper
                if (child.getParent().getState().isAvailable()) {
                    registerWrapper((Wrapper) child);
                }
            }
        }
    } else if (Container.REMOVE_CHILD_EVENT.equals(event.getType())) {
        // 如果是移除子容器事件
        Container child = (Container) event.getData();
        removeListeners(child);
        // 不需要取消注册，生命周期监听器会在子容器停止时处理此操作
    } else if (Host.ADD_ALIAS_EVENT.equals(event.getType())) {
        // 如果是添加主机别名事件
        // 处理动态添加主机别名
        mapper.addHostAlias(((Host) event.getSource()).getName(), event.getData().toString());
    } else if (Host.REMOVE_ALIAS_EVENT.equals(event.getType())) {
        // 如果是移除主机别名事件
        // 处理动态移除主机别名
        mapper.removeHostAlias(event.getData().toString());
    } else if (Wrapper.ADD_MAPPING_EVENT.equals(event.getType())) {
        // 如果是添加映射事件
        // 处理动态添加映射器
        Wrapper wrapper = (Wrapper) event.getSource();
        Context context = (Context) wrapper.getParent();
        String contextPath = context.getPath();
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
        String version = context.getWebappVersion();
        String hostName = context.getParent().getName();
        String wrapperName = wrapper.getName();
        String mapping = (String) event.getData();
        boolean jspWildCard = ("jsp".equals(wrapperName) && mapping.endsWith("/*"));
        mapper.addWrapper(hostName, contextPath, version, mapping, wrapper, jspWildCard,
                context.isResourceOnlyServlet(wrapperName));
    } else if (Wrapper.REMOVE_MAPPING_EVENT.equals(event.getType())) {
        // 如果是移除映射事件
        // 处理动态移除映射器
        Wrapper wrapper = (Wrapper) event.getSource();
        Context context = (Context) wrapper.getParent();
        String contextPath = context.getPath();
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
        String version = context.getWebappVersion();
        String hostName = context.getParent().getName();
        String mapping = (String) event.getData();
        mapper.removeWrapper(hostName, contextPath, version, mapping);
    } else if (Context.ADD_WELCOME_FILE_EVENT.equals(event.getType())) {
        // 如果是添加欢迎文件事件
        // 处理动态添加欢迎文件
        Context context = (Context) event.getSource();
        String hostName = context.getParent().getName();
        String contextPath = context.getPath();
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
        String welcomeFile = (String) event.getData();
        mapper.addWelcomeFile(hostName, contextPath, context.getWebappVersion(), welcomeFile);
    } else if (Context.REMOVE_WELCOME_FILE_EVENT.equals(event.getType())) {
        // 如果是移除欢迎文件事件
        // 处理动态移除欢迎文件
        Context context = (Context) event.getSource();
        String hostName = context.getParent().getName();
        String contextPath = context.getPath();
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
        String welcomeFile = (String) event.getData();
        mapper.removeWelcomeFile(hostName, contextPath, context.getWebappVersion(), welcomeFile);
    } else if (Context.CLEAR_WELCOME_FILES_EVENT.equals(event.getType())) {
        // 如果是清除欢迎文件事件
        // 处理动态清除欢迎文件
        Context context = (Context) event.getSource();
        String hostName = context.getParent().getName();
        String contextPath = context.getPath();
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
       String version = context.getWebappVersion();
        mapper.clearWelcomeFiles(hostName, contextPath, version);
    }
}

```


## 注册容器方法

```java
private void registerHost(Host host) {
    // 获取主机的别名数组
    String[] aliases = host.findAliases();
    // 将主机和其别名添加到映射器中
    mapper.addHost(host.getName(), aliases, host);

    // 遍历主机的子容器
    for (Container container : host.findChildren()) {
        // 如果容器的状态可用，则注册上下文
        if (container.getState().isAvailable()) {
            registerContext((Context) container);
        }
    }

    // 默认主机可能已更改
    findDefaultHost();

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("mapperListener.registerHost", host.getName(), domain, service));
    }
}

/**
 * 注销主机。
 */
private void unregisterHost(Host host) {
    // 获取主机名称
    String hostname = host.getName();

    // 从映射器中移除主机
    mapper.removeHost(hostname);

    // 默认主机可能已更改
    findDefaultHost();

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("mapperListener.unregisterHost", hostname, domain, service));
    }
}

/**
 * 注销包装器。
 */
private void unregisterWrapper(Wrapper wrapper) {
    // 获取包装器所在的上下文和相关信息
    Context context = ((Context) wrapper.getParent());
    String contextPath = context.getPath();
    String wrapperName = wrapper.getName();

    // 如果上下文路径是根路径，将其设置为空字符串
    if ("/".equals(contextPath)) {
        contextPath = "";
    }
    String version = context.getWebappVersion();
    String hostName = context.getParent().getName();

    // 获取包装器的映射路径数组
    String[] mappings = wrapper.findMappings();

    // 遍历映射路径数组，从映射器中移除对应的映射
    for (String mapping : mappings) {
        mapper.removeWrapper(hostName, contextPath, version, mapping);
    }

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("mapperListener.unregisterWrapper", wrapperName, contextPath, service));
    }
}

/**
 * 注册上下文。
 */
private void registerContext(Context context) {
    // 获取上下文路径
    String contextPath = context.getPath();
    // 如果上下文路径是根路径，将其设置为空字符串
    if ("/".equals(contextPath)) {
        contextPath = "";
    }
    Host host = (Host) context.getParent();

    // 获取上下文的资源、欢迎文件和包装器列表
    WebResourceRoot resources = context.getResources();
    String[] welcomeFiles = context.findWelcomeFiles();
    List<WrapperMappingInfo> wrappers = new ArrayList<>();

    // 遍历上下文的子容器
    for (Container container : context.findChildren()) {
        // 准备包装器的映射信息，并添加到包装器列表中
        prepareWrapperMappingInfo(context, (Wrapper) container, wrappers);

        if (log.isDebugEnabled()) {
            log.debug(sm.getString("mapperListener.registerWrapper", container.getName(), contextPath, service));
        }
    }

    // 将上下文和相关信息添加到映射器中
    mapper.addContextVersion(host.getName(), host, contextPath, context.getWebappVersion(), context, welcomeFiles,
            resources, wrappers);

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("mapperListener.registerContext", contextPath, service));
    }
}

/**
 * 注销上下文。
 */
private void unregisterContext(Context context) {
    // 获取上下文路径
    String contextPath = context.getPath();
    // 如果上下文路径是根路径，将其设置为空字符串
    if ("/".equals(contextPath)) {
        contextPath = "";
    }
    String hostName = context.getParent().getName();

    // 如果上下文已暂停，暂停上下文的版本；否则从映射器中移除上下文的版本
    if (context.getPaused()) {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("mapperListener.pauseContext", contextPath, service));
        }
        mapper.pauseContextVersion(context, hostName, contextPath, context.getWebappVersion());
    } else {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("mapperListener.unregisterContext", contextPath, service));
        }
        mapper.removeContextVersion(context, hostName, contextPath, context.getWebappVersion());
    }
}

/**
 * 注册包装器。
 */
private void registerWrapper(Wrapper wrapper) {
    // 获取包装器所在的上下文、上下文路径、版本和主机名称
    Context context = ((Context) wrapper.getParent());
    String contextPath = context.getPath();
    String version = context.getWebappVersion();
    String hostName = context.getParent().getName();

    // 准备包装器的映射信息，并添加到映射器中
    List<WrapperMappingInfo> mappingInfoList = new ArrayList<>();
    prepareWrapperMappingInfo(context, wrapper, mappingInfoList);
    mapper.addWrappers(hostName, contextPath, version, mappingInfoList);

    if (log.isDebugEnabled()) {
        log.debug(sm.getString("mapperListener.registerWrapper", wrapper.getName(), contextPath, service));
    }
}

```

registerHost(Host host) 方法：

- 获取主机的别名（aliases）数组。
- 调用mapper.addHost()方法，将主机和其别名添加到映射器（mapper）中。
- 遍历主机的子容器，如果容器的状态是可用的，则调用registerContext()方法，注册上下文（Context）。


unregisterHost(Host host) 方法：

- 获取主机的名称。
- 调用mapper.removeHost()方法，从映射器中移除主机。
- 调用findDefaultHost()方法，找到默认的主机。


unregisterWrapper(Wrapper wrapper) 方法：

- 获取包装器所在的上下文（Context）和相关信息。
- 遍历包装器的映射路径（mappings），调用mapper.removeWrapper()方法，从映射器中移除相应的映射。


registerContext(Context context) 方法：

- 获取上下文的路径（contextPath）。
- 如果上下文路径是根路径"/"，则将其设置为空字符串。
- 获取上下文的父级主机（Host）。
- 获取上下文的资源（WebResourceRoot）、欢迎文件（welcomeFiles）和包装器（Wrapper）列表。
- 遍历上下文的子容器，调用prepareWrapperMappingInfo()方法，准备包装器的映射信息，并将它们添加到包装器列表中。
- 调用mapper.addContextVersion()方法，将上下文和相关信息添加到映射器中。


unregisterContext(Context context) 方法：

- 获取上下文的路径（contextPath）。
- 如果上下文路径是根路径"/"，则将其设置为空字符串。
- 获取上下文的父级主机的名称。
- 如果上下文已暂停，调用mapper.pauseContextVersion()方法，暂停上下文的版本。
- 否则，调用mapper.removeContextVersion()方法，从映射器中移除上下文的版本。


registerWrapper(Wrapper wrapper) 方法：

- 获取包装器所在的上下文、上下文路径、版本和主机名称。
- 创建一个包装器映射信息的列表。
- 调用prepareWrapperMappingInfo()方法，准备包装器的映射信息，并将其添加到列表中。
- 调用mapper.addWrappers()方法，将包装器的映射信息添加到映射器中。

Tomcat源码学习7 --Mapper

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

## 容器的层次结构

Tomcat 设计了 4 种容器，分别是 Engine、Host、Context 和 Wrapper。这 4 种容器不是平行关系，而是父子关系。




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

你可以再通过 Tomcat 的 server.xml 配置文件来加深对 Tomcat 容器的理解。Tomcat 采用了组件化的设计，它的构成组件都是可配置的，其中最外层的是 Server，其他组件按照一定的格式要求配置在这个顶层容器中。


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

## Container接口
```cpp
public interface Container extends Lifecycle {
    public void setName(String name);
    public Container getParent();
    public void setParent(Container container);
    public void addChild(Container child);
    public void removeChild(Container child);
    public Container findChild(String name);
}


```

所有容器组件都实现了 Container 接口，因此组合模式可以使得用户对单容器对象和组合容器对象的使用具有一致性。这里单容器对象指的是最底层的 Wrapper，组合容器对象指的是上面的 Context、Host 或者 Engine。Container 接口定义如下：

Mapper 组件的功能就是将用户请求的 URL 定位到一个 Servlet，它的工作原理是：Mapper 组件里保存了 Web 应用的配置信息，其实就是容器组件与访问路径的映射关系，比如 Host 容器里配置的域名、Context 容器里的 Web 应用路径，以及 Wrapper 容器里 Servlet 映射的路径，你可以想象这些配置信息就是一个多层次的 Map。

当一个请求到来时，Mapper 组件通过解析请求 URL 里的域名和路径，再到自己保存的 Map 里去查找，就能定位到一个 Servlet。请你注意，一个请求 URL 最后只会定位到一个 Wrapper 容器，也就是一个 Servlet。

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


并不是说只有 Servlet 才会去处理请求，实际上这个查找路径上的父子容器都会对请求做一些处理。我在上一期说过，连接器中的 Adapter 会调用容器的 Service 方法来执行 Servlet，最先拿到请求的是 Engine 容器，Engine 容器对请求做一些处理后，会把请求传给自己子容器 Host 继续处理，依次类推，最后这个请求会传给 Wrapper 容器，Wrapper 会调用最终的 Servlet 来处理。


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

Wrapper 容器的最后一个 Valve 会创建一个 Filter 链，并调用 doFilter() 方法，最终会调到 Servlet 的 service 方法。


## Filter和Value区别
Valve 是 Tomcat 的私有机制，与 Tomcat 的基础架构 /API 是紧耦合的。Servlet API 是公有的标准，所有的 Web 容器包括 Jetty 都支持 Filter 机制。

另一个重要的区别是 Valve 工作在 Web 容器级别，拦截所有应用的请求；而 Servlet Filter 工作在应用级别，只能拦截某个 Web 应用的所有请求。如果想做整个 Web 容器的拦截器，必须通过 Valve 来实现。

## 一个初始的server.xml

```xml
<?xml version="1.0" encoding="UTF-8"?>


<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  
  
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

  
  <GlobalNamingResources>
    
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>

  
  <Service name="Catalina">

    
    


    
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />
    
    
    
    

    
    

    

    
    <Engine name="Catalina" defaultHost="localhost">

      
      

      
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

        
        

        
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />

      </Host>
    </Engine>
  </Service>
</Server>


```

Tomcat源码学习6 --容器

## 总体架构
Tomcat 要实现 2 个核心功能：

- 处理 Socket 连接，负责网络字节流与 Request 和 Response 对象的转化。
- 加载和管理 Servlet，以及具体处理 Request 请求。

因此 Tomcat 设计了两个核心组件连接器（Connector）和容器（Container）来分别做这两件事情。连接器负责对外交流，容器负责内部处理。




## Tomcat支持的IO模型
#### Tomcat 支持的 I/O 模型有：

- NIO：非阻塞 I/O，采用 Java NIO 类库实现。

- NIO2：异步 I/O，采用 JDK 7 最新的 NIO2 类库实现。

- APR：采用 Apache 可移植运行库实现，是 C/C++ 编写的本地库。


#### Tomcat 支持的应用层协议有：

- HTTP/1.1：这是大部分 Web 应用采用的访问协议。

- AJP：用于和 Web 服务器集成（如 Apache）。

- HTTP/2：HTTP 2.0 大幅度的提升了 Web 性能。


Tomcat 为了实现支持多种 I/O 模型和应用层协议，一个容器可能对接多个连接器，就好比一个房间有多个门。但是单独的连接器或者容器都不能对外提供服务，需要把它们组装起来才能工作，组装后这个整体叫作 Service 组件。这里请你注意，Service 本身没有做什么重要的事情，只是在连接器和容器外面多包了一层，把它们组装在一起。Tomcat 内可能有多个 Service，这样的设计也是出于灵活性的考虑。通过在 Tomcat 中配置多个 Service，可以实现通过不同的端口号来访问同一台机器上部署的不同应用。



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

从图上你可以看到，最顶层是 Server，这里的 Server 指的就是一个 Tomcat 实例。一个 Server 中有一个或者多个 Service，一个 Service 中有多个连接器和一个容器。连接器与容器之间通过标准的 ServletRequest 和 ServletResponse 通信。

连接器对 Servlet 容器屏蔽了协议及 I/O 模型等的区别，无论是 HTTP 还是 AJP，在容器中获取到的都是一个标准的 ServletRequest 对象。

我们可以把连接器的功能需求进一步细化，比如：

- 监听网络端口。

- 接受网络连接请求。

- 读取请求网络字节流。

- 根据具体应用层协议（HTTP/AJP）解析字节流，生成统一的 Tomcat Request 对象。

- 将 Tomcat Request 对象转成标准的 ServletRequest。

- 调用 Servlet 容器，得到 ServletResponse。

- 将 ServletResponse 转成 Tomcat Response 对象。
 
- 将 Tomcat Response 转成网络字节流。

- 将响应字节流写回给浏览器。

需求列清楚后，我们要考虑的下一个问题是，连接器应该有哪些子模块？优秀的模块化设计应该考虑高内聚、低耦合。

- 高内聚是指相关度比较高的功能要尽可能集中，不要分散。

- 低耦合是指两个相关的模块要尽可能减少依赖的部分和降低依赖的程度，不要让两个模块产生强依赖。

需要实现的功能

- 网络通信。

- 应用层协议解析。

- Tomcat Request/Response 与 ServletRequest/ServletResponse 的转化。

因此 Tomcat 的设计者设计了 3 个组件来实现这 3 个功能，分别是 EndPoint、Processor 和 Adapter。

由于 I/O 模型和应用层协议可以自由组合，比如 NIO + HTTP 或者 NIO2 + AJP。Tomcat 的设计者将网络通信和应用层协议解析放在一起考虑，设计了一个叫 ProtocolHandler 的接口来封装这两种变化点。各种协议和通信模型的组合有相应的具体实现类。比如：Http11NioProtocol 和 AjpNioProtocol。

连接器模块用三个核心组件：Endpoint、Processor 和 Adapter 来分别做三件事情，其中 Endpoint 和 Processor 放在一起抽象成了 ProtocolHandler 组件，它们的关系如下图所示。
![image.png](/static/img/3d643d7c8564fbdcfa7fdb2accbaf424.image.webp)


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

### 连接器组件图

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