InjectionSource valueSource = null;
final boolean isEnvEntryType = this.isEnvEntryType(injectionType, module);
final boolean isResourceRefType = RESOURCE_REF_ENTRIES.contains(injectionType);
boolean createBinding = true;
if (!isEmpty(lookup)) {
valueSource = new LookupInjectionSource(lookup);
} else if (isEnvEntryType) {
// if it's a env-entry type then we do *not* create a BindingConfiguration to bind to the ENC
// since the binding (value) for env-entry is always driven from a deployment descriptor.
// The deployment descriptor processing and subsequent binding in the ENC is taken care off by a
// different Deployment unit processor. If the value isn't specified in the deployment descriptor,
// then there will be no binding the ENC and that's what is expected by the Java EE 6 spec. Furthermore,
// if the @Resource is a env-entry binding then the injection target will be optional since in the absence of
// a env-entry-value, there won't be a binding and effectively no injection. This again is as expected by spec.
} else if (!isResourceRefType) {
//otherwise we just try and handle it
//if we don't have a value source we will try and inject from a lookup
//and the user has to configure the value in a deployment descriptor
final EEResourceReferenceProcessor resourceReferenceProcessor = EEResourceReferenceProcessorRegistry.getResourceReferenceProcessor(injectionType);
if (resourceReferenceProcessor != null) {
valueSource = resourceReferenceProcessor.getResourceReferenceBindingSource(phaseContext, eeModuleDescription, classDescription, injectionType, localContextName, targetDescription);
}
} else {
//handle resource reference types
createBinding = false;
valueSource = new LookupInjectionSource(localContextName);
}
final boolean createBindingFinal = createBinding;
// EE.5.2.4
// Each injection of an object corresponds to a JNDI lookup. Whether a new
// instance of the requested object is injected, or whether a shared instance is
// injected, is determined by the rules described above.
// Because of performance we allow any type of InjectionSource.
if (valueSource == null) {
// the ResourceInjectionConfiguration is created by LazyResourceInjection
if (targetDescription != null) {
OptionalLookupInjectionSource optionalInjection = new OptionalLookupInjectionSource(localContextName);
final ResourceInjectionConfiguration injectionConfiguration = new ResourceInjectionConfiguration(targetDescription, optionalInjection, true);
classDescription.addResourceInjection(injectionConfiguration);
}
} else {
// our injection comes from the local lookup, no matter what.
final InjectionSource injectionSource = new LookupInjectionSource(localContextName);
final ResourceInjectionConfiguration injectionConfiguration = targetDescription != null ?
new ResourceInjectionConfiguration(targetDescription, injectionSource) : null;
// TODO: class hierarchies? shared bindings?
if (createBindingFinal) {