// when it has been returned on a handler.
// This will disable automatic response recycling/pooling.
// Typically this is used when the response sharing part of its data structure.
func (h *SingleHandler[Req, Resp]) WithSharedResponse() *SingleHandler[Req, Resp] {
	h.sharedResp = true
	return h
}

// NewResponse creates a new response.

<img src="/img/deployment/https/https05.drawio.svg">

### HTTP Response { #http-response }

The application would process the request and send a **plain (unencrypted) HTTP response** to the TLS Termination Proxy.

<img src="/img/deployment/https/https06.drawio.svg">

### HTTPS Response { #https-response }

import org.opensearch.transport.client.Client;

/**
 * Abstract class representing a request that can be executed to produce a response.
 *
 * @param <T> the type of response produced by this request
 */
public abstract class Request<T extends Response> {
    /**
     * Constructs a new request.
     */
    public Request() {
        // nothing
    }

    /**
     * Executes the request.

        e.printStackTrace();
      }

      @Override public void onResponse(Call call, Response response) throws IOException {
        try (ResponseBody responseBody = response.body()) {
          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          Headers responseHeaders = response.headers();
          for (int i = 0, size = responseHeaders.size(); i < size; i++) {

        assertTrue(reqCap.getValue() instanceof NtTransNotifyChange, "SMB1 notify request must be used");
    }

    // If a response is not marked as received, throw a CIFSException
    @Test
    @DisplayName("watch() throws CIFSException when response not received")
    void watch_responseNotReceived_throwsCIFSException() throws Exception {
        NotifyResponse resp = mock(NotifyResponse.class);

            }
        });
        return response;
    }

    /**
     * Writes no-cache headers to the response.
     *
     * @param response the stream response
     * @param responseData the response data
     */
    protected void writeNoCache(final StreamResponse response, final ResponseData responseData) {
        response.header("Pragma", "no-cache");
        response.header("Cache-Control", "no-cache");

import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;
import org.codelibs.fess.opensearch.config.exentity.DuplicateHost;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin duplicate host management.
 * Provides RESTful API endpoints for managing duplicate host settings in the Fess search engine.

import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class SampleHttpClient {
  private final OkHttpClient client;

  public SampleHttpClient() {
    client = new OkHttpClient.Builder().build();
  }

  public void makeCall(HttpUrl url) throws IOException {
    try (Response response = client.newCall(new Request(url, Headers.EMPTY, "GET", null)).execute()) {

///

/// note | 技術細節

你也可以使用 `from starlette.requests import Request`。

**FastAPI** 為了方便開發者而提供了它，但實際上它直接來自 Starlette。

///

### 在 `response` 之前與之後 { #before-and-after-the-response }

你可以在任何*路徑操作*接收 `request` 之前，加入要執行的程式碼。

也可以在產生出 `response` 之後、回傳之前執行程式碼。

例如，你可以新增一個自訂標頭 `X-Process-Time`，其內容為處理請求並產生回應所花費的秒數：

{* ../../docs_src/middleware/tutorial001_py310.py hl[10,12:13] *}

/// tip

import org.codelibs.fess.util.RenderDataUtil;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;
import org.lastaflute.web.ruts.process.ActionRuntime;

import jakarta.annotation.Resource;

/**
 * Admin action for Boost Document management.
 *
 */