Make Bean With Only Some Property Value Known at Config Time

[steve_smith]

Hi,

I have bean which can have multiple instance at runtime. So I cannot make it a "singleton" bean in app context. I did think about making it a prototype bean (i.e. non-singleton) but problem is some property value are known at config time (i.e. when I make app context file -- so can be set with setter injection) and some only known at run time. And to complicate it, my bean cannot do its "initialization" (i.e. afterPropertiesSet) until all property values are set. Example:

public class MyBean implements InitializingBean
{
  private String propertyKnownAtConfigTime;
  private String propertyKnownAtRunTime;
  // also other properties known at config time and run time

  public void setPropertyKnownAtConfigTime(String propertyKnownAtConfigTime)
  {
    this.propertyKnownAtConfigTime = propertyKnownAtConfigTime;
  }

  public void setPropertyKnownAtRunTime(String propertyKnownAtRunTime)
  {
    this.propertyKnownAtRunTime = propertyKnownAtRunTime;
  }

  public void afterPropertiesSet() throws Exception
  {
    // do something that needs both propertyKnownAtConfigTime 
    // and propertyKnownAtRunTime
  }
}

So here is one way how can do this, I think:

<bean name="myBeanConfigTimeProperties" class="java.util.HashMap">
  <constructor-arg index="0">
    <map>
      <entry key="propertyKnownAtConfigTime">
        <value>hello world</value>
      </entry>
      <!-- plus other properties known at config time -->
    </map>
  </constructor-arg>
</bean>

At runtime then do this in class that uses MyBean:

public class MyClassThatUsesMyBean
{
  private Map myBeanConfigTimeProperties;
 
  // setter called by container via setter injection
  public void setMyBeanConfigTimeProperties(Map myBeanConfigTimeProperties)
  {
    this.myBeanConfigTimeProperties = myBeanConfigTimeProperties;
  }

  public void useMyBeanForSomething(String foo)
  {
    MyBean myBean = new MyBean();
    myBean.setPropertyKnownAtRunTime(foo);
    BeanWrapper bwMyBean = BeanWrapperImpl(myBean);
    bwMyBean.setPropertyValues(myBeanConfigTimeProperties);
    try
    {
      myBean.afterPropertiesSet();
    }
    catch(Exception e)
    {
      throw new RuntimeException(e);
    }
    // now do something with myBean
  }
}

Perhaps, is needed, some utility like this for better abstraction:

public class someUtilClass
{
  public static void setPropertyValues(Object bean, Map propertyValues, boolean callAfterPropertiesSetIfInitializingBean)
  {
    BeanWrapper bwBean = new BeanWrapperImpl(bean);
    bwBean.setPropertyValues(propertyValues);

    if (callAfterPropertiesSetIfInitializingBean && bean instanceof InitializingBean)
    {
      try
      {
        ((InitializingBean) bean).afterPropertiesSet();
      }
      catch(Exception e)
      {
        throw new RuntimeException(e);
      }    
    }
  }
}

Then if use this util, previous code now look like this:

  public void useMyBeanForSomething(String foo)
  {
    MyBean myBean = new MyBean();
    myBean.setPropertyKnownAtRunTime(foo);
    someUtilClass.setPropertyValues(myBean, myBeanConfigTimeProperties, true);
    // now do something with myBean
  }

I think this works but maybe Spring already have an abstraction for this that I can use? It seems I reinvent wheel. Am I crazy guy?

[cyboc]

Stefano,

I think Spring already has an abstraction to do this but I can't remember what it is called. I skimmed the manual and the API but I can't see it. It seems like a common problem and, as such, I'm sure the Spring gods must have already solved it.

Having said that, it seems like your solution could work. One suggestion might be to overload someUtilClass.setPropertyValues() with a signature that allows you to pass the name of an arbitrary initializer method, similar to the init-method attribute of the bean element in an app context file. For example, you could have this signature:

void setPropertyValues(Object bean, Map propertyValues, String initMethod)

In the implementation, you can invoke the initMethod via reflection -- see AbstractAutowireCapableBeanFactory.invokeCustomIni tMethod() for an example that you can adapt to your needs.

