Spring IoC - Ensuring all beans are created before @PostConstruct/afterProperiesSet

I've got a project using Spring IoC for dependency injection, and I'm trying to slightly simplify my model by having one central location for accessing most of my beans.

I'm running into a problem using the @PostConstruct mechanism, or alternatively when implementing the InitializingBean interface. While all the dependencies in that particular bean may have been resolved, the dependencies in injected beans may not have been. For example I have:

public class A {
    public void doSomething() {};
}

publi开发者_StackOverflow社区c class B {
    private A objectA;

    @Required
    public void setObjectA(A objectA) {
        this.objectA = objectA;
    }

    public A getObjectA() {
        return objectA;
    }
}

public class C implements InitializingBean {
    private B objectB;

    @Required
    public void setObjectB(B objectB) {
        this.objectB = objectB;
    }

    public void afterPropertiesSet() throws Exception {
        objectB.getObjectA().doSomething();
    }
}

My context.xml file defines these three beans and injects the appropriate properties, but I get a NullPointerException when the object of class C gets instantiated and the afterPropertiesSet method is called, debugging shows me that the call to getObjectA() returns null. If I inject object A directly into class C I get no errors.

Is there a mechanism I can use to ensure that all beans have been completely instantiated before my afterPropertiesSet method / any method annotated with @PostConstruct is called?

Thanks,

Joseph.

The afterPropertiesSet() is little too early to call methods on injected dependencies. Indeed, the init-method (if you have that in XML) is called after afterPropertiesSet() and then postProcessAfterInitialization() of BeanPostProcessors are called. You have @Required annotation and so, ofcourse, RequiredAnnotationBeanPostProcessor is executed.

Lifecycle callback methods are what they are: they inform you about lifecycle events and their purpose is not to enable you to hijack the task that Spring is performing. (Though you can do it as you did when directly injecting object A in C- but it is not recommended).

If you want to use object A (or any other spring bean for that matter) in class C, then I would recommend to use ApplicationContextAware (or BeanFactoryAware as the case may be) and use getBean() method to get fully baked and ready to serve bean!

Implement ApplicationListener[ContextRefreshedEvent] and do your work in onApplicationEvent(). Word of caution - ContextRefreshedEvent is sometimes published multiple times, so you may want to set a flag after the first time you get it to ignore the additional events.

Use @DependsOn to ensure that A is instantiated before C.