Home Original page

Proxy pattern

In computer programming, the proxy pattern is a software design pattern. A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. In the proxy, extra functionality can be provided, for example caching when operations on the real object are resource intensive, or checking preconditions before operations on the real object are invoked. For the client, usage of a proxy object is similar to using the real object, because both implement the same interface.

Overview

The Proxy [1] design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

What problems can the Proxy design pattern solve? [2]

  • The access to an object should be controlled.
  • Additional functionality should be provided when accessing an object.

When accessing sensitive objects, for example, it should be possible to check that clients have the needed access rights.

What solution does the Proxy design pattern describe?

Define a separate Proxy object that

  • can be used as substitute for another object (Subject) and
  • implements additional functionality to control the access to this subject.

This makes it possible to work through a Proxy object to perform additional functionality when accessing a subject. For example, to check the access rights of clients accessing a sensitive object.

To act as substitute for a subject, a proxy must implement the Subject interface. Clients can't tell whether they work with a subject or its proxy.

See also the UML class and sequence diagram below.

Structure

UML class and sequence diagram

A sample UML class and sequence diagram for the Proxy design pattern. [3]

In the above UML class diagram, the Proxy class implements the Subject interface so that it can act as substitute for Subject objects. It maintains a reference (realSubject) to the substituted object (RealSubject) so that it can forward requests to it (realSubject.operation).

The sequence diagram shows the run-time interactions: The Client object works through a Proxy object that controls the access to a RealSubject object. In this example, the Proxy forwards the request to the RealSubject, which performs the request.

Class diagram

Possible usage scenarios

Remote proxy

In distributed object communication, a local object represents a remote object (one that belongs to a different address space). The local object is a proxy for the remote object, and method invocation on the local object results in remote method invocation on the remote object. An example would be an ATM implementation, where the ATM might hold proxy objects for bank information that exists in the remote server.

Virtual proxy

In place of a complex or heavy object, a skeleton representation may be advantageous in some cases. When an underlying image is huge in size, it may be represented using a virtual proxy object, loading the real object on demand.

Protection proxy

A protection proxy might be used to control access to a resource based on access rights.

Example

C#

interface ICar { void DriveCar ; } // Real Object public class Car : ICar { public void DriveCar { Console.WriteLine("Car has been driven!"); } } // Proxy Object public class ProxyCar : ICar { private Driver driver; private ICar realCar; public ProxyCar(Driver driver) { this.driver = driver; this.realCar = new Car; } public void DriveCar { if (driver.Age < 16) Console.WriteLine("Sorry, the driver is too young to drive."); else this.realCar.DriveCar; } } public class Driver { public int Age { get; set; } public Driver(int age) { this.Age = age; } } // How to use above Proxy class? private void btnProxy_Click(object sender, EventArgs e) { ICar car = new ProxyCar(new Driver(15)); car.DriveCar; car = new ProxyCar(new Driver(25)); car.DriveCar; }

Output 

Sorry, the driver is too young to drive. Car has been driven!

Notes:

  • A proxy may hide information about the real object to the client.
  • A proxy may perform optimization like on demand loading.
  • A proxy may do additional house-keeping job like audit tasks.
  • Proxy design pattern is also known as surrogate design pattern.

C++

#include <iostream> #include <memory> class ICar { public: virtual ~ICar { std::cout << "ICar destructor!" << std::endl; } virtual void DriveCar = 0; }; class Car : public ICar { public: void DriveCar override { std::cout << "Car has been driven!" << std::endl; } }; class ProxyCar : public ICar { public: ProxyCar(int driver_age) : driver_age_(driver_age) {} void DriveCar override { if (driver_age_ > 16) { real_car_->DriveCar; } else { std::cout << "Sorry, the driver is too young to drive." << std::endl; } } private: std::unique_ptr<ICar> real_car_ = std::make_unique<Car>; int driver_age_; }; int main { std::unique_ptr<ICar> car = std::make_unique<ProxyCar>(16); car->DriveCar; car = std::make_unique<ProxyCar>(25); car->DriveCar; }

Crystal

