下面列出了org.springframework.boot.context.embedded.jetty.JettyServerCustomizer#org.eclipse.jetty.server.Connector 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public int getPort(Environment environment) {
int defaultPort = 9090;
MutableServletContextHandler h = environment.getApplicationContext();
if (h == null) {
return defaultPort;
}
Server s = h.getServer();
if (s == null) {
return defaultPort;
}
Connector[] c = s.getConnectors();
if (c != null && c.length > 0) {
AbstractNetworkConnector anc = (AbstractNetworkConnector) c[0];
if (anc != null) {
return anc.getLocalPort();
}
}
return defaultPort;
}
/**
* Returns true if a listener on the HTTPS binding port is running.
*
* @return true if a listener on the HTTPS binding port is running.
*/
public boolean isHttpsBindActive()
{
if ( isHttpBindEnabled() )
{
final int configuredPort = getHttpBindSecurePort();
for ( final Connector connector : httpBindServer.getConnectors() )
{
if ( !( connector instanceof ServerConnector ) )
{
continue;
}
final int activePort = ( (ServerConnector) connector ).getLocalPort();
if ( activePort == configuredPort )
{
return true;
}
}
}
return false;
}
public void start() throws Exception {
//flushCapturedRequests();
server = new Server(0);
ServerConnector connector = new ServerConnector(server);
ServletContextHandler handler = new ServletContextHandler();
ServletHolder testServ = new ServletHolder("test", RestHelper.class);
testServ.setInitParameter("resourceBase",System.getProperty("user.dir"));
testServ.setInitParameter("dirAllowed","true");
handler.addServlet(testServ,"/test");
handler.addServlet(testServ,"/someTopic");
handler.addServlet(testServ,"/someKey");
server.setHandler(handler);
server.setConnectors(new Connector[]{connector});
server.start();
port = server.getURI().getPort();
}
@Test
public void testCreateHttpServerUsingHttpsAndRedirection() {
createHttpsContextProperties();
server = jettyStarter.createHttpServer(8080, 8443, true, true);
Connector[] connectors = server.getConnectors();
assertThat(connectors).hasLength(2);
assertThat(connectors[0].getName()).isEqualTo(JettyStarter.HTTP_CONNECTOR_NAME);
assertThat(connectors[0].getConnectionFactory(HttpConnectionFactory.class)).isNotNull();
assertThat(connectors[1].getName()).isEqualTo(JettyStarter.HTTPS_CONNECTOR_NAME.toLowerCase());
assertThat(connectors[1].getConnectionFactory(HttpConnectionFactory.class)).isNotNull();
assertThat(connectors[1].getConnectionFactory(SslConnectionFactory.class)).isNotNull();
unsetHttpsContextProperties();
}
@SuppressWarnings("squid:S2095")
private Server createRedirectorServer() {
int unsecurePort = conf.get(HTTP_PORT_KEY, HTTP_PORT_DEFAULT);
String hostname = conf.get(HTTP_BIND_HOST, HTTP_BIND_HOST_DEFAULT);
QueuedThreadPool qtp = new QueuedThreadPool(25);
qtp.setName(serverName + "Redirector");
qtp.setDaemon(true);
Server server = new LimitedMethodServer(qtp);
InetSocketAddress addr = new InetSocketAddress(hostname, unsecurePort);
ServerConnector connector = new ServerConnector(server);
connector.setHost(addr.getHostName());
connector.setPort(addr.getPort());
server.setConnectors(new Connector[]{connector});
ServletContextHandler context = new ServletContextHandler();
context.addServlet(new ServletHolder(new RedirectorServlet()), "/*");
context.setContextPath("/");
server.setHandler(context);
return server;
}
private ServerConnector findServerConnector(Server server) {
final Connector[] connectors = server.getConnectors();
if (connectors.length == 0) {
throw new IllegalStateException("server has no connectors");
}
for (final Connector c : connectors) {
if (!(c instanceof ServerConnector)) {
continue;
}
return (ServerConnector) c;
}
throw new IllegalStateException("Server has no associated ServerConnector");
}
public static void main(String[] args) throws Exception
{
// jetty config
Properties properties = new Properties();
properties.load(CrudApiHandler.class.getClassLoader().getResourceAsStream("jetty.properties"));
HttpConfiguration config = new HttpConfiguration();
config.setSendServerVersion( false );
HttpConnectionFactory factory = new HttpConnectionFactory( config );
Server server = new Server();
ServerConnector connector = new ServerConnector(server,factory);
server.setConnectors( new Connector[] { connector } );
connector.setHost(properties.getProperty("host"));
connector.setPort(Integer.parseInt(properties.getProperty("port")));
server.addConnector(connector);
server.setHandler(new CrudApiHandler());
server.start();
server.join();
}
@Test
public void testInitContainerInvalidHTTPPort() {
System.setProperty(AthenzConsts.ATHENZ_PROP_HTTP_PORT, "-10");
System.setProperty(AthenzConsts.ATHENZ_PROP_HTTPS_PORT, "4443");
AthenzJettyContainer container = AthenzJettyContainer.createJettyContainer();
assertNotNull(container);
Server server = container.getServer();
Connector[] connectors = server.getConnectors();
assertEquals(connectors.length, 2);
assertTrue(connectors[0].getProtocols().contains("http/1.1"));
assertTrue(connectors[1].getProtocols().contains("http/1.1"));
assertTrue(connectors[1].getProtocols().contains("ssl"));
}
@BeforeClass
public static void setUp() throws Exception {
// Check if executed inside target directory or module directory
String pathPrefix =new File(".").getCanonicalFile().getName().equals("target") ? "../" : "./";
server = new Server();
ServerConnector connector = new ServerConnector(server);
connector.setPort(18080);
connector.setHost("localhost");
server.setConnectors(new Connector[]{connector});
WebAppContext context = new WebAppContext();
context.setDescriptor(pathPrefix + "src/main/webapp/WEB-INF/web.xml");
context.setResourceBase(pathPrefix + "src/main/webapp");
context.setContextPath("/");
context.setParentLoaderPriority(true);
server.setHandler(context);
server.start();
client = ClientBuilder.newClient();
root = client.target("http://" + connector.getHost() + ':' + connector.getPort() + '/');
}
/**
* Starts the server.
*
* @param host
* the host to listen
* @param port
* the port to listen
* @throws Exception
* if the server can't be started
*/
public void start(String host, int port) throws Exception {
server = new Server();
@SuppressWarnings("resource")
final ServerConnector connector = new ServerConnector(server);
connector.setPort(port);
connector.setHost(host);
server.setConnectors(new Connector[] {connector });
final ServletHandler servletHandler = new ServletHandler();
server.setHandler(servletHandler);
servletHandler.addServletWithMapping(AddInServlet.class, "/*");
final HandlerList handlers = new HandlerList();
handlers.setHandlers(new Handler[] {servletHandler, new DefaultHandler() });
server.setHandler(handlers);
server.start();
}
@Override
public void startSSL(String keyStoreLocation, String keyStorePassword) throws Exception {
Server server = new Server();
HttpConfiguration httpsConfig = new HttpConfiguration();
httpsConfig.addCustomizer(new SecureRequestCustomizer());
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keyStoreLocation);
sslContextFactory.setKeyStorePassword(keyStorePassword);
ServerConnector https = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, "http/1.1"),
new HttpConnectionFactory(httpsConfig));
https.setHost(host);
https.setPort(port);
server.setConnectors(new Connector[]{https});
configureContextHandler(server);
startServer(server);
}
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());
}
private static void installListeners(Server server, Collection<? extends InetSocketAddress> addresses) {
final List<Connector> connectors = new ArrayList<>(addresses.size());
for (InetSocketAddress address : addresses) {
final ServerConnector server_connector = new ServerConnector(server);
server_connector.setReuseAddress(true);
if (address.getAddress() != null) {
if (!address.getAddress().isAnyLocalAddress()) {
LOG.log(Level.INFO, "Binding API server address: {0}", address.getAddress().getHostAddress());
server_connector.setHost(address.getAddress().getHostAddress());
}
} else if (address.getHostString() != null) {
LOG.log(Level.INFO, "Binding API server address name: {0}", address.getHostString());
server_connector.setHost(address.getHostString());
}
LOG.log(Level.INFO, "Binding API server port: {0}", address.getPort());
server_connector.setPort(address.getPort());
connectors.add(server_connector);
}
server.setConnectors(connectors.toArray(new Connector[connectors.size()]));
}
@Override
public void lifeCycleStarted(LifeCycle bean) {
if (bean instanceof Server) {
Server server = (Server)bean;
Connector[] connectors = server.getConnectors();
if (connectors == null || connectors.length == 0) {
server.dumpStdErr();
throw new IllegalStateException("No Connector");
} else if (!Arrays.stream(connectors).allMatch(Connector::isStarted)) {
server.dumpStdErr();
throw new IllegalStateException("Connector not started");
}
ContextHandler context = server.getChildHandlerByClass(ContextHandler.class);
if (context == null || !context.isAvailable()) {
server.dumpStdErr();
throw new IllegalStateException("No Available Context");
}
}
}
public PrometheusServer(int addr, SSLContextService sslContextService, ComponentLog logger, boolean needClientAuth, boolean wantClientAuth) throws Exception {
PrometheusServer.logger = logger;
this.server = new Server();
this.handler = new ServletContextHandler(server, "/metrics");
this.handler.addServlet(new ServletHolder(new MetricsServlet()), "/");
SslContextFactory sslFactory = createSslFactory(sslContextService, needClientAuth, wantClientAuth);
HttpConfiguration httpsConfiguration = new HttpConfiguration();
httpsConfiguration.setSecureScheme("https");
httpsConfiguration.setSecurePort(addr);
httpsConfiguration.addCustomizer(new SecureRequestCustomizer());
ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslFactory, "http/1.1"),
new HttpConnectionFactory(httpsConfiguration));
https.setPort(addr);
this.server.setConnectors(new Connector[]{https});
this.server.start();
}
@Override
public void serverStarted(Server server) {
// Detect the port Jetty is listening on - works with configured and random ports
for (final Connector connector : server.getConnectors()) {
try {
if ("application".equals(connector.getName())) {
final ServerSocketChannel channel = (ServerSocketChannel) connector
.getTransport();
final InetSocketAddress socket = (InetSocketAddress) channel
.getLocalAddress();
timbuctooConfiguration.getUriHelper().notifyOfPort(socket.getPort());
}
} catch (Exception e) {
LOG.error("No base url provided, and unable to get generate one myself", e);
}
}
}
public ApiServer(ServerOptions options) {
requestPool = new QueuedThreadPool(250);
jettyServer = new Server(requestPool);
ServerConnector connector = new ServerConnector(jettyServer);
connector.setPort(options.port);
jettyServer.setConnectors(new Connector[]{connector});
Handler rootHandler;
String contextPath = normalizeContextPath(options.contextPath);
if (contextPath == null) {
ServletHandler router = new ServletHandler();
router.addServletWithMapping(Router.class, "/*");
rootHandler = router;
} else {
ServletContextHandler contextHandler = new ServletContextHandler();
contextHandler.setContextPath(contextPath);
contextHandler.addServlet(Router.class, "/*");
rootHandler = contextHandler;
}
MultipartConfigInjectionHandler multipartWrapper = new MultipartConfigInjectionHandler(
options.temporaryDirectory, options.maxFileSize, options.maxRequestSize, options.fileSizeThreshold);
multipartWrapper.setHandler(rootHandler);
jettyServer.setHandler(multipartWrapper);
}
@BeforeClass
public static void startServer() throws Exception {
// Let server pick its own random, available port.
server = new Server(0);
ServletContextHandler handler = new ServletContextHandler();
handler.setContextPath("/");
Class<?> config = CommonsMultipartResolverTestConfig.class;
ServletHolder commonsResolverServlet = new ServletHolder(DispatcherServlet.class);
commonsResolverServlet.setInitParameter("contextConfigLocation", config.getName());
commonsResolverServlet.setInitParameter("contextClass", AnnotationConfigWebApplicationContext.class.getName());
handler.addServlet(commonsResolverServlet, "/commons-resolver/*");
config = StandardMultipartResolverTestConfig.class;
ServletHolder standardResolverServlet = new ServletHolder(DispatcherServlet.class);
standardResolverServlet.setInitParameter("contextConfigLocation", config.getName());
standardResolverServlet.setInitParameter("contextClass", AnnotationConfigWebApplicationContext.class.getName());
standardResolverServlet.getRegistration().setMultipartConfig(new MultipartConfigElement(""));
handler.addServlet(standardResolverServlet, "/standard-resolver/*");
server.setHandler(handler);
server.start();
Connector[] connectors = server.getConnectors();
NetworkConnector connector = (NetworkConnector) connectors[0];
baseUrl = "http://localhost:" + connector.getLocalPort();
}
@Override
public void start() throws Exception {
this.jettyServer.start();
this.contextHandler.start();
Connector[] connectors = jettyServer.getConnectors();
NetworkConnector connector = (NetworkConnector) connectors[0];
this.port = connector.getLocalPort();
}
public Server createJettyServer(String host, int port) throws Exception {
server = new Server();
ServerConnector connector = new ServerConnector(server);
connector.setHost(host);
connector.setPort(port);
server.setConnectors(new Connector[]{connector});
handlers = new HandlerList();
server.setHandler(handlers);
return server;
}
private List<ServerConnector> getSocketConnectors( WebServer wServer ) {
List<ServerConnector> sConnectors = new ArrayList<ServerConnector>();
Connector[] connectors = wServer.getServer().getConnectors();
for ( Connector cn : connectors ) {
if ( cn instanceof ServerConnector ) {
sConnectors.add( (ServerConnector) cn );
}
}
return sConnectors;
}
@Override
public void start(){
try{
NadiaProcessorConfig config = NadiaProcessorConfig.getInstance();
//Jetty:
server = new Server();
//main config
WebAppContext context = new WebAppContext();
context.setDescriptor(config.getProperty(NadiaProcessorConfig.JETTYWEBXMLPATH));
context.setResourceBase(config.getProperty(NadiaProcessorConfig.JETTYRESOURCEBASE));
context.setContextPath(config.getProperty(NadiaProcessorConfig.JETTYCONTEXTPATH));
context.setParentLoaderPriority(true);
server.setHandler(context);
//ssl (https)
SslContextFactory sslContextFactory = new SslContextFactory(config.getProperty(NadiaProcessorConfig.JETTYKEYSTOREPATH));
sslContextFactory.setKeyStorePassword(config.getProperty(NadiaProcessorConfig.JETTYKEYSTOREPASS));
ServerConnector serverconn = new ServerConnector(server, sslContextFactory);
serverconn.setPort(8080); //443 (or 80) not allowed on Linux unless run as root
server.setConnectors(new Connector[] {serverconn});
//start
server.start();
logger.info("REST interface started on "+server.getURI());
server.join();
}
catch(Exception ex){
ex.printStackTrace();
logger.severe("Nadia: failed to start Jetty: "+ex.getMessage());
server.destroy();
}
}
private Server buildServer(final int port) {
final QueuedThreadPool threadPool = new QueuedThreadPool(4, 2);
final Server server = new Server(threadPool);
final ServerConnector connector = new ServerConnector(server);
connector.setPort(port);
server.setConnectors(new Connector[] {connector});
return server;
}
private static Server buildServer(final int port) {
final QueuedThreadPool threadPool = new QueuedThreadPool(10, 2);
final Server server = new Server(threadPool);
final ServerConnector connector = new ServerConnector(server);
connector.setPort(port);
server.setConnectors(new Connector[] {connector});
return server;
}
public void startup() throws Exception {
Resource configXml = Resource.newSystemResource(DEFAULT_JETTY_CONFIG);
XmlConfiguration configuration = new XmlConfiguration(configXml.getInputStream());
server = (Server) configuration.configure();
Integer port = config.getHttpPort();
if (port != null && port > 0) {
Connector[] connectors = server.getConnectors();
for (Connector connector : connectors) {
if (connector instanceof AbstractNetworkConnector) {
((AbstractNetworkConnector) connector).setPort(port);
}
}
}
Handler handler = server.getHandler();
if (handler != null && handler instanceof WebAppContext) {
WebAppContext webAppContext = (WebAppContext) handler;
String webAppPath = System.getProperty("webapp.conf");
logger.info("Web App Path is " + webAppPath);
if (StringUtils.isBlank(webAppPath)) {
webAppContext.setResourceBase(JettyServer.class.getResource("/webapp").toString());
} else {
webAppContext.setResourceBase(webAppPath);
}
}
server.start();
if (logger.isInfoEnabled()) {
logger.info("##Jetty Embed Server is started.");
}
}
public void start() throws Exception
{
server = new Server();
Connector connector = new SelectChannelConnector();
connector.setPort(port);
server.addConnector(connector);
// Setup the basic application "context" for this application at "/"
// This is also known as the handler tree (in jetty speak)
ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
contextHandler.setContextPath("/");
server.setHandler(contextHandler);
WebSocketServlet webSocketServlet = new WebSocketServlet()
{
@Override
public WebSocket doWebSocketConnect(HttpServletRequest request, String protocol)
{
return websocket;
}
};
contextHandler.addServlet(new ServletHolder(webSocketServlet), "/pubsub");
server.start();
if (port == 0) {
port = server.getConnectors()[0].getLocalPort();
}
}
private void setSSLContext() {
for (Connector connector : server.getConnectors()) {
for (ConnectionFactory connectionFactory : connector.getConnectionFactories()) {
if (connectionFactory instanceof SslConnectionFactory) {
runtimeInfo.setSSLContext(((SslConnectionFactory) connectionFactory).getSslContextFactory().getSslContext());
}
}
}
if (runtimeInfo.getSSLContext() == null) {
throw new IllegalStateException("Unexpected error, SSLContext is not set for https enabled server");
}
}
@Override public Server newServer(int port) {
Server result = new Server();
SocketConnector connector = new SocketConnector();
connector.setMaxIdleTime(1000 * 60 * 60);
connector.setPort(port);
result.setConnectors(new Connector[] {connector});
return result;
}
@Override
public Connection newConnection(Connector connector, EndPoint endPoint) {
LOG.info("newConnection: {}", endPoint.getLocalAddress().toString());
ServerSessionListener listener = new CustomSessionListener(connector, endPoint, streamProcessors);
Generator generator = new Generator(connector.getByteBufferPool(), getMaxDynamicTableSize(), getMaxHeaderBlockFragment());
FlowControlStrategy flowControl = getFlowControlStrategyFactory().newFlowControlStrategy();
HTTP2ServerSession session = new HTTP2ServerSession(connector.getScheduler(), endPoint, generator, listener, flowControl);
session.setMaxLocalStreams(getMaxConcurrentStreams());
session.setMaxRemoteStreams(getMaxConcurrentStreams());
// For a single stream in a connection, there will be a race between
// the stream idle timeout and the connection idle timeout. However,
// the typical case is that the connection will be busier and the
// stream idle timeout will expire earlier than the connection's.
long streamIdleTimeout = getStreamIdleTimeout();
if (streamIdleTimeout <= 0) {
streamIdleTimeout = endPoint.getIdleTimeout();
}
session.setStreamIdleTimeout(streamIdleTimeout);
session.setInitialSessionRecvWindow(getInitialSessionRecvWindow());
ServerParser parser = newServerParser(connector, session, RateControl.NO_RATE_CONTROL);
HTTP2Connection connection = new HTTP2ServerConnection(connector.getByteBufferPool(), executor,
endPoint, getHttpConfiguration(), parser, session, getInputBufferSize(), listener);
connection.addListener(connectionListener);
return configure(connection, connector, endPoint);
}
KafkaCruiseControlApp(KafkaCruiseControlConfig config, Integer port, String hostname) throws ServletException {
this._config = config;
MetricRegistry metricRegistry = new MetricRegistry();
_jmxReporter = JmxReporter.forRegistry(metricRegistry).inDomain(METRIC_DOMAIN).build();
_jmxReporter.start();
_kafkaCruiseControl = new AsyncKafkaCruiseControl(config, metricRegistry);
_server = new Server();
NCSARequestLog requestLog = createRequestLog();
if (requestLog != null) {
_server.setRequestLog(requestLog);
}
_server.setConnectors(new Connector[]{ setupHttpConnector(hostname, port) });
ServletContextHandler contextHandler = createContextHandler();
maybeSetSecurityHandler(contextHandler);
_server.setHandler(contextHandler);
setupWebUi(contextHandler);
KafkaCruiseControlServlet servlet = new KafkaCruiseControlServlet(_kafkaCruiseControl, metricRegistry);
String apiUrlPrefix = config.getString(WebServerConfig.WEBSERVER_API_URLPREFIX_CONFIG);
ServletHolder servletHolder = new ServletHolder(servlet);
contextHandler.addServlet(servletHolder, apiUrlPrefix);
}