下面列出了怎么用org.eclipse.jetty.server.handler.AbstractHandler的API类实例代码及写法,或者点击链接到github查看源代码。
public static void main(String[] args) throws Exception {
OptionsParser parser = new OptionsParser(args);
final int port = Integer.parseInt(parser.getOptionValue(SubmitOption.PORT));
final String[] mainArgs = new String[]{FullyRemoteJdbcMetaFactory.class.getName()};
HttpServer server = Main.start(mainArgs, port, new HandlerFactory() {
@Override
public AbstractHandler createHandler(Service service) {
return new AvaticaJsonHandler(service);
}
});
InetAddress address = InetAddress.getLocalHost();
String hostName = "localhost";
if (address != null) {
hostName = StringUtils.isNotBlank(address.getHostName()) ? address.getHostName() : address
.getHostAddress();
}
String url = Driver.CONNECT_STRING_PREFIX + "url=http://" + hostName + ":" + server.getPort();
System.out.println("Quicksql server started, Please connect : " + url);
server.join();
}
@Override
public void start() throws Exception {
sessionService = BeanHelper.getServiceBean(SessionService.class);
requestService = BeanHelper.getServiceBean(RequestService.class);
accountSysService = BeanHelper.getServiceBean(AccountSysService.class);
Handler entranceHandler = new AbstractHandler(){
@Override
public void handle(String target, Request baseRequest,
HttpServletRequest request, HttpServletResponse response) throws IOException {
fire(request,response,"EntranceJetty");
}
};
server = new Server(this.port);
server.setHandler(entranceHandler);
server.start();
}
private LegacyHttpServer(int port, int threads) {
this.server = new Server(new QueuedThreadPool(threads));
server.setHandler(
new AbstractHandler() {
@Override
public void handle(
String target,
Request baseRequest,
HttpServletRequest request,
HttpServletResponse response)
throws IOException {
final String method = baseRequest.getParameter("method");
if ("helloworld.Greeter/SayHello".equals(method)) {
baseRequest.setHandled(true);
sayHello(baseRequest, response);
}
}
});
final ServerConnector connector = new ServerConnector(server);
connector.setPort(port);
server.addConnector(connector);
}
public static void startDestinationServer(String responseContent) {
DESTINATION_SERVER.setHandler(
new AbstractHandler() {
@Override
public void handle(String path,
Request request,
HttpServletRequest httpRequest,
HttpServletResponse response) throws IOException {
response.setHeader("Content-Type", "text/plain");
response.setHeader("X-Via", request.getHeader("X-Via"));
try (PrintWriter writer = response.getWriter()) {
writer.println(responseContent);
}
}
});
try {
DESTINATION_SERVER.start();
}
catch (Exception e) {
throw new RuntimeException("Failed to start destination server", e);
}
}
@BeforeClass
public static void beforeClass() throws Exception {
final String[] mainArgs = new String[] { FullyRemoteJdbcMetaFactory.class.getName() };
// Bind to '0' to pluck an ephemeral port instead of expecting a certain one to be free
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 2; i++) {
if (sb.length() > 0) {
sb.append(",");
}
HttpServer jsonServer = Main.start(mainArgs, 0, new HandlerFactory() {
@Override public AbstractHandler createHandler(Service service) {
return new AvaticaJsonHandler(service);
}
});
ACTIVE_SERVERS.add(jsonServer);
sb.append("http://localhost:").append(jsonServer.getPort());
}
url = AlternatingDriver.PREFIX + "url=" + sb.toString();
}
private ContextHandler mockConfigServerHandler(final int statusCode, final ApolloConfig result,
final boolean failedAtFirstTime) {
ContextHandler context = new ContextHandler("/configs/*");
context.setHandler(new AbstractHandler() {
AtomicInteger counter = new AtomicInteger(0);
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
if (failedAtFirstTime && counter.incrementAndGet() == 1) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
baseRequest.setHandled(true);
return;
}
response.setContentType("application/json;charset=UTF-8");
response.setStatus(statusCode);
response.getWriter().println(gson.toJson(result));
baseRequest.setHandled(true);
}
});
return context;
}
public static Pair<Server, Integer> runHttpServer(Map<String, Object> jars) throws Exception {
final Server server = new Server();
final ServerConnector connector = new ServerConnector(server);
server.setConnectors(new Connector[] { connector });
server.setHandler(new AbstractHandler() {
@Override
public void handle(String s, Request request, HttpServletRequest req, HttpServletResponse rsp)
throws IOException {
ByteBuffer b = (ByteBuffer) jars.get(s);
if (b != null) {
rsp.getOutputStream().write(b.array(), 0, b.limit());
rsp.setContentType("application/octet-stream");
rsp.setStatus(HttpServletResponse.SC_OK);
request.setHandled(true);
}
}
});
server.start();
return new Pair<>(server, connector.getLocalPort());
}
@Before
public void initializeCollector() throws Exception {
Server server = new Server();
connector = new AbstractConnector(server, null, null, null, 0) {
@Override
protected void accept(int acceptorID) throws IOException, InterruptedException {
}
@Override
public Object getTransport() {
return null;
}
};
collector.setHandler(new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
baseRequest.setHandled(true);
baseRequest.getResponse().setStatus(httpResponseCode);
}
});
server.setHandler(collector);
server.start();
}
public static void run() throws Exception {
server.setHandler(new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
target = target.substring(1);
if (isHandled(target)) {
count(target);
response.setContentType("text/html;charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
baseRequest.setHandled(true);
response.getWriter().println(target);
} else {
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
baseRequest.setHandled(true);
}
}
});
server.start();
}
public static void main(final String[] args) throws Exception {
final Server server = new Server(Integer.valueOf(args[0]));
final SRLParser parser = makeParser(args[1]);
server.setHandler(new AbstractHandler() {
@Override
public void handle(final String target, final Request baseRequest, final HttpServletRequest request,
final HttpServletResponse response) throws IOException, ServletException {
final String sentence = baseRequest.getParameter("sentence");
response.setContentType("text/html; charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
doParse(parser, sentence, response.getWriter());
baseRequest.setHandled(true);
}
});
server.start();
server.join();
}
@BeforeAll
void startJetty() throws Exception {
jetty = new org.eclipse.jetty.server.Server(0);
jetty.setHandler(new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
if (Collections.list(request.getHeaders("host")).size() == 1) {
response.setStatus(HttpStatus.OK.code());
} else {
response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.code());
}
baseRequest.setHandled(true);
}
});
jetty.start();
}
public static void main(String[] args) throws Exception {
// http://docs.codehaus.org/display/JETTY/Embedding+Jetty
int port = 8887;
Server server = new Server(port);
final ProxyServlet servlet = new ProxyServlet();
server.setHandler(new AbstractHandler() {
public void handle(
String target, Request baseRequest, HttpServletRequest req,
HttpServletResponse resp)
throws ServletException {
try {
servlet.service(req, resp);
} catch (IOException e) {
throw (ServletException) new ServletException().initCause(e);
}
}
});
server.start();
}
private ContextHandler systemRestart() {
AbstractHandler system = new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest,
HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
restartContexts();
response.setContentType("text/html;charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
baseRequest.setHandled(true);
response.getWriter().println("<h1>Done</h1>");
}
};
ContextHandler context = new ContextHandler();
context.setContextPath("/vraptor/restart");
context.setResourceBase(".");
context.setClassLoader(Thread.currentThread().getContextClassLoader());
context.setHandler(system);
return context;
}
/**
* Creates an {@link AbstractHandler handler} returning an arbitrary String as a response.
*
* @return never <code>null</code>.
*/
public Handler getMockHandler() {
Handler handler = new AbstractHandler() {
//@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
setRequestBody(IOUtils.toString(baseRequest.getInputStream()));
response.setStatus(getStatus());
response.setContentType(getContentType());
byte[] body = getResponseBody();
response.setContentLength(body.length);
IOUtils.write(body, response.getOutputStream());
baseRequest.setHandled(true);
}
};
return handler;
}
private Handler buildSettingsHandler() {
final String responseTemplate = "var Gobblin = window.Gobblin || {};" + "Gobblin.settings = {restServerUrl:\"%s\", hideJobsWithoutTasksByDefault:%s, refreshInterval:%s}";
return new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
if (request.getRequestURI().equals("/js/settings.js")) {
response.setContentType("application/javascript");
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println(String.format(responseTemplate, AdminWebServer.this.restServerUri.toString(),
AdminWebServer.this.hideJobsWithoutTasksByDefault, AdminWebServer.this.refreshInterval));
baseRequest.setHandled(true);
}
}
};
}
/** Create a Jetty handler that expects a request with a given content body. */
private AbstractHandler createHandlerThatExpectsContent(String expected) {
return new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
String body = request.getReader().lines().collect(Collectors.joining());
if (validateRequest(request) && body.equals(expected)) {
response.setStatus(HttpServletResponse.SC_OK);
} else {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
baseRequest.setHandled(true);
}
};
}
static void register(String route, AbstractHandler handler) {
ContextHandler context = new ContextHandler();
context.setContextPath(route);
context.setResourceBase(".");
context.setClassLoader(Thread.currentThread().getContextClassLoader());
context.setHandler(handler);
CONTEXTS.add(context);
}
@BeforeEach
void setUp() throws Exception {
server = new Server();
Path keyStorePath = Paths.get(ReporterFactoryTest.class.getResource("/keystore").toURI());
final SslContextFactory sslContextFactory = new SslContextFactory(keyStorePath.toAbsolutePath().toString());
sslContextFactory.setKeyStorePassword("password");
sslContextFactory.getSslContext();
final HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.setSecureScheme("https");
httpConfiguration.setSecurePort(0);
final HttpConfiguration httpsConfiguration = new HttpConfiguration(httpConfiguration);
httpsConfiguration.addCustomizer(new SecureRequestCustomizer());
final ServerConnector httpsConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(httpsConfiguration));
httpsConnector.setPort(0);
server.addConnector(httpsConnector);
server.setHandler(new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) {
baseRequest.setHandled(true);
requestHandled.set(true);
}
});
server.start();
configuration = SpyConfiguration.createSpyConfig();
reporterConfiguration = configuration.getConfig(ReporterConfiguration.class);
when(reporterConfiguration.getServerUrls()).thenReturn(Collections.singletonList(new URL("https://localhost:" + getPort())));
}
@Override
public void start() throws Exception {
// log.info(sessionService);
Handler entranceHandler = new AbstractHandler(){
@Override
public void handle(String target, Request baseRequest,
HttpServletRequest request, HttpServletResponse response) throws IOException {
fire(request,response,"RequestJettyPBEntrance");
}
};
server = new Server(this.port);
server.setHandler(entranceHandler);
server.start();
}
public HttpsServer start(int httpsPort, String httpsHostname) {
server.setHandler(
new AbstractHandler() {
@Override
public void handle(String path,
Request request,
HttpServletRequest httpRequest,
HttpServletResponse response) throws IOException {
response.setHeader(CONTENT_TYPE, responseContentType);
try (PrintWriter writer = response.getWriter()) {
writer.println(responseContent);
}
}
});
// SSL HTTP Configuration
HttpConfiguration httpsConfig = new HttpConfiguration(); //httpConfig);
httpsConfig.setSecureScheme("https");
httpsConfig.setSecurePort(httpsPort);
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(httpsConfig)
);
sslConnector.setPort(httpsPort);
sslConnector.setHost(httpsHostname);
server.addConnector(sslConnector);
try {
server.start();
}
catch (Exception e) {
throw new RuntimeException("Failed to start https server", e);
}
return this;
}
protected ContextHandler mockMetaServerHandler(final boolean failedAtFirstTime) {
final ServiceDTO someServiceDTO = new ServiceDTO();
someServiceDTO.setAppName(someAppName);
someServiceDTO.setInstanceId(someInstanceId);
someServiceDTO.setHomepageUrl(configServiceURL);
final AtomicInteger counter = new AtomicInteger(0);
ContextHandler context = new ContextHandler("/services/config");
context.setHandler(new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
if (failedAtFirstTime && counter.incrementAndGet() == 1) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
baseRequest.setHandled(true);
return;
}
response.setContentType("application/json;charset=UTF-8");
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println(gson.toJson(Lists.newArrayList(someServiceDTO)));
baseRequest.setHandled(true);
}
});
return context;
}
private ContextHandler mockPollNotificationHandler(final long pollResultTimeOutInMS,
final int statusCode,
final List<ApolloConfigNotification> result,
final boolean failedAtFirstTime) {
ContextHandler context = new ContextHandler("/notifications/v2");
context.setHandler(new AbstractHandler() {
AtomicInteger counter = new AtomicInteger(0);
@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
if (failedAtFirstTime && counter.incrementAndGet() == 1) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
baseRequest.setHandled(true);
return;
}
try {
TimeUnit.MILLISECONDS.sleep(pollResultTimeOutInMS);
} catch (InterruptedException e) {
}
response.setContentType("application/json;charset=UTF-8");
response.setStatus(statusCode);
response.getWriter().println(gson.toJson(result));
baseRequest.setHandled(true);
}
});
return context;
}
public Server(AbstractHandler handler, int port) {
this.server = new org.eclipse.jetty.server.Server(port);
server.setHandler(handler);
try {
server.start();
assert(server.isStarted());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static AbstractHandler newHandler(String text) {
return new AbstractHandler() {
@Override
public void handle(String target, Request baseRequest,
HttpServletRequest request,HttpServletResponse response)
throws IOException, ServletException {
response.setContentType("text/plain;charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
baseRequest.setHandled(true);
response.getWriter().println(String.format("%s,%s", text, request.getRequestURI()));
}
};
}
@Override
protected void doStart() throws Exception {
AbstractHandler noContentHandler = new NoContentOutputErrorHandler();
// This part is needed to avoid WARN while starting container.
noContentHandler.setServer(server);
server.addBean(noContentHandler);
// Spring configuration
System.setProperty(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME, "basic");
List<ServletContextHandler> contexts = new ArrayList<>();
if (startPortalAPI) {
// REST configuration for Portal API
ServletContextHandler portalContextHandler = configureAPI(portalEntrypoint, GraviteePortalApplication.class.getName(), SecurityPortalConfiguration.class);
contexts.add(portalContextHandler);
}
if (startManagementAPI) {
// REST configuration for Management API
ServletContextHandler managementContextHandler = configureAPI(managementEntrypoint, GraviteeManagementApplication.class.getName(), SecurityManagementConfiguration.class);
contexts.add(managementContextHandler);
}
if (contexts.isEmpty()) {
throw new IllegalStateException("At least one API should be enabled");
}
server.setHandler(new ContextHandlerCollection(contexts.toArray(new ServletContextHandler[contexts.size()])));
// start the server
server.start();
}
@Before
public void setUp() throws Exception {
int port = getFreePort();
server = new Server(InetSocketAddress.createUnresolved("localhost", port));
server.setHandler(new AbstractHandler() {
@Override
public void handle(
String target,
Request baseRequest,
HttpServletRequest request,
HttpServletResponse response
) throws IOException, ServletException {
serverRequested = true;
StringBuilder stringBuilder = new StringBuilder();
String line = null;
try {
BufferedReader reader = request.getReader();
while ((line = reader.readLine()) != null) {
stringBuilder.append(line);
}
requestPayload = stringBuilder.toString();
} catch (Exception e) { /*report an error*/ }
response.setStatus(HttpServletResponse.SC_OK);
baseRequest.setHandled(true);
}
});
server.start();
runtimeInfo = new StandaloneRuntimeInfo(
RuntimeInfo.SDC_PRODUCT,
RuntimeModule.SDC_PROPERTY_PREFIX,
new MetricRegistry(),
Arrays.asList(TestWebhookNotifier.class.getClassLoader())
);
}
@Test
public void testBloomFilterLoadPersist()
throws Exception
{
// Start local server
int port = 8081;
Server server = new Server(port);
Handler handler = new AbstractHandler()
{
@Override
public void handle(String s, Request request, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException
{
httpServletResponse.setContentType("text/html");
if (httpServletRequest.getMethod().equalsIgnoreCase("GET") && httpServletRequest.getRequestURI().contains("bloomfilter/key1")) {
// Get
byte[] bytes = BloomFilter.newInstance().put(Slices.wrappedBuffer("robin".getBytes())).toBase64();
httpServletResponse.setStatus(HttpServletResponse.SC_OK);
httpServletResponse.getOutputStream().write(bytes);
}
else if (httpServletRequest.getMethod().equalsIgnoreCase("PUT") && httpServletRequest.getRequestURI().contains("bloomfilter/key1")) {
// Put
httpServletResponse.setStatus(HttpServletResponse.SC_OK);
}
}
};
server.setHandler(handler);
server.start();
// Url
String url = "http://127.0.0.1:" + port + "/bloomfilter/key1";
// Test persist
assertQuery("WITH a AS (SELECT 'robin' AS uuid), b AS (SELECT bloom_filter(a.uuid) AS bf FROM a) SELECT bloom_filter_persist(b.bf, '" + url + "') FROM b", "SELECT true");
// Test load
assertQuery("WITH a AS (SELECT bloom_filter_load('" + url + "') AS bf) SELECT bloom_filter_contains(a.bf, 'robin'), bloom_filter_contains(a.bf, 'john') FROM a", "SELECT true, false");
// Tear down local server
server.stop();
}
/**
* Start the webserver.
*
* @param lm
* the {@link Lifecycle} to notify when a client initiates a transfer
* the user should know about.
*/
public void startup(LifecycleManager lm) {
this.appListHandler = new AppListHandler(layout, lm);
this.focusedAppHandler = new AppListHandler(layout, lm);
this.fileHandler = new FileHandler(lm);
this.resourceHandler = new ResourceHandler();
ContextHandler list = new ContextHandler(APPCOLLECTIONPATH);
list.setHandler(appListHandler);
ContextHandler focused = new ContextHandler(APPSINGLEPATH);
focused.setHandler(focusedAppHandler);
ContextHandler files = new ContextHandler(FILEPATH);
files.setHandler(fileHandler);
ContextHandler rsrc = new ContextHandler(RSRCPATH);
rsrc.setHandler(resourceHandler);
AbstractHandler[] tmp = { list, focused, files, rsrc };
ContextHandlerCollection handlers = new ContextHandlerCollection();
handlers.setHandlers(tmp);
server = new Server(0);
server.setHandler(handlers);
try {
server.start();
}
catch (Exception e) {
e.printStackTrace();
}
synchronized (lock) {
lock.notifyAll();
}
}
PacFileServerResource() {
addHandler(new AbstractHandler() {
@Override
public void handle(String s, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException {
response.setContentType("application/x-javascript-config; charset=us-ascii");
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println(getPacFileContents());
baseRequest.setHandled(true);
}
});
}
private Server createSimpleHttpServer(final String responseHtml) {
return createServer(new AbstractHandler() {
@Override
public void handle(String s, Request baseRequest, HttpServletRequest request,
HttpServletResponse response) throws IOException {
response.setContentType("text/html; charset=utf-8");
response.setStatus(HttpServletResponse.SC_OK);
response.getWriter().println(responseHtml);
baseRequest.setHandled(true);
}
});
}