自定义spring框架IOC功能

我是西瓜王

已于 2023-06-23 19:26:19 修改

阅读量179

点赞数

分类专栏： spring框架笔记文章标签： spring java 数据库

于 2023-05-21 13:22:46 首次发布

本文链接：https://blog.csdn.net/weixin_51262054/article/details/130765279

版权

笔记同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

spring框架

9 篇文章 0 订阅

订阅专栏

1 spring框架的基本使用

1.创建三层架构：controller表示层、service服务层、dao持久层

2.编写controller表示层、service服务层、dao持久层

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

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {  //set方法注入
        this.userDao = userDao;
    }

    @Override
    public void add() {
        System.out.println("UserService");
        userDao.add();
    }
}

public class UserController {
    public static void main(String[] args) {
        //创建spring容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //从容器对象中获取userService对象
        UserService userService = applicationContext.getBean("userService", UserService.class);

        userService.add();
    }
}

3.编写applicationContext.xml（名字随便写）容器配置文件

前面的是命名空间（防止标签重名）

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <bean id="userDao" class="org.example.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="org.example.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

2 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进行交互。

BeanFactory方法获取bean（用时才实例化对象）

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
UserService userService = beanFactory.getBean("userService", UserService.class);

userService.add();

ApplicationContext方法获取bean（创建容器对象时就实例化对象）

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userService", UserService.class);

userService.add();

3 bean概述

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

spring中bean用于对一个类进行封装。

为什么Bean如此重要呢?

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

4 Spring IOC相关接口分析

4.1 BeanFactory解析

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

其中，BeanFactory作为最顶层的一个接口，定义了Ioc容器的基本功能规范，BeanFactoy有三个重要的子接口:ListableBeanFactory、HierarchicalBeanFactory和AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口。

那么为何要定义这么多层次的接口呢?
每个接口都有它的使用场合，主要是为了区分在spring内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，

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

这三个接口共同定义了Bean的集合、Bean之间的关系及Bean行为。最基本的Ioc容器接口是BeanEactory

在BeanFactory里只对Ioc容器的基本行为做了定义，根本不关心你的Bean是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。
BeanFactory有一个很重要的子接口，就是ApplicationContext接口，该接口主要来规范容器中的bean对象是非延时加载，即在创建容器对象的时候就对象bean进行初始化，并存储到一个容器中。

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

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

4.2 BeanDefinition解析

Spring Ioc容器管理我们定义的各种Bean对象及其相互关系，而Bean对象在spring实现中是以BeanDefinition来描述的

BeanDefinition接口主要是用来描述Bean，存储Bean的相关信息，主要包括：Bean的属性、是否单例、延迟加载、Bean的名称、构造方法等。

4.3 BeanDefinitionReader解析

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

源码：

public interface BeanDefinitionReader {
    //获取注册表
    BeanDefinitionRegistry getRegistry();

    @Nullable
    ResourceLoader getResourceLoader();

    @Nullable
    ClassLoader getBeanClassLoader();

    BeanNameGenerator getBeanNameGenerator();

    //指定方式加载bean
    int loadBeanDefinitions(Resource var1) throws BeanDefinitionStoreException;

    int loadBeanDefinitions(Resource... var1) throws BeanDefinitionStoreException;

    int loadBeanDefinitions(String var1) throws BeanDefinitionStoreException;

    int loadBeanDefinitions(String... var1) throws BeanDefinitionStoreException;
}

4.4 BeanDefinitionRegistry 解析

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

public interface BeanDefinitionRegistry extends AliasRegistry {
    //往注册表中注册bean
    void registerBeanDefinition(String var1, BeanDefinition var2) throws BeanDefinitionStoreException;

    //移除bean
    void removeBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

    //获取bean
    BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
    
    //判断是否包含该bean
    boolean containsBeanDefinition(String var1);

    //获取所以bean名称
    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();

    boolean isBeanNameInUse(String var1);
}

实现类中都定义了map来注册bean

private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories;

4.5 创建容器

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

5 自定义Spring IOC

这里主要实现xml方式注册bean。

5.1 定义bean相关的pojo类

<beans>
    <bean id="userDao" class="org.example.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="org.example.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

我们想要把这些类注册到spring容器过程中，肯定要把它们封装成bean对象进行处理。

5.1.1 PropertyValue类

用来封装bean标签下的property标签的属性

