Proxy: un intermediario con la misma cara

  • Lección 15 de 32
  • 10 min
  • Intermedio
  • 11 pasos

Una app que lee un catálogo enorme al arrancar, aunque casi nunca lo usa. Vas a poner delante un objeto con la misma interfaz que decide cuándo crearlo y quién puede tocarlo.

El archivo se lee
—
AppLazyCatalogGuardedCatalognew Proxyreactive()CatalogProxyLazyCatalogFileCatalogsettingsstateRemoteCatalogFileCatalogCataloginterfaceCatalogviewerLoggedCatalogLoggedCatalogcomponente Acomponente BAPIAPIlee todo el archivoAl arrancar la app▸const catalog = new FileCatalog();// el constructor lee todo el archivoshowHome(); // y el inicio no lo usael mismo contratoUn contrato, dos clasesinterface Catalog {find(id: string): Product;update(p: Product): void;}// FileCatalog lee el archivo// LazyCatalog se pone delanteFileCatalog: todavía noLazyCatalogclass LazyCatalog implements Catalog {private real?: FileCatalog;find(id: string) {▸this.real ??= new FileCatalog();return this.real.find(id);}// update(p) delega igual}se crea aquí, una vezfind() delegaLo que escribe la appconst catalog: Catalog =new LazyCatalog(); // aún no lee▸catalog.find("p1"); // crea y leecatalog.find("p2"); // reutilizaError: solo adminadmin pasaGuardedCatalogclass GuardedCatalog implements Catalog {// real y role llegan al crearloupdate(p: Product) {▸if (this.role !== "admin")throw new Error("solo admin");this.real.update(p);}}trampa setsolo lecturaProxy de JavaScriptconst asViewer = new Proxy(settings, {▸set(obj, key, value) {if (role !== "admin")throw new Error("solo lectura");return Reflect.set(obj, key, value);},});asViewer.theme = "light"; // Errorset: avisase vuelve a pintarVue 3import { reactive } from "vue";▸const state = reactive({ count: 0 });state.count; // get: anota quién leestate.count++; // set: avisacontrola el accesoañade un logMisma forma, otra intenciónmisma interfazlos dosenvuelven otro objetolos dosProxycontrola el accesoDecoratorañade comportamientouna clase normalTres ideas equivocadas«solo es cosa de redes»también vive en tu código«necesita Proxy de JS»una clase basta«no cuesta nada»cada llamada da un salto máscada find() va a la redLo que no se ve▸const p = catalog.find("p1");// parece una lectura en memoria// pero cada llamada va a la redcatalog === realCatalog; // falsecontrola el accesoProxy en una tablaproblemacontrolar el acceso a un objetosoluciónotro objeto, misma interfazusoscrear al usar, permisos, Vuevs Decoratormisma forma, otra intenciónno lo usessi esconde costos
  • petición
  • respuesta
  • petición fallida
  • evento
  • petición lenta

Paso 1 de 11

Problema

La app crea todo aunque no lo use

Una tienda tiene un FileCatalog: al crearse, lee del disco el archivo completo de productos. La app lo crea al arrancar con new FileCatalog() para tenerlo listo.

El problema: muchas pantallas, como la de inicio, nunca buscan un producto. La app paga la lectura del archivo en cada arranque, aunque nadie llegue a usar el catálogo.

Paso 2 de 11

Concepto

Un contrato que comparten los dos

Quien usa el catálogo no necesita saber qué clase tiene delante: le basta la interfaz Catalog, con find y update.

Un proxy es otro objeto que implementa esa misma interfaz y se pone delante del real. Quien llama no nota la diferencia; el proxy decide qué pasa antes de llegar al objeto real: crearlo, comprobar permisos o vigilar los cambios.

Paso 3 de 11

Solución

`LazyCatalog` crea el real cuando hace falta

LazyCatalog implementa Catalog, pero no lee nada al crearse: solo guarda un campo real vacío.

La primera vez que alguien llama a find, crea el FileCatalog con ??= y le pasa la llamada. update hace lo mismo. Ahora crear el catálogo al arrancar ya no lee el archivo.

