Java 类com.google.inject.MembersInjector 实例源码

/**
 * Wraps a {@link Finder} returned by {@link #createFinder(Class)} to do
 * member injection using the passed in {@link MembersInjector}.
 * 
 * @param finder
 *            The finder.
 * @param membersInjector
 *            The instance of {@link MembersInjector}.
 * @return A wrapped {@link Finder}.
 */
public static Finder wrapFinderWithMemberInjection(final Finder finder,
        final SelfInjectingServerResource.MembersInjector membersInjector) {
    return new Finder(finder.getContext(), finder.getTargetClass()) {
        @Override
        public ServerResource find(Request request, Response response) {
            ServerResource res = finder.find(request, response);
            if (res instanceof SelfInjectingServerResource) {
                SelfInjectingServerResource tmp = (SelfInjectingServerResource) res;
                tmp.ensureInjected(membersInjector);
            } else {
                membersInjector.injectMembers(res);
            }
            return res;
        }
    };
}

@Override
public <T> MembersInjector<T> getMembersInjector(
        TypeLiteral<T> typeLiteral) {
    Consumer<T> membersInjector = delegate
            .getMembersInjector(typeLiteral.getTypeToken());
    return new MembersInjector<T>() {
        @Override
        public void injectMembers(T instance) {
            membersInjector.accept(instance);
        }

        @Override
        public String toString() {
            return membersInjector.toString();
        }
    };
}

/**
 * Returns the looked up members injector. The result is not valid until this lookup has been
 * initialized, which usually happens when the injector is created. The members injector will
 * throw an {@code IllegalStateException} if you try to use it beforehand.
 */
public MembersInjector<T> getMembersInjector() {
  return new MembersInjector<T>() {
    @Override
    public void injectMembers(T instance) {
      MembersInjector<T> local = delegate;
      if (local == null) {
        throw new IllegalStateException(
            "This MembersInjector cannot be used until the Injector has been created.");
      }
      local.injectMembers(instance);
    }

    @Override
    public String toString() {
      return "MembersInjector<" + type + ">";
    }
  };
}

