不同Bean创建方式有三种:
1、大多数情况下,BeanFactory使用new关键字调用构造器
2、BeanFactory调用某个类的静态工厂方法创建Bean
3、BeanFactory调用实例工厂方法创建Bean
第一种常用不做分析,分析后二者。
BeanFactory调用某个类的静态工厂方法创建Bean
[color=red]接口Being.java[/color]
[color=red]实现类Dog.java[/color]
[color=red]实现类Cat.java[/color]
[color=red]工厂类BeingFactory.java,存在一个静态方法getBeing(String arg)[/color]
配置文件
如此可以看出:
1、class属性值并非是Bean的实现类,而是静态工厂类
2、必须使用factory-method指定产生实例的静态工厂方法
3、如果静态方法需要参数,数使用constructor-arg元素指定
接下来分析,BeanFactory调用实例工厂方法创建Bean
便于对比,只在BeingFactory.java添加方法:
配置文件添加
可以看出大同小异,只是factory-bean不同而已。
二者测试类的部分代码
1、大多数情况下,BeanFactory使用new关键字调用构造器
2、BeanFactory调用某个类的静态工厂方法创建Bean
3、BeanFactory调用实例工厂方法创建Bean
第一种常用不做分析,分析后二者。
BeanFactory调用某个类的静态工厂方法创建Bean
[color=red]接口Being.java[/color]
package com.modellite.spring;
public interface Being {
public void testBeing();
}
[color=red]实现类Dog.java[/color]
package com.modellite.spring;
public class Dog implements Being {
private String msg;
public Dog() {
}
public void testBeing() {
System.out.println(msg + " 狗爱啃骨头");
}
public void setMsg(String msg) {
this.msg = msg;
}
}
[color=red]实现类Cat.java[/color]
package com.modellite.spring;
public class Cat implements Being {
private String msg;
public Cat() {
}
public void setMsg(String msg) {
this.msg = msg;
}
public void testBeing() {
System.out.println(msg + " 猫爱抓老鼠");
}
}
[color=red]工厂类BeingFactory.java,存在一个静态方法getBeing(String arg)[/color]
package com.modellite.spring;
public class BeingFactory {
public static Being getBeing(String arg) {
if (arg.equalsIgnoreCase("dog")) {
return new Dog();
} else {
return new Cat();
}
}
}
配置文件
<?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.xsd">
<!-- 静态工厂方法创建bean -->
<!-- 此处的class并非是dog的实现类,而是产生dog的静态工厂类,采用静态工厂方法创建bean实例,必须使用factory-method指定静态工厂方法 -->
<bean id="dog" class="com.modellite.spring.BeingFactory"
factory-method="getBeing">
<!-- 调用静态工厂方法时,传入的参数使用constructor-arg元素指定 -->
<constructor-arg value="dog" />
<!-- property用于确定普通接受依赖注入的属性 -->
<property name="msg" value="我是狗" />
</bean>
<!-- 此处的class并非是cat的实现类,而是产生cat的静态工厂类,采用静态工厂方法创建bean实例,必须使用factory-method指定静态工厂方法 -->
<bean id="cat" class="com.modellite.spring.BeingFactory"
factory-method="getBeing">
<!-- 调用静态工厂方法时,传入的参数使用constructor-arg元素指定 -->
<constructor-arg>
<value>cat</value>
</constructor-arg>
<!-- property用于确定普通接受依赖注入的属性 -->
<property name="msg">
<value>我是猫</value>
</property>
</bean>
如此可以看出:
1、class属性值并非是Bean的实现类,而是静态工厂类
2、必须使用factory-method指定产生实例的静态工厂方法
3、如果静态方法需要参数,数使用constructor-arg元素指定
接下来分析,BeanFactory调用实例工厂方法创建Bean
便于对比,只在BeingFactory.java添加方法:
public Being getBing(String arg){
if (arg.equalsIgnoreCase("dog")) {
return new Dog();
} else {
return new Cat();
}
}
配置文件添加
<!-- 调用实例工厂方法创建Bean -->
<!-- 配置工厂bean,该bean负责产生其他bean实例 -->
<bean id="beingFactory" class="com.modellite.spring.BeingFactory"/>
<bean id="dogB" factory-bean="beingFactory" factory-method="getBing">
<!-- 调用工厂方法时,传入的参数也使用constructor-arg元素指定 -->
<constructor-arg value="dog" />
<!-- property用于确定普通接受依赖注入的属性 -->
<property name="msg" value="我是狗" />
</bean>
<bean id="catB" factory-bean="beingFactory" factory-method="getBing">
<!-- 调用工厂方法时,传入的参数也使用constructor-arg元素指定 -->
<constructor-arg value="cat" />
<!-- property用于确定普通接受依赖注入的属性 -->
<property name="msg" value="我是猫" />
</bean>
可以看出大同小异,只是factory-bean不同而已。
二者测试类的部分代码
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
//测试静态
Being b1 = (Being) ctx.getBean("dog");
b1.testBeing();
Being b2 = (Being) ctx.getBean("cat");
b2.testBeing();
//测试实例工厂
Being b3 = (Being) ctx.getBean("dogB");
b3.testBeing();
Being b4 = (Being) ctx.getBean("catB");
b4.testBeing();