Proxy pattern શું છે?

Question

Accepted Answer

**Proxy** pattern એક **placeholder અથવા surrogate** આપે છે અન્ય object માટે તેની access નિયંત્રિત કરવા માટે। proxy પાસે real object જેવો જ interface છે પણ behavior ઉમેરે છે — જેમ કે lazy loading, access control, caching, અથવા logging — પછી તેને delegate કરતાં પહેલાં.

## 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"
```

## Proxies ના પ્રકારો

```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
```

## Uses અને example

```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 સમજવું મૂલ્યવાન છે કારણ કે તે **useful structural pattern** છે objects ની access નિયંત્રિત કરવા માટે, practical applications સાથે, તેથી તે relevant design knowledge છે.

Proxy pattern એક surrogate આપે છે જેનો interface real object જેવો જ હોય, behavior ઉમેરતા હોય delegate કરતાં પહેલાં — નિયંત્રિત કરતા હોય real object ક્યારે અને કેવી રીતે access થાય છે.

સમજવું કે તે શું કરે છે (એક stand-in જે control અથવા behavior ઉમેરે છે જ્યારે transparently real object ને represent કરે છે) તે core knowledge છે.

**Types of proxies** સમજવું મૂલ્યવાન છે કારણ કે દરેક એક real need ને address કરે છે: **virtual proxies** (lazy initialization — heavy resources ની creation અથવા loading defer કરવી જ્યાં સુધી જરૂર ન હોય, performance માટે મહત્વનું), **protection proxies** (access control — permission check કરવી access allow કરતાં પહેલાં), **caching proxies** (re-fetching અથવા recomputing ટાળવા માટે results cache કરવું — common optimization), **remote proxies** (અન્ય locations માં objects represent કરવું, network calls hide કરવું), અને logging/smart proxies.

એ important cross-cutting concerns (lazy loading, access control, caching, remote access) cover કરે છે transparently apply કરે છે.

**Uses** સમજવું — ORMs (lazy-loading entities, very common real application), API clients (caching અને retry), JavaScript Proxy object, access control, અને remote service proxies — તેનું practical applicability સ્પષ્ટ કરે છે.

Proxy pattern real frameworks (ORMs lazy-load via proxies, JS પાસે built-in Proxy છે) માં દેખાય છે અને transparent રીતે access control, caching, અથવા lazy loading add કરવાનું clean રસ્તું છે object ની આસપાસ.

તેથી Proxy pattern useful structural pattern છે objects ની access નિયંત્રિત કરવા માટે (lazy loading, access control, caching, remote access) real applications (ORMs, API clients, JS Proxy) સાથે, અને તે શું કરે છે અને તેના types સમજવું relevant છે આ common needs માટે, Proxy pattern સમજવું valuable છે, practically-relevant design knowledge — useful pattern objects ની access transparently નિયંત્રિત કરવા માટે (lazy loading, caching, access control), real frameworks જેમ કે ORMs માં દેખાતું, અને important design knowledge object access ની આસપાસ cross-cutting behavior add કરવા માટે cleanly.