Examples with ComponentBag org.glassfish.jersey.model.internal.ComponentBag used on opensource projects

Example 1 with ComponentBag

use of org.glassfish.jersey.model.internal.ComponentBag in project jersey by jersey.

the class ProviderBinder method bindProviders.

/**
     * Bind all providers contained in {@code p roviderBag} (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<Class<?>> registeredClasses, InjectionManager injectionManager) {
    Predicate<ContractProvider> 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<Class<?>> correctlyConfigured = componentClass -> Providers.checkProviderRuntime(componentClass, componentBag.getModel(componentClass), constrainedTo, registeredClasses == null || !registeredClasses.contains(componentClass), false);
    /*
         * These binder will be register to Bean Manager at the and of method because of a bulk registration to avoid register
         * each binder alone.
         */
    Collection<Binder> binderToRegister = new ArrayList<>();
    // Bind provider classes except for pure meta-providers and providers with empty contract models (e.g. resources)
    Set<Class<?>> 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 pure provider instances except for pure meta-providers and providers with empty contract models (e.g. resources)
    Set<Object> instances = componentBag.getInstances(filter);
    if (constrainedTo != null) {
        instances = instances.stream().filter(component -> correctlyConfigured.test(component.getClass())).collect(Collectors.toSet());
    }
    for (final Object provider : instances) {
        final ContractProvider model = componentBag.getModel(provider.getClass());
        binderToRegister.addAll(createProviderBinders(provider, model));
    }
    injectionManager.register(CompositeBinder.wrap(binderToRegister));
}

Example 2 with ComponentBag

use of org.glassfish.jersey.model.internal.ComponentBag in project jersey by jersey.

the class ApplicationHandler method bindEnhancingResourceClasses.

private void bindEnhancingResourceClasses(final ResourceModel resourceModel, final ResourceBag resourceBag, final Iterable<ComponentProvider> componentProviders) {
    final Set<Class<?>> newClasses = new HashSet<>();
    final Set<Object> newInstances = new HashSet<>();
    for (final Resource res : resourceModel.getRootResources()) {
        newClasses.addAll(res.getHandlerClasses());
        newInstances.addAll(res.getHandlerInstances());
    }
    newClasses.removeAll(resourceBag.classes);
    newInstances.removeAll(resourceBag.instances);
    final ComponentBag emptyComponentBag = ComponentBag.newInstance(input -> false);
    bindProvidersAndResources(componentProviders, emptyComponentBag, newClasses, newInstances);
}

Example 3 with ComponentBag

use of org.glassfish.jersey.model.internal.ComponentBag in project jersey by jersey.

the class ApplicationHandler method initialize.

/**
     * Assumes the configuration field is initialized with a valid ResourceConfig.
     */
