Spring框架（IoC部分）

本文章包含了maven的使用，站在程序员的角度看Spring对IoC的实现，GoF工厂模式，手写Spring的IoC框架... ...

什么是IoC？

Spring的IoC意为控制反转，它一共反转了两件事

1，不在程序中采用硬编码的方式来new对象了（即不管new对象了，把权力交出去了）

2，不再采用硬编码的方式来维护对象的关系了（对象之间的维护权也交出去了）

在我的前两篇博客中都使用了MVC设计模式，这其中都使用了Service层关联Dao层的写法，在Service层的代码中new了Dao对象，如果出现了新的需求就需要修改原先的代码而不是在原先的代码上增添新的代码，这是违背了OCP开闭原则的。

同时在Service层中因为有dao层对象，因此service层是依赖dao层的，这也违背了DIP依赖倒置原则（凡是上层依赖下层的，都违背了依赖倒置原则）。

这时就需要使用到Spring框架中的IoC模式，让Spring框架来帮助我们创建对象和处理依赖之间的上下依赖关系。

准备工作（Maven）

使用到的工具是Maven来帮我们导入Spring相关jar包，这样我们就不用再到网上找jar包下载到本地了，统一把管理jar包的工作交给maven来管理。

1，maven的下载地址：Maven – Download Apache Maven

2，解压之后配置环境变量：

首先需要再系统变量中添加MAVEN_HOME并把变量值改为下载的maven

然后需要在path下新增一个MAVEN_HOME，注意这里的路径是需要到maven的bin目录的。

3，maven的功能配置

进入到下载的maven的conf目录中，找到settings配置文件，在其中设置：

（1）设置本地maven仓库地址

  <localRepository>D:\maven-repository</localRepository>

（2）中央仓库下载速度偏慢，建议在这里设置为阿里云的镜像仓库

    <mirror>

      <id>alimaven</id>

      <name>aliyun maven</name>

      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>

      <mirrorOf>central</mirrorOf>

    </mirror>

（3）配置对应的JDK版本（我用的是21版本）

    <profile>

    <id>jdk-21</id>

    <activation>

      <activeByDefault>true</activeByDefault>

      <jdk>21</jdk>

    </activation>

    <properties>

      <maven.compiler.source>21</maven.compiler.source>

      <maven.compiler.target>21</maven.compiler.target>

      <maven.compiler.compilerVersion>21</maven.compiler.compilerVersion>

    </properties>

    </profile>

至此完成了maven的所有配置。

IDEA中配置maven

 

我们在IDEA中这样设置，构造系统选择Maven，并且需要修改组ID为com.xxx.xxx

在这之前我们还需要到设置中进行设置（如下图）

 选择构建，执行，部署下的Maven，然后需要修改Maven的主路径为我们下载maven的位置，然后修改用户设置文件为刚刚进行maven修改的conf目录下的settings.xml配置文件.

完成这些设置之后我们创建出来的项目应该是这样的：

然后在pom.xml中就可以导入我们需要的jar包了，例如我们需要编写Spring的IoC功能就需要使用到Spring-context的jar包，我们先加上一个<dependencies>标签，并在标签下复制如下GAVP信息

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0</version>
        </dependency>

 这样我们然后点击右边的刷新，maven就会自动帮我们下载jar包

如果我们需要下载其他jar包：如log4j，dom4j，junit等等，我们都可以到这个网站去https://mvnrepository.com/搜索相关jar包名称，找到后选择对应版本并点入：

将下面的<dependency>标签复制到pom.xml中即可下载下对应jar包。

程序员视角开发Spring项目

Spring对IoC的实现主要就只有两大块，一个是set注入，一个是构造注入。什么是注入？注入就是将相关的属性值赋给属性，而有了这样的注入之后我们就不需要再new对象了。例如原先我们在service层都需要：private UserDao userDao = new UserDao()，使用了IoC之后我们只需要：private UserDao userDao;即可，避免了new对象的过程。

IoC的本质就是一个大容器对其中的一堆豆子进行管理，而这些豆子就是我们创建的一个个对象，比如UserDao就可以抽象成一个豆子，在这些豆子中写相应代码就能够实现注入。

