Refine search
/** * Pre-initialize the client runtime. */ public void preInitialize() { // pre-initialize MessageBodyWorkers injectionManager.getInstance(MessageBodyWorkers.class); }
/** * Register/bind custom provider instances. Registered providers will be handled * always as Singletons. * * @param instances custom provider instances. */ public void bindInstances(final Collection<Object> instances) { List<Binder> binders = instances.stream() .map(ProviderBinder::createInstanceBinders) .flatMap(Collection::stream) .collect(Collectors.toList()); injectionManager.register(CompositeBinder.wrap(binders)); }
@PostConstruct private void inject(final InvocationContext context) throws Exception { final Object beanInstance = context.getTarget(); injectionManager.inject(beanInstance, CdiComponentProvider.CDI_CLASS_ANALYZER); // Invoke next interceptor in chain context.proceed(); } }
/** * Creates a new instance of processor. * @param injectionManager injection manager. * @param monitoringEventListener Monitoring event listener. */ MonitoringStatisticsProcessor( final InjectionManager injectionManager, final MonitoringEventListener monitoringEventListener) { this.monitoringEventListener = monitoringEventListener; final ResourceModel resourceModel = injectionManager.getInstance(ExtendedResourceContext.class).getResourceModel(); this.statisticsBuilder = new MonitoringStatisticsImpl.Builder(resourceModel); this.statisticsCallbackList = injectionManager.getAllInstances(MonitoringStatisticsListener.class); this.scheduler = injectionManager.getInstance(ScheduledExecutorService.class, BackgroundSchedulerLiteral.INSTANCE); this.interval = PropertiesHelper.getValue(injectionManager.getInstance(Configuration.class).getProperties(), ServerProperties.MONITORING_STATISTICS_REFRESH_INTERVAL, DEFAULT_INTERVAL, Collections.<String, String>emptyMap()); }
@Override public void onShutdown(final Container container) { try { for (final ContainerLifecycleListener listener : containerLifecycleListeners) { listener.onShutdown(container); } } finally { try { // Call @PreDestroy method on Application. injectionManager.preDestroy(ResourceConfig.unwrapApplication(application)); } finally { // Shutdown ServiceLocator. // Takes care of the injected executors & schedulers shut-down too. managedObjectsFinalizer.preDestroy(); injectionManager.shutdown(); } } } }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; ResourceConfig runtimeConfig = serverBag.getRuntimeConfig(); ComponentBag componentBag = runtimeConfig.getComponentBag(); OptionsMethodProcessor optionsMethodProcessor = new OptionsMethodProcessor(); injectionManager.register(Bindings.service(optionsMethodProcessor).to(ModelProcessor.class)); // Get all model processors, registered as an instance or class List<ModelProcessor> modelProcessors = Stream.concat( componentBag.getClasses(CONTRACT_PROVIDER_MODEL_PROCESSOR_ONLY).stream() .map(injectionManager::createAndInitialize), componentBag.getInstances(CONTRACT_PROVIDER_MODEL_PROCESSOR_ONLY).stream()) .map(CAST_TO_MODEL_PROCESSOR) .collect(Collectors.toList()); modelProcessors.add(optionsMethodProcessor); // model processors registered using binders List<ModelProcessor> modelProcessorsFromBinders = ComponentBag .getFromBinders(injectionManager, componentBag, CAST_TO_MODEL_PROCESSOR, BINDING_MODEL_PROCESSOR_ONLY); modelProcessors.addAll(modelProcessorsFromBinders); serverBag.setModelProcessors(modelProcessors); } }
if (!providerClasses.isEmpty()) { injectionManager = Injections.createInjectionManager(injectionManager); injectionManager.register(new AbstractBinder() { @Override protected void configure() { providers.add(injectionManager.createAndInitialize(providerClass)); .collect(Collectors.toList())); _writerInterceptors.addAll( StreamSupport.stream(processingProviders.getGlobalWriterInterceptors().spliterator(), false) .collect(Collectors.toList())); new RankedComparator<>(), _readerInterceptors).spliterator(), false).collect(Collectors.toList())); this.writerInterceptors = Collections.unmodifiableList(StreamSupport.stream(Providers.sortRankedProviders( new RankedComparator<>(), _writerInterceptors).spliterator(), false).collect(Collectors.toList()));
if (constrainedTo != null) { classes = classes.stream() .filter(correctlyConfigured) .collect(Collectors.toSet()); if (constrainedTo != null) { instances = instances.stream() .filter(component -> correctlyConfigured.test(component.getClass())) .collect(Collectors.toSet()); injectionManager.register(CompositeBinder.wrap(binderToRegister));
return new ResourceConfig(); } else if (applicationClass == Application.class) { return new Application(); injectionManager.register(Bindings.serviceAsContract(applicationClass).in(Singleton.class)); appClassBound = true; ? injectionManager.getInstance(applicationClass) : injectionManager.createAndInitialize(applicationClass); if (app instanceof ResourceConfig) { final ResourceConfig _rc = (ResourceConfig) app; final Class<? extends Application> innerAppClass = _rc.getApplicationClass(); if (innerAppClass != null) { Application innerApp = createApplication(injectionManager, innerAppClass, componentProvidersValue); _rc.setApplication(innerApp);
requestResponseBindingExternalized = rrbExternalized; final AbstractBinder webComponentBinder = new WebComponentBinder(resourceConfig.getProperties()); resourceConfig.register(webComponentBinder); && resourceConfig.isProperty(ServletProperties.FILTER_FORWARD_ON_404); this.queryParamsAsFormParams = !resourceConfig.isProperty(ServletProperties.QUERY_PARAMS_AS_FORM_PARAMS_DISABLED); this.configSetStatusOverSendError = ServerProperties.getValue(resourceConfig.getProperties(), ServerProperties.RESPONSE_SET_STATUS_OVER_SEND_ERROR, false, Boolean.class); this.backgroundTaskScheduler = appHandler.getInjectionManager() .getInstance(ScheduledExecutorService.class, BackgroundSchedulerLiteral.INSTANCE);
injectionManager.register(new MessagingBinders.MessageBodyProviders(application.getProperties(), RuntimeType.SERVER)); ((ResourceConfig) application).lock(); if (!CommonProperties.getValue(runtimeConfig.getProperties(), RuntimeType.SERVER, CommonProperties.FEATURE_AUTO_DISCOVERY_DISABLE, Boolean.FALSE, Boolean.class)) { runtimeConfig.configureAutoDiscoverableProviders(injectionManager, bootstrapBag.getAutoDiscoverables()); } else { runtimeConfig.configureForcedAutoDiscoverableProviders(injectionManager); executorProvidersConfigurator.init(injectionManager, bootstrapBag); injectionManager.completeRegistration(); () -> injectionManager.getInstance(RequestProcessingContextReference.class)); ResourceBag resourceBag = bootstrapBag.getResourceBag(); for (final Object instance : componentBag.getInstances(ComponentBag.excludeMetaProviders(injectionManager))) { injectionManager.inject(instance); injectionManager.inject(instance); compositeListener.onEvent(initFinishedEvent); MonitoringContainerListener containerListener = injectionManager.getInstance(MonitoringContainerListener.class); containerListener.init(compositeListener, initFinishedEvent);
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; Application resultApplication; // ApplicationConfigurer was created with an Application instance. if (application != null) { if (application instanceof ResourceConfig) { ResourceConfig rc = (ResourceConfig) application; if (rc.getApplicationClass() != null) { rc.setApplication(createApplication( injectionManager, rc.getApplicationClass(), serverBag.getComponentProviders())); } } resultApplication = application; // ApplicationConfigurer was created with an Application class. } else { resultApplication = createApplication(injectionManager, applicationClass, serverBag.getComponentProviders()); } serverBag.setApplication(resultApplication); injectionManager.register(Bindings.service(resultApplication).to(Application.class)); }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; ResourceConfig runtimeConfig = serverBag.getRuntimeConfig(); ComponentBag componentBag = runtimeConfig.getComponentBag(); ManagedObjectsFinalizer finalizer = serverBag.getManagedObjectsFinalizer(); // TODO: Do we need to register DEFAULT Executor and ScheduledExecutor to InjectionManager? ScheduledExecutorServiceProvider defaultScheduledExecutorProvider = new DefaultBackgroundSchedulerProvider(); InstanceBinding<ScheduledExecutorServiceProvider> schedulerBinding = Bindings .service(defaultScheduledExecutorProvider) .to(ScheduledExecutorServiceProvider.class) .qualifiedBy(BackgroundSchedulerLiteral.INSTANCE); injectionManager.register(schedulerBinding); finalizer.registerForPreDestroyCall(defaultScheduledExecutorProvider); ExecutorServiceProvider defaultAsyncExecutorProvider = new DefaultManagedAsyncExecutorProvider(); InstanceBinding<ExecutorServiceProvider> executorBinding = Bindings .service(defaultAsyncExecutorProvider) .to(ExecutorServiceProvider.class); injectionManager.register(executorBinding); finalizer.registerForPreDestroyCall(defaultAsyncExecutorProvider); registerExecutors(injectionManager, componentBag, defaultAsyncExecutorProvider, defaultScheduledExecutorProvider); }
private ApplicationContext createSpringContext() { ApplicationHandler applicationHandler = injectionManager.getInstance(ApplicationHandler.class); ApplicationContext springContext = (ApplicationContext) applicationHandler.getConfiguration() .getProperty(PARAM_SPRING_CONTEXT); if (springContext == null) { String contextConfigLocation = (String) applicationHandler.getConfiguration() .getProperty(PARAM_CONTEXT_CONFIG_LOCATION); springContext = createXmlSpringConfiguration(contextConfigLocation); } return springContext; }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; serverBag.setApplicationHandler(ApplicationHandler.this); serverBag.setConfiguration(ResourceConfig.createRuntimeConfig(serverBag.getApplication())); // TODO: Do we really need these three bindings in DI provider? What JAX-RS specification says? InstanceBinding<ApplicationHandler> handlerBinding = Bindings.service(ApplicationHandler.this) .to(ApplicationHandler.class); InstanceBinding<ResourceConfig> configBinding = Bindings.service(serverBag.getRuntimeConfig()) .to(Configuration.class) .to(ServerConfig.class); injectionManager.register(handlerBinding); injectionManager.register(configBinding); } }
/** * Bind contract provider model to a provider class using the supplied injection manager. * * @param providerClass provider class. * @param model contract provider model. */ public static void bindProvider(Class<?> providerClass, ContractProvider model, InjectionManager injectionManager) { injectionManager.register(CompositeBinder.wrap(createProviderBinders(providerClass, model))); }
feature = injectionManager.createAndInitialize(registration.getFeatureClass()); managedObjectsFinalizer.registerForPreDestroyCall(feature); } else { injectionManager.inject(feature);
@Override public void postInit(InjectionManager injectionManager, BootstrapBag bootstrapBag) { contextResolverFactory.initialize(injectionManager.getAllInstances(ContextResolver.class)); bootstrapBag.setContextResolvers(contextResolverFactory); } }
private void close() { if (closed.compareAndSet(false, true)) { try { for (final ClientLifecycleListener listener : lifecycleListeners) { try { listener.onClose(); } catch (final Throwable t) { LOG.log(Level.WARNING, LocalizationMessages.ERROR_LISTENER_CLOSE(listener.getClass().getName()), t); } } } finally { try { connector.close(); } finally { managedObjectsFinalizer.preDestroy(); injectionManager.shutdown(); } } } }