【SSH进阶之路】Spring的IOC逐层深入——源码解析之IoC的根本BeanFactory(五)

我们前面的三篇博文，简单易懂的介绍了为什么要使用IOC[实例讲解]（二）、和Spring的IOC原理[通俗解释]（三）以及依赖注入的两种常用实现类型（四），这些都是刚开始学习Spring
IoC容器时的基础内容，当然只有有了这些基础，我们才能走到今天更加详细的解析Spring的源码，深入理解IOC。

        这篇我先简单的复习一下IoC，然后根据实例介绍IoC最基本的原理。废话少说，下面我们开始这篇博文的话题：

什么是IoC

        IoC容器，最主要的就是完成对象的创建以及维护对象的依赖关系等。

       所谓控制反转，包括两部分：一是控制，二是反转，就是把传统方式需要由代码来实现对象的创建、维护对象的依赖关系，反转给容器来帮忙管理和实现。所以我们必须要创建一个容器，同时需要一种描述来让容器创建对象与对象的关系。

       IoC容器是怎么完成初始化的以及对象创建的。Spring只需要四步：

          


1、定位

      我们知道对象和对象关系可以用xml,properties文件等语义化配置文件表示，我们要怎样定位这些文件呢？Spring为我们设置了资源加载器和资源定位的方法，可能是classpath(类路径)，filesystem(文件系统)，或者URL网络资源，或者web容器（servletContext）等。

2、载入

      我们定位到资源文件之后 ，需要将这些资源文件载入，在创建IoC容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证使用的是新建立起来的IoC容器。

3、解析

      有了配置文件，还需要对配置文件进行解析。不同的配置文件对对象的描述不一样，自定义声明式的，都必须转化成统一的描述定义。

4、注册

      向IoC容器注册解析后的BeanDefinition，此时我们IoC容器初始化完成。

       到这，相信你对IoC容器一定又有了更进一步的认识。下面我们再通过原来的一个例子，解释一下IoC的核心。

     

IoC的核心-BeanFactory

项目的包图：



Spring的配置文件：

[html] view
plaincopyprint?





<?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:aop="http://www.springframework.org/schema/aop"  

         xmlns:tx="http://www.springframework.org/schema/tx"  

         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd  

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd  

           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">  

  

    <!-- 使用spring管理对象的创建，还有对象的依赖关系 -->  

    <bean id="userDao4Mysql" class="com.tgb.spring.dao.UserDao4MysqlImpl"/>  

  

    <bean id="userDao4Oracle" class="com.tgb.spring.dao.UserDao4OracleImpl"/>  

      

    <bean id="userManager" class="com.tgb.spring.manager.UserManagerImpl">  

        <!-- (1)userManager使用了userDao，Ioc是自动创建相应的UserDao实现，都是由容器管理-->  

        <!-- (2)在UserManager中提供构造函数，让spring将UserDao实现注入（DI）过来 -->  

        <!-- (3)让spring管理我们对象的创建和依赖关系，必须将依赖关系配置到spring的核心配置文件中 -->  

  

        <property name="userDao" ref="userDao4Oracle"></property>  

    </bean>  

      

</beans>  

业务逻辑层：

UserManager接口：添加用户的方法

[java] view
plaincopyprint?





public interface UserManager {  

  

    public void addUser(String userName,String password);  

}  

UserManager实现

[java] view
plaincopyprint?





import com.tgb.spring.dao.UserDao;  

  

public class UserManagerImpl implements UserManager{  

  

    private UserDao userDao;  

  

    //使用设值方式赋值  

    public void setUserDao(UserDao userDao) {  

        this.userDao = userDao;  

    }  

      

    @Override  

    public void addUser(String userName, String password) {  

  

        userDao.addUser(userName, password);  

    }  

}  

数据访问层：

UserDao接口：添加用户的方式

[java] view
plaincopyprint?





public interface UserDao {  

  

    public void addUser(String userName,String password);  

}  

UserDao两种实现（Mysql和Oracle）

[java] view
plaincopyprint?





public class UserDao4MysqlImpl implements UserDao{  

  

    @Override  

    public void addUser(String userName, String password) {  

        //打印访问MySQL的相关信息  

        System.out.println("UserDao4MysqlImpl.addUser");  

    }  

  

}  

[java] view
plaincopyprint?





public class UserDao4OracleImpl implements UserDao{  

  

    @Override  

