spring beanpostprocessor doesn't work on component-scan?

Question

Hi,

I have many cookie-cutter spring beans and don't want to explicitly define each one in xml. So I went the component scanning route which lets me do this. This is nice, but I just realized that MyBeanPostProcessor isn't being called for the beans loaded in using the component-scan technique. MyBeanPostProcessor simply attempts to do some setter injection on these beans. The below configuration just shows this approach I tried which doesn't work. Any other ideas how to do setter injection on these beans?

I'm using Spring 2.5.5

Thanks, Ben

<context:component-scan base-package="us.benanderson" 
        use-default-filters="false" 
        annotation-config="false"
        scope-resolver="us.benanderson.MyScopeResolver"
        name-generator="us.benanderson.MyBeanNameGenerator">
    <context:include-filter type="custom" expression="us.benanderson.MyTypeFilter" />
</context:component-scan>
<bean class="us.benanderson.MyBeanPostProcessor">
    <property name="order" value="500" />
</bean>

Answer 1

After the application context has loaded check that the beans that you've annotated are available.

I suspect since you've turned off "annotation-config" that it is ignoring your annotations.

Answer 2

Any other ideas how to do setter injection on these beans?

My personal favorite approach is to use annotations like @Resource (which is built into Java SE 6) or @Autowire (which is Spring-specific).

These annotations can be applied to setters or fields. As Michael Wiles points out, however, you'll have to enable annotation-config:

<context:component-scan annotation-config="true"
...
/>

(or just leave off annotation-config="true" since true is the default)

I like use packages to separate my component-scanned beans vs non-component-scanned beans. For example: I usually auto-scan my Actions, DAOs, etc., but not my Entities:

<context:component-scan base-package="my.package">
    <context:include-filter type="aspectj" expression="my.package..*" />
    <context:exclude-filter type="aspectj" expression="my.package.entities.*" />
</context:component-scan>

Then Actions can have DAOs injected into them like so:

public class MyAction {
    @Resource
    public void setMyDao(MyDao myDao) { ... }
}

Having said all that, component-scanned beans should be full-fledged beans, just as if they had been cofigured via xml configuration. This could be a bug in Spring. Their forum or bug tracker may be a good place to head.

Answer 3

Here is my test case, that appears to work (Spring 2.5.6). I thought about excluding some files for brevity, but I decided against it.

Start.java (entry-point)

package se.waxwing.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Start {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("se/waxwing/test/Context.xml");
        context.getBean("customBean");
    }
}

Context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"&gt;


 <context:component-scan base-package="se.waxwing.test" 
        use-default-filters="false" 
        annotation-config="false"
        scope-resolver="se.waxwing.test.MyScopeResolver">
     <context:include-filter type="custom" expression="se.waxwing.test.MyTypeFilter" />
 </context:component-scan>

 <bean id="beanProcessor" class="se.waxwing.test.MyBeanPostProcessor" />

</beans>

CustomBean.java (this is the I want to find - see MyTypeFilter)

package se.waxwing.test;

public class CustomBean {

    public CustomBean() {
        System.err.println("instantiating component");
    }
}

MyBeanPostProcessor.java

package se.waxwing.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.err.println("after " + beanName);
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.err.println("before " + beanName);
        return bean;
    }   
}

MyScopeResolver.java

package se.waxwing.test;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.ScopeMetadata;
import org.springframework.context.annotation.ScopeMetadataResolver;
import org.springframework.context.annotation.ScopedProxyMode;

public class MyScopeResolver implements ScopeMetadataResolver {

    @Override
    public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
        ScopeMetadata result = new ScopeMetadata();
        result.setScopedProxyMode(ScopedProxyMode.NO);
        result.setScopeName("prototype");
        return result;
    }

}

MyTypeFilter.java

package se.waxwing.test;

import java.io.IOException;

import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

public class MyTypeFilter implements TypeFilter {

    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        return metadataReader.getClassMetadata().getClassName().equals(CustomBean.class.getCanonicalName());
    }
}

This produces the following output:

2009-aug-26 15:44:02 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@c1b531: display name [org.springframework.context.support.ClassPathXmlApplicationContext@c1b531]; startup date [Wed Aug 26 15:44:02 CEST 2009]; root of context hierarchy
2009-aug-26 15:44:02 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [se/waxwing/test/Context.xml]
2009-aug-26 15:44:02 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
INFO: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@c1b531]: org.springframework.beans.factory.support.DefaultListableBeanFactory@121f1d
2009-aug-26 15:44:02 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@121f1d: defining beans [customBean,beanProcessor]; root of factory hierarchy
instantiating component
before customBean
after customBean

So, as you can see, the customBean bean was found by my type filter, added as a bean, and when applicationContext.getBean("customBean") was called a new object was instantiated and then it was passed to my post bean processor.