(3)spring源碼解析-refresh()方法以前

本文是做者原創,版權歸做者全部.若要轉載,請註明出處.

本文源碼版本5.1.x.話很少說,開始

首先是配置類

@Configuration
@ComponentScan("com.day01")
public class SpringConfig {

}

IndexService

@Service
public class IndexService  {
    
    public IndexService(){
        System.out.println("IndexService  構造方法");
    }

    @PostConstruct
    public void init(){
        System.out.println("IndexService  init方法");
    }


    public void hello(){
        System.out.println("IndexService  hello");
    }
}

測試類

public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(SpringConfig.class);
        //AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(IndexService.class);
        IndexService indexService = (IndexService) applicationContext.getBean("indexService");
        indexService.hello();
        System.out.println(indexService);
    }

第一行點進去

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        //annotatedClasses --->  配置類的class對象
        this();
        register(annotatedClasses);
        refresh();
    }

今天咱們先看refresh()方法以前的源碼

this()調的構造器以下

public AnnotationConfigApplicationContext() {
        /**
         * 父類的構造方法
         * 建立一個讀取註解的Bean定義讀取器
         * 什麼是BeanDefinition
         */
        super();
        this.reader = new AnnotatedBeanDefinitionReader(this);
        //能夠用來掃描包或者類，繼而轉換成BeanDefinition
        //可是實際上咱們掃描包工做不是scanner這個對象來完成的
        //是spring本身new的一個ClassPathBeanDefinitionScanner
        //這裏的scanner僅僅是爲了程序員可以在外部調用AnnotationConfigApplicationContext對象的scan方法
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

/**
     * 這個類顧名思義是一個reader，一個讀取器
     * 讀取什麼呢？仍是顧名思義:AnnotatedBeanDefinition意思是讀取一個被加了註解的BeanDefinition
     * 這個類在構造方法中實例化的
     */
    private final AnnotatedBeanDefinitionReader reader;

    /**
     * 贊成顧名思義，這是一個掃描器，掃描全部加了註解的bean
     *  一樣是在構造方法中被實例化的
     */
    private final ClassPathBeanDefinitionScanner scanner;

 

先看super()父類構造器

public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }

能夠看出初始化beanFactory 爲默認實現DefaultListableBeanFactory

咱們看一下些DefaultListableBeanFactory的屬性和方法

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
      implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

/** Map of bean definition objects, keyed by bean name. */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

/** List of bean definition names, in registration order. */
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

//手動註冊的單例對象的名稱列表，按註冊順序排列
    /** List of names of manually registered singletons, in registration order. */
    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
   return getBean(requiredType, (Object[]) null);
}

@SuppressWarnings("unchecked")
@Override
public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
   Assert.notNull(requiredType, "Required type must not be null");
   Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
   if (resolved == null) {
      throw new NoSuchBeanDefinitionException(requiredType);
   }
   return (T) resolved;
}
}

能夠看出,這是bean工廠的實現類,裏面有存BeanDefinition和beanDefinitionNames 的map和getBean等方法

父類構造器結束,就是實例了一個默認的bean工廠,繼續下一行

this.reader = new AnnotatedBeanDefinitionReader(this);

點進去看源碼

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this(registry, getOrCreateEnvironment(registry));
    }

這裏BeanDefinitionRegistry是一個BeanDefinition註冊器

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

繼續看最後一行

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
        registerAnnotationConfigProcessors(registry, null);
    }

