/** * Returns the fully qualified classname of the type of the injection target (field/method). * * @param container The container * @param injectionTargets The injection target * @return */ private static String getTargetType(InjectionContainer container, ResourceInjectionTargetMetaData injectionTarget) { AccessibleObject accessibleObject = InjectionUtil.findInjectionTarget(container.getClassloader(), injectionTarget); if (accessibleObject instanceof Field) { return ((Field) accessibleObject).getType().getName(); } else if (accessibleObject instanceof Method) { return ((Method) accessibleObject).getParameterTypes()[0].getName(); } return null; }
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("")) // { // jndiName = envRef.getResolvedJndiName(); // if (jndiName == null || jndiName.equals("")) // throw new RuntimeException("mapped-name 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 static <X extends RemoteEnvironment> Map<AccessibleObject, Injector> processAnnotations(InjectionContainer container, Collection<InjectionHandler<X>> handlers, Class<?> clazz) { Map<AccessibleObject, Injector> classInjectors = new HashMap<AccessibleObject, Injector>(); HashSet<String> visitedMethods = new HashSet<String>(); collapseXmlMethodInjectors(visitedMethods, clazz, container.getEncInjections(), classInjectors); processClassAnnotations(container, handlers, clazz); visitedMethods = new HashSet<String>(); processMethodAnnotations(container, handlers, visitedMethods, clazz, classInjectors); processFieldAnnotations(container, handlers, clazz, classInjectors); return classInjectors; }
InjectionUtil.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef.getInjectionTargets()); continue; if(envRef.getInjectionTargets() != null) InjectionUtil.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef.getInjectionTargets()); continue; InjectionUtil.injectionTarget(encName, envRef, container, container.getEncInjections());
public static String getEncName(Field field) { return getEncName(field.getDeclaringClass()) + "/" + field.getName(); }
public static <X extends RemoteEnvironment> void processClassAnnotations(InjectionContainer container, Collection<InjectionHandler<X>> handlers, Class<?> clazz) { if (clazz == null || clazz.equals(Object.class)) { return; } if (handlers != null) { for (InjectionHandler<?> handler : handlers) { handler.handleClassAnnotations(clazz, container); } } // recursion needs to come last as the method could be overriden and we don't want the overriding method to be ignored processClassAnnotations(container, handlers, clazz.getSuperclass()); }
public static <X extends RemoteEnvironment> void processMethodAnnotations(InjectionContainer container, Collection<InjectionHandler<X>> handlers, Set<String> visitedMethods, Class<?> clazz, Map<AccessibleObject, Injector> classInjectors) { if (clazz == null || clazz.equals(Object.class)) { return; } Method[] methods = clazz.getDeclaredMethods(); for (Method method : methods) { if (method.getParameterTypes().length != 1) continue; if (!Modifier.isPrivate(method.getModifiers())) { if (visitedMethods.contains(method.getName())) { continue; } visitedMethods.add(method.getName()); } if (handlers != null) { for (InjectionHandler<?> handler : handlers) { handler.handleMethodAnnotations(method, container, classInjectors); } } } // recursion needs to come last as the method could be overriden and we don't want the overriding method to be ignored processMethodAnnotations(container, handlers, visitedMethods, clazz.getSuperclass(), classInjectors); }
collapseXmlMethodInjectors(visitedMethods, clazz.getSuperclass(), xmlDefinedInjectors, classInjectors);
public static <X extends RemoteEnvironment> void processFieldAnnotations(InjectionContainer container, Collection<InjectionHandler<X>> handlers, Class<?> clazz, Map<AccessibleObject, Injector> classInjectors) { if (clazz == null || clazz.equals(Object.class)) { return; } if (handlers != null) { Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { log.trace("process field annotation for " + field.toGenericString()); for (InjectionHandler<?> handler : handlers) { handler.handleFieldAnnotations(field, container, classInjectors); } } } // recursion needs to come last as the method could be overriden and we don't want the overriding method to be ignored processFieldAnnotations(container, handlers, clazz.getSuperclass(), classInjectors); }
Map<AccessibleObject, Injector> tmp = InjectionUtil.processAnnotations(this, handlers, getBeanClass()); injectors.addAll(tmp.values()); Map<AccessibleObject, Injector> injections = InjectionUtil.processAnnotations(this, handlers, interceptorClass); InterceptorInjector injector = new InterceptorInjector(injections); interceptorInjectors.put(interceptorClass, injector);
if(envRef.getInjectionTargets() != null) InjectionUtil.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef.getInjectionTargets()); continue; InjectionUtil.injectionTarget(encName, envRef, container, container.getEncInjections());
public static String getEncName(Method method) { String encName = method.getName().substring(3); if (encName.length() > 1) { encName = encName.substring(0, 1).toLowerCase() + encName.substring(1); } else { encName = encName.toLowerCase(); } encName = getEncName(method.getDeclaringClass()) + "/" + encName; return encName; }
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()); } }
InjectionUtil.createInjectors(container.getInjectors(), container.getClassloader(), factory, envRef .getInjectionTargets()); continue; InjectionUtil.injectionTarget(encName, envRef, container, container.getEncInjections());
/** * Create and add multiple injectors for injection targets. * * @param injectors the list on which to add injectors * @param classLoader the class loader to resolve an injection target * @param factory the injector factory * @param injectionTargets the injection targets */ public static void createInjectors(List<Injector> injectors, ClassLoader classLoader, InjectorFactory<?> factory, Collection<ResourceInjectionTargetMetaData> injectionTargets) { for(ResourceInjectionTargetMetaData injectionTarget : injectionTargets) { AccessibleObject ao = findInjectionTarget(classLoader, injectionTarget); BeanProperty property = BeanPropertyFactory.create(ao); injectors.add(factory.create(property)); } }
protected String getEncName(EJB ref, Field field) { String encName = ref.name(); if (encName == null || encName.equals("")) { encName = InjectionUtil.getEncName(field); } else { encName = "env/" + encName; } return encName; }
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())); } }
public static void createInjectors(Map<String, Map<AccessibleObject, Injector>> injectors, ClassLoader classLoader, InjectorFactory<?> factory, Collection<ResourceInjectionTargetMetaData> injectionTargets) { for(ResourceInjectionTargetMetaData injectionTarget : injectionTargets) { Map<AccessibleObject, Injector> map = injectors.get(injectionTarget.getInjectionTargetClass()); if(map == null) { map = new HashMap<AccessibleObject, Injector>(); injectors.put(injectionTarget.getInjectionTargetClass(), map); } AccessibleObject ao = InjectionUtil.findInjectionTarget(classLoader, injectionTarget); BeanProperty property = BeanPropertyFactory.create(ao); map.put(ao, factory.create(property)); } }
protected String getEncName(EJB ref, Method method) { String encName = ref.name(); if (encName == null || encName.equals("")) { encName = InjectionUtil.getEncName(method); } else { encName = "env/" + encName; } return encName; }
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())); } }