Spring 注解学习笔记_容器启动

最新推荐文章于 2021-12-03 14:18:05 发布
最新推荐文章于 2021-12-03 14:18:05 发布
阅读量155 收藏
点赞数
分类专栏： spring 学习 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43415605/article/details/107488627
版权

该系列学习笔记均是笔者通过学习某站雷丰阳老师的相关课程并结合 spring 2.* 版本源码自行整理出来的。如果有叙述不到位或者有误的地方烦请各位读者评论区给予指正，大家共同学习。
同时关于容器启动源码极为重要，未避免笔者水平误导读者，此处给出笔者认为写得很棒的一篇文章

Spring 容器的创建执行逻辑集中在 refresh 函数

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Spring 容器刷新前的预准备工作
      prepareRefresh();

      // 新建一个 beanFactory 并为其设置唯一 id 唯一标识
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 对新建的 beanFactory 进行预处理工作
      prepareBeanFactory(beanFactory);

      try {

         // 依次调用 BeanDefinitionRegistryPostProcessor::postProcessBeanDefinitionRegistry 和 BeanFactoryPostProcessor::postProcessBeanFactory 方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // 向容器中注册 BeanPostProcessor
         registerBeanPostProcessors(beanFactory);

         // 初始化 MessageSource 组件
         initMessageSource();

         // 初始化事件派发器
         initApplicationEventMulticaster();

         // 将项目中的所有 ApplicationListener 注册进入容器
         registerListeners();

         // 初始化所有剩下的单实例 bean
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      } catch (BeansException ex) {}
      finally {}
   }
}
  • prepareRefresh() 进行 Spring 容器刷新前的预准备工作
    protected void prepareRefresh() {
   // 记录容器的启动时间
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);
  
   // 验证 Spring 环境变量中属性的合法性
   getEnvironment().validateRequiredProperties();

   // 存储容器刷新前注册的本地 ApplicationListener
   if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   }
   else {
      // 重置 applicationListeners
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }

   // 新建 set 保存在事件派发器配置完成之前发布的事件
   this.earlyApplicationEvents = new LinkedHashSet<>();
}
  • obtainFreshBeanFactory() 用于获取 BeanFactory
    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return this.beanFactory;
}

    @Override
