Spring Prototype Bean Scope

Direct Answer

Prototype scope tells Spring to create a new bean instance each time that bean is requested from the container. It does not mean a new object appears on every method call, and a prototype injected once into a singleton is still that same injected instance. Spring performs initialization callbacks but does not manage complete destruction of prototype instances.

Code Example

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

@Component
@Scope("prototype") // a new instance every time
public class InvoiceGenerator {
    private final List<String> lineItems = new ArrayList<>();
    private BigDecimal totalAmount = BigDecimal.ZERO;

    public void addItem(String item, BigDecimal price) {
        lineItems.add(item); // mutable state
        totalAmount = totalAmount.add(price);
    }

    public byte[] generatePDF() {
        // build PDF from lineItems and totalAmount
        return new byte[0];
    }
}

Common Mistakes & Pitfalls

• Injecting prototype into singleton via constructor: The most common mistake. Spring creates one prototype instance at startup and reuses it forever — you lose prototype behavior. Use ObjectProvider, @Lookup method injection, or getBean() to get a fresh instance each time.
• Expecting Spring to call @PreDestroy: Spring doesn't track prototype beans after creation, so @PreDestroy methods never run. If your prototype holds resources like file handles or connections, close them manually.
• Using prototype when you need request or session scope: Freshers sometimes use prototype for web-scoped data like user sessions. That's wrong — you'll get a new instance on every injection, not one per request or session.