你可以定义在返回响应后运行的后台任务。

这对需要在请求之后执行的操作很有用，但客户端不必在接收响应之前等待操作完成。

包括这些例子：

* 执行操作后发送的电子邮件通知：
    * 由于连接到电子邮件服务器并发送电子邮件往往很“慢”（几秒钟），您可以立即返回响应并在后台发送电子邮件通知。
* 处理数据：
    * 例如，假设您收到的文件必须经过一个缓慢的过程，您可以返回一个"Accepted"(HTTP 202)响应并在后台处理它。

## 使用 `BackgroundTasks` { #using-backgroundtasks }

首先导入 `BackgroundTasks` 并在 *路径操作函数* 中使用类型声明 `BackgroundTasks` 定义一个参数：

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}

 *       hunt through classes like {@link Arrays} and {@link Longs} for them.
 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarLongs().stream()...}.

  K get(int index) {
    return map.entrySet().asList().get(index).getKey();
  }

  @Override
  public void forEach(Consumer<? super K> action) {
    checkNotNull(action);
    map.forEach((k, v) -> action.accept(k));
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  // redeclare to help optimizers with b/310253115
  @SuppressWarnings("RedundantOverride")
  @Override
  @J2ktIncompatible

    }

    @Test
    @DisplayName("Should accept null dialect during construction")
    void testNullDialect() {
        // When/Then
        assertDoesNotThrow(() -> {
            Smb2EncryptionContext context = new Smb2EncryptionContext(1, null, testEncryptionKey, testDecryptionKey);
            assertNull(context.getDialect(), "Dialect should be null");
        }, "Should accept null dialect during construction");
    }

         * @param stream the {@link Consumer} to process the {@link Stream}
         */
        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);
            }
        }

        /**
         * Applies the given function to a stream created by the supplier and returns the result.
         * The stream is automatically closed after the function is applied.

// Or create a visible subclass for testing.
// For now, let's assume we can modify the original class slightly for testability,
// or we accept the less precise testToStringFormat test.

// Let's add a package-private helper to TransTransactNamedPipeResponse:
// String superToString() { return super.toString(); }
// And modify the test to use it.

Si una request entrante no se valida correctamente, se enviará un response `400`.

## `GZipMiddleware` { #gzipmiddleware }

Maneja responses GZip para cualquier request que incluya `"gzip"` en el header `Accept-Encoding`.

El middleware manejará tanto responses estándar como en streaming.

{* ../../docs_src/advanced_middleware/tutorial003_py310.py hl[2,6] *}

Se soportan los siguientes argumentos:

    return new ImmutableMapKeySet<>(this);
  }

  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {
    checkNotNull(action);
    for (Entry<K, V> entry : entries) {
      action.accept(entry.getKey(), entry.getValue());
    }
  }

  @Override
  boolean isHashCodeFast() {
    return true;
  }

  @Override
  public int hashCode() {
    return hashCode;
  }

        return createPathMatcher(baseDirectory, includes, null, false);
    }

    /**
     * Returns a filter for directories that may contain paths accepted by the given matcher.
     * The given path matcher should be an instance created by this service.
     * The path matcher returned by this method expects directory paths.

# ADR-0004 - Use a platform-oriented architecture for Gradle

## Status

- ACCEPTED on 2024-02-07

## Context

The Gradle code base is essentially a large monolith, without strong internal boundaries.
This has a number of negative effects on productivity, including:

- Unclear ownership of code.
- Difficult to focus on one particular area.
- Unintended coupling between areas of the code, including tests.

## Decision