Wikipedia

Proxy pattern: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
Bender the Bot (talk | contribs)
Bots
1,064,377 edits
m →External links: HTTP to HTTPS for SourceForge
 
(37 intermediate revisions by 27 users not shown)
Line 1:
{{short description|Software design 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 (object-oriented programming)|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
<ref name="GoF">{{cite book|author=Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides|title=Design Patterns: Elements of Reusable Object-Oriented Software|year=1994|publisher=Addison Wesley|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/207 207ff]|url-access=registration|url=https://archive.org/details/designpatternsel00gamm/page/207}}</ref>
|title=Design Patterns: Elements of Reusable Object-Oriented Software|year=1994|publisher=Addison Wesley|isbn=0-201-63361-2
|pages=207ff}}</ref>
design pattern is one of the twenty-three well-known
''[[Design Patterns|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? ===
Source:<ref>{{cite web|title=The Proxy design pattern - Problem, Solution, and Applicability|url=http://w3sdesign.com/?gr=s07&ugr=proble|website=w3sDesign.com|accessdateaccess-date=2017-08-12}}</ref>===
 
* The access to an object should be controlled.
* Additional functionality should be provided when accessing an object.
Line 20 ⟶ 19:
 
Define a separate <code>Proxy</code> object that
* can be used as a substitute for another object (<code>Subject</code>), and
* implements additional functionality to control the access to this subject.
 
This enablesmakes it possible to work through a <code>Proxy</code> object to perform additional functionality when accessing a subject. For example, tolike checkchecking the access rights of clients accessing a sensitive object.
 
<br>
To act as a substitute for a subject, a proxy must implement the <code>Subject</code> interface. Clients can't tell whether they work with a subject or its proxy.
Clients can't tell whether they work with a subject or its proxy.
See also the UML class and sequence diagram below.
Line 33 ⟶ 31:
=== UML class and sequence diagram ===
[[File:w3sDesign Proxy Design Pattern UML.jpg|frame|none|A sample UML class and sequence diagram for the Proxy design pattern.
<ref>{{cite web|title=The Proxy design pattern - Structure and Collaboration|url=http://w3sdesign.com/?gr=s07&ugr=struct|website=w3sDesign.com|accessdateaccess-date=2017-08-12}}</ref>]]
 
In the above [[Unified Modeling Language|UML]] [[Class diagram|class diagram]],
the <code>Proxy</code> class implements the <code>Subject</code> interface so that it can act as substitute for <code>Subject</code> objects. It maintains a reference (<code>realSubject</code>)
to the substituted object (<code>RealSubject</code>) so that it can forward requests to it
Line 47 ⟶ 45:
 
=== Class diagram ===
[[File:proxy_pattern_diagram.svg|frame|none|400px|Proxy in [[Unified Modeling Language|UML]]]]
 
[[File:Proxy pattern in LePUS3.gif|frame|none|300px|Proxy in [[Lepus3|LePUS3]] ([https://web.archive.org/web/20180314162121/http://www.lepus.org.uk/ref/legend/legend.xml legend])]]
 
== 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 [[Automated teller machine|ATM]] implementation, where the ATM might hold proxy objects for bank information that exists in the remote server. kurac
 
===Virtual proxy===
Line 62 ⟶ 60:
A protection proxy might be used to control access to a resource based on access rights.
 
==Example==
<!-- Wikipedia is not a list of examples. Do not add examples from your favorite programming language here; this page exists to explain the design pattern, not to show how it interacts with subtleties of every language under the sun. Feel free to add examples here: http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Proxy -->
 
{{Wikibooks|Computer Science Design Patterns|Proxy|Proxy implementations in various languages}}
 
=== PHP ===
<source lang=PHP>
<?php
 
interface Image {
public function displayImage();
}
 
// On System A
class RealImage implements Image {
 
private $filename = null;
/**
* Constructor
* @param $filename
*/
public function __construct($filename) {
$this->filename = $filename;
$this->loadImageFromDisk();
}
 
/**
* Loads the image from the disk
*/
private function loadImageFromDisk() {
echo "Loading {$this->filename} \r\n";
}
 
/**
* Displays the image
*/
public function displayImage() {
echo "Displaying {$this->filename} \r\n";
}
 
}
 
// On System B
class ProxyImage implements Image {
 
private $image = null;
private $filename = null;
/**
* Constructor
* @param $filename
*/
public function __construct($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
</source>
 
The program's output is:
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
 
=== C# ===
<source lang="CSharp">
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();
}
</source>
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++ ===
<source lang=Cpp>
class ICar {
public:
virtual void DriveCar() = 0;
virtual ~ICar () {
std::cout << "ICar destructor!" << std::endl;
}
};
 
class Car : public ICar {
void DriveCar() override {
std::cout << "Car has been driven!" << std::endl;
}
};
 
class ProxyCar : public ICar {
private:
ICar* realCar;
int _driver_age;
 
public:
ProxyCar (int driver_age) : realCar(new Car()), _driver_age(driver_age) {}
~ProxyCar () {
delete realCar;
}
 
void DriveCar() {
if (_driver_age > 16)
realCar->DriveCar();
else
std::cout << "Sorry, the driver is too young to drive." << std::endl;
}
};
 
// How to use above Proxy class?
int main()
{
ICar* car = new ProxyCar(16);
car->DriveCar();
delete car;
 
car = new ProxyCar(25);
car->DriveCar();
delete car;
}
</source>
 
=== Crystal ===
<source lang=Ruby>
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
</source>
 
Output
Sorry, the driver is too young to drive.
Car has been driven!
 
=== Delphi / Object Pascal ===
<source lang=Delphi>
// 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.
</source>
 
Usage
<source lang=Delphi>
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.
</source>
 
Output
Sorry, the driver is too young to drive.
Car has been driven!
 
=== Java ===
The following [[Java (programming language)|Java]] example illustrates the "virtual proxy" pattern. The <tt>ProxyImage</tt> 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 <tt>displayImage()</tt>, that has to be coded by all classes implementing it.
 
The proxy class <tt>ProxyImage</tt> is running on another system than the real image class itself and can represent the real image <tt>RealImage</tt> over there. The image information is accessed from the disk. Using the proxy pattern, the code of the <tt>ProxyImage</tt> 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.
 
<source lang=Java>
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
}
}
</source>
 
The program's output is:
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===
<source lang="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):
print("Car has been driven!")
 
 
class Driver(object):
def __init__(self, age):
self.age = age
 
 
class ProxyCar(AbstractCar):
def __init__(self, driver):
self.car = Car()
self.driver = driver
 
def drive(self):
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()
</source>
 
===Rust===
<source lang="rust">
trait ICar {
fn drive(&self);
}
 
struct Car {}
 
impl ICar for Car {
fn drive(&self) {
println!("brum brum");
}
}
 
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!("no brum brum for you")
}
}
}
 
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_can_drive() {
let car = Car::new();
let proxy_car = ProxyCar::new(17, &car);
proxy_car.drive();
}
#[test]
fn test_underage() {
let car = Car::new();
let proxy_car = ProxyCar::new(16, &car);
proxy_car.drive();
}
}
</source>
==See also==
* [[Composite pattern]]
Line 640 ⟶ 66:
 
==References==
{{Reflist|2}}
 
==External links==
{{Wikibooks|Computer Science Design Patterns|Proxy|Proxy implementations in various languages}}
{{Commons category}}
* {{cite web |last1=Geary |first1=David |date=2002-02-22 |df=mdy |url=https://www.infoworld.com/article/2074068/take-control-with-the-proxy-design-pattern.html |title=Take control with the Proxy design pattern |work=[[JavaWorld]] |access-date=2020-07-20}}
* [http://www.lepus.org.uk/ref/companion/Proxy.xml Proxy pattern in UML and in LePUS3 (a formal modelling language)]
* [https://perfectjpattern.sourceforge.net/dp-proxy.html PerfectJPattern Open Source Project], Provides componentized implementation of the Proxy Pattern in Java
* [http://www.javaworld.com/javaworld/jw-02-2002/jw-0222-designpatterns.html Take control with the Proxy design pattern] by [[David Geary, JavaWorld.com]]
* {{webarchive |url=https://web.archive.org/web/20120311202925/http://www.netobjectives.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison |title=Adapter vs. Proxy vs. Facade Pattern Comparison}}
* [http://perfectjpattern.sourceforge.net/dp-proxy.html PerfectJPattern Open Source Project], Provides componentized implementation of the Proxy Pattern in Java
* [https://sourcemaking.com/design_patterns/proxy Proxy Design Pattern]
* [http://www.netobjectives.com/PatternRepository/index.php?title=AdapterVersusProxyVersusFacadePatternComparison Adapter vs. Proxy vs. Facade Pattern Comparison]
* {{webarchive |url=https://web.archive.org/web/20141019100543/http://patterns.org.pl/proxy.html |title=Proxy pattern C++ implementation example}}
* [http://sourcemaking.com/design_patterns/proxy Proxy Design Pattern]
* [https://webwiki.archivec2.orgcom/web/20141019100543/http://patterns.org.pl/proxy.html?ProxyPattern Proxy pattern C++description from the Portland implementationPattern exampleRepository]
* [http://c2.com/cgi/wiki?ProxyPattern Proxy pattern description from the Portland Pattern Repository]
 
{{Design Patterns Patterns}}
Retrieved from "https://en.wikipedia.org/wiki/Proxy_pattern"