@Lazy Beans in Spring / Spring Boot

In Spring Boot, beans are created eagerly by default, meaning all singleton beans are instantiated at application startup.

The @Lazy annotation allows you to delay bean creation until the bean is actually needed.

In simple words:

@Lazy = Create the bean only when it is first used, not at startup.

Default Bean Creation Behavior (Without @Lazy)

By default, Spring uses eager initialization for singleton beans.

@Component
publicclassReportService {

publicReportService() {
        System.out.println("ReportService created");
    }
}

What Happens Internally

1. Application starts
2. Spring scans components
3. ReportService bean is created
4. Constructor runs immediately
5. Message is printed at startup

What @Lazy Does

When a bean is marked with @Lazy:

• Spring does not create the bean at startup
• A proxy object is injected instead
• The real bean is created on first access
• Bean lifecycle begins at runtime

Key Points:

• Only creation timing changes, scope remains the same
• Singleton beans are still singleton; prototype beans are naturally lazy
• Reduces startup time and memory usage

Internal Working of @Lazy (Execution Flow)

The internal steps when @Lazy is used are:

Step 1: Proxy Object Injection

• Spring injects a proxy object instead of the real bean
• The real bean is NOT created yet
• Proxy knows how to create the bean when first needed

Example:

@Service
publicclassPaymentService {
publicPaymentService() {
        System.out.println("PaymentService constructor called");
    }

publicvoidprocessPayment() {
        System.out.println("Payment processed");
    }
}

@Service
publicclassOrderService {

@Autowired
@Lazy
private PaymentService paymentService;// Proxy injected here

publicvoidplaceOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();// Real bean created here
    }
}

Step 2: Bean Creation Is Delayed

During application startup:

• Lazy bean is not instantiated.
• Constructor is not executed.
• @PostConstruct is not called.

Example with @PostConstruct:

@Service
@Lazy
publicclassPaymentService {

publicPaymentService() {
        System.out.println("PaymentService constructor called");
    }

@PostConstruct
publicvoidinit() {
        System.out.println("PaymentService @PostConstruct called");
    }

publicvoidprocessPayment() {
        System.out.println("Payment processed");
    }
}

Startup Output:

OrderServiceconstructor called

• Notice: No PaymentService output yet because it’s lazy.

Step 3: First Method Call Triggers Bean Creation

When the application first uses the bean:

• Method is called on the proxy
• Spring creates the real bean
• Dependencies are injected
• Lifecycle callbacks (@PostConstruct) are executed
• Proxy forwards the method call to the real bean

Example Usage:

@SpringBootApplication
publicclassApp {
publicstaticvoidmain(String[] args) {
ApplicationContextcontext= SpringApplication.run(App.class, args);
OrderServiceorderService= context.getBean(OrderService.class);
        orderService.placeOrder();// Lazy bean created here
    }
}

Output:

OrderService constructorcalled
Placing order...
PaymentService constructorcalled
PaymentService@PostConstructcalled
Payment processed

Diagram:

Application Startup
        ↓
@Lazy BeanNOT Created
        ↓
FirstMethodCallon Bean
        ↓
Real Bean Instance Created
        ↓
Dependencies Injected
        ↓
@PostConstruct Executed
        ↓
Method Execution Continues

Usage Scenarios of @Lazy

@Lazy is used to delay bean creation until it is first needed, improving startup performance, resolving circular dependencies, and controlling resource-heavy beans selectively.

1. Using @Lazy at Class Level

Applying @Lazy on a class makes the bean lazy everywhere, meaning it is created only when first accessed in the application, not at startup.

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
publicclassReportService {

publicReportService() {
        System.out.println("Lazy ReportService created");
    }

publicvoidgenerateReport() {
        System.out.println("Generating report...");
    }
}

Behavior:

• Bean is lazy everywhere.
• Created only when first accessed in the application.
• @PostConstruct (if present) is executed after bean creation.

Example:

ReportServicereportService= context.getBean(ReportService.class);
reportService.generateReport();

Output:

Lazy ReportService created
Generating report...

2. Using @Lazy at Injection Point (Field Injection)

Applying @Lazy at a field delays the creation of that specific dependency; the containing bean is created at startup, but the lazy bean is instantiated only when first accessed.

@Service
publicclassOrderService {

@Autowired
@Lazy
private PaymentService paymentService;

publicvoidplaceOrder() {
        paymentService.pay();
    }
}

Behavior:

• OrderService is created at startup.
• PaymentService is not created until placeOrder() is called.
• Provides fine-grained lazy control for specific dependencies.

3. Using @Lazy with Constructor Injection (Recommended)

