Spring框架使用到的设计模式解析

r囧r小猫 2023-09-24 17:49 76阅读 0赞

# 1.spring使用回顾 #

自定义spring框架前，先回顾一下spring框架的使用，从而分析spring的核心，并对核心功能进行模拟。

*  数据访问层。定义UserDao接口及其子实现类

public interface UserDao {
        
        public void add();
    }
    
    public class UserDaoImpl implements UserDao {
        
    
        public void add() {
        
            System.out.println("userDaoImpl ....");
        }
    }

● 业务逻辑层。定义UserService接口及其子实现类

public interface UserService {
        
        public void add();
    }
    
    public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        public void add() {
        
            System.out.println("userServiceImpl ...");
            userDao.add();
        }
    }

*  定义UserController类，使用main方法模拟controller层

public class UserController {
        
        public static void main(String[] args) {
        
            //创建spring容器对象
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            //从IOC容器中获取UserService对象
            UserService userService = applicationContext.getBean("userService", UserService.class);
            //调用UserService对象的add方法
            userService.add();
        }
    }

*  编写配置文件。在类路径下编写一个名为ApplicationContext.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    
        <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
            <property name="userDao" ref="userDao"></property>
        </bean>
    
        <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
    
    </beans>

# 代码运行结果： #

userServiceImpl...
    userDaoImpl...

通过上面代码及结果可以看出：

● userService对象是从`applicationContex`t容器对象获取到的，也就是**userService对象交由spring进行管理**。  
● 上面结果可以看到调用了UserDao对象中的add方法，也就是说**UserDao子实现类对象也交由spring管理了**。  
● UserService中的userDao变量我们并没有进行赋值，但是可以正常使用，说明**spring已经将UserDao对象赋值给了userDao变量**。

上面三点体现了Spring框架的`IOC（Inversion of Control）`和`DI（Dependency Injection, DI）`

# 2.spring核心功能结构 #

Spring大约有20个模块，由1300多个不同的文件构成。这些模块可以分为:

**核心容器、AOP和设备支持、数据访问与集成、Web组件、通信报文和集成测试**等，下面是 Spring 框架的总体架构图：

![在这里插入图片描述][93c34cf493ed4a7d85a690cbc9902b5b.png]  
核心容器由 `beans`、`core`、`context` 和 `expression`（`Spring Expression Language，SpEL`）4个模块组成。

● `spring-beans`和`spring-core`模块是**Spring框架的核心模块**，包含了`控制反转（Inversion of Control，IOC）`和`依赖注入（Dependency Injection，DI）`。`BeanFactory`使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。`BeanFactory属于延时加载`，也就是说在**实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。**  
● `spring-context`模块构架于核心模块之上，扩展了`BeanFactory`，为它添**加了Bean生命周期控制、框架事件体系及资源加载透明化等功能**。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，`ApplicationContext`是该**模块的核心接口**，它的`超类是 BeanFactory`。与BeanFactory不同，**ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。**  
● `spring-context-support`模块是对`Spring IoC容器`及`IoC子容器`的扩展支持。  
● `spring-context-indexe`模块是`Spring的类管理组件`和`Classpath扫描组件`。  
● `spring-expression`模块是`统一表达式语言（EL）`的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，**最出色的要数函数调用和简单字符串的模板函数**。EL的特性是基于**Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互**。

## 1） bean ##

Spring 就是`面向 Bean 的编程（BOP,Bean Oriented Programming）`，Bean 在 Spring 中处于核心地位。Bean对于Spring的意义就像Object对于OOP的意义一样，Spring中没有Bean也就没有Spring存在的意义。**Spring IoC容器通过配置文件或者注解的方式来管理bean对象之间的依赖关系。**

spring中bean用于对一个类进行封装。如下面的配置：

**为什么Bean如此重要呢？**

● spring 将bean对象交由一个叫**IOC容器进行管理**。  
● **bean对象之间的依赖关系在配置文件中体现，并由spring完成**。

# 3.Spring IOC相关接口分析 #

## 1) BeanFactory解析 ##

