摘要：簡單介紹模塊和模塊是框架的基礎部分，提供控制反轉和依賴注入特性。

Spring Framework簡單介紹

Core Container模塊:Core 和 Beans 模塊是框架的基礎部分，提供 IoC （控制反轉）和 DI（依賴注入）特性。 Context構建于Core 和 Bean 之上，提供了一個BeanFactory來訪問應用組件，添加了國際化（例如資源綁定）、事件傳播、資源加載等。SpEL提供了強大的表達式語言。

Data Access/Integration模塊：JDBC提供了一個JDBC抽象層，ORM對象關系映射如：JPA，XOM提供了一個ObjectXML映射關系，JMS提供了生產消息和消費消息的功能，Transactions：提供了編程和聲明性的事務管理，這些事務類必須實現特定的接口。

Web模塊：提供了面向Web的特性，比如Spring Mvc，使用servlet listeners初始化IoC容器以及一個面向Web的應用上下文，典型的父子容器關系。

Aop模塊：Aspects模塊提供了對AspectJ集成的支持。Instrumentation模塊提供了class instrumentation支持和classloader實現，動態字節碼插樁。

Test模塊：Test模塊支持使用Junit等對Spring組件進行測試

Ioc的核心思想以及常用注解和應用

Ioc的核心思想：資源組件不由使用方管理，而由不使用資源的第三方管理，這可以帶來很多好處。第一，資源集中管理，實現資源的可配置和易管理。第二，降低了使用資源雙方的依賴程度，也就是我們說的耦合度

常用的注解：

@Configuration 相對于配置文件中的
@Bean 相對于配置文件中的
@CompentScan 包掃描
@Scope 配置Bean的作用域
@Lazy 是否開啟懶加載
@Conditional 條件注解 spring boot中經常用到
@Import 導入組件
......

應用：

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.beans.factory.annotation.Autowired;
    
   
    public class PrincipleAspect {
        @Autowired
        private PrincipleLog principleLog;
    
        /*public PrincipleLog getPrincipleLog() {
            return principleLog;
        }
    
        public void setPrincipleLog(PrincipleLog principleLog) {
            this.principleLog = principleLog;
        }*/
    }

    package com.toby.ioc.iocprinciple;
    
    public class PrincipleBean {
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.beans.factory.annotation.Autowire;
    import org.springframework.context.annotation.*;
    
    @Configuration
    @ComponentScan(basePackages = {"com.toby.ioc.iocprinciple"})
    //@ImportResource("classpath:Beans.xml")
    @Import(PrincipleService.class)
    public class PrincipleConfig {
        @Bean
        public PrincipleBean principleBean(){
            return new PrincipleBean();
        }
    
        //@Bean(autowire = Autowire.BY_TYPE)
        @Bean
        public PrincipleAspect principleAspect(){
            return new PrincipleAspect();
        }
    
        @Bean
        @Primary
        public PrincipleLog principleLog(){
            return new PrincipleLog();
        }
    
        @Bean
        public PrincipleLog principleLog2(){
            return new PrincipleLog();
        }
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class PrincipleController {
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class PrincipleDao {
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @desc: 循環依賴
     * @author: toby
     */
    @Component
    public class PrincipleInstanceA {
        @Autowired
        private PrincipleInstanceB instanceB;
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @desc: 循環依賴
     * @author: toby
     */
    @Component
    public class PrincipleInstanceB {
        @Autowired
        private PrincipleInstanceA instanceA;
    }

    package com.toby.ioc.iocprinciple;
    
    /**
     * @desc:
     * @author: toby
     */
    public class PrincipleLog {
    }

    package com.toby.ioc.iocprinciple;
    
    /**
     * @desc:
     * @author: toby
     */
    public class PrincipleService {
    }

    package com.toby.ioc.iocprinciple;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /**
     * @desc: ioc原理解析 啟動
     * @author: toby
     */
    public class PrincipleMain {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PrincipleConfig.class);
            /*for (String beanDefinitionName : context.getBeanDefinitionNames()) {
                System.out.println("bean定義名稱:" + beanDefinitionName);
            }*/
            PrincipleAspect principleAspect = context.getBean(PrincipleAspect.class);
            context.close();
            System.out.println(principleAspect);
        }
    }

完整的代碼請見：spring

getBean的源碼解析

beanfactory的類繼承圖：

首先創建org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class...)

    public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        //主要的作用往容器中注冊系統級別的處理器，為處理我們自定義的配置類準備，以及初始化classpath下的bean定義掃描
        this();
        //注冊我們自定義的配置類
        register(annotatedClasses);
        //Ioc容器刷新12大步
        refresh();
   }

org.springframework.context.support.AbstractApplicationContext#refresh 12大步

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            //1:準備刷新上下文環境
            prepareRefresh();

            //2:獲取初始化Bean工廠
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            //3:對bean工廠進行填充屬性
            prepareBeanFactory(beanFactory);
            try {
                //4：Spring開放接口 留給子類去實現該接口
                postProcessBeanFactory(beanFactory);

                //:5：調用我們的bean工廠的后置處理器
                invokeBeanFactoryPostProcessors(beanFactory);

                // 6：注冊我們bean后置處理器
                registerBeanPostProcessors(beanFactory);

                // 7：初始化國際化資源處理器
                initMessageSource();

                //8：初始化事件多播器
                initApplicationEventMulticaster();

                //9：// 這個方法同樣也是留個子類實現的springboot也是從這個方法進行啟動tomcat的.
                onRefresh();

                //10：把我們的事件監聽器注冊到多播器上
                registerListeners();

                //11：實例化所有的非懶加載的單實例bean
                finishBeanFactoryInitialization(beanFactory);

                //12：最后刷新容器 發布刷新事件(Spring cloud eureka也是從這里啟動的)
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset "active" flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring"s core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

第11步：實例化所有的非懶加載的單實例bean
org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
                @Override
                public String resolveStringValue(String strVal) {
                    return getEnvironment().resolvePlaceholders(strVal);
                }
            });
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        //凍結所有的bean定義
        beanFactory.freezeConfiguration();
        
        //實例化剩余的非懶加載的單實例bean
        beanFactory.preInstantiateSingletons();
    }

實例化剩余的非懶加載的單實例bean：

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Pre-instantiating singletons in " + this);
        }

        // 獲取容器中所有beanName
        List beanNames = new ArrayList(this.beanDefinitionNames);

        //觸發實例化所有的非懶加載的單實例bean
        for (String beanName : beanNames) {
            //合并bean定義
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //非抽象，單實例，非懶加載
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //是否工廠bean，是要獲取factorybean的getObject方法
                if (isFactoryBean(beanName)) {
                    //factorybean的bean那么前面加了一個FACTORY_BEAN_PREFIX就是&
                    final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        //調用getBean流程
                        getBean(beanName);
                    }
                }
                else {//非工廠bean
                    //調用getBean流程
                    getBean(beanName);
                }
            }
        }

        //觸發初始化之后的回調，到這里所有的bean都存放在了單例緩沖池中了
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction