// AbstractEnvironment.getPropertySources
public MutablePropertySources getPropertySources() {
    return this.propertySources;
}

// MutablePropertySources.get
public PropertySource<?> get(String name) {
    for (PropertySource<?> propertySource : this.propertySourceList) {
        if (propertySource.getName().equals(name)) {
            return propertySource;
        }
    }
    return null;
}

// MutablePropertySources.addFirst — highest precedence
public void addFirst(PropertySource<?> propertySource) {
    synchronized (this.propertySourceList) {
        removeIfPresent(propertySource); // same name moves, not duplicated
        this.propertySourceList.add(0, propertySource);
    }
}

// MutablePropertySources.addLast — lowest precedence
public void addLast(PropertySource<?> propertySource) {
    synchronized (this.propertySourceList) {
        removeIfPresent(propertySource);
        this.propertySourceList.add(propertySource);
    }
}

// MutablePropertySources.addBefore — just above the named source
public void addBefore(String relativePropertySourceName, PropertySource<?> propertySource) {
    synchronized (this.propertySourceList) {
        removeIfPresent(propertySource);
        int index = assertPresentAndGetIndex(relativePropertySourceName);
        addAtIndex(index, propertySource);
    }
}

// PropertySourcesPropertyResolver.getProperty — first source with the key wins
protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
    for (PropertySource<?> propertySource : this.propertySources) {
        Object value = propertySource.getProperty(key);
        if (value != null) {
            if (resolveNestedPlaceholders && value instanceof String string) {
                value = resolveNestedPlaceholders(string); // ${...}
            }
            return convertValueIfNecessary(value, targetValueType);
        }
    }
    return null;
}

// usage
ConfigurableEnvironment env = context.getEnvironment();
MutablePropertySources sources = env.getPropertySources();
sources.addFirst(new MapPropertySource("override", Map.of("app.timeout", "30")));
sources.addAfter("systemProperties", new PropertiesPropertySource("app", appProperties));
PropertySource<?> sys = sources.get("systemProperties");
String timeout = env.getProperty("app.timeout"); // "30", from "override"

// AbstractApplicationContext.refresh — definitions first, singletons last
public void refresh() {
    prepareRefresh();                                          // Environment
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    prepareBeanFactory(beanFactory);
    postProcessBeanFactory(beanFactory);
    invokeBeanFactoryPostProcessors(beanFactory);              // getBeanFactoryPostProcessors()
    registerBeanPostProcessors(beanFactory);                   // register only
    finishBeanFactoryInitialization(beanFactory);              // create singletons
}

// SpringFactoriesLoader.loadFactories — usual entry
public static <T> List<T> loadFactories(Class<T> factoryType, ClassLoader classLoader) {
    return SpringFactoriesLoader.forDefaultResourceLocation(classLoader).load(factoryType);
}

// SpringFactoriesLoader.forResourceLocation — parse every jar, cache by class loader
public static SpringFactoriesLoader forResourceLocation(
        String resourceLocation, ClassLoader classLoader) {
    ClassLoader resourceClassLoader = (classLoader != null)
            ? classLoader : SpringFactoriesLoader.class.getClassLoader();
    Map<String, Factories> factoriesCache = cache.computeIfAbsent(
            resourceClassLoader, key -> new ConcurrentReferenceHashMap<>());
    Factories factories = factoriesCache.computeIfAbsent(resourceLocation,
            key -> new Factories(loadFactoriesResource(resourceClassLoader, resourceLocation)));
    return new SpringFactoriesLoader(classLoader, factories.byType());
}

// SpringFactoriesLoader.loadFactoriesResource — key = interface, value = impl names
protected static Map<String, List<String>> loadFactoriesResource(
        ClassLoader classLoader, String resourceLocation) {
    Map<String, List<String>> result = new LinkedHashMap<>();
    Enumeration<URL> urls = classLoader.getResources(resourceLocation); // META-INF/spring.factories
    while (urls.hasMoreElements()) {
        Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement()));
        properties.forEach((name, value) -> {
            String[] implementationNames = StringUtils.commaDelimitedListToStringArray((String) value);
            List<String> implementations = result.computeIfAbsent(((String) name).trim(), key -> new ArrayList<>());
            for (String implementationName : implementationNames) {
                implementations.add(implementationName.trim());
            }
        });
    }
    result.replaceAll(SpringFactoriesLoader::toDistinctUnmodifiableList); // drop duplicate class names
    return Collections.unmodifiableMap(result);
}

