Design Patterns in Action(7)- Proxy

Photo by Alexa Soh on Unsplash

Simply put, the Proxy pattern is a way to avoid direct access to an object through a substitute, aka. Proxy. The proxy object looks like the same to the client as the real subject, so they will need to have the same interface. Requests from the client are passed to the real subject through the proxy, with a bit added flavour, e.g. caching, logging, encryption, etc. So in a way, it’s a bit like a middleware.

The participants in Proxy pattern:

  • Real Subject: object that the client really want.
  • Proxy Subject: a proxy that implements all real subject’s interface but does something extra without the client realising that.

The implementation of Proxy pattern is pretty simple, however, there’s another native implementation in JavaScript that encapsulates the pattern with an abstract API — feel free to take a look.

So, ours example will implement Proxy for the purpose of caching. Let’s take a look at python one. Note the real object fetches the bread label asynchronously so the proxy will cache the response to accelerate the speed to return the response to the client.

import asyncio
from abc import ABCMeta, abstractmethod

class IBread(metaclass=ABCMeta):
def label_bread():

class Bread(IBread):
kind_match = {
"Sourdough": "Your sourdough is here!",
"Ciabatta": "Your ciabatta is here!",
"Rye bread": "Your rye bread is here!",

def __init__(self):

async def label_bread(self, kind):
await asyncio.sleep(100)
return self.kind_match.get(kind)

class BreadProxy(IBread):
def __init__(self):
self.cache = {}
self.bread = Bread()

async def label_bread(self, kind):
if not self.cache.get(kind):
self.cache[kind] = await self.bread.label_bread(kind)
return self.cache[kind]
return self.cache[kind]

async def main():
breadProxy = BreadProxy()
await breadProxy.label_bread("Sourdough")
await breadProxy.label_bread("Sourdough")
await breadProxy.label_bread("Ciabatta")
await breadProxy.label_bread("Sourdough")

if __name__ == "__main__":

This is another with JavaScript:

sleep = (m) => new Promise((r) => setTimeout(r, m));

class Bread {
constructor() {}

async labelBread(kind) {
switch (kind) {
case "Sourdough":
await sleep(10);
return "Your sourdough is here!";
case "Ciabatta":
await sleep(100);
return "Your ciabatta is here!";
case "Rye bread":
await sleep(30);
return "Your rye bread is here!";

class BreadProxy {
constructor() {
this.cache = {};
this.bread = new Bread();

async labelBread(kind) {
if (this.cache[kind] == null) {
this.cache[kind] = await this.bread.labelBread(kind);
return this.cache[kind];

const breadProxy = new BreadProxy();
(async () => {
await breadProxy.labelBread("Sourdough");
await breadProxy.labelBread("Sourdough");
await breadProxy.labelBread("Ciabatta");
await breadProxy.labelBread("Sourdough");

That’s so much of it! Happy Reading!




Hi :)

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

Special Concepts about JavaScript & MongoDB

Project does not exists or it does not contain an Active Cloud Store

Faster React Lists using a Randomized Data Structure

I managed to highlight the little angel and create a link. This is beautiful!

Issue of AngularJS with jQuery — ngRepeat on Object with Wrap Function

Manipulating JavaScript Object

Dissecting WhatsApp Layout through React Native (part2)… Cont’d

Where can I download Samsung firmware?

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store


Hi :)

More from Medium

Design Patterns — Prototype Pattern

Chain Of Responsibility Design Pattern

Strategy Pattern — Exemplified!

Factory Design Pattern