/**
 * 用来封装bean标签下的property标签的属性
 * name属性
 * ref属性
 * value属性：给基本属性及String类型赋值
 */
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;
    }


}

5.1.2 MutablePropertyValues类

一个bean标签下可能有多个property

/**
 * 用户存储和管理多个PropertyValue对象
 */
public class MutablePropertyValues implements Iterable<PropertyValue>{
    //定义list集合对象，用来存储PropertyValue对象
    private final List<PropertyValue> propertyValueList;

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

    public MutablePropertyValues(List<PropertyValue> propertyValueList) {
        if (propertyValueList == null){
            this.propertyValueList = new ArrayList<PropertyValue>();
        }else {
            this.propertyValueList = propertyValueList;
        }
    }

    //获取所有的PropertyValue对象，以数组形式返回
    public PropertyValue[] getPropertyValues(){
        return propertyValueList.toArray(new PropertyValue[0]);
    }

    //根据name属性值获取PropertyValue对象
    public PropertyValue getPropertyValue(String propertyName){
        for (PropertyValue propertyValue : propertyValueList) {
            if (propertyValue.getName().equals(propertyName)){
                return propertyValue;
            }
        }
        return null;
    }

    //判断集合是否为空
    public boolean isEmpty(){
        return propertyValueList.isEmpty();
    }

    //添加PropertyValue对象
    public MutablePropertyValues addPropertyValue(PropertyValue pv){
        //判断集合中存储的PropertyValue对象是否和传递进来的重复了，如果重复了，则进行覆盖
        for (int i = 0; i < propertyValueList.size(); i++) {
            PropertyValue currentPv = propertyValueList.get(i);
            if (currentPv.getName().equals(pv.getName())){
                propertyValueList.set(i, pv);
                return this;  //目的是实现链式编程
            }
        }
        this.propertyValueList.add(pv);
        return this;
    }

    //判断是否有指定name值的PropertyValue对象
    public boolean contains(String propertyName){
        return getPropertyValue(propertyName) != null;
    }

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

}

5.1.3 BeanDefinition类

用来封装bean标签数据

/**
 * 用来封装bean标签数据
 * id属性
 * class属性
 * property子标签属性
 */
public class BeanDefinition {
    private String id;
    private String className;
    private MutablePropertyValues propertyValues;

    public BeanDefinition() {
        this.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 MutablePropertyValues getPropertyValues() {
        return propertyValues;
    }

    public void setPropertyValues(MutablePropertyValues propertyValues) {
        this.propertyValues = propertyValues;
    }
}

5.2 定义注册表相关类

5.2.1 BeanDefinitionRegistry接口

定义功能规范：

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

/**
 * 注册表
 */
public interface BeanDefinitionRegistry {

    //往注册表中注册bean
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    //移除bean
    void removeBeanDefinition(String beanName) throws Exception;

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

    //判断是否包含该bean
    boolean containsBeanDefinition(String beanName);

    //获取所以bean名称
    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();
}

5.2.2 SimpleBeanDefinitionRegistry类

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

/**
 * 注册表接口的子实现类
 */
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry{
    //定义一个容器，用来存储BeanDefinition对象
    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 String[] getBeanDefinitionNames() {
        return beanDefinitionMap.keySet().toArray(new String[0]);
    }

    @Override
    public int getBeanDefinitionCount() {
        return beanDefinitionMap.size();
    }
}

5.3 解析器相关类

5.3.1 BeanDefinitionReader接口

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

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

/**
 * 用来解析配置文件，接口定义规范
 */
public interface BeanDefinitionReader {
    //获取注册表对象
    BeanDefinitionRegistry getRegistry();