// SpringFactoriesLoader.load — names for this factory type, then one instance each
public <T> List<T> load(Class<T> factoryType, ArgumentResolver argumentResolver,
        FailureHandler failureHandler) {
    List<String> implementationNames = this.factories.getOrDefault(factoryType.getName(), Collections.emptyList());
    List<T> result = new ArrayList<>();
    for (String implementationName : implementationNames) {
        T factory = instantiateFactory(implementationName, factoryType, argumentResolver, failureHandler);
        if (factory != null) {
            result.add(factory);
        }
    }
    AnnotationAwareOrderComparator.sort(result);
    return result;
}

// SpringFactoriesLoader.instantiateFactory — Class.forName, then the resolvable constructor
protected <T> T instantiateFactory(String implementationName, Class<T> type,
        ArgumentResolver argumentResolver, FailureHandler failureHandler) {
    Class<?> implementationClass = ClassUtils.forName(implementationName, this.classLoader);
    // implementationClass must be assignable to type
    FactoryInstantiator<T> instantiator = FactoryInstantiator.forClass(implementationClass);
    return instantiator.instantiate(argumentResolver); // constructor.newInstance(resolved args)
}

// PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors
// Several loops on purpose: a processor may register more processors.
// getBean() of an Ordered processor must not run before every PriorityOrdered
// processor has already called postProcessBeanDefinitionRegistry.
public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<>();

    if (beanFactory instanceof BeanDefinitionRegistry registry) {
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // Loop 1 — getBeanFactoryPostProcessors(), filled by addBeanFactoryPostProcessor before refresh().
        // Not beans in the factory. Registry processors run now. Plain ones are saved.
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

        // allowEagerInit=false: collect names without creating FactoryBeans.
        // Loop 2 — BeanDefinitionRegistryPostProcessor beans that implement PriorityOrdered.
        // ConfigurationClassPostProcessor is in this pass (PriorityOrdered, lowest order value).
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        List<BeanDefinitionRegistryPostProcessor> current = new ArrayList<>();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                current.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(current, beanFactory); // OrderComparator / dependency comparator
        registryProcessors.addAll(current);
        invokeBeanDefinitionRegistryPostProcessors(current, registry); // postProcessBeanDefinitionRegistry
        current.clear();

        // Loop 3 — rescan names. PriorityOrdered processors may have registered Ordered ones.
        // Skip names already in processedBeans. PriorityOrdered also implements Ordered, so the skip matters.
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                current.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(current, beanFactory);
        registryProcessors.addAll(current);
        invokeBeanDefinitionRegistryPostProcessors(current, registry);
        current.clear();

        // Loop 4 — while. Anything left, including processors registered by the previous iteration.
        // reiterate stays true when this scan found at least one new name.
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    current.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(current, beanFactory);
            registryProcessors.addAll(current);
            invokeBeanDefinitionRegistryPostProcessors(current, registry);
            current.clear();
        }

        // Loop inside invokeBeanFactoryPostProcessors: postProcessBeanFactory, not the registry callback.
        // Registry processors first, then the plain ones saved in loop 1.
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }
    else {
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Loop 5 — every BeanFactoryPostProcessor name. Skip processedBeans (registry processors already ran both callbacks).
    // Split into three lists before any further getBean(), so Ordered beans are not created while sorting PriorityOrdered.
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // already ran postProcessBeanFactory above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName); // name only
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // Loop 6 — postProcessBeanFactory for PriorityOrdered, then Ordered, then the rest.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    beanFactory.clearMetadataCache(); // definitions may have changed placeholders
}

// ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    processConfigBeanDefinitions(registry); // parse @Configuration, register BeanDefinitions
}

// AbstractApplicationContext.registerBeanPostProcessors — register only, do not create singletons
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

// ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    this.registriesPostProcessed.add(System.identityHashCode(registry)); // run once per registry
    processConfigBeanDefinitions(registry);
}

// ConfigurationClassPostProcessor.processConfigBeanDefinitions
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName)); // @Configuration, @Component, ...
        }
    }
    configCandidates.sort(...); // @Order

    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<>();
    do {
        parser.parse(candidates);   // ConfigurationClassParser: BeanMethod, imports, scan
        parser.validate();
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);
        this.reader.loadBeanDefinitions(configClasses); // ConfigurationClassBeanDefinitionReader: register
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        // new definitions not parsed yet (e.g. from a registrar) become the next candidates
    }
    while (!candidates.isEmpty());
}

