Spring Beans

A "bean" in Spring is simply an object that the IoC container instantiates, configures, and manages on your behalf, as opposed to an object you create yourself with "new". Beans are the fundamental building blocks of a Spring application — controllers, services, repositories, and configuration objects are all beans once the container is responsible for their lifecycle.

Spring identifies which classes should become beans primarily through stereotype annotations, and it controls how many instances of a bean exist and how long they live through bean scopes. Understanding both of these — stereotypes and scopes — is essential before touching more advanced Spring features, because nearly everything else in the framework (AOP, transactions, MVC controllers) operates on beans that the container already manages.

Stereotype Annotations

Spring provides several specialized annotations that mark a class as a candidate for auto-detection and registration as a bean. All of them are built on top of the generic @Component annotation, but using the more specific one communicates intent and, for some, adds extra behavior.

• @Component — the generic stereotype; any class annotated with it becomes a bean during component scanning.
• @Service — marks a class that holds business logic; semantically identical to @Component but clarifies the layer.
• @Repository — marks a data-access class; Spring also translates its persistence-related exceptions into Spring's unchecked DataAccessException hierarchy.
• @Controller / @RestController — marks a class as a Spring MVC web endpoint handler; @RestController combines @Controller with @ResponseBody.

Bean Scopes

A bean's scope determines how many instances of it the container creates and how long each instance lives. The two scopes used in the vast majority of applications are singleton and prototype.

• singleton (default) — exactly one shared instance per Spring container, created once and reused for every injection point.
• prototype — a brand-new instance is created every time the bean is requested from the container or injected elsewhere.
• Web-aware scopes also exist — request, session, and application — but only apply in a web application context.

Declaring Scope Explicitly

Scope is set with the @Scope annotation, most commonly @Scope("singleton") or @Scope("prototype"), applied on the same class as the stereotype annotation. Because singleton beans are shared, they must be designed to be stateless or thread-safe; prototype beans are safer for holding request-specific mutable state, but the container does not manage their destruction callbacks the way it does for singletons.

Example

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Component
@Scope("prototype")
class ShoppingCart {
    // Each injection/lookup gets a new instance.
}

@Service
class CheckoutService {
    // Default scope is singleton: one shared instance for the whole app.
}

@Configuration
@ComponentScan(basePackages = "com.webnest.beansdemo")
class AppConfig { }

public class BeanScopeDemo {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        ShoppingCart cart1 = context.getBean(ShoppingCart.class);
        ShoppingCart cart2 = context.getBean(ShoppingCart.class);
        System.out.println("Prototype beans equal? " + (cart1 == cart2));

        CheckoutService service1 = context.getBean(CheckoutService.class);
        CheckoutService service2 = context.getBean(CheckoutService.class);
        System.out.println("Singleton beans equal? " + (service1 == service2));
    }
}

Prototype beans equal? false
Singleton beans equal? true

Exercise

Using the lesson's A singleton service bean and a prototype bean requested twice example, create a small implementation or design sketch that demonstrates @Component, @Service, @Repository, and @Controller/@RestController are stereotype annotations that register a class as a Spring bean.. Add a test case or scenario that would catch Assuming @Service, @Repository, and @Controller behave completely differently from @Component — functionally they are almost the same, differing mainly in semantics and (for @Repository) exception translation., and describe the expected result.

Quick quiz

Interview questions