Spring Autowiring

[Sanju Manc]

In the spring application context , I've

<context:component-scan base-package="com.howtodoinjava" />

and a bean as below

package com.howtodoinjava.beans;

import org.springframework.stereotype.Component;

@Component
public class BeanD {
	private String  a;
	private String b;

	
	public BeanD(){
		super();
	}
	public BeanD(String a, String b) {
		this.a = a;
		this.b = b;
	}
	
	public String getB() {
		return this.b;
	}

	public void setB(String b) {
		this.b = b;
	}

	public String getA() {
		return this.a;
	}

	public void setA(String a) {
		this.a = a;
	}

}

In service class

package com.howtodoinjava.beans;

public interface TestSpringService {
	
	public String testAutowire();

}

Service implementation class has

package com.howtodoinjava.beans;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TestSpringServiceImpl implements TestSpringService {

	@Autowired
	BeanD beanD;

	public String testAutowire() {
		return beanD.getA() + beanD.getB();
	}

}

And the test class is as follows

package com.howtodoinjava.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

import com.howtodoinjava.beans.BeanD;
import com.howtodoinjava.beans.TestSpringService;


@Component
public class TestSpringAutowire {
	
	@Autowired
    TestSpringService testService;
	
	@Autowired
	BeanD beanD;
	private static ClassPathXmlApplicationContext applicationContext;
	
	protected static void loadContext(String appContext) {
		applicationContext = new ClassPathXmlApplicationContext(appContext);
	}
	
		
	public String testAutowireFunc(){
		/*beanD.setA("Hi");
		beanD.setB("BYE");*/
		beanD = new BeanD("Hi","Bye");
		return testService.testAutowire();
	}
	public static void main(String args[]){
		loadContext("application-context.xml");
		TestSpringAutowire test1 = applicationContext.getBean(TestSpringAutowire.class); 
		System.out.println(test1.testAutowireFunc());
	}
}

The output is "nullnull". Is it possible to reinitialize the bean with some properties in TEST class? Is there a way to instruct the spring not to use default contructor?

[Tim Holloway]

I've reformatted your example using our editor's Code Tags (use the Code button on the message editor). See how much prettier it is?

Autowiring has certain constraints. When you need to override those constraints, use XML settings in the spring application XML file. The XML overrides any annotated items it defines.

To construct a bean using something other than the basic no-arguments constructor, you can likewise define the bean in the spring application XML file. Some good examples of this sort of work are illiustrated in the Manning "Spring in Action" book by Walls and Briedenbach,

[Jesper de Jong]

It looks like you expected the BeanD object that you created in line 29 would be injected in the TestSpringServiceImpl bean. But that's not how autowiring works.

First of all, Spring doesn't know anything about the BeanD object that you created in line 29 with "new", so it can't inject this object anywhere. It's going to create a new instance of BeanD itself, using the no-args constructor, and that's what's going to be injected. The point with Spring beans is, that you should let Spring create the beans, and not create them yourself at arbitrary points in your code - Spring is not automatically going to know about any object that you create wherever in your code.

To make it work, you can do this:

1. Remove the @Component annotation from class BeanD, so that Spring isn't automatically going to create a singleton instance of BeanD.

package com.howtodoinjava.beans;

// Note: No @Component annotation
public class BeanD {
    private String  a;
    private String b;

    // ...

2. Add @Configuration to class TestSpringAutowire, and add a @Bean method to it, which is the factory method to create the BeanD instance that Spring is going to use:

package com.howtodoinjava.test;

import com.howtodoinjava.beans.BeanD;
import com.howtodoinjava.beans.TestSpringService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

@Component
@Configuration
public class TestSpringAutowire {

    // ...

    // Factory method for BeanD
    @Bean
    public BeanD beanD() {
        return new BeanD("Hi","Bye");
    }

    public String testAutowireFunc(){
        return testService.testAutowire();
    }

    public static void main(String args[]){
        loadContext("application-context.xml");
        TestSpringAutowire test1 = applicationContext.getBean(TestSpringAutowire.class);
        System.out.println(test1.testAutowireFunc());
    }
}

The @Configuration annotation tells Spring that it should look for factory methods in that class to create beans. You should annotate those factory methods with @Bean.

[Tim Holloway]

It bears repeating:

Jesper de Jong wrote:
First of all, Spring doesn't know anything about the BeanD object that you created in line 29 with "new", so it can't inject this object anywhere. It's going to create a new instance of BeanD itself, using the no-args constructor, and that's what's going to be injected. The point with Spring beans is, that you should let Spring create the beans, and not create them yourself at arbitrary points in your code - Spring is not automatically going to know about any object that you create wherever in your code.

[Sanju Manc]

Sorry for not formatting the code.
Thank you so much for replies Tim and Jesper. I've modified the code to use @Configuration and @Bean annotations and it works. As Tim mentioned, I could declare the bean(BeanD) with property values for constructor, so it can be used in TestSpringAutowire class which I've not tested though.
There are two ways to populate the bean instance variables:
1. create a bean using default constructor and populate the instance variables in calling class
2. use the overridden constructor with arguments to populate the instance variables, so the calling class can invoke the bean with the overridden constructor
The later can be achieved with Spring using either @component and @bean or with XML declaration, in this case how does spring initialize bean with dynamic constructor arguments?

Thanks