private void createURLInjector(String encName, String mappedName, InjectionContainer container) { assert encName.length() > 0 : "encName is empty"; assert mappedName.length() > 0 : "mappedName is empty"; // Create a URL from the mappedName try { URL url = new URL(mappedName.trim()); container.getEncInjectors().put(encName, new ValueEncInjector(encName, url, "@Resource")); } catch (MalformedURLException e) { throw new RuntimeException(e); } }
private static void createURLInjector(String encName, String mappedName, InjectionContainer container) { assert encName.length() > 0 : "encName is empty"; assert mappedName.length() > 0 : "mappedName is empty"; // Create a URL from the mappedName try { URL url = new URL(mappedName.trim()); container.getEncInjectors().put(encName, new ValueEncInjector(encName, url, "@Resource")); } catch (MalformedURLException e) { throw new RuntimeException("failed to create url injector for: " + encName, e); } }
private static void createURLInjector(String encName, String mappedName, InjectionContainer container) { assert encName.length() > 0 : "encName is empty"; assert mappedName.length() > 0 : "mappedName is empty"; // Create a URL from the mappedName try { URL url = new URL(mappedName.trim()); container.getEncInjectors().put(encName, new ValueEncInjector(encName, url, "@Resource")); } catch (MalformedURLException e) { throw new RuntimeException(e); } }
private void bindRefOnType(Class<?> type, InjectionContainer container, WebServiceRef wsref) { String name = wsref.name(); if (name.equals("")) name = InjectionUtil.getEncName(type).substring(4); if (!container.getEncInjectors().containsKey(name)) { String encName = "env/" + name; ServiceReferenceMetaData sref = getServiceRef(name); container.getEncInjectors().put(name, new ServiceRefInjector(encName, type, sref)); } }
public void handleMethodAnnotations(Method method, InjectionContainer container, Map<AccessibleObject, Injector> injectors) { JndiInject ref = method.getAnnotation(JndiInject.class); if (ref != null) { if (!method.getName().startsWith("set")) throw new RuntimeException("@EJB can only be used with a set method: " + method); String encName = InjectionUtil.getEncName(method); if (!container.getEncInjectors().containsKey(encName)) { container.getEncInjectors().put(encName, new LinkRefEncInjector(encName, ref.jndiName(), "@JndiInject")); } injectors.put(method, new JndiMethodInjector(method, encName, container.getEnc())); } }
public void handleFieldAnnotations(Field field, InjectionContainer container, Map<AccessibleObject, Injector> injectors) { JndiInject ref = field.getAnnotation(JndiInject.class); if (ref != null) { String encName = InjectionUtil.getEncName(field); if (!container.getEncInjectors().containsKey(encName)) { container.getEncInjectors().put(encName, new LinkRefEncInjector(encName, ref.jndiName(), "@JndiInject")); } injectors.put(field, new JndiFieldInjector(field, encName, container.getEnc())); } } }
private static void handleClassAnnotation(PersistenceUnit ref, InjectionContainer container, Class<?> clazz) { String encName = ref.name(); if (encName == null || encName.equals("")) { throw new RuntimeException("JBoss requires name() for class level @PersistenceUnit"); } encName = "env/" + encName; if (container.getEncInjectors().containsKey(encName)) return; container.getEncInjectors().put(encName, new PuEncInjector(encName, null, ref.unitName(), "@PersistenceUnit")); try { addPUDependency(ref.unitName(), container); } catch (NameNotFoundException e) { throw new RuntimeException("Illegal @PersistenceUnit on " + clazz.getName() + " of unitname " + ref.unitName() + " :" + e.getMessage()); } }
private static void loadXmlMessageDestinationRefs(InjectionContainer container, Collection<MessageDestinationReferenceMetaData> refs) { for (MessageDestinationReferenceMetaData envRef : refs) { String encName = "env/" + envRef.getMessageDestinationRefName(); if (container.getEncInjectors().containsKey(encName)) continue; String jndiName = envRef.getMappedName(); if (jndiName == null || jndiName.equals("")) { // Look for a message-destination-link jndiName = envRef.getResolvedJndiName(); if (jndiName == null) { throw new RuntimeException("message-destination has no jndi-name/resolved-jndi-name " + envRef); // TODO: add dependency } } container.getEncInjectors().put(encName, new LinkRefEncInjector(encName, jndiName, "<message-destination-ref>")); InjectionUtil.injectionTarget(encName, envRef, container, container.getEncInjections()); } }
private static void loadEnvEntry(InjectionContainer container, Collection<EnvironmentEntryMetaData> envEntries) { for (EnvironmentEntryMetaData envEntry : envEntries) { String encName = "env/" + envEntry.getEnvEntryName(); // 16.4.1.3: If the env-entry-value is not specified, no value will be injected and it // will not be initialized into the naming context. if(envEntry.getValue() == null) { log.debug("ignoring env-entry " + envEntry); continue; } InjectionUtil.injectionTarget(encName, envEntry, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) continue; log.trace("adding env-entry injector " + encName); container.getEncInjectors().put(encName, new EnvEntryEncInjector(encName, envEntry.getType(), envEntry.getValue())); } }
protected void ejbRefEncInjector(String mappedName, String encName, String fieldName, Class refClass, String link, String errorType, InjectionContainer container) { if (refClass != null && (refClass.equals(Object.class) || refClass.equals(void.class))) refClass = null; if (mappedName != null && mappedName.trim().equals("")) mappedName = null; if(mappedName == null) mappedName = getMappedName(encName, container, fieldName); EncInjector injector = null; if (mappedName == null) { // TODO: remove this block, see previous comments log.warn("EJBTHREE-1289: Using legacy EjbEncInjector, because mappedName for enc \"" + encName + "\", field \"" + fieldName + "\" is null (container.environmentRefGroup.annotatedEjbReferences = " + container.getEnvironmentRefGroup().getAnnotatedEjbReferences() + ")"); // legacy injector = new EjbEncInjector(encName, refClass, link, errorType); } else { injector = new EjbEncInjector(encName, mappedName, errorType); } container.getEncInjectors().put(encName, injector); }
private static void loadEnvEntry(InjectionContainer container, Collection<EnvironmentEntryMetaData> envEntries) { for (EnvironmentEntryMetaData envEntry : envEntries) { String encName = "env/" + envEntry.getEnvEntryName(); // 16.4.1.3: If the env-entry-value is not specified, no value will be injected and it // will not be initialized into the naming context. if (envEntry.getValue() == null) { log.debug("ignoring env-entry " + envEntry); continue; } InjectionUtil.injectionTarget(encName, envEntry, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) continue; log.trace("adding env-entry injector " + encName); container.getEncInjectors().put(encName, new EnvEntryEncInjector(encName, envEntry.getType(), envEntry.getValue())); } }
private static void loadEnvEntry(InjectionContainer container, Collection<EnvironmentEntryMetaData> envEntries) { for (EnvironmentEntryMetaData envEntry : envEntries) { String encName = "env/" + envEntry.getEnvEntryName(); // 16.4.1.3: If the env-entry-value is not specified, no value will be injected and it // will not be initialized into the naming context. if(envEntry.getValue() == null) { log.debug("ignoring env-entry " + envEntry); continue; } InjectionUtil.injectionTarget(encName, envEntry, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) continue; log.trace("adding env-entry injector " + encName); String envEntryType = getEnvEntryType(container, envEntry); if (envEntryType == null) { throw new RuntimeException("env-entry-type is not specified for env-entry named " + envEntry.getName()); } container.getEncInjectors().put(encName, new EnvEntryEncInjector(encName, envEntryType, envEntry.getValue())); } }
public void handleMethodAnnotations(Method method, InjectionContainer container, Map<AccessibleObject, Injector> injectors) { EJB ref = container.getAnnotation(EJB.class, method); if (ref != null) { if (!method.getName().startsWith("set")) throw new RuntimeException("@EJB can only be used with a set method: " + method); String encName = getEncName(ref, method); if (!container.getEncInjectors().containsKey(encName)) { ejbRefEncInjector(ref.mappedName(), encName, method.getName().substring(0), method.getParameterTypes()[0], ref.beanName(), "@EJB", container); if (isIgnoreDependency(container, ref)) log.debug("IGNORING <ejb-ref> DEPENDENCY: " + encName); else ejbRefDependency(ref.mappedName(), ref.beanName(), container, method.getParameterTypes()[0], "@EJB", encName); } super.handleMethodAnnotations(method, container, injectors); } }
public void loadXml(X xml, InjectionContainer container) { if (xml == null) return; if (xml instanceof JBossEnterpriseBeanMetaData == false) return; JndiRefsMetaData jndiRefs = ((JBossEnterpriseBeanMetaData) xml).getJndiRefs(); if (jndiRefs == null) return; for (JndiRefMetaData ref : jndiRefs) { if (ref.getMappedName() == null || ref.getMappedName().equals("")) throw new RuntimeException("mapped-name is required for " + ref.getJndiRefName() + " of container " + container.getIdentifier()); String encName = "env/" + ref.getJndiRefName(); if (!container.getEncInjectors().containsKey(encName)) { container.getEncInjectors().put(encName, new LinkRefEncInjector(encName, ref.getMappedName(), "jndi ref")); } InjectionUtil.injectionTarget(encName, ref, container, container.getEncInjections()); } }
private static void loadPersistenceContextClassAnnotation( PersistenceContext ref, InjectionContainer container, Class<?> clazz) { String encName = ref.name(); if (encName == null || encName.equals("")) { throw new RuntimeException( "JBoss requires name() for class level @PersistenceContext"); } encName = "env/" + ref.name(); if (container.getEncInjectors().containsKey(encName)) return; String error = "Unable to load class-level @PersistenceContext(" + ref.unitName() + ") on " + container.getIdentifier(); container.getEncInjectors().put(encName, new PcEncInjector(encName, ref.unitName(), ref.type(), null, error)); try { PersistenceUnitHandler.addPUDependency(ref.unitName(), container); } catch (NameNotFoundException e) { throw new RuntimeException("Illegal @PersistenceUnit on " + clazz.getName() + " of unitname " + ref.unitName() + " :" + e.getMessage()); } }
protected void handleClassAnnotation(EJB ejb, Class<?> clazz, InjectionContainer container) { String encName = ejb.name(); if (encName == null || encName.equals("")) { throw new RuntimeException("JBoss requires the name of the @EJB in the @EJBs: " + clazz); } encName = "env/" + encName; if (container.getEncInjectors().containsKey(encName)) return; ejbRefEncInjector(ejb.mappedName(), encName, null, ejb.beanInterface(), ejb.beanName(), "@EJB", container); // handle dependencies if (isIgnoreDependency(container, ejb)) log.debug("IGNORING <ejb-ref> DEPENDENCY: " + encName); else ejbRefDependency(ejb.mappedName(), ejb.beanName(), container, ejb.beanInterface(), "@EJB", encName); }
protected void handleClassAnnotation(EJB ejb, Class<?> clazz, InjectionContainer container) { String encName = ejb.name(); if (encName == null || encName.equals("")) { throw new RuntimeException("JBoss requires the name of the @EJB in the @EJBs: " + clazz); } encName = "env/" + encName; if (container.getEncInjectors().containsKey(encName)) return; ejbRefEncInjector(ejb.mappedName(), encName, null, ejb.beanInterface(), ejb.beanName(), "@EJB", container); // handle dependencies if (isIgnoreDependency(container, ejb)) log.debug("IGNORING <ejb-ref> DEPENDENCY: " + encName); else ejbRefDependency(ejb.mappedName(), ejb.beanName(), container, ejb.beanInterface(), "@EJB", encName); }
public void loadXml(X xml, InjectionContainer container) { if (xml == null) return; if (xml.getPersistenceUnitRefs() == null) return; for (PersistenceUnitReferenceMetaData ref : xml.getPersistenceUnitRefs()) { String encName = "env/" + ref.getPersistenceUnitRefName(); // we add injection target no matter what. enc injection might be overridden but // XML injection cannot be overriden Class<?> injectionType = InjectionUtil.injectionTarget(encName, ref, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) return; container.getEncInjectors().put(encName, new RemotePuEncInjector(encName, injectionType, ref.getPersistenceUnitName(), "<persistence-unit-ref>")); try { PersistenceUnitHandler.addPUDependency(ref.getPersistenceUnitName(), container); } catch (NameNotFoundException e) { throw new RuntimeException("Illegal <persistence-unit-ref> of " + ref.getPersistenceUnitRefName() + " :" + e.getMessage()); } } }
public void loadXml(X xml, InjectionContainer container) { if (xml == null) return; if (xml.getPersistenceUnitRefs() == null) return; for (PersistenceUnitReferenceMetaData ref : xml.getPersistenceUnitRefs()) { String encName = "env/" + ref.getPersistenceUnitRefName(); // we add injection target no matter what. enc injection might be overridden but // XML injection cannot be overriden Class<?> injectionType = InjectionUtil.injectionTarget(encName, ref, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) return; container.getEncInjectors().put(encName, new PuEncInjector(encName, injectionType, ref.getPersistenceUnitName(), "<persistence-unit-ref>")); try { addPUDependency(ref.getPersistenceUnitName(), container); } catch (NameNotFoundException e) { throw new RuntimeException("Illegal <persistence-unit-ref> of " + ref.getPersistenceUnitRefName() + " :" + e.getMessage()); } } }
public void handleFieldAnnotations(Field field, InjectionContainer container, Map<AccessibleObject, Injector> injectors) { EJB ref = container.getAnnotation(EJB.class, field); if (ref != null) { String encName = getEncName(ref, field); if (!container.getEncInjectors().containsKey(encName)) { Class<?> businessInterface = field.getType(); if (ref.beanInterface() != null && ref.beanInterface() != Object.class) { businessInterface = ref.beanInterface(); } if (container.getAnnotation(IgnoreDependency.class, field) == null) { if (isIgnoreDependency(container, ref)) log.debug("IGNORING <ejb-ref> DEPENDENCY: " + encName); else ejbRefDependency(ref.mappedName(), ref.beanName(), container, businessInterface, "@EJB", encName); } ejbRefEncInjector(ref.mappedName(), encName, field.getName(), businessInterface, ref.beanName(), "@EJB", container); } super.handleFieldAnnotations(field, container, injectors); } }