    public void addUser(String userName, String password) {  

        //打印访问Oracle的相关信息  

        System.out.println("UserDao4OracleImpl.addUser");  

    }  

  

}  

客户端：

[java] view
plaincopyprint?





import org.springframework.beans.factory.BeanFactory;  

import org.springframework.context.support.ClassPathXmlApplicationContext;  

  

import com.tgb.spring.manager.UserManager;  

  

public class Client {  

  

    public static void main(String[] args){  

          

        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");  

        //到IOC容器中获取UserManager  

        UserManager userManager = (UserManager) factory.getBean("userManager");  

        //UserManager使用UserDao，在配置文件已经有依赖关系  

        userManager.addUser("jiuqiyuliang", "123456");        

    }  

}  

运行效果图：



         在我们客户端的代码中，初始化IoC容器时，我们使用的是Spring最最核心的接口——BeanFactory， 它可以说是 spring 的心脏。 Spring 的 ioc 就是围绕着BeanFactory 展开的。我们通过类图看一下Spring为我们提供哪些最基本的服务：



        从上图中我们可以看到BeanFactory是最顶层的接口，它定义了IOC容器的基本功能。其中BeanFactory作为最顶层的一个接口类，它定义了IOC容器的基本功能规范，BeanFactory 有三个子类：ListableBeanFactory、HierarchicalBeanFactory 和AutowireCapableBeanFactory。但是从上图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，他实现了所有的接口。那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在 Spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如 ListableBeanFactory 接口表示这些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的，也就是每个Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。这四个接口共同定义了 Bean 的集合、Bean 之间的关系、以及 Bean 行为、最基本的IOC容器接口BeanFactory

      我们通过源码看一下BeanFactory为我们提供的最基本服务：

[java] view
plaincopyprint?





public interface BeanFactory {  

  

    /** 

     * Used to dereference a {@link FactoryBean} instance and distinguish it from 

     * beans <i>created</i> by the FactoryBean. 

     * 对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，     

     * 如果需要得到工厂本身，需要转义  

     */  

    String FACTORY_BEAN_PREFIX = "&";  

  

    /** 

     * Return an instance, which may be shared or independent, of the specified bean. 

     * 根据bean的名字，获取在IOC容器中得到bean实例 

     */  

    Object getBean(String name) throws BeansException;  

  

    /** 

     * Return an instance, which may be shared or independent, of the specified bean. 

     * 根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。 

     */  

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;  

  

    /** 

     * Return the bean instance that uniquely matches the given object type, if any. 

     * 根据Class类型来得到bean实例，增加了类型安全验证机制。 

     */  

    <T> T getBean(Class<T> requiredType) throws BeansException;  

  

    /** 

     * Return an instance, which may be shared or independent, of the specified bean. 

     * 

     */  

    Object getBean(String name, Object... args) throws BeansException;  

  

    /** 

     * Return an instance, which may be shared or independent, of the specified bean. 

     

     */  

    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;  

  

    /** 

     * Does this bean factory contain a bean definition or externally registered singleton 

     * instance with the given name? 

     * 提供对bean的检索，看看是否在IOC容器有这个名字的bean   

     */  

    boolean containsBean(String name);  

  

    /** 

     * Is this bean a shared singleton? That is, will {@link #getBean} always 

     * return the same instance? 

     * 根据bean名字得到bean实例，并同时判断这个bean是不是单例  

     */  

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  

  

    /** 

     * Is this bean a prototype? That is, will {@link #getBean} always return 

     * independent instances? 

     */  

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;  

  

    /** 

     * Check whether the bean with the given name matches the specified type. 

     * More specifically, check whether a {@link #getBean} call for the given name 

     * would return an object that is assignable to the specified target type. 

     *  

     */  

    boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;  

  

    /** 

     * Determine the type of the bean with the given name. More specifically, 

     * determine the type of object that {@link #getBean} would return for the given name. 

     * 得到bean实例的Class类型 

     */  

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;  

  

    /** 

     * Return the aliases for the given bean name, if any. 

     * All of those aliases point to the same bean when used in a {@link #getBean} call. 

     * 得到bean的别名，如果根据别名检索，那么其原名也会被检索出来 

     */  

    String[] getAliases(String name);  

总结

         BeanFactory只对IoC容器的基本行为作了定义或者是规范，根本没有具体实现。

         下篇博文我会为大家详细的介绍“屌丝版”BeanFactory和高帅富版BeanFactory。敬请关注。