Spring中`Bean的创建`是典型的**工厂模式**，这一系列的**Bean工厂，即IoC容器**，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在Spring中有许多IoC容器的实现供用户选择，其相互关系如下图所示  
![在这里插入图片描述][f0555b423a9b40fd86e60cad8c4cdf9e.png]  
其中，`BeanFactory`作为`最顶层的一个接口`，**定义了IoC容器的基本功能规范**，`BeanFactory有三个重要的子接口`：`ListableBeanFactory`、`HierarchicalBeanFactory`和`AutowireCapableBeanFactory`。但是从类图中我们可以发现最终的默认实现类是`DefaultListableBeanFactory`，它实现了所有的接口。

那么**为何要定义这么多层次的接口呢？**

每个接口都有它的使用场合，主要是为了区分在Spring内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，

● `ListableBeanFactory接口`表示这些**Bean可列表化**。  
● `HierarchicalBeanFactory`表示这些`Bean 是有继承关系的`，也就是`每个 Bean 可能有父 Bean`  
● `AutowireCapableBeanFactory 接口`定义`Bean的自动装配规则`。

这三个接口共同定义了**Bean的集合、Bean之间的关系及Bean行为**。最基本的**IoC容器接口是BeanFactory**，来看一下它的源码：

public interface BeanFactory {
        
    
    	String FACTORY_BEAN_PREFIX = "&";
    
    	//根据bean的名称获取IOC容器中的的bean对象
    	Object getBean(String name) throws BeansException;
    	//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
    	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
    	Object getBean(String name, Object... args) throws BeansException;
    	<T> T getBean(Class<T> requiredType) throws BeansException;
    	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    	
    	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    
    	//判断容器中是否包含指定名称的bean对象
    	boolean containsBean(String name);
    	//根据bean的名称判断是否是单例
    	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    	@Nullable
    	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    	String[] getAliases(String name);
    }

在BeanFactory里**只对IoC容器的基本行为做了定义**，根本不关心你的Bean是如何定义及怎样加载的。正如我们只**关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的**。

**BeanFactory有一个很重要的子接口**，就是`ApplicationContext接口`，该接口主要来规范容器中的**bean对象是非延时加载**，即在**创建容器对象的时候就对象bean进行初始化**，并存储到一个容器中。  
![在这里插入图片描述][a5ac58d05f16478d8662640afa0f665a.png]

要知道**工厂是如何产生对象的，我们需要看具体的IoC容器实现，Spring提供了许多IoC容器实现**，比如：

● `ClasspathXmlApplicationContext`: 根据**类路径加载xml配置文件，并创建IOC容器对象。**  
●`FileSystemXmlApplicationContext`：根据**系统路径加载xml配置文件，并创建IOC容器对象。**  
● `AnnotationConfigApplicationContext`：**加载注解类配置，并创建IOC容器。**

## 2) BeanDefinition解析 ##

**Spring IoC容器管理我们定义的各种Bean对象及其相互关系**，而**Bean对象在Spring实现中是以** `BeanDefinition来描述`的，如下面配置文件

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
    
    bean标签还有很多属性：
    	scope、init-method、destory-method等。

![在这里插入图片描述][e2659246817b4ed88cda55f6a7a863ba.png]

## 3) BeanDefinitionReader解析 ##

Bean的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。\*\*Bean的解析主要就是对Spring配置文件的解析。\*\*这个解析过程主要通过BeanDefinitionReader来完成，看看Spring中BeanDefinitionReader的类结构图，如下图所示。

![在这里插入图片描述][95134d38c390400d88e649987b5a46a5.png]  
看看`BeanDefinitionReader接口定义的功能`来理解它具体的作用：

public interface BeanDefinitionReader {
        
    
    	//获取BeanDefinitionRegistry注册器对象
    	BeanDefinitionRegistry getRegistry();
    
    	@Nullable
    	ResourceLoader getResourceLoader();
    
    	@Nullable
    	ClassLoader getBeanClassLoader();
    
    	BeanNameGenerator getBeanNameGenerator();
    
    	/*
    		下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
    	*/
    	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
    	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
    }

