Scopes & Bean Lifecycle

Use @DependsOn only when a bean must exist before another for a side effect but there is no reference to inject. Prefer injection because it's type-safe, self-documenting, and refactor-proof; @DependsOn relies on fragile string names.

@Bean's destroyMethod defaults to the sentinel "(inferred)": if the bean has a public close() or shutdown() method (or implements AutoCloseable), Spring calls it automatically on shutdown. Set destroyMethod="" to turn this off.

Spring doesn't manage a prototype's full lifecycle — it creates and hands off the instance without tracking it, so no destroy callback runs. To clean up, do it manually or use a custom BeanPostProcessor/DisposableBeanAdapter yourself.

At the end of refresh, DefaultLifecycleProcessor.onRefresh() starts every SmartLifecycle bean whose isAutoStartup() returns true, in ascending phase order. Beans with isAutoStartup()==false are skipped and only start on an explicit start() call.

afterSingletonsInstantiated() is a one-time callback fired after ALL non-lazy singletons are created, so a bean can safely act on the whole set of singletons. It runs during singleton pre-instantiation, before SmartLifecycle start(), which comes later at finishRefresh().

A session-scoped bean has one instance per HttpSession, shared across that user's requests until the session ends. If sessions are replicated across a cluster, the bean must be Serializable and mutations may not propagate instantly, so avoid non-serializable or heavily mutable state.

In the constructor, field/setter-injected dependencies aren't set yet, and the bean isn't fully post-processed. @PostConstruct runs after injection, so collaborators are available. But it runs before AOP proxying, so self-invocation there isn't advised.

stop(Runnable) lets a bean shut down asynchronously: do your cleanup, then call callback.run() to signal completion. DefaultLifecycleProcessor stops all beans in a phase, then waits up to a timeout (default 30s) for their callbacks before moving to the next phase.

Aware setters run once per instance, before init callbacks, so don't do heavy work in them — just capture the reference and act in @PostConstruct. Context-level Aware needs an ApplicationContext to fire, and calling getBean during the callback can hit half-built beans.

Use a BeanFactoryPostProcessor to iterate bean definitions and, for names ending in 'Repository', set lazy-init false and mark them for proxying. Do metadata changes only in the BFPP; do the actual proxy wrapping in a BeanPostProcessor. Never call getBean in the BFPP.

BPPs are created early, before normal beans, so any beans a BPP depends on get built early too — potentially before all BPPs are registered, so they may miss post-processing (e.g. not get proxied). Order BPPs with Ordered/PriorityOrdered; BPPs don't post-process each other.

Default to stateless singletons — they're cheap, cached, and thread-safe when immutable. Reach for prototype only when you truly need per-use mutable state or non-shareable objects, and inject them via ObjectProvider. Prefer passing state as method parameters over creating stateful beans.

The level-3 ObjectFactory calls getEarlyBeanReference, which lets AOP post-processors build the proxy early, so a dependent in the cycle receives the proxy. If a different post-processor later wraps the bean into yet another object after the early reference was already exposed, the identities diverge and Spring throws BeanCurrentlyInCreationException.

On a BeanDefinition call setDependsOn(String...) (e.g. via BeanDefinitionBuilder.addDependsOn or an AbstractBeanDefinition), or in XML use depends-on. It's the programmatic equivalent of @DependsOn, used by infrastructure/registrars where annotations aren't available.

Implement org.springframework.beans.factory.config.Scope (get, remove, registerDestructionCallback, resolveContextualObject, getConversationId), then register it via ConfigurableBeanFactory.registerScope(name, scope) — usually in a BeanFactoryPostProcessor — and use @Scope("myScope") on beans.