// ConfigurationClassParser.parse
public void parse(Set<BeanDefinitionHolder> configCandidates) {
    for (BeanDefinitionHolder holder : configCandidates) {
        BeanDefinition bd = holder.getBeanDefinition();
        if (bd instanceof AnnotatedBeanDefinition annotatedBeanDef) {
            parse(annotatedBeanDef, holder.getBeanName());
        }
        else if (bd instanceof AbstractBeanDefinition abstractBeanDef && abstractBeanDef.hasBeanClass()) {
            parse(abstractBeanDef.getBeanClass(), holder.getBeanName());
        }
        else {
            parse(bd.getBeanClassName(), holder.getBeanName());
        }
    }
    this.deferredImportSelectorHandler.process(); // DeferredImportSelector after this pass
}

// ConfigurationClassParser.parse
private ConfigurationClass parse(AnnotatedBeanDefinition beanDef, String beanName) {
    ConfigurationClass configClass = new ConfigurationClass(
            beanDef.getMetadata(), beanName, (beanDef instanceof ScannedGenericBeanDefinition));
    processConfigurationClass(configClass, DEFAULT_EXCLUSION_FILTER);
    return configClass;
}

// ConfigurationClassParser.parse
private ConfigurationClass parse(Class<?> clazz, String beanName) {
    ConfigurationClass configClass = new ConfigurationClass(clazz, beanName);
    processConfigurationClass(configClass, DEFAULT_EXCLUSION_FILTER);
    return configClass;
}

// ConfigurationClassParser.parse
ConfigurationClass parse(String className, String beanName) {
    MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
    ConfigurationClass configClass = new ConfigurationClass(reader, beanName);
    processConfigurationClass(configClass, DEFAULT_EXCLUSION_FILTER);
    return configClass;
}

// ConfigurationClassParser.processConfigurationClass
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) {
    SourceClass sourceClass = asSourceClass(configClass, filter);
    do {
        sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
    }
    while (sourceClass != null); // once per class in the superclass chain
    this.configurationClasses.put(configClass, configClass);
}

// ConfigurationClassParser.doProcessConfigurationClass
protected SourceClass doProcessConfigurationClass(
        ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) {
    processMemberClasses(configClass, sourceClass, filter);          // nested classes
    propertySourceRegistry.processPropertySource(propertySource);    // @PropertySource
    for (AnnotationAttributes componentScan : componentScans) {      // @ComponentScan → BeanDefinitions
        Set<BeanDefinitionHolder> scannedBeanDefinitions =
                this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
        for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
                bdCand = holder.getBeanDefinition();
            }
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                parse(bdCand.getBeanClassName(), holder.getBeanName()); // step into parse(String, String)
            }
        }
    }
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true); // @Import
    configClass.addImportedResource(resolvedResource, readerClass);  // @ImportResource
    configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); // @Bean
    processInterfaces(configClass, sourceClass);
    return superclass; // continue with the superclass
}

// ConfigurationClassParser.processImports
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
        Collection<SourceClass> importCandidates, Predicate<String> filter, boolean checkForCircularImports) {
    for (SourceClass candidate : importCandidates) {
        if (candidate.isAssignable(ImportSelector.class)) {
            ImportSelector selector = ParserStrategyUtils.instantiateClass(candidate.loadClass(),
                    ImportSelector.class, this.environment, this.resourceLoader, this.registry);
            if (selector instanceof DeferredImportSelector deferredImportSelector) {
                this.deferredImportSelectorHandler.handle(configClass, deferredImportSelector); // store, do not select yet
            }
            else {
                String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                processImports(configClass, currentSourceClass, asSourceClasses(importClassNames, filter), filter, false);
            }
        }
        else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
            ImportBeanDefinitionRegistrar registrar = ParserStrategyUtils.instantiateClass(candidate.loadClass(),
                    ImportBeanDefinitionRegistrar.class, this.environment, this.resourceLoader, this.registry);
            configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
        }
        else {
            processConfigurationClass(candidate.asConfigClass(configClass), filter); // imported @Configuration
        }
    }
}

// ConfigurationClassParser.DeferredImportSelectorHandler
void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
    this.deferredImportSelectors.add(new DeferredImportSelectorHolder(configClass, importSelector));
}

// ConfigurationClassParser.DeferredImportSelectorHandler
void process() {
    List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
    DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
    deferredImports.forEach(handler::register); // selectors that share a Group go into one grouping
    handler.processGroupImports();
}

// ConfigurationClassParser.DeferredImportSelectorGrouping
Iterable<Group.Entry> getImports() {
    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                deferredImport.getImportSelector()); // default group calls selectImports
    }
    return this.group.selectImports();
}

