Qu'est-ce que le pattern Proxy ?

Question

Accepted Answer

Le pattern **Proxy** fournit un **substitut ou un intermédiaire** pour un autre objet afin de contrôler l'accès à celui-ci. Le proxy a la même interface que l'objet réel mais ajoute du comportement — comme le chargement différé, le contrôle d'accès, la mise en cache ou la journalisation — avant de déléguer à celui-ci.

## Ce que fait le pattern Proxy

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

## Types de 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
```

## Utilisations et exemple

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

## Pourquoi c'est important

Comprendre le pattern Proxy est précieux car c'est un **pattern structurel utile** pour contrôler l'accès aux objets, avec des applications pratiques, c'est donc une connaissance de conception pertinente.

Le pattern Proxy fournit un substitut avec la même interface qu'un objet réel, ajoutant du comportement avant de déléguer à celui-ci — contrôlant quand et comment l'objet réel est accédé.

Comprendre ce qu'il fait (un intermédiaire qui ajoute du contrôle ou du comportement tout en représentant transparemment l'objet réel) est la connaissance fondamentale.

Comprendre les **types de proxies** est précieux car chacun répond à un besoin réel : les **proxies virtuels** (initialisation différée — différer la création ou le chargement de ressources lourdes jusqu'à ce qu'elles soient nécessaires, important pour les performances), les **proxies de protection** (contrôle d'accès — vérifier les permissions avant d'autoriser l'accès), les **proxies de mise en cache** (mettre en cache les résultats pour éviter de réinitialiser ou de recalculer — une optimisation courante), les **proxies distants** (représenter des objets dans d'autres emplacements, masquer les appels réseau) et les proxies de journalisation/intelligents.

Ceux-ci couvrent les préoccupations transversales importantes (chargement différé, contrôle d'accès, mise en cache, accès distant) appliquées de manière transparente.

Comprendre les **utilisations** — les ORMs (chargement différé des entités, une application réelle très courante), les clients API (mise en cache et retry), l'objet Proxy JavaScript, le contrôle d'accès et les proxies de service distant — clarifie son applicabilité pratique.

Le pattern Proxy apparaît dans les frameworks réels (les ORMs chargent différé via des proxies, JS a un Proxy intégré) et c'est le moyen propre d'ajouter du contrôle d'accès, de la mise en cache ou du chargement différé de manière transparente autour d'un objet.

Puisque le pattern Proxy est un pattern structurel utile pour contrôler l'accès aux objets (chargement différé, contrôle d'accès, mise en cache, accès distant) avec des applications réelles (ORMs, clients API, Proxy JS), et puisque comprendre ce qu'il fait et ses types est pertinent pour ces besoins courants, comprendre le pattern Proxy est une connaissance de conception utile et pertinente en pratique — un pattern utile pour contrôler l'accès aux objets de manière transparente (chargement différé, mise en cache, contrôle d'accès), apparaissant dans les frameworks réels comme les ORMs, et une connaissance de conception importante pour ajouter du comportement transversal autour de l'accès aux objets de manière propre.