private ServerRuntime initialize(Iterable<ComponentProvider> componentProviders) {
    LOGGER.config(LocalizationMessages.INIT_MSG(Version.getBuildId()));
    // Lock original ResourceConfig.
    if (application instanceof ResourceConfig) {
        ((ResourceConfig) application).lock();
    }
    final boolean ignoreValidationErrors = ServerProperties.getValue(runtimeConfig.getProperties(), ServerProperties.RESOURCE_VALIDATION_IGNORE_ERRORS, Boolean.FALSE, Boolean.class);
    final boolean disableValidation = ServerProperties.getValue(runtimeConfig.getProperties(), ServerProperties.RESOURCE_VALIDATION_DISABLE, Boolean.FALSE, Boolean.class);
    final ResourceBag resourceBag;
    final ProcessingProviders processingProviders;
    final ComponentBag componentBag;
    ResourceModel resourceModel;
    CompositeApplicationEventListener compositeListener = null;
    // mark begin of validation phase
    Errors.mark();
    try {
        // AutoDiscoverable.
        if (!CommonProperties.getValue(runtimeConfig.getProperties(), RuntimeType.SERVER, CommonProperties.FEATURE_AUTO_DISCOVERY_DISABLE, Boolean.FALSE, Boolean.class)) {
            runtimeConfig.configureAutoDiscoverableProviders(injectionManager);
        } else {
            runtimeConfig.configureForcedAutoDiscoverableProviders(injectionManager);
        }
        // Configure binders and features.
        runtimeConfig.configureMetaProviders(injectionManager);
        final ResourceBag.Builder resourceBagBuilder = new ResourceBag.Builder();
        // Adding programmatic resource models
        for (final Resource programmaticResource : runtimeConfig.getResources()) {
            resourceBagBuilder.registerProgrammaticResource(programmaticResource);
        }
        // Introspecting classes & instances
        for (final Class<?> c : runtimeConfig.getClasses()) {
            try {
                final Resource resource = Resource.from(c, disableValidation);
                if (resource != null) {
                    resourceBagBuilder.registerResource(c, resource);
                }
            } catch (final IllegalArgumentException ex) {
                LOGGER.warning(ex.getMessage());
            }
        }
        for (final Object o : runtimeConfig.getSingletons()) {
            try {
                final Resource resource = Resource.from(o.getClass(), disableValidation);
                if (resource != null) {
                    resourceBagBuilder.registerResource(o, resource);
                }
            } catch (final IllegalArgumentException ex) {
                LOGGER.warning(ex.getMessage());
            }
        }
        resourceBag = resourceBagBuilder.build();
        runtimeConfig.lock();
        componentBag = runtimeConfig.getComponentBag();
        final Class<ExternalRequestScope>[] extScopes = ServiceFinder.find(ExternalRequestScope.class, true).toClassArray();
        boolean extScopeBound = false;
        if (extScopes.length == 1) {
            for (final ComponentProvider p : componentProviders) {
                if (p.bind(extScopes[0], new HashSet<Class<?>>() {

                    {
                        add(ExternalRequestScope.class);
                    }
                })) {
                    extScopeBound = true;
                    break;
                }
            }
        } else if (extScopes.length > 1) {
            if (LOGGER.isLoggable(Level.WARNING)) {
                final StringBuilder scopeList = new StringBuilder("\n");
                for (final Class<ExternalRequestScope> ers : extScopes) {
                    scopeList.append("   ").append(ers.getTypeParameters()[0]).append('\n');
                }
                LOGGER.warning(LocalizationMessages.WARNING_TOO_MANY_EXTERNAL_REQ_SCOPES(scopeList.toString()));
            }
        }
        if (!extScopeBound) {
            injectionManager.register(new ServerRuntime.NoopExternalRequestScopeBinder());
        }
        bindProvidersAndResources(componentProviders, componentBag, resourceBag.classes, resourceBag.instances);
        for (final ComponentProvider componentProvider : componentProviders) {
            componentProvider.done();
        }
        final Iterable<ApplicationEventListener> appEventListeners = Providers.getAllProviders(injectionManager, ApplicationEventListener.class, new RankedComparator<>());
        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 = injectionManager.getInstance(refGenericType.getType());
        refProcessingProvider.set(processingProviders);
        resourceModel = new ResourceModel.Builder(resourceBag.getRootResources(), false).build();
        resourceModel = processResourceModel(resourceModel);
        if (!disableValidation) {
            final ComponentModelValidator validator = new ComponentModelValidator(injectionManager);
            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);
            // reset errors to the state before validation phase
            Errors.reset();
        } else {
            Errors.unmark();
        }
    }
    bindEnhancingResourceClasses(resourceModel, resourceBag, componentProviders);
    ExecutorProviders.createInjectionBindings(injectionManager);
    // initiate resource model into JerseyResourceContext
    final JerseyResourceContext jerseyResourceContext = injectionManager.getInstance(JerseyResourceContext.class);
    jerseyResourceContext.setResourceModel(resourceModel);
    msgBodyWorkers = injectionManager.getInstance(MessageBodyWorkers.class);
    // assembly request processing chain
    final ReferencesInitializer referencesInitializer = injectionManager.createAndInitialize(ReferencesInitializer.class);
    final ContainerFilteringStage preMatchRequestFilteringStage = new ContainerFilteringStage(processingProviders.getPreMatchFilters(), processingProviders.getGlobalResponseFilters());
    final ChainableStage<RequestProcessingContext> routingStage = Routing.forModel(resourceModel.getRuntimeResourceModel()).beanManager(injectionManager).resourceContext(jerseyResourceContext).configuration(runtimeConfig).entityProviders(msgBodyWorkers).processingProviders(processingProviders).buildStage();
    final ContainerFilteringStage resourceFilteringStage = new ContainerFilteringStage(processingProviders.getGlobalRequestFilters(), null);
    /**
         *  Root linear request acceptor. This is the main entry point for the whole request processing.
         */
    final Stage<RequestProcessingContext> rootStage = Stages.chain(referencesInitializer).to(preMatchRequestFilteringStage).to(routingStage).to(resourceFilteringStage).build(Routing.matchedEndpointExtractor());
    final ServerRuntime serverRuntime = injectionManager.createAndInitialize(ServerRuntime.Builder.class).build(rootStage, compositeListener, processingProviders);
    // Inject instances.
    for (final Object instance : componentBag.getInstances(ComponentBag.excludeMetaProviders(injectionManager))) {
        injectionManager.inject(instance);
    }
    for (final Object instance : resourceBag.instances) {
        injectionManager.inject(instance);
    }
    logApplicationInitConfiguration(injectionManager, 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 = injectionManager.getInstance(MonitoringContainerListener.class);
        containerListener.init(compositeListener, initFinishedEvent);
    }
    return serverRuntime;
}