When @Lazy is applied to a constructor parameter, the dependency is created only when first used, providing a clean, testable, and safe way to manage lazy beans.

@Service
publicclassOrderService {

privatefinal PaymentService paymentService;

publicOrderService(@Lazy PaymentService paymentService) {
this.paymentService = paymentService;
    }
}

Advantages:

• Clean and explicit dependency management.
• Testable and safe.
• Best practice over field injection.
• Bean is created only when first used, preserving constructor safety.

4. Using @Lazy with @Bean Methods

Applying @Lazy on a @Bean method delays the bean’s creation until it is explicitly requested from the application context, which is useful for heavy or resource-intensive beans.

@Configuration
publicclassAppConfig {

@Bean
@Lazy
public HeavyServiceheavyService() {
returnnewHeavyService();
    }
}

Behavior:

• Bean is created only when requested from the application context.
• Useful for heavy or resource-intensive beans.

5. Global Lazy Initialization

Enabling spring.main.lazy-initialization=true makes all singleton beans lazy by default, improving startup time, but delays error detection, as configuration issues appear only at runtime.

spring.main.lazy-initialization=true

Behavior:

• Makes all singleton beans lazy by default.
• Speeds up startup for large applications.
• Useful for microservices or modular applications.

Risks:

• Configuration errors appear only at runtime.
• Startup validation (e.g., missing beans) is skipped.

6. Resolving Circular Dependencies

Using @Lazy on one of the dependent beans lets Spring inject a proxy and delay bean creation, breaking the circular reference and allowing the application to start.

Problem Without @Lazy:

When two or more beans depend on each other, Spring cannot create them at startup, causing a circular dependency error and preventing the application from starting.

@Service
publicclassAService {
@Autowired
private BService bService;
}

@Service
publicclassBService {
@Autowired
private AService aService;
}

• Application fails at startup due to circular dependency.

Temporary Fix Using @Lazy:

Applying @Lazy on one of the dependent beans allows Spring to inject a proxy and delay its creation, resolving the circular dependency at startup.

@Service
publicclassAService {

@Autowired
@Lazy
private BService bService;
}

@Service
publicclassBService {

@Autowired
private AService aService;
}

Behavior:

• Spring injects a proxy for BService.
• Circular dependency is resolved, and the application starts.
• Workaround: not a design solution—better to refactor if possible.

7. @Lazy vs ObjectProvider (Advanced Usage)

ObjectProvider allows explicit retrieval of a bean when needed, giving fine-grained control without hidden proxies, whereas @Lazy uses a proxy to delay creation automatically.

@Service
publicclassOrderService {

privatefinal ObjectProvider<PaymentService> provider;

publicOrderService(ObjectProvider<PaymentService> provider) {
this.provider = provider;
    }

publicvoidplaceOrder() {
PaymentServicepaymentService= provider.getObject();
        paymentService.pay();
    }
}

Behavior:

• No hidden proxy is created.
• Explicit bean retrieval gives fine-grained control over bean lifecycle.
• Easier to debug and understand compared to @Lazy proxies.

8. Using @Lazy with @Transactional

Applying @Lazy to transactional beans adds extra proxy layers on top of the existing @Transactional proxy, which can cause unexpected behavior. It’s best to keep transactional beans eager and use @Lazy only for non-critical or heavy beans.

Recommendation:

• Keep transactional beans eager.
• Use @Lazy only for heavy or helper beans.

9. Using @Lazy with AOP (Aspects)

• Aspects (e.g., logging, security, auditing) are applied only when the bean is created.
• Lazy beans delay aspect activation.
• Can cause unexpected behavior if aspects are critical at startup.

Tip: Avoid @Lazy on critical AOP components.

10. Thread Safety

• Lazy initialization is thread-safe.
• Spring ensures only one instance of a singleton bean is created, even if multiple threads access it simultaneously.
• No additional synchronization required.

Limitations of @Lazy

• Errors appear at runtime, not startup

• Debugging becomes harder
• Small performance overhead due to proxies
• Can hide poor architectural design

When to Use @Lazy

• Heavy resource-intensive beans
• Optional integrations
• External API clients
• Rarely used features
• Startup optimization in large applications

When NOT to Use @Lazy

• Core application beans
• Security and authentication beans
• Database or transaction managers
• Beans required during startup validation

Conclusion

@Lazy is a powerful Spring feature that helps optimize application startup time and memory usage by delaying bean creation until it is actually required.

However, @Lazy should be treated as an optimization tool, not a design fix. Overusing it can hide architectural issues, delay error detection, and make debugging more difficult.