Spring-இல் bean scope-கள் மற்றும் lifecycle callback-களை விளக்குங்கள்.

Question

IT Interview Practice · Accepted Answer

ஒரு **bean scope**, container எத்தனை instance-களை உருவாக்குகிறது மற்றும் அவை எவ்வளவு காலம் வாழ்கின்றன என்பதைக் கட்டுப்படுத்துகிறது. **Lifecycle callback-கள்**, ஒரு bean கட்டமைக்கப்பட்ட உடனேயும், அது அழிக்கப்படுவதற்கு சற்று முன்பும் code-ஐ இயக்க அனுமதிக்கின்றன.

## நீங்கள் உண்மையில் பயன்படுத்தும் scope-கள்

- **singleton** (default): ஒரு container-க்கு *ஒரு* பகிரப்பட்ட instance. Startup-இல் eager-ஆக உருவாக்கப்படுகிறது.
- **prototype**: bean கோரப்படும்/inject செய்யப்படும் ஒவ்வொரு முறையும் ஒரு *புதிய* instance.
- **request** / **session**: ஒரு HTTP request அல்லது session-க்கு ஒரு instance (web app-கள் மட்டுமே).

```java
@Service // singleton by default — one shared OrderService for the whole app
public class OrderService { }

@Component
@Scope("prototype") // fresh instance on every getBean/inject
public class ReportBuilder { }
```

**பாரம்பரிய பொறி:** ஒரு singleton-க்குள் ஒரு prototype-ஐ inject செய்வது. Singleton *ஒருமுறை* மட்டுமே wire செய்யப்படுகிறது, எனவே அது ஒரே ஒரு prototype instance-ஐ என்றென்றும் வைத்திருக்கிறது — "ஒவ்வொரு முறையும் புதியது" என்ற வாக்குறுதி உடைகிறது. `@Lookup`, ஒரு `ObjectProvider<ReportBuilder>`, அல்லது scoped-proxy மூலம் இதைச் சரிசெய்யுங்கள்.

## Lifecycle callback-கள்

```java
@Component
public class ConnectionPool {

@PostConstruct // runs after dependencies are injected, before use
    public void open() { /* open sockets, warm caches */ }

@PreDestroy // runs on graceful container shutdown (singletons only)
    public void close() { /* release resources */ }
}
```

முக்கியம்: prototype bean-களில் Spring `@PreDestroy`-ஐ அழைக்காது — அது அவற்றை ஒப்படைத்துவிட்டு அவற்றைக் கண்காணிப்பதை நிறுத்துகிறது, எனவே அவற்றின் cleanup *உங்கள்* பொறுப்பு.

## இது ஏன் முக்கியம்

இது Spring-ஐ மந்திரமாகக் கருதுபவர்களை, container-ஐ புரிந்துகொள்பவர்களிடமிருந்து பிரிக்கிறது. Singleton-ஒரு-prototype-ஐ-வைத்திருக்கும் bug ஒரு பிடித்தமான interview சூழ்நிலை, ஏனெனில் அது நுட்பமானது மற்றும் உண்மையான production bug-களை ஏற்படுத்துகிறது. Singleton-கள் **stateless மற்றும் thread-safe** ஆக இருக்க வேண்டும் (அவை அனைத்து request thread-கள் முழுவதும் பகிரப்படுகின்றன) என்பதை அறிவது, interviewer-கள் கேட்கும் நடைமுறை பாடம்.

நீங்கள் உண்மையில் பயன்படுத்தும் scope-கள்

Lifecycle callback-கள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்