yield request_state
    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)
    response.headers["custom"] = "foo"
    return response


@app.get("/user", dependencies=[Depends(set_up_request_state_dependency)])
def get_user():

            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),
                    request.getArtifact(),
                    request.getRemoteRepositories());
        }
    }

    private static <T> List<T> toList(Collection<T> items) {
        return (items != null) ? new ArrayList<>(items) : null;
    }

}

var decryptObjectMetaTests = []struct {
	info    ObjectInfo
	request *http.Request
	expErr  error
}{
	{
		info:    ObjectInfo{Size: 100},
		request: &http.Request{Header: http.Header{}},
		expErr:  nil,
	},
	{
		info:    ObjectInfo{Size: 100, UserDefined: map[string]string{crypto.MetaAlgorithm: crypto.InsecureSealAlgorithm}},

    }

    protected FormatType getFormatType(final HttpServletRequest request) {
        FormatType formatType = (FormatType) request.getAttribute(API_FORMAT_TYPE);
        if (formatType != null) {
            return formatType;
        }

        formatType = detectFormatType(request);
        request.setAttribute(API_FORMAT_TYPE, formatType);
        return formatType;
    }

  }

  @Test
  fun request() {
    val request: Request = Request.Builder().build()
    val isHttps: Boolean = request.isHttps
    val url: HttpUrl = request.url
    val method: String = request.method
    val headers: Headers = request.headers
    val header: String? = request.header("")
    val headersForName: List<String> = request.headers("")
    val body: RequestBody? = request.body

     */
    @Nonnull
    default DependencyResolverResult collect(@Nonnull DependencyResolverRequest request) {
        if (request.getRequestType() != DependencyResolverRequest.RequestType.COLLECT) {
            throw new IllegalArgumentException("requestType should be COLLECT when calling collect()");
        }
        return resolve(request);
    }

    /**
     * Flattens a list of nodes.

import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class PerCallSettings {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build()

    // Copy to customize OkHttp for this request.
    val client1 =
      client.newBuilder()

                MEDIA_TYPE_PNG))
        .build();

    Request request = new Request.Builder()
        .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)
        .url("https://api.imgur.com/3/image")
        .post(requestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

# Request Body

When you need to send data from a client (let's say, a browser) to your API, you send it as a **request body**.

A **request** body is data sent by the client to your API. A **response** body is the data your API sends to the client.

Your API almost always has to send a **response** body. But clients don't necessarily need to send **request bodies** all the time, sometimes they only request a path, maybe with some query parameters, but don't send a body.

import java.io.IOException;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class GetExample {
  final OkHttpClient client = new OkHttpClient();

  String run(String url) throws IOException {
    Request request = new Request.Builder()
        .url(url)
        .build();

    try (Response response = client.newCall(request).execute()) {
      return response.body().string();
    }
  }