org.glassfish.jersey.internal.inject.ProviderBinder Maven / Gradle / Ivy
Show all versions of jaxrs-ri Show documentation
/*
* Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.jersey.internal.inject;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import jakarta.ws.rs.RuntimeType;
import jakarta.inject.Singleton;
import org.glassfish.jersey.model.ContractProvider;
import org.glassfish.jersey.model.internal.ComponentBag;
/**
* Class used for registration of the custom providers into injection manager.
*
* Custom providers are classes that implements specific JAX-RS or Jersey
* SPI interfaces (e.g. {@link jakarta.ws.rs.ext.MessageBodyReader}) and are
* supplied by the user. These providers will be bound into the injection manager
* annotated by a {@link Custom @Custom} qualifier annotation.
*
*
* Use the {@code @Custom} qualifier annotation to retrieve these providers
* from injection manager. You may also use a one of the provider accessor utility
* method defined in {@link Providers} class.
*
*
* @author Miroslav Fuksa
* @author Marek Potociar
* @author Michal Gajdos
*/
public class ProviderBinder {
private final InjectionManager injectionManager;
/**
* Create new provider binder instance.
*
* @param injectionManager the binder will use to bind the providers into.
*/
public ProviderBinder(final InjectionManager injectionManager) {
this.injectionManager = injectionManager;
}
/**
* 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) {
final T instance = injectionManager.getInstance(providerClass);
if (instance != null) {
injectionManager.register(createInstanceBinder(instance, model));
} else {
injectionManager.register(createClassBinder(model));
}
}
private static Binder createInstanceBinder(T instance, ContractProvider model) {
return new AbstractBinder() {
@Override
protected void configure() {
final InstanceBinding binding = bind(instance)
.in(model.getScope())
.qualifiedBy(CustomAnnotationLiteral.INSTANCE);
binding.to(model.getContracts());
int priority = model.getPriority(model.getImplementationClass());
if (priority > ContractProvider.NO_PRIORITY) {
binding.ranked(priority);
}
}
};
}
private static Binder createClassBinder(ContractProvider model) {
return new AbstractBinder() {
@Override
protected void configure() {
final ClassBinding binding = bind(model.getImplementationClass())
.in(model.getScope())
.qualifiedBy(CustomAnnotationLiteral.INSTANCE);
binding.to(model.getContracts());
int priority = model.getPriority(model.getImplementationClass());
if (priority > ContractProvider.NO_PRIORITY) {
binding.ranked(priority);
}
}
};
}
private static Collection createProviderBinders(Class providerClass, ContractProvider model) {
/* Create a Binder of the Provider with the concrete contract. */
Function binderFunction = contract -> new AbstractBinder() {
@Override
@SuppressWarnings("unchecked")
protected void configure() {
ClassBinding builder = bind(providerClass)
.in(model.getScope())
.qualifiedBy(CustomAnnotationLiteral.INSTANCE)
.to(contract);
int priority = model.getPriority(contract);
if (priority > ContractProvider.NO_PRIORITY) {
builder.ranked(priority);
}
}
};
/* Create Binders with all contracts and return their collection. */
return model.getContracts().stream()
.map(binderFunction)
.collect(Collectors.toList());
}
/**
* Bind contract provider model to a provider instance using the supplied injection manager.
*
* Scope value specified in the {@link ContractProvider contract provider model}
* is ignored as instances can only be bound as "singletons".
*
* @param providerInstance provider instance.
* @param model contract provider model.
*/
public static void bindProvider(Object providerInstance, ContractProvider model, InjectionManager injectionManager) {
injectionManager.register(createInstanceBinder(providerInstance, model));
}
private static Collection createProviderBinders(Object providerInstance, ContractProvider model) {
/* Create a Binder of the Provider with the concrete contract. */
Function binderFunction = contract -> new AbstractBinder() {
@Override
@SuppressWarnings("unchecked")
protected void configure() {
InstanceBinding builder = bind(providerInstance)
.qualifiedBy(CustomAnnotationLiteral.INSTANCE)
.to(contract);
int priority = model.getPriority(contract);
if (priority > ContractProvider.NO_PRIORITY) {
builder.ranked(priority);
}
}
};
/* Create Binders with all contracts and return their collection. */
return model.getContracts().stream()
.map(binderFunction)
.collect(Collectors.toList());
}
/**
* Bind all providers contained in {@code providerBag} (classes and instances) using injection manager. Configuration is
* also committed.
*
* @param componentBag bag of provider classes and instances.
* @param injectionManager injection manager the binder will use to bind the providers into.
*/
public static void bindProviders(final ComponentBag componentBag, final InjectionManager injectionManager) {
bindProviders(componentBag, null, Collections.emptySet(), injectionManager);
}
/**
* Bind all providers contained in {@code providerBag} (classes and instances) using injection manager. Configuration is
* also committed.
*
* @param componentBag bag of provider classes and instances.
* @param constrainedTo current runtime (client or server).
* @param registeredClasses classes which are manually registered by the user (not found by the classpath scanning).
* @param injectionManager injection manager the binder will use to bind the providers into.
*/
public static void bindProviders(ComponentBag componentBag,
RuntimeType constrainedTo,
Set> registeredClasses,
InjectionManager injectionManager) {
Predicate filter = ComponentBag.EXCLUDE_EMPTY
.and(ComponentBag.excludeMetaProviders(injectionManager));
/*
* Check the {@code component} whether it is correctly configured for client or server {@link RuntimeType runtime}.
*/
Predicate> correctlyConfigured =
componentClass -> Providers.checkProviderRuntime(
componentClass,
componentBag.getModel(componentClass),
constrainedTo,
registeredClasses == null || !registeredClasses.contains(componentClass),
false);
/*
* These binder will be registered to InjectionManager at the end of method because of a bulk registration to avoid a
* registration each binder alone.
*/
Collection binderToRegister = new ArrayList<>();
// Bind provider classes except for pure meta-providers and providers with empty contract models (e.g. resources)
Set> classes = new LinkedHashSet<>(componentBag.getClasses(filter));
if (constrainedTo != null) {
classes = classes.stream()
.filter(correctlyConfigured)
.collect(Collectors.toSet());
}
for (final Class providerClass : classes) {
final ContractProvider model = componentBag.getModel(providerClass);
binderToRegister.addAll(createProviderBinders(providerClass, model));
}
// Bind provider instances except for pure meta-providers and providers with empty contract models (e.g. resources)
Set