import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * Finds all Jersey components that provide a specific contract, and invokes a callback with each discovered component to activate it.
 *
 * @param contract
 *     The contract that components must implement
 * @param consumer
 *     Callback to provide for each discovered component
 * @param <T>
 *     Type of the component to find and activate
 */
protected <T> void activate(@NonNull Class<T> contract, @NonNull ComponentConsumer<T> consumer) {
    Providers.getAllServiceHandles(locator, contract).forEach(handle -> {
        String name    = handle.getActiveDescriptor().getName();
        T      service = handle.getService();
        if (name == null) {
            name = getName(service.getClass());
        }
        consumer.accept(name, service);
    });
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("unchecked")
public boolean configure(FeatureContext context) {
    context.register(new WebSocketBinder());
    if (serverContainer == null) {
        logger.warn(Messages.get("web.socket.server.unsupported"));
    }

    for (Class endpointClass : endpointClasses) {
        WebSocket webSocket = getAnnotation(WebSocket.class, endpointClass);
        if (webSocket == null) continue;
        Class<? extends Annotation> scope = getScope(endpointClass);
        final Binding binding = Bindings.service(endpointClass).to(endpointClass).in(scope);
        Providers.getProviderContracts(endpointClass).forEach(binding::to);
        injectionManager.register(binding);
        DefaultServerEndpointConfig endpointConfig = new DefaultServerEndpointConfig(
                injectionManager,
                endpointClass,
                webSocket
        );
        if (serverContainer != null) {
            try {
                serverContainer.addEndpoint(endpointConfig);
            } catch (DeploymentException e) {
                throw new WebSocketException(e);
            }
        }
        if (webSocket.withSockJS()) {
            // create resource use modelProcessor
        }
    }

    return true;
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * Get a {@link java.util.LinkedHashSet collection} of available template processors.
 *
 * @return set of template processors.
 */
private Set<TemplateProcessor> getTemplateProcessors() {
    final Set<TemplateProcessor> templateProcessors = Sets.newLinkedHashSet();

    templateProcessors.addAll(Providers.getCustomProviders(injectionManager, TemplateProcessor.class));
    templateProcessors.addAll(Providers.getProviders(injectionManager, TemplateProcessor.class));

    return templateProcessors;
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * Get {@link org.glassfish.jersey.server.mvc.spi.ViewableContext viewable context}.
 * User defined (custom) contexts have higher priority than the default ones
 * (i.e. {@link ResolvingViewableContext}).
 *
 * @return {@code non-null} viewable context.
 */
private ViewableContext getViewableContext() {
    final Set<ViewableContext> customProviders =
            Providers.getCustomProviders(injectionManager, ViewableContext.class);
    if (!customProviders.isEmpty()) {
        return customProviders.iterator().next();
    }
    return Providers.getProviders(injectionManager, ViewableContext.class).iterator().next();
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
private Set<TemplateProcessor> getTemplateProcessors() {
    Set<TemplateProcessor> templateProcessors = Sets.newLinkedHashSet();

    templateProcessors.addAll(Providers.getCustomProviders(injectionManager, TemplateProcessor.class));
    templateProcessors.addAll(Providers.getProviders(injectionManager, TemplateProcessor.class));
    return templateProcessors;
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * Creates new instance.
 *
 * @param manager a {@link InjectionManager} object.
 */
@Inject
public OptionsMethodProcessor(InjectionManager manager) {
    methodList = Lists.newArrayList();

    methodList.add(new ModelProcessorUtil.Method(HttpMethod.OPTIONS, WILDCARD_TYPE, WILDCARD_TYPE,
            GenericOptionsInflector.class));

    generators = Providers.getAllRankedSortedProviders(manager, OptionsResponseGenerator.class);
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * <p>getStreamingProcesses.</p>
 *
 * @param manager InjectionManager.
 * @return a {@link java.lang.Iterable} object.
 */
public static Iterable<StreamingProcess> getStreamingProcesses(InjectionManager manager) {
    return Providers.getAllProviders(manager, StreamingProcess.class);
}
 

import org.glassfish.jersey.internal.inject.Providers; //导入依赖的package包/类
/**
 * <p>getTransformer.</p>
 *
 * @param transformerClass a {@link java.lang.Class} object.
 * @param <R>              Result.
 * @param <T>              Transformer.
 * @return a {@link java.lang.Iterable} object.
 */
protected <R, T extends Transformer<Transformed<R>>> Iterable<T> getTransformer(Class<T> transformerClass) {
    return Providers.getAllRankedSortedProviders(manager, transformerClass);
}