    //加载配置文件并在注册表中进行注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

5.3.2 XmlBeanDefinitionReader类

XmlBeanDefinitionReader类是专门用来解析xml配置文件的。

/**
 * 针对xml配置文件进行解析的类
 */
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 {
        //使用dom4j进行xml文件的解析
        SAXReader reader = new SAXReader();
        InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
        Document document = reader.read(is);
        //根据Document获取根标签对象（beans）
        Element rootElement = document.getRootElement();
        //获取根标签下的所有bean标签对象
        List<Element> beanElements = rootElement.elements("bean");
        for (Element beanElement : beanElements) {
            //获取id属性
            String id = beanElement.attributeValue("id");
            //获取class属性
            String className = beanElement.attributeValue("class");
            //将id属性和class属性封装到BeanDefinition对象中
            //1.创建BeanDefinition
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            //存储多个PropertyValue的容器
            MutablePropertyValues propertyValues = new MutablePropertyValues();

            //获取bean标签下的所有的property标签对象
            List<Element> propertyElements = beanElement.elements("property");
            for (Element propertyElement : propertyElements) {
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");

                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                propertyValues.addPropertyValue(propertyValue);
            }

            beanDefinition.setPropertyValues(propertyValues);

            //将beanDefinition注册到注册表中
            registry.registerBeanDefinition(id,beanDefinition);
        }
    }
}

5.4 IOC容器相关类

核心部分

5.4.1 BeanFactory接口

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

/**
 * IOC容器父接口
 */
public interface BeanFactory {

    Object getBean(String name) throws Exception;

    <T>T getBean(String name, Class<? extends T> clazz) throws Exception;
}

5.4.2 ApplicationContext接口

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

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

/**
 * 定义非延时加载功能
 */
public interface ApplicationContext extends BeanFactory {

    void refresh() throws Exception;
}

5.4.3 AbstractApplicationContext抽象类

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

/**
 * ApplicationContext接口的子实现类，用于立即加载
 */
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 {
        //加载BeanDefinition对象
        beanDefinitionReader.loadBeanDefinitions(configLocation);
        //初始化bean
        finishBeanInitialization();
    }

    //初始化bean
    private void finishBeanInitialization() throws Exception {
        //获取注册表对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();

        //获取BeanDefinition对象
        String[] beanNames = registry.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            //进行bean的初始化
            getBean(beanName);
        }
    }
}

5.4.4 ClassPathXmlApplicationContext类

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

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

/**
 * IOC容器具体的子实现类
 * 用于加载类路径下的XML格式的配置文件
 */
public class ClassPathXmlApplicationContext extends AbstractApplicationContext{
    public ClassPathXmlApplicationContext(String configLocation) {
        this.configLocation = configLocation;
        //构建解析器对象
        beanDefinitionReader = new XmlBeanDefinitionReader();
        try {
            this.refresh();
        } catch (Exception e){

        }

    }

    //根据bean对象的名称获取bean对象
    @Override
    public Object getBean(String name) throws Exception {
        //判断对象容器中是否包含指定名称的bean对象，如果包含直接返回，否则需自行创建
        Object obj = singletonObjects.get(name);
        if (obj != null){
            return obj;
        }
        //获取beanDefinition对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        //获取bean信息中的className
        String className = beanDefinition.getClassName();
        //通过反射创建对象
        Class<?> clazz = Class.forName(className);
        Object beanObj = clazz.newInstance();

        //进行依赖注入
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        for (PropertyValue propertyValue : propertyValues) {
            //获取name属性值
            String propertyName = propertyValue.getName();
            //获取value属性
            String value = propertyValue.getValue();
            //获取ref属性
            String ref = propertyValue.getRef();

            if (ref != null && !"".equals(ref)){
                //获取依赖的bean对象
                Object bean = getBean(ref);
                //拼接方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
                //获取所以的方法对象
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (method.getName().equals(methodName)){
                        //执行改setter方法
                        method.invoke(beanObj,bean);
                    }
                }
            }

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

        //在返回beanObj对象之前，将该对象存储到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);
    }
}

5.5 总结

目的：使用xml配置文件方式注册bean，和set方式注入 bean。

核心实现技术：反射

过程：

创建ClassPathXmlApplicationContext对象时通过构造方法传入配置文件名称
在ClassPathXmlApplicationContext的构造方法中执行了refresh()方法初始化bean（这里就体现了容器中的bean对象是非延时加载）

refresh()里的执行流程是：

执行XmlBeanDefinitionReader解析器的loadBeanDefinitions方法对配置文件进行解析，把一个个的bean封装成BeanDefinition并存储（注册）到SimpleBeanDefinitionRegistry的Map集合中。
从SimpleBeanDefinitionRegistry注册表中拿出所有的bean并遍历执行getBean（beanName）通过反射创建对象，通过反射set注入到成员变量中

使用到的设计模式：

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

spring框架其实使用到了很多设计模式，如AOP使用到了代理模式，选择JDK代理或者CGIB
代理使用到了策略模式，还有适配器模式，装饰者模式，观察者模式等。