自定义IOC容器

MR.XSS2023-06-092023-07-25

IOC

终于学完了设计模式，今天试着写了一下IOC容器，只是简单的模仿了一下，不喜勿喷

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.xu.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="com.xu.dao.impl.UserDaoImpl"></bean>

</beans>

代码运行结果如下：

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

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

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

spring核心功能结构

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

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

核心容器由 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-indexer模块是Spring的类管理组件和Classpath扫描组件。
spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。

bean概述

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

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

<bean id="userService" class="com.xu.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.xu.dao.impl.UserDaoImpl"></bean>

为什么Bean如此重要呢？

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

Spring IOC相关接口分析

BeanFactory解析

Spring中Bean的创建是典型的工厂模式，这一系列的Bean工厂，即IoC容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在Spring中有许多IoC容器的实现供用户选择，其相互关系如下图所示。

其中，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进行初始化，并存储到一个容器中。

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

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

BeanDefinition解析

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

<bean id="userDao" class="com.xu.dao.impl.UserDaoImpl"></bean>

bean标签还有很多属性：
	scope、init-method、destory-method等。

其继承体系如下图所示。

BeanDefinitionReader解析

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

看看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;
}

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

继承结构图如下：

从上面类图可以看到BeanDefinitionRegistry接口的子实现类主要有以下几个：

DefaultListableBeanFactory

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

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

SimpleBeanDefinitionRegistry

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

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

7.3.5 创建容器

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

自定义IOC

总体架构

PropertyValue类

封装property标签，属性有value，name，ref，三个属性，用于反射创建对象

package com.xu.framework.beans;

/**
 * @author ==> 许帅帅
 * @version ==> 1.0
 *  封装xml配置文件属性
 * 2023/6/8 20:37
 */
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;
    }
}

MutablePropertyValues类

用来存储property类

该类实现了迭代器，可以使用增强for循环
成员变量设置List集合作为容器，存储多个property对象
该类有个 addProperty 方法，该方法保证了相同的PropertyValue对象只会添加一次

package com.xu.framework.beans;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author MR.XSS
 * 存储PropertyValue对象 --> 简易的说就是存储引用标签
 * 2023/6/8 21:19
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {
    private final List<PropertyValue> propertyValues;

    public MutablePropertyValues() {
        this.propertyValues = new ArrayList<>();
    }

    public MutablePropertyValues(List<PropertyValue> propertyValues) {
        this.propertyValues = (propertyValues == null ? new ArrayList<>() : propertyValues);
    }

    //获取pv数组
    public PropertyValue[] getPropertyValues() {
        return this.propertyValues.toArray(new PropertyValue[0]);
    }

    public PropertyValue getPropertyValue(String propertyName) {
        for (PropertyValue pv : this.propertyValues) {
            if(pv.getName().equals(propertyName)){
                return pv;
            }
        }

        return null;
    }

    public boolean isEmpty() {
        return propertyValues.isEmpty();
    }


    //添加
    public MutablePropertyValues addProperty(PropertyValue propertyValue) {
        //判断是否有相同的bean
        for (int i = 0; i < this.propertyValues.size(); i++) {
            PropertyValue pv = this.propertyValues.get(i);
            if (pv.getName().equals(propertyValue)) {
                this.propertyValues.set(i, propertyValue);
                return this;
            }
        }
        this.propertyValues.add(propertyValue);
        return this;
    }

    //判断是否包含该名字pv
    public boolean contains(String propertyValueName) {
        return this.getPropertyValue(propertyValueName) != null;
    }


    //获取迭代器
    @Override
    public Iterator<PropertyValue> iterator() {
        return propertyValues.iterator();
    }
}

BeanDefinition类

该类用来封装Bean标签数据，便于反射创建对象

该类有三个成员变量
id，bean标签id标识
classname，类的全类名
PropertyValue集合，Bean标签里面包的property标签

package com.xu.framework.beans;

/**
 * @author MR.XSS
 * @version 1.0
 *      用来封装bean标签数据
 *      id属性
 *      class属性
 *      property 子标签的数据
 * 2023/6/8 22:05
 */
public class BeanDefinition {
    private String id;
    private String className;

    private MutablePropertyValues mutablePropertyValues;

