Spring Autowire during instantation? - spring

Question

While refactoring an application and implementing injection via Spring it would be helpful to get hold of autowired objects within the instantiation phase. I cannot get it work (and would understand if it does not work at all; instatiation would be very tricky) but nevertheless want ot ask the question here to make sure.
For testing purposes I created this bean:
import org.springframework.stereotype.Repository;
#Repository
public class MyService {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
which is meant to become injected to this component:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import de.sample.spring.service.MyService;
#Component
public class MyComponent {
#Autowired
private MyService myService;
public MyComponent() {
System.out.println("MyService during instantiation="+myService);
showInternallyMyService();
}
#Autowired
private void setMyService(MyService myService) {
System.out.println("MyService during instantion via setter="+myService);
}
private void showInternallyMyService() {
System.out.println("MyService during instantiation via constructor call="+myService);
}
public void showWhenExternalCalledMyService() {
System.out.println("MyService when show has been called after instatiation="+myService);
}
}
The associated applicationContext is:
<?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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<!-- enable autowire -->
<context:annotation-config />
<context:component-scan base-package="de.sample.spring.service" />
<context:component-scan base-package="de.sample.spring.component" />
</beans>
The stuff is then run by:
import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import de.sample.spring.component.MyComponent;
public class Start {
private static final Logger LOGGER = LoggerFactory.getLogger(Start.class);
private final static String contextPath = "/context/applicationContext.xml";
public static void main(String[] args) throws IOException {
ApplicationContext context = null;
try {
context = new ClassPathXmlApplicationContext(contextPath);
} catch (Exception e) {
LOGGER.error("",e);
}
MyComponent myComponent = (MyComponent) context.getBean("myComponent");
myComponent.showWhenExternalCalledMyService();
}
}
The resulting log shows then these messages
MyService during instantiation=null
MyService during instantiation via constructor call=null
MyService during instantiation via setter=de.sample.spring.service.MyService#2ea227af
MyService when show has been called after instantiation=de.sample.spring.service.MyService#2ea227af
As can be seen the "Autowired" object is null in the constructor phase, only in the running phase it is instantiated. As already said - I think this is the way it is meant to work, but still I hope I'm wrong and can manage to get it work to access the autowired in the constructor. I know, I could use the constructor with properties - this would solve my problem but I wonder if it could be managed with another approach.

Answer 1

Beans get autowired after the constructor has been executed...per default.
If you want to autowire it at construction time you have to #autowire it at the constructor:
#Autowired
public MyComponent(MyService myService) {
System.out.println("MyService during intantiation="+myService);
showInternallyMyService();
}

Answer 2

You can try the way #watchme mentioned but take note that using this way will make it kind of immutable object but ensure that required dependencies are not null.
Also With #Autowired on a field you don't need a setter method for it and once your bean's constructor is done with allocating/creating the object,
Spring will scan for this annotation and would inject the object instances that you annotated.

Answer 3

This works as designed. During the initialization phase, beans are initialized and the dependency injection is done.
If you want to guarantee all dependencies have been injected, you should implement your logic in an initialization callback. Use the #PostConstruct annotation:
#Component
public class MyComponent {
#Autowired
private MyService myService;
public MyComponent() {
System.out.println("MyService during intantiation="+myService);
}
#Autowired
private void setMyService(MyService myService) {
System.out.println("MyService during instantion via setter="+myService);
}
#PostConstruct
private void showInternallyMyService() {
System.out.println("MyService during initialization="+myService);
}
}