[steve_smith]

One suggestion might be to overload someUtilClass.setPropertyValues() with a signature that allows you to pass the name of an arbitrary initializer method

Good suggestion. I was just being lazy guy.

I did think about making it a prototype bean (i.e. non-singleton) but problem is some property value are known at config time (i.e. when I make app context file -- so can be set with setter injection) and some only known at run time. And to complicate it, my bean cannot do its "initialization" (i.e. afterPropertiesSet) until all property values are set.

Another reason why I am thinking prototype bean is not working for this problem, is because beans that depend on MyBean can use zero-to-many instance of MyBean. What dependent beans really need is reference to a factory that creates MyBean instances, where some properties values are set in app context file and some set on the fly. Am I crazy guy? Is this already provided in Spring Framework somehow?

[Andreas Senft]

What dependent beans really need is reference to a factory that creates MyBean instances, where some properties values are set in app context file and some set on the fly. Am I crazy guy? Is this already provided in Spring Framework somehow?

Maybe ObjectFactoryCreatingFactoryBean could be useful for you.
For providing additional runtime parameters for the instances to create, I think you need to implement your own subclass. This is because the getObject() Method itself is parameterless.

To make it work, I think the factory itself should be declared as prototype. Otherwise there might be problems if multiple threads parameterize the factory and then try to create an instance. Alternatively, your subclass might use ThreadLocal for parameterization. That should eliminate the need for prototype factories.

Hope that helps,
Andreas

[steve_smith]

Andreas,

Thanks for tips. I look into your idea and I think can work. I think two complications are:

1. additional runtime properties
2. I think, is best for code reuse, for this FactoryBean to be generic (e.g. additional runtime properties set through property-name-to-property-value map instead of having specific property setters on FactoryBean)
3. calling init-method (e.g. afterPropertiesSet) only after both config-time and runtime properties have been set first

For complication 1 and 2, I think can solve with subclass ObjectFactoryCreatingFactoryBean and add method:

public void setRuntimePropertyValues(Map propertyValues)

Then, need also to override createInstance like this:

protected Object createInstance() 
{
  return new ObjectFactory() 
  {
    public Object getObject() throws BeansException 
    {
      // get bean with config-time properties set
      Object bean = beanFactory.getBean(targetBeanName);

      // now set also runtime properties
      BeanWrapper bwBean = new BeanWrapperImpl(bean);
      bwBean.setPropertyValues(runtimePropertyValues);

      return bean;
    }
  };
}

Now for complication 3, I cannot simply have target bean implement InitializingBean. For this, problem is, somewhere in call to beanFactory.getBean(targetBeanName), container will call afterPropertiesSet(). But, you see, this is not good because only config-time properties have been set so far, not runtime properties. So maybe I need to make new interface and have target bean implement it. Example:

public interface RuntimeInitializingBean 
{
  void afterRuntimePropertiesSet() throws Exception;
}

Then, must change createInstance to somethings like this one:

protected Object createInstance() 
{
  return new ObjectFactory() 
  {
    public Object getObject() throws BeansException 
    {
      // get bean with config-time properties set
      Object bean = beanFactory.getBean(targetBeanName);

      // now set also runtime properties
      BeanWrapper bwBean = new BeanWrapperImpl(bean);
      bwBean.setPropertyValues(runtimePropertyValues);

      // now call init method
      if (bean instanceof RuntimeInitializingBean)
      {
        try
        {
          ((RuntimeInitializingBean) bean).afterRuntimePropertiesSet();
        }
        catch (Exception e)
        {
          throw new BeanInitializationException(
            "An error occurred in afterRuntimePropertiesSet()", e);
        }
      }

      return bean;
    }
  };
}

So what you thinking about this one? Maybe not worth effort (without using ObjectFactoryCreatingFactoryBean, I only need 3 lines of code to create bean - see useMyBeanForSomething() in above post)?

Maybe Rod can also say about this one?

[Andreas Senft]

I think, is best for code reuse, for this FactoryBean to be generic (e.g. additional runtime properties set through property-name-to-property-value map instead of having specific property setters on FactoryBean)

