All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.glassfish.jersey.internal.inject.AbstractBinder Maven / Gradle / Ivy

Go to download

A bundle project producing JAX-RS RI bundles. The primary artifact is an "all-in-one" OSGi-fied JAX-RS RI bundle (jaxrs-ri.jar). Attached to that are two compressed JAX-RS RI archives. The first archive (jaxrs-ri.zip) consists of binary RI bits and contains the API jar (under "api" directory), RI libraries (under "lib" directory) as well as all external RI dependencies (under "ext" directory). The secondary archive (jaxrs-ri-src.zip) contains buildable JAX-RS RI source bundle and contains the API jar (under "api" directory), RI sources (under "src" directory) as well as all external RI dependencies (under "ext" directory). The second archive also contains "build.xml" ANT script that builds the RI sources. To build the JAX-RS RI simply unzip the archive, cd to the created jaxrs-ri directory and invoke "ant" from the command line.

There is a newer version: 3.1.6
Show newest version
/*
 * Copyright (c) 2017, 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.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import jakarta.ws.rs.core.GenericType;

import jakarta.inject.Provider;

import org.glassfish.jersey.internal.LocalizationMessages;

/**
 * Implementation of {@link Binder} interface dedicated to keep some level of code compatibility between previous HK2
 * implementation and new DI SPI.
 * 

* Currently, there are supported only bind method and more complicated method where HK2 interfaces are required were omitted. * * @author Petr Bouda */ public abstract class AbstractBinder implements Binder { private List internalBindings = new ArrayList<>(); private List installed = new ArrayList<>(); private InjectionManager injectionManager; private boolean configured = false; /** * Implement to provide binding definitions using the exposed binding methods. */ protected abstract void configure(); /** * Sets {@link InjectionManager} to be able to create instance providers using the injection manager. {@code InjectionManager} * should be called before the invocation of {@link #configure()}, otherwise immediate invocation {@link Provider#get()} * returns * * @param injectionManager injection manager to create a provider. */ void setInjectionManager(InjectionManager injectionManager) { this.injectionManager = injectionManager; } /** * Creates a new instance of {@link Provider} which is able to retrieve a managed instance registered in * {@link InjectionManager}. If {@code InjectionManager} is {@code null} at the time of calling {@link Provider#get()} then * {@link IllegalStateException} is thrown. * * @param clazz class of managed instance. * @param type of the managed instance returned using provider. * @return provider with instance of managed instance. */ protected final Provider createManagedInstanceProvider(Class clazz) { return () -> { if (injectionManager == null) { throw new IllegalStateException(LocalizationMessages.INJECTION_MANAGER_NOT_PROVIDED()); } return injectionManager.getInstance(clazz); }; } /** * Start building a new class-based service binding. *

* Does NOT bind the service type itself as a contract type. * * @param service type. * @param serviceType service class. * @return initialized binding builder. */ public ClassBinding bind(Class serviceType) { ClassBinding binding = Bindings.service(serviceType); internalBindings.add(binding); return binding; } /** * Binds the provided binding and return the same instance. * * @param binding binding. * @return the same provided binding. */ public Binding bind(Binding binding) { internalBindings.add(binding); return binding; } /** * Start building a new class-based service binding. *

* Binds the service type itself as a contract type. * * @param service type. * @param serviceType service class. * @return initialized binding builder. */ public ClassBinding bindAsContract(Class serviceType) { ClassBinding binding = Bindings.serviceAsContract(serviceType); internalBindings.add(binding); return binding; } /** * Start building a new generic type-based service binding. *

* Binds the generic service type itself as a contract type. * * @param service type. * @param serviceType generic service type information. * @return initialized binding builder. */ public ClassBinding bindAsContract(GenericType serviceType) { ClassBinding binding = Bindings.service(serviceType); internalBindings.add(binding); return binding; } /** * Start building a new generic type-based service binding. *

* Binds the generic service type itself as a contract type. * * @param serviceType generic service type information. * @return initialized binding builder. */ public ClassBinding bindAsContract(Type serviceType) { ClassBinding binding = Bindings.serviceAsContract(serviceType); internalBindings.add(binding); return binding; } /** * Start building a new instance-based service binding. The binding is naturally * considered to be a {@link jakarta.inject.Singleton singleton-scoped}. *

* Does NOT bind the service type itself as a contract type. * * @param service type. * @param service service instance. * @return initialized binding builder. */ public InstanceBinding bind(T service) { InstanceBinding binding = Bindings.service(service); internalBindings.add(binding); return binding; } /** * Start building a new supplier class-based service binding. * * @param service type. * @param supplierType service supplier class. * @param supplierScope factory scope. * @return initialized binding builder. */ public SupplierClassBinding bindFactory( Class> supplierType, Class supplierScope) { SupplierClassBinding binding = Bindings.supplier(supplierType, supplierScope); internalBindings.add(binding); return binding; } /** * Start building a new supplier class-based service binding. *

* The supplier itself is bound in a per-lookup scope. * * @param service type. * @param supplierType service supplier class. * @return initialized binding builder. */ public SupplierClassBinding bindFactory(Class> supplierType) { SupplierClassBinding binding = Bindings.supplier(supplierType); internalBindings.add(binding); return binding; } /** * Start building a new supplier instance-based service binding. * * @param service type. * @param factory service instance. * @return initialized binding builder. */ public SupplierInstanceBinding bindFactory(Supplier factory) { SupplierInstanceBinding binding = Bindings.supplier(factory); internalBindings.add(binding); return binding; } /** * Start building a new injection resolver binding. The injection resolver is naturally * considered to be a {@link jakarta.inject.Singleton singleton-scoped}. *

* There is no need to provide any additional information. Other method on {@link Binding} * will be ignored. * * @param type of the injection resolver. * @param resolver injection resolver instance. * @return initialized binding builder. */ public InjectionResolverBinding bind(T resolver) { InjectionResolverBinding binding = Bindings.injectionResolver(resolver); internalBindings.add(binding); return binding; } /** * Adds all binding definitions from the binders to the binding configuration. * * @param binders binders whose binding definitions should be configured. */ public final void install(AbstractBinder... binders) { Arrays.stream(binders) .filter(Objects::nonNull) .forEach(installed::add); } @Override public Collection getBindings() { invokeConfigure(); List bindings = installed.stream() .flatMap(binder -> Bindings.getBindings(injectionManager, binder).stream()) .collect(Collectors.toList()); bindings.addAll(internalBindings); return bindings; } private void invokeConfigure() { if (!configured) { configure(); configured = true; } } }