protected final void refreshBeanFactory() throws IllegalStateException {
   this.beanFactory = new DefaultListableBeanFactory();
   // 为新创建的 beanFactory 设置一个唯一 id
   this.beanFactory.setSerializationId(getId());
}
  • prepareBeanFactory(beanFactory) 对新建的 beanFactory 进行预处理工作
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // 设置 beanFactory 的类加载器、表达式解析器
   beanFactory.setBeanClassLoader(getClassLoader());
   beanFactory.setBeanExpressionResolver(new 
                                         StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

   // 添加 ApplicationContextAwareProcessor implements BeanPostProcessor
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
   // 设置容器中忽略的自动装配接口
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

   // 设置可以自动解析的自动装配 => 可以在任何组件中自动注入
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // 添加 ApplicationListenerDetector implements BeanPostProcessor
   // 用于检测添加到容器中的 Bean 对象是否 instanceof ApplicationListener
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // 注册默认环境 Bean => 可以在任何组件中自动注入
   if (!beanFactory.containsLocalBean("environment")) {
      beanFactory.registerSingleton("environment", getEnvironment());
   }
   if (!beanFactory.containsLocalBean("systemProperties")) {
      beanFactory.registerSingleton("systemProperties", getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean("systemEnvironment")) {
      beanFactory.registerSingleton("systemEnvironment", getEnvironment().getSystemEnvironment());
   }
}
  • invokeBeanFactoryPostProcessors(beanFactory) 依次调用 BeanDefinitionRegistryPostProcessor::postProcessBeanDefinitionRegistry 和 BeanFactoryPostProcessor::postProcessBeanFactory 方法
    public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  
      // 先获取容器中所有 BeanDefinitionRegistryPostProcessor
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         // 优先执行 list(BeanDefinitionRegistryPostProcessor) 中所有继承 PriorityOrdered
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      // 执行 currentRegistryProcessors 集合中所有继承 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor::postProcessBeanDefinitionRegistry 方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      // 将 currentRegistryProcessors 集合清空，进行下一轮反射执行目标方法
      currentRegistryProcessors.clear();

      // 再执行 list(BeanDefinitionRegistryPostProcessor) 中所有继承 Ordered
  
      // 执行 currentRegistryProcessors 集合中所有继承 Ordered 的 BeanDefinitionRegistryPostProcessor::postProcessBeanDefinitionRegistry 方法

      // 最后执行 list(BeanDefinitionRegistryPostProcessor) 中所有未继承上述两种接口
      
      // 执行 currentRegistryProcessors 集合中所有未继承上述两种接口的 BeanDefinitionRegistryPostProcessor::postProcessBeanDefinitionRegistry 方法

   else {}

   // 再获取容器中所有 BeanFactoryPostProcessor
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, Ordered, and the rest.
   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();

   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   // 优先执行 list(BeanFactoryPostProcessor) 中所有继承 PriorityOrdered 的 BeanFactoryPostProcessor::postProcessBeanFactory
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   // 再执行 list(BeanFactoryPostProcessor) 中所有继承 Ordered 的 BeanFactoryPostProcessor::postProcessBeanFactory
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   // 最后执行 list(BeanFactoryPostProcessor) 中所有未继承上述两种接口的 BeanFactoryPostProcessor::postProcessBeanFactory
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}
  • registerBeanPostProcessors(beanFactory) 注册 BeanPostProcessor
    public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   // Separate between BeanPostProcessors that implement PriorityOrdered, Ordered, and the rest.
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
         priorityOrderedPostProcessors.add(pp);
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   // 优先注册 PriorityOrdered 优先级接口的 BeanPostProcessor
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // 再注册 Ordered 接口的 BeanPostProcessor
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // 最后注册没有实现任何优先级接口的 BeanPostProcessors
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   sortPostProcessors(internalPostProcessors, beanFactory);
   // 再将 internalPostProcessors 集合中保存的 MergedBeanDefinitionPostProcessor 进行注册
   registerBeanPostProcessors(beanFactory, internalPostProcessors);
   
   // 注册一个 ApplicationListenerDetector 用于检测 Bean 对象是否 implements ApplicationListener
   // 如果是 applicationContext.addApplicationListener((ApplicationListener<?>) bean)
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
  • initMessageSource() 初始化 MessageSource 组件（用于国际化，消息绑定，消息解析）
    protected void initMessageSource() {
   // 获取之前创建的 beanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 判断容器中是否有 id = "messageSource" 的组件
   if (beanFactory.containsLocalBean("messageSource")) {
      // 存在，则获取 id = "messageSource" class = MessageSource.class 的组件
      this.messageSource = beanFactory.getBean("messageSource", MessageSource.class);
      if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
         HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
         if (hms.getParentMessageSource() == null) {
            hms.setParentMessageSource(getInternalParentMessageSource());
         }
      }
   }
   else {
      // 容器中不存在则新建 DelegatingMessageSource，且注册进 beanFactory => 可以在任何组件注入
      DelegatingMessageSource dms = new DelegatingMessageSource();
      this.messageSource = dms;
      beanFactory.registerSingleton("messageSource", this.messageSource);
   }
}
  • initApplicationEventMulticaster() 初始化事件派发器
    protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 尝试从容器中获取 id = "applicationEventMulticaster" 的事件派发器
   if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
      this.applicationEventMulticaster =
            beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
   }
   else {
      // 获取失败，注入 id = "applicationEventMulticaster" 的事件派发器 
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
   }
}
  • registerListeners() 将项目中的所有 ApplicationListener 注册进入容器
    protected void registerListeners() {

   // 获取容器中所有 ApplicationListener 类型的 Bean 即监听器
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
   for (String listenerBeanName : listenerBeanNames) {
      // 将 ApplicationListener 添加到事件派发器
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // 获取之前保存在事件派发器配置完成之前发布的事件的 set
   Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         // 将这些 event 利用事件派发器发布
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}
  • finishBeanFactoryInitialization(beanFactory) 初始化所有剩下的单实例 bean
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

   // 初始化所有剩下的单实例 bean
   beanFactory.preInstantiateSingletons();
}

    @Override
