林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

         摘要：Spring的核心容器实现了Ioc,其目 的是提供一种无侵入式的框架。在本文中，首先讲解了Spring的基础bean的相关知识，然后介绍了Spring是如何对bean进行管理的。

        在Spring中，有2个最基本最重要的包，即org.springframework.beans 和org.springframework.context.在这两个包中实现了无侵入式的框架，代码中大量引用了java的反射机制，通过动态调用的方式避免了硬编码，为spring的反向控制特性提供了基础。在这2个包中，最重要的类是BeanFactory和ApplicationContext。

• BeanFactory提供了一种先进的配置机制来管理任何种类的bean。
• ApplicationContext建立在BeanFactory之上，并增加了其他功能，如国际化，获取资源，事件传递等。

 本文工程免费下载

一、Bean的基础知识

1.在xml配置文件中，bean的标识（id 和 name）

 id:指定在benafactory中管理该bean的唯一的标识。name可用来唯一标识bean 或给bean起别名。

 <bean id="helloWorld" class="com.name.HelloWorld">
........
 </bean>

class属性指定了bean的来源，即bean的实际路径。注意要指定全路径，而不可只写类名。

3.Singleton的使用

在spring中，bean可被定义为2中部署模式中的一种。singleton和prototype模式。

singloeton:只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一实例。

prototype:对这个bean的每次请求都会都会创建一个新的bean实例。根据已经存在的bean而clone出来的bean。默认为singleton模式。

 改写成prototype模式写法如下：

<bean id="student3" class="com.mucfc.beanfactory.Student" scope="prototype">
	.......
</bean>

spring中，bean的属性值有2种注入方式。setter注入和构造函数注入。

setter注入是在调用无参的构造函数或无参的静态工厂方法实例化配置文档中定义的bean之后，通过调用bean上的setter方法实现的。

构造函数的依赖注入是通过调用带有很多参数的构造方法实现的，每个参数表示一个对象或者属性。

这里不懂看此文

 5.对属性null值的处理

	<bean id="student5" class="com.mucfc.beanfactory.Student">
		<property name="std_name">
			<value></value>
		</property>
		<property name="std_id">
			<value>2005</value>
		</property>
	</bean>

	<bean id="student5" class="com.mucfc.beanfactory.Student">
		<property name="std_name">
			<value/>
		</property>
		<property name="std_id">
			<value>2005</value>
		</property>
	</bean>

以上等同于this.std_name=null

 6.使用依赖depends-on

此属性可在使用该bean之前，强制初始化一个或多个bean的初始化。例如

	<bean id="school" class="com.mucfc.beanfactory.School"
		depends-on="student6">
		<property name="student" ref="student6" />
	</bean>

<bean id="student6" class="com.mucfc.beanfactory.Student">
		<property name="std_name" value="水水" />
		<property name="std_id" value="3009" />
	</bean>

7.指定bean引用

<property name=" xxx" ref="yyyy "/>

或者

<property name="xxxx">
<ref bean="yyt"/>
<property/>

二、bean的生命周期

                                                                                                beanfactory中bean的生命周期图

2.1 实例bean

package com.mucfc.beanlive;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

//①管理Bean生命周期的接口   
public class Worker implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{
	private String name;
	private String workType;
	private int salary;
	
	public BeanFactory beanFactory;
	private String beanName;
	
	public void Worker(){
		System.out.println("调用worker()构造函数");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getWorkType() {
		return workType;
	}
	public void setWorkType(String workType) {
		this.workType = workType;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	 public void printInfo() {    
	        System.out.println("name:" + name + ";workType:" + workType + ";salary:"    
	                + salary);    
	    }    
	 //⑤DisposableBean接口方法    
	@Override
	public void destroy() throws Exception {
		System.out.println("----------------销毁bean----------------------");
		 System.out.println("调用DisposableBean.destroy()。");    
		
	}
	 //④InitializingBean接口方法    
	@Override
	public void afterPropertiesSet() throws Exception {
		 System.out.println("调用InitializingBean.afterPropertiesSet()。");   
		
	}
	 //③BeanNameAware接口方法    
	@Override
	public void setBeanName(String arg0) {
		System.out.println("----------------初始化bean----------------------");
		 System.out.println("调用BeanNameAware.setBeanName()。");    
	        this.beanName = arg0;    
		
	}
	 //②BeanFactoryAware接口方法    
	@Override
	public void setBeanFactory(BeanFactory arg0) throws BeansException {
		 System.out.println("调用BeanFactoryAware.setBeanFactory()。");    
	     this.beanFactory = arg0;    
	}
	
	//⑥通过<bean>的init-method属性指定的初始化方法    
    public void myInit() {    
        System.out.println("调用init-method所指定的myInit()，将salary设置为600。");    
        this.salary = 600;    
    }    
        
     //⑦通过<bean>的destroy-method属性指定的销毁方法    
    public void myDestroy() {    
        System.out.println("调用destroy-method所指定的myDestroy()。");    
    }    
	
}

MyInstantiationAwareBeanPostProcessor通过扩展InstantiationAwareBeanPostProcessor适配器InstantiationAwareBeanPostProcessorAdapter提供实现：

（这是实例化bean时会用到的函数）

package com.mucfc.beanlive;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

public class MyInstantiationAwareBeanPostProcessor extends
		InstantiationAwareBeanPostProcessorAdapter {
	// ①接口方法：在实例化Bean前进行调用
	public Object postProcessBeforeInstantiation(Class beanClass,
			String beanName) throws BeansException {
		System.out.println("----------------实例化bean----------------------");
		// ①-1仅对容器中worker Bean进行处理
		if ("worker".equals(beanName)) {
			System.out
					.println("InstantiationAware BeanPostProcessor. postProcess BeforeInstantiation");
		}
		return null;
	}

	// ②接口方法：在实例化Bean后调用
	public boolean postProcessAfterInstantiation(Object bean, String beanName)
			throws BeansException {
		// ②-1仅对容器中car Bean进行处理
		if ("worker".equals(beanName)) {
			System.out
					.println("InstantiationAware BeanPostProcessor.postProcess AfterInstantiation");
		}
		return true;
	}

	// ③接口方法：在设置某个属性时调用
	public PropertyValues postProcessPropertyValues(PropertyValues pvs,
			PropertyDescriptor[] pds, Object bean, String beanName)
			throws BeansException {

		// ③-1仅对容器中wroker Bean进行处理，还可以通过pdst入参进行过滤，
		// 仅对car的某个特定属性时进行处理。
		if ("worker".equals(beanName)) {
			System.out
					.println("Instantiation AwareBeanPostProcessor.postProcess PropertyValues");
		}
		return pvs;
	}
}

在MyInstantiationAwareBeanPostProcessor中，我们通过过滤条件仅对work Bean进行处理，而对其他的Bean一概视而不见。

此外，我们还提供了一个BeanPostProcessor实现类，在该实现类中，我们也只对work Bean进行处理，对配置文件所提供的属性设置值进行判断，并执行相应的"补缺补漏"的操作：

BeanPostProcessor实现类(这里是bean初始化和使用时会用到的函数 )

package com.mucfc.beanlive;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor{

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		 if(beanName.equals("worker")){    
			 Worker worker = (Worker)bean;    
	            if(worker.getWorkType() == null){    
	                System.out.println("调用BeanPostProcessor.postProcess AfterInitialization()，  getWorkType为空，设置为默认临时工");    
	                worker.setWorkType("临时工"); 
	            }    
	        }    
	        return bean;    
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		if(beanName.equals("worker")){    
			 Worker worker = (Worker)bean;     
	            if(worker.getSalary() >= 1000){    
	                System.out.println("调用BeanPostProcessor.postProcess BeforeInitialization()， 将salary调整为800。");    
	                worker.setSalary(800);   
	            }    
	        }    
	        return bean;    
	    }    

}

在MyBeanPostProcessor类的postProcessBeforeInitialization()方法中，我们首先判断处理的Bean是否名为worker，如果是，进一步判断该Bean的workerType属性是否为空，如果为空，将该属性设置为"临时工"。在postProcessAfterInitialization()方法中，我们也是只对名为woker的Bean进行处理，判断其salary是否超过最大速度1000，如果超过，将其设置为800。(黑心老板啊！！！！！)

至于如何将MyInstantiationAwareBeanPostProcessor和MyBeanPostProcessor这两个后处理器注册到BeanFactory容器中

现在，我们在Spring配置文件中定义Car的配置信息，如代码清单3 29所示：

然后就是beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id="worker" class="com.mucfc.beanlive.Worker"
      init-method="myInit"   
      destroy-method="myDestroy"   
       p:name="小强"   
       p:salary="1000"     
/>
</beans>

package com.mucfc.beanlive;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Test {
	 private static void LifeCycleInBeanFactory(){  
		 //①下面两句装载配置文件并启动容器    
	      Resource res = new ClassPathResource("beans.xml");      
	      BeanFactory bf = new XmlBeanFactory(res);    
	           
	   
	      //②向容器中注册MyBeanPostProcessor后处理器    
	((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());    
	          
	      //③向容器中注册MyInstantiationAwareBeanPostProcessor后处理器    
	((ConfigurableBeanFactory)bf).addBeanPostProcessor(    
	                               new MyInstantiationAwareBeanPostProcessor());    
	      //④第一次从容器中获取worker，将触发容器实例化该Bean，这将引发Bean生命周期方法的调用。    
	      Worker worker1 = (Worker)bf.getBean("worker");    
	      System.out.println("第一次从容器中获取worker");
	      worker1.printInfo();    
	      System.out.println("修改第一次从容器中获取worker的workType");
	      worker1.setWorkType("正式工");   
	      System.out.println("第一次从容器中获取worker（修改过后的）");
	      worker1.printInfo();    
	       //⑤第二次从容器中获取worker，直接从缓存池中获取    
	      System.out.println("第二次从容器中获取worker");
	      Worker worker2= (Worker)bf.getBean("worker");      
	      worker2.printInfo();  
	       //⑥查看worker1和worker2是否指向同一引用    
	      System.out.println("查看worker1和worker2是否指向同一引用    ");
	      System.out.println("worker1==worker2:"+(worker1==worker2));  
	       //⑦关闭容器    
	      ((XmlBeanFactory)bf).destroySingletons();    
	      
		 
	 }
	public static void main(String[] args) {
		LifeCycleInBeanFactory();
	}

}

图片看不清的话，看文字吧：

四月 07, 2015 3:43:54 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
----------------实例化bean----------------------
InstantiationAware BeanPostProcessor. postProcess BeforeInstantiation
InstantiationAware BeanPostProcessor.postProcess AfterInstantiation
Instantiation AwareBeanPostProcessor.postProcess PropertyValues
----------------初始化bean----------------------
调用BeanNameAware.setBeanName()。
调用BeanFactoryAware.setBeanFactory()。
调用BeanPostProcessor.postProcess BeforeInitialization()， 将salary调整为800。
调用InitializingBean.afterPropertiesSet()。
调用init-method所指定的myInit()，将salary设置为600。
调用BeanPostProcessor.postProcess AfterInitialization()，  getWorkType为空，设置为默认临时工
第一次从容器中获取worker
name:小强;workType:临时工;salary:600
修改第一次从容器中获取worker的workType
第一次从容器中获取worker（修改过后的）
name:小强;workType:正式工;salary:600
第二次从容器中获取worker
name:小强;workType:正式工;salary:600
查看worker1和worker2是否指向同一引用    
worker1==worker2:true
四月 07, 2015 3:43:54 下午 org.springframework.beans.factory.xml.XmlBeanFactory destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.xml.XmlBeanFactory@16905e: defining beans [worker]; root of factory hierarchy
----------------销毁bean----------------------
调用DisposableBean.destroy()。
调用destroy-method所指定的myDestroy()。

我们可以看到第二次获取worker时，直接从容器的缓存中获取，它们两个的指向的是同一个引用！切记！

四、ApplicationContext与beanfactory的区别