I agree. A generic subclass using BeanWrapper (as sketched by you) is a preferrable solution.

So what you thinking about this one? Maybe not worth effort (without using ObjectFactoryCreatingFactoryBean, I only need 3 lines of code to create bean - see useMyBeanForSomething() in above post)?

I think a generic approach would be worthwile. It could be applied in different cases as well. For the initialization method I would prefer a reflective approach (like the normal init-method) in favour of an additional attribute.

Regards,
Andreas

[cyboc]

Stefano,

Give the following a try. I took your code snippets and added in some of Andreas' comments to create an initial implementation. If anyone finds this handy, please let me know.

First, two new interfaces and the FactoryBean implementation. Note that the FactoryBean allows you to either supply a custom init-method name or you can implement DynamicInitializingBean in the bean that the factory creates:

package com.cbconstantini.core.spring;

import java.util.Map;

import org.springframework.beans.factory.ObjectFactory;

/**
 * An ObjectFactory that allows you to supply bean property values at 
 * dynamically at runtime (ObjectFactory only allows you to supply bean property
 * values at config time).
 * @author jkelly
 */
public interface DynamicObjectFactory extends ObjectFactory
{
  /**
   * Sets the dynamicPropertyValues that this factory will set on the bean it
   * creates.
   * @param dynamicPropertyValues a property-name-to-property-value Map
   */
  void setDynamicPropertyValues(Map dynamicPropertyValues);
}

package com.cbconstantini.core.spring;

/**
 * Interface to be implemented by beans that need to react once all their
 * dynamic properties have been set by a DynamicObjectFactory. For example, to
 * perform custom initialization, or merely to check that all mandatory dynamic
 * properties have been set.
 * @author jkelly
 */
public interface DynamicInitializingBean
{
  /**
   * Invoked by a DynamicObjectFactory after it has set all dynamic bean
   * properties supplied.
   * <p>
   * This method allows the bean instance to perform initialization only
   * possible when all dynamic bean properties have been set and to throw an
   * exception in the event of misconfiguration.
   * @throws Exception in the event of misconfiguration &#40;such as failure to set
   * an essential property&#41; or if initialization fails.
   */
  void afterDynamicPropertiesSet&#40;&#41; throws Exception;
&#125;

package com.cbconstantini.core.spring;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean;
import org.springframework.util.StringUtils;

/**
 * An ObjectFactoryCreatingFactoryBean that creates DynamicObjectFactory instances.
 * @author jkelly
 */
public class DynamicObjectFactoryCreatingFactoryBean extends
  ObjectFactoryCreatingFactoryBean
{
  private String dynamicInitMethodName;
  
  /**
   * Sets the name of the initialization method that this factory will call
   * after it sets the dynamicPropertyValues.
   * @param dynamicInitMethodName
   */
  public void setDynamicInitMethodName(String dynamicInitMethodName)
  {
    this.dynamicInitMethodName = dynamicInitMethodName;
  }
  
  /**
   * Overrides ObjectFactoryCreatingFactoryBean.createInstance() to return a 
   * DynamicObjectFactory instead of an ObjectFactory.
   */
  protected Object createInstance()
  {
    return new DynamicObjectFactory()
    {
      private Map dynamicPropertyValues;
      private ObjectFactory wrappedObjectFactory = (ObjectFactory)
        DynamicObjectFactoryCreatingFactoryBean.super.createInstance();

      public void setDynamicPropertyValues(Map dynamicPropertyValues)
      {
        this.dynamicPropertyValues = dynamicPropertyValues;
      }

      public Object getObject() throws BeansException
      {
        // get the bean with only config time property values set
        Object bean = wrappedObjectFactory.getObject();
        
        // now set also dynamic property values
        BeanWrapper bwBean = new BeanWrapperImpl(bean);
        bwBean.setPropertyValues(dynamicPropertyValues);
  
        // now call either custom dynamic init-method or afterDynamicPropertiesSet()
        if (StringUtils.hasText(dynamicInitMethodName))
        {
          Method initMethod = BeanUtils.findMethod(bean.getClass(),
            dynamicInitMethodName, null);
          if (initMethod == null)
          {
            throw new BeanInitializationException(
              "Couldn't find an init method named '" + dynamicInitMethodName
                + "' on bean of type '" + bean.getClass().getName() + "'");
          }
 
          if (!Modifier.isPublic(initMethod.getModifiers()))
          {
            initMethod.setAccessible(true);
          }          
          
          try
          {
            initMethod.invoke(bean, (Object[]) null);
          }
          catch (InvocationTargetException ite)
          {
            throw new BeanInitializationException(
              "An error occurred in afterDynamicPropertiesSet()", ite.getTargetException());            
          }
          catch (Exception e)
          {
            throw new BeanInitializationException(
              "An error occurred in afterDynamicPropertiesSet()", e);            
          }
        }
        else if (bean instanceof DynamicInitializingBean)
        {
          try
          {
            ((DynamicInitializingBean) bean).afterDynamicPropertiesSet();
          }
          catch (Exception e)
          {
            throw new BeanInitializationException(
              "An error occurred in afterDynamicPropertiesSet()", e);
          }
        }        
        
        return bean;
      }
    }; 
  }
}

Now a TestCase (with accompanying application context file and helper classes) that shows sample usage:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC  "-//SPRING//DTD BEAN//EN" "http&#58;//www.springframework.org/dtd/spring-beans.dtd">

<!--
  Test data for DynamicObjectFactoryCreatingFactoryBeanTest
-->

<beans>
  <bean id="prototypeTarget" class="com.cbconstantini.core.spring.MyBean" singleton="false">
    <property name="propertyKnownAtConfigTime">
      <value>foo</value>
    </property>
  </bean> 	

