lookup = FIXED_LOCATIONS.get(injectionType);
}
InjectionSource valueSource = null;
final boolean isEnvEntryType = this.isEnvEntryType(injectionType, module);
if (!isEmpty(lookup)) {
valueSource = new LookupInjectionSource(lookup, JAVAX_NAMING_CONTEXT.equals(injectionType));
} else if (isEnvEntryType) {
// if it's an 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 an env-entry binding then the injection target will be optional since in the absence of
// an env-entry-value, there won't be a binding and effectively no injection. This again is as expected by spec.
} else {
//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 = registry.getResourceReferenceProcessor(injectionType);
if (resourceReferenceProcessor != null) {
valueSource = resourceReferenceProcessor.getResourceReferenceBindingSource();
}
}
// 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) {
final LookupInjectionSource optionalInjection = new LookupInjectionSource(localContextName, true);
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;
final BindingConfiguration bindingConfiguration = new BindingConfiguration(localContextName, valueSource);
classDescription.getBindingConfigurations().add(bindingConfiguration);