// Jetty 10 version
public class MyWebSocket implements WebSocketListener {
  @Override
  public void onWebSocketBinary(byte[] arg0, int arg1, int arg2) {
  }

  @Override
  public void onWebSocketClose(int code, String reason) {
  }

  @Override
  public void onWebSocketConnect(Session session) {
  }

  @Override
  public void onWebSocketError(Throwable arg0) {
  }

  @Override
  public void onWebSocketText(String payload) {
  }
}

// Jetty 12 version
@WebSocket
public class MyWebSocket {
  @OnWebSocketClose
  public void onWebSocketClose(int code, String reason) {
  }

  @OnWebSocketOpen
  public void onWebSocketOpen(Session session) {
  }

  @OnWebSocketError
  public void onWebSocketError(Throwable arg0) {
  }

  @OnWebSocketMessage
  public void onWebSocketText(String payload) {
  }
}

// Jetty 10 version
public class WebSocketController extends JettyWebSocketServlet {
  @Override
  public void configure(JettyWebSocketServletFactory factory) {
    factory.setIdleTimeout(timeout);
    factory.addMapping("/websocket", new JettyWebSocketCreator() {
      @Override
      public Object createWebSocket(JettyServerUpgradeRequest servletUpgradeRequest, JettyServerUpgradeResponse servletUpgradeResponse) {
        // do some other stuff here for XSRF
        return new MyWebSocket();
      }
    });
  }
}

// Jetty 12 version
public class WebSocketController extends JettyWebSocketServlet {
  @Override
  protected void configure(JettyWebSocketServletFactory factory) {
    // Be very idle
    factory.setIdleTimeout(timeout);
    factory.addMapping("/websocket", (servletUpgradeRequest, servletUpgradeResponse) -> {
      // do some other stuff here for XSRF
      return new Socket();
    });
  }
}

HttpConfiguration config = new HttpConfiguration();
UriCompliance compliance = UriCompliance.from(
  EnumSet.of(
    // Allow more PATH violations
    UriCompliance.Violation.SUSPICIOUS_PATH_CHARACTERS,
    UriCompliance.Violation.ILLEGAL_PATH_CHARACTERS,
    // Below is from UriCompliance.LEGACY
    UriCompliance.Violation.AMBIGUOUS_PATH_SEGMENT,
    UriCompliance.Violation.AMBIGUOUS_PATH_SEPARATOR,
    UriCompliance.Violation.AMBIGUOUS_PATH_ENCODING,
    UriCompliance.Violation.AMBIGUOUS_EMPTY_SEGMENT,
    UriCompliance.Violation.UTF16_ENCODINGS,
    UriCompliance.Violation.USER_INFO));
config.setUriCompliance(compliance);

// This is linked to UriCompliance.LEGACY above to allow 
// AMBIGUOUS_PATH_ENCODING with Servlet 6 for retro-compatibility
// server is org.eclipse.jetty.server.Server
server.getContainedBeans(ServletHandler.class).forEach(h -> 
  h.setDecodeAmbiguousURIs(true));

public class EmptySegmentRewriteHandler extends Handler.Wrapper {
    public EmptySegmentRewriteHandler(Handler handler) {
        super(handler);
    }

    @Override
    public boolean handle(Request request, Response response, Callback callback) throws Exception {
        if (request.getHttpURI().hasViolation(UriCompliance.Violation.AMBIGUOUS_EMPTY_SEGMENT)) {
            request = rewriteRequest(request);
        }
        return super.handle(request, response, callback);
    }

    Request rewriteRequest(Request request) {
        HttpURI rewrite = rewriteHttpURL(request);
        return Request.serveAs(request, rewrite);
    }

    private HttpURI rewriteHttpURL(Request base) {
        String param = base.getHttpURI().getParam();
        String query = base.getHttpURI().getQuery();
        List<String> segments = Arrays
                .stream(base.getHttpURI().getPath().split("/"))
                .filter(v -> !v.isEmpty())
                .toList();
        String newPath = "/" + StringUtils.join(segments, "/");

        return HttpURI.build(base.getHttpURI(), newPath, param, query).asImmutable();
    }
}

package com.example;

import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.apache.commons.io.IOUtils;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.EntityTemplate;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.client.OutputStreamRequestContent;
import org.eclipse.jetty.io.Content;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.util.Callback;
import org.junit.jupiter.api.Test;

class JettyServerWithClientTest {
  private static Server createServer() {
    Server server = new Server(5555);
    server.setHandler(new Handler.Abstract() {
      @Override
      public boolean handle(Request request, Response response, Callback callback) throws IOException {
        response.setStatus(200);
        response.getHeaders().add("Content-Type", "application/json;charset=utf-8");
        String content = "{}";
        ByteBuffer buffer = ByteBuffer.wrap(content.getBytes(StandardCharsets.UTF_8));
        // Consuming the request makes the  client works
        // IOUtils.consume(Content.Source.asInputStream(request));
        response.write(true, buffer, callback);
        return true;
      }
    });

  return server;
}

@Test
public void testJettyClient() throws Exception {
  var port = startServer();
  var url = "http://localhost:" + port + "/";

  try (HttpClient httpClient = new HttpClient()) {
      httpClient.start();
      for (int i = 0; i < 1000000; i++) {
        OutputStreamRequestContent content = new OutputStreamRequestContent();
        httpClient.POST(url)
          .body(content)
          .send(result -> {
          });
        try (OutputStream output = content.getOutputStream()) {
          output.write("{}".getBytes());
        }
      }
    }
  }

  private static Integer startServer() throws InterruptedException, ExecutionException {
    CompletableFuture<Integer> future = new CompletableFuture<>();
    var t = new Thread(() -> {
      try {
        var server = createServer();
        server.start();
        var port = ((ServerConnector) server.getConnectors()[0]).getLocalPort();
        future.complete(port);
        server.join();
      } catch (Exception e) {
          throw new RuntimeException(e);
      }
  });
    t.start();
    return future.get();
  }


  @Test
  public void testApacheHttpClient4() throws Exception {
    var port = startServer();

    var httpClient = HttpClients.createDefault();
    var url = "http://localhost:" + port + "/";

    for (int i = 0; i < 1000000; i++) {
      var post = new HttpPost(url);
      var entity = new EntityTemplate(outputStream -> {
          outputStream.write("{}".getBytes());
          outputStream.flush();
      });
      entity.setContentType(ContentType.APPLICATION_JSON.toString());
      post.setEntity(entity);
      var resp = httpClient.execute(post);
      try {
          assert resp.getStatusLine().getStatusCode() == 200;
          assert "{}".equals(IOUtils.toString(resp.getEntity().getContent(), StandardCharsets.UTF_8));
      } finally {
          EntityUtils.consume(resp.getEntity());
      }
    }
  }
}