/**
* A Molgenis common web application initializer
*
* @param servletContext
* @param appConfig
* @param isDasUsed is the molgenis-omx-das module used?
* @throws ServletException
*/
protected void onStartup(ServletContext servletContext, Class<?> appConfig, boolean isDasUsed)
throws ServletException {
// Create the 'root' Spring application context
AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
rootContext.register(appConfig);
// Manage the lifecycle of the root application context
servletContext.addListener(new ContextLoaderListener(rootContext));
// Register and map the dispatcher servlet
ServletRegistration.Dynamic dispatcherServlet =
servletContext.addServlet("dispatcher", new DispatcherServlet(rootContext));
if (dispatcherServlet == null) {
logger.warn(
"ServletContext already contains a complete ServletRegistration for servlet 'dispatcher'");
} else {
final int maxSize = 32 * 1024 * 1024;
int loadOnStartup = (isDasUsed ? 2 : 1);
dispatcherServlet.setLoadOnStartup(loadOnStartup);
dispatcherServlet.addMapping("/");
dispatcherServlet.setMultipartConfig(
new MultipartConfigElement(null, maxSize, maxSize, maxSize));
dispatcherServlet.setInitParameter("dispatchOptionsRequest", "true");
}
// add filters
javax.servlet.FilterRegistration.Dynamic etagFilter =
servletContext.addFilter("etagFilter", new ShallowEtagHeaderFilter());
etagFilter.addMappingForServletNames(EnumSet.of(DispatcherType.REQUEST), true, "dispatcher");
// enable use of request scoped beans in FrontController
servletContext.addListener(new RequestContextListener());
}
// @Override
public void onStartup(ServletContext servletContext) throws ServletException {
WebApplicationContext rootAppContext = createRootApplicationContext(servletContext);
System.out.println("##################################################");
if (rootAppContext != null) {
servletContext.addFilter("app", "org.apache.tapestry5.TapestryFilter");
servletContext.setInitParameter("tapestry.app-package", "com.noofinc");
FilterRegistration.Dynamic tapestryFilter =
servletContext.addFilter("app", new TapestryFilter());
tapestryFilter.addMappingForUrlPatterns(null, true, "/*");
tapestryFilter.setAsyncSupported(true);
servletContext.addListener(
new ContextLoaderListener(rootAppContext) {
@Override
public void contextInitialized(ServletContextEvent event) {
// no-op because the application context is already initialized
}
});
} else {
this.logger.debug(
"No ContextLoaderListener registered, as "
+ "createRootApplicationContext() did not "
+ "return an application context");
}
}
@Override
public void addFilter(final FilterModel filterModel) {
LOG.debug("add filter [{}]", filterModel);
final ServletContext servletContext = findOrCreateServletContext(filterModel);
final FilterRegistration.Dynamic filterRegistration =
servletContext.addFilter(filterModel.getName(), filterModel.getFilter());
if (filterModel.getServletNames() != null) {
filterRegistration.addMappingForServletNames(
getDispatcherTypes(filterModel), /*
* TODO get asynch
* supported?
*/ false, filterModel.getServletNames());
} else if (filterModel.getUrlPatterns() != null) {
filterRegistration.addMappingForServletNames(
getDispatcherTypes(filterModel), /*
* TODO get asynch
* supported?
*/ false, filterModel.getUrlPatterns());
} else {
throw new AddFilterException(
"cannot add filter to the context; at least a not empty list of servlet names or URL patterns in exclusive mode must be provided: "
+ filterModel);
}
filterRegistration.setInitParameters(filterModel.getInitParams());
// filterRegistration.setAsyncSupported(filterModel.); TODO FIXME see
// how to get this info... ? see above
}
@Override
public void onStartup(ServletContext container) throws ServletException {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(AppConfig.class);
ctx.register(SecurityConfig.class);
container.addListener(new ContextLoaderListener(ctx));
container
.addFilter("springSecurityFilterChain", DelegatingFilterProxy.class)
.addMappingForUrlPatterns(null, false, "/*");
Map<String, String> initParams = new HashMap<String, String>();
initParams.put("encoding", "UTF-8");
initParams.put("forceEncoding", "true");
FilterRegistration.Dynamic ceFilter =
container.addFilter("encodingFilter", CharacterEncodingFilter.class);
ceFilter.setInitParameters(initParams);
ceFilter.addMappingForUrlPatterns(null, false, "/*");
ctx.setServletContext(container);
ServletRegistration.Dynamic servlet =
container.addServlet("dispatcher", new DispatcherServlet(ctx));
servlet.setLoadOnStartup(1);
servlet.addMapping("/");
}
protected FilterRegistration.Dynamic registerServletFilter(
ServletContext servletContext, Filter filter) {
String filterName = Conventions.getVariableName(filter);
FilterRegistration.Dynamic registration = servletContext.addFilter(filterName, filter);
registration.setAsyncSupported(true);
registration.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), false, "/*");
return registration;
}
/** Initializes the caching HTTP Headers Filter. */
private void initCachingHttpHeadersFilter(
ServletContext servletContext, EnumSet<DispatcherType> disps) {
log.debug("Registering Caching HTTP Headers Filter");
FilterRegistration.Dynamic cachingHttpHeadersFilter =
servletContext.addFilter("cachingHttpHeadersFilter", new CachingHttpHeadersFilter(env));
cachingHttpHeadersFilter.addMappingForUrlPatterns(disps, true, "/assets/*");
cachingHttpHeadersFilter.addMappingForUrlPatterns(disps, true, "/scripts/*");
cachingHttpHeadersFilter.setAsyncSupported(true);
}
private void addCacheFilter(ServletContext context) {
FilterRegistration.Dynamic filter =
context.addFilter(CACHE_FILTER_NAME, CacheServletFilter.class);
filter.setAsyncSupported(true);
String[] mappings =
new String[] {"/", "*.html", "*.css", "*.js", "*.ejs", "*.less", "*.hbs", "*.map"};
for (String mapping : mappings) {
filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, mapping);
}
}
@Override
public void contextInitialized(ServletContextEvent sce) {
ServletContext servletContext = sce.getServletContext();
log.info("Web application configuration");
log.debug("Configuring Spring root application context");
AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
rootContext.register(ApplicationConfiguration.class);
rootContext.refresh();
servletContext.setAttribute(
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, rootContext);
log.debug("Configuring Spring Web application context");
AnnotationConfigWebApplicationContext dispatcherServletConfig =
new AnnotationConfigWebApplicationContext();
dispatcherServletConfig.setParent(rootContext);
dispatcherServletConfig.register(DispatcherServletConfig.class);
log.debug("Registering Spring MVC Servlet");
ServletRegistration.Dynamic dispatcherServlet =
servletContext.addServlet("dispatcher", new DispatcherServlet(dispatcherServletConfig));
dispatcherServlet.addMapping("/tatami/*");
dispatcherServlet.setLoadOnStartup(2);
log.debug("Registering Meteor Servlet for online users");
ServletRegistration.Dynamic meteorServlet =
servletContext.addServlet("atmosphereServlet", new MeteorServlet());
meteorServlet.setAsyncSupported(true);
meteorServlet.addMapping("/realtime/*");
meteorServlet.setLoadOnStartup(3);
meteorServlet.setInitParameter(
"org.atmosphere.servlet", "fr.ippon.tatami.web.atmosphere.users.OnlineUsersServlet");
meteorServlet.setInitParameter(
"org.atmosphere.cpr.broadcasterCacheClass", "org.atmosphere.cache.HeaderBroadcasterCache");
meteorServlet.setInitParameter(
"org.atmosphere.cpr.broadcastFilterClasses",
"org.atmosphere.client.TrackMessageSizeFilter");
meteorServlet.setInitParameter("org.atmosphere.useNative", "true");
log.debug("Registering Spring Security Filter");
FilterRegistration.Dynamic springSecurityFilter =
servletContext.addFilter("springSecurityFilterChain", new DelegatingFilterProxy());
EnumSet<DispatcherType> disps =
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC);
springSecurityFilter.addMappingForServletNames(disps, true, "dispatcher", "atmosphereServlet");
log.debug("Web application fully configured");
}
private void configureCrossOriginFilter(final Environment environment, final String urlPattern) {
// http://www.eclipse.org/jetty/documentation/current/cross-origin-filter.html
final FilterRegistration.Dynamic filter =
environment.servlets().addFilter("CORS", CrossOriginFilter.class);
filter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, urlPattern);
filter.setInitParameter("allowedOrigins", "*");
filter.setInitParameter(
"allowedHeaders",
"Content-Type,Content-Length,Accept,Origin,X-Session,Authorization,User-Agent,X-Requested-With");
filter.setInitParameter("allowedMethods", "POST,GET,PUT");
}
private void addGzipFilter(ServletContext context) {
FilterRegistration.Dynamic filter =
context.addFilter(GZIP_FILTER_NAME, ApplicationGzipFilter.class);
filter.setInitParameter(
"mimeTypes",
"application/json,text/html,text/plain,text/xml,application/xhtml+xml,text/css,application/javascript,image/svg+xml");
filter.setAsyncSupported(true);
String[] mappings = new String[] {"/*"};
for (String mapping : mappings) {
filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, mapping);
}
}
@Override
public void contextInitialized(ServletContextEvent sce) {
ServerWebSocketContainer container =
(ServerWebSocketContainer)
sce.getServletContext().getAttribute(ServerContainer.class.getName());
FilterRegistration.Dynamic filter =
sce.getServletContext().addFilter(FILTER_NAME, JsrWebSocketFilter.class);
filter.setAsyncSupported(true);
if (!container.getConfiguredServerEndpoints().isEmpty()) {
filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
} else {
container.setContextToAddFilter((ServletContextImpl) sce.getServletContext());
}
}
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
appContext.register(SpringWebAppConfig.class);
ServletRegistration.Dynamic dispatcher =
servletContext.addServlet("springDispatcher", new DispatcherServlet(appContext));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
// UtF8 Character Filter.
FilterRegistration.Dynamic fr =
servletContext.addFilter("encodingFilter", CharacterEncodingFilter.class);
fr.setInitParameter("encoding", "UTF-8");
fr.setInitParameter("forceEncoding", "true");
fr.addMappingForUrlPatterns(null, true, "/*");
}
public void onStartup(ServletContext container) throws javax.servlet.ServletException {
AnnotationConfigWebApplicationContext applContext = new AnnotationConfigWebApplicationContext();
applContext.register(Config.class);
container.addListener(new ContextLoaderListener(applContext));
FilterRegistration.Dynamic characterEncodingFilter =
container.addFilter("characterEncodingFilter", new CharacterEncodingFilter());
characterEncodingFilter.addMappingForUrlPatterns(
EnumSet.allOf(DispatcherType.class), true, "/*");
characterEncodingFilter.setInitParameter("encoding", "UTF-8");
characterEncodingFilter.setInitParameter("forceEncoding", "true");
ServletRegistration.Dynamic dispatcher =
container.addServlet("dispatcher", new DispatcherServlet(applContext));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
@Override
public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {
ctx.addServlet(ConfigurationServlet.class.getSimpleName(), new ConfigurationServlet())
.addMapping(ConfigurationServlet.CONFIGURATION_ENDPOINT);
ctx.addServlet(
StagemonitorMetricsServlet.class.getSimpleName(), new StagemonitorMetricsServlet())
.addMapping("/stagemonitor/metrics");
ctx.addServlet(RumServlet.class.getSimpleName(), new RumServlet())
.addMapping("/stagemonitor/public/rum");
ctx.addServlet(FileServlet.class.getSimpleName(), new FileServlet())
.addMapping("/stagemonitor/static/*", "/stagemonitor/public/static/*");
ctx.addServlet(WidgetServlet.class.getSimpleName(), new WidgetServlet())
.addMapping("/stagemonitor");
final ServletRegistration.Dynamic requestTraceServlet =
ctx.addServlet(RequestTraceServlet.class.getSimpleName(), new RequestTraceServlet());
requestTraceServlet.addMapping("/stagemonitor/request-traces");
requestTraceServlet.setAsyncSupported(true);
final FilterRegistration.Dynamic securityFilter =
ctx.addFilter(
StagemonitorSecurityFilter.class.getSimpleName(), new StagemonitorSecurityFilter());
// Add as last filter so that other filters have the chance to set the
// WebPlugin.STAGEMONITOR_SHOW_WIDGET request attribute that overrides the widget visibility.
// That way the application can decide whether a particular user is allowed to see the widget.P
securityFilter.addMappingForUrlPatterns(
EnumSet.of(DispatcherType.REQUEST), true, "/stagemonitor/*");
securityFilter.setAsyncSupported(true);
final FilterRegistration.Dynamic monitorFilter =
ctx.addFilter(
HttpRequestMonitorFilter.class.getSimpleName(), new HttpRequestMonitorFilter());
monitorFilter.addMappingForUrlPatterns(
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD), false, "/*");
monitorFilter.setAsyncSupported(true);
final FilterRegistration.Dynamic userFilter =
ctx.addFilter(UserNameFilter.class.getSimpleName(), new UserNameFilter());
// Have this filter run last because user information may be populated by other filters e.g.
// Spring Security
userFilter.addMappingForUrlPatterns(
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD), true, "/*");
userFilter.setAsyncSupported(true);
ctx.addListener(MDCListener.class);
ctx.addListener(MonitoredHttpRequest.StagemonitorServletContextListener.class);
ctx.addListener(SpringMonitoredHttpRequest.HandlerMappingServletContextListener.class);
ctx.addListener(SessionCounter.class);
}
/** Initializes the GZip filter. */
private void initGzipFilter(ServletContext servletContext, EnumSet<DispatcherType> disps) {
log.debug("Registering GZip Filter");
FilterRegistration.Dynamic compressingFilter =
servletContext.addFilter("gzipFilter", new GZipServletFilter());
Map<String, String> parameters = new HashMap<>();
compressingFilter.setInitParameters(parameters);
compressingFilter.addMappingForUrlPatterns(disps, true, "*.css");
compressingFilter.addMappingForUrlPatterns(disps, true, "*.json");
compressingFilter.addMappingForUrlPatterns(disps, true, "*.html");
compressingFilter.addMappingForUrlPatterns(disps, true, "*.js");
compressingFilter.addMappingForUrlPatterns(disps, true, "*.svg");
compressingFilter.addMappingForUrlPatterns(disps, true, "*.ttf");
compressingFilter.addMappingForUrlPatterns(disps, true, "/api/*");
compressingFilter.addMappingForUrlPatterns(disps, true, "/metrics/*");
compressingFilter.setAsyncSupported(true);
}
/** Initializes Metrics. */
private void initMetrics(ServletContext servletContext, EnumSet<DispatcherType> disps) {
log.debug("Initializing Metrics registries");
servletContext.setAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE, metricRegistry);
servletContext.setAttribute(MetricsServlet.METRICS_REGISTRY, metricRegistry);
log.debug("Registering Metrics Filter");
FilterRegistration.Dynamic metricsFilter =
servletContext.addFilter("webappMetricsFilter", new InstrumentedFilter());
metricsFilter.addMappingForUrlPatterns(disps, true, "/*");
metricsFilter.setAsyncSupported(true);
log.debug("Registering Metrics Servlet");
ServletRegistration.Dynamic metricsAdminServlet =
servletContext.addServlet("metricsServlet", new MetricsServlet());
metricsAdminServlet.addMapping("/metrics/metrics/*");
metricsAdminServlet.setAsyncSupported(true);
metricsAdminServlet.setLoadOnStartup(2);
}
private void addControllerFilter(Class<?> klass)
throws InstantiationException, IllegalAccessException {
assert klass != null;
ControllerFilter filter;
if (Controller.class.isAssignableFrom(klass)) {
filter =
new ControllerFilter(
controllerFactory.createController(klass.asSubclass(Controller.class)));
} else {
SimpleControllerWrapper.checkValidSimpleControllerClass(klass);
SimpleControllerWrapper simpleController =
SimpleControllerWrapper.createInstance(controllerFactory.createController(klass));
configure(simpleController);
filter = new ControllerFilter(simpleController);
}
FilterRegistration.Dynamic dynamic = context.addFilter(klass.getSimpleName(), filter);
BeforeURL before = klass.getAnnotation(BeforeURL.class);
EnumSet<DispatcherType> set = EnumSet.of(DispatcherType.REQUEST);
dynamic.addMappingForUrlPatterns(set, false, before.value());
}
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
rootContext.register(ApplicationConfig.class);
servletContext.addListener(new ContextLoaderListener(rootContext));
AnnotationConfigWebApplicationContext dispatcherContext =
new AnnotationConfigWebApplicationContext();
dispatcherContext.register(WebConfig.class);
ServletRegistration.Dynamic dispatcher =
servletContext.addServlet("dispatcher", new DispatcherServlet(dispatcherContext));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
FilterRegistration.Dynamic hiddenHttpMethodFilter =
servletContext.addFilter("hiddenHttpMethodFilter", HiddenHttpMethodFilter.class);
hiddenHttpMethodFilter.addMappingForUrlPatterns(null, false, "/*");
}
private void configureCors(Environment environment) {
FilterRegistration.Dynamic filter =
environment.servlets().addFilter("CORS", CrossOriginFilter.class);
filter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
filter.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*");
filter.setInitParameter(
CrossOriginFilter.ALLOWED_HEADERS_PARAM,
"Content-Type,Authorization,X-Requested-With,Content-Length,Accept,Origin");
filter.setInitParameter(
CrossOriginFilter.ALLOWED_METHODS_PARAM, "OPTIONS,GET,PUT,POST,PATCH,DELETE,HEAD");
filter.setInitParameter(CrossOriginFilter.ACCESS_CONTROL_ALLOW_ORIGIN_HEADER, "*");
filter.setInitParameter(CrossOriginFilter.ALLOW_CREDENTIALS_PARAM, "true");
filter.setInitParameter(CrossOriginFilter.CHAIN_PREFLIGHT_PARAM, "false");
}
@Override
public void onStartup(ServletContext container) {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(WebConfig.class);
ctx.scan("com.taskstrategy.data", "com.taskstrategy.business");
ctx.setServletContext(container);
ctx.refresh();
container.addListener(new ContextLoaderListener(ctx));
container.setInitParameter("defaultHtmlEscape", "true");
FilterRegistration.Dynamic securityFilter =
container.addFilter(
"securityFilter", new DelegatingFilterProxy("springSecurityFilterChain"));
securityFilter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
ServletRegistration.Dynamic registration =
container.addServlet("dispatcher", new DispatcherServlet(ctx));
registration.setLoadOnStartup(1);
registration.setAsyncSupported(true);
registration.addMapping("/");
}
@Override
public void run(InflectorServerConfiguration configuration, Environment environment)
throws Exception {
final FilterRegistration.Dynamic cors =
environment.servlets().addFilter("crossOriginRequsts", CrossOriginFilter.class);
cors.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
SwaggerInflector inflector =
new SwaggerInflector(Configuration.read(configuration.getConfig()));
environment.jersey().getResourceConfig().registerResources(inflector.getResources());
// add serializers for swagger
environment.jersey().register(SwaggerSerializers.class);
// example serializers
environment.jersey().register(ExampleSerializer.class);
// mappers
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(new JsonNodeExampleSerializer());
Json.mapper().registerModule(simpleModule);
Yaml.mapper().registerModule(simpleModule);
}
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
Dynamic servlet =
servletContext.addServlet("DispatcherServlet", new DispatcherServlet(context));
servlet.setLoadOnStartup(1);
servlet.addMapping("/*");
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceEncoding(true);
FilterRegistration.Dynamic characterEncoding =
servletContext.addFilter("characterEncoding", characterEncodingFilter);
EnumSet<DispatcherType> dispatcherTypes =
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD);
characterEncoding.addMappingForUrlPatterns(dispatcherTypes, true, "/");
FilterRegistration.Dynamic corsFilter =
servletContext.addFilter("corsFilter", CORSFilter.class);
corsFilter.addMappingForUrlPatterns(null, false, "/*");
super.onStartup(servletContext);
}
// @Override
public void onStartup2(ServletContext servletContext) throws ServletException {
System.out.println("GreenhouseWebAppInitializer.onStartup()");
WebApplicationContext context = getContext();
servletContext.addListener(new ContextLoaderListener(context));
servletContext.addFilter("app", "org.apache.tapestry5.TapestryFilter");
servletContext.setInitParameter("tapestry.app-package", "com.noofinc");
FilterRegistration.Dynamic tapestryFilter =
servletContext.addFilter("app", new TapestryFilter());
tapestryFilter.addMappingForUrlPatterns(null, true, "/*");
tapestryFilter.setAsyncSupported(true);
ServletRegistration.Dynamic dispatcher =
servletContext.addServlet("servletDispatcher", new DispatcherServlet(context));
dispatcher.setAsyncSupported(true);
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/*");
}
@Override
protected void doAdditionalModuleStartLogic() throws Exception {
if (StringUtils.isNotBlank(dispatchServletName)) {
DispatcherServlet loaderServlet =
new DispatcherServlet(
(WebApplicationContext)
((SpringResourceLoader) rootResourceLoader.getResourceLoaders().get(0))
.getContext());
ServletRegistration registration =
getServletContext().addServlet(dispatchServletName, loaderServlet);
registration.addMapping("/" + dispatchServletName + "/*");
if (dispatchServletMappings != null) {
dispatchServletMappings
.stream()
.map(mapping -> "/" + mapping + "/*")
.forEach(registration::addMapping);
}
if (mapFilters) {
for (String filterName : filtersToMap) {
FilterRegistration filter = getServletContext().getFilterRegistration(filterName);
filter.addMappingForServletNames(null, true, dispatchServletName);
}
}
if (enableSpringSecurity) {
DelegatingFilterProxy filterProxy =
new DelegatingFilterProxy(
SPRING_SECURITY_FILTER_CHAIN,
(WebApplicationContext)
((SpringResourceLoader) rootResourceLoader.getResourceLoaders().get(0))
.getContext());
FilterRegistration.Dynamic securityFilter =
getServletContext()
.addFilter(KC_PREFIX + getModuleName() + SPRING_SECURITY_FILTER_PROXY, filterProxy);
securityFilter.addMappingForServletNames(null, true, dispatchServletName);
}
}
}
/** Initializes the static resources production Filter. */
private void initStaticResourcesProductionFilter(
ServletContext servletContext, EnumSet<DispatcherType> disps) {
log.debug("Registering static resources production Filter");
FilterRegistration.Dynamic staticResourcesProductionFilter =
servletContext.addFilter(
"staticResourcesProductionFilter", new StaticResourcesProductionFilter());
staticResourcesProductionFilter.addMappingForUrlPatterns(disps, true, "/");
staticResourcesProductionFilter.addMappingForUrlPatterns(disps, true, "/index.html");
staticResourcesProductionFilter.addMappingForUrlPatterns(disps, true, "/assets/*");
staticResourcesProductionFilter.addMappingForUrlPatterns(disps, true, "/scripts/*");
staticResourcesProductionFilter.addMappingForUrlPatterns(disps, true, "/favicon.ico");
staticResourcesProductionFilter.setAsyncSupported(true);
}
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.setConfigLocation("com.sms.config");
// 加入logback监听器
servletContext.addListener(new LogbackConfigListener());
// 加入spring监听器
servletContext.addListener(new ContextLoaderListener(context));
EnumSet<DispatcherType> dispatcherTypes =
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD);
// 加入spring mvc配置
ServletRegistration.Dynamic dispatcher =
servletContext.addServlet("spring-mvc", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
// 加入OpenEntityManagerInViewFilter
FilterRegistration.Dynamic openEntityManagerInViewFilter =
servletContext.addFilter(
"openEntityManagerInViewFilter", OpenEntityManagerInViewFilter.class);
openEntityManagerInViewFilter.addMappingForUrlPatterns(dispatcherTypes, true, "/*");
// 加入security过滤器
FilterRegistration.Dynamic securityFilterChain =
servletContext.addFilter("springSecurityFilterChain", new DelegatingFilterProxy());
securityFilterChain.addMappingForUrlPatterns(dispatcherTypes, true, "/*");
// 加入Spring编码过滤器
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceEncoding(true);
FilterRegistration.Dynamic encodingFilter =
servletContext.addFilter("characterEncodingFilter", characterEncodingFilter);
encodingFilter.addMappingForUrlPatterns(dispatcherTypes, true, "/");
}
@Override
public void run(AcikSozlukConfiguration acikSozlukConfiguration, Environment environment)
throws Exception {
// CORS Settings
FilterRegistration.Dynamic filter =
environment.servlets().addFilter("CORS", CrossOriginFilter.class);
filter.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET,PUT,POST,DELETE,OPTIONS");
filter.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*");
filter.setInitParameter(CrossOriginFilter.ACCESS_CONTROL_ALLOW_ORIGIN_HEADER, "*");
filter.setInitParameter(
CrossOriginFilter.ALLOWED_HEADERS_PARAM,
"Content-Type,Authorization,X-Requested-With,Content-Length,Accept,Origin");
filter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
// CORS Settings
final HeaderDAO headerDAO = new HeaderDAO(hibernateBundle.getSessionFactory());
final EntryDAO entryDAO = new EntryDAO(hibernateBundle.getSessionFactory());
final WriterDAO writerDAO = new WriterDAO(hibernateBundle.getSessionFactory());
environment.jersey().register(new HeaderResource(headerDAO, entryDAO, writerDAO));
environment.jersey().register(new WriterResource(writerDAO, headerDAO, entryDAO));
environment.jersey().register(new EntryResource(entryDAO, headerDAO, writerDAO));
}
/**
* Initialize servlet when application on startup.
*
* @param servletContext Get ServletContext.
* @throws ServletException push ServletException in up.
*/
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(WebAppConfig.class);
ctx.register(SecurityConfig.class);
servletContext.addListener(new ContextLoaderListener(ctx));
ctx.setServletContext(servletContext);
Dynamic servlet =
servletContext.addServlet(DISPATCHER_SERVLET_NAME, new DispatcherServlet(ctx));
servlet.setLoadOnStartup(1);
servlet.addMapping("/");
FilterRegistration.Dynamic encodingFilter =
servletContext.addFilter(ENCODING_FILTER_NAME, new CharacterEncodingFilter());
encodingFilter.setInitParameter("encoding", "UTF-8");
encodingFilter.setInitParameter("forceEncoding", "true");
encodingFilter.addMappingForUrlPatterns(null, true, "/*");
FilterRegistration.Dynamic springSecurityFilterChain =
servletContext.addFilter("springSecurityFilterChain", new DelegatingFilterProxy());
springSecurityFilterChain.addMappingForUrlPatterns(null, false, "/*");
}
WsServerContainer(ServletContext servletContext) {
this.servletContext = servletContext;
// Configure servlet context wide defaults
String value =
servletContext.getInitParameter(Constants.BINARY_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM);
if (value != null) {
setDefaultMaxBinaryMessageBufferSize(Integer.parseInt(value));
}
value = servletContext.getInitParameter(Constants.TEXT_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM);
if (value != null) {
setDefaultMaxTextMessageBufferSize(Integer.parseInt(value));
}
value =
servletContext.getInitParameter(
Constants.ENFORCE_NO_ADD_AFTER_HANDSHAKE_CONTEXT_INIT_PARAM);
if (value != null) {
setEnforceNoAddAfterHandshake(Boolean.parseBoolean(value));
}
// Executor config
int executorCoreSize = 0;
long executorKeepAliveTimeSeconds = 60;
value = servletContext.getInitParameter(Constants.EXECUTOR_CORE_SIZE_INIT_PARAM);
if (value != null) {
executorCoreSize = Integer.parseInt(value);
}
value = servletContext.getInitParameter(Constants.EXECUTOR_KEEPALIVETIME_SECONDS_INIT_PARAM);
if (value != null) {
executorKeepAliveTimeSeconds = Long.parseLong(value);
}
FilterRegistration.Dynamic fr =
servletContext.addFilter("Tomcat WebSocket (JSR356) Filter", new WsFilter());
fr.setAsyncSupported(true);
EnumSet<DispatcherType> types = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD);
fr.addMappingForUrlPatterns(types, true, "/*");
// Use a per web application executor for any threads that the WebSocket
// server code needs to create. Group all of the threads under a single
// ThreadGroup.
StringBuffer threadGroupName = new StringBuffer("WebSocketServer-");
threadGroupName.append(servletContext.getVirtualServerName());
threadGroupName.append('-');
if ("".equals(servletContext.getContextPath())) {
threadGroupName.append("ROOT");
} else {
threadGroupName.append(servletContext.getContextPath());
}
threadGroup = new ThreadGroup(threadGroupName.toString());
WsThreadFactory wsThreadFactory = new WsThreadFactory(threadGroup);
executorService =
new ThreadPoolExecutor(
executorCoreSize,
Integer.MAX_VALUE,
executorKeepAliveTimeSeconds,
TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
wsThreadFactory);
}
private void registerHiddenHttpMethodFilter(ServletContext servletContext) {
FilterRegistration.Dynamic fr =
servletContext.addFilter("hiddenHttpMethodFilter", HiddenHttpMethodFilter.class);
fr.addMappingForServletNames(
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD), false, DISPATCHER_SERVLET_NAME);
}
