Package com.google.inject.assistedinject

Class FactoryProvider2<F>

java.lang.Object
com.google.inject.assistedinject.FactoryProvider2<F>
All Implemented Interfaces:
AssistedInjectBinding<F>, Provider<F>, HasDependencies, ProviderWithExtensionVisitor<F>, InvocationHandler, javax.inject.Provider<F>
final class FactoryProvider2<F> extends Object implements InvocationHandler, ProviderWithExtensionVisitor<F>, HasDependencies, AssistedInjectBinding<F>
The newer implementation of factory provider. This implementation uses a child injector to create values.

  • Field Details

    • RETURN_ANNOTATION

      static final Annotation RETURN_ANNOTATION
      A constant annotation to denote the return value, instead of creating a new one each time.

    • logger

      static final Logger logger

    • DEFAULT_ANNOTATION

      static final Assisted DEFAULT_ANNOTATION
      if a factory method parameter isn't annotated, it gets this annotation.

    • assistDataByMethod

      private final com.google.common.collect.ImmutableMap<Method,FactoryProvider2.AssistData> assistDataByMethod
      Mapping from method to the data about how the method will be assisted.

    • methodHandleByMethod

      private final com.google.common.collect.ImmutableMap<Method,MethodHandle> methodHandleByMethod
      Mapping from method to method handle, for generated default methods.

    • injector

      private Injector injector
      the hosting injector, or null if we haven't been initialized yet

    • factory

      private final F factory
      the factory interface, implemented and provided

    • factoryKey

      private final Key<F> factoryKey
      The key that this is bound to.

    • collector

      private final BindingCollector collector
      The binding collector, for equality/hashing purposes.

    • methodHandlesLookupCxtor

      private static final Constructor<MethodHandles.Lookup> methodHandlesLookupCxtor

  • Constructor Details

    • FactoryProvider2

      FactoryProvider2(Key<F> factoryKey, BindingCollector collector)
      Parameters:
      factoryKey - a key for a Java interface that defines one or more create methods.
      collector - binding configuration that maps method return types to implementation types.

  • Method Details

    • isDefault

      static boolean isDefault(Method method)

    • isCompatible

      private boolean isCompatible(Method src, Method dst)

    • get

      public F get()
      Description copied from interface: Provider
      Provides an instance of T.
      Specified by:
      get in interface Provider<F>
      Specified by:
      get in interface javax.inject.Provider<F>

    • getDependencies

      public Set<Dependency<?>> getDependencies()
      Description copied from interface: HasDependencies
      Returns the known dependencies for this type. If this has dependencies whose values are not known statically, a dependency for the Injector will be included in the returned set.
      Specified by:
      getDependencies in interface HasDependencies
      Returns:
      a possibly empty set

    • getKey

      public Key<F> getKey()
      Description copied from interface: AssistedInjectBinding
      Returns the Key for the factory binding.
      Specified by:
      getKey in interface AssistedInjectBinding<F>

    • getAssistedMethods

      public Collection<AssistedMethod> getAssistedMethods()
      Description copied from interface: AssistedInjectBinding
      Returns an AssistedMethod for each method in the factory.
      Specified by:
      getAssistedMethods in interface AssistedInjectBinding<F>

    • acceptExtensionVisitor

      public <T, V> V acceptExtensionVisitor(BindingTargetVisitor<T,V> visitor, ProviderInstanceBinding<? extends T> binding)
      Description copied from interface: ProviderWithExtensionVisitor
      Instructs the extension determine if the visitor is an instance of a custom extension visitor, and if so, visit it using that method. If the visitor is not an instance of the custom extension visitor, this method MUST call visitor.visit(binding).

      Due to issues with generics, the type parameters of this method do not relate to the type of the provider. In practice, the 'B' type will always be a supertype of 'T'.

      Specified by:
      acceptExtensionVisitor in interface ProviderWithExtensionVisitor<F>

    • validateFactoryReturnType

      private void validateFactoryReturnType(Errors errors, Class<?> returnType, Class<?> factoryType)

    • isTypeNotSpecified

      private boolean isTypeNotSpecified(TypeLiteral<?> typeLiteral, ConfigurationException ce)
      Returns true if the ConfigurationException is due to an error of TypeLiteral not being fully specified.

    • findMatchingConstructorInjectionPoint

      private <T> InjectionPoint findMatchingConstructorInjectionPoint(Method method, Key<?> returnType, TypeLiteral<T> implementation, List<Key<?>> paramList) throws ErrorsException
      Finds a constructor suitable for the method. If the implementation contained any constructors marked with AssistedInject, this requires all Assisted parameters to exactly match the parameters (in any order) listed in the method. Otherwise, if no AssistedInject constructors exist, this will default to looking for an @Inject constructor.
      Throws:
      ErrorsException

    • constructorHasMatchingParams

      private boolean constructorHasMatchingParams(TypeLiteral<?> type, Constructor<?> constructor, List<Key<?>> paramList, Errors errors) throws ErrorsException
      Matching logic for constructors annotated with AssistedInject. This returns true if and only if all @Assisted parameters in the constructor exactly match (in any order) all @Assisted parameters the method's parameter.
      Throws:
      ErrorsException

    • getDependencies

      private Set<Dependency<?>> getDependencies(InjectionPoint ctorPoint, TypeLiteral<?> implementation)
      Calculates all dependencies required by the implementation and constructor.

    • removeAssistedDeps

      private Set<Dependency<?>> removeAssistedDeps(Set<Dependency<?>> deps)
      Return all non-assisted dependencies.

    • isValidForOptimizedAssistedInject

      private boolean isValidForOptimizedAssistedInject(Set<Dependency<?>> dependencies, Class<?> implementation, TypeLiteral<?> factoryType)
      Returns true if all dependencies are suitable for the optimized version of AssistedInject. The optimized version caches the binding & uses a ThreadLocal Provider, so can only be applied if the assisted bindings are immediately provided. This looks for hints that the values may be lazily retrieved, by looking for injections of Injector or a Provider for the assisted values.

    • isInjectorOrAssistedProvider

      private boolean isInjectorOrAssistedProvider(Dependency<?> dependency)
      Returns true if the dependency is for Injector or if the dependency is a Provider for a parameter that is @Assisted.

    • assistKey

      private <T> Key<T> assistKey(Method method, Key<T> key, Errors errors) throws ErrorsException
      Returns a key similar to key, but with an @Assisted binding annotation. This fails if another binding annotation is clobbered in the process. If the key already has the @Assisted annotation, it is returned as-is to preserve any String value.
      Throws:
      ErrorsException

    • initialize

      @Inject @Toolable void initialize(Injector injector)
      At injector-creation time, we initialize the invocation handler. At this time we make sure all factory methods will be able to build the target types.

    • getBindingFromNewInjector

      public Binding<?> getBindingFromNewInjector(Method method, Object[] args, FactoryProvider2.AssistData data)
      Creates a child injector that binds the args, and returns the binding for the method's result.

    • invoke

      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
      When a factory method is invoked, we create a child injector that binds all parameters, then use that to get an instance of the return type.
      Specified by:
      invoke in interface InvocationHandler
      Throws:
      Throwable

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • canRethrow

      static boolean canRethrow(Method invoked, Throwable thrown)
      Returns true if thrown can be thrown by invoked without wrapping.

    • findMethodHandlesLookupCxtor

      private static Constructor<MethodHandles.Lookup> findMethodHandlesLookupCxtor()

    • createMethodHandle

      private static MethodHandle createMethodHandle(Method method, Object proxy)