final Iterable<ApplicationEventListener> appEventListeners = Providers.getAllProviders(locator,
ApplicationEventListener.class, new RankedComparator<ApplicationEventListener>());
if (appEventListeners.iterator().hasNext()) {
compositeListener = new CompositeApplicationEventListener(appEventListeners);
compositeListener.onEvent(new ApplicationEventImpl(ApplicationEvent.Type.INITIALIZATION_START,
this.runtimeConfig, componentBag.getRegistrations(), resourceBag.classes, resourceBag.instances,
null));
}
processingProviders = getProcessingProviders(componentBag);
// initialize processing provider reference
final GenericType<Ref<ProcessingProviders>> refGenericType = new GenericType<Ref<ProcessingProviders>>() {
};
final Ref<ProcessingProviders> refProcessingProvider = locator.getService(refGenericType.getType());
refProcessingProvider.set(processingProviders);
resourceModel = new ResourceModel.Builder(resourceBag.getRootResources(), false).build();
resourceModel = processResourceModel(resourceModel);
if (!disableValidation) {
final ComponentModelValidator validator = new ComponentModelValidator(locator);
validator.validate(resourceModel);
}
if (Errors.fatalIssuesFound() && !ignoreValidationErrors) {
throw new ModelValidationException(LocalizationMessages.RESOURCE_MODEL_VALIDATION_FAILED_AT_INIT(),
ModelErrors.getErrorsAsResourceModelIssues(true));
}
} finally {
if (ignoreValidationErrors) {
Errors.logErrors(true);
Errors.reset(); // reset errors to the state before validation phase
} else {
Errors.unmark();
}
}
bindEnhancingResourceClasses(resourceModel, resourceBag, componentProviders);
// initiate resource model into JerseyResourceContext
final JerseyResourceContext jerseyResourceContext = locator.getService(JerseyResourceContext.class);
jerseyResourceContext.setResourceModel(resourceModel);
final RuntimeModelBuilder runtimeModelBuilder = locator.getService(RuntimeModelBuilder.class);
runtimeModelBuilder.setProcessingProviders(processingProviders);
// assembly request processing chain
/**
* Root hierarchical request matching acceptor.
* Invoked in a single linear stage as part of the main linear accepting chain.
*/
final Router resourceRoutingRoot = runtimeModelBuilder.buildModel(resourceModel.getRuntimeResourceModel(), false);
final ReferencesInitializer referencesInitializer = locator.createAndInitialize(ReferencesInitializer.class);
final ContainerFilteringStage preMatchRequestFilteringStage = new ContainerFilteringStage(
processingProviders.getPreMatchFilters(),
processingProviders.getGlobalResponseFilters());
final RoutingStage routingStage = new RoutingStage(resourceRoutingRoot);
final ContainerFilteringStage resourceFilteringStage = new ContainerFilteringStage(
processingProviders.getGlobalRequestFilters(), null);
final RoutedInflectorExtractorStage routedInflectorExtractorStage = new RoutedInflectorExtractorStage();
/**
* Root linear request acceptor. This is the main entry point for the whole request processing.
*/
final Stage<RequestProcessingContext> rootStage = Stages
.chain(referencesInitializer)
.to(locator.createAndInitialize(ContainerMessageBodyWorkersInitializer.class))
.to(preMatchRequestFilteringStage)
.to(routingStage)
.to(resourceFilteringStage)
.build(routedInflectorExtractorStage);
this.runtime = locator.createAndInitialize(ServerRuntime.Builder.class)
.build(rootStage, compositeListener, processingProviders);
// Inject instances.
for (final Object instance : componentBag.getInstances(ComponentBag.EXCLUDE_META_PROVIDERS)) {
locator.inject(instance);
}
for (final Object instance : resourceBag.instances) {
locator.inject(instance);
}
logApplicationInitConfiguration(locator, resourceBag, processingProviders);
if (compositeListener != null) {
final ApplicationEvent initFinishedEvent = new ApplicationEventImpl(
ApplicationEvent.Type.INITIALIZATION_APP_FINISHED, runtimeConfig,
componentBag.getRegistrations(), resourceBag.classes, resourceBag.instances, resourceModel);
compositeListener.onEvent(initFinishedEvent);
final MonitoringContainerListener containerListener