How to provide constructor initialization to a bean using name attribute in configuration file of Spring Framework ?.

A simple example to demonstrate, how to provide constructor initialization to a bean using constructor-arg tag's name attribute in configuration file of Spring Framework introduced in Spring 3.0

1. Create a normal POJO class having constructor say 'Person' -

package com.hubberspot.spring;

public class Person {

 private String name;
 private int age;

 public Person(String name , int age) {
  this.name = name;
  this.age = age;
 }


 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 } 
}

2. Create a spring.xml file placed in classpath of your application -

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <bean id="person" class="com.hubberspot.spring.Person"> <constructor-arg name="name" value="Jonty"></constructor-arg> <constructor-arg name="age" value="28"></constructor-arg> </bean> </beans>

3. Create a Test class for the application (imp) -

package com.hubberspot.spring;

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


public class PersonTest {

 public static void main(String[] args) {

  // ApplicationContext is a Spring interface which 
  // provides with the configuration for an application. 
  // It provides us with all the methods that BeanFactory 
  // provides. It loads the file resources in a older 
  // and generic manner. It helps us to publish events to the
  // listener registered to it. It also provides quick support
  // for internationalization. It provides us with the object 
  // requested, it reads the configuration file and provides
  // us with the necessary object required.
  // We are using concrete implementation of ApplicationContext
  // here called as ClassPathXmlApplicationContext because this 
  // bean factory reads the xml file placed in the classpath of 
  // our application. We provide ClassPathXmlApplicationContext
  // with a configuration file called as spring.xml placed
  // at classpath of our application. 
  ApplicationContext context = 
    new ClassPathXmlApplicationContext(("spring.xml"));

  // In order to get a object instantiated for a particular bean 
  // we call getBean() method of ClassPathXmlApplicationContext
  // passing it the id for which the object is to be needed. 
  // Here getBean() returns an Object. We need to cast it back 
  // to the Person object. Without implementing new keyword we 
  // have injected object of Person just by reading an xml 
  // configuration file.
  Person person = (Person)context.getBean("person");

  System.out.println("The name of person is : " + person.getName());
  System.out.println("The age of person is : " +person.getAge());

 }

}

Output of the program :