Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opérations de chemin*.

Cela peut être utile, par exemple, pour retourner des en-têtes personnalisés ou des cookies.

## Renvoyer une `Response`

                            negoResp.getCommonCapabilities(), curSessId, token);

                    if (chain != null) {
                        request.chain((ServerMessageBlock2) chain);
                    }

                    request.setDigest(this.digest);
                    request.setSessionId(curSessId);

                    try {

# This workflow uses actions that are not certified by GitHub. They are provided
# by a third-party and are governed by separate terms of service, privacy
# policy, and support documentation.

name: Scorecard supply-chain security
on:
  # For Branch-Protection check. Only the default branch is supported. See
  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
  branch_protection_rule:

    /**
     * This method simply calls {@code negotiate( req, resp, false )}
     * and then {@code chain.doFilter}. You can override and call
     * negotiate manually to achive a variety of different behavior.
     */
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {

    private byte[] blob = null;

    /**
     * Constructs a session setup AndX response.
     *
     * @param config the configuration to use
     * @param andx the next command in the AndX chain, or null
     */
    public SmbComSessionSetupAndXResponse(final Configuration config, final ServerMessageBlock andx) {
        super(config, andx);
    }

    /**

 * ListenableFuture}</a>.
 *
 * <p>This class is GWT-compatible.
 *
 * <h3>Purpose</h3>
 *
 * <p>The main purpose of {@code ListenableFuture} is to help you chain together a graph of
 * asynchronous operations. You can chain them together manually with calls to methods like {@link
 * Futures#transform(ListenableFuture, com.google.common.base.Function, Executor) Futures.transform}

 * ListenableFuture}</a>.
 *
 * <p>This class is GWT-compatible.
 *
 * <h3>Purpose</h3>
 *
 * <p>The main purpose of {@code ListenableFuture} is to help you chain together a graph of
 * asynchronous operations. You can chain them together manually with calls to methods like {@link
 * Futures#transform(ListenableFuture, com.google.common.base.Function, Executor) Futures.transform}

 * ```
 *
 * As expected, this fails with a certificate pinning exception:
 *
 * ```java
 * javax.net.ssl.SSLPeerUnverifiedException: Certificate pinning failure!
 * Peer certificate chain:
 *     sha256/afwiKY3RxoMmLkuRW1l7QsPZTJPwDS2pdDROQjXw8ig=: CN=publicobject.com, OU=PositiveSSL
 *     sha256/klO23nT2ehFDXCfx3eHTDRESMz3asj1muO+4aIdjiuY=: CN=COMODO RSA Secure Server CA

      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            val request =
              chain!!
                .request()
                .newBuilder()
                .header("Host", "privateobject.com")
                .build()
            chain.proceed(request)
          },
        ).build()
    server.enqueue(MockResponse())

   */
  abstract fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags

  abstract operator fun <T : Any> get(key: KClass<T>): T?
}

/** An empty tags. This is always the tail of a [LinkedTags] chain. */
internal object EmptyTags : Tags() {
  override fun <T : Any> plus(
    key: KClass<T>,
    value: T?,
  ): Tags =
    when {
      value != null -> LinkedTags(key, value, this)
      else -> this
    }