public void preInstantiateSingletons() throws BeansException {

   // 获取容器中的所有 Bean，依次进行初始化和创建对象
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   for (String beanName : beanNames) {
      // 获取 Bean 的定义信息
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 如果 Bean 对象 非抽象 单实例 非懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         // if (beanInstance instanceof FactoryBean)
         if (isFactoryBean(beanName)) {
            // 通过 "&" + factoryBeanName 获取工厂本身的 Bean
            Object bean = getBean("&" + beanName);
            if (bean instanceof FactoryBean) {
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               else {}
            }
         }
         else {
            // 非工厂 bean 使用 genBean 创建 Bean 对象
            getBean(beanName);
         }
      }
   }

   // 判断容器中的 bean 是否 instanceof SmartInitializingSingleton
   // 如果是，则执行 SmartInitializingSingleton::afterSingletonsInstantiated
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         smartSingleton.afterSingletonsInstantiated();
      }
   }
}

    • getBean(beanName) 创建 Bean 对象

      @Override
public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

      protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   final String beanName = transformedBeanName(name);
   Object bean;

   // 先获取缓存中保存的单实例 Bean
   // 如果能获取到说明这个 Bean之 前被创建过（所有创建过的单实例Bean都会被缓存起来）
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
		  // 获取失败，开始 Bean 的创建过程
      // 首先标记当前 Bean 已经被创建，用于多线程情况
      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
         // 获取 Bean 的定义信息
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

         // 获取当前 Bean 对象的依赖信息，需要先创建 Bean 的依赖 Bean
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            for (String dep : dependsOn) {
               registerDependentBean(dep, beanName);
               try {
                  // 存在依赖 Bean，先创建依赖 Bean 对象
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {}
            }
         }

         // 创建单实例 Bean
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  // 创建单实例 Bean
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {}
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }
      } catch (BeansException ex) 
   }

   // Check if required type matches the type of the actual bean instance.
   if (requiredType != null && !requiredType.isInstance(bean)) {
      try {
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         return convertedBean;
      }
      catch (TypeMismatchException ex) {}
   }
   return (T) bean;
}
      • getSingleton(beanName, () -> { return createBean(beanName, mbd, args) }) 创建 Bean 对象并缓存
        public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   synchronized (this.singletonObjects) {
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         boolean newSingleton = false;
         try {
            // 利用函数式接口 getObject => createBean(beanName, mbd, args) 创建单实例 Bean
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {}
         catch (BeanCreationException ex) {}
         finally {}
         if (newSingleton) {
            // 将创建的 Bean 添加到缓存 singletonObjects 中
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}
      • getObject() => createBean(beanName, mbd, args) 创建单实例 Bean
        @Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

   RootBeanDefinition mbdToUse = mbd;

   try {
      // 利用 InstantiationAwareBeanPostProcessor::postProcessBeforeInstantiation 尝试获取当前 beanName 对应的代理对象
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         // 若存在代理对象直接 return
         return bean;
      }
   }
   catch (Throwable ex) {}

   try {
      // 不存在代理对象，则创建单实例 Bean
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {}
   catch (Throwable ex) {}
}
        • doCreateBean(beanName, mbdToUse, args) 创建单实例 Bean
          protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    // 如果 Bean 对象为单实例
    if (mbd.isSingleton()) {
        // 先尝试从缓存中获取
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 获取失败则执行 Bean 对象构造方法 => 创建 Bean 对象
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 为创建的 Bean 对象进行属性赋值
        populateBean(beanName, mbd, instanceWrapper);
        // 执行 Bean 对象的初始化方法
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {}

    // Register bean as disposable.
    try {
        // 将单实例 Bean 对象加入到 list 中，在容器销毁时会调用这个 list 中所有 Bean 对象的销毁方法
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {}

    return exposedObject;
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
{

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 执行容器中所有的 BeanPostProcessor 执行其 postProcessBeforeInitialization 方法 
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 执行 Bean 对象的初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {}
    if (mbd == null || !mbd.isSynthetic()) {
        // 执行容器中所有的 BeanPostProcessor 执行其 postProcessAfterInitialization 方法 
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}
  • finishRefresh() 完成 BeanFactory 的初始化创建工作 => IOC容器创建完成
    protected void finishRefresh() {

   // 初始化和生命周期有关的后置处理器
   initLifecycleProcessor();

   // 获取之前的和生命周期有关的后置处理器，调用 onRefresh 方法
   getLifecycleProcessor().onRefresh();

   // 获取事件派发器，发布容器刷新完毕事件
   publishEvent(new ContextRefreshedEvent(this));
}
    • initLifecycleProcessor() 初始化和生命周期有关的后置处理器
      protected void initLifecycleProcessor() {
   // 获取 beanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 判断 beanFactory 中是否存在 id = "lifecycleProcessor" 的组件
   if (beanFactory.containsLocalBean("lifecycleProcessor")) {
      // 存在则获取 id = "lifecycleProcessor" 且 class = LifecycleProcessor.class 的组件
      this.lifecycleProcessor = beanFactory.getBean("lifecycleProcessor", LifecycleProcessor.class);
   }
   else {
      // 不存在则新建 DefaultLifecycleProcessor 并设置 id = "lifecycleProcessor"
      DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
      this.lifecycleProcessor = defaultProcessor;
      beanFactory.registerSingleton("lifecycleProcessor", this.lifecycleProcessor);
   }
}
非酋只配做分母
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring源码分析--注解方式启动容器
逗逗大魔王的博客
03-05 467
四、注解方式 前面我们了解了通过XML方式启动容器，这次我们看看注解是怎么启动容器的。 ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); HelloService helloService = (HelloService) beanFactory.g...
Spring框架容器开启注解的方式
Smallc0de的博客
08-09 890
前言 现在大多数人都在使用SpringCloud和SpringBoot作为Web开发框架的时代，其实这篇文章讲解的内容已经是大多数码农都接触不到的地方了。但是为什么还要写呢？因为这部分Spring官方文档并没有放弃，而且我们再工作中不可避免地会接触到多老的项目。比如使用Spring4，甚至使用Spring3构建的项目，就可能会碰到这些问题。而彼时的体系完全不像现在这么方便，所以为了更好的了解这些，笔者就把从官网上读到的内容，在这里做一个总结。好脑子不如烂笔头，既是为了提醒自己，也可以助人为乐。 Spring
【Spring源码解析】-- Spring容器启动流程分析[注解版]（三）
小虎的博客
09-06 274
现在开始进入正题，开启我们对Spring源码的分析。那么首先看下面的代码： public static void main(String[] args){ //创建Spring容器，那么spring容器都经历了撒？怎么完成创建的呢？又是如何实现组件的扫描呢？ AnnotationConfigApplicationContext applicationContext...
Spring IOC容器注解启动流程浅析
clyu的博客
03-02 538
前言 refresh()方法所有的ApplicationContext子类都没重写，只有AbstractApplicationContext里有实现过（接口定义在ConfigurableApplicationContext），因此我们看起来也容易了，直接上源码~ public void refresh() throws BeansException, IllegalStateException {...
Spring入门-注解配置
赵广陆
12-04 1208
目录注解开发1)注解驱动的意义1.1)什么是注解驱动1.2)注解驱动的弊端2)常用注解2.1)启动注解功能2.2)bean的定义2.3)bean的作用域2.4)bean的生命周期2.5)加载第三方资源2.6)bean的非引用类型属性注入2.7)bean的引用类型属性注入2.8)bean的引用类型属性注入2.9)bean的引用类型属性注入2.10)加载properties文件2.11)纯注解格式2.12)第三方bean配置与管理3)bean加载控制3.1)依赖加载**3.2)依赖加载应用场景**4)整合第三方
SpringBoot经典学习笔记_springboot_SpringBoot经典学习笔记_
09-30
SpringBoot经典学习笔记是针对Java开发者的宝贵资源，它涵盖了SpringBoot的核心概念、特性以及实践应用。SpringBoot是由Pivotal团队开发的框架，旨在简化Spring应用的初始搭建以及开发过程，通过“约定优于配置”的...
学习Spring笔记_Annotation(注解)_Component
08-05
8. **工具支持**：开发过程中，IDE如IntelliJ IDEA和Eclipse都有对Spring注解的良好支持，包括代码提示、自动配置检测等，极大地提高了开发效率。 总的来说，Spring框架的注解和@Component注解是实现IoC和AOP的核心...
SpringCloud学习笔记
12-08
【SpringBoot核心特性】 SpringBoot是Spring框架的一个扩展，它旨在简化Spring应用程序的开发过程，...这份学习笔记涵盖了SpringBoot的基础特性和SpringCloud的负载均衡实践，对于深入理解这两个技术有极大的帮助。
马士兵老师spring框架学习笔记
02-28
马士兵老师是知名的Java教育专家，他的Spring框架学习笔记深入浅出，对于初学者和进阶者来说都是一份宝贵的资源。这份笔记涵盖了Spring的核心概念、配置、AOP（面向切面编程）、DI（依赖注入）等关键知识点。 1. **...
spring学习笔记共10页.pdf.zip
最新发布
11-25
这份"spring学习笔记共10页.pdf.zip"压缩包文件，显然包含了关于Spring框架的详细学习资料，可能是由一位经验丰富的开发者或教师精心整理的。在10页的笔记中，我们可以期待涵盖Spring框架的基础概念、核心特性以及...
springMVC全注解启动和容器的初始化
clyu的博客
03-08 4019
前言 在学习springMVC注解启动启动之前，我们先了解下ServletContainerInitializer。 在web容器启动时为提供给第三方组件机会做一些初始化的工作，例如注册servlet或者filtes等，servlet规范中通过ServletContainerInitializer的onStartup(Set<Class<?>> var1, ServletC...
单元测试启动spring容器
热门推荐
it帝国的博客-辉
11-30 1万+
介绍在spring的框架下，做单元测试的两种办法。     一、使用spring中对Junit框架的整合功能     除了junit4和spring的jar包，还需要spring-test.jar。引入如下依赖：   org.springframework spring-test 3.1.1.RELEASE org.springframework spri
spring容器启动会默认执行的注解
ysxybyb的博客
02-21 2122
@PostConstruct  在一个方法里用此注解，会在spring容器加载后，执行这个方法， 在相应的控制器的配置文件里注意，default-lazy-init="false"，不然是不会执行的 default-lazy-init="false" default-autowire="byName"
SpringBoot框架之注解方式启动SpringMVC容器
September的博客
04-09 1333
纯手写SpringBoot框架之注解方式启动SpringMVC容器 上一篇，使用Java语言创建Tomcat容器，并且通过Tomcat执行Servlet，接下来，将会 使用Java语言创建创建SpringBoot内置Tomcat,使用注解方式启动SpringMVC容器。 代码实现。 1.pom.xml文件，需要依赖的jar包。 <dependencies> &l...
纯手写SpringBoot框架之注解方式启动SpringMVC容器
li420520的博客
06-24 1073
使用Java语言创建Tomcat容器，并且通过Tomcat执行Servlet，接下来，将会使用Java语言在SpringBoot创建内置Tomcat,使用注解方式启动SpringMVC容器。 代码实现。 1.pom.xml文件，需要依赖的jar包。 <dependencies> <!--Java语言操作Tomcat--> <depend...
Spring容器启动之后进行初始化操作
u011494081的专栏
04-28 7009
Spring容器启动之后进行初始化操作在开发项目中，经常会遇到这样的需求：项目启动之后需要进行一些初始化操作。在spring项目开发中可以使用下面两种方法完成。 实现ApplicationListener接口 使用@PostConstrut注解 1. 实现ApplicationListener接口创建一个类实现ApplicationListener接口，同时监听ContextRefreshedEve
bean生命周期+循环依赖完整执行情况之源码调用流程
qq_37361535的博客
12-03 555
为了增强记忆，为了更好的理解，把源码调用流程记录下来 这里以Aserivce和Bservice循坏依赖为例子 Aservice先创建 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean 方法执行内容{ org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)，先去找一级、二
Spring源码之启动过程（一）—— 容器的启动
奔跑的蜗牛_Kieasr
10-31 1287
registerAnnotationConfigProcessors()方法 所属类：org.springframework.context.annotation.AnnotationConfigUtils public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { ..
全网最细致的spring源码分析（二）：spring在创建bean对象的之前的骚操作
敲代码的旺财的博客
03-28 1273
一、回顾 上回说到Spring在获取单例Bean的时候，有一种情况会调用ObjectFactory下的createBean方法创建bean。 当然不可能指望在一个方法中就完成创建bean的复杂逻辑，而且跟踪如此之多的spring代码，多多少少也能发现一些规律，一层套一层的验证判断、各种类之间的协作，直到出现一个以do开头的方法来真正的完成工作，其他的方法只是在做...
Spring框架学习笔记：IoC与AOP解析
"Spring_in_action_学习笔记" Spring框架是Java开发中的一个重要组成部分，以其轻量级、非侵入式的设计理念赢得了广泛的认可。本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值