Assigning dependent values to spring bean resources is technically known as "
WIRING". There are 2 types in
wiring. They are
- Explicit wiring
- Auto wiring
Explicit wiring:
The setter injection,constructor injections are considered as explicit wiring. In this approach programmer has to pass/provide dependent value the spring container to inject to the reference bean.
Auto wiring:
In this approach spring container itself choose the dependent value to assian to resource. To let Spring container do this we use '
<autowire>' attribute in bean tag.
There are 4 types of auto wiring,
byName:
In this type of auto wiring the spring container assigns value to the dependent bean by name of the bean property, i.e the id of the dependent bean object and the name of the spring bean property must be same.
In this approach spring container use setter injection to assign value.
Look at the following example ...how a java.util.Date value is assigning to the bean
in this example
beans.xml (spring configuration file)
DemoBean.java (spring bean)
MainApp.java (client program)
DemoBean.java
//DemoBean.java
public class DemoBean{
private String uname;
private Date date;
/**
* @return the uname
*/
public String getUname() {
return uname;
}
/**
* @param uname the uname to set
*/
public void setUname(String uname) {
this.uname = uname;
}
/**
* @return the date
*/
public Date getDate() {
return date;
}
/**
* @param date the date to set
*/
public void setDate(Date date) {
this.date = date;
System.out.println("date: "+date);
}
}
MainApp.java
//MainApp.java
public class MainApp{
public static void main(String a[]){
FileSystemResource res=new FileSystemResource("beans.xml");
XmlBeanFactory factory=new XmlBeanFactory(res);
Demo beanobj=(Demo)factory.getBean("demobean");
}
}
beans.xml
//beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
............................>
<bean id="demobean" class="DemoBean"
autowire="byName">
<property name="uname" value="raju"/>
</bean>
<bean id="
date" class="java.util.Date"/>
</beans>
with the
autowire="byName" the spring container look for bean object which has 'date' as id (here date is property name) if found assigns to the resource other wise no value will be assigned.
byType:
In this type of auto wiring the spring container assigns value to the dependent bean
by type(data type) of the bean property, i.e the
type(data type) of the dependent bean object and the
type(data type) of the spring bean property must be
same.
In this approach spring container use setter injection to assign value.
Look at the following example ...how a java.util.Date value is assigning to the bean
in this example
beans.xml (spring configuration file)
DemoBean.java (spring bean)
MainApp.java (client program)
DemoBean.java & MainApp.java are same,but change in beans.xml
beans.xml
//beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
............................>
<bean id="demobean" class="DemoBean"
autowire="byType">
<property name="uname" value="raju"/>
</bean>
<bean id="date" class="java.util.Date"/>
</beans>
with the
autowire="byType" the spring container look for bean object 'java.util.Date' type if found assigns to the resource other wise no value will be assigned.
If more than one 'java.util.Date' type object found in spring configuration file Exception will be thrown by container.
constructor:
In this type of auto wiring the spring container assigns value to the dependent bean
through parameterized constructor of bean , i.e the the spring container calls
parameterized constructor to assign dependent values to the resource.This is similar to
byTtype mode.
Look at the following example ...how a java.util.Date value is assigning to the bean
in this example
beans.xml (spring configuration file)
DemoBean.java (spring bean)
MainApp.java (client program)
in this example MainApp.java is same and changes are needed in beans.xml,
DemoBean.xml.
beans.xml
//beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
............................>
<bean id="demobean" class="DemoBean"
autowire="constructor">
<property name="uname" value="raju"/>
</bean>
<bean id="date" class="java.util.Date"/>
</beans>
DemoBean.java
//DemoBean.java
public class DemoBean{
private String uname;
private Date date;
/**
* @return the uname
*/
public String getUname() {
return uname;
}
/**
* @param uname the uname to set
*/
public void setUname(String uname) {
this.uname = uname;
System.out.println("uname: "+uname);
}
/**
*constructor
**/
public DemoBean(Date d){
date=d;
System.out.println("date: "+date);
}
}
with the
autowire="constructor" the spring container look for bean object 'java.util.Date' type if found assigns to the resource otherwise Exception will be thrown by container.
If more than one 'java.util.Date' type object found in spring configuration file Exception will be thrown by container.
autodetect:
In this mode of auto wiring spring container first try to assigns a value to dependent bean using
constructor mode if this mode is not possible then container go to
byType mode, i.e if we place a
constructor in bean class container choose
constructor mode else you place
setter methods container use
byType mode.
Lets take the same example
beans.xml (spring configuration file)
DemoBean.java (spring bean)
MainApp.java (client program)
in this example MainApp.java is same and changes are needed in beans.xml,
DemoBean.xml.
beans.xml
//beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
............................>
<bean id="demobean" class="DemoBean"
autowire="autodetect">
<property name="uname" value="raju"/>
</bean>
<bean id="date" class="java.util.Date"/>
</beans>
DemoBean.java
//DemoBean.java
public class DemoBean{
private String uname;
private Date date;
/**
* @return the uname
1
*/
public String getUname() {
return uname;
}
/**
* @param uname the uname to set
*/
public void setUname(String uname) {
this.uname = uname;
System.out.println("uname: "+uname);
}
/**
*constructor
**/
public DemoBean(Date d){
date=d;
System.out.println("constructor autowiring: "+date);
}
}
DemoBean.java
//DemoBean.java
public class DemoBean{
private String uname;
private Date date;
2
/**
* @return the date
*/
public Date getDate() {
return date;
}
/**
* @param date the date to set
*/
public void setDate(Date date) {
System.out.println("setter method autodetect: "+date);
this.date = date;
}
/**
* @return the uname
*/
public String getUname() {
return uname;
}
/**
* @param uname the uname to set
*/
public void setUname(String uname) {
this.uname = uname;
System.out.println("uname: "+uname);
}
}
with
1 'DemoBean.java' spring container performs
constructor based auto wiring and
with
2 'DemoBean.java' spring container performs
byType(setter injection
) based auto wiring.
if neither constructor nor setter method found container don't assign a value.
Limitations of Autowiring:
- Autowiring is possible only on reference type Bean Propertied(we can inject only object,simple values can not be injected).
- There is chance of getting ambiguity.
- Kills readability of spring configuration file.
