下面列出了org.springframework.boot.context.embedded.jetty.JettyServerCustomizer#org.eclipse.jetty.server.HttpConnectionFactory 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@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);
}
private ServerConnector createHttpChannelConnector(
Server server, HttpConfiguration httpConfig) {
ServerConnector conn = new ServerConnector(server,
conf.getInt(HTTP_ACCEPTOR_COUNT_KEY, HTTP_ACCEPTOR_COUNT_DEFAULT),
conf.getInt(HTTP_SELECTOR_COUNT_KEY, HTTP_SELECTOR_COUNT_DEFAULT));
ConnectionFactory connFactory = new HttpConnectionFactory(httpConfig);
conn.addConnectionFactory(connFactory);
if (Shell.WINDOWS) {
// result of setting the SO_REUSEADDR flag is different on Windows
// http://msdn.microsoft.com/en-us/library/ms740621(v=vs.85).aspx
// without this 2 NN's can start on the same machine and listen on
// the same port with indeterminate routing of incoming requests to them
conn.setReuseAddress(false);
}
return conn;
}
@Before
public void initialize()
throws Exception
{
Path cfgFile = Paths.get("target/appserver-base/conf/archiva.xml");
if (Files.exists(cfgFile)) {
Files.delete(cfgFile);
}
try {
repositoryRegistry.removeRepository( "test-repo-re" );
} catch (Exception e) {
// Ignore
}
server = new Server( );
serverConnector = new ServerConnector( server, new HttpConnectionFactory());
server.addConnector( serverConnector );
createContext( server, Paths.get( "src/test/" ) );
this.server.start();
this.port = serverConnector.getLocalPort();
log.info( "start server on port {}", this.port );
}
private static Server createServer(Handler handler, int port, KeyStore keyStore, String keyPassword) throws Exception {
Server server = new Server();
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setIncludeProtocols("TLSv1.2");
sslContextFactory.setKeyStore(keyStore);
sslContextFactory.setKeyManagerPassword(keyPassword);
HttpConfiguration httpsConfig = new HttpConfiguration();
httpsConfig.addCustomizer(new SecureRequestCustomizer());
ServerConnector sslConnector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig));
sslConnector.setPort(port);
server.addConnector(sslConnector);
server.setHandler(handler);
return server;
}
private static Server startServer(ContextHandlerCollection contexts, int port) throws Exception {
System.setProperty(MessagingPropertyKeys.PROPERTY_SERVLET_HOST_PATH, "http://localhost:" + port);
setBounceProxyUrl();
setDirectoriesUrl();
logger.info("HOST PATH: {}", System.getProperty(MessagingPropertyKeys.PROPERTY_SERVLET_HOST_PATH));
final Server jettyServer = new Server();
ServerConnector connector = new ServerConnector(jettyServer,
new HttpConnectionFactory(new HttpConfiguration()));
connector.setPort(port);
connector.setAcceptQueueSize(1);
jettyServer.setConnectors(new Connector[]{ connector });
jettyServer.setHandler(contexts);
jettyServer.start();
logger.trace("Started jetty server: {}", jettyServer.dump());
return jettyServer;
}
public void start(){
try{
jettyServer=new Server(port);
HttpConfiguration httpConfiguration = new HttpConfiguration();
ConnectionFactory c = new HttpConnectionFactory(httpConfiguration);
ServerConnector serverConnector = new ServerConnector(jettyServer, c);
serverConnector.setPort(port);
jettyServer.setConnectors(new Connector[] { serverConnector });
jettyServer.setHandler(requestHandler);
jettyServer.start();
if(statusButton!=null){
updateStatusIcon();
iconThread=new IconThread();
iconThread.start();
}
}
catch(Exception e){
wandora.handleError(e);
}
}
@Override
public void startComponent() {
// Initialize servlet using RESTEasy and it's Guice bridge.
// The listener must be injected by the same Guice module which also binds the REST endpoints.
ServletContextHandler servletHandler = new ServletContextHandler();
servletHandler.addEventListener(listener);
servletHandler.addServlet(HttpServletDispatcher.class, "/*");
// Configure Jetty: Remove 'server' header from response and set listen port.
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendServerVersion(false);
ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(httpConfig));
connector.setPort(port);
// Starting up Jetty to serve the REST API.
server.addConnector(connector);
server.setHandler(servletHandler);
if (!LambdaUtils.tryTo(server::start, ex -> logger.error(ex, "Failed to start REST API."))) {
throw new IllegalStateException("Failed to start REST API.");
}
}
protected static void addHttpsConnector(Server server, Integer port) throws Exception {
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(Config.sslKeyStore().getAbsolutePath());
sslContextFactory.setKeyStorePassword(Config.token().getSslKeyStorePassword());
sslContextFactory.setKeyManagerPassword(Config.token().getSslKeyManagerPassword());
sslContextFactory.setTrustAll(true);
HttpConfiguration config = new HttpConfiguration();
config.setSecureScheme("https");
config.setOutputBufferSize(32768);
config.setRequestHeaderSize(8192 * 2);
config.setResponseHeaderSize(8192 * 2);
config.setSendServerVersion(true);
config.setSendDateHeader(false);
ServerConnector sslConnector = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(config));
sslConnector.setPort(port);
server.addConnector(sslConnector);
}
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();
}
public PitchforkService(final Config config, final ZipkinSpanProcessorFactory processorFactory) {
this.cfg = HttpConfig.from(config);
final QueuedThreadPool threadPool = new QueuedThreadPool(cfg.getMaxThreads(), cfg.getMinThreads(), cfg.getIdleTimeout());
server = new Server(threadPool);
final ServerConnector httpConnector = new ServerConnector(server, new HttpConnectionFactory(new HttpConfiguration()));
httpConnector.setPort(cfg.getPort());
httpConnector.setIdleTimeout(cfg.getIdleTimeout());
server.addConnector(httpConnector);
final ServletContextHandler context = new ServletContextHandler(server, "/");
addResources(context, processorFactory);
if (cfg.isGzipEnabled()) {
final GzipHandler gzipHandler = new GzipHandler();
gzipHandler.setInflateBufferSize(cfg.getGzipBufferSize());
context.setGzipHandler(gzipHandler);
}
server.setStopTimeout(cfg.getStopTimeout());
logger.info("pitchfork has been initialized successfully !");
}
private ServerConnector createHttpChannelConnector(
Server server, HttpConfiguration httpConfig) {
ServerConnector conn = new ServerConnector(server,
conf.getInt(HTTP_ACCEPTOR_COUNT_KEY, HTTP_ACCEPTOR_COUNT_DEFAULT),
conf.getInt(HTTP_SELECTOR_COUNT_KEY, HTTP_SELECTOR_COUNT_DEFAULT));
ConnectionFactory connFactory = new HttpConnectionFactory(httpConfig);
conn.addConnectionFactory(connFactory);
if(Shell.WINDOWS) {
// result of setting the SO_REUSEADDR flag is different on Windows
// http://msdn.microsoft.com/en-us/library/ms740621(v=vs.85).aspx
// without this 2 NN's can start on the same machine and listen on
// the same port with indeterminate routing of incoming requests to them
conn.setReuseAddress(false);
}
return conn;
}
private ServerConnector createHttpChannelConnector(
Server server, HttpConfiguration httpConfig) {
ServerConnector conn = new ServerConnector(server,
conf.getInt(HTTP_ACCEPTOR_COUNT_KEY, HTTP_ACCEPTOR_COUNT_DEFAULT),
conf.getInt(HTTP_SELECTOR_COUNT_KEY, HTTP_SELECTOR_COUNT_DEFAULT));
ConnectionFactory connFactory = new HttpConnectionFactory(httpConfig);
conn.addConnectionFactory(connFactory);
if(Shell.WINDOWS) {
// result of setting the SO_REUSEADDR flag is different on Windows
// http://msdn.microsoft.com/en-us/library/ms740621(v=vs.85).aspx
// without this 2 NN's can start on the same machine and listen on
// the same port with indeterminate routing of incoming requests to them
conn.setReuseAddress(false);
}
return conn;
}
/** Build a Jetty server */
private static Server jettyServer(int port, boolean loopback) {
Server server = new Server();
HttpConnectionFactory f1 = new HttpConnectionFactory();
f1.getHttpConfiguration().setRequestHeaderSize(512 * 1024);
f1.getHttpConfiguration().setOutputBufferSize(5 * 1024 * 1024);
// Do not add "Server: Jetty(....) when not a development system.
if ( true )
f1.getHttpConfiguration().setSendServerVersion(false);
ServerConnector connector = new ServerConnector(server, f1);
connector.setPort(port);
server.addConnector(connector);
if ( loopback )
connector.setHost("localhost");
return server;
}
private List<ConnectionFactory> createConnectionFactories(Metric metric) {
HttpConnectionFactory httpFactory = newHttpConnectionFactory();
if (connectorConfig.healthCheckProxy().enable() || connectorConfig.secureRedirect().enabled()) {
return List.of(httpFactory);
} else if (connectorConfig.ssl().enabled()) {
return connectionFactoriesForHttps(metric, httpFactory);
} else if (TransportSecurityUtils.isTransportSecurityEnabled()) {
switch (TransportSecurityUtils.getInsecureMixedMode()) {
case TLS_CLIENT_MIXED_SERVER:
case PLAINTEXT_CLIENT_MIXED_SERVER:
return List.of(new DetectorConnectionFactory(newSslConnectionFactory(metric, httpFactory)), httpFactory);
case DISABLED:
return connectionFactoriesForHttps(metric, httpFactory);
default:
throw new IllegalStateException();
}
} else {
return List.of(httpFactory);
}
}
@BeforeClass
public static void startHttpsServer() throws Exception {
skipIfHeadlessEnvironment();
server = new Server();
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(ErrorCases.class.getResource("keystore").getPath());
sslContextFactory.setKeyStorePassword("activeeon");
HttpConfiguration httpConfig = new HttpConfiguration();
HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
httpsConfig.addCustomizer(new SecureRequestCustomizer());
ServerConnector sslConnector = new ServerConnector(server,
new ConnectionFactory[] { new SslConnectionFactory(sslContextFactory,
HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(httpsConfig) });
server.addConnector(sslConnector);
server.start();
serverUrl = "https://localhost:" + sslConnector.getLocalPort() + "/rest";
}
@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();
}
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();
}
/**
* Create ssl connector if https is used
* @return
*/
private ServerConnector sslConnector() {
HttpConfiguration http_config = new HttpConfiguration();
http_config.setSecureScheme("https");
http_config.setSecurePort(this.getPort());
HttpConfiguration https_config = new HttpConfiguration(http_config);
https_config.addCustomizer(new SecureRequestCustomizer());
SslContextFactory sslContextFactory = new SslContextFactory(this.getCertKeyStorePath());
sslContextFactory.setKeyStorePassword(this.getCertKeyStorePassword());
//exclude weak ciphers
sslContextFactory.setExcludeCipherSuites("^.*_(MD5|SHA|SHA1)$");
//only support tlsv1.2
sslContextFactory.addExcludeProtocols("SSL", "SSLv2", "SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.1");
ServerConnector connector = new ServerConnector(jettyServer,
new SslConnectionFactory(sslContextFactory, "http/1.1"),
new HttpConnectionFactory(https_config));
connector.setPort(this.getPort());
connector.setIdleTimeout(50000);
return connector;
}
public static void main(String[] args) throws Exception
{
Server server = new Server(8080);
ServerConnector connector = server.getBean(ServerConnector.class);
HttpConfiguration config = connector.getBean(HttpConnectionFactory.class).getHttpConfiguration();
config.setSendDateHeader(true);
config.setSendServerVersion(true);
ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SECURITY|ServletContextHandler.NO_SESSIONS);
context.setContextPath("/");
server.setHandler(context);
context.addServlet(org.eclipse.jetty.servlet.DefaultServlet.class,"/");
context.addServlet(JsonServlet.class,"/json");
context.addServlet(PlaintextServlet.class,"/plaintext");
server.start();
server.join();
}
public ChaosHttpProxy(URI endpoint, ChaosConfig config)
throws Exception {
setChaosConfig(config);
Supplier<Failure> supplier = new RandomFailureSupplier(
config.getFailures());
requireNonNull(endpoint);
client = new HttpClient();
server = new Server();
HttpConnectionFactory httpConnectionFactory =
new HttpConnectionFactory();
// TODO: SSL
ServerConnector connector = new ServerConnector(server,
httpConnectionFactory);
connector.setHost(endpoint.getHost());
connector.setPort(endpoint.getPort());
server.addConnector(connector);
this.handler = new ChaosHttpProxyHandler(client, supplier);
HandlerList handlers = new HandlerList();
handlers.addHandler(new ChaosApiHandler(this, handler));
handlers.addHandler(handler);
server.setHandler(handlers);
}
private Connector createConnector( final Server httpBindServer ) {
final int port = getHttpBindUnsecurePort();
if (port > 0) {
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSendServerVersion( false );
configureProxiedConnector(httpConfig);
ServerConnector connector = new ServerConnector(httpBindServer, new HttpConnectionFactory(httpConfig));
// Listen on a specific network interface if it has been set.
connector.setHost(getBindInterface());
connector.setPort(port);
return connector;
}
else
{
return null;
}
}
/**
* Create HTTP connector.
*
* @return Initialized {@link ServerConnector} instance for HTTP connections.
*/
private ServerConnector createHttpConnector(int port, int acceptors, int selectors) {
logger.info("Setting up HTTP connector for web server");
final HttpConfiguration httpConfig = new HttpConfiguration();
final ServerConnector httpConnector =
new ServerConnector(embeddedJetty, null, null, null, acceptors, selectors, new HttpConnectionFactory(httpConfig));
httpConnector.setPort(port);
return httpConnector;
}
public void init() {
// connector configuration
SslContextFactory sslContextFactory = new SslContextFactory();
if (null != keyStorePath) {
sslContextFactory.setKeyStorePath(keyStorePath);
}
if (null != keyStorePassword) {
sslContextFactory.setKeyStorePassword(keyStorePassword);
}
if (null != keyManagerPassword) {
sslContextFactory.setKeyManagerPassword(keyManagerPassword);
}
SslConnectionFactory sslConnectionFactory =
new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString());
HttpConnectionFactory httpConnectionFactory =
new HttpConnectionFactory(new HttpConfiguration());
ServerConnector sslConnector =
new ServerConnector(server, sslConnectionFactory, httpConnectionFactory);
sslConnector.setHost(host);
sslConnector.setPort(port);
server.addConnector(sslConnector);
ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
ServletHolder servletHolder = new ServletHolder(new ExchangeServlet(sessions, ringBuffer));
context.addServlet(servletHolder, "/trade/*");
// context.addServlet(DefaultServlet.class, "/");
server.setHandler(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())));
}
protected Connector getConnector(String host, int port) throws IOException {
HttpConfiguration http_config = new HttpConfiguration();
// this is to enable large header sizes when Kerberos is enabled with AD
final int bufferSize = AtlasConfiguration.WEBSERVER_REQUEST_BUFFER_SIZE.getInt();;
http_config.setResponseHeaderSize(bufferSize);
http_config.setRequestHeaderSize(bufferSize);
ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(http_config));
connector.setPort(port);
connector.setHost(host);
return connector;
}
private HttpdForTests(boolean allowedScopedLinkLocal) throws SocketException {
// Configure the logging for jetty. Which uses a singleton. Ho hum.
Log.setLog(new JavaUtilLog());
server = new Server();
ServerConnector connector = new ServerConnector(server);
connector.addConnectionFactory(new HttpConnectionFactory());
// Choose a port randomly upon listening for socket connections.
connector.setPort(0);
server.addConnector(connector);
handlerList = new HandlerList();
localhost = getLocalhostAddress(allowedScopedLinkLocal).getHostAddress();
}
private void configureConnectors(SslContextFactory sslContextFactory) {
final HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.setSendServerVersion(false);
final HttpConnectionFactory httpConnectionFactory =
new HttpConnectionFactory(httpConfiguration);
List<URI> listeners = parseListeners(config.getList(RestConfig.LISTENERS_CONFIG),
config.getInt(RestConfig.PORT_CONFIG), Arrays.asList("http", "https"), "http");
for (URI listener : listeners) {
log.info("Adding listener: " + listener.toString());
NetworkTrafficServerConnector connector;
if (listener.getScheme().equals("http")) {
connector = new NetworkTrafficServerConnector(this, httpConnectionFactory);
} else {
connector = new NetworkTrafficServerConnector(this, httpConnectionFactory,
sslContextFactory);
}
connector.setPort(listener.getPort());
connector.setHost(listener.getHost());
connector.setIdleTimeout(config.getLong(RestConfig.IDLE_TIMEOUT_MS_CONFIG));
connectors.add(connector);
super.addConnector(connector);
}
}
private ServerConnector getServerConnector() {
SslConnectionFactory sslConnectionFactory = getSSLConnectionFactory();
HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(new HttpConfiguration());
ServerConnector connector = new ServerConnector(server, sslConnectionFactory, httpConnectionFactory);
connector.setPort(port);
return connector;
}
protected ServerConnector getServerConnector() {
HttpConnectionFactory factory = new HttpConnectionFactory();
factory.getHttpConfiguration().setRequestHeaderSize(maxAllowedHeaderSize);
if (null == sslFactory) {
return new ServerConnector(server, factory);
}
return new ServerConnector(server, AbstractConnectionFactory.getFactories(sslFactory, factory));
}
@Test
public void testSetConnector() throws Exception {
URL url = new URL("http://localhost:" + PORT4 + "/hello/test");
JettyHTTPTestHandler handler1 = new JettyHTTPTestHandler("string1", true);
JettyHTTPTestHandler handler2 = new JettyHTTPTestHandler("string2", true);
JettyHTTPServerEngine engine = new JettyHTTPServerEngine();
engine.setPort(PORT4);
Server server = new Server();
ServerConnector connector = new ServerConnector(server);
connector.setPort(PORT4);
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.addCustomizer(new org.eclipse.jetty.server.ForwardedRequestCustomizer());
HttpConnectionFactory httpFactory = new HttpConnectionFactory(httpConfig);
Collection<ConnectionFactory> connectionFactories = new ArrayList<>();
connectionFactories.add(httpFactory);
connector.setConnectionFactories(connectionFactories);
engine.setConnector(connector);
List<Handler> handlers = new ArrayList<>();
handlers.add(handler1);
engine.setHandlers(handlers);
engine.finalizeConfig();
engine.addServant(url, handler2);
String response = null;
try {
response = getResponse(url.toString());
assertEquals("the jetty http handler1 did not take effect", response, "string1string2");
} catch (Exception ex) {
fail("Can't get the reponse from the server " + ex);
}
engine.stop();
JettyHTTPServerEngineFactory.destroyForPort(PORT4);
}