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




## 解法一：哈希表

假设最终的最大异或结果为 maxXOR，我们可以从最高位开始构建这个结果。我们使用一个掩码 mask 来构建当前位的前缀。初始时，mask 为 0。

对于每一位，我们通过遍历数组 nums，计算所有数的当前位前缀，然后将其加入一个集合 prefixes 中。集合 prefixes 存储了所有可能的当前位前缀。

接下来，我们假设当前位为 1，构建一个潜在的最大异或结果 potentialMax。我们通过将 maxXOR 的当前位设置为 1 来构建 potentialMax。例如，如果 maxXOR 的二进制表示为 1010，而当前位为第 3 位，那么 potentialMax 的二进制表示为 1110。

然后，我们遍历 prefixes 集合中的每个前缀 prefix。我们检查集合中是否存在一个前缀与 potentialMax ^ prefix 相等。这里的 ^ 是按位异或运算符。如果存在这样的前缀，说明最大异或结果的当前位可以为 1，我们更新 maxXOR 为 potentialMax，并跳出循环，继续处理下一位。如果不存在这样的前缀，则最大异或结果的当前位必须为 0，我们不需要更新 maxXOR，继续处理下一位。

通过这种方式，我们逐位确定了最大异或结果 maxXOR。最后，返回得到的 maxXOR 即为所求。

这种方法的时间复杂度为 O(32N) = O(N)，其中 N 是数组的长度。因为一个整数的二进制表示最多有 32 位，所以我们需要进行 32 次循环来确定最大异或结果的每一位。在每一次循环中，我们需要遍历数组 nums，计算当前位的前缀，所以时间复杂度为 O(N)。总的时间复杂度为 O(32N) = O(N)。这种方法的空间复杂度为 O(1)。
```cpp
class Solution {
public:
    int findMaximumXOR(vector<int>& nums) {
        int maxXOR = 0;
        int mask = 0;

        for (int i = 31; i >= 0; i--) {
            mask |= (1 << i);  // 构建当前位的掩码

            unordered_set<int> prefixes;  // 用于存储当前位前缀的集合

            for (int num : nums) {
                prefixes.insert(num & mask);  // 将当前位的前缀加入集合
            }

            int potentialMax = maxXOR | (1 << i);  // 假设当前位为 1

            for (int prefix : prefixes) {
                if (prefixes.count(potentialMax ^ prefix)) {
                    // 如果存在一个前缀与 potentialMax^prefix 相等
                    // 则最大异或值的当前位可以为 1
                    maxXOR = potentialMax;
                    break;
                }
            }
        }

        return maxXOR;
    }
};
```

## 解法二：trie树
我们定义了 TrieNode 类表示 Trie 树的节点。每个节点有两个子节点，分别表示当前位为 0 和 1 时的情况。

接下来，我们定义了 Trie 类表示 Trie 树。Trie 类有一个根节点，并提供了插入和查找最大异或值的方法。

在插入方法 insert 中，我们从当前数的最高位开始遍历，将每一位作为索引，根据当前位的值选择相应的子节点。如果子节点为空，我们创建一个新的节点。然后，将当前节点移动到下一位的子节点，继续进行插入操作。最终，将整个数的二进制表示插入 Trie 树中。

在查找最大异或值的方法 findMaxXOR 中，我们从当前数的最高位开始遍历，依次判断当前位的相反位是否存在。如果存在相反位，说明最大异或值的当前位可以为 1，我们将当前位的值设为 1，并将当前节点移动到相反位的子节点。如果不存在相反位，说明最大异或值的当前位必须为 0，我们将当前位的值设为 0，并将当前节点移动到当前位的子节点。通过这样的遍历，我们可以得到最大异或值。

```cpp
class Solution {
public:
    // Trie 节点
    class TrieNode {
    public:
        TrieNode* next[2];

        TrieNode() {
            next[0] = nullptr;
            next[1] = nullptr;
        }
    };

    // Trie 树
    class Trie {
    public:
        TrieNode* root;

        Trie() {
            root = new TrieNode();
        }

        void insert(int num) {
            TrieNode* curr = root;

            for (int i = 31; i >= 0; i--) {
                int bit = (num >> i) & 1;

                if (curr->next[bit] == nullptr) {
                    curr->next[bit] = new TrieNode();
                }

                curr = curr->next[bit];
            }
        }

        int findMaxXOR(int num) {
            int maxXOR = 0;
            TrieNode* curr = root;

            for (int i = 31; i >= 0; i--) {
                int bit = (num >> i) & 1;
                int oppositeBit = bit ^ 1;  // 获取与当前位相反的位

                if (curr->next[oppositeBit] != nullptr) {
                    maxXOR |= (1 << i);  // 如果存在相反位，则当前位可以为 1
                    curr = curr->next[oppositeBit];
                } else {
                    curr = curr->next[bit];
                }
            }

            return maxXOR;
        }
    };

    int findMaximumXOR(vector<int>& nums) {
        Trie trie;
        int maxXOR = 0;

        for (int num : nums) {
            trie.insert(num);
            int currXOR = trie.findMaxXOR(num);
            maxXOR = max(maxXOR, currXOR);
        }

        return maxXOR;
    }
};
```

每日一题11.4

![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>


```