Set注入

用我们常用的setter方法来给属性完成注入，首先需要在resources目录下创建一个spring类型的xml配置文件。

如果我们需要管理UserDao对象只需要写一个<bean>：id为自己取的名，class为类的全路径

<bean id="userDaoBean" class="com.ryy.spring.Dao.UserDao"/>

这样写就相当于把一个UserDao对象配置一个bean放入到了IoC容器中，而如果想要实现UserService能够直接调用userDao的方法，并且不是通过new对象的形式实现，这时候就是二者之间的依赖关系了，在userService的<bean>下配置：

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

name：set方法的方法名去掉set，然后把剩下的单词首字母变小写写到这里。

ref：指定的就是userDao的<bean>的id。

完整举例：

Spring将一个Bean的引用注入到另一个Bean中。

<bean id="someService" class="com.example.SomeService">
    <property name="dependency" ref="someDependency"/>
</bean>

<bean id="someDependency" class="com.example.SomeDependency"/>

public class SomeService {
    private SomeDependency dependency;

    public void setDependency(SomeDependency dependency) {
        this.dependency = dependency;
    }
}

在这个示例中，Spring会将someDependency Bean的引用注入到someService Bean中.

构造注入

构造注入如字面意思就是通过构造方法来实现注入，其注入过程与set注入大相径庭，唯一的区别就在于标签名，构造注入不是用<property>而是用<constructor-arg>标签，在这个标签后面可以像<property>一样跟name属性，也可以跟<constructor-arg>自己的index属性，index属性后面都是写0，1，2... ...，这些参数代表了第一个参数，第二个参数，第三个参数... ...，ref属性还是和<property>一样。

完整举例：

public class SomeService {
    private SomeDependency dependency;

    public SomeService(SomeDependency dependency) {
        this.dependency = dependency;
    }
}

<bean id="someService" class="com.example.SomeService">
    <constructor-arg ref="someDependency"/>
</bean>

<bean id="someDependency" class="com.example.SomeDependency"/>

GoF工厂模式

大家这一部分具体可以去看老杜的Spring6教学讲解的工厂，我这里主要是分享老杜视频中未提到的简单工厂模式和工厂方法模式的结合。

GoF工厂模式中又分为简单工厂模式和工厂方法模式：

（1）简单工厂模式：职责分离，客户端不需要关心产品的生产细节，客户端只负责消费，工厂类负责生产。生产者和消费者分离了。

缺点：如果需要一个新的产品，工厂类的代码是需要修改的，这就违背了OCP原则。工厂类负责所有产品的生产，责任重大，一旦出问题，整个系统必然瘫痪。

（2）工厂方法模式：一个工厂对应生产一种产品，这样工厂就不是全能类了，角色变化在于原先的工厂类变成了抽象工厂角色和具体工厂角色。

缺点：每次增加一个产品时都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加。

大家看完老杜的GoF工厂模式视频之后会想到如何将两种工厂模式结合进行降低耦合度的操作，我给出如下解释：（准备工作：如下创建工厂方法模式

abstract public class Weapon {
    public abstract void attack();
}
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍!!");
    }
}
abstract public class WeaponFactory {
    public abstract Weapon get();
}
public class DaggerFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Dagger();
    }
}

但是光用工厂方法模式的话，在主程序中就需要new一个DaggerFactory，而这是违背了OCP原则的，我们需要做到尽可能不去new新对象，如下：

public class test {
    public static void main(String[] args) {
        WeaponFactory daggerFactory = AllFactory.get("Dagger");
        Weapon dagger = daggerFactory.get();
        dagger.attack();
    }
}

我们依旧要通过武器名来获取相关武器的对象，这时候我们就需要一个总工厂类来创建各个工厂类，我们取名为AllFactory类，在其中我们需要一个集合来存放武器名和武器工厂类，而想要通过名字就获取到对应工厂的实例对象，这时候就要使用到反射机制，通过武器工厂类来获取武器工厂类的实例对象并返回，这样在主程序中就能使用武器工厂类的相关方法了。

而创建集合还有一个优势就是如果有新的武器工厂类需要新增进去，就直接在原先代码的基础上新增代码即可，无需修改原先的代码，这样也符合OCP原则。

