Bean scopes in Spring — what does `singleton` vs `prototype` mean?

Deep dive

A bean scope controls *how many instances* Spring creates and *when*.

• `singleton` (default): one instance **per ApplicationContext** (not a JVM-wide singleton). Because it can be used by many threads, it should be stateless or thread-safe.
• `prototype`: a new instance each time the bean is requested, but after creation Spring **does not fully manage its lifecycle** (e.g., destroy callbacks are not invoked automatically).
• Web scopes (`request`, `session`, `application`, `websocket`) exist in web applications.

Prototype injected into a singleton (common gotcha)

If you inject a prototype bean into a singleton bean, you still get **one instance** at injection time. If you need a fresh instance per use, inject a provider.

Example

@Component
@Scope("prototype")
class TraceId { /* ... */ }

@Service
class OrderService {
  private final ObjectProvider<TraceId> traceId;
  OrderService(ObjectProvider<TraceId> traceId) { this.traceId = traceId; }

  void handle() {
    TraceId id = traceId.getObject(); // fresh instance
  }
}

Common pitfalls

• Keeping request/user state in a singleton bean.
• Assuming prototype beans are automatically cleaned up by Spring.
• Overusing prototype when a method-local object would do.