Facade
Table of content
A Facade pattern hides the complexities of the system and provides an interface to the client from where the client can access the system. Dividing a system into subsystems helps reduce complexity. We need to minimize the communication and dependencies between subsystems. For this, we introduce a facade object that provides a single, simplified interface to the more general facilities of a subsystem.
Examples
The SCP command is a shortcut for SSH commands. A remote file copy could be done writing several commands with an SSH connection but it can be done in one command with SCP. So the SCP command is a facade for the SSH commands. Although it may not be coded in the object programming paradigm, it is a good illustration of the design pattern.
Cost
This pattern is very easy and has not additional cost.
Creation
This pattern is very easy to create.
Maintenance
This pattern is very easy to maintain.
Removal
This pattern is very easy to remove too.
Advises
- Do not use this pattern to mask only three or four method calls.
Implementations
Implementation in Java
This is an abstract example of how a client ("you") interacts with a facade (the "computer") to a complex system (internal computer parts, like CPU and HardDrive).
/* Complex parts */ class CPU { public void freeze() { ... } public void jump(long position) { ... } public void execute() { ... } } class Memory { public void load(long position, byte[] data) { ... } } class HardDrive { public byte[] read(long lba, int size) { ... } } /* Facade */ class Computer { private CPU processor; private Memory ram; private HardDrive hd; public Computer() { this.processor = new CPU(); this.ram = new Memory(); this.hd = new HardDrive(); } public void start() { processor.freeze(); ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE)); processor.jump(BOOT_ADDRESS); processor.execute(); } } /* Client */ class You { public static void main(String[] args) { Computer facade = new Computer(); facade.start(); } } Implementation in C#
using System; namespace Facade { public class CPU { public void Freeze() { } public void Jump(long addr) { } public void Execute() { } } public class Memory { public void Load(long position, byte[] data) { } } public class HardDrive { public byte[] Read(long lba, int size) { return null; } } public class Computer { var cpu = new CPU(); var memory = new Memory(); var hardDrive = new HardDrive(); public void StartComputer() { cpu.Freeze(); memory.Load(0x22, hardDrive.Read(0x66, 0x99)); cpu.Jump(0x44); cpu.Execute(); } } public class SomeClass { public static void Main(string[] args) { var facade = new Computer(); facade.StartComputer(); } } } Implementation in Ruby
# Complex parts class CPU def freeze; puts 'CPU: freeze'; end def jump(position); puts "CPU: jump to #{position}"; end def execute; puts 'CPU: execute'; end end class Memory def load(position, data) puts "Memory: load #{data} at #{position}" end end class HardDrive def read(lba, size) puts "HardDrive: read sector #{lba} (#{size} bytes)" return 'hdd data' end end # Facade class Computer BOOT_ADDRESS = 0 BOOT_SECTOR = 0 SECTOR_SIZE = 512 def initialize @cpu = CPU.new @memory = Memory.new @hard_drive = HardDrive.new end def start_computer @cpu.freeze @memory.load(BOOT_ADDRESS, @hard_drive.read(BOOT_SECTOR, SECTOR_SIZE)) @cpu.jump(BOOT_ADDRESS) @cpu.execute end end # Client facade = Computer.new facade.start_computer Implementation in Python
# Complex parts class CPU: def freeze(self): pass def jump(self, position): pass def execute(self): pass class Memory: def load(self, position, data): pass class HardDrive: def read(self, lba, size): pass # Facade class Computer: def __init__(self): self.cpu = CPU() self.memory = Memory() self.hard_drive = HardDrive() def start_computer(self): self.cpu.freeze() self.memory.load(0, self.hard_drive.read(0, 1024)) self.cpu.jump(10) self.cpu.execute() # Client if __name__ == '__main__': facade = Computer() facade.start_computer() Implementation in PHP
/* Complex parts */ class CPU { public function freeze() { /* ... */ } public function jump( $position ) { /* ... */ } public function execute() { /* ... */ } } class Memory { public function load( $position, $data ) { /* ... */ } } class HardDrive { public function read( $lba, $size ) { /* ... */ } } /* Facade */ class Computer { protected $cpu = null; protected $memory = null; protected $hardDrive = null; public function __construct() { $this->cpu = new CPU(); $this->memory = new Memory(); $this->hardDrive = new HardDrive(); } public function startComputer() { $this->cpu->freeze(); $this->memory->load( BOOT_ADDRESS, $this->hardDrive->read( BOOT_SECTOR, SECTOR_SIZE ) ); $this->cpu->jump( BOOT_ADDRESS ); $this->cpu->execute(); } } /* Client */ $facade = new Computer(); $facade->startComputer(); Implementation in JavaScript
/* Complex parts */ var CPU = function () {}; CPU.prototype = { freeze: function () { console.log('CPU: freeze'); }, jump: function (position) { console.log('CPU: jump to ' + position); }, execute: function () { console.log('CPU: execute'); } }; var Memory = function () {}; Memory.prototype = { load: function (position, data) { console.log('Memory: load "' + data + '" at ' + position); } }; var HardDrive = function () {}; HardDrive.prototype = { read: function (lba, size) { console.log('HardDrive: read sector ' + lba + '(' + size + ' bytes)'); return 'hdd data'; } }; /* Facade */ var Computer = function () { var cpu, memory, hardDrive; cpu = new CPU(); memory = new Memory(); hardDrive = new HardDrive(); var constant = function (name) { var constants = { BOOT_ADDRESS: 0, BOOT_SECTOR: 0, SECTOR_SIZE: 512 }; return constants[name]; }; this.startComputer = function () { cpu.freeze(); memory.load(constant('BOOT_ADDRESS'), hardDrive.read(constant('BOOT_SECTOR'), constant('SECTOR_SIZE'))); cpu.jump(constant('BOOT_ADDRESS')); cpu.execute(); } }; /* Client */ var facade = new Computer(); facade.startComputer(); Implementation in ActionScript 3.0
/* Complex Parts */ /* CPU.as */ package { public class CPU { public function freeze():void { trace("CPU::freeze"); } public function jump(addr:Number):void { trace("CPU::jump to", String(addr)); } public function execute():void { trace("CPU::execute"); } } } /* Memory.as */ package { import flash.utils.ByteArray; public class Memory { public function load(position:Number, data:ByteArray):void { trace("Memory::load position:", position, "data:", data); } } } /* HardDrive.as */ package { import flash.utils.ByteArray; public class HardDrive { public function read(lba:Number, size:int):ByteArray { trace("HardDrive::read returning null"); return null; } } } /* The Facade */ /* Computer.as */ package { public class Computer { public static const BOOT_ADDRESS:Number = 0x22; public static const BOOT_SECTOR:Number = 0x66; public static const SECTOR_SIZE:int = 0x200; private var _cpu:CPU; private var _memory:Memory; private var _hardDrive:HardDrive; public function Computer() { _cpu = new CPU(); _memory = new Memory(); _hardDrive = new HardDrive(); } public function startComputer():void { _cpu.freeze(); _memory.load(BOOT_ADDRESS, _hardDrive.read(BOOT_SECTOR, SECTOR_SIZE)); _cpu.jump(BOOT_ADDRESS); _cpu.execute(); } } } /* Client.as : This is the application's Document class */ package { import flash.display.MovieClip; public class Client extends MovieClip { private var _computer:Computer; public function Client() { _computer = new Computer(); _computer.startComputer(); } } } Implementation in Scala
/* Complex parts */ package intel { class CPU { def freeze() = ??? def jump(position: Long) = ??? def execute() = ??? } } package ram.plain { class Memory { def load(position: Long, data: Array[Byte]) = ??? } } package hdd { class HardDrive { def read(lba: Long, size: Int): Array[Byte] = ??? } } /* Facade */ //imports for the facade import common.patterns.intel.CPU import common.patterns.ram.plain.Memory import common.patterns.hdd.HardDrive package pk { class ComputerFacade(conf: String) { val processor: CPU = new CPU val ram: Memory = new Memory val hd: HardDrive = new HardDrive val BOOT_ADDRESS: Long = ??? val BOOT_SECTOR: Long = ??? val SECTOR_SIZE: Int = ??? def start() = { processor.freeze() ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE)) processor.jump(BOOT_ADDRESS) processor.execute() } } } //imports for your package import common.patterns.pk.ComputerFacade /* Client */ object You { def main(args: Array[String]) { new ComputerFacade("conf").start() } } Implementation in Delphi
program Facade; {$APPTYPE CONSOLE} {$R *.res} uses System.SysUtils; type (* complex parts - > Subsystem *) TCPU = class procedure Freeze; procedure Jump(position: Integer); procedure Execute; end; TMemory = class procedure Load(position: Integer; data: string); end; THardDrive = class function Read(lba, size: Integer): string; end; (* Facade *) TComputer = class fCPU: TCPU; fMemory: TMemory; fHardDrive: THardDrive; const BOOT_ADDRESS: Integer = 0; BOOT_SECTOR: Integer = 0; SECTOR_SIZE: Integer = 512; public procedure Start_Computer; constructor Create; end; { TCPU } procedure TCPU.Execute; begin WriteLn('CPU: execute'); end; procedure TCPU.Freeze; begin WriteLn('CPU: freese'); end; procedure TCPU.Jump(position: Integer); begin WriteLn('CPU: jump to ' + IntToStr(position)); end; { TMemory } procedure TMemory.Load(position: Integer; data: string); begin WriteLn('Memory: load "' + data + '" at ' + IntToStr(position)); end; { THardDrive } function THardDrive.Read(lba, size: Integer): string; begin WriteLn('HardDrive: read sector ' + IntToStr(lba) + ' (' + IntToStr(size) + ' bytes)'); Result := 'hdd data'; end; { TComputer } constructor TComputer.Create; begin fCPU := TCPU.Create; fMemory := TMemory.Create; fHardDrive := THardDrive.Create; end; procedure TComputer.Start_Computer; begin fCPU.Freeze; fMemory.Load(BOOT_ADDRESS, fHardDrive.Read(BOOT_SECTOR, SECTOR_SIZE)); fCPU.Jump(BOOT_ADDRESS); fCPU.Execute; end; var facad: TComputer; begin try { TODO -oUser -cConsole Main : Insert code here } facad := TComputer.Create; facad.Start_Computer; WriteLn(#13#10 + 'Press any key to continue...'); ReadLn; facad.Free; except on E: Exception do WriteLn(E.ClassName, ': ', E.Message); end; end.
