Spring中创建bean的三种方式

1.调用构造器"new"一个Bean实现

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <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" xmlns:aop="http://www.springframework.org/schema/aop"  
3.     xmlns:tx="http://www.springframework.org/schema/tx"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
6.            http://www.springframework.org/schema/context  
7.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
8.            http://www.springframework.org/schema/aop  
9.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
10.            http://www.springframework.org/schema/tx   
11.            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
12.     <!-- 采用Set注入的方式依赖 -->  
13.     <bean id="chinese" class="com.jask.spring.Chinese">  
14.         <property name="meiGou">  
15.             <ref local="meiGou" />  
16.         </property>  
17.     </bean>  
18.     <bean id="meiGou" class="com.jask.spring.MeiGou"></bean>  
19.   
20.   
21. </beans>  

 

[java]  view plain  copy

 print ?

1. public class Chinese implements Person  
2. {  
3.     private Person meiGou;  
4.     public Chinese()  
5.     {  
6.           
7.         System.out.println("Chinese init");  
8.     }  
9.     public void say()  
10.     {  
11.         meiGou.say();  
12.     }  
13.   
14.     public void sayBye()  
15.     {  
16.         meiGou.sayBye();  
17.     }  
18.   
19.     public void setMeiGou(MeiGou meiGou)  
20.     {  
21.         System.out.println("Chinese‘s 依赖关系");  
22.         this.meiGou = meiGou;  
23.     }  
24. }  

 

[java]  view plain  copy

 print ?

1. public class MeiGou implements Person  
2. {  
3.     private Chinese chinese;  
4.     public MeiGou()  
5.     {  
6.         System.out.println("MeiGou init");  
7.     }  
8.     public void say()  
9.     {  
10.         System.out.println("MeiGou Say");  
11.     }  
12.   
13.     public void sayBye()  
14.     {  
15.         System.out.println("MeiGou sayBye");  
16.     }  
17.   
18.     public void setChinese(Chinese chinese)  
19.     {  
20.         this.chinese = chinese;  
21.     }  
22. }  

 

[java]  view plain  copy

 print ?

1. public class TestMain  
2. {  
3.   
4.     public static void main(String[] args)  
5.     {  
6.         ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");  
7.         BeanFactory factory = (BeanFactory)ctx;  
8.         Chinese chinese =  (Chinese) factory.getBean("chinese");  
9.         chinese.say();  
10.           
11.     }  
12. }  

 

结果：

Chinese init
MeiGou init
Chinese‘s 依赖关系
MeiGou Say

 

实例执行顺序：

首先去实现一个Chinese对象的构造器

再去实现依赖的对象MeiGou构造器

然后在去注入依赖关系

最后返回依赖的实现

2.采用静态工厂方法创建Bean

只修改了Spring配置文件

[html]  view plain  copy

 print ?

1. <!-- Bean的静态工厂创建实例 -->  
2.     <bean id="chinese" class="com.jask.spring.Chinese">  
3.         <property name="meiGou">  
4.             <ref local="meiGou"/>  
5.         </property>  
6.     </bean>  
7.     <bean id="meiGou" class="com.jask.spring.StaticFactory" factory-method="getPerson">  
8.         <constructor-arg>  
9.             <value>meiGou</value>  
10.         </constructor-arg>  
11.     </bean>  

3.采用实现工厂方法创建Bean

只修改了Spring配置文件

[html]  view plain  copy

 print ?

1. <!-- Bean的实现工厂创建实例 -->  
2.     <bean id="staticFactoryBean" class="com.jask.spring.StaticFactory"></bean>  
3.     <bean id="chinese" class="com.jask.spring.Chinese">  
4.         <property name="meiGou">  
5.             <ref local="meiGou"/>  
6.         </property>  
7.     </bean>  
8.     <bean id="meiGou" factory-bean="staticFactoryBean" factory-method="getPerson">  
9.         <constructor-arg>  
10.             <value>meiGou</value>  
11.         </constructor-arg>  
12.     </bean>