request.url(url)

  data?.let {
    request.method(requestMethod, it.toRequestBody(mediaType()))
  }

  for (header in headers.orEmpty()) {
    val parts = header.split(':', limit = 2)
    if (!isSpecialHeader(parts[0])) {
      request.header(parts[0], parts[1])
    }
  }
  referer?.let {
    request.header("Referer", it)
  }
  request.header("User-Agent", userAgent)

  return request.build()
}

private fun sendRequest(
  client: OkHttpClient,
  url: String,
) {
  System.out.printf("%-40s ", url)
  System.out.flush()
  println(Platform.get())
  val request =
    Request.Builder()
      .url(url)
      .build()
  try {
    client.newCall(request).execute().use { response ->
      val handshake = response.handshake
      println(
        "${handshake!!.tlsVersion} ${handshake.cipherSuite} ${response.protocol} " +

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

        async def custom_route_handler(request: Request) -> Response:
            request = GzipRequest(request.scope, request.receive)
            return await original_route_handler(request)

        return custom_route_handler


app = FastAPI()
app.router.route_class = GzipRoute


@app.post("/sum")

        });
        try {
            badWordService.store(entity);
            suggestHelper.addBadWord(entity.getSuggestWord(), false);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public interface WebApiManager {

    boolean matches(HttpServletRequest request);

    void process(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;

/**
 * The handler of multipart request (fileupload request). <br>
 * This instance is created per one multipart request.
 * @author modified by jflute (originated in Seasar)
 */
public class FessMultipartRequestHandler implements MultipartRequestHandler {

You could create an API with a *path operation* that could trigger a request to an *external API* created by someone else (probably the same developer that would be *using* your API).

The process that happens when your API app calls the *external API* is named a "callback". Because the software that the external developer wrote sends a request to your API and then your API *calls back*, sending a request to an *external API* (that was probably created by the same developer).

                default:
                    throw new SmbException( "Invalid operation for " + service + " service" + request );
            }
        }
        request.tid = tid;
        if( inDfs && !service.equals("IPC") && request.path != null && request.path.length() > 0 ) {
            /* When DFS is in action all request paths are
             * full UNC paths minus the first backslash like
             *   \server\share\path\to\file

import okhttp3.DelegatingSocketFactory
import okhttp3.MediaType
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol.HTTP_1_1
import okhttp3.RecordingEventListener
import okhttp3.Request
import okhttp3.RequestBody
import okhttp3.SimpleProvider
import okhttp3.internal.http.CancelTest.CancelMode.CANCEL
import okhttp3.internal.http.CancelTest.CancelMode.INTERRUPT

        try {
            userService.store(entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }