Core模块主要的功能是实现了反向控制IOC（Inversion of Control）与依赖注入DI（Dependency Injection）、Bean配置以及加载。Core模块中有Beans、BeanFactory、BeanDefinitions、ApplicationContext等几个重要概念。
Beans为Spring里的各种对象，一般要配置在Spring配置文件中：BeanFactory为创建Beans的Factory，Spring通过BeanFactory加载各种Beans；BeanDefinition为Bean在配置文件中的定义，一般要定义id与class：ApplicationContext代表配置文件。
这些类都位于org.springframework.beans和org.springframework.context中。这是Spring最核心的包。Core模块依赖于Spring的Core类库。
BeanFactory工厂
BeanFactory是实例化、配置、管理众多Bean的容器。这些Bean类一般是离散的，但在Spring中被配置为相互依赖。BeanFactory根据配置实例化Bean对象，并设置相互的依赖性。
BeanFactory可用接口org.springframework.beans.factory.BeanFactory表示。BeanFactory有多种实现，最常用的为org.springframework.beans.factory.xml.XmlBeanFactory。XmlBeanFactory能加载XML格式的配置文件。
实例化BeanFactory
在Web程序中用户不需要实例化BeanFactory，Web程序加载的时候会自动实例化BeanFactory，并加载所有的Beans，将各种Bean设置到各个Servlet中、Struts的Action中、或者Hibernate资源中。开发者直接编写Servlet、Action、Hibernate相关的代码即可，无须操作 BeanFactory。
在Java桌面程序中，需要从BeanFactory中获取Bean，因此需要实例化BeanFactory，构造函数的参数为配置文件的路径。例如加载ClassPath下的配置文件可以用ClassPathResource加载，然后传递给XmlBeanFactory构造函数。代码如下：
ClassPathResource res = new ClassPathResource("applicationContext.xml"); // 获取配置资源
XmlBeanFactory factory = new XmlBeanFactory(res); // 获取对象工厂
IService hello = (IService)factory.getBean("service"); // 获取对象
...// 其他代码略
factory.destorySingletons(); // 销毁对象
参数applicationContext.xml为ClassPath根目录下的文件。applicationContext.xml为Spring默认的配置文件名称，默认存储在ClassPath根目录下。或者使用文件流加载任意位置的配置文件，并传递给XmlBeanFactory构造函数，例如：
InputStream is = new FileInputStream("C:\ApplicationContext.xml"); // 获取配置资源
XmlBeanFactory factory = new XmlBeanFactory(is); // 获取对象工厂
IService hello = (IService)factory.getBean("service"); // 获取对象
或者用ClassPathXmlApplicationContext加载多个配置文件（多个配置文件以字符串数组形式传入），并传递给XmlBeanFactory构造函数：
ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml", "applicationContext-part2.xml"}); // 多个配置
BeanFactory factory = (BeanFactory)appContext; // ApplicationContext继承自BeanFactory接口
XmlBeanFactory配置格式
一个BeanFactory中配置了多个Bean。在XmlBeanFactory中，配置文件的根节点为<beans>，里面定义了几个<bean>子节点，每个<bean>定义一个Bean。格式如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans> <!-- Beans根节点 -->
<bean id="..." class="..."> <!--Bean节点，定义Bean-->
...
</bean>
<bean id="..." class="..."> <!--Bean节点，定义Bean-->
<property name="..." value="..."></property> <!-- Property定义属性 -->
<property name="..." ref="..."></property> <!-- Property定义属性 -->
</bean>
</beans>
配置Java Bean
一个BeanDefinition定义一个Bean，在XML中对应一个<bean>标记。Spring通过<bean>配置来实例化Bean，设置Bean的属性，以及设置Bean之间相互的依赖性。
基本配置<bean>
一个<bean>通常需要定义id与class属性。class属性是必须的，如果有其它Bean引用了该Bean，则id属性是必须的。Bean之间通过id属性相互访问，如：
<bean id="exampleBean" class="example.ExampleBean"></bean>
上面代码等价于
ExampleBean exampleBean = new ExampleBean();
其中，对象名exampleBean相当于配置中的id属性。
工厂模式factory-method
如果一个Bean不能通过new直接实例化，而是通过工厂类的某个方法建的，可以把class设为工厂类，用factory-method指向创建对象的法：
<!-- createInstance()是静态方法 -->
<bean id="exampleBean"
class="example.MyFactoryBean"
factory-method="createInstance" />
<!-- createInstance()是非静态方法 -->
<bean id="exampleBean2"
factory-bean="myFactoryBean"
factory-method="createInstance" />
构造函数<constructor-arg>
如果Bean的构造函数带参数，那就需指定参数，用<constructor-arg>指定
<bean id="exampleBean" class="examples.ExampleBean"><!-- 定义Bean -->
<constructor-arg><ref bean="anotherExampleBean" /></constructor-arg><!-- 构造函数参数 -->
<constructor-arg><ref bean="yetAnotherBean" /></constructor-arg><!-- 构造函数参数 -->
<constructor-arg><value>1</value></constructor-arg><!-- 构造函数参数 -->
</bean>
每个<constructor-arg>的参数的顺序要与构造函数相同。
public class ExampleBean {
private AnotherBean beanOne;
private YetAnotherBean beanTwo;
private int i;
public ExampleBean(AnotherBean beanOne, YetAnotherBean beanTwo, int i){
this.beanOne = beanOne;
this.beanTwo = beanTwo;
this.i = i;
}
}
单态模式singleton
Bean可以定义为单态模式（Singleton）。即在程序中只有一个实例，像数据源等一般设为单例。Spring默认是单态模式，如果想使用非单例模式（称为Prototype模式），需把singleton属性置为false：
<bean id="exampleBean" class="examples.ExampleBean" singleton="false" />
非单例下，每次请求该Bean，都会生成一个新的对象。
配置属性<property>
Spring通过Bean的setter方法设置属性。因此，需要由Spring注射的属性一般都具有公共的setter，getter方法。例如下面的配置代码：
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" />
<property name="username" value="root" />
<property name="password" value="admin" />
</bean>
destroy-method属性配置关闭方法。在销毁对象时会调用该方法。
注意：
<!-- 将password设为空字符串 --> <property name="password"><value></value></property> <!-- 将password设为null，也可以不设置 --> <property name="password"><null /></property>
设置对象属性<ref>
使用ref标签配置Bean的id属性使用。如：
<bean id="dao" class="com.helloweenvsfei.forum.dao.impl.DaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean class="com.helloweenvsfei.forum.service.impl.ThreadServiceImpl">
<property name="dao" ref="dao"></property>
</bean>
ref的内容为引用的Bean的id属性。
也可使用内部配置（或者内联配置），类似于JAVA中的匿名类对象。因为内部配置一般不会被其他的Bean引用，因此不需要配置内部Bean的id。例如：
<property name="dao">
<bean class="example.DaoImpl"></bean>
</property>
除了使用<ref>的bean属性，还可以使用local、parent，它们与bean属性的作用是一样的。不同的是，local只能使用本配置文件中的bean，而parent只能使用父配置文件中的bean，但bean则没有任何限制。
配置List属性<list>
<list>配置java.util.List类型的属性。list属性中可配置任意类型对象，如果为java对象，使用ref指定，或者<bean>定义新实例，如果是普通类型如String，int，double等，直接用字符串即可。<list>中的元素会按配置的先后顺序排序，例如：
<property name="someList">
<list>
<value>String,Integer,Double,Boolean等类型对象</value>
<ref bean="myDataSource" />
</list>
</property>
配置Set属性<set>
<set>配置java.util.Set类型的属性。Set属性中可配置任意类型对象。如果为java对象，则使用<ref>指定，或者使用<bean>重新定义新实例。如果是普通类型如String，int，double等，直接用字符串即可。例如：
<property name="someSet">
<set>
<value>String,Integer,Double,Boolean等类型对象</value>
<ref bean="myDataSource" />
<set>
</property>
配置Map属性<map>
<map>配置java.util.Map类型的属性。<entry>配置Map里的元素，key指定索引，value指定值。如果为java对象，则使用ref指定，或者使用<bean>重新定义新实例，如果key为对象，，使用key-ref属性，例如：
<property name="someMap">
<map>
<entry key="yup an entry">
<value>just some string</value>
</entry>
<entry key-ref="myDataSource">
<ref bean="serviceImpl" />
</entry>
</map>
</property>
配置Properties属性<props>
使用<props>与<prop>配置Properties属性。<props/>配置一个Properties对象，<prop/>配置一条属性，属性key配置索引，例如：
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.hbm2ddl.auto">create</prop>
</props>
<idref>与<ref>的区别
<idref>与<ref>的作用是一样的，都是配置java对象的。<idref>的用法也与<ref>基本相同。不同的是，<idref>只有bean与local属性，没有parent属性，如
<idref local="dataSource" />
Spring加载XML配置文件时，会检查<idref>配置的Bean存在不存在。而<ref>只会在第一次调用时才会检查。换句话说，如果Bean不存在，<idref>能在启动程序的时候就抛出错误，而<ref>只会在运行中抛出错误。
设置destory-method销毁方法
有的对象（例如数据源，JDBC连接，输入输出流等）在使用完毕后需要执行close()方法释放资源。可以使用destory-method配置。Spring在注销这些资源时会调用destory-method里配置的方法。例如：
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
.....
</bean>
设置depends-on依赖对象
Spring默认按照配置文件里Bean配置的先后顺序实例化Bean，但有时候在实例化A对象之前需要先实例化后面的B对象。这时候可以使用depends-on，强制先实例化B对象。如：
<bean id="a" class="examples.A" depends-on="b"></bean> <bean id="b" class="examples.B"></bean>
在实例化A的时候会检查B的实例是否存在，如果不存在，先实例化B
初始化方法init-method
与destory-method相反，有的对象在实例化后需要执行某些初始化代码，但这些初始化代码不能写在构造函数中。这时候可以把这部分初始化代码写在一个方法中，如init()，使用init-method属性，强制Spring执行该方法进行初始化，如：
<bean id="c" class="example.C" init-method="init"></bean>
属性自动装配autowire
为了防止配置文件过大，可以使用autowire属性
配置autowire自动装配
使用<bean>的autowire属性后，不需要再用<property name="" value="" />显示地设置该Bean的属性、依赖关系。Spring会根据反射，自动寻找符合条件的属性，设置到该Bean属性上。如果autowire设置为byType，将会按照属性的类型自动匹配。如：
<bean id="d" class="examples.D" autowire="byType"></bean>
autowire取值范围
autowire属性定义的不是需要自动装配的属性名，而是自动装配的规则。一但配置，所有的属性都将遵循autowire定义的规则。autowire所有的取值以及意义见下表
如果显示定义了<property>或者<constructor-arg>，会覆盖默认装配。自动装配一般与下面的依赖检查连用。
注意：在大型项目中不推荐使用，因为自动装配会隐藏依赖装配的细节。降低可读性与可维护性，并可能带来意想不到的麻烦。
依赖检查dependency
有时候某些Bean的属性配置有错误，比如某个属性没有设置。这种错误在程序启动的时候不会有任何异常表现，会一直潜伏到Spring调用该Bean时才会被发现。为了防止这种情况，Spring提供依赖检查，在程序启动的时候检查依赖配置。如果有错误，启动时就会抛出异常，以便发现配置错误。
配置dependency依赖检查
依赖检查能够检查属性是否被设置。如果配置了依赖检查，程序启动时会进行配置校验，以便及时地发现配置错误。通过设置<bean>的dependency-check设置依赖检查规则，如：
<bean id="bean" class="examples.Bean" dependency-check="all"></bean>
dependency属性取值范围
dependency属性有多种取值，分别应对不同的情况。但是需要注意，dependency依赖检查是很生硬的，例如设置为object，将会检查所有的java对象属性，只要有一个属性没有设置，就会抛出异常，即某属性明明不需要设置，但是没法避免dependency检查，容易造成“一竿子全打死”的现象。dependency的取值以及意义见表
Bean的高级特性
Spring程序中，JAVA Bean一般与Spring是非耦合的，不会依赖于Spring类库。这也是Spring的优点。但有时候Java Bean需要知道自己在Spring框架中的一些属性。Spring提供了一些接口，实例化Java Bean对象后Spring会调用接口的方法。
BeanNameAware接口获取Bean的id
BeanNameAware接口帮助Java Bean知道自己在配置文件中的id，实现BeanNameAware，实现方法名为setBeanName()方法，初始化该对象后Spring就会执行该回调方法，将id设置进来。Bean中设置一个变量，接受id名称即可，例如：
package com.helloweenvsfei.spring.example;
import org.springframework.beans.factory.BeanNameAware;
public class WhatsTheNameBean implements BeanNameAware {
private String beanName;
public void setBeanName(String beanName) {
this.beanName = beanName;
}
}
提示：setBeanName()方法的回调发生在所有参数被设置完之后，初始化方法（init-method属性）被执行之前。
BeanFactoryAware接口获取BeanFactory
BeanFactoryAware接口帮助java Bean知道哪个BeanFactory实例化了自己，BeanFactoryAware接口中有setBeanFactory的回调方法，初始化该对象后，会回调该方法，将BeanFactory传递进来。BeanFactoryAware接口的代码如下：
public interface BeanFactoryAware{
void setBeanFactory(BeanFactory beanFactory) throws BeanException
}
用法同BeanNameAware，实现了BeanFactoryAware接口的Java Bean能够获取到BeanFactory，从BeanFactory中能够获取到BeanFactory中配置的其他Java Bean。Spring不推荐这样做，因为这样会与Spring耦合。获取其它Java Bean一般通过设置getter、setter方法，用依赖注入实现
InitializingBean接口执行初始化方法
实现了InitializingBean接口的Java Bean会在实例后、所有属性被设置后调用初始化方法。但使用该接口会与Spring代码发生耦合，因此不推荐使用。InitializingBean接口代码如下：
public interface InitializingBean{
public void afterPropertiesSet();
}
Spring推荐使用init-method配置，效果等价：
<bean id="d" class="examples.D" init-method="afterPropertiesSet"></bean>
DisposableBean接口执行销毁方法
实现了DisposableBean接口的Java Bean会在对象丢弃的时候调用销毁方法。但使用该接口会与Spring代码发生耦合，因此不推荐使用。DisposableBean接口代码如下：
public interface DisposableBean{
void destory() throws Exception;
}
Spring推荐使用destory-method配置，效果等价：
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destory-method="close"></bean>
BeanFactory高级特性
如果Java Bean实现了BeanFactoryAware接口，就能够获得BeanFactory对象。BeanFactory有下面几个常用的方法：
属性覆盖器
对于一些参数，更实用更简单的方法是使用properties配置，而不是配置在Spring的配置文件中。Spring提供属性替代配置，允许把某些属性配置在properties文件中。
配置PropertyOverrideConfigurer属性覆盖器
PropertyOverrideConfigurer允许把XML配置里的某些参数配置到properties文件中。这在数据库配置中很常见。配置时需要配置一个PropertyOverrideConfigurer对象，指定properties文件的位置，然后把替换的属性用形如${jdbc.url}的字符串替代，如：
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties" />
</bean>
PropertyOverrideConfigurer对象会到指定名称的properties文件（例如jdbc.properties）中，寻找属性名为变量的配置，变量的配置，{}中最好不要有空格
properties配置
具体的数据库配置是写在jdbc.properties里面的。properties中的配置比applicationContext.xml中更便于阅读、修改与维护。代码如下：
jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/forum?characterEncoding=UTF-8 jdbc.username=root jdbc.password="admin