Interface StrategySelector

All Superinterfaces:
Serializable, Service, Stoppable
public interface StrategySelector extends Service, Stoppable
Service which acts as a registry for named strategy implementations.

Strategies are more open-ended than services, though a strategy managed here might very well also be a service. The strategy is any interface that has multiple, (possibly short) named implementations.

StrategySelector manages resolution of particular implementation by (possibly short) name via the selectStrategyImplementor(Class, String) method, which is the main contract here. As indicated in the Javadoc of that method, the given name might be either a short registered name or the implementation FQN. As an example, consider resolving the TransactionCoordinatorBuilder implementation to use. To use the JDBC-based TransactionCoordinatorBuilder the passed name might be either "jdbc" or "org.hibernate.resource.transaction.backend.jdbc.internal.JdbcResourceLocalTransactionCoordinatorBuilderImpl".

Strategy implementations can be managed by registerStrategyImplementor(Class, String, Class) and unRegisterStrategyImplementor(Class, Class). Originally designed to help the OSGi use case, though no longer used there.

The service also exposes a general typing API via resolveStrategy(Class, Object) and resolveDefaultableStrategy(Class, Object, T) which accept implementation references rather than implementation names, allowing for a multitude of interpretations of said "implementation reference". See the docs for resolveDefaultableStrategy(Class, Object, T) for details.

  • Method Details

    • selectStrategyImplementor

      <T> Class<? extends T> selectStrategyImplementor(Class<T> strategy, String name)
      Locate the named strategy implementation.
      Type Parameters:
      T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
      Parameters:
      strategy - The type of strategy to be resolved.
      name - The name of the strategy to locate; might be either a registered name or the implementation FQN.
      Returns:
      The named strategy implementation class.

    • resolveStrategy

      <T> T resolveStrategy(Class<T> strategy, @Nullable Object strategyReference)
      Resolve strategy instances. See discussion on resolveDefaultableStrategy(Class, Object, T). Only difference is that here, the implied default value is null.
      Type Parameters:
      T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
      Parameters:
      strategy - The type (interface) of the strategy to be resolved.
      strategyReference - The reference to the strategy for which we need to resolve an instance.
      Returns:
      The strategy instance

    • resolveDefaultableStrategy

      <T> T resolveDefaultableStrategy(Class<T> strategy, Object strategyReference, T defaultValue)
      Resolve strategy instances. The incoming reference might be:
      • null - in which case defaultValue is returned.
      • An actual instance of the strategy type - it is returned, as is
      • A reference to the implementation Class - an instance is created by calling Class.newInstance() (aka, the class's no-arg ctor).
      • The name of the implementation class - First the implementation's Class reference is resolved, and then an instance is created by calling Class.newInstance()
      Type Parameters:
      T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
      Parameters:
      strategy - The type (interface) of the strategy to be resolved.
      strategyReference - The reference to the strategy for which we need to resolve an instance.
      defaultValue - THe default value to use if strategyReference is null
      Returns:
      The strategy instance

    • resolveDefaultableStrategy

      <T> T resolveDefaultableStrategy(Class<T> strategy, Object strategyReference, Callable<T> defaultResolver)
      Resolve strategy instances. The incoming reference might be:
      • null - in which case defaultValue is returned.
      • An actual instance of the strategy type - it is returned, as is
      • A reference to the implementation Class - an instance is created by calling Class.newInstance() (aka, the class's no-arg ctor).
      • The name of the implementation class - First the implementation's Class reference is resolved, and then an instance is created by calling Class.newInstance()
      Type Parameters:
      T - The type of the strategy. Used to make sure that the strategy and implementation are type compatible.
      Parameters:
      strategy - The type (interface) of the strategy to be resolved.
      strategyReference - The reference to the strategy for which we need to resolve an instance.
      defaultResolver - A strategy for resolving the default value strategyReference resolves to null.
      Returns:
      The strategy instance

    • resolveStrategy

      <T> T resolveStrategy(Class<T> strategy, Object strategyReference, Callable<T> defaultResolver, StrategyCreator<T> creator)

    • resolveStrategy

      <T> T resolveStrategy(Class<T> strategy, Object strategyReference, T defaultValue, StrategyCreator<T> creator)

    • getRegisteredStrategyImplementors

      <T> Collection<Class<? extends T>> getRegisteredStrategyImplementors(Class<T> strategy)
      Retrieve all the registered implementors of the given strategy. Useful to allow defaulting the choice to the single registered implementor when only one is registered
      Returns:
      The implementors. Should never return null

    • registerStrategyImplementor

      @Deprecated(since="7.0", forRemoval=true) <T> void registerStrategyImplementor(Class<T> strategy, String name, Class<? extends T> implementation)
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use NamedStrategyContributor instead
      Registers a named implementor of a particular strategy contract.
      Type Parameters:
      T - The strategy type.
      Parameters:
      strategy - The strategy contract.
      name - The registration name
      implementation - The implementation class

    • unRegisterStrategyImplementor

      @Deprecated(since="7.0", forRemoval=true) <T> void unRegisterStrategyImplementor(Class<T> strategy, Class<? extends T> implementation)
      Deprecated, for removal: This API element is subject to removal in a future version.
      Use NamedStrategyContributor instead
      Unregisters a named implementor of a particular strategy contract. Unregisters all named registrations for the given strategy contract naming the given class.
      Type Parameters:
      T - The strategy type.
      Parameters:
      strategy - The strategy contract.
      implementation - The implementation class