public void handleClassAnnotations(Class<?> clazz, InjectionContainer container) { Resources resources = container.getAnnotation(Resources.class, clazz); if (resources != null) { for (Resource ref : resources.value()) { handleClassAnnotation(ref, container, clazz); } } Resource res = container.getAnnotation(Resource.class, clazz); if (res != null) handleClassAnnotation(res, container, clazz); }
public void inject(InjectionContainer container) { try { Context envCtx = container.getEnc(); ClassLoader loader = container.getClassloader(); UnifiedVirtualFile vfsRoot = UnifiedVirtualFileFactory.getInstance().create(container.getRootFile()); new ServiceReferenceHandler().bindServiceRef(envCtx, name, vfsRoot, loader, sref); } catch (Exception e) { throw new WebServiceException("Unable to bind ServiceRef [enc=" + name + "]", e); } }
jndiName = container.getEjbJndiName(ejbLink, refClass); jndiName = container.getEjbJndiName(refClass); throw new RuntimeException("could not resolve global JNDI name for " + error + " for container " + container.getIdentifier() + ": reference class: " + refClass.getName() + " ejbLink: " + ejbLink + " " + e.getMessage()); throw new RuntimeException("Failed to populate ENC: " + encName + " global jndi name was null"); log.debug(" " + encName + " --> " + jndiName); Context enc = container.getEnc(); Util.rebind(enc, encName, new LinkRef(jndiName)); throw new RuntimeException("could not bind enc name '" + encName + "' for " + error + " for container " + container.getIdentifier() + ": reference class: " + refClass.getName() + " ejbLink: " + ejbLink + " " + e.getMessage());
private void addInjector(InjectionContainer container, String encName, AnnotatedElement annotatedElement) { Injector jndiInjector; if(annotatedElement instanceof Method) jndiInjector = new JndiMethodInjector((Method)annotatedElement, encName, container.getEnc()); else if(annotatedElement instanceof Field) jndiInjector = new JndiFieldInjector((Field)annotatedElement, encName, container.getEnc()); else throw new IllegalStateException("Annotated element for '" + encName + "' is niether Method nor Field: " + annotatedElement); container.getInjectors().add(jndiInjector); }
/** * @deprecated resolve until a bean name is acquired, do not depend on a business interface */ @Deprecated protected void addDependency(InjectionContainer container, String link, Class<?> businessIntf) { log.warn("EJBTHREE-1828: calling deprecated addDependency"); EJBContainer refCon = (EJBContainer) container.resolveEjbContainer(link, businessIntf); // Do not depend on myself if(container.equals(refCon)) return; ((JBoss5DependencyPolicy) container.getDependencyPolicy()).addDependency(link, businessIntf); }
public void inject(InjectionContainer container) { try { Util.rebind(container.getEnc(), encName, obj); } catch (NamingException e) { throw new RuntimeException(new StringBuilder().append("could not bind enc name '").append(encName).append("' for ").append(error).append(" for container ").append(container.getIdentifier()).append(e.getMessage()).toString()); } } }
protected void ejbRefXml(AbstractEJBReferenceMetaData ref, String interfaceName, InjectionContainer container, String errorType) InjectionUtil.injectionTarget(encName, ref, container, container.getEncInjections()); if (container.getEncInjectors().containsKey(encName)) return; refClass = container.getClassloader().loadClass(interfaceName); throw new RuntimeException("could not find " + errorType + "'s local interface " + interfaceName + " in " + container.getDeploymentDescriptorType() + " of " + container.getIdentifier());
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 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 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 String link = envRef.getLink(); if( link != null ) { jndiName = container.resolveMessageDestination(link); if (jndiName == null) throw new RuntimeException("message-destination-link not found " + link + " of deployment " + container.getIdentifier()); // TODO: add dependency } else throw new RuntimeException("mapped-name or message-destination-link is required for " + envRef.getMessageDestinationRefName() + " of deployment " + container.getIdentifier()); } container.getEncInjectors().put(encName, new LinkRefEncInjector(encName, jndiName, "<message-destination-ref>")); InjectionUtil.injectionTarget(encName, envRef, container, container.getEncInjections()); } }
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()); } }
if (!container.getEncInjectors().containsKey(encName)) + container.getIdentifier() + " failed to inject on method " + method.toString(); container.getEncInjectors().put(encName, new PcEncInjector(encName, ref.unitName(), ref.type(), method.getParameterTypes()[0], error)); encName, container.getEnc()));
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); } }
Utils.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef.getInjectionTargets()); continue; Utils.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef.getInjectionTargets()); continue; throw new RuntimeException("mapped-name is required for " + envRef.getResourceRefName() + " of deployment " + container.getIdentifier());
return injectionType; ClassLoader loader = container.getClassloader(); for(ResourceInjectionTargetMetaData injectionTarget : ref.getInjectionTargets()) JndiPropertyInjector propInjector = new JndiPropertyInjector(prop, encName, container.getEnc()); container.getInjectors().add(propInjector);
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); }
throw new RuntimeException("For deployment " + container.getIdentifier() + "not enough information for @EJB. Please fill out the beanName and/or businessInterface attributes"); jndiName = container.getEjbJndiName(businessInterface); throw new RuntimeException("For deployment " + container.getIdentifier() + " could not find jndi binding based on interface only for @EJB(" + businessInterface.getName() + ") " + e.getMessage()); throw new RuntimeException("For deployment " + container.getIdentifier() + " could not find jndi binding based on interface only for @EJB(" + businessInterface.getName() + ")"); jndiName = container.getEjbJndiName(ref.beanName(), businessInterface); if (jndiName == null) throw new RuntimeException("For EJB " + container.getIdentifier() + "could not find jndi binding based on beanName and business interface for @EJB(" + ref.beanName() + ", " + businessInterface.getName() + ")");
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); } }
public void handleFieldAnnotations(Field field, InjectionContainer container, Map<AccessibleObject, Injector> injectors) { EJB ref = container.getAnnotation(EJB.class, field); if(ref == null) return; String encName = getEncName(ref, field); injectors.put(field, new JndiFieldInjector(field, encName, container.getEnc())); }
public void inject(InjectionContainer container) { try { Util.rebind(container.getEnc(), name, getEnvEntryValue(container.getClassloader())); } catch (Exception e) { throw new RuntimeException("Invalid <env-entry> name: " + name, e); } }