1.实例化spring容器 和 从容器获取Bean对象
实例化Spring容器常用的两种方式：
方法一:
在类路径下寻找配置文件来实例化容器 [推荐使用]
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
方法二:
在文件系统路径下寻找配置文件来实例化容器 [这种方式可以在开发阶段使用]
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{“d:\\beans.xml“});
Spring的配置文件可以指定多个，可以通过String数组传入。
当spring容器启动后，因为spring容器可以管理bean对象的创建，销毁等生命周期，
所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建bean对象。
从容器获取bean对象的代码如下：
ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
OrderService service = (OrderService)ctx.getBean("personService");
2.Spring实例化Bean的三种方式
以下是三种方式的例子：
1.使用类构造器实例化 [默认的类构造器] <bean id=“orderService" class="cn.itcast.OrderServiceBean"/> 2.使用静态工厂方法实例化 <bean id="personService" class="cn.itcast.service.OrderFactory" factory-method="createOrder"/> public class OrderFactory { public static OrderServiceBean createOrder(){ // 注意这里的这个方法是 static 的！ return new OrderServiceBean(); } } 3.使用实例工厂方法实例化: <bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/> <bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/> public class OrderFactory { public OrderServiceBean createOrder(){ return new OrderServiceBean(); } }
3.Bean的生命周期 （Bean的作用域）
bean的scope 属性
The scope of this bean: typically "singleton" (one shared instance, which will be returned by all calls
to getBean with the given id), or "prototype" (independent instance resulting from each call to
getBean). Default is "singleton". Singletons are most commonly used, and are ideal for multi-
threaded service objects. Further scopes, such as "request" or "session", might be supported by
extended bean factories (e.g. in a web environment). Note: This attribute will not be inherited by
child bean definitions. Hence, it needs to be specified per concrete bean definition. Inner bean
definitions inherit the singleton status of their containing bean definition, unless explicitly specified:
The inner bean will be a singleton if the containing bean is a singleton, and a prototype if the
containing bean has any other scope.
.singleton [单例]
eg：<bean id="personService" class="com.yinger.service.impl.PersonServiceBean" scope="singleton"></bean>
在每个Spring IoC容器中一个bean定义只有一个对象实例。
请注意Spring的singleton bean概念与“四人帮”（GoF）模式一书中定义的Singleton模式是完全不同的。
经典的GoF Singleton模式中所谓的对象范围是指在每一个ClassLoader中指定class创建的实例有且仅有一个。
把Spring的singleton作用域描述成一个container对应一个bean实例最为贴切。亦即，假如在单个Spring容器内定义了某个指定class的bean，
那么Spring容器将会创建一个且仅有一个由该bean定义指定的类实例。
默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。
如：<bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>
如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：
<beans default-lazy-init="true“ ...>
.prototype [原型]
每次从容器获取bean都是新的对象。
对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是
装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法。
但对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，
都是客户端代码的职责。（让Spring容器释放被prototype作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持有要被清除的bean的引用。）
以下的三种scope只是在web应用中才可以使用
.request
.session
.global session
使用这三种配置之前要先初始化Web配置
RequestContextListener和RequestContextFilter两个类做的都是同样的工作： 将HTTP request对象绑定到为该请求提供服务的Thread。
这使得具有request和session作用域的bean能够在后面的调用链中被访问到。
指定Bean的初始化方法和销毁方法
<bean id="xxx" class="cn.itcast.OrderServiceBean" init-method="init" destroy-method="close"/>
Spring提供了几个标志接口（marker interface），这些接口用来改变容器中bean的行为；它们包括InitializingBean和DisposableBean。
现这两个接口的bean在初始化和析构时容器会调用前者的afterPropertiesSet()方法，以及后者的destroy()方法。
Spring在内部使用BeanPostProcessor实现来处理它能找到的任何标志接口并调用相应的方法。
如果你需要自定义特性或者生命周期行为，你可以实现自己的 BeanPostProcessor。
初始化回调和析构回调：
测试：
bean对象：
package com.yinger.service.impl; public class PersonServiceBean implements com.yinger.service.PersonService{ //构造器 public PersonServiceBean(){ System.out.println("instance me"); } //save方法 public void save() { System.out.println("save"); } //初始化方法,这个方法是类被实例化了之后就会执行的！ public void init(){ System.out.println("init"); } //销毁方法 public void destroy(){ System.out.println("destroy"); } }
JUnit Test：
package com.yinger.test; import org.junit.BeforeClass; import org.junit.Test; import org.springframework.context.support.AbstractApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.yinger.service.PersonService; public class SpringTest { @BeforeClass public static void setUpBeforeClass() throws Exception { } @Test //创建的单元测试 public void testSave() { AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); System.out.println("--------"); PersonService ps = (PersonService)ctx.getBean("personService"); ps.save(); ctx.close(); //有了这一句才会有destroy方法的调用 } }
beans.xml 设置：
如果lazy-init（默认是default，也就是false）没有设置，或者设置为default或者false
<bean id="personService" class="com.yinger.service.impl.PersonServiceBean" scope="singleton" init-method="init" destroy-method="destroy" lazy-init="false"></bean>
那么结果是：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext). log4j:WARN Please initialize the log4j system properly. instance me init -------- save destroy
反之，如果设置为true，结果是：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
--------
instance me
init
save
destroy
修改测试代码：
@Test
public void testSave() {
AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
// System.out.println("--------");
PersonService ps = (PersonService)ctx.getBean("personService");
PersonService ps1 = (PersonService)ctx.getBean("personService");
System.out.println(ps==ps1);
// ps.save();
ctx.close();
}
重新测试：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext). log4j:WARN Please initialize the log4j system properly. instance me init true destroy
[在scope为singleton时，每次使用getBean得到的都是同一个bean，同一个对象]
修改bean中的scope属性：scope="prototype"
测试结果：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext). log4j:WARN Please initialize the log4j system properly. instance me init instance me init false
[在scope为prototype时，每次得到的bean对象都是不同的，从上面可以看出实例化了两个对象，最终的比较是false]
4.依赖注入
来自Spring参考文档：依赖注入（DI）背后的基本原理是对象之间的依赖关系（即一起工作的其它对象）只会通过以下几种方式来实现：构造器的参数、工厂方法的参数，
或给由构造函数或者工厂方法创建的对象设置属性。因此，容器的工作就是创建bean时注入那些依赖关系。
相对于由bean自己来控制其实例化、直接在构造器中指定依赖关系或者类似服务定位器（Service Locator）模式这3种自主控制依赖关系注入的方法来说，
控制从根本上发生了倒转，这也正是控制反转（Inversion of Control， IoC） 名字的由来。
（1）基本类型的注入：
基本类型对象注入： <bean id="orderService" class="cn.itcast.service.OrderServiceBean"> <constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入 <property name=“name” value=“zhao/>//属性setter方法注入 </bean> 注入其他bean：
方式一 <bean id="orderDao" class="cn.itcast.service.OrderDaoBean"/> <bean id="orderService" class="cn.itcast.service.OrderServiceBean"> <property name="orderDao" ref="orderDao"/> </bean> 方式二(使用内部bean,但该bean不能被其他bean使用) <bean id="orderService" class="cn.itcast.service.OrderServiceBean"> <property name="orderDao"> <bean class="cn.itcast.service.OrderDaoBean"/> </property> </bean>
测试 构造器和setter 方式注入：
新建一个DAO的接口：
package com.yinger.dao; public interface PersonDao { public void save(); }
新建一个接口的实现类：
package com.yinger.dao.impl; import com.yinger.dao.PersonDao; public class PersonDaoBean implements PersonDao{ public void save() { System.out.println("PersonDaoBean.save()"); } }
修改原有的PersonServiceBean，添加两个字段：
package com.yinger.service.impl; import com.yinger.dao.PersonDao; import com.yinger.service.PersonService; public class PersonServiceBean implements PersonService{ private PersonDao pDao;//这样设计就实现了业务层和数据层的彻底解耦 private String name; //默认的构造器 public PersonServiceBean(){ System.out.println("instance me"); } //带参数的构造器 public PersonServiceBean(PersonDao pDao){ this.pDao=pDao; } //带参数的构造器 public PersonServiceBean(PersonDao pDao,String name){ this.pDao=pDao; this.name=name; } //save方法 public void save() { // System.out.println("save"); pDao.save(); System.out.println(this.getName()); } //初始化方法,这个方法是类被实例化了之后就会执行的！ public void init(){ System.out.println("init"); } //销毁方法 public void destroy(){ System.out.println("destroy"); } public String getName() { return name; } public void setName(String name) { this.name = name; } }
修改beans.xml：
<bean id="personService" class="com.yinger.service.impl.PersonServiceBean"> <constructor-arg index="0"> <bean id="pDao" class="com.yinger.dao.impl.PersonDaoBean"></bean> </constructor-arg> <constructor-arg index="1" type="java.lang.String" value="name" /> </bean>
新增一个测试方法：
@Test
public void testInjection() {
AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
System.out.println("--------");
PersonService ps = (PersonService)ctx.getBean("personService");
ps.save();
ctx.close();
}
测试结果：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext). log4j:WARN Please initialize the log4j system properly. -------- PersonDaoBean.save() name
如果在beans.xml中再添加一句：
<property name="name" value="name2"></property>
重新测试，结果是：
log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext). log4j:WARN Please initialize the log4j system properly. -------- PersonDaoBean.save() name2
（2）集合类型的注入：
集合类型的装配：
public class OrderServiceBean { private Set<String> sets = new HashSet<String>(); private List<String> lists = new ArrayList<String>(); private Properties properties = new Properties(); private Map<String, String> maps = new HashMap<String, String>(); ....//这里省略属性的getter和setter方法 }
XML配置：
<bean id="order" class="cn.itcast.service.OrderServiceBean"> <property name="lists"> <list> <value>lihuoming</value> </list> </property> <property name="sets"> <set> <value>set</value> </set> </property> <property name="maps"> <map> <entry key="lihuoming" value="28"/> </map> </property> <property name="properties"> <props> <prop key="12">sss</prop> </props> </property> </bean>
补充：Spring对泛型的支持
（3）三种依赖注入的方式 和 两种装配方式：
①使用构造器注入
②使用属性setter方法注入：
通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即可实现基于setter的DI。
Spring开发团队提倡使用setter注入。而且setter DI在以后的某个时候还可将实例重新配置（或重新注入）
③使用Field注入（用于注解方式）
处理bean依赖关系通常按以下步骤进行：
-
根据定义bean的配置（文件）创建并初始化
BeanFactory实例（大部份的Spring用户使用支持XML格式配置文件的BeanFactory或ApplicationContext实现）。 -
每个bean的依赖将以属性、构造器参数、或静态工厂方法参数的形式出现。当这些bean被实际创建时，这些依赖也将会提供给该bean。
-
每个属性或构造器参数既可以是一个实际的值，也可以是对该容器中另一个bean的引用。
-
每个指定的属性或构造器参数值必须能够被转换成特定的格式或构造参数所需的类型。默认情况下，Spring会以String类型提供值转换成各种内置类型，
比如int、long、String、boolean等。
在<constructor-arg/>或<property/>元素内部还可以使用ref元素。该元素用来将bean中指定属性的值设置为对容器中的另外一个bean的引用。
注意：内部bean中的scope标记及id或name属性将被忽略。内部bean总是匿名的且它们总是prototype模式的。同时将内部bean注入到包含该内部bean之外的bean是不可能的。
注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。
1.手工装配依赖对象
2.自动装配依赖对象
<1>手工装配
手工装配依赖对象，在这种方式中又有两种编程方式
1. 在xml配置文件中，通过在bean节点下配置，如
<bean id="orderService" class="cn.itcast.service.OrderServiceBean"><constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入
<property name=“