private InjectionSite findInjectionSite(Injectable attribute) { // try constructor for (int i = 0; i < cdiSources.size(); i++) { Injectable injectable = cdiSources.get(i); if (attribute.equals(injectable)) { return new ConstructorInjectionSite(constructor, i); } } // try postConstruction for (Map.Entry<InjectionSite, Injectable> entry : postConstruction.entrySet()) { if (entry.getValue().equals(attribute)) { return entry.getKey(); } } return null; }
public void updated(Object instance, String referenceName) { if (instance != null && !reinjectable) { throw new IllegalStateException("Implementation is not reinjectable: " + componentUri); } for (int i = 0; i < injectables.length; i++) { Injectable attribute = injectables[i]; if (attribute.getName().equals(referenceName)) { Injector<Object> injector = injectors[i]; if (instance != null) { updatedInjectors.add(injector); } } } }
public void setObjectFactory(Injectable injectable, ObjectFactory<?> objectFactory, InjectionAttributes attributes) { if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { setUpdatableFactory(injectable, objectFactory, attributes); } else { // the factory corresponds to a property or context, which will override previous values if reinjected factories.put(injectable, objectFactory); } }
public PhysicalSourceDefinition generateResourceSource(LogicalResourceReference<?> resourceReference) throws GenerationException { URI uri = resourceReference.getUri(); ServiceContract serviceContract = resourceReference.getDefinition().getServiceContract(); String interfaceName = getInterfaceName(serviceContract); JavaSourceDefinition wireDefinition = new JavaSourceDefinition(); wireDefinition.setUri(uri); wireDefinition.setInjectable(new Injectable(InjectableType.RESOURCE, uri.getFragment())); wireDefinition.setInterfaceName(interfaceName); return wireDefinition; }
public PhysicalSourceDefinition generateSource(LogicalReference reference, EffectivePolicy policy) throws GenerationException { URI uri = reference.getUri(); ServiceContract serviceContract = reference.getDefinition().getServiceContract(); String interfaceName = getInterfaceName(serviceContract); JavaSourceDefinition wireDefinition = new JavaSourceDefinition(); wireDefinition.setUri(uri); wireDefinition.setInjectable(new Injectable(InjectableType.REFERENCE, uri.getFragment())); wireDefinition.setInterfaceName(interfaceName); // assume for now that any wire from a JUnit component can be optimized wireDefinition.setOptimizable(true); if (reference.getDefinition().isKeyed()) { wireDefinition.setKeyed(true); DataType<?> type = reference.getDefinition().getKeyDataType(); String className = type.getPhysical().getName(); wireDefinition.setKeyClassName(className); } return wireDefinition; }
public void removed(Object instance, String referenceName) { if (instance != null && !reinjectable) { throw new IllegalStateException("Implementation is not reinjectable: " + componentUri); } for (int i = 0; i < injectables.length; i++) { Injectable attribute = injectables[i]; if (attribute.getName().equals(referenceName)) { Injector<Object> injector = injectors[i]; injector.clearObjectFactory(); if (instance != null) { updatedInjectors.add(injector); } } } }
protected void createPropertyFactories(PCD definition, ImplementationManagerFactory factory) throws BuilderException { List<PhysicalPropertyDefinition> propertyDefinitions = definition.getPropertyDefinitions(); TypeMapping typeMapping = new TypeMapping(); helper.resolveTypeParameters(factory.getImplementationClass(), typeMapping); for (PhysicalPropertyDefinition propertyDefinition : propertyDefinitions) { String name = propertyDefinition.getName(); Document value = propertyDefinition.getValue(); Injectable source = new Injectable(InjectableType.PROPERTY, name); Type type = factory.getGenericType(source); DataType<?> dataType = getDataType(type, typeMapping); ClassLoader classLoader = classLoaderRegistry.getClassLoader(definition.getClassLoaderId()); boolean many = propertyDefinition.isMany(); ObjectFactory<?> objectFactory = propertyBuilder.createFactory(name, dataType, value, many, classLoader); factory.setObjectFactory(source, objectFactory); } }
private void generateContextInjectionMapping(WebComponentType type, Map<String, Map<String, InjectionSite>> mappings) { // OASIS API Map<String, InjectionSite> oasisMapping = mappings.get(OASIS_CONTEXT_ATTRIBUTE); if (oasisMapping == null) { oasisMapping = new HashMap<String, InjectionSite>(); WebContextInjectionSite site = new WebContextInjectionSite(ComponentContext.class.getName(), SESSION_CONTEXT); oasisMapping.put(SESSION_CONTEXT_SITE, site); mappings.put(OASIS_CONTEXT_ATTRIBUTE, oasisMapping); } for (Map.Entry<String, Map<InjectionSite, Injectable>> entry : type.getInjectionSites().entrySet()) { for (Map.Entry<InjectionSite, Injectable> siteMap : entry.getValue().entrySet()) { if (siteMap.getValue().equals(Injectable.OASIS_COMPONENT_CONTEXT)) { oasisMapping.put(entry.getKey(), siteMap.getKey()); } } } }
public void startUpdate() { for (Map.Entry<Injectable, ObjectFactory<?>> entry : factories.entrySet()) { // signal to multiplicity factories that previous contents should be overwritten if the factory is updated (e.g. during reinjection) Injectable injectable = entry.getKey(); ObjectFactory<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicityObjectFactory) { MultiplicityObjectFactory<?> multiplicityObjectFactory = (MultiplicityObjectFactory<?>) factory; multiplicityObjectFactory.startUpdate(); } } } }
private void generateReferenceInjectionMapping(AbstractReference definition, WebComponentType type, Map<String, Map<String, InjectionSite>> mappings) { Map<String, InjectionSite> mapping = mappings.get(definition.getName()); if (mapping == null) { mapping = new HashMap<String, InjectionSite>(); mappings.put(definition.getName(), mapping); } for (Map.Entry<String, Map<InjectionSite, Injectable>> entry : type.getInjectionSites().entrySet()) { for (Map.Entry<InjectionSite, Injectable> siteMap : entry.getValue().entrySet()) { if (siteMap.getValue().getName().equals(definition.getName())) { mapping.put(entry.getKey(), siteMap.getKey()); } } } ServiceContract contract = definition.getServiceContract(); String interfaceClass = contract.getQualifiedInterfaceName(); // inject the reference into the session context WebContextInjectionSite site = new WebContextInjectionSite(interfaceClass, SESSION_CONTEXT); mapping.put(SESSION_CONTEXT_SITE, site); // also inject the reference into the servlet context WebContextInjectionSite servletContextsite = new WebContextInjectionSite(interfaceClass, SERVLET_CONTEXT); mapping.put(SERVLET_CONTEXT_SITE, servletContextsite); }
public void endUpdate() { for (Map.Entry<Injectable, ObjectFactory<?>> entry : factories.entrySet()) { // signal to multiplicity factories updates are complete Injectable injectable = entry.getKey(); ObjectFactory<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicityObjectFactory) { MultiplicityObjectFactory<?> multiplicityObjectFactory = (MultiplicityObjectFactory<?>) factory; multiplicityObjectFactory.endUpdate(); } } } }
public void removeObjectFactory(Injectable injectable) { factory.removeObjectFactory(injectable); String name = injectable.getName(); List<Object> instances = scopeContainer.getActiveInstances(this); for (Object instance : instances) { getImplementationManager().removed(instance, name); } // Clear the instance factory as it has changed and will need to be re-created. This can happen if reinjection occurs after the first // instance has been created. recreate.set(true); }
InjectionSite site = entry.getKey(); Injectable attribute = entry.getValue(); InjectableType type = attribute.getType(); ObjectFactory<?> factory = factories.get(attribute); if (factory == null && (type == InjectableType.REFERENCE || type == InjectableType.CALLBACK)) {
/** * Sets an object factory. * * @param injectable the injectable identifying the component reference, property or context artifact the object factory creates instances for * @param objectFactory the object factory * @param attributes the injection attributes */ public void setObjectFactory(Injectable injectable, ObjectFactory<?> objectFactory, InjectionAttributes attributes) { factory.setObjectFactory(injectable, objectFactory, attributes); List<Object> instances = scopeContainer.getActiveInstances(this); String name = injectable.getName(); for (Object instance : instances) { getImplementationManager().updated(instance, name); } // Clear the instance factory as it has changed and will need to be re-created. This can happen if reinjection occurs after the first // instance has been created. recreate.set(true); }