abstract class AbstractCar abstract def drive end class Car < AbstractCar def drive puts "Car has been driven!" end end class Driver getter age : Int32 def initialize(@age) end end class ProxyCar < AbstractCar private getter driver : Driver private getter real_car : AbstractCar def initialize(@driver) @real_car = Car.new end def drive if driver.age <= 16 puts "Sorry, the driver is too young to drive." else @real_car.drive end end end # Program driver = Driver.new(16) car = ProxyCar.new(driver) car.drive driver = Driver.new(25) car = ProxyCar.new(driver) car.drive

Output 

Sorry, the driver is too young to drive. Car has been driven!

Delphi / Object Pascal

// Proxy Design pattern unit DesignPattern.Proxy; interface type // Car Interface ICar = interface procedure DriveCar; end; // TCar class, implementing ICar TCar = Class(TInterfacedObject, ICar) class function New: ICar; procedure DriveCar; End; // Driver Interface IDriver = interface function Age: Integer; end; // TDriver Class, implementing IDriver TDriver = Class(TInterfacedObject, IDriver) private FAge: Integer; public constructor Create(Age: Integer); Overload; class function New(Age: Integer): IDriver; function Age: Integer; End; // Proxy Object TProxyCar = Class(TInterfacedObject, ICar) private FDriver: IDriver; FRealCar: ICar; public constructor Create(Driver: IDriver); Overload; class function New(Driver: IDriver): ICar; procedure DriveCar; End; implementation { TCar Implementation } class function TCar.New: ICar; begin Result := Create; end; procedure TCar.DriveCar; begin WriteLn('Car has been driven!'); end; { TDriver Implementation } constructor TDriver.Create(Age: Integer); begin inherited Create; FAge := Age; end; class function TDriver.New(Age: Integer): IDriver; begin Result := Create(Age); end; function TDriver.Age: Integer; begin Result := FAge; end; { TProxyCar Implementation } constructor TProxyCar.Create(Driver: IDriver); begin inherited Create; Self.FDriver := Driver; Self.FRealCar := TCar.Create AS ICar; end; class function TProxyCar.New(Driver: IDriver): ICar; begin Result := Create(Driver); end; procedure TProxyCar.DriveCar; begin if (FDriver.Age <= 16) then WriteLn('Sorry, the driver is too young to drive.') else FRealCar.DriveCar; end; end.

Usage 

program Project1; {$APPTYPE Console} uses DesignPattern.Proxy in 'DesignPattern.Proxy.pas'; begin TProxyCar.New(TDriver.New(16)).DriveCar; TProxyCar.New(TDriver.New(25)).DriveCar; end.

Output 

Sorry, the driver is too young to drive. Car has been driven!

Java

The following Java example illustrates the "virtual proxy" pattern. The ProxyImage class is used to access a remote method.

The example creates first an interface against which the pattern creates the classes. This interface contains only one method to display the image, called displayImage, that has to be coded by all classes implementing it.

The proxy class ProxyImage is running on another system than the real image class itself and can represent the real image RealImage over there. The image information is accessed from the disk. Using the proxy pattern, the code of the ProxyImage avoids multiple loading of the image, accessing it from the other system in a memory-saving manner. The lazy loading demonstrated in this example is not part of the proxy pattern, but is merely an advantage made possible by the use of the proxy. 

interface Image { public void displayImage; } // On System A class RealImage implements Image { private final String filename; /**  * Constructor  * @param filename  */ public RealImage(String filename) { this.filename = filename; loadImageFromDisk; } /**  * Loads the image from the disk  */ private void loadImageFromDisk { System.out.println("Loading " + filename); } /**  * Displays the image  */ public void displayImage { System.out.println("Displaying " + filename); } } // On System B class ProxyImage implements Image { private final String filename; private RealImage image; /**  * Constructor  * @param filename  */ public ProxyImage(String filename) { this.filename = filename; } /**  * Displays the image  */ public void displayImage { if (image == null) { image = new RealImage(filename); } image.displayImage; } } class ProxyExample { /**  * Test method  */ public static void main(final String[] arguments) { Image image1 = new ProxyImage("HiRes_10MB_Photo1"); Image image2 = new ProxyImage("HiRes_10MB_Photo2"); image1.displayImage; // loading necessary image1.displayImage; // loading unnecessary image2.displayImage; // loading necessary image2.displayImage; // loading unnecessary image1.displayImage; // loading unnecessary } }

Output 

Loading HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo1 Loading HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo1

JavaScript

