Un "middleware" es una función que trabaja con cada **request** antes de que sea procesada por cualquier *path operation* específica. Y también con cada **response** antes de devolverla.

* Toma cada **request** que llega a tu aplicación.
* Puede entonces hacer algo a esa **request** o ejecutar cualquier código necesario.
* Luego pasa la **request** para que sea procesada por el resto de la aplicación (por alguna *path operation*).

            return response.request
              .newBuilder()
              .header("Authorization", credential)
              .build()
          }
        },
      ).build()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://publicobject.com/secrets/hellosecret.txt")
        .build()

    client.newCall(request).execute().use { response ->

    }

    /**
     * Method read.
     *
     * @param reader a reader object.
     * @param strict a strict object.
     * @return Metadata
     * @throws IOException            IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *                                any.
     */
    public Metadata read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {

        )

    async def __call__(self, request: Request) -> Optional[str]:
        api_key = request.query_params.get(self.model.name)
        return self.check_api_key(api_key)


class APIKeyHeader(APIKeyBase):
    """
    API key authentication using a header.

    This defines the name of the header that should be provided in the request with

        // When
        MsrpcEnumerateAliasesInDomain request = new MsrpcEnumerateAliasesInDomain(mockDomainHandle, acctFlags, mockSamArray);

        // Then
        assertNotNull(request, "The request object should not be null.");
        assertEquals(mockDomainHandle, request.domain_handle, "The domain handle should be set correctly.");
        assertEquals(acctFlags, request.acct_flags, "The account flags should be set correctly.");

            @dev-productivity
      - name: Trigger a build
        uses: peter-evans/create-or-update-comment@v5
        if: ${{ steps.create-pull-request.outputs.pull-request-number }}
        with:
          issue-number: ${{ steps.create-pull-request.outputs.pull-request-number }}
          body: |
            @bot-gradle test ReadyForNightly
            ```
            stopGradleDaemons=true

	return op
}

// If trace is enabled, execute the request if it is traced by other handlers
// otherwise, generate a trace event with request information but no response.
func httpTracerMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Setup a http request response recorder - this is needed for
		// http stats requests and audit if enabled.

from fastapi import Body, FastAPI, HTTPException, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.routing import APIRoute


class ValidationErrorLoggingRoute(APIRoute):
    def get_route_handler(self) -> Callable:
        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:
            try:

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    for (int i = 0; i < 5; i++) {
      System.out.println("    Request: " + i);

      Request request = new Request.Builder()
          .url("https://api.github.com/search/repositories?q=http")
          .build();

      OkHttpClient clientForCall;
      if (i == 2) {

  private var client = clientTestRule.newClientBuilder().build()

  @StartStop
  private val server = MockWebServer()

  val request by lazy { Request(server.url("/")) }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {
        withContext(Dispatchers.IO) {
          assertThat(it.body.string()).isEqualTo("abc")