    public BeanDefinition() {
        mutablePropertyValues = 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 MutablePropertyValues getMutablePropertyValues() {
        return mutablePropertyValues;
    }

    public void setMutablePropertyValues(MutablePropertyValues mutablePropertyValues) {
        this.mutablePropertyValues = mutablePropertyValues;
    }
}

BeanDefinitionRegisrty接口

这个接口用来用来规范注册Bean的

package com.xu.framework.beans.factory.support;

import com.xu.framework.beans.BeanDefinition;

/**
 * @author MR.XSS
 * @version 1.0
 * 2023/6/9 9:03
 */
public interface BeanDefinitionRegistry {
    //注册beandefinition
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    //删除BeanDefinition
    void removeBeanDefinition(String beanName) throws Exception;

    //获取BeanDefinition
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    //是否包含BeanDefinition
    boolean containsBeanDefinition(String beanName);

    //获取总数
    int getBeanDefinitionCount();

    //获取Names数组
    String[] getBeanDefinitionNames();
}

SimpleBeanDefinitionRegistry类

实现了BeanDefinitionRegistry接口，用来注册Bean

拥有一个成员变量，该成员变量是一个Map集合，用来保存Bean

package com.xu.framework.beans.factory.support;

import com.xu.framework.beans.BeanDefinition;

import java.util.HashMap;
import java.util.Map;

/**
 * @author MR.XSS
 * @version 1.0
 *      注册表相关的类
 * 2023/6/9 9:03
 */
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry{

    private Map<String,BeanDefinition> beanDefinitionMap = new HashMap<>();

    @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[0]);
    }
}

BeanDefinitionReader接口

该接口规范了读取配置文件的方法

package com.xu.framework.beans.factory.support;

/**
 * @author MR.XSS
 * @version 1.0
 * 解析配置文件的规范
 * 2023/6/9 9:21
 */
public interface BeanDefinitionReader {
    //获取注册表
    BeanDefinitionRegistry getRegistry();
    //加载配置文件，并在注册表中注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

XMLBeanDefinitionReader类

该类实现了BeanDefinitionReader接口，实现了对Xml配置文件的读取

读取配置文件，这里引入了第三方库dom4j，该库可以实现对xml文件的读取

该类注入了SimpleBeanDefinitionRegistry类，随着遍历DOM文件树，蒋所有文件里的内容存储到注册表里面

package com.xu.framework.beans.factory.xml;

import com.xu.framework.beans.BeanDefinition;
import com.xu.framework.beans.MutablePropertyValues;
import com.xu.framework.beans.PropertyValue;
import com.xu.framework.beans.factory.support.BeanDefinitionReader;
import com.xu.framework.beans.factory.support.BeanDefinitionRegistry;
import com.xu.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.util.List;

/**
 * @author MR.XSS
 * @version 1.0
 * 2023/6/9 9:25
 */
public class XMLBeanDefinitionReader implements BeanDefinitionReader {

    private BeanDefinitionRegistry registry;

    public XMLBeanDefinitionReader() {
        registry = new SimpleBeanDefinitionRegistry();
    }

    @Override
    public BeanDefinitionRegistry getRegistry() {
        return registry;
    }

    @Override
    public void loadBeanDefinitions(String configLocation) throws Exception {
        //读取bean的XML文件
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(XMLBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation));

        //获取根标签
        Element rootElement = document.getRootElement();

        //获取bean标签
        List<Element> beanList = rootElement.elements("bean");

        //遍历集合
        for (Element element : beanList) {
            String id = element.attributeValue("id");
            String className = element.attributeValue("class");

            //创建bean定义对象
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            //创建MutablePropertyValues对象
            MutablePropertyValues propertyValues = new MutablePropertyValues();

            List<Element> propertyList = element.elements("property");
            for (Element property : propertyList) {
                String ref = property.attributeValue("ref");
                String name = property.attributeValue("name");
                String value = property.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                propertyValues.addProperty(propertyValue);
            }

            beanDefinition.setMutablePropertyValues(propertyValues);
            registry.registerBeanDefinition(id,beanDefinition);
        }
    }
}

BeanFactory，ApplicationContext接口

规范Bean工厂，并且ApplicationContext接口继承Bean工厂

package com.xu.framework.beans.factory;

/**
 * @author MR.XSS
 * @version 1.0
 * 2023/6/9 10:32
 */
public interface BeanFactory {
    Object getBean(String name) throws Exception;
    <T> T getBean(String name, Class<? extends T> clazz) throws Exception;
}

package com.xu.framework.context;

import com.xu.framework.beans.factory.BeanFactory;

/**
 * @author MR.XSS
 * @version 1.0
 * 2023/6/9 10:56
 */
public interface ApplicationContext extends BeanFactory {
    void refresh() throws Exception;
}

AbstractApplicationContext类

