springIOC原理——自己实现一下不就懂了嘛

Posted 2021-06-30 小王子jvm

使用Spring

只需要引入对应的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
</dependencies>

maven自动依赖几个核心包：

测试

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

//service 层
public interface UserService {
    void add();
}
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String username;
    private String password;


    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

    public void add() {
        userDao.add();
        System.out.println("UserService实现类"+username+"=="+password);
    }
}

使用xml配置文件方式，配置如下：

<beans >
    <!--创建userService，依赖注入dao-->
    <bean id="userService" class="com.sheep.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="username" value="sheep"/>
        <property name="password" value="123456"/>
    </bean>

    <!--dao相关的bean-->
    <bean id="userDao" class="com.sheep.dao.impl.UserDaoImpl"/>
</beans>

然后就是controller，用一个main模拟：

public class MainController {
    public static void main(String[] args) throws Exception {
        //创建IOC容器，加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取相应的bean
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

经过测试是可以正常输出内容的。

相关IOC接口源码

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

最顶层接口是一个BeanFactory，定义了IoC容器的基本功能规范。它的实现有很多。每个接口都有它的使用场合，主要是为了区分在Spring内部操作过程中对象的传递和转化，对对象的 数据访问所做的限制。

在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.sheep.dao.impl.UserDaoImpl"></bean>
bean标签还有很多属性：
scope、init-method、destory-method等。

解析id，class这些东西然后封装成一个BeanDefinition，被没有什么特别。

BeanDefinitionReader解析

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

总之这个接口就是规范解析配置的规范，比如像解析xml，就有对应的实现做这个事情。

BeanDefinitionRegistry解析

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

也没有什么特别的，这个接口只不过定义的怎么注册，实现类都会有一个map集合来保存解析出来的东西。

从上面类图可以看到BeanDefinitionRegistry接口的子实现类主要有以下几个： （所谓的注册就是保存解析的东西，这里就是解析出来的东西就是BeanDefinition）

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

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

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

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

创建容器的过程

ClassPathXmlApplicationContext对Bean配置资源的载入是从refresh（）方法开始的。

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

自定义SpringIOC

整个工程的结构如下：

定义bean相关的pojo类

PropertyValue类

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

/**
 * 每一bean可能会引用其他bean，这个用来封装被引用的bean解析后的属性
 * @Description: 封装被引用的bean解析后的属性
 *  name : 引用的名字，也就是放在容器中的key
 *  ref : 引用类型
 *  value : 基本类型的引用
 */
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类

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

/**
 * 一个bean标签可以有多个property子标签，所以再定义一个MutablePropertyValues类，用来存
 * 储并管理多个PropertyValue对象。
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {

    //用一个list集合保存
    private final List<PropertyValue> propertyValueList;

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

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

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

    //通过propertyName获取对应的PropertyValue
    public PropertyValue getPropertyValue(String propertyName){
        for (PropertyValue propertyValue : propertyValueList) {
            if (propertyName.equals(propertyValue.getName())){
                return propertyValue;
            }
        }
        return null;
    }

    //迭代器模式，用于遍历
    public Iterator<PropertyValue> iterator() {
        return propertyValueList.iterator();
    }

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

    //是否已有这个封装的对象
    public boolean contains(String propertyName) {
        return getPropertyValue(propertyName) != null;
    }

    //添加一个propertyValue到容器中,存在的化进行覆盖
    public MutablePropertyValues addPropertyValue(PropertyValue propertyValue){
        for (int i = 0; i < propertyValueList.size(); i++) {
            PropertyValue tmp = this.propertyValueList.get(i);
            if (tmp.getName().equals(propertyValue.getName())){
                //存在就覆盖
                propertyValueList.set(i,new PropertyValue(propertyValue.getName(),
                        propertyValue.getRef(),propertyValue.getValue()));
            }
        }
        this.propertyValueList.add(propertyValue);
        return this;
    }
}

BeanDefinition类

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

/**
 * 解析出来的Bean的配置属性
 */
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 MutablePropertyValues getPropertyValues() {
        return propertyValues;
    }

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

定义注册表相关类

BeanDefinitionRegistry接口

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

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

/**
 * 用于注册保存BeanDefinition
 */
public interface BeanDefinitionRegistry {

    void registryBeanDefinition(String beanName, BeanDefinition beanDefinition);

    void removeBeanDefinition(String beanName) throws Exception;

    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionsName();
}

SimpleBeanDefinitionRegistry类

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

public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {

    //既然是需要保存，就需要用到map
    private final Map<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    //注册这个BeanDefinition到表中
    public void registryBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(beanName,beanDefinition);
    }

    //删除
    public void removeBeanDefinition(String beanName) throws Exception {
        beanDefinitionMap.remove(beanName);
    }

    //获取这个beanDefinition
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        return beanDefinition;
    }

    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

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

    public String[] getBeanDefinitionsName() {
        return  beanDefinitionMap.keySet().toArray(new String[0]);
    }
}

定义解析器相关类

BeanDefinitionReader接口

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

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

/**
 * 解析xml并在封装成BeanDefinition的规范接口
 */
public interface BeanDefinitionReader {
    BeanDefinitionRegistry getBeanDefinitionRegistry();
    void loadBeanDefinitions(String classPath) throws Exception;
}

XmlBeanDefinitionReader类

既然要解析xml文件，解析的包是必不可少的：

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>

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

public class XmlBeanDefinitionReader implements BeanDefinitionReader {

    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
        this.registry = new SimpleBeanDefinitionRegistry();
    }

    public BeanDefinitionRegistry getBeanDefinitionRegistry() {
        return registry;
    }

    /**
     * 加载配置文件，并解析成对应的BeanDefinition
     * @param classPath
     * @throws Exception
     */
    public void loadBeanDefinitions(String classPath) throws Exception {
        //从类路径下加载
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(classPath);
        //利用dom4j解析配置文件
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(is);
        Element rootElement = document.getRootElement();    //也就是Beans标签
        parseBean(rootElement); //解析这个根节点并封装
    }

    /**
     * 利用dom4j进行解析
     * @param rootElement
     */
    private void parseBean(Element rootElement) {
        //获取所有的标签，这里只有bean标签
        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);

            //然后继续解析可能会有的引用依赖，也就是property
            List<Element> list = element.elements("property");
            MutablePropertyValues propertyValues = 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);
                propertyValues.addPropertyValue(propertyValue);
            }
            //将所有的依赖全部注入相应的bean
            beanDefinition.setPropertyValues(propertyValues);
            registry.registryBeanDefinition(id,beanDefinition);
        }
    }
}

IOC容器相关类

BeanFactory接口

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

/**
 * IOC容器的顶级接口，规范怎么获取生产获取Bean，这就是一个典型的工厂模式
 */
public interface BeanFactory {

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

ApplicationContext接口

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

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

public interface ApplicationContext extends BeanFactory {

    void refresh() throws ExceptionspringIOC原理——自己实现一下不就懂了嘛

 springIOC原理——自己实现一下不就懂了嘛
 js的隐式类型转换你懂了嘛   一起来复习一下吧
 js的隐式类型转换你懂了嘛   一起来复习一下吧
 js的隐式类型转换你懂了嘛   一起来复习一下吧
 知道Dubbo性能为什么这么强？看完你就懂了！