/** * Get a {@link java.util.LinkedHashSet collection} of available template processors. * * @return set of template processors. */ private Set<TemplateProcessor> getTemplateProcessors() { final Set<TemplateProcessor> templateProcessors = new LinkedHashSet<>(); templateProcessors.addAll(Providers.getCustomProviders(injectionManager, TemplateProcessor.class)); templateProcessors.addAll(Providers.getProviders(injectionManager, TemplateProcessor.class)); return templateProcessors; }
/** * Constructor expecting {@link InjectionManager} to be injected. * * @param injectionManager injection manager to be injected. */ @Inject public EntityInspectorImpl(final InjectionManager injectionManager) { Spliterator<EntityProcessor> entities = Providers.getAllProviders(injectionManager, EntityProcessor.class, new RankedComparator<>()).spliterator(); this.entityProcessors = StreamSupport.stream(entities, false).collect(Collectors.toList()); }
/** * Get the sorted iterable of all {@link RankedProvider providers} (custom and default) registered for the given service * provider contract in the underlying {@link InjectionManager injection manager} container. * * @param <T> service provider contract Java type. * @param injectionManager underlying injection manager. * @param contract service provider contract. * @param comparator comparator to sort the providers with. * @return set of all available ranked service providers for the contract. Return value is never null. */ public static <T> Iterable<T> getAllProviders( InjectionManager injectionManager, Class<T> contract, RankedComparator<T> comparator) { //noinspection unchecked return sortRankedProviders(comparator, getAllRankedProviders(injectionManager, contract)); }
@Override public void visitInvocable(final Invocable invocable) { // TODO: check invocable. Class resClass = invocable.getHandler().getHandlerClass(); if (resClass != null && !checkedClasses.contains(resClass)) { checkedClasses.add(resClass); final boolean provider = Providers.isProvider(resClass); int counter = 0; for (Annotation annotation : resClass.getAnnotations()) { if (SCOPE_ANNOTATIONS.contains(annotation.annotationType())) { counter++; } } if (counter == 0 && provider) { Errors.warning(resClass, LocalizationMessages.RESOURCE_IMPLEMENTS_PROVIDER(resClass, Providers.getProviderContracts(resClass))); } else if (counter > 1) { Errors.fatal(resClass, LocalizationMessages.RESOURCE_MULTIPLE_SCOPE_ANNOTATIONS(resClass)); } } }
Providers.getAllProviders(injectionManager, MessageBodyReader.class).spliterator(); messageBodyReaders = StreamSupport.stream(mbrSpliterator, false).collect(Collectors.toSet()); Providers.getAllProviders(injectionManager, MessageBodyWriter.class).spliterator(); messageBodyWriters = StreamSupport.stream(mbwSpliterator, false).collect(Collectors.toSet()); } else { messageBodyReaders = Providers.getCustomProviders(injectionManager, MessageBodyReader.class); messageBodyWriters = Providers.getCustomProviders(injectionManager, MessageBodyWriter.class); printProviders(LocalizationMessages.LOGGING_PRE_MATCH_FILTERS(), processingProviders.getPreMatchFilters(), sb); printProviders(LocalizationMessages.LOGGING_GLOBAL_REQUEST_FILTERS(), processingProviders.getGlobalRequestFilters(), sb); printProviders(LocalizationMessages.LOGGING_GLOBAL_RESPONSE_FILTERS(), processingProviders.getGlobalResponseFilters(), sb); printProviders(LocalizationMessages.LOGGING_GLOBAL_READER_INTERCEPTORS(), processingProviders.getDynamicFeatures(), sb); printProviders(LocalizationMessages.LOGGING_MESSAGE_BODY_READERS(), messageBodyReaders.stream().map(new WorkersToStringTransform<>()).collect(Collectors.toList()), sb); printProviders(LocalizationMessages.LOGGING_MESSAGE_BODY_WRITERS(), messageBodyWriters.stream().map(new WorkersToStringTransform<>()).collect(Collectors.toList()), sb);
@SuppressWarnings("unchecked") private static <T> Collection<Binder> createInstanceBinders(T instance) { Function<Class, Binder> binderFunction = contract -> new AbstractBinder() { @Override protected void configure() { bind(instance).to(contract).qualifiedBy(CustomAnnotationLiteral.INSTANCE); } }; return Providers.getProviderContracts(instance.getClass()).stream() .map(binderFunction) .collect(Collectors.toList()); }
componentClass -> Providers.checkProviderRuntime( componentClass, componentBag.getModel(componentClass), 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());
/** * Create new {@link org.glassfish.jersey.message.MessageBodyWorkers} initialization function * for requests and responses. * * @param requestRefProvider client request context reference injection provider. * @param workersProvider message body workers injection provider. * @param injectionManager injection manager. */ public RequestProcessingInitializationStage( Provider<Ref<ClientRequest>> requestRefProvider, MessageBodyWorkers workersProvider, InjectionManager injectionManager) { this.requestRefProvider = requestRefProvider; this.workersProvider = workersProvider; writerInterceptors = Collections.unmodifiableList( StreamSupport.stream( Providers.getAllProviders(injectionManager, WriterInterceptor.class, new RankedComparator<>()).spliterator(), false) .collect(Collectors.toList()) ); readerInterceptors = Collections.unmodifiableList( StreamSupport.stream( Providers.getAllProviders(injectionManager, ReaderInterceptor.class, new RankedComparator<>()).spliterator(), false) .collect(Collectors.toList()) ); }
.collect(Collectors.toList())); _writerInterceptors.addAll( StreamSupport.stream(processingProviders.getGlobalWriterInterceptors().spliterator(), false) .collect(Collectors.toList())); this.readerInterceptors = Collections.unmodifiableList(StreamSupport.stream(Providers.sortRankedProviders( new RankedComparator<>(), _readerInterceptors).spliterator(), false).collect(Collectors.toList())); this.writerInterceptors = Collections.unmodifiableList(StreamSupport.stream(Providers.sortRankedProviders( new RankedComparator<>(), _writerInterceptors).spliterator(), false).collect(Collectors.toList())); this.requestFilters.addAll(_requestFilters);
/** * Constructor for HK2 expecting {@link ServiceLocator} to be injected. * * @param locator service locator to be injected. */ @Inject public EntityInspectorImpl(final ServiceLocator locator) { this.entityProcessors = Lists.newArrayList(Providers.getAllProviders(locator, EntityProcessor.class, new RankedComparator<EntityProcessor>())); }
@Inject ParamConverterFactory(ServiceLocator locator) { converterProviders = new ArrayList<>(); final Set<ParamConverterProvider> customProviders = Providers.getCustomProviders(locator, ParamConverterProvider.class); converterProviders.addAll(customProviders); final Set<ParamConverterProvider> providers = Providers.getProviders(locator, ParamConverterProvider.class); providers.removeAll(customProviders); converterProviders.addAll(providers); }
@Inject ResourceMethodInvocationHandlerFactory(ServiceLocator locator) { providers = Providers.getProviders(locator, ResourceMethodInvocationHandlerProvider.class); }
@Override public ResourceConfig register(final Object component) { final Object object = requireNonNull(component); Class<?> clazz = object.getClass(); // If a class gets passed through as an object, cast to Class and register directly if (component instanceof Class<?>) { return super.register((Class<?>) component); } else if (Providers.isProvider(clazz) || Binder.class.isAssignableFrom(clazz)) { // If jersey supports this component's class (including hk2 Binders), register directly return super.register(object); } else { // Else register a binder that binds the instance to its class type try { // Need to create a new subclass dynamically here because hk2/jersey // doesn't add new bindings for the same class ClassPool pool = ClassPool.getDefault(); CtClass cc = pool.makeClass(SpecificBinder.class.getName() + UUID.randomUUID()); cc.setSuperclass(pool.get(SpecificBinder.class.getName())); Object binderProxy = cc.toClass().getConstructor(Object.class, Class.class).newInstance(object, clazz); super.register(binderProxy); return super.register(clazz); } catch (Exception e) { throw new RuntimeException(e); } } }
((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); Providers.getAllProviders(injectionManager, ApplicationEventListener.class, new RankedComparator<>()); if (!disableValidation()) { ComponentModelValidator validator = new ComponentModelValidator( bootstrapBag.getValueParamProviders(), bootstrapBag.getMessageBodyWorkers()); if (Errors.fatalIssuesFound() && !ignoreValidationError()) { throw new ModelValidationException(LocalizationMessages.RESOURCE_MODEL_VALIDATION_FAILED_AT_INIT(), ModelErrors.getErrorsAsResourceModelIssues(true)); if (ignoreValidationError()) { Errors.logErrors(true); .entityProviders(msgBodyWorkers) .valueSupplierProviders(bootstrapBag.getValueParamProviders()) .modelProcessors(Providers.getAllRankedSortedProviders(injectionManager, ModelProcessor.class)) .createService(serviceType -> Injections.getOrCreate(injectionManager, serviceType)) .processingProviders(processingProviders)
private ResourceModel processResourceModel(ResourceModel resourceModel) { final Iterable<RankedProvider<ModelProcessor>> allRankedProviders = Providers.getAllRankedProviders(locator, ModelProcessor.class); final Iterable<ModelProcessor> modelProcessors = Providers.sortRankedProviders(new RankedComparator<ModelProcessor>(), allRankedProviders); for (final ModelProcessor modelProcessor : modelProcessors) { resourceModel = modelProcessor.processResourceModel(resourceModel, getConfiguration()); } return resourceModel; }
ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; ComponentBag componentBag = serverBag.getRuntimeConfig().getComponentBag(); ResourceConfig.unwrapApplication(serverBag.getRuntimeConfig()).getClass(), NameBinding.class); Providers.getAllRankedProviders(injectionManager, ContainerResponseFilter.class); Providers.getAllRankedProviders(injectionManager, ContainerRequestFilter.class); Providers.getAllRankedProviders(injectionManager, ReaderInterceptor.class); Providers.getAllRankedProviders(injectionManager, WriterInterceptor.class); nameBoundWriterInterceptorsInverse); Iterable<DynamicFeature> dynamicFeatures = Providers.getAllProviders(injectionManager, DynamicFeature.class);
ResourceMethodInvocationHandlerFactory(InjectionManager injectionManager) { this.providers = Values.lazy((Value<Set<ResourceMethodInvocationHandlerProvider>>) () -> Providers.getProviders(injectionManager, ResourceMethodInvocationHandlerProvider.class)); }
/** * Return the first found {@link AsyncContextDelegateProvider} * (via {@link Providers#getAllProviders(InjectionManager, Class)}) or {@code #DEFAULT_ASYNC_DELEGATE} if * other delegate cannot be found. * * @return a non-null AsyncContextDelegateProvider. */ private AsyncContextDelegateProvider getAsyncExtensionDelegate() { final Iterator<AsyncContextDelegateProvider> providers = Providers.getAllProviders(appHandler.getInjectionManager(), AsyncContextDelegateProvider.class).iterator(); if (providers.hasNext()) { return providers.next(); } return (request, response) -> DEFAULT_ASYNC_DELEGATE; }
/** * Create a new Jersey server-side application handler configured by a * {@link Application JAX-RS Application (sub-)class}. * * @param jaxrsApplicationClass JAX-RS {@code Application} (sub-)class that will be * instantiated and used to configure the new Jersey * application handler. */ public ApplicationHandler(final Class<? extends Application> jaxrsApplicationClass) { this.locator = Injections.createLocator(new ServerBinder(null), new ApplicationBinder()); locator.setDefaultClassAnalyzerName(JerseyClassAnalyzer.NAME); final LazyValue<Iterable<ComponentProvider>> componentProviders = getLazyInitializedComponentProviders(locator); this.application = createApplication(jaxrsApplicationClass, componentProviders); this.runtimeConfig = ResourceConfig.createRuntimeConfig(application); this.runtime = Errors.processWithException(new Producer<ServerRuntime>() { @Override public ServerRuntime call() { return initialize(componentProviders.get()); } }); this.containerLifecycleListeners = Providers.getAllProviders(locator, ContainerLifecycleListener.class); }
/** * Get the iterable of all providers (custom and default) registered for the given service provider contract * in the underlying {@link InjectionManager injection manager} container. * * @param <T> service provider contract Java type. * @param injectionManager underlying injection manager. * @param contract service provider contract. * @return iterable of all available service provider instances for the contract. Return value is never null. */ public static <T> Iterable<T> getAllProviders(InjectionManager injectionManager, Class<T> contract) { return getAllProviders(injectionManager, contract, (Comparator<T>) null); }