深入剖析Spring(五):IOC核心思想(代码篇)

我会带着你远行 2023-07-19 12:19 18阅读 0赞

> 在上一篇文章中，我们粗略的对Spring源码IOC这块过了一遍，那么这篇文章来简单写一个IOC的过程。由于理论性的东西都在上一篇解释过了，这篇咱就直接在代码中理解。

#### 一、准备工作 ####

##### 1.1本文所用到的依赖包: #####

<dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.12</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>4.3.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>2.5</version>
            </dependency>

##### 1.2 web.xml文件 #####

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
        <display-name>MVC Web Application</display-name>
    
        <servlet>
            <servlet-name>CcMvc</servlet-name>
            
            <servlet-class>com.ccc.spring2.webmvc.XHDispatcherServlet</servlet-class>
            <init-param>
                
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:application.properties</param-value>
            </init-param>
            
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            
            <servlet-name>CcMvc</servlet-name>
            <url-pattern>/*</url-pattern>
        </servlet-mapping>
    </web-app>

##### 1.3 建立项目结构 #####

我们模仿spring的项目结构

###### 1.3.1 创建BeanFactory接口 ######

在包beans下创建：

/** * @author chenxh * @date 2020/3/23 20:28 * @Description: 单例工厂顶层 * @modify: * @modifyDate: * @Description: */
    public interface XHBeanFactory { 
        /** * 根据beanName从IOC容器中获取一个实例Bean * spring中使用单例有利于管理和维护 * */
        Object getBean(String beanName) throws Exception;
    
        Object getBean(Class<?> beanClass) throws Exception;
    
    }

##### 1.3.2 创建BeanDefinition #####

在之前说道过在Spring容器启动的过程中，会将Bean解析成BeanDefinition结构。因此我们也创建一个，模仿spring的包名创建一个config包：

@Data
    public class XHBeanDefinition { 
    
        private String beanClassName; //全包名
        private boolean isLazyInit = false; //是否懒加载
        private String factoryBeanName; //类名首字母小写
        private boolean isSingleton = true; //是否单例
    }

##### 1.3.3 BeanDefinitionReader #####

这个方法主要作用是解析配置文件并将其封装成BeanDefinition对象供IOC操作，此方法在上几篇文章MVC中写过，这里就不在解释了。

package com.ccc.spring2.beans.support;
    
    import com.ccc.spring2.beans.config.XHBeanDefinition;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Properties;
    
    /** * 加载配置文件的类 */
    public class XHBeanDefinitionReader { 
    
        private Properties config = new Properties();
        //定义配置文件,暂时写死
        private final String SCAN_PACKAGE = "scanPackage";
        //存储所有的类名
        private List<String> registyBeanClasses = new ArrayList<String>();  //全包名
    
        public XHBeanDefinitionReader(String... locations) { 
            //通过URL定位找到对应的文件，转为文件流读取
            try (InputStream is = this.getClass().getClassLoader().getResourceAsStream(locations[0].replace("classpath:", ""))) { 
                config.load(is);
            } catch (IOException e) { 
                e.printStackTrace();
            }
            //进行扫描
            doScanner(config.getProperty(SCAN_PACKAGE));
        }
    
        private void doScanner(String scanPackage) { 
            //转换为文件路径，实际上就是把.替换为/就OK了
            URL url = this.getClass().getResource("/" + scanPackage.replaceAll("\\.","/"));
            File classPath = new File(url.getFile());
            for (File file : classPath.listFiles()) { 
                if (file.isDirectory()) { 
                    doScanner(scanPackage + "." + file.getName());
                } else { 
                    if (!file.getName().endsWith(".class")) { 
                        continue;
                    }
                    String className = (scanPackage + "." + file.getName().replace(".class", ""));
                    registyBeanClasses.add(className);
                }
            }
    
        }
    
        public Properties getConfig() { 
            return this.config;
        }
    
        //扫描配置信息并内部封装成XHBeanDefinition对象,便于IOC操作
        public List<XHBeanDefinition> loadBeanDefinitions(String... locations) { 
            List<XHBeanDefinition> result = new ArrayList<XHBeanDefinition>();
            try { 
                System.out.println("registyBeanClasses:"+registyBeanClasses);
                for (String className : registyBeanClasses) { 
                    Class<?> beanClass = Class.forName(className);
                    //如果是一个接口，是不能实例化的
                    //用它实现类来实例化
                    if(beanClass.isInterface()) {  continue; }
    
                    //beanName有三种情况:
                    //1、默认是类名首字母小写
                    //2、自定义名字
                    //3、接口注入
                    result.add(doCreateBeanDefinition(toLowerFirstCase(beanClass.getSimpleName()),beanClass.getName()));
                    result.add(doCreateBeanDefinition(beanClass.getName(),beanClass.getName()));
                    Class<?> [] interfaces = beanClass.getInterfaces();
                    for (Class<?> i : interfaces) { 
                        //如果是多个实现类，只能覆盖
                        //为什么？因为Spring没那么智能，就是这么傻
                        //这个时候，可以自定义名字
                        result.add(doCreateBeanDefinition(i.getName(),beanClass.getName()));
                    }
    
                }
            }catch (Exception e){ 
                e.printStackTrace();
            }
            return result;
        }
    
        //把配置信息解析成BeanDefinition
        //把每一个配信息解析成一个BeanDefinition
        private XHBeanDefinition doCreateBeanDefinition(String factoryBeanName,String beanClassName){ 
            XHBeanDefinition beanDefinition = new XHBeanDefinition();
            beanDefinition.setBeanClassName(beanClassName);
            beanDefinition.setFactoryBeanName(factoryBeanName);
            return beanDefinition;
        }
    
        /** * 首字母小写 */
        private String toLowerFirstCase(String simpleName) { 
            char [] chars = simpleName.toCharArray();
            chars[0] += (1<<5);
            return String.valueOf(chars);
        }
    }

