SpringComponent now supports adding properties as beans instead of

[utils] / system / spring / src / main / java / org / wamblee / system / spring / SpringComponent.java

diff --git a/system/spring/src/main/java/org/wamblee/system/spring/SpringComponent.java b/system/spring/src/main/java/org/wamblee/system/spring/SpringComponent.java
index 0e54deaec72ff12b194348704632f9bb8fdf7c4e..d0abbcd173b8f20152744cac6b4b35df1cd94f53 100644 (file)
--- a/system/spring/src/main/java/org/wamblee/system/spring/SpringComponent.java
+++ b/system/spring/src/main/java/org/wamblee/system/spring/SpringComponent.java
@@ -15,6 +15,7 @@
  */ 
 package org.wamblee.system.spring;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
 
@@ -25,10 +26,12 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.context.support.AbstractApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.context.support.GenericApplicationContext;
-import org.wamblee.system.AbstractComponent;
-import org.wamblee.system.ProvidedInterface;
-import org.wamblee.system.RequiredInterface;
-import org.wamblee.system.SystemAssemblyException;
+import org.wamblee.system.core.AbstractComponent;
+import org.wamblee.system.core.DefaultScope;
+import org.wamblee.system.core.ProvidedInterface;
+import org.wamblee.system.core.RequiredInterface;
+import org.wamblee.system.core.Scope;
+import org.wamblee.system.core.SystemAssemblyException;
 
 /**
  * Represents a system configured based on spring. The spring config files that
@@ -36,23 +39,18 @@ import org.wamblee.system.SystemAssemblyException;
  * 
  * @author Erik Brakkee
  */
-public class SpringComponent extends AbstractComponent {
+public class SpringComponent extends AbstractComponent<Scope> {
+
+       private static final String CONTEXT_KEY = "context";
 
        static final ThreadLocal<SpringComponent> THIS = new ThreadLocal<SpringComponent>();
+       static final ThreadLocal<Scope> SCOPE = new ThreadLocal<Scope>();
 
        private Properties _properties;
        private String[] _configFiles;
        private Map<String, ProvidedInterface> _provided;
        private Map<RequiredInterface, String> _required;
-       /**
-        * Parent application context containing required services.
-        */
-       private GenericApplicationContext _parentContext;
-
-       /**
-        * Application context containing parsed objects.
-        */
-       private AbstractApplicationContext _context;
+       private Map<String, Properties> _propertyObjects;
 
        /**
         * Constructs a spring system.
@@ -79,6 +77,8 @@ public class SpringComponent extends AbstractComponent {
                _configFiles = aConfigFiles;
                _provided = aProvided;
                _required = aRequired;
+               _propertyObjects = new HashMap<String, Properties>(); 
+               
        }
 
        /**
@@ -98,69 +98,101 @@ public class SpringComponent extends AbstractComponent {
                        setProperty((String) key, aProperties.getProperty((String) key));
                }
        }
+       
+       public void addProperties(String aBeanname, Properties aProperties) { 
+           _propertyObjects.put(aBeanname, aProperties);
+       }
+       
+       public Properties getProperties(String aBeanname) { 
+           return _propertyObjects.get(aBeanname);
+       }
 
        @Override
-       protected void doStart() {
+       protected Scope doStart(Scope aExternalScope) {
 
                SpringComponent old = THIS.get();
+               Scope oldScope = SCOPE.get();
                THIS.set(this);
+               Scope scope = new DefaultScope(getProvidedInterfaces(), aExternalScope);
+               SCOPE.set(scope);
                try {
-                       _parentContext = new GenericApplicationContext();
+                       GenericApplicationContext parentContext = new GenericApplicationContext();
 
-                       registerRequiredServices();
+                       registerRequiredServices(parentContext);
+                       registerPropertyObjects(parentContext);
 
-                       _parentContext.refresh();
+                       parentContext.refresh();
+                       
+                       System.out.println("Parent context " + parentContext);
+                   
+                       AbstractApplicationContext context = parseConfigFiles(parentContext);
 
-                       parseConfigFiles();
-
-                       _context
+                       context
                                        .addBeanFactoryPostProcessor(new PropertySetter(_properties));
-                       _context.refresh();
+                       context.refresh();
 
-                       exposeProvidedServices();
+                       exposeProvidedServices(context, aExternalScope);
+                       
+                       scope.put(CONTEXT_KEY, context);
+                       return scope; 
                } catch (Exception e) {
                        throw new SystemAssemblyException(
-                                       "Failed to assemble spring system", e);
+                                       "Failed to assemble spring system " + getName(), e);
                } finally {
                        THIS.set(old);
+                       SCOPE.set(oldScope);
                }
        }
 
-       private void exposeProvidedServices() {
+       private void exposeProvidedServices(AbstractApplicationContext aContext, Scope aScope) {
                // Call addService for each provided service.
 
                for (String name : _provided.keySet()) {
-                       Object svc = _context.getBean(name);
+                       Object svc = aContext.getBean(name);
                        if (svc == null) {
                                throw new IllegalArgumentException(getQualifiedName() + ": service '"
                                                + name + "' is null");
                        }
-                       addService(_provided.get(name), svc);
+                       addInterface(_provided.get(name), svc, aScope);
+                       System.out.println("addService " + _provided.get(name) + " " + svc);
                }
        }
 
-       private void parseConfigFiles() {
+       private AbstractApplicationContext parseConfigFiles(GenericApplicationContext aParentContext) {
                // Parse spring config files
 
-               _context = new ClassPathXmlApplicationContext((String[]) _configFiles,
-                               _parentContext);
+               return new ClassPathXmlApplicationContext((String[]) _configFiles,
+                               false, aParentContext);
        }
 
-       private void registerRequiredServices() {
+       private void registerRequiredServices(GenericApplicationContext aParentContext) {
                // Register required services in a parent context
-               for (RequiredInterface required: getRequiredServices()) { 
+               for (RequiredInterface required: getRequiredInterfaces()) { 
                        String beanName = _required.get(required);
                        ConstructorArgumentValues cargs = new ConstructorArgumentValues();
                        cargs.addGenericArgumentValue(required.getName());
                        BeanDefinition definition = new RootBeanDefinition(
                                        RequiredServiceBean.class, cargs,
                                        new MutablePropertyValues());
-                       _parentContext.registerBeanDefinition(beanName, definition);
+                       aParentContext.registerBeanDefinition(beanName, definition);
                }
        }
+       
+       private void registerPropertyObjects(GenericApplicationContext aParentContext) {
+        for (String beanName: _propertyObjects.keySet()) { 
+            ConstructorArgumentValues cargs = new ConstructorArgumentValues();
+            cargs.addGenericArgumentValue(PropertySetter.createPropertyFile(_propertyObjects.get(beanName)));
+            BeanDefinition definition = new RootBeanDefinition(
+                    ConfiguredProperties.class, cargs,
+                    new MutablePropertyValues());
+            aParentContext.registerBeanDefinition(beanName, definition);
+        }
+    }
+
 
        @Override
-       protected void doStop() {
-               _context.close();
+       protected void doStop(Scope aRuntime) {
+               AbstractApplicationContext context = (AbstractApplicationContext)aRuntime.get(CONTEXT_KEY);
+               context.close();
        }
 }