Spring的IOC逐層深刻——源碼解析之IoC的根本BeanFactory(五)

時間 2019-11-21

標籤 spring ioc 深刻源碼解析根本 beanfactory 欄目 Spring 简体版

原文原文鏈接

什麼是IoC

IoC容器，最主要的就是完成對象的建立以及維護對象的依賴關係等。html

所謂控制反轉，包括兩部分：一是控制，二是反轉，就是把傳統方式須要由代碼來實現對象的建立、維護對象的依賴關係，反轉給容器來幫忙管理和實現。因此咱們必需要建立一個容器，同時須要一種描述來讓容器建立對象與對象的關係。java

IoC容器是怎麼完成初始化的以及對象建立的。Spring只須要四步：web

一、定位spring

咱們知道對象和對象關係能夠用xml,properties文件等語義化配置文件表示，咱們要怎樣定位這些文件呢？Spring爲咱們設置了資源加載器和資源定位的方法，多是classpath(類路徑)，filesystem(文件系統)，或者URL網絡資源，或者web容器（servletContext）等。sql

二、載入安全

咱們定位到資源文件以後，須要將這些資源文件載入，在建立IoC容器前，若是已經有容器存在，則須要把已有的容器銷燬和關閉，以保證使用的是新創建起來的IoC容器。網絡

三、解析app

有了配置文件，還須要對配置文件進行解析。不一樣的配置文件對對象的描述不同，自定義聲明式的，都必須轉化成統一的描述定義。ide

四、註冊函數

向IoC容器註冊解析後的BeanDefinition，此時咱們IoC容器初始化完成。

到這，相信你對IoC容器必定又有了更進一步的認識。下面咱們再經過原來的一個例子，解釋一下IoC的核心。

IoC的核心-BeanFactory

項目的包圖：

Spring的配置文件：

[html] view plain copy

<?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">
<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">
<property name="userDao" ref="userDao4Oracle"></property>
</bean>
</beans>

業務邏輯層：
UserManager接口：添加用戶的方法

[java] view plain copy

public interface UserManager {
public void addUser(String userName,String password);
}

UserManager實現

[java] view plain copy

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 plain copy

public interface UserDao {
public void addUser(String userName,String password);
}

UserDao兩種實現（Mysql和Oracle）

[java] view plain copy

public class UserDao4MysqlImpl implements UserDao{
@Override
public void addUser(String userName, String password) {
//打印訪問MySQL的相關信息
System.out.println("UserDao4MysqlImpl.addUser");
}
}

[java] view plain copy

public class UserDao4OracleImpl implements UserDao{
@Override
public void addUser(String userName, String password) {
//打印訪問Oracle的相關信息
System.out.println("UserDao4OracleImpl.addUser");
}
}

客戶端：

[java] view plain copy

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 plain copy

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);