## 4) BeanDefinitionRegistry解析 ##

`BeanDefinitionReader`用来`解析bean定义`，并`封装BeanDefinition对象`，而我们定义的配置文件中定义了很多bean标签，所以就有一个问题，**解析的BeanDefinition对象存储到哪儿**？答案就是`BeanDefinition的注册中心`，而该`注册中心顶层接口就是BeanDefinitionRegistry`。

public interface BeanDefinitionRegistry extends AliasRegistry {
        
    
    	//往注册表中注册bean
    	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException;
    
    	//从注册表中删除指定名称的bean
    	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
    	//获取注册表中指定名称的bean
    	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        
    	//判断注册表中是否已经注册了指定名称的bean
    	boolean containsBeanDefinition(String beanName);
        
    	//获取注册表中所有的bean的名称
    	String[] getBeanDefinitionNames();
        
    	int getBeanDefinitionCount();
    	boolean isBeanNameInUse(String beanName);
    }

继承结构图如下：  
![在这里插入图片描述][15e72940dca343269ab4d5e3cc9621cc.png]  
从上面类图可以看到BeanDefinitionRegistry接口的子实现类主要有以下几个：

*  `DefaultListableBeanFactory`  
    在该类中定义了如下代码，就是用来注册bean

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

*  `SimpleBeanDefinitionRegistry`  
    在该类中定义了如下代码，就是用来注册bean

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

## 5) 创建容器 ##

`ClassPathXmlApplicationContext`对Bean配置资源的载入是从`refresh（）`方法开始的。`refresh（）方法`是一个`模板方法`，**规定了 IoC 容器的启动流程，有些逻辑要交给其子类实现.它对 Bean 配置资源进行载入，`ClassPathXmlApplicationContext`通过调用其父类`AbstractApplicationContext`的`refresh（）`方法启动整个IoC容器对Bean定义的载入过程**。

# 4.自定义SpringIOC #

现要对下面的配置文件进行解析，并自定义Spring框架的IOC对涉及到的对象进行管理。

<?xml version="1.0" encoding="UTF-8"?>
    <beans>
        <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
            <property name="userDao" ref="userDao"></property>
        </bean>
        <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
    </beans>

## 1) 定义bean相关的pojo类 ##

### (1)PropertyValue类 ###

用于`封装bean的属性`，体现到上面的配置文件就是**封装bean标签的子标签property标签数据**。

public class PropertyValue {
        
    
      private String name;
      private String ref;
      private String value;
    
      public PropertyValue() {
        
      }
    
      public PropertyValue(String name, String ref,String value) {
        
        this.name = name;
        this.ref = ref;
        this.value = value;
      }
    
      public String getName() {
        
        return name;
      }
    
      public void setName(String name) {
        
        this.name = name;
      }
    
      public String getRef() {
        
        return ref;
      }
    
      public void setRef(String ref) {
        
        this.ref = ref;
      }
    
      public String getValue() {
        
        return value;
      }
    
      public void setValue(String value) {
        
        this.value = value;
      }
    }

### (2)MutablePropertyValues类 ###

一个bean标签可以有多个property子标签，所以再定义一个MutablePropertyValues类，用来存**储并管理多个PropertyValue对象**。

public class MutablePropertyValues implements Iterable<PropertyValue> {
        
    
        private final List<PropertyValue> propertyValueList;
    
        public MutablePropertyValues() {
        
            this.propertyValueList = new ArrayList<PropertyValue>();
        }
    
        public MutablePropertyValues(List<PropertyValue> propertyValueList) {
        
            this.propertyValueList = (propertyValueList != null ? propertyValueList : new ArrayList<PropertyValue>());
        }
    
        public PropertyValue[] getPropertyValues() {
        
            return this.propertyValueList.toArray(new PropertyValue[0]);
        }
    
        public PropertyValue getPropertyValue(String propertyName) {
        
            for (PropertyValue pv : this.propertyValueList) {
        
                if (pv.getName().equals(propertyName)) {
        
                    return pv;
                }
            }
            return null;
        }
    
        @Override
        public Iterator<PropertyValue> iterator() {
        
            return propertyValueList.iterator();
        }
    