public class AllFactory {
    //为符合工厂设计模式创建一个HashMap用来存放武器工厂，这样就只需要添加而不用修改了
    private static final Map<String, Class<? extends WeaponFactory>> factoryMap = new HashMap<>();

    static {
        factoryMap.put("Dagger", DaggerFactory.class);
        // 可以在这里继续添加其他武器工厂
    }

    public static WeaponFactory get(String weaponType) {
        Class<? extends WeaponFactory> factoryClass = factoryMap.get(weaponType);
        if (factoryClass != null) {
            try {
                //利用反射机制获取无参构造器后创建类实例对象
                return factoryClass.getDeclaredConstructor().newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null; // 或者抛出异常
    }
}

手写Spring框架（IoC）

1，我们在之前已经站在使用框架者的角度使用过Spring框架了，那我们就可以根据使用者的相关代码来开发Spring框架，比如使用到了ApplicationContext接口，以及旗下的getBean方法和具体实现类：ClassPathXmlApplicationContext。我们创建三个类：

User类：

public class User {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

UserDao类：

public class UserDao {
    public void insert(){
        System.out.println("mysql数据库正在保存用户信息... ...");
    }
}

UserService类：

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

mySpring配置文件：

<!--这个配置文件也是使用mySpring框架的开发人员提供的-->
<beans>
    <bean id="user" class="com.ryy.myspring.bean.User">
        <property name="name" value="张三"></property>
        <property name="age" value="30"></property>
    </bean>

    <bean id="userDaoBean" class="com.ryy.myspring.bean.UserDao"></bean>

    <bean id="userService" class="com.ryy.myspring.bean.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>
</beans>

2，开发框架：首先我们需要在maven中准备好相关的的jar包，有dom4j,log4j2,junit等：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.myspringframework</groupId>
    <artifactId>mySpring</artifactId>
    <version>1.0.0</version>
    <!--打包方式-->
    <packaging>jar</packaging>

    <!--导入依赖-->
    <dependencies>
        <!--dom4j是一个能够解析xml文件的java组件-->
        <!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/jaxen/jaxen -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.2.0</version>
        </dependency>

        <!--单元测试依赖-->
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.10.2</version>
            <scope>test</scope>
        </dependency>

        <!--导入log4j的依赖-->
        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.23.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-slf4j2-impl -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
            <version>2.23.1</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

log4j2日志框架相关配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <loggers>
        <root level="DEBUG">
            <appender-ref ref="spring6log"/>
        </root>
    </loggers>
    <appenders>
        <console name="spring6log" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
        </console>
    </appenders>
</configuration>

 

然后我们需要一个核心文件来存放我们开发的框架的接口和实现类：

 3，准备好ApplicationContext接口，ApplicationContext接口中提供⼀个getBean()方法，通过该方法可以获取Bean对象。

/**
 * mySpring应用上下文接口
 */
public interface ApplicationContext {
    /**
     * 根据bean的名称获取对应的bean对象
     * @param beanName mySpring配置文件中bean标签的id
     * @return 对应的单例bean对象
     */
    Object getBean(String beanName);
}

4，由Application application = new ClassPathXmlApplicationContext("spring配置文件路径")可知我们还需一个ClassPathXmlApplicationContext的构造方法来初始化Bean对象，该类从类路径当中加载 myspring.xml配置⽂件。

public class ClassPathXmlApplicationContext implements ApplicationContext{
 @Override
 public Object getBean(String beanId) {
     return null;
   }
}

5，在看过老杜之前的阅读源码视频之后我们应该还知道一个概念是一级缓存，二级缓存，三级缓存。这其实就是三个集合用来存放三个阶段的bean，分别是曝光的bean，赋值的bean以及bean的工厂类。

在这里我们也需要一个Map来统一存放各个Bean，然后用getBean从集合当中获取这些bean对象。Map集合的key存储beanId，value存储Bean实例。并且在ClassPathXmlApplicationContext类中添加构造⽅法，该构造⽅法的参数接收myspring.xml文件并返回实例对象（反射）

public class ClassPathXmlApplicationContext implements ApplicationContext{
     /**
     * 存储bean的Map集合
     */
     private Map<String,Object> beanMap = new HashMap<>();
     /**
     * 在该构造⽅法中，解析myspring.xml⽂件，创建所有的Bean实例，并将Bean实例存放到
    Map集合中。
     * @param resource 配置⽂件路径（要求在类路径当中）
     */
     public ClassPathXmlApplicationContext(String resource) {
     }
     @Override
     public Object getBean(String beanId) {
     return beanMap.get(beanId);
   }
}

6，先做的第一件事并不是给属性赋值，而是让属性曝光，通过xml配置文件中的class类路径通过反射，来获取类对象并获取无参构造方法并创建类实例对象存放到Map集合当中，我们可以用日志打印一下是否能获取到类实例对象，代码中已写上详细注释。

    public ClassPathXmlApplicationContext(String configLocation) {
        //解析mySpring.xml文件，然后实例化Bean，将bean存放到singletonObjects集合当中
        //这是dom4j解析xml文件的核心对象
        SAXReader reader = new SAXReader();
        //获取一个输入流，指向配置文件(只适合在类路径下加载资源)
        InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
        try {
            //读文件，得到文档对象
            Document document = reader.read(in);
            //获取所有的同名bean标签
            List<Node> nodes = document.selectNodes("//bean");
            //遍历bean标签
            nodes.forEach(node -> {
                try {
                    //向下转型的目的是为了使用Element接口里更加丰富的方法
                    Element beanElt = (Element) node;
                    //获取bean标签中的id属性
                    String id = beanElt.attributeValue("id");
                    //获取Class属性
                    String className = beanElt.attributeValue("class");
                    logger.info("beanName=" + id);
                    logger.info("beanClassName=" + className);
                    //通过反射机制创建对象，将其放到Map集合中，提前曝光
                    //获取Class
                    Class<?> aClass = Class.forName(className);
                    //获取无参构造方法并创建类实例对象
                    Object bean = aClass.getDeclaredConstructor().newInstance();
                    //将bean曝光放入到Map集合
                    singletonObjects.put(id, bean);
                    //记录日志
                    logger.info(singletonObjects.toString());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });
          } catch (DocumentException e) {
            throw new RuntimeException(e);
        }

7，由于上面一步只是将对象曝光，并没有给对象赋值，因此看如下运行结果：

 可见name和age属性都是为空，那么下一步就是要给曝光出来的对象一一赋值（通过名字来获取属性）

首先：再次重新把所有的bean标签遍历一遍，这一次主要是给对象属性赋值

//再次重新把所有的bean标签遍历一遍，这一次主要是给对象属性赋值
            nodes.forEach(node -> {
                try {
                    Element beanElt = (Element) node;
                    //获取id
                    String id = beanElt.attributeValue("id");
                    //获取className
                    String className = beanElt.attributeValue("class");
                    //获取Class对象
                    Class<?> aClass = Class.forName(className);

然后获取该bean标签下所有的属性property标签并遍历，首先我们获取property标签下的name属性，value属性需要分成两种情况讨论因此放在下一块。

通过"name"标签获得了各属性名。 

                    //获取该bean标签下所有的属性property标签
                    List<Element> properties = beanElt.elements("property");
                    //遍历所有的属性标签
                    properties.forEach(property -> {
                        //获取属性名
                        String propertyName = property.attributeValue("name");
                        try {
                            //通过属性名获取属性类型
                            Field field = aClass.getDeclaredField(propertyName);
                            logger.info("属性名：" + propertyName)

由于是set注入，因此需要在注入属性值给对象之前获取setter方法，根据idea自动生成的setter方法名来配对其对应格式获得setter方法名并通过反射得到对应方法。

                            //获取set方法名(把第一个字母取大写之后跟上剩余的方法名)
                            String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
                            //获取set方法
                            Method setMethod = aClass.getDeclaredMethod(setMethodName, field.getType());
                            //获取具体的值
                            String value = property.attributeValue("value");
                            Object actualValue = null; //新建一个真值参数作为传入方法的参数
                            String ref = property.attributeValue("ref");

（1）如果是非简单类型：

第一个参数是集合中通过id得到的对应类对象，如userDao,User类等，第二个参数是setter方法需要传入的参数，ref代表的是另一个bean的id，集合中已经集成了所有的bean对象，因此能够获取到另一个bean对象并作为参数返回

if(ref != null){
                                //说明这个值是非简单类型
                                //ref代表的是另一个bean的id，集合中已经集成了所有的bean对象，因此能够获取到另一个bean对象并作为参数返回
                                setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
                            }

（2）如果是简单类型：

我们在其中需要设置我们设定的简单类型有哪些，然后根据传入的值一一判断。

                            if(value != null){
                                //说明这个值是简单类型
                                //mySpring框架声明：只支持如下类型为简单类型
                                //byte, short, int, long, float, double, boolean, char
                                //Byte, Short, Integer, Long, Double, Float, Boolean, Character
                                //String
                                //获取简单类型即去除包名
                                String propertyTypeSimpleName = field.getType().getSimpleName();
                                switch (propertyTypeSimpleName){
                                    case "byte":
                                        actualValue = Byte.parseByte(value);
                                        break;
                                    case "short":
                                        actualValue = Short.parseShort(value);
                                        break;
                                    case "int":
                                        actualValue = Integer.parseInt(value);
                                        break;
                                    case "long":
                                        actualValue = Long.parseLong(value);
                                        break;
                                    case "float":
                                        actualValue = Float.parseFloat(value);
                                        break;
                                    case "double":
                                        actualValue = Double.parseDouble(value);
                                        break;
                                    case "boolean":
                                        actualValue = Boolean.parseBoolean(value);
                                        break;
                                    case "char":
                                        actualValue = value.charAt(0);
                                        break;
                                    case "Byte":
                                        actualValue = Byte.valueOf(value);
                                        break;
                                    case "Short":
                                        actualValue = Short.valueOf(value);
                                        break;
                                    case "Integer":
                                        actualValue = Integer.valueOf(value);
                                        break;
                                    case "Long":
                                        actualValue = Long.valueOf(value);
                                        break;
                                    case "Float":
                                        actualValue = Float.valueOf(value);
                                        break;
                                    case "Double":
                                        actualValue = Double.valueOf(value);
                                        break;
                                    case "Boolean":
                                        actualValue = Boolean.valueOf(value);
                                        break;
                                    case "Character":
                                        actualValue = value.charAt(0);
                                        break;
                                    case "String":
                                        actualValue = value;
                                        break;
                                }
                                setMethod.invoke(singletonObjects.get(id), actualValue);
                            }

然后我们可以写一个测试程序来测试一下我们的框架：

import com.ryy.myspring.bean.UserService;
import org.junit.jupiter.api.Test;
import org.myspringframework.core.ApplicationContext;
import org.myspringframework.core.ClassPathXmlApplicationContext;

public class mySpringTest {
    @Test
    public void testMySpring(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
        Object user = applicationContext.getBean("user");
        System.out.println(user);

        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.save();
    }
}

 

手写Spring框架（IoC）整体代码

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ClassPathXmlApplicationContext implements ApplicationContext {
    private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);

    private Map<String, Object> singletonObjects = new HashMap<>();

    /**
     * 解析mySpring配置文件，然后初始化所有的Bean对象
     *
     * @param configLocation Spring配置文件的路径，注：使用ClassPathXmlApplicationContext，配置文件应当放到类路径下
     */
    public ClassPathXmlApplicationContext(String configLocation) {
        //解析mySpring.xml文件，然后实例化Bean，将bean存放到singletonObjects集合当中
        //这是dom4j解析xml文件的核心对象
        SAXReader reader = new SAXReader();
        //获取一个输入流，指向配置文件(只适合在类路径下加载资源)
        InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
        try {
            //读文件，得到文档对象
            Document document = reader.read(in);
            //获取所有的同名bean标签
            List<Node> nodes = document.selectNodes("//bean");
            //遍历bean标签
            nodes.forEach(node -> {
                try {
                    //向下转型的目的是为了使用Element接口里更加丰富的方法
                    Element beanElt = (Element) node;
                    //获取bean标签中的id属性
                    String id = beanElt.attributeValue("id");
                    //获取Class属性
                    String className = beanElt.attributeValue("class");
                    logger.info("beanName=" + id);
                    logger.info("beanClassName=" + className);
                    //通过反射机制创建对象，将其放到Map集合中，提前曝光
                    //获取Class
                    Class<?> aClass = Class.forName(className);
                    //获取无参构造方法并创建类实例对象
                    Object bean = aClass.getDeclaredConstructor().newInstance();
                    //将bean曝光放入到Map集合
                    singletonObjects.put(id, bean);
                    //记录日志
                    logger.info(singletonObjects.toString());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });

            //再次重新把所有的bean标签遍历一遍，这一次主要是给对象属性赋值
            nodes.forEach(node -> {
                try {
                    Element beanElt = (Element) node;
                    //获取id
                    String id = beanElt.attributeValue("id");
                    //获取className
                    String className = beanElt.attributeValue("class");
                    //获取Class对象
                    Class<?> aClass = Class.forName(className);
                    //获取该bean标签下所有的属性property标签
                    List<Element> properties = beanElt.elements("property");
                    //遍历所有的属性标签
                    properties.forEach(property -> {
                        //获取属性名
                        String propertyName = property.attributeValue("name");
                        try {
                            //通过属性名获取属性类型
                            Field field = aClass.getDeclaredField(propertyName);
                            logger.info("属性名：" + propertyName);
                            //获取set方法名(把第一个字母取大写之后跟上剩余的方法名)
                            String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
                            //获取set方法
                            Method setMethod = aClass.getDeclaredMethod(setMethodName, field.getType());
                            //获取具体的值
                            String value = property.attributeValue("value");
                            Object actualValue = null; //新建一个真值参数作为传入方法的参数
                            String ref = property.attributeValue("ref");
                            //调用set方法(第二个参数我们要传入具体的值，但是值有可能是value形式也有可能是ref形式)
                            if(value != null){
                                //说明这个值是简单类型
                                //mySpring框架声明：只支持如下类型为简单类型
                                //byte, short, int, long, float, double, boolean, char
                                //Byte, Short, Integer, Long, Double, Float, Boolean, Character
                                //String
                                //获取简单类型即去除包名
                                String propertyTypeSimpleName = field.getType().getSimpleName();
                                switch (propertyTypeSimpleName){
                                    case "byte":
                                        actualValue = Byte.parseByte(value);
                                        break;
                                    case "short":
                                        actualValue = Short.parseShort(value);
                                        break;
                                    case "int":
                                        actualValue = Integer.parseInt(value);
                                        break;
                                    case "long":
                                        actualValue = Long.parseLong(value);
                                        break;
                                    case "float":
                                        actualValue = Float.parseFloat(value);
                                        break;
                                    case "double":
                                        actualValue = Double.parseDouble(value);
                                        break;
                                    case "boolean":
                                        actualValue = Boolean.parseBoolean(value);
                                        break;
                                    case "char":
                                        actualValue = value.charAt(0);
                                        break;
                                    case "Byte":
                                        actualValue = Byte.valueOf(value);
                                        break;
                                    case "Short":
                                        actualValue = Short.valueOf(value);
                                        break;
                                    case "Integer":
                                        actualValue = Integer.valueOf(value);
                                        break;
                                    case "Long":
                                        actualValue = Long.valueOf(value);
                                        break;
                                    case "Float":
                                        actualValue = Float.valueOf(value);
                                        break;
                                    case "Double":
                                        actualValue = Double.valueOf(value);
                                        break;
                                    case "Boolean":
                                        actualValue = Boolean.valueOf(value);
                                        break;
                                    case "Character":
                                        actualValue = value.charAt(0);
                                        break;
                                    case "String":
                                        actualValue = value;
                                        break;
                                }
                                setMethod.invoke(singletonObjects.get(id), actualValue);
                            }
                            if(ref != null){
                                //说明这个值是非简单类型
                                //ref代表的是另一个bean的id，集合中已经集成了所有的bean对象，因此能够获取到另一个bean对象并作为参数返回
                                setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
                            }
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Object getBean(String beanName) {
        return singletonObjects.get(beanName);
    }
}