// Driver class class Driver { constructor (age) { this.age = age } } // Car class class Car { drive  { console.log('Car has been driven!') } } // Proxy car class class ProxyCar { constructor (driver) { this.car = new Car this.driver = driver } drive  { if (this.driver.age <= 16) { console.log('Sorry, the driver is too young to drive.') } else { this.car.drive } } } // Run program const driver = new Driver(16) const car = new ProxyCar(driver) car.drive const driver2 = new Driver(25) const car2 = new ProxyCar(driver2) car2.drive

Output 

Sorry, the driver is too young to drive. Car has been driven!

PHP

<?php interface Image { public function displayImage; } // On System A class RealImage implements Image { private string $filename = null; public function __construct(string $filename) { $this->filename = $filename; $this->loadImageFromDisk; } /**  * Loads the image from the disk  */ private function loadImageFromDisk { echo "Loading {$this->filename}" . \PHP_EOL; } /**  * Displays the image  */ public function displayImage { echo "Displaying {$this->filename}" . \PHP_EOL; } } // On System B class ProxyImage implements Image { private ?Image $image = null; private string $filename = null; public function __construct(string $filename) { $this->filename = $filename; } /**  * Displays the image  */ public function displayImage { if ($this->image === null) { $this->image = new RealImage($this->filename); } $this->image->displayImage; } } $image1 = new ProxyImage("HiRes_10MB_Photo1"); $image2 = new ProxyImage("HiRes_10MB_Photo2"); $image1->displayImage; // Loading necessary $image1->displayImage; // Loading unnecessary $image2->displayImage; // Loading necessary $image2->displayImage; // Loading unnecessary $image1->displayImage; // Loading unnecessary

Output 

Loading HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo1 Displaying HiRes_10MB_Photo1 Loading HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo2 Displaying HiRes_10MB_Photo1

Python

""" Proxy pattern example. """ from abc import ABCMeta, abstractmethod NOT_IMPLEMENTED = "You should implement this." class AbstractCar: __metaclass__ = ABCMeta @abstractmethod def drive(self): raise NotImplementedError(NOT_IMPLEMENTED) class Car(AbstractCar): def drive(self) -> None: print("Car has been driven!") class Driver: def __init__(self, age: int) -> None: self.age = age class ProxyCar(AbstractCar): def __init__(self, driver) -> None: self.car = Car self.driver = driver def drive(self) -> None: if self.driver.age <= 16: print("Sorry, the driver is too young to drive.") else: self.car.drive driver = Driver(16) car = ProxyCar(driver) car.drive driver = Driver(25) car = ProxyCar(driver) car.drive

Output 

Sorry, the driver is too young to drive. Car has been driven!

Rust

trait ICar {  fn drive(&self); } struct Car {} impl ICar for Car {  fn drive(&self) {  println!("Car has been driven!");  } } impl Car {  fn new -> Car {  Car {}  } } struct ProxyCar<'a> {  real_car: &'a ICar,  driver_age: i32, } impl<'a> ICar for ProxyCar<'a> {  fn drive(&self) {  if self.driver_age > 16 {  self.real_car.drive;  } else {  println!("Sorry, the driver is too young to drive.")  }  } } impl<'a> ProxyCar<'a> {  fn new(driver_age: i32, other_car: &'a ICar) -> ProxyCar {  ProxyCar {  real_car: other_car,  driver_age: driver_age,  }  } } #[cfg(test)] mod tests {  use super::*;    #[test]  fn test_underage {  let car = Car::new;  let proxy_car = ProxyCar::new(16, &car);  proxy_car.drive;  }  #[test]  fn test_can_drive {  let car = Car::new;  let proxy_car = ProxyCar::new(17, &car);  proxy_car.drive;  } }

Output 

Sorry, the car is to young for you to drive. Car has been driven!

See also

References

  1. ^ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 207ff. ISBN 0-201-63361-2.
  2. ^ "The Proxy design pattern - Problem, Solution, and Applicability". w3sDesign.com. Retrieved 2017-08-12.
  3. ^ "The Proxy design pattern - Structure and Collaboration". w3sDesign.com. Retrieved 2017-08-12.

External links

This article is copied from an article on Wikipedia® - the free encyclopedia created and edited by its online user community. The text was not checked or edited by anyone on our staff. Although the vast majority of Wikipedia® encyclopedia articles provide accurate and timely information, please do not assume the accuracy of any particular article. This article is distributed under the terms of GNU Free Documentation License.