  <bean id="prototype" class="com.cbconstantini.core.spring.DynamicObjectFactoryCreatingFactoryBean">
    <property name="targetBeanName"><idref local="prototypeTarget"/></property>
  </bean> 
  
  <bean id="testBean" class="com.cbconstantini.core.spring.DynamicObjectFactoryCreatingFactoryBeanTest$TestBean">
    <property name="dynamicObjectFactory"><ref local="prototype"/></property>
  </bean>
  
  <bean id="prototypeTargetWithCustomInit" class="com.cbconstantini.core.spring.MyBeanWithCustomInit" singleton="false">
    <property name="propertyKnownAtConfigTime">
      <value>foo</value>
    </property>
  </bean> 	

  <bean id="prototypeWithCustomInit" class="com.cbconstantini.core.spring.DynamicObjectFactoryCreatingFactoryBean">
    <property name="targetBeanName"><idref local="prototypeTargetWithCustomInit"/></property>
    <property name="dynamicInitMethodName">
      <value>myCustomInitMethod</value>
    </property>
  </bean> 
  
  <bean id="testBeanWithCustomInit" class="com.cbconstantini.core.spring.DynamicObjectFactoryCreatingFactoryBeanTest$TestBean">
    <property name="dynamicObjectFactory"><ref local="prototypeWithCustomInit"/></property>
  </bean>     
</beans>

package com.cbconstantini.core.spring;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

import junit.framework.TestCase;

/**
 * TestCase for DynamicObjectFactoryCreatingFactoryBean.
 * @author jkelly
 */
public class DynamicObjectFactoryCreatingFactoryBeanTest extends TestCase
{
  private BeanFactory beanFactory;

  protected void setUp() throws Exception
  {
    super.setUp();
    this.beanFactory = new XmlBeanFactory(new ClassPathResource(
      "DynamicObjectFactoryCreatingFactoryBeanTest.xml", getClass()));    
  }

  public void testGetObject()
  {
    // get DynamicObjectFactory
    TestBean testBean = (TestBean) beanFactory.getBean("testBean");
    DynamicObjectFactory dynamicObjectFactory = testBean.getDynamicObjectFactory();
   
    // set dynamicProperties
    Map dynamicProperties = new HashMap();
    dynamicProperties.put("propertyKnownAtRunTime", "bar");
    dynamicObjectFactory.setDynamicPropertyValues(dynamicProperties);
    
    // create a bean with the factory
    Object obj = dynamicObjectFactory.getObject();
    DynamicObjectFactoryTestBean bean = (DynamicObjectFactoryTestBean) dynamicObjectFactory.getObject();
    
    // do assertions
    assertEquals("getConcatenated()", "foobar", bean.getConcatenated());    
  }
  
