Spring-Lazy-init源码探讨

分手后的思念是犯贱 2022-05-10 14:28 178阅读 0赞

在Spring中，使用azy-init="true"可以延迟实例化bean，等待调用bean时再实例化bean。  
本文记录Spring如何实现延迟实例化。  
Spring版本：5.0.4  
测试代码

package cn.wzx;
    
    import cn.wzx.model.Student;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author Walker
     * @since 1.0 2018-10-16
     */
    public class SpringTest {
    
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans.xml");
            System.out.println("容器已经启动");
            Student student = context.getBean(Student.class);
        }
    
    }

实体类：

package cn.wzx.model;
    
    /**
     * @author Walker
     * @since 1.0 2018-10-16
     */
    public class Student {
    
        public Student() {
            System.out.println("Student init.");
        }
    
        private String name;
    
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

使用ClassPathXmlApplicationContext创建Spring容器的主要流程是先解析XML文件，接着实例化bean。  
可以查看之前的文章  
[Spring-ClassPathXmlApplicationContext源码探讨-解析XML文件][Spring-ClassPathXmlApplicationContext_-_XML]  
[Spring-Bean初始化源码探讨][Spring-Bean]  
在解析XML文件过程中，会解析是否有配置lazy-init属性。  
**BeanDefinitionParserDelegate\#parseBeanDefinitionAttributes()**

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
    			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
    
    	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
    		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
    	}
    	else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
    		bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
    	}
    	else if (containingBean != null) {
    		// Take default from containing bean in case of an inner bean definition.
    		bd.setScope(containingBean.getScope());
    	}
    
    	if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
    		bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    	}
    	//处理lazy-init属性
    	String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
    	if (DEFAULT_VALUE.equals(lazyInit)) {
    		lazyInit = this.defaults.getLazyInit();
    	}
    	bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
    
    	String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
    	bd.setAutowireMode(getAutowireMode(autowire));
    
    	if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
    		String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
    		bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
    	}
    
    	String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
    	if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
    		String candidatePattern = this.defaults.getAutowireCandidates();
    		if (candidatePattern != null) {
    			String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
    			bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
    		}
    	}
    	else {
    		bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
    	}
    
    	if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
    		bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    	}
    
    	if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
    		String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
    		bd.setInitMethodName(initMethodName);
    	}
    	else if (this.defaults.getInitMethod() != null) {
    		bd.setInitMethodName(this.defaults.getInitMethod());
    		bd.setEnforceInitMethod(false);
    	}
    
    	if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
    		String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
    		bd.setDestroyMethodName(destroyMethodName);
    	}
    	else if (this.defaults.getDestroyMethod() != null) {
    		bd.setDestroyMethodName(this.defaults.getDestroyMethod());
    		bd.setEnforceDestroyMethod(false);
    	}
    
    	if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
    		bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    	}
    	if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
    		bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    	}
    
    	return bd;
    }

接着在实例化bean过程中会判断属性是否延迟实例化。  
DefaultListableBeanFactory\#preInstantiateSingletons()

public void preInstantiateSingletons() throws BeansException {
    	if (this.logger.isDebugEnabled()) {
    		this.logger.debug("Pre-instantiating singletons in " + this);
    	}
    
    	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    	// Trigger initialization of all non-lazy singleton beans...
    	for (String beanName : beanNames) {
    		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    		//如果是延迟实例化,则绕过
    		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    			if (isFactoryBean(beanName)) {
    				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    				if (bean instanceof FactoryBean) {
    					final FactoryBean<?> factory = (FactoryBean<?>) bean;
    					boolean isEagerInit;
    					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
    						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
    										((SmartFactoryBean<?>) factory)::isEagerInit,
    								getAccessControlContext());
    					}
    					else {
    						isEagerInit = (factory instanceof SmartFactoryBean &&
    								((SmartFactoryBean<?>) factory).isEagerInit());
    					}
    					if (isEagerInit) {
    						getBean(beanName);
    					}
    				}
    			}
    			else {
    				getBean(beanName);
    			}
    		}
    	}
    
    	// Trigger post-initialization callback for all applicable beans...
    	for (String beanName : beanNames) {
    		Object singletonInstance = getSingleton(beanName);
    		if (singletonInstance instanceof SmartInitializingSingleton) {
    			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    			if (System.getSecurityManager() != null) {
    				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    					smartSingleton.afterSingletonsInstantiated();
    					return null;
    				}, getAccessControlContext());
    			}
    			else {
    				smartSingleton.afterSingletonsInstantiated();
    			}
    		}
    	}
    }

[Spring-ClassPathXmlApplicationContext_-_XML]: https://blog.csdn.net/wang704987562/article/details/81273899
[Spring-Bean]: https://blog.csdn.net/wang704987562/article/details/80795987