Cannot reference FactoryBean in a SpEL expression [SPR-9511]

[spring-projects-issues]

matthew inger opened SPR-9511 and commented

Status Quo

Currently, if you try to reference a FactoryBean in a SpEL expression using standard syntax, you get an error as follows.

Caused by: org.springframework.beans.factory.BeanExpressionException: Expression parsing failed; nested exception is java.lang.IllegalStateException: Cannot handle (38) '&'
	at org.springframework.context.expression.StandardBeanExpressionResolver.evaluate(StandardBeanExpressionResolver.java:142)
	at org.springframework.beans.factory.support.AbstractBeanFactory.evaluateBeanDefinitionString(AbstractBeanFactory.java:1299)
	at org.springframework.beans.factory.support.BeanDefinitionValueResolver.evaluate(BeanDefinitionValueResolver.java:224)
	at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:311)
	... 45 more
Caused by: java.lang.IllegalStateException: Cannot handle (38) '&'
	at org.springframework.expression.spel.standard.Tokenizer.process(Tokenizer.java:193)
	at org.springframework.expression.spel.standard.Tokenizer.<init>(Tokenizer.java:47)
	at org.springframework.expression.spel.standard.InternalSpelExpressionParser.doParseExpression(InternalSpelExpressionParser.java:110)
	at org.springframework.expression.spel.standard.SpelExpressionParser.doParseExpression(SpelExpressionParser.java:56)
	at org.springframework.expression.spel.standard.SpelExpressionParser.doParseExpression(SpelExpressionParser.java:1)
	at org.springframework.expression.common.TemplateAwareExpressionParser.parseExpressions(TemplateAwareExpressionParser.java:128)
	at org.springframework.expression.common.TemplateAwareExpressionParser.parseTemplate(TemplateAwareExpressionParser.java:74)
	at org.springframework.expression.common.TemplateAwareExpressionParser.parseExpression(TemplateAwareExpressionParser.java:64)
	at org.springframework.context.expression.StandardBeanExpressionResolver.evaluate(StandardBeanExpressionResolver.java:119)
	... 48 more

Work-Around

I can work around this by injecting the AnnotationSessionFactoryBean into my initializer, but that will break when I move to Hibernate 4. Alternatively, I could use a BeanReferenceFactoryBean and get the BeanFactory to retrieve a named bean and then use SpEL from there. Either seems like a hack, and SpEL should support this IMHO.

Example Code

Here's the relevant XML configuration:

    <bean id="entityCallbackHandler" class="org.hibernate.ejb.event.EntityCallbackHandler "/>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
     ...
    </bean>

    <bean id="entityCallbackHandlerInitializer"
          class="hibernate.utilities.EntityCallbackHandlerInitializer">
    	<property name="entityCallbackHandler" ref="entityCallbackHandler" />
    	<property name="configuration" value="#{&amp;sessionFactory.configuration}" />
    </bean>

And the java code for the initializer class:

public class EntityCallbackHandlerInitializer {

  private Configuration configuration;

  private EntityCallbackHandler entityCallbackHandler;
  
  public void setConfiguration(Configuration configuration) {
      this.configuration = configuration;
  }

  public void setEntityCallbackHandler(EntityCallbackHandler entityCallbackHandler) {
      this.entityCallbackHandler = entityCallbackHandler;
  }

  @PostConstruct
  public void init() throws ClassNotFoundException {
      final ReflectionManager reflectionManager = configuration.getReflectionManager();
      final Iterator<PersistentClass> classMappings = configuration.getClassMappings();
      while (classMappings.hasNext()) {
          entityCallbackHandler.add(
                  reflectionManager.classForName(classMappings.next().getClassName(), this.getClass()),
                  reflectionManager);
      }
  }
}

---

Issue Links:

• SpEl does not support conjunction (&&) and disjunction (||) logic [SPR-7652] #12308 SpEl does not support conjunction (&&) and disjunction (||) logic

[spring-projects-issues]

matthew inger commented

yes, i did use the entity reference for the ampersand in my code. Jira seems to be interprerating that in the description, and replacing with with an actual ampersand :(

[spring-projects-issues]

Sam Brannen commented

Andy Clement added as watcher.

@Andy, can you comment here?

[spring-projects-issues]

Chris Beams commented

Andy, for context, the & operator is used to dereference Spring FactoryBean types. For example, if bean "foo" is assignable to Spring's FactoryBean interface, the following call will return the result of foo.getObject(), i.e. the object produced by the factory bean:

Object foo = context.getBean("foo");

However, if the caller wants to access the factory itself, & can be used to dereference:

Object fooFactoryBean = context.getBean("&foo");

So matthew is asking about supporting & syntax in SpEL expressions. At a glance, this makes sense to me.

[spring-projects-issues]

Andy Clement commented

Yep, sounds a reasonable requirement. Prior to me adding '&&' last week we didn't really allow '&' anywhere in the expressions (hence the error). Shouldn't be too hard to add. What would the name of the SpEL Ast node be for the construct? We currently have 'bean reference' for the syntax @Foo - would it make sense to call this a 'factory bean reference'? We can probably just use the same BeanResolver and pass through the additional '&' through on the front of the bean name we pass to the resolve() method.

[spring-projects-issues]

Sam Brannen commented

Hi Andy,

What would the name of the SpEL Ast node be for the construct? We currently have 'bean reference' for the syntax @Foo - would it make sense to call this a 'factory bean reference'?

Yes, that is exactly what I was going to recommend: factory bean reference; however, if you check out the documentation for BeanFactoryUtils.isFactoryDereference(String), you'll see that it refers to it as a factory dereference:

/**
 * Return whether the given name is a factory dereference
 * (beginning with the factory dereference prefix).
 * @param name the name of the bean
 * @return whether the given name is a factory dereference
 * @see BeanFactory#FACTORY_BEAN_PREFIX
 */
public static boolean isFactoryDereference(String name) {
	return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}

And here's the corresponding documentation from BeanFactory:

/**
 * Used to dereference a {@link FactoryBean} instance and distinguish it from
 * beans <i>created</i> by the FactoryBean. For example, if the bean named
 * <code>myJndiObject</code> is a FactoryBean, getting <code>&myJndiObject</code>
 * will return the factory, not the instance returned by the factory.
 */
String FACTORY_BEAN_PREFIX = "&";

So now I'm wondering if it should be called factory dereference or factory bean reference.

Although I guess both make sense depending on your point of view.

We can probably just use the same BeanResolver and pass through the additional '&' through on the front of the bean name we pass to the resolve() method.

Sounds good.

Cheers,

Sam

[spring-projects-issues]

Chris Beams commented

Thanks, Andy and Sam, this looks like a thumbs-up for being feasible and worth implementing. Slating for the General Backlog until someone can pick up the work.

[spring-projects-issues]

Andy Clement commented

Improvement committed, with tests and minor doc updates.