繼續跟進去

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);//AnnotationAwareOrderComparator主要能解析@Order註解和@Priority
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());//ContextAnnotationAutowireCandidateResolver提供處理延遲加載的功能
      }
   }

   //a Set of BeanDefinitionHolders, containing all bean definitions
   //BeanDefinitionHolder是存儲BeanDefinitionName和BeanDefinition的一個數據結構
   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
   //BeanDefinitio的註冊，這裏很重要，須要理解註冊每一個bean的類型,CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME=internalConfigurationAnnotationProcessor
   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      //ConfigurationClassPostProcessor是一個BeanFactory的後置處理器，主要功能是解析加了@Configuration的配置類，還會解析@ComponentScan、@ComponentScans註解掃描的包，以及解析@Import等註解
      //須要注意的是ConfigurationClassPostProcessor的類型是BeanDefinitionRegistryPostProcessor
      //而 BeanDefinitionRegistryPostProcessor 最終實現BeanFactoryPostProcessor這個接口
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   //AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME=internalAutowiredAnnotationProcessor
   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      //AutowiredAnnotationBeanPostProcessor是解析AutoWired註解的BeanPostProcessor
      //AutowiredAnnotationBeanPostProcessor 實現了 MergedBeanDefinitionPostProcessor
      //MergedBeanDefinitionPostProcessor 最終實現了 BeanPostProcessor
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   //COMMON_ANNOTATION_PROCESSOR_BEAN_NAME=internalCommonAnnotationProcessor
   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      //CommonAnnotationBeanPostProcessor支持對@PostConstruct和@PreDestroy註解,以及對@Resource註解的處理
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }
   //PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME=internalPersistenceAnnotationProcessor,跳過,不重要
   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }
   //EVENT_LISTENER_PROCESSOR_BEAN_NAME=internalEventListenerProcessor
   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      //EventListenerMethodProcessor支持事件監聽,不太熟
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }
   //EVENT_LISTENER_FACTORY_BEAN_NAME=internalEventListenerFactory
   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      //DefaultEventListenerFactory不太瞭解,事件監聽相關
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

這裏的BeanDefinitionHolder看下

public class BeanDefinitionHolder implements BeanMetadataElement {

    private final BeanDefinition beanDefinition;

    private final String beanName;

    @Nullable
    private final String[] aliases;
　　//省略
}

能夠認爲:BeanDefinitionHolder是存儲BeanDefinitionName和BeanDefinition的一個數據結構

debug看下最後一行的結果

 

 

 能夠看出,bean工廠已經存在5個BeanDefinition,咱們繼續看下面的源碼

讀取器看完了,掃描器先不看了,咱們看register(annotatedClasses);方法

public void register(Class<?>... annotatedClasses) {
        Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
        this.reader.register(annotatedClasses);//被註解的類
    }

繼續跟下去

public void register(Class<?>... annotatedClasses) {
        for (Class<?> annotatedClass : annotatedClasses) {
            registerBean(annotatedClass);
        }
    }

這裏循環處理全部要處理的annotated類。如:Configuration註解的配置類

public void registerBean(Class<?> annotatedClass) {
        doRegisterBean(annotatedClass, null, null, null);
    }

繼續跟

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

        /**
         * 根據指定的bean建立一個AnnotatedGenericBeanDefinition
         * 這個AnnotatedGenericBeanDefinition能夠理解爲一個數據結構
         * AnnotatedGenericBeanDefinition包含了類的其餘信息,好比一些元信息
         * scope，lazy等等.
         * 此時由於傳入的註解,因此new AnnotatedGenericBeanDefinition
         */
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        /**
         * 判斷這個類是否須要跳過解析
         * 經過代碼能夠知道spring判斷是否跳過解析，主要判斷類有沒有加註解
         */
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }

        abd.setInstanceSupplier(instanceSupplier);
        /**
         * 獲得類的做用域 singleton
         */
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        /**
         * 把類的做用域添加到數據結構結構中
         */
        abd.setScope(scopeMetadata.getScopeName());
        /**
         * 生成類的名字經過beanNameGenerator
         */
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
        /**
         * 處理類當中的通用註解
         * 分析源碼能夠知道他主要處理
         * Lazy DependsOn Primary Role等等註解
         * 處理完成以後processCommonDefinitionAnnotations中依然是把他添加到AnnotatedGenericBeanDefinition數據結構當中
         */
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        if (qualifiers != null) {//qualifiers老是爲null
            for (Class<? extends Annotation> qualifier : qualifiers) {
                //若是配置了@Primary註解，若是加了則做爲首選
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                //懶加載註解
                else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                }
                else {
                    //若是使用了除@Primary和@Lazy之外的其餘註解，則爲該Bean添加一個根據名字自動裝配的限定符
                    //這裏難以理解，後面會詳細介紹
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        //自定義註解
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }

        /**
         * 這個BeanDefinitionHolder也是一個數據結構,這個對象放入了BeanDefinition和beanName
         */
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        /**
         * ScopedProxyMode 這個知識點比較複雜，須要結合web去理解
         * 能夠暫時放一下，等說道springmvc的時候再說
         * 或者看狀況如今說也是同樣的
         */
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        /**
         * 把上述的這個數據結構註冊給registry
         * registy就是AnnotatonConfigApplicationContext
         * AnnotatonConfigApplicationContext在初始化的時候通過調用父類的構造方法
         * 實例化了一個DefaultListableBeanFactory
         * *registerBeanDefinition裏面就是把definitionHolder這個數據結構包含的信息註冊到
         * DefaultListableBeanFactory這個工廠
         */

　　　　　　BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);//關鍵代碼

 }