        public boolean isEmpty() {
        
            return this.propertyValueList.isEmpty();
        }
    
        public MutablePropertyValues addPropertyValue(PropertyValue pv) {
        
            for (int i = 0; i < this.propertyValueList.size(); i++) {
        
                PropertyValue currentPv = this.propertyValueList.get(i);
                if (currentPv.getName().equals(pv.getName())) {
        
                    this.propertyValueList.set(i, new PropertyValue(pv.getName(),pv.getRef(), pv.getValue()));
                    return this;
                }
            }
            this.propertyValueList.add(pv);
            return this;
        }
    
        public boolean contains(String propertyName) {
        
            return getPropertyValue(propertyName) != null;
        }
    }

### (3)BeanDefinition类 ###

BeanDefinition类用来封装bean信息的，主要包含i**d（即bean对象的名称）、class（需要交由spring管理的类的全类名）及子标签property数据。**

public class BeanDefinition {
        
        private String id;
        private String className;
    
        private MutablePropertyValues propertyValues;
    
        public BeanDefinition() {
        
            propertyValues = new MutablePropertyValues();
        }
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public String getClassName() {
        
            return className;
        }
    
        public void setClassName(String className) {
        
            this.className = className;
        }
    
        public void setPropertyValues(MutablePropertyValues propertyValues) {
        
            this.propertyValues = propertyValues;
        }
    
        public MutablePropertyValues getPropertyValues() {
        
            return propertyValues;
        }
    }

## 2)定义注册表相关类 ##

### (1)BeanDefinitionRegistry接口 ###

BeanDefinitionRegistry接口定义了注册表的相关操作，定义如下功能：

● **注册BeanDefinition对象**到注册表中  
● 从注册表中**删除**指定名称的BeanDefinition对象  
● 根据名称从注册表中**获取**BeanDefinition对象  
● **判断**注册表中是否包含指定名称的BeanDefinition对象  
● 获取注册表中BeanDefinition**对象的个数**  
● 获取注册表中所有的**BeanDefinition的名称**

public interface BeanDefinitionRegistry {
        
    
        //注册BeanDefinition对象到注册表中
        void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
    
        //从注册表中删除指定名称的BeanDefinition对象
        void removeBeanDefinition(String beanName) throws Exception;
    
        //根据名称从注册表中获取BeanDefinition对象
        BeanDefinition getBeanDefinition(String beanName) throws Exception;
    
        boolean containsBeanDefinition(String beanName);
    
        int getBeanDefinitionCount();
    
        String[] getBeanDefinitionNames();
    }

### (2)SimpleBeanDefinitionRegistry类 ###

该类实现了**BeanDefinitionRegistry接口**，**定义了Map集合作为注册表容器。**

public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
        
    
        private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();
    
        @Override
        public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        
            beanDefinitionMap.put(beanName,beanDefinition);
        }
    
        @Override
        public void removeBeanDefinition(String beanName) throws Exception {
        
            beanDefinitionMap.remove(beanName);
        }
    
        @Override
        public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        
            return beanDefinitionMap.get(beanName);
        }
    
        @Override
        public boolean containsBeanDefinition(String beanName) {
        
            return beanDefinitionMap.containsKey(beanName);
        }
    
        @Override
        public int getBeanDefinitionCount() {
        
            return beanDefinitionMap.size();
        }
    
        @Override
        public String[] getBeanDefinitionNames() {
        
            return beanDefinitionMap.keySet().toArray(new String[1]);
        }
    }

## 3)定义解析器相关类 ##

### (1)BeanDefinitionReader接口 ###

`BeanDefinitionReader`是用来**解析配置文件并在注册表中注册bean的信息**。定义了两个规范：

*  **获取注册表的功能，让外界可以通过该对象获取注册表对象**。
 *  **加载配置文件，并注册bean数据**。

public interface BeanDefinitionReader {
        
    
    	//获取注册表对象
        BeanDefinitionRegistry getRegistry();
    	//加载配置文件并在注册表中进行注册
        void loadBeanDefinitions(String configLocation) throws Exception;
    }

### (2)XmlBeanDefinitionReader类 ###

XmlBeanDefinitionReader类是专门用来**解析xml配置文件**的。该类实现BeanDefinitionReader接口并实现接口中的两个功能。

public class XmlBeanDefinitionReader implements BeanDefinitionReader {
        
    
        private BeanDefinitionRegistry registry;
    
        public XmlBeanDefinitionReader() {
        
            this.registry = new SimpleBeanDefinitionRegistry();
        }
    
        @Override
        public BeanDefinitionRegistry getRegistry() {
        
            return registry;
        }
    
        @Override
        public void loadBeanDefinitions(String configLocation) throws Exception {
        
    
            InputStream is = this.getClass().getClassLoader().getResourceAsStream(configLocation);
            SAXReader reader = new SAXReader();
            Document document = reader.read(is);
            Element rootElement = document.getRootElement();
            //解析bean标签
            parseBean(rootElement);
        }
    
        private void parseBean(Element rootElement) {
        
    
            List<Element> elements = rootElement.elements();
            for (Element element : elements) {
        
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                BeanDefinition beanDefinition = new BeanDefinition();
                beanDefinition.setId(id);
                beanDefinition.setClassName(className);
                List<Element> list = element.elements("property");
                MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
                for (Element element1 : list) {
        
                    String name = element1.attributeValue("name");
                    String ref = element1.attributeValue("ref");
                    String value = element1.attributeValue("value");
                    PropertyValue propertyValue = new PropertyValue(name,ref,value);
                    mutablePropertyValues.addPropertyValue(propertyValue);
                }
                beanDefinition.setPropertyValues(mutablePropertyValues);
    
                registry.registerBeanDefinition(id,beanDefinition);
            }
        }
    }

## 4)IOC容器相关类 ##

### (1) BeanFactory接口 ###

在该接口中**定义IOC容器的统一规范即获取bean对象**。

public interface BeanFactory {
        
    	//根据bean对象的名称获取bean对象
        Object getBean(String name) throws Exception;
    	//根据bean对象的名称获取bean对象，并进行类型转换
        <T> T getBean(String name, Class<? extends T> clazz) throws Exception;
    }

### (2)ApplicationContext接口 ###

该接口的所以的子**实现类对bean对象的创建都是非延时**的，所以在该`接口中定义 refresh() 方法`，该方法主要完成以下两个功能：

● 加载配置文件。  
● 根据注册表中的**BeanDefinition对象封装的数据进行bean对象的创建。**

public interface ApplicationContext extends BeanFactory {
        
    	//进行配置文件加载并进行对象创建
        void refresh() throws IllegalStateException, Exception;
    }

### (3)AbstractApplicationContext类 ###

● 作为`ApplicationContext接口的子类`，所以该类也是非延时加载，所以需要在该类中`定义一个Map集合`，作为`bean对象存储的容器`。  
● 声明`BeanDefinitionReader`类型的变量，用来进行`xml配置文件的解析`，符合单一职责原则。  
`BeanDefinitionReader类型的对象`创建交由**子类实现**，因为只有子类明确到底创建BeanDefinitionReader哪儿个子实现类对象。

> **注意：该类finishBeanInitialization()方法中调用getBean()方法**使用到了**模板方法模式**。

public abstract class AbstractApplicationContext implements ApplicationContext {
        
    
        protected BeanDefinitionReader beanDefinitionReader;
        //用来存储bean对象的容器   key存储的是bean的id值，value存储的是bean对象
        protected Map<String, Object> singletonObjects = new HashMap<String, Object>();
    
        //存储配置文件的路径
        protected String configLocation;
    
        public void refresh() throws IllegalStateException, Exception {
        
    
            //加载BeanDefinition
            beanDefinitionReader.loadBeanDefinitions(configLocation);
    
            //初始化bean
            finishBeanInitialization();
        }
    
        //bean的初始化
        private void finishBeanInitialization() throws Exception {
        
            BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
            String[] beanNames = registry.getBeanDefinitionNames();
    
            for (String beanName : beanNames) {
        
                BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
                getBean(beanName);
            }
        }
    }