##### 1.3.4 BeanWrapper #####

BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器.在包beans下：

public class XHBeanWrapper { 
    
        private Object wrappedInstance; //类名，首字母小写
        private Class<?> wrappedClass; //对象
    
        public XHBeanWrapper(Object wrappedInstance){ 
            this.wrappedInstance = wrappedInstance;
        }
    
        public Object getWrappedInstance(){ 
            return this.wrappedInstance;
        }
    
        // 返回代理以后的Class
        // 可能会是这个 $Proxy0
        public Class<?> getWrappedClass(){ 
            return this.wrappedInstance.getClass();
        }
    }

##### 1.3.5 IOC容器AbstractApplicationContext #####

创建包名context在子包support下创建（support包名的意思在java中大多数是扩展的意思。）  
在上篇文章中提到过IOC初始化真正的逻辑是在refresh() 中，而该又是实际上又是一个模板方法，只是规定了IOC启动的流程，具体的逻辑还是由其子类来实现的。

public abstract class XHAbstractApplicationContext { 
        //规范方法,提供重写
        public void refresh() throws Exception { };
    }

##### 1.3.6 DefaultListableBeanFactory #####

是否还记得这个类，在这稍微解释一下spring中BeanFactory定义了一系列规范都由子类去实现，例如表示可序列化的Bean，有继承关系的bean等等，这些Bean在spring中都是分开管理的而DefaultListableBeanFactory这个类就是这些子类最终的实现类。也就是这些类最终都由它来实现了。  
在这里我们简单的定义一下。理解一下它的思想：在beans包下创建support

//我们简单就实现一个IOC父类
    public class XHDefaultListableBeanFactory extends XHAbstractApplicationContext { 
    
         //存储注册信息的BeanDefinition,伪IOC容器 //key是类名小写,value是beanDefinition对象
         protected final Map<String, XHBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, XHBeanDefinition>();
    }

##### 1.3.7 ApplicationContext #####

这个应该不陌生了。

public class XHApplicationContext extends XHDefaultListableBeanFactory implements XHBeanFactory { 
    	//配置文件
        private String[] configLocations;
        //加载配置文件的类
        private XHBeanDefinitionReader reader;
        //单例IOC容器
        private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
        //通用IOC容器
        private Map<String, XHBeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();
    
        public XHApplicationContext(String... configLocations) throws Exception { 
            this.configLocations = configLocations;
            refresh();
        }
        /** * 重写AbstractApplicationContext的refresh方法 * 此方法是一个模板方法，规定了IOC容器的运行流程， * 调用的是父类AbstractApplicationContext 的方法. * 真正的载入也是从这个时候开始的。 */
         
        @Override
        public void refresh() throws Exception { 
            //IOC
            //1.定位,找到配置文件
            reader = new XHBeanDefinitionReader(this.configLocations);
    
            //2.加载配置文件，扫描相关的类,把它们封装成BeanDefinition
            List<XHBeanDefinition> beanDefinitions = reader.loadBeanDefinitions();
    
            //3.注册，把配置信息放到容器里(伪IOC容器)
            doRegisterBeanDefinition(beanDefinitions);
    
            //4.把非懒加载的类提前初始化
            doAutowired();
        }
    }

手动创建以上方法。到此准备工作结束了。

#### 2. 填坑 ####

既然我们主路拉通了，那么现在就开始来填坑。  
关注refresh()这个方法是IOC容器初始化的入口。其实在之前的文章中就讲过这个过程。在这里1、2两步就不说啦，代码也贴出来了也注释啦，有兴趣的朋友可以去看看小编这个专栏下的MVC篇。里面提到了这些。

##### 2.1 doRegisterBeanDefinition(beanDefinitions) #####

此方法将BeanDefinitionReader对象解析出来对象进行迭代并存放到Map中。

private void doRegisterBeanDefinition(List<XHBeanDefinition> beanDefinitions) { 
            //IOC加载
            for (XHBeanDefinition beanDefinition : beanDefinitions) { 
                //父类XHDefaultListableBeanFactory中定义的map。这个Map不是真正意义上的IOC容器
                super.beanDefinitionMap.put(beanDefinition.getFactoryBeanName(), beanDefinition);
            }
        }

##### 2.2 doAutowired() #####

遍历上一步中存入Map中的集合，并判断对象中isLazyInit属性是否为懒加载，如果不是懒加载的就进行getBean（）DI注入操作。

//处理非延时加载
        private void doAutowired() throws Exception { 
            //遍历定位
            for (Map.Entry<String, XHBeanDefinition> beanDefinitionEntry : super.beanDefinitionMap.entrySet()) { 
                String beanName = beanDefinitionEntry.getKey();
                if (!beanDefinitionEntry.getValue().isLazyInit()) { 
                    getBean(beanName);
                }
            }
        }

IOC的简单步骤到此就介绍的差不多了，我们发现不管是之前MVC中介绍的，还是本文章介绍的内容，我们都能发现Spring在处理过程中，都是一步步去解析的，例如之前在解析配置文件的时候，会先加载->在找到所有class类->在判断是否@Service、@Controller这些类注解->在判断是否@Autowried等注解。

对于IOC 整理就以上这些就介绍这么多，如果发现有补充的地方，我会继续添加，同时希望各位看过的伙伴们如果发现了问题能够及时批评指正，在此感谢。下一篇我会记录DI的过程。

上一篇:[深入剖析Spring(四):IOC核心思想(源码分析篇)][Spring_IOC]

[Spring_IOC]: https://blog.csdn.net/qq_40409260/article/details/105110956