private void addConstructorInjectionPoints(final Injectable concreteInjectable, final MetaConstructor injectableConstructor, final DependencyGraphBuilder builder) { final MetaParameter[] params = injectableConstructor.getParameters(); for (int i = 0; i < params.length; i++) { final MetaParameter param = params[i]; builder.addConstructorDependency(concreteInjectable, param.getType(), qualFactory.forSink(param), i, param); } }
private void addAllInjectableProviders(final DependencyGraphBuilder graphBuilder) { for (final Entry<InjectableHandle, InjectableProvider> entry : injectionContext.getInjectableProviders().entries()) { graphBuilder.addExtensionInjectable(entry.getKey().getType(), entry.getKey().getQualifier(), ANY, entry.getValue()); } for (final Entry<InjectableHandle, InjectableProvider> entry : injectionContext.getExactTypeInjectableProviders().entries()) { graphBuilder.addExtensionInjectable(entry.getKey().getType(), entry.getKey().getQualifier(), EXACT_TYPE, entry.getValue()); } }
private void addContextualProviderInjectable(final Injectable providerInjectable, final DependencyGraphBuilder builder, final boolean enabled) { final MetaClass providerImpl = providerInjectable.getInjectedType(); final MetaMethod providerMethod = providerImpl.getMethod("provide", Class[].class, Annotation[].class); // Do not get generic return type for contextual providers final MetaClass providedType = providerMethod.getReturnType(); final InjectableType injectableType = (enabled ? InjectableType.ContextualProvider : InjectableType.Disabled); final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forUniversallyQualified(), EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean); builder.addProducerMemberDependency(providedInjectable, providerImpl, providerInjectable.getQualifier(), providerMethod); }
private void addDisposerDependencies(final Injectable producedInjectable, final MetaMethod disposer, final DependencyGraphBuilder builder) { for (final MetaParameter param : disposer.getParameters()) { if (param.isAnnotationPresent(Disposes.class)) { builder.addDisposesMethodDependency(producedInjectable, disposer.getDeclaringClass(), qualFactory.forSink(disposer.getDeclaringClass()), disposer); } else { builder.addDisposesParamDependency(producedInjectable, param.getType(), qualFactory.forSink(param), param.getIndex(), param); } } }
private void processProducerAndDisposerMethodsDependencies(final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaMethod method, final Injectable producedInjectable) { final MetaParameter[] params = method.getParameters(); for (int i = 0; i < params.length; i++) { final MetaParameter param = params[i]; builder.addProducerParamDependency(producedInjectable, param.getType(), qualFactory.forSink(param), i, param); } final Collection<MetaMethod> matchingDisposes = getMatchingMethods(method, disposesMethods); if (matchingDisposes.size() > 1) { // TODO descriptive message with names of disposers found. throw new RuntimeException(); } else if (!matchingDisposes.isEmpty()) { addDisposerDependencies(producedInjectable, matchingDisposes.iterator().next(), builder); } }
private void addFieldInjectionPoints(final Injectable typeInjectable, final DependencyGraphBuilder builder, final List<String> problems) { final boolean noPublicFieldsAllowed = typeInjectable.getWiringElementTypes().contains(WiringElementType.NormalScopedBean); final MetaClass type = typeInjectable.getInjectedType(); final Collection<Class<? extends Annotation>> injectAnnotations = injectionContext.getAnnotationsForElementType(WiringElementType.InjectionPoint); for (final Class<? extends Annotation> inject : injectAnnotations) { for (final MetaField field : type.getFieldsAnnotatedWith(inject)) { if (noPublicFieldsAllowed && field.isPublic()) { problems.add("The normal scoped bean " + type.getFullyQualifiedName() + " has a public field " + field.getName()); } builder.addFieldDependency(typeInjectable, field.getType(), qualFactory.forSink(field), field); } } }
final DependencyGraph dependencyGraph = graphBuilder.createGraph(getReachabilityStrategy()); log.debug("Resolved dependency graph with {} reachable injectables in {}ms", dependencyGraph.getNumberOfInjectables(), System.currentTimeMillis() - start);
private void addMethodInjectionPoints(final Injectable typeInjectable, final DependencyGraphBuilder builder, final List<String> problems) { final MetaClass type = typeInjectable.getInjectedType(); final Collection<Class<? extends Annotation>> injectAnnotations = injectionContext.getAnnotationsForElementType(WiringElementType.InjectionPoint); for (final Class<? extends Annotation> inject : injectAnnotations) { for (final MetaMethod setter : type.getMethodsAnnotatedWith(inject)) { if (setter.getParameters().length != 1) { problems.add("The method injection point " + setter.getName() + " in " + setter.getDeclaringClass().getFullyQualifiedName() + " should have exactly one parameter, not " + setter.getParameters().length + "."); } else { final MetaParameter metaParam = setter.getParameters()[0]; builder.addSetterMethodDependency(typeInjectable, metaParam.getType(), qualFactory.forSink(setter.getParameters()[0]), setter); } } } }
final boolean enabled; if (isSimpleton(type)) { builder.addInjectable(type, qualFactory.forSource(type), ANY, Dependent.class, InjectableType.Type, WiringElementType.DependentBean, WiringElementType.Simpleton); maybeProcessAsStaticOnlyProducer(builder, type, problems); final Injectable typeInjectable = builder.addInjectable(type, qualFactory.forSource(type), getPathPredicate(type, problems), directScope, InjectableType.Type, getWiringTypes(type, directScope)); processInjectionPoints(typeInjectable, builder, problems); final Injectable typeInjectable = builder.addInjectable(type, qualFactory.forSource(type), getPathPredicate(type, problems), directScope, InjectableType.Disabled, getWiringTypes(type, directScope)); maybeProcessAsProducer(builder, type, typeInjectable, false, problems); final WiringElementType scopeWiringType = (type.isAnnotationPresent(SharedSingleton.class) ? WiringElementType.SharedSingleton : WiringElementType.DependentBean); builder.addInjectable(type, qualFactory.forUniversallyQualified(), ANY, Dependent.class, InjectableType.JsType, scopeWiringType);
private void addProviderInjectable(final Injectable providerImplInjectable, final DependencyGraphBuilder builder, final boolean enabled) { final MetaClass providerImpl = providerImplInjectable.getInjectedType(); final MetaMethod providerMethod = providerImpl.getMethod("get", new Class[0]); final MetaClass providedType = getMethodReturnType(providerMethod); final InjectableType injectableType = (enabled ? InjectableType.Provider : InjectableType.Disabled); final Injectable providedInjectable = builder.addInjectable(providedType, qualFactory.forSource(providerMethod), EXACT_TYPE, Dependent.class, injectableType, WiringElementType.Provider, WiringElementType.DependentBean); builder.addProducerMemberDependency(providedInjectable, providerImplInjectable.getInjectedType(), providerImplInjectable.getQualifier(), providerMethod); }
private void processProducerMethod(final Injectable producerTypeInjectable, final MetaClass producerType, final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaMethod method, final boolean enabled, final List<String> problems) { final Class<? extends Annotation> directScope = getScope(method); final WiringElementType[] wiringTypes = getWiringTypeForProducer(producerType, method, directScope); final InjectableType injectableType = (enabled ? InjectableType.Producer : InjectableType.Disabled); final Injectable producedInjectable = builder.addInjectable(getMethodReturnType(method), qualFactory.forSource(method), getPathPredicate(method, problems), directScope, injectableType, wiringTypes); if (method.isStatic()) { builder.addProducerMemberDependency(producedInjectable, producerType, method); } else { builder.addProducerMemberDependency(producedInjectable, producerType, producerTypeInjectable.getQualifier(), method); } if (enabled) { processProducerAndDisposerMethodsDependencies(builder, disposesMethods, method, producedInjectable); } }
private void processProducerField(final Injectable producerInjectable, final MetaClass producerType, final DependencyGraphBuilder builder, final Collection<MetaMethod> disposesMethods, final MetaField field, final boolean enabled, final List<String> problems) { final Class<? extends Annotation> scopeAnno = getScope(field); final InjectableType injectableType = (enabled ? InjectableType.Producer : InjectableType.Disabled); final Injectable producedInjectable = builder.addInjectable(field.getType(), qualFactory.forSource(field), getPathPredicate(field, problems), scopeAnno, injectableType, getWiringTypeForProducer(producerType, field, scopeAnno)); if (field.isStatic()) { builder.addProducerMemberDependency(producedInjectable, producerType, field); } else { builder.addProducerMemberDependency(producedInjectable, producerInjectable.getInjectedType(), producerInjectable.getQualifier(), field); } if (enabled) { processDisposerDependencies(builder, disposesMethods, field, producedInjectable); } }