  public void testGetObjectWithCustomInit()
  {
    // get DynamicObjectFactory
    TestBean testBean = (TestBean) beanFactory.getBean("testBeanWithCustomInit");
    DynamicObjectFactory dynamicObjectFactory = testBean.getDynamicObjectFactory();
   
    // set dynamicProperties
    Map dynamicProperties = new HashMap();
    dynamicProperties.put("propertyKnownAtRunTime", "bar");
    dynamicObjectFactory.setDynamicPropertyValues(dynamicProperties);
    
    // create a bean with the factory
    Object obj = dynamicObjectFactory.getObject();
    DynamicObjectFactoryTestBeanWithCustomInit bean = (DynamicObjectFactoryTestBeanWithCustomInit) dynamicObjectFactory.getObject();
    
    // do assertions
    assertEquals("getConcatenated()", "barfoo", bean.getConcatenated());    
  }  
  
  public static class TestBean {
    public DynamicObjectFactory dynamicObjectFactory;

    public DynamicObjectFactory getDynamicObjectFactory()
    {
      return dynamicObjectFactory;
    }
    public void setDynamicObjectFactory(
      DynamicObjectFactory dynamicObjectFactory)
    {
      this.dynamicObjectFactory = dynamicObjectFactory;
    }
  }
}

package com.cbconstantini.core.spring;

/**
 * Test class to be instantiated by a DynamicObjectFactory in 
 * DynamicObjectFactoryCreatingFactoryBeanTest.
 * @author jkelly
 */
public class MyBean implements DynamicInitializingBean
{
  private String propertyKnownAtConfigTime;
  private String propertyKnownAtRunTime;
  private String concatenated;

  public void setPropertyKnownAtConfigTime(String propertyKnownAtConfigTime)
  {
    this.propertyKnownAtConfigTime = propertyKnownAtConfigTime;
  }

  public void setPropertyKnownAtRunTime(String propertyKnownAtRunTime)
  {
    this.propertyKnownAtRunTime = propertyKnownAtRunTime;
  }
  
  public String getConcatenated()
  {
    return concatenated;
  }  
  
  /* (non-Javadoc)
   * @see com.cbconstantini.core.spring.DynamicInitializingBean#afterDynamicPropertiesSet()
   */
  public void afterDynamicPropertiesSet() throws Exception
  {
    concatenated = propertyKnownAtConfigTime + propertyKnownAtRunTime;
  } 
}

package com.cbconstantini.core.spring;

/**
 * Test class to be instantiated by a DynamicObjectFactory in 
 * DynamicObjectFactoryCreatingFactoryBeanTest. This class has a custom 
 * init-method called myCustomInitMethod().
 * @author jkelly
 */
public class MyBeanWithCustomInit
{
  private String propertyKnownAtConfigTime;
  private String propertyKnownAtRunTime;
  private String concatenated;

  public void setPropertyKnownAtConfigTime(String propertyKnownAtConfigTime)
  {
    this.propertyKnownAtConfigTime = propertyKnownAtConfigTime;
  }

  public void setPropertyKnownAtRunTime(String propertyKnownAtRunTime)
  {
    this.propertyKnownAtRunTime = propertyKnownAtRunTime;
  }
  
  public String getConcatenated()
  {
    return concatenated;
  }
  
  public void myCustomInitMethod()
  {
    concatenated = propertyKnownAtRunTime + propertyKnownAtConfigTime;
  }
}

[steve_smith]

Cyboc,

I take quick look just now and I think is great. I think will work for me! I will try closer look today and let you know if any problem.

Andreas, what you thinking about this one by Cyboc? It seems you can now have custom init method.

Okay, see you now.

[alexandrupopescu]

Excellent solution cyboc! I would like to ask you if I can use the above ideas and code in my project?

tia,