旗下导航:搜·么
当前位置:网站首页 > JAVA教程 > 正文

Spring lazy-init道理的剖析(代码示例)【JAVA教程】,Spring

作者:搜教程发布时间:2019-11-27分类:JAVA教程浏览:45评论:0


导读:本篇文章给人人带来的内容是关于Springlazy-init道理的剖析(代码示例),有肯定的参考价值,有须要的朋侪可以参考一下,愿望对你有所协助。一般的bean的初始化是...
本篇文章给人人带来的内容是关于Spring lazy-init道理的剖析(代码示例),有肯定的参考价值,有须要的朋侪可以参考一下,愿望对你有所协助。

一般的bean的初始化是在容器启动初始化阶段实行的,而被lazy-init润饰的bean 则是在从容器里第一次举行context.getBean(“”)时举行触发。Spring 启动的时刻会把一切bean信息(包含XML和注解)剖析转化成Spring可以辨认的BeanDefinition并存到Hashmap里供下面的初始化时用。接下来对每一个BeanDefinition举行处置惩罚,假如是懒加载的则在容器初始化阶段不处置惩罚,其他的则在容器初始化阶段举行初始化并依靠注入。

本文我说了很屡次 Spring 容器初始化bean初始化,容器的初始化有能够包含bean的初始化重要取决于该bean是不是是懒加载的,特此说明怕误解 。。。:)

一.先睹为快

话不多说先写个例子看下这属性到底有什么作用,我们定义了一个叫做coffee的一般bean,代码以下:

1.一般非懒加载bean的演示

package com.test.spring;

public class Coffee {

    public Coffee() {
        System.out.println("正在初始化bean !!!挪用无参组织函数");
    }
    
}
<bean name="coffee" class="com.test.spring.Coffee"/>
@Test
public void testLazyInit() {

    System.out.println("最先初始化Spring容器 ");
    // 非懒加载的bean会在容器初始化时举行bean的初始化,后面会拿Spring启动时的源码举行剖析
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
   // 非懒加载的bean 的组织函数会在这个位置打印
    System.out.println("Spring容器初始化终了");
    
   System.out.println("最先从容器中猎取Bean");

   Coffee coffee = context.getBean("coffee", Coffee.class);

   System.out.println("猎取终了  bean :" + coffee);
}

运转效果以下:

2.非懒加载bean的演示

<bean name="coffee" class="com.test.spring.Coffee" lazy-init="true" />
@Test
    public void testLazyInit() {

        System.out.println("最先初始化Spring容器 ");
     // 在初始化容器阶段不会对懒加载的bean举行初始化
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
  
        System.out.println("Spring容器初始化终了");

        System.out.println("最先从容器中猎取Bean");
     // 在这一阶段会对懒加载的bean举行初始化
        Coffee coffee = context.getBean("coffee", Coffee.class);

        System.out.println("猎取终了  bean :" + coffee);


    }

运转效果以下:

二,道理剖析

Spring 启动时重要干俩件事 1.初始化容器 2.对bean举行初始化并依靠注入。(懒加载的bean不做第二件)

然则关于大多数bean来讲,bean的初始化以及依靠注入就是在容器初始化阶段举行的,只要懒加载的bean是当应用程序第一次举行getBean时举行初始化并依靠注入。下面贴出代码看下

Spring 容器初始化代码以下就一行:

ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            // Spring ioc 启动进口 了解了refresh 就了解了ioc
            refresh();
        }
    }

Spring 初始化进口 refresh(省略了部份基础次无关的代码,望邃晓,太长了影响浏览体验)

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

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

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
                // Instantiate all remaining (non-lazy-init) singletons.
                // 初始化一切非 懒加载的bean!!!!
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }
 }

第20行则是跟本次主题有关的,就是说在容器启动的时刻 只处置惩罚 non-lazy-init bean,懒加载的bean在Spring启动阶段基础不做任何处置惩罚下面看下源码就邃晓了

点进去第20行的finishBeanFactoryInitialization(beanFactory)里头有个初始化non-lazy-init bean的函数 preInstantiateSingletons()

细致逻辑以下

1.对beanNames 鸠合遍历猎取每一个BeanDefinition

2.推断是不是是懒加载的,假如不是则继承处置惩罚(non-lazy-init bean 不做处置惩罚)

3.推断是不是是factorybean 假如不是则举行实例化并依靠注入

public void preInstantiateSingletons() throws BeansException {
   // 一切beanDefinition鸠合
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
   // 触发一切非懒加载单例bean的初始化
   for (String beanName : beanNames) {
       // 猎取bean 定义
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 推断是不是是懒加载单例bean,假如是单例的而且不是懒加载的则在Spring 容器
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          // 推断是不是是FactoryBean
         if (isFactoryBean(beanName)) {
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                   isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                      @Override
                      public Boolean run() {
                         return ((SmartFactoryBean<?>) factory).isEagerInit();
                      }
                   }, getAccessControlContext());
                }
         }else {
             // 假如是一般bean则举行初始化依靠注入,此 getBean(beanName)接下来触发的逻辑跟
             // context.getBean("beanName") 所触发的逻辑是一样的
            getBean(beanName);
         }
      }
   }
}

getBean() 要领是完成bean 初始化以及依靠注入的函数

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

三,总结

关于被润饰为lazy-init的bean Spring初始化阶段不会举行init而且依靠注入,当第一次举行getBean时刻举行初始化并依靠注入

关于非懒加载的bean getBean的时刻会从缓存里头取 由于容器初始化阶段已初始化了

// 容器启动初始化 会初始化并依靠注入非懒加载的bean
   ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");
// lazy-init bean会举行第一次初始化并依靠注入  其他的会从缓存里取
   Coffee coffee = context.getBean("coffee", Coffee.class);

本篇文章到这里就已悉数完毕了,更多其他精彩内容可以关注ki4网的Java教程视频栏目!

以上就是Spring lazy-init道理的剖析(代码示例)的细致内容,更多请关注ki4网别的相干文章!

标签:Spring


欢迎 发表评论: