Proxy pattern என்றால் என்ன?

Question

Accepted Answer

**Proxy** pattern ஒரு பொருளுக்கு **placeholder அல்லது surrogate** வழங்கும் இது அந்த பொருளுக்கான access ஐ கட்டுப்படுத்த உதவுகிறது. proxy இல் real object போன்ற same interface இருக்கும் ஆனால் அது அதற்கு delegate செய்வதற்கு முன்பு lazy loading, access control, caching, அல்லது logging போன்ற நடத்தை சேர்க்கிறது.

## Proxy pattern என்ன செய்கிறது

```text
PROXY → an object that STANDS IN for another, controlling access to it:
  → same interface as the real object (clients use it transparently)
  → adds behavior BEFORE/AROUND delegating to the real object
  → controls WHEN and HOW the real object is accessed
→ "a stand-in that adds control/behavior"
```

## Proxy களின் வகைகள்

```text
VIRTUAL proxy → LAZY initialization → create/load the real object only when needed
  (e.g. defer loading a heavy resource until first use)
PROTECTION proxy → ACCESS CONTROL → check permissions before allowing access
CACHING proxy → cache results → return cached data instead of re-fetching/recomputing
REMOTE proxy → represent an object in another location (network/remote calls hidden)
LOGGING/smart proxy → add logging, reference counting, etc. around access
```

## பயன்பாடுகள் மற்றும் உதாரணம்

```js
// a caching proxy wraps a service, caching results
class CachingProxy {
  constructor(service) { this.service = service; this.cache = {}; }
  fetch(id) {
    if (!this.cache[id]) this.cache[id] = this.service.fetch(id);  // cache misses
    return this.cache[id];   // serve from cache otherwise
  }
}
```

```text
USES → ORMs (lazy-loading entities), API clients (caching/retry), JS Proxy object,
  access control, virtual proxies for heavy objects, remote service proxies
```

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

Proxy pattern ஐ புரிந்துகொள்வது மதிப்பளிக்கும் ஏனெனில் இது **பொருட்களுக்கான access ஐ கட்டுப்படுத்த ஒரு பயனுள்ள structural pattern** இது practical பயன்பாடுகளுடன் கூடியது, எனவே இது relevant design அறிவு.

Proxy pattern real object போன்ற same interface உடன் surrogate வழங்குகிறது, அதற்கு delegate செய்வதற்கு முன்பு நடத்தை சேர்க்கிறது — real object access செய்யப்படும் போது மற்றும் எப்படி access செய்யப்படுகிறது என்பதை கட்டுப்படுத்துகிறது.

இது என்ன செய்கிறது என்பதை புரிந்துகொள்வது (real object ஐ transparently பிரதிநிதித்வம் செய்யும் while control அல்லது நடத்தை சேர்க்கும் stand-in) core அறிவு.

**Proxy களின் வகைகள்** ஐ புரிந்துகொள்வது மதிப்பளிக்கும் ஏனெனில் ஒவ்வொரு real need ஐ address செய்கிறது: **virtual proxies** (lazy initialization — heavy resources ஐ creation அல்லது loading defer செய்தல் needed வரை, performance க்கு important), **protection proxies** (access control — access allow செய்வதற்கு முன்பு permissions check செய்தல்), **caching proxies** (results ஐ cache செய்யுதல் re-fetching அல்லது recomputing தவிர்க்க — ஒரு common optimization), **remote proxies** (other locations இல் உள்ள objects ஐ represent செய்தல், network calls hide செய்தல்), மற்றும் logging/smart proxies.

இவை important cross-cutting concerns (lazy loading, access control, caching, remote access) ஐ transparently பயன்படுத்துகிறது.

**பயன்பாடுகள்** ஐ புரிந்துகொள்வது — ORMs (lazy-loading entities, very common real application), API clients (caching மற்றும் retry), JavaScript Proxy object, access control, மற்றும் remote service proxies — அதன் practical applicability ஐ clarify செய்கிறது.

Proxy pattern real frameworks இல் தோன்றுகிறது (ORMs lazy-load via proxies, JS built-in Proxy உள்ளது) மற்றும் access control, caching, அல்லது lazy loading ஐ transparently ஒரு object around சேர்க்க clean வழி.

Proxy pattern ஒரு பயனுள்ள structural pattern அதன் object access கட்டுப்படுத்தும் (lazy loading, access control, caching, remote access) real applications உடன் (ORMs, API clients, JS Proxy), மற்றும் இது என்ன செய்கிறது மற்றும் அதன் வகைகள் புரிந்துகொள்வது relevant இந்த common needs க்கு இருப்பதால், Proxy pattern ஐ புரிந்துகொள்வது மதிப்பளிக்கும், practically-relevant design அறிவு — ஒரு பயனுள்ள pattern object access transparently கட்டுப்படுத்த (lazy loading, caching, access control), ORMs போன்ற real frameworks இல் தோன்றும், மற்றும் object access around cross-cutting நடத்தை cleanly சேர்க்க important design அறிவு.