package com.xu.framework.context.support;

import com.xu.framework.beans.BeanDefinition;
import com.xu.framework.beans.factory.support.BeanDefinitionReader;
import com.xu.framework.beans.factory.support.BeanDefinitionRegistry;
import com.xu.framework.context.ApplicationContext;

import java.util.HashMap;
import java.util.Map;

/**
 * @author MR.XSS
 * @version 1.0
 * AbstractApplicationContext
 * ApplicationContext 接口子实现类，用于立即加载类
 * 2023/6/9 11:15
 */
public abstract class AbstractApplicationContext implements ApplicationContext {

    //声明解析器
    protected BeanDefinitionReader beanDefinitionReader;

    //用于定义存储存储bean对象的map集合
    protected Map<String, Object> singletonObjects = new HashMap<>();

    // 记录配置文件路径变量
    protected String configLocation;

    @Override
    public void refresh() throws Exception{
        beanDefinitionReader.loadBeanDefinitions(configLocation);
        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);
        }
    }
}

ClassPathXMLApplicationContext类

该类作为容器，并且在创建容器之时就会立即加载类

package com.xu.framework.context.support;

import com.xu.framework.beans.BeanDefinition;
import com.xu.framework.beans.MutablePropertyValues;
import com.xu.framework.beans.PropertyValue;
import com.xu.framework.beans.factory.support.BeanDefinitionRegistry;
import com.xu.framework.beans.factory.xml.XMLBeanDefinitionReader;
import com.xu.framework.utils.StringUtils;

import java.lang.reflect.Method;

/**
 * @author MR.XSS
 * @version 1.0
 * IOC容器具体子实现类
 * 用于加载类路径下xml格式配置文件
 * 2023/6/9 12:24
 */
public class ClassPathXMLApplicationContext extends AbstractApplicationContext {

    public ClassPathXMLApplicationContext(String configLocation) {
        this.configLocation = configLocation;
        beanDefinitionReader = new XMLBeanDefinitionReader();
        try {
            refresh();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object getBean(String name) throws Exception {
        Object obj = singletonObjects.get(name);
        if (obj != null){
            return obj;
        }

        //获取BeanDefinition对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        String className = beanDefinition.getClassName();

        //通过反射创建对象
        Class<?> clazz = Class.forName(className);
        Object beanObj = clazz.newInstance();


        //进行依赖注入操作
        MutablePropertyValues mutablePropertyValues = beanDefinition.getMutablePropertyValues();

        for (PropertyValue mutablePropertyValue : mutablePropertyValues) {
            //获取name属性值
            String propertyName = mutablePropertyValue.getName();
            String value = mutablePropertyValue.getValue();
            String ref = mutablePropertyValue.getRef();

            //引用数据类型
            if(ref != null && !"".equals(ref)){
                Object bean = getBean(ref);
                //拼接方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);

                //获取所有方法对象
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (methodName.equals(method.getName())){
                        //执行set方法
                        method.invoke(beanObj,bean);
                    }
                }
            }

            //基本数据类型
            if(value != null && !"".equals(value)){
                //拼接方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
                Method method = clazz.getMethod(methodName, String.class);
                method.invoke(beanObj,value);
            }
        }

        //返回之前，将对象存储到map中
        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 null;
        }
        return clazz.cast(bean);
    }
}

工具类

package com.xu.framework.utils;

/**
 * @author MR.XSS
 * @version 1.0
 * 2023/6/9 16:01
 */
public class StringUtils {
    public StringUtils() {}
    //userDao   ==>    setUserDao
    public static String getSetterMethodByFieldName(String filedName){
        String methodName = "set" + filedName.substring(0,1).toUpperCase() + filedName.substring(1);
        return methodName;
    }
}

自定义IOC容器

自定义IOC容器

IOC

spring使用回顾

spring核心功能结构

bean概述

Spring IOC相关接口分析

BeanFactory解析

BeanDefinition解析

BeanDefinitionReader解析

BeanDefinitionRegistry解析

7.3.5 创建容器

自定义IOC

总体架构

PropertyValue类

MutablePropertyValues类

BeanDefinition类

BeanDefinitionRegisrty接口

SimpleBeanDefinitionRegistry类

BeanDefinitionReader接口

XMLBeanDefinitionReader类

BeanFactory，ApplicationContext接口

AbstractApplicationContext类

ClassPathXMLApplicationContext类

工具类

安装到本地仓库

使用IDEA的Maven工具进行安装

安装成功

集成测试

引入依赖

测试类

配置文件

测试

MR.XSS