private <T> BindingImpl<MembersInjector<T>> createMembersInjectorBinding(
    Key<MembersInjector<T>> key, Errors errors) throws ErrorsException {
  Type membersInjectorType = key.getTypeLiteral().getType();
  if (!(membersInjectorType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawMembersInjector().toException();
  }

  @SuppressWarnings("unchecked") // safe because T came from Key<MembersInjector<T>>
  TypeLiteral<T> instanceType =
      (TypeLiteral<T>)
          TypeLiteral.get(((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
  MembersInjector<T> membersInjector = membersInjectorStore.get(instanceType, errors);

  InternalFactory<MembersInjector<T>> factory =
      new ConstantFactory<MembersInjector<T>>(Initializables.of(membersInjector));

  return new InstanceBindingImpl<MembersInjector<T>>(
      this,
      key,
      SourceProvider.UNKNOWN_SOURCE,
      factory,
      ImmutableSet.<InjectionPoint>of(),
      membersInjector);
}

private <T> BindingImpl<MembersInjector<T>> createMembersInjectorBinding(
    Key<MembersInjector<T>> key, Errors errors) throws ErrorsException {
  Type membersInjectorType = key.getTypeLiteral().getType();
  if (!(membersInjectorType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawMembersInjector().toException();
  }

  @SuppressWarnings("unchecked") // safe because T came from Key<MembersInjector<T>>
  TypeLiteral<T> instanceType = (TypeLiteral<T>) TypeLiteral.get(
      ((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
  MembersInjector<T> membersInjector = membersInjectorStore.get(instanceType, errors);

  InternalFactory<MembersInjector<T>> factory = new ConstantFactory<MembersInjector<T>>(
      Initializables.of(membersInjector));


  return new InstanceBindingImpl<MembersInjector<T>>(this, key, SourceProvider.UNKNOWN_SOURCE,
      factory, ImmutableSet.<InjectionPoint>of(), membersInjector);
}

void injectMembers(T t, Errors errors, InternalContext context, boolean toolableOnly) {
  // optimization: use manual for/each to save allocating an iterator here
  for (int i = 0, size = memberInjectors.size(); i < size; i++) {
    SingleMemberInjector injector = memberInjectors.get(i);
    if(!toolableOnly || injector.getInjectionPoint().isToolable()) {
      injector.inject(errors, context, t);
    }
  }

  // TODO: There's no way to know if a user's MembersInjector wants toolable injections.
  if(!toolableOnly) {
    for (MembersInjector<? super T> userMembersInjector : userMembersInjectors) {
      try {
        userMembersInjector.injectMembers(t);
      } catch (RuntimeException e) {
        errors.errorInUserInjector(userMembersInjector, typeLiteral, e);
      }
    }
  }
}

private <T> BindingImpl<MembersInjector<T>> createMembersInjectorBinding(
    Key<MembersInjector<T>> key, Errors errors) throws ErrorsException {
  Type membersInjectorType = key.getTypeLiteral().getType();
  if (!(membersInjectorType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawMembersInjector().toException();
  }

  @SuppressWarnings("unchecked") // safe because T came from Key<MembersInjector<T>>
  TypeLiteral<T> instanceType = (TypeLiteral<T>) TypeLiteral.get(
      ((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
  MembersInjector<T> membersInjector = membersInjectorStore.get(instanceType, errors);

  InternalFactory<MembersInjector<T>> factory = new ConstantFactory<MembersInjector<T>>(
      Initializables.of(membersInjector));


  return new InstanceBindingImpl<MembersInjector<T>>(this, key, SourceProvider.UNKNOWN_SOURCE,
      factory, ImmutableSet.<InjectionPoint>of(), membersInjector);
}

void injectMembers(T t, Errors errors, InternalContext context, boolean toolableOnly) {
  // optimization: use manual for/each to save allocating an iterator here
  for (int i = 0, size = memberInjectors.size(); i < size; i++) {
    SingleMemberInjector injector = memberInjectors.get(i);
    if(!toolableOnly || injector.getInjectionPoint().isToolable()) {
      injector.inject(errors, context, t);
    }
  }

  // TODO: There's no way to know if a user's MembersInjector wants toolable injections.
  if(!toolableOnly) {
  // optimization: use manual for/each to save allocating an iterator here
    for (int i = 0, size = userMembersInjectors.size(); i < size; i++) {
      MembersInjector<? super T> userMembersInjector = userMembersInjectors.get(i);
      try {
        userMembersInjector.injectMembers(t);
      } catch (RuntimeException e) {
        errors.errorInUserInjector(userMembersInjector, typeLiteral, e);
      }
    }
  }
}

@Inject public MemberInjectingFactory(TypeLiteral<T> type, MembersInjector<T> injector) {
    this.type = type;
    this.injector = injector;
    this.injectionPoint = InjectionPoint.forConstructorOf(type);
    this.constructor = (Constructor<T>) injectionPoint.getMember();
    this.constructor.setAccessible(true);

    dependencies.addAll(Dependency.forInjectionPoints(InjectionPoint.forInstanceMethodsAndFields(type)));
}

private void analyzeDependencies(final Collection<Dependency<?>> dependencies)
{
    for( final Dependency<?> d : dependencies )
    {
        final Key<?> key = d.getKey();
        InjectionPoint injectionPoint = d.getInjectionPoint();
        if( injectionPoint != null && injectionPoint.isOptional() )
        {
            continue;
        }
        if( key.getAnnotationType() == Assisted.class )
        {
            continue;
        }
        TypeLiteral<?> typeLiteral = key.getTypeLiteral();
        Class<?> rawType = typeLiteral.getRawType();
        if( rawType == Injector.class )
        {
            continue;
        }
        if( rawType == MembersInjector.class )
        {
            Key<?> injectedKey = key
                .ofType(((ParameterizedType) typeLiteral.getType()).getActualTypeArguments()[0]);
            dependentKeys.add(injectedKey);
            analyzeImplementation(injectedKey.getTypeLiteral(), true);
        }
        else if( rawType == Provider.class )
        {
            dependentKeys.add(key.ofType(((ParameterizedType) typeLiteral.getType()).getActualTypeArguments()[0]));
        }
        else
        {
            dependentKeys.add(key);
        }
    }
}

private <T> void checkForFrameworkTypes(Class<T> type) {
    if (Provider.class.equals(type) || TypeLiteral.class.equals(type)
            || MembersInjector.class.equals(type)
            || Injector.class.equals(type)) {
        throw new com.github.ruediste.salta.core.SaltaException(
                "Binding to core guice framework type is not allowed: "
                        + type.getSimpleName() + ".");
    }
}

@Override
public <T> MembersInjector<T> getMembersInjector(
        TypeLiteral<T> typeLiteral) {
    TypeToken<MembersInjector<T>> injectorType = new TypeToken<MembersInjector<T>>() {
        private static final long serialVersionUID = 1L;
    }.where(new TypeParameter<T>() {
    }, typeLiteral.getTypeToken());
    return delegate.getInstance(DependencyKey.of(injectorType));
}

@Override
public <T> MembersInjector<T> getMembersInjector(final TypeLiteral<T> typeLiteral) {
  final MembersInjectorLookup<T> element =
      new MembersInjectorLookup<T>(
          getElementSource(), MoreTypes.canonicalizeForKey(typeLiteral));
  elements.add(element);
  return element.getMembersInjector();
}

@Override
public <T> Boolean visit(MembersInjectorLookup<T> lookup) {
  try {
    MembersInjector<T> membersInjector =
        injector.membersInjectorStore.get(lookup.getType(), errors);
    lookup.initializeDelegate(membersInjector);
  } catch (ErrorsException e) {
    errors.merge(e.getErrors()); // TODO: source
  }

  return true;
}

@Override
public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
  Errors errors = new Errors(typeLiteral);
  try {
    return membersInjectorStore.get(typeLiteral, errors);
  } catch (ErrorsException e) {
    throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
  }
}

@Override
public void register(MembersInjector<? super T> membersInjector) {
  checkState(valid, "Encounters may not be used after hear() returns.");

  if (membersInjectors == null) {
    membersInjectors = Lists.newArrayList();
  }

  membersInjectors.add(membersInjector);
}

void injectMembers(T t, InternalContext context, boolean toolableOnly)
    throws InternalProvisionException {
  ImmutableList<SingleMemberInjector> localMembersInjectors = memberInjectors;
  if (localMembersInjectors != null) {
    // optimization: use manual for/each to save allocating an iterator here
    for (int i = 0, size = localMembersInjectors.size(); i < size; i++) {
      SingleMemberInjector injector = localMembersInjectors.get(i);
      if (!toolableOnly || injector.getInjectionPoint().isToolable()) {
        injector.inject(context, t);
      }
    }
  }

  // TODO: There's no way to know if a user's MembersInjector wants toolable injections.
  if (!toolableOnly) {
    ImmutableList<MembersInjector<? super T>> localUsersMembersInjectors = userMembersInjectors;
    if (localUsersMembersInjectors != null) {
      // optimization: use manual for/each to save allocating an iterator here
      for (int i = 0; i < localUsersMembersInjectors.size(); i++) {
        MembersInjector<? super T> userMembersInjector = localUsersMembersInjectors.get(i);
        try {
          userMembersInjector.injectMembers(t);
        } catch (RuntimeException e) {
          throw InternalProvisionException.errorInUserInjector(
              userMembersInjector, typeLiteral, e);
        }
      }
    }
  }
}

/**
 * Returns the looked up members injector. The result is not valid until this lookup has been
 * initialized, which usually happens when the injector is created. The members injector will
 * throw an {@code IllegalStateException} if you try to use it beforehand.
 */
public MembersInjector<T> getMembersInjector() {
  return new MembersInjector<T>() {
    public void injectMembers(T instance) {
      checkState(delegate != null,
          "This MembersInjector cannot be used until the Injector has been created.");
      delegate.injectMembers(instance);
    }

    @Override public String toString() {
      return "MembersInjector<" + type + ">";
    }
  };
}

@Override public <T> Boolean visit(MembersInjectorLookup<T> lookup) {
  try {
    MembersInjector<T> membersInjector
        = injector.membersInjectorStore.get(lookup.getType(), errors);
    lookup.initializeDelegate(membersInjector);
  } catch (ErrorsException e) {
    errors.merge(e.getErrors()); // TODO: source
  }

  return true;
}

public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
  Errors errors = new Errors(typeLiteral);
  try {
    return membersInjectorStore.get(typeLiteral, errors);
  } catch (ErrorsException e) {
    throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
  }
}

public void register(MembersInjector<? super T> membersInjector) {
  checkState(valid, "Encounters may not be used after hear() returns.");

  if (membersInjectors == null) {
    membersInjectors = Lists.newArrayList();
  }

  membersInjectors.add(membersInjector);
}

void reinject(Iterable<Object> objects)
{
    final MembersInjector<O> injector = this.injector.get().getMembersInjector(owner);

    for (Object obj : objects)
        if (obj != null)
            injector.injectMembers(owner.cast(obj));
}

/**
 * Returns the looked up members injector. The result is not valid until this lookup has been
 * initialized, which usually happens when the injector is created. The members injector will
 * throw an {@code IllegalStateException} if you try to use it beforehand.
 */
public MembersInjector<T> getMembersInjector() {
  return new MembersInjector<T>() {
    public void injectMembers(T instance) {
      checkState(delegate != null,
          "This MembersInjector cannot be used until the Injector has been created.");
      delegate.injectMembers(instance);
    }

    @Override public String toString() {
      return "MembersInjector<" + type + ">";
    }
  };
}

@Override public <T> Boolean visit(MembersInjectorLookup<T> lookup) {
  try {
    MembersInjector<T> membersInjector
        = injector.membersInjectorStore.get(lookup.getType(), errors);
    lookup.initializeDelegate(membersInjector);
  } catch (ErrorsException e) {
    errors.merge(e.getErrors()); // TODO: source
  }

  return true;
}

public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
  Errors errors = new Errors(typeLiteral);
  try {
    return membersInjectorStore.get(typeLiteral, errors);
  } catch (ErrorsException e) {
    throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
  }
}

public void register(MembersInjector<? super T> membersInjector) {
  checkState(valid, "Encounters may not be used after hear() returns.");

  if (membersInjectors == null) {
    membersInjectors = Lists.newArrayList();
  }

  membersInjectors.add(membersInjector);
}

@Override
public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> encounter) {
    for (Field field : typeLiteral.getRawType().getDeclaredFields()) {
        if (field.getType() == JCS.class
                && field.isAnnotationPresent(InjectJcs.class)) {
            //
            InjectJcs annot = field.getAnnotation(InjectJcs.class);
            MembersInjector<I> injector = new InjectJcsMembersInjector<I>(
                    field, annot.cacheName());
            encounter.register(injector);
        }
    }
}

@Override
public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
  return injector.getMembersInjector(typeLiteral);
}

@Override
public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
  return injector.getMembersInjector(type);
}

@Override
protected void configure() {
    final InjectionPoint point = InjectionPoint.forConstructorOf(innerType);
    final Constructor<I> constructor = (Constructor<I>) point.getMember();
    constructor.setAccessible(true);

    if(point.getDependencies().isEmpty() || !Types.isAssignable(point.getDependencies().get(0).getKey().getTypeLiteral(), outerType)) {
        addError("Expected %s to take %s as the first parameter of its injectable constructor", innerType, outerType);
        return;
    }

    final Set<Dependency<?>> dependencies = point.getDependencies()
                                                 .stream()
                                                 .skip(1)
                                                 .collect(Collectors.toImmutableSet());

    final List<Provider<?>> providers = dependencies.stream()
                                                    .map(dep -> getProvider(dep.getKey()))
                                                    .collect(Collectors.toImmutableList());

    final MembersInjector<I> membersInjector = getMembersInjector(innerType);

    class FactoryImpl implements InnerFactory<O, I>, HasDependencies {
        @Override
        public Set<Dependency<?>> getDependencies() {
            return dependencies;
        }

        public I create(O outer) {
            final Object[] args = new Object[providers.size() + 1];

            args[0] = outer;

            for(int i = 0; i < providers.size(); i++) {
                args[i + 1] = providers.get(i).get();
            }

            return Injection.wrappingExceptions(() -> {
                final I instance = constructor.newInstance(args);
                membersInjector.injectMembers(instance);
                return instance;
            });
        }
    }

    bind(factoryKey).toInstance(new FactoryImpl());
}

@Override
default <T> MembersInjector<T> getMembersInjector(final TypeLiteral<T> typeLiteral) {
  return this.binder().getMembersInjector(typeLiteral);
}

@Override
default <T> MembersInjector<T> getMembersInjector(final Class<T> type) {
  return this.binder().getMembersInjector(type);
}

private void addMembersInjectorCreationRule() {
    // members injector creation rule
    config.creationPipeline.creationRules
            .add(new MembersInjectorCreationRuleBase(config) {
                @Override
                protected TypeToken<?> getDependency(
                        CoreDependencyKey<?> key) {
                    Class<?> rawType = key.getRawType();
                    if (MembersInjector.class.equals(key.getRawType())) {
                        if (key.getType().getType() instanceof Class) {
                            throw new SaltaException(
                                    "Cannot inject a MembersInjector that has no type parameter");
                        }
                        TypeToken<?> dependency = key.getType().resolveType(
                                rawType.getTypeParameters()[0]);
                        return dependency;
                    } else
                        return null;
                }

                @Override
                protected Object wrapInjector(
                        Consumer<Object> saltaMembersInjector) {
                    return new MembersInjector<Object>() {
                        @Override
                        public void injectMembers(Object x) {
                            saltaMembersInjector.accept(x);
                        }

                        @Override
                        public String toString() {
                            return saltaMembersInjector.toString();
                        };
                    };
                }

                @Override
                protected Class<?> getWrappedInjectorType() {
                    return MembersInjector.class;
                }
            });

}

@Override
public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
    return getMembersInjector(TypeLiteral.get(type));
}

@Override
public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
    return getMembersInjector(TypeLiteral.get(type));
}

public Errors errorInUserInjector(MembersInjector<?> listener,
        TypeLiteral<?> type, RuntimeException cause) {
    return errorInUserCode(cause,
            "Error injecting %s using %s.%n" + " Reason: %s", type,
            listener, cause);
}

@Override
public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral)
{
    return injector().getMembersInjector(typeLiteral);
}

@Override
public <T> MembersInjector<T> getMembersInjector(Class<T> type)
{
    return injector().getMembersInjector(type);
}

private <T> MembersInjector<T> createElementInjector(Field field) {
    return new ElementMembersInjector<T>(injector, field, selectorFactory);
}

@Override
  public <I> void hear(final TypeLiteral<I> type,
                     final TypeEncounter<I> encounter) {
// Ver si la clase inyectada tiene alg�n miembro anotado con @I18NMessageBundle
// y en ese caso inyecta el bundle correspondiente en el miembro
      final FieldAnnotated<I18NMessageBundleService>[] fieldsAnnotatedWithI18N = ReflectionUtils.fieldsAnnotated(type.getRawType(),
                                                                                                               I18NMessageBundleService.class);

      if (fieldsAnnotatedWithI18N != null && fieldsAnnotatedWithI18N.length > 0) {      
          // registrar un inyector de miembros en las clases (ver I18NGuiceModule): binder.bindListener(Matchers.any(),new I18NMessageAnnotationGuiceHandler());
          // ... es decir, para cualquier clase inyectada por Guice, se mira a ver si tiene la anotaci�n @I18NMessageAnnotationGuiceHandler
          //     y se inyectan aqu� sus miembros
          encounter.register(new MembersInjector<I>() {
            // Annonymous Inner Type of MemberInjector...
              @Override
              public void injectMembers(I instance) {
                // Inyectar el I18NService a cada miembro anotado con @I18NMessageBundle
                  for (FieldAnnotated<I18NMessageBundleService> fieldAnnotatedWitI18N : fieldsAnnotatedWithI18N) {
                    // Verificar que el miembro es de tipo I18NService
                      if (!fieldAnnotatedWitI18N.getField().getType().isAssignableFrom(I18NService.class)) {                            
                        throw new IllegalStateException(Strings.of("Field {} of type {} must be of type {} to be injected with a {}")
                                                           .customizeWith(fieldAnnotatedWitI18N.getField().getName(),instance.getClass().getCanonicalName(),I18NService.class.getName(),I18NService.class.getName())
                                                           .asString());
                      }

                      // Obtener el nombre del bundle a inyectar (si no viene en la anotaci�n se toma el nombre de la clase)
                      I18NMessageBundleService i18nServiceAnnotation = fieldAnnotatedWitI18N.getAnnotation();
                      String[] theBundleChain = i18nServiceAnnotation.chain();
                      if (theBundleChain != null && theBundleChain.length > 0) {
                        for (String c : theBundleChain) {
                            if (c.length() == 0) c = type.getRawType().getName().replace('.', '/');     // Poner como valor por defecto el nombre de la clase
                            if (c.startsWith("/")) c = c.substring(1);                                  // asegurarse de que la ruta es relativa (se usa ClassPathLoader)                               
                        }
                      }
                      if (!_isValidBundleChain(theBundleChain)) throw new IllegalStateException(Strings.of("Field {} of type {} annotated with {} must have a 'chain' attribute of type String[] with the names of the Bundles of the chain")
                                                                                                     .customizeWith(fieldAnnotatedWitI18N.getField().getName(),instance.getClass().getCanonicalName(),I18NService.class.getName())
                                                                                                     .asString());
                      // Obtener la localizaci�n de la definici�n del loading/reloading de recursos en un 
                      // fichero properties
                      ResourcesLoaderDefLocation resLoadDefLocAnnotation = fieldAnnotatedWitI18N.getField().getAnnotation(ResourcesLoaderDefLocation.class);
                      if (resLoadDefLocAnnotation == null) throw new IllegalStateException(Strings.of("Field {} of type {} annotated with {} must define the XMLProperties file location of the resources loading/reloading definition using a {} nested-annotation")
                                                                                                .customizeWith(fieldAnnotatedWitI18N.getField().getName(),instance.getClass().getCanonicalName(),I18NService.class.getName(),ResourcesLoaderDefLocation.class.getName())
                                                                                                .asString());
                    ResourcesLoaderDef resLoadDef = _extractResourcesLoaderDefFromAnnotation(_xmlProperties,
                                                                                             resLoadDefLocAnnotation);
                      ResourceBundleControl resBundleControl = ResourceBundleControlBuilder.forLoadingDefinition(resLoadDef);

                      // Obtener el comportamiento en caso de no encontrarse la clave
                      ResourceBundleMissingKeyBehaviour theMissingKeyBehaviour = i18nServiceAnnotation.missingKeyBehaviour();

                      // Obtener un I18NService de la factor�a y asignarlo al miembro (comprobando previamente que el miembro es del tipo I18NService
                      I18NService service = I18NServiceBuilder.create(resBundleControl)
                                                            .forBundleChain(theBundleChain)
                                                            .withMissingKeyBehaviour(theMissingKeyBehaviour);
                      ReflectionUtils.setFieldValue(instance,fieldAnnotatedWitI18N.getField(),service,false);
                  }
              }

          });
      }
  }