咱們看最後一行關鍵代碼

public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        // Register bean definition under primary name.
        String beanName = definitionHolder.getBeanName();//獲取beanName
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());//關鍵代碼

        //別名,先不看
        // Register aliases for bean name, if any.
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

仍是跟關鍵代碼

@Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {

        //DefaultListableBeanFactory
        this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
    }

這裏的beanFactory就是前文說的DefaultListableBeanFactory,繼續跟

@Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {

        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");

        if (beanDefinition instanceof AbstractBeanDefinition) {//驗證
            try {
                ((AbstractBeanDefinition) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }
        //這裏beanDefinitionMap是存儲bean的name和.beanDefinition的map結果,此處有5個spring內置的BeanDefinition
        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);//這裏的beanName是配置類的名字,existingDefinition應該爲null
        if (existingDefinition != null) {
            if (!isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
            }
            else if (existingDefinition.getRole() < beanDefinition.getRole()) {
                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
                if (logger.isInfoEnabled()) {
                    logger.info("Overriding user-defined bean definition for bean '" + beanName +
                            "' with a framework-generated bean definition: replacing [" +
                            existingDefinition + "] with [" + beanDefinition + "]");
                }
            }
            else if (!beanDefinition.equals(existingDefinition)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Overriding bean definition for bean '" + beanName +
                            "' with a different definition: replacing [" + existingDefinition +
                            "] with [" + beanDefinition + "]");
                }
            }
            else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Overriding bean definition for bean '" + beanName +
                            "' with an equivalent definition: replacing [" + existingDefinition +
                            "] with [" + beanDefinition + "]");
                }
            }
            this.beanDefinitionMap.put(beanName, beanDefinition);
        }
        else {//進這裏
            if (hasBeanCreationStarted()) {//這裏跳過,不進這裏,先不看
                // Cannot modify startup-time collection elements anymore (for stable iteration)
                synchronized (this.beanDefinitionMap) {
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                    updatedDefinitions.addAll(this.beanDefinitionNames);
                    updatedDefinitions.add(beanName);
                    this.beanDefinitionNames = updatedDefinitions;
                    removeManualSingletonName(beanName);
                }
            }
            else {//關鍵代碼
                // Still in startup registration phase
                //這裏的beanDefinitionMap是一個map,存放beanName,beanDefinition
                this.beanDefinitionMap.put(beanName, beanDefinition);
                //這裏的beanDefinitionNames是一個list,存放beanName
                this.beanDefinitionNames.add(beanName);
                removeManualSingletonName(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }

        if (existingDefinition != null || containsSingleton(beanName)) {
            resetBeanDefinition(beanName);
        }
    }

這裏的關鍵代碼,我標註出來了,就是上面那個bean工廠的默認實現的幾個屬性

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

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

//手動註冊的單例對象的名稱列表，按註冊順序排列
    /** List of names of manually registered singletons, in registration order. */
    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

到這裏register方法就結束了,大概是將咱們的類解析成BeanDefinition,並存在bean工廠的beanDefinitionMap 屬性中,後面就是refresh()方法了,這個方法太複雜,咱們在後面分幾個博客來研究他,先看一下源碼吧

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {

            //準備工做包括設置啓動時間，是否激活標識位，
            // 初始化屬性源(property source)配置
            // Prepare this context for refreshing.
            prepareRefresh();
            //此處的beanFactory就是DefaultListableBeanFactory,有Map<String, BeanDefinition> beanDefinitionMap和List<String> beanDefinitionNames等屬性
            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            //準備工廠
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                //目前是空方法,留給後續擴展
                postProcessBeanFactory(beanFactory);

                //完成掃描和解析(類--->beanDefinition)         beanDefinitionMap
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                //註冊beanPostProcessor
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();
                //初始化應用事件廣播器
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                //實例化全部單例的對象
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                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();
            }
        }
    }

好了,這篇文章到這裏就結束了.謝謝你們的觀看,你們有空的話就幫我點個贊吧
文章中如有錯誤和疏漏之處,還請各位大佬不吝指出