<bean id="XXX" class="XXX.XXX.XXXX" lazy-init="true"/>

@Lazy
@Component
public class XXXX {
    ...
}

@Configuration
public class XXXX {
    @Lazy
    @Bean
    public XXX getXXX() {
        return new XXX();
    }
}

@ComponentScan(value = "XXX.XXX", lazyInit = true)
@Configuration
public class XXXX {
    ...
}

public class ClassPathBeanDefinitionScanner 
        extends ClassPathScanningCandidateComponentProvider {
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
       // 不管是讀取注解或者XML配置方式bean，最終讀取加載Bean時都會進入到該方法
       // 對相應(yīng)的包進行處理
       // beanDefinitions是保存返回bean定義的集合
       Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
       // 遍歷多個包下的類
       for (String basePackage : basePackages) {
          // 獲取滿足條件的bean定義集合
          Set<BeanDefinition> candidates = 
                  findCandidateComponents(basePackage);
          // 對每個bean定義進行處理
          for (BeanDefinition candidate : candidates) {
             ScopeMetadata scopeMetadata = this.scopeMetadataResolver
                     .resolveScopeMetadata(candidate);
             candidate.setScope(scopeMetadata.getScopeName());
             String beanName = this.beanNameGenerator
                     .generateBeanName(candidate, this.registry);
             // 這個方法會處理@ComponentScan中的lazyInit值，因為在使用
             // @ComponentScan注解時會首先把該值賦值到beanDefinitionDefaults
             // 默認(rèn)bean定義值的對象中，在postProcessBeanDefinition方法中
             // 會首先應(yīng)用一次這些默認(rèn)值，其中就包括lazyInit、autowireMode等
             if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition(
                        (AbstractBeanDefinition) candidate, beanName);
             }
             // 讀取@Lazy、@Primary和@DependsOn等注解值
             if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils
                        .processCommonDefinitionAnnotations(
                                (AnnotatedBeanDefinition) candidate);
             }
             // 如果候選者滿足要求則將其注冊到Bean定義中心
             if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = 
                        new BeanDefinitionHolder(candidate, beanName);
                definitionHolder = AnnotationConfigUtils
                        .applyScopedProxyMode(scopeMetadata, 
                            definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                // 注冊bean定義
                registerBeanDefinition(definitionHolder, this.registry);
             }
          }
       }
       return beanDefinitions;
    }
    protected void postProcessBeanDefinition(
            AbstractBeanDefinition beanDefinition, String beanName) {
       // 此處會應(yīng)用默認(rèn)值，如lazyInit、autowireMode、initMethod等
       beanDefinition.applyDefaults(this.beanDefinitionDefaults);
       if (this.autowireCandidatePatterns != null) {
          beanDefinition.setAutowireCandidate(PatternMatchUtils
                  .simpleMatch(this.autowireCandidatePatterns, beanName));
       }
    }
}

public abstract class AbstractApplicationContext 
        extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        ...
        // 刷新流程中執(zhí)行初始化非延遲單例的方法
        finishBeanFactoryInitialization(beanFactory);
        ...
    }
    protected void finishBeanFactoryInitialization(
            ConfigurableListableBeanFactory beanFactory) {
        ...
        // 實際執(zhí)行初始化非延遲加載單例
        beanFactory.preInstantiateSingletons();
    }
}

public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry,
        Serializable {
    // 當(dāng)BeanDefinition被創(chuàng)建注冊到工廠中時bean定義的名字將會被保存到這個集合中
    // 且里面的順序為注冊進來的順序
    private volatile List<String> beanDefinitionNames = 
            new ArrayList<>(256);
    @Override
    public void preInstantiateSingletons() throws BeansException {
        // 獲取所有已注冊到Spring工廠中的bean定義
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // 遍歷bean定義，初始化非抽象、單例且非延遲加載的bean對象
        for (String beanName : beanNames) {
           RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
           // !bd.isLazyInit()便是判斷非延遲加載的，因此前面獲取到的延遲加載
           // 屬性會在這里進行判斷
           if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
              // 這里面會判斷是否是FactoryBean類型，最終都會調(diào)用到getBean中
              ...
           }
        }
        // 后續(xù)略過
        ...
    }
}

@Controller
public class TestController implements InitializingBean{
    @Autowired
    private TestService testService;
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("testController Initializing");
    }
}

@Lazy
@Service
public class TestService implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("testService Initializing");
    }
}

@Lazy
@Controller
public class TestController implements InitializingBean{
    @Autowired
    private TestService testService;
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("testController Initializing");
    }
}