Qué cambió

  • LazyCatalog
  • la lectura pasa al primer find

Paso 4 de 11

Técnica

La primera llamada crea, las demás reutilizan

La app llama a catalog.find("p1"). El proxy ve que real está vacío, crea el FileCatalog, le pasa la llamada y devuelve la respuesta.

En find("p2") el campo ya tiene el objeto y el proxy delega directo. El archivo se lee una sola vez, y solo si alguien busca un producto.

Paso 5 de 11

Solución

`GuardedCatalog` decide quién cambia precios

Otro uso: en el panel de la tienda, un admin puede cambiar precios y un viewer solo puede mirar. En vez de repetir el if del rol en cada pantalla, lo pone un proxy.

GuardedCatalog recibe el catálogo real y el rol. find pasa directo; update lanza un error si el rol no es admin. Las pantallas siguen usando un Catalog y no saben que hay un control.

Qué cambió

  • GuardedCatalog
  • el if del rol en cada pantalla

Paso 6 de 11

Técnica

JavaScript trae `Proxy` de serie

JavaScript tiene un objeto Proxy: new Proxy(objeto, handler) devuelve un envoltorio, y el handler define trampas (traps) que interceptan operaciones como leer (get) o escribir (set) una propiedad.

Aquí solo hay trampa set: leer asViewer.theme llega directo a settings, pero escribir lanza un error si role no es admin. Es el mismo proxy de permisos, sin escribir una clase.

Paso 7 de 11

Técnica

Vue usa proxies para saber qué repintar

En Vue 3, reactive() devuelve un proxy del objeto. Cuando un componente lee state.count, la trampa get anota que ese componente depende de count.

Cuando tu código escribe state.count++, la trampa set avisa a quienes lo leyeron y Vue los vuelve a pintar. Tú escribes un objeto normal; el proxy lleva la cuenta.

Paso 8 de 11

Compromiso

Misma forma, otra intención

Piensa en un LoggedCatalog que envuelve el catálogo y escribe un log en cada llamada: es un Decorator, como viste en su lección. En código se parece mucho a LazyCatalog: los dos implementan Catalog y llaman al objeto que envuelven.

La diferencia es la intención. Un Decorator añade comportamiento; un Proxy controla el acceso al real: cuándo se crea, quién entra, qué cambios se vigilan. Una caché puede ser cualquiera de los dos: nómbrala por lo que buscas.

Paso 9 de 11

Concepto

Tres ideas equivocadas sobre Proxy

En redes, un proxy es un servidor intermedio. El patrón usa la misma idea dentro de tu código: cualquier objeto que se pone delante de otro con su misma interfaz.

No necesitas el Proxy de JavaScript: LazyCatalog es una clase normal. Y no es gratis: cada llamada que pasa por el proxy da un salto más.

Paso 10 de 11

Compromiso

Cuándo un proxy esconde demasiado

Si find parece una lectura en memoria pero el proxy va a la red, quien llama no espera la demora ni los errores de red. La misma interfaz oculta un costo que convenía ver.

También cambia la identidad: el proxy es otro objeto, así que comparar con === contra el real da false, y al depurar hay un salto más. No lo uses si quien llama necesita saber qué pasa, ni en un bucle donde cada acceso extra pesa.

Paso 11 de 11

Resumen

Un intermediario con la misma cara

Un proxy implementa la misma interfaz que el objeto real y controla el acceso a él: lo crea en el primer uso, comprueba permisos o vigila cambios, como reactive() en Vue.

En el código se parece a un Decorator; la diferencia es la intención. Si esconde costos que quien llama debería ver, no lo uses.

Aprenderás

  • Reconocer cuándo conviene un intermediario: crear un objeto caro tarde o controlar quién lo usa.
  • Escribir un proxy que crea el objeto real solo cuando alguien lo necesita.
  • Usar un proxy para comprobar permisos sin cambiar a quien llama.
  • Reconocer el `Proxy` de JavaScript y cómo lo usa Vue para la reactividad.
  • Distinguir Proxy de Decorator y saber cuándo un proxy esconde demasiado.