Example 4 with ComponentBag

use of org.glassfish.jersey.model.internal.ComponentBag in project jersey by jersey.

the class ApplicationHandler method bindProvidersAndResources.

private void bindProvidersAndResources(final Iterable<ComponentProvider> componentProviders, final ComponentBag componentBag, final Collection<Class<?>> resourceClasses, final Collection<Object> resourceInstances) {
    JerseyResourceContext resourceContext = injectionManager.getInstance(JerseyResourceContext.class);
    Set<Class<?>> registeredClasses = runtimeConfig.getRegisteredClasses();
    /*
         * Check the {@code component} whether it is correctly configured for client or server {@link RuntimeType runtime}.
         */
    java.util.function.Predicate<Class<?>> correctlyConfigured = componentClass -> Providers.checkProviderRuntime(componentClass, componentBag.getModel(componentClass), RuntimeType.SERVER, !registeredClasses.contains(componentClass), resourceClasses.contains(componentClass));
    /*
         * Check the {@code resource class} whether it is correctly configured for client or server {@link RuntimeType runtime}.
         */
    BiPredicate<Class<?>, ContractProvider> correctlyConfiguredResource = (resourceClass, model) -> Providers.checkProviderRuntime(resourceClass, model, RuntimeType.SERVER, !registeredClasses.contains(resourceClass), true);
    Set<Class<?>> componentClassses = componentBag.getClasses(ComponentBag.excludeMetaProviders(injectionManager)).stream().filter(correctlyConfigured).collect(Collectors.toSet());
    // Merge programmatic resource classes with component classes.
    Set<Class<?>> classes = Collections.newSetFromMap(new IdentityHashMap<>());
    classes.addAll(componentClassses);
    classes.addAll(resourceClasses);
    // Bind classes.
    for (final Class<?> componentClass : classes) {
        ContractProvider model = componentBag.getModel(componentClass);
        if (bindWithComponentProvider(componentClass, model, componentProviders)) {
            continue;
        }
        if (resourceClasses.contains(componentClass)) {
            if (!Resource.isAcceptable(componentClass)) {
                LOGGER.warning(LocalizationMessages.NON_INSTANTIABLE_COMPONENT(componentClass));
                continue;
            }
            if (model != null && !correctlyConfiguredResource.test(componentClass, model)) {
                model = null;
            }
            resourceContext.unsafeBindResource(componentClass, model, injectionManager);
        } else {
            ProviderBinder.bindProvider(componentClass, model, injectionManager);
        }
    }
    // Merge programmatic resource instances with other component instances.
    Set<Object> instances = componentBag.getInstances(ComponentBag.excludeMetaProviders(injectionManager)).stream().filter(instance -> correctlyConfigured.test(instance.getClass())).collect(Collectors.toSet());
    instances.addAll(resourceInstances);
    // Bind instances.
    for (Object component : instances) {
        ContractProvider model = componentBag.getModel(component.getClass());
        if (resourceInstances.contains(component)) {
            if (model != null && !correctlyConfiguredResource.test(component.getClass(), model)) {
                model = null;
            }
            resourceContext.unsafeBindResource(component, model, injectionManager);
        } else {
            ProviderBinder.bindProvider(component, model, injectionManager);
        }
    }
}