### (4)ClassPathXmlApplicationContext类 ###

该类主要是**加载类路径下的配置文件，并进行bean对象的创建**，主要完成以下功能：

● 在构造方法中，**创建BeanDefinitionReader对象**。  
● 在构造方法中，**调用refresh()方法，用于进行配置文件加载、创建bean对象并存储到容器中**。  
● **重写父接口中的getBean()方法**，并实现依赖注入操作。

public class ClassPathXmlApplicationContext extends AbstractApplicationContext{
        
    
        public ClassPathXmlApplicationContext(String configLocation) {
        
            this.configLocation = configLocation;
            //构建XmlBeanDefinitionReader对象
            beanDefinitionReader = new XmlBeanDefinitionReader();
            try {
        
                this.refresh();
            } catch (Exception e) {
        
            }
        }
    
        //根据bean的id属性值获取bean对象
        @Override
        public Object getBean(String name) throws Exception {
        
    
            //return singletonObjects.get(name);
            Object obj = singletonObjects.get(name);
            if(obj != null) {
        
                return obj;
            }
    
            BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
            BeanDefinition beanDefinition = registry.getBeanDefinition(name);
            if(beanDefinition == null) {
        
                return null;
            }
            String className = beanDefinition.getClassName();
            Class<?> clazz = Class.forName(className);
            Object beanObj = clazz.newInstance();
            MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
            for (PropertyValue propertyValue : propertyValues) {
        
                String propertyName = propertyValue.getName();
                String value = propertyValue.getValue();
                String ref = propertyValue.getRef();
                if(ref != null && !"".equals(ref)) {
        
    
                    Object bean = getBean(ref);
                    String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                    Method[] methods = clazz.getMethods();
                    for (Method method : methods) {
        
                        if(method.getName().equals(methodName)) {
        
                            method.invoke(beanObj,bean);
                        }
                    }
                }
    
                if(value != null && !"".equals(value)) {
        
                    String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);
                    Method method = clazz.getMethod(methodName, String.class);
                    method.invoke(beanObj,value);
                }
            }
            singletonObjects.put(name,beanObj);
            return beanObj;
        }
    
        @Override
        public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
        
    
            Object bean = getBean(name);
            if(bean != null) {
        
                return clazz.cast(bean);
            }
            return null;
        }
    }

# 5.自定义Spring IOC总结 #

## 使用到的设计模式 ##

● `工厂模式`。这个使用工厂模式 + 配置文件的方式。  
● `单例模式`。`Spring IOC管理的bean对象都是单例的`，此处的单例不是通过构造器进行单例的控制的，而是spring框架对每一个bean只创建了一个对象。  
● `模板方法模式`。`AbstractApplicationContext类中的finishBeanInitialization()方法调用了子类的getBean()方法`，因为getBean()的实现和环境息息相关。  
● `迭代器模式`。对于`MutablePropertyValues类定义使用到了迭代器模式`，因为此类存储并管理PropertyValue对象，也属于一个容器，所以给该容器提供一个遍历方式。

[93c34cf493ed4a7d85a690cbc9902b5b.png]: https://img-blog.csdnimg.cn/93c34cf493ed4a7d85a690cbc9902b5b.png
[f0555b423a9b40fd86e60cad8c4cdf9e.png]: https://img-blog.csdnimg.cn/f0555b423a9b40fd86e60cad8c4cdf9e.png
[a5ac58d05f16478d8662640afa0f665a.png]: https://img-blog.csdnimg.cn/a5ac58d05f16478d8662640afa0f665a.png
[e2659246817b4ed88cda55f6a7a863ba.png]: https://img-blog.csdnimg.cn/e2659246817b4ed88cda55f6a7a863ba.png
[95134d38c390400d88e649987b5a46a5.png]: https://img-blog.csdnimg.cn/95134d38c390400d88e649987b5a46a5.png
[15e72940dca343269ab4d5e3cc9621cc.png]: https://img-blog.csdnimg.cn/15e72940dca343269ab4d5e3cc9621cc.png