雪地白狐 ------> 隐居江南

Spring 作为一种IOC容器最大的目的就是降低组件与组件之间的依赖关系。而BeanFactory作为整个Spring IOC容器的核心使用了一种统一的方法来装配所有的应用对象，通过Java的反射机制和依赖注入(Dependency Injection)来实现这一装配过程，使受之管理的对象无需知道Spring的存在(受管对象甚至不用import 任何Spring的class)，同时也降低了组件间的依赖程度，同时受管对象的生命周期由BeanFactory来统一管理，开发者就不用实现大量的自制的工厂Singleton。

注：以下那些受Spring IOC容器即BeanFactory控制管理的对象简称bean对象

一. BeanFactory

作为整个Spring IOC容器核心Interface BeanFacotry被放在包 org.springframework.beans.factory中，这是一个非常简单的接口，如果Spring现有的BeanFactory的实现无法满足你的要求（这种情况应该不多J），你可以很容易创建自己的一个实现。

  
public interface BeanFactory {

    Object getBean(String name) throws BeansException;
    Object getBean(String name, Class requiredType) throws BeansException;

    boolean containsBean(String name);

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name) throws NoSuchBeanDefinitionException;

}

这就是BeanFactory的代码，总共有5个函数所组成，2个getBean函数提供根据String类型的名称来寻找受BeanFactory的bean对象，区别在于其中一个函数提供了类型检测的功能，来检测取得bean对象是否为所需的类型，如果类型不符将抛出一个BeanNotOfRequiredTypeException的异常。

函数isSingleton 则用来判断BeanFactory的bean对象被定义为Singleton还是Prototype。如果被定义为Singleton的话，在BeanFactory的生命周期内，所有对getBean的调用将返回一个bean对象的实例引用，如果是Prototype则每次调用getBean对会创建一个独立的对象实例。

如果一个bean对象被定义了别名，那么函数getAliases就可以用来取得该bean对象的所有别名。

二. 使用BeanFactory


前面介绍了Spring IOC容器的核心Interface BeanFactory，现在我们通过一个的例子来简单的了解如何使用BeanFactory。这个例子中，使用了BeanFactory最常用的几个实现之一XMLBeanFactory，这个BeanFactory实现是通过XML来组装bean对象的(当然BeanFactory 还有一个实现是通过Java配置文件.propeties来组装bean对象)。


例子有1个Interface 和3个Class所组成，先来看Interface：

   
package net.hashmap.spring.ioc.example.dao;

public interface AbstractDAO {
    public void insert();
    public void update();
    public void delete();
    public void get();
}

AbstractDAO这个接口定义了4个访问数据库的方法，然后来看看AbstractDAO的2个实现HibernateDAO和JDBCDAO。

  

package net.hashmap.spring.ioc.example.dao.support;

import net.hashmap.spring.ioc.example.dao.AbstractDAO;

public class HibernateDAO implements AbstractDAO {
    public void insert() {
        System.out.println("This is HibernateDAO.insert");
    }

    public void update() {
        System.out.println("This is HibernateDAO.update");
    }

    public void delete() {
        System.out.println("This is HibernateDAO.delete");
    }

    public void get() {
        System.out.println("This is HibernateDAO.get");
    }
}

   
package net.hashmap.spring.ioc.example.dao.support;

import net.hashmap.spring.ioc.example.dao.AbstractDAO;

public class JdbcDAO implements AbstractDAO {
    public void insert() {
        System.out.println("This is JdbcDAO.insert");
    }

    public void update() {
        System.out.println("This is JdbcDAO.update");
    }

    public void delete() {
        System.out.println("This is JdbcDAO.delete");
    }

    public void get() {
        System.out.println("This is JdbcDAO.get");
    }
}

这2个Class都实现了AbstractDAO，但是一个提供了通过Hibernate来访问数据库，而另外一个则使用了JDBC（具体和数据库交互的代码，不在讨论范畴内）。


现在再来看看具体的模拟业务逻辑的Class

  

package net.hashmap.spring.ioc.example.logic;

import net.hashmap.spring.ioc.example.dao.AbstractDAO;

public class LogicBusinessImpl {
    private AbstractDAO _dao; 
    public AbstractDAO getDao() {
        return _dao;
    } 
    public void setDao(AbstractDAO _dao) {
        this._dao = _dao;
    } 
    public void BusinessHandle() {
        _dao.insert();
        _dao.get();
        _dao.update();
        _dao.delete();
    }
}

LogicBusinessImpl定义了一个方法getDao，这个getter就是用来给IOC容器进行依赖注入的。


接着就是相当重要的组装bean对象的xml。

  
<?xml version="1.0" encoding="UTF-8"?>
<beans>
 <bean id="hibernatedao" class="net.hashmap.spring.ioc.example.dao.support.HibernateDAO" />
 <bean id="jdbcdao" class="net.hashmap.spring.ioc.example.dao.support.JdbcDAO" />

 <bean id="HLogicImpl" class="net.hashmap.spring.ioc.example.logic.LogicBusinessImpl">
  <property name="dao">
   <ref local="hibernatedao" />
  </property>
 </bean>

 <bean id="JLogicImpl" class="net.hashmap.spring.ioc.example.logic.LogicBusinessImpl">
  <property name="dao">
   <ref local="jdbcdao" />
  </property>
 </bean>

</beans>

Xml文件里总共组装了2个LogicBusinessImpl,一个的使用HibernateDAO来作为bean对象的DAO，另一个则使用了JdbcDAO。通过这样组装bean对象，我们就可以不用在bean对象中显示的声明所依赖的对象，从而降低了对象间的依赖程度，同时由于我们依赖的只有一个接口，所以这样的代码更容易测试。


再来看看我们如何使用Spring的BeanFactory

   
Resource res = new ClassPathResource("bean.xml");
XmlBeanFactory bf = new XmlBeanFactory(res);

LogicBusinessImpl HbuisImpl = (LogicBusinessImpl ) bf.getBean("HLogicImpl");

HbuisImpl.BusinessHandle();
System.out.println("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\");
LogicBusinessImpl JBuisImpl = (LogicBusinessImpl ) bf.getBean("JLogicImpl");
JBuisImpl.BusinessHandle();

XmlBeanFactory 通过ClassPathResource来读入组装bean对象的xml文件，Spring 不光提供了访问Classpath的ClassPathResource，还有访问文件路径的FileSystemResource，访问Url的UrlResource,以及流形式的InputStreamResource。


以上就是使用Spring的XmlBeanFactory做的一个example，例子很简单，但是后续针对Spring IOC的学习都会基于这个例子。