/** * 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); } } } }
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 + ">"; } }; }
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)); }
@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)); }
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); } } }); } }