// ConfigurationClassParser.DeferredImportSelectorGroupingHandler
void processGroupImports() {
    for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
        Predicate<String> filter = grouping.getCandidateFilter();
        for (Group.Entry entry : grouping.getImports()) {
            ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
            processImports(configurationClass, asSourceClass(configurationClass, filter),
                    Collections.singleton(asSourceClass(entry.getImportClassName(), filter)), filter, false);
        }
    }
}

// AbstractApplicationContext.getEnvironment — create once
public ConfigurableEnvironment getEnvironment() {
    if (this.environment == null) {
        this.environment = createEnvironment(); // StandardEnvironment, web: StandardServletEnvironment
    }
    return this.environment;
}

// AbstractEnvironment constructor
protected AbstractEnvironment(MutablePropertySources propertySources) {
    this.propertySources = propertySources;
    this.propertyResolver = createPropertyResolver(propertySources);
    customizePropertySources(propertySources);
}

// StandardEnvironment.customizePropertySources — first match wins on later lookup
protected void customizePropertySources(MutablePropertySources propertySources) {
    propertySources.addLast(new PropertiesPropertySource("systemProperties", getSystemProperties()));
    propertySources.addLast(new SystemEnvironmentPropertySource("systemEnvironment", getSystemEnvironment()));
}

// StandardServletEnvironment.customizePropertySources — stubs replaced in prepareRefresh
protected void customizePropertySources(MutablePropertySources propertySources) {
    propertySources.addLast(new StubPropertySource("servletConfigInitParams"));
    propertySources.addLast(new StubPropertySource("servletContextInitParams"));
    super.customizePropertySources(propertySources);
}

// AbstractRefreshableWebApplicationContext.initPropertySources
protected void initPropertySources() {
    ((ConfigurableWebEnvironment) getEnvironment()).initPropertySources(this.servletContext, this.servletConfig);
}

// AbstractApplicationContext.prepareBeanFactory
beanFactory.registerSingleton("environment", getEnvironment());
// ${...} in definitions: Environment.resolvePlaceholders
// @PropertySource is added later by ConfigurationClassParser, not here

// AbstractAutowireCapableBeanFactory.initializeBean
protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    invokeAwareMethods(beanName, bean); // BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    invokeInitMethods(beanName, wrappedBean, mbd); // InitializingBean.afterPropertiesSet, then init-method
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    return wrappedBean;
}

// ApplicationContextAwareProcessor sets EnvironmentAware, EmbeddedValueResolverAware,
// ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware,
// ApplicationContextAware, ServletContextAware before the BeanPostProcessor loop above.

// DisposableBeanAdapter.destroy — shutdown
postProcessBeforeDestruction(); // DestructionAwareBeanPostProcessor
((DisposableBean) bean).destroy();
invokeCustomDestroyMethod();    // destroy-method

// DefaultListableBeanFactory.preInstantiateSingletons
public void preInstantiateSingletons() {
    for (String beanName : beanNames) {
        if (isSingleton && !isLazy) {
            getBean(beanName);
        }
    }
}

// AbstractAutowireCapableBeanFactory.createBean
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    resolveBeanClass(mbd, beanName);
    Object early = resolveBeforeInstantiation(beanName, mbd); // InstantiationAwareBeanPostProcessor may return a proxy
    if (early != null) {
        return early;
    }
    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

// AbstractAutowireCapableBeanFactory.doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    instanceWrapper = createBeanInstance(beanName, mbd, args); // supplier, @Bean factory method, or constructor
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); // @Autowired metadata
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
    return exposedObject;
}

// FactoryBean: getBean("name") calls FactoryBean.getObject(); getBean("&name") returns the factory.
// A lazy-init definition stays uncreated until getBean.

public class Client {
    private final String endpoint;
    public Client(String endpoint) { this.endpoint = endpoint; }
    public String endpoint() { return endpoint; }
}

public class ClientFactoryBean implements FactoryBean<Client> {
    private String endpoint;

    public void setEndpoint(String endpoint) { this.endpoint = endpoint; }

    @Override
    public Client getObject() {
        return new Client(endpoint);
    }

    @Override
    public Class<?> getObjectType() {
        return Client.class;
    }

    @Override
    public boolean isSingleton() {
        return true; // container caches getObject() for this name
    }
}

@Configuration
public class AppConfig {
    @Bean
    public ClientFactoryBean client() {
        ClientFactoryBean factory = new ClientFactoryBean();
        factory.setEndpoint("https://api.example.com");
        return factory;
    }
}

ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);

Client product = ctx.getBean("client", Client.class);
// product.endpoint() == "https://api.example.com"
// type is Client, not ClientFactoryBean

ClientFactoryBean factory = (ClientFactoryBean) ctx.getBean("&client");
// the FactoryBean instance registered under the name "client"