Provides a surrogate or placeholder for another object to control access to it
AKA: Surrogate
More concretely, the proxy pattern creates a representative of some other resource or object in order to hide problems with interacting directly with that resource.
For example, we may not want to interact directly with an object, because:
A virtual proxy is a type of proxy we may want to use to defer the cost of creating or interacting with a resource until it is needed.
This may already remind you of the concept of lazy evaluation or lazy loading that we discussed earlier in the semester.
Imagine, for example, that we want to display a gallery of images in an application, but some images may be loaded remotely from the internet.
We could create a list of Image objects for our gallery and we could then iterate through the list to draw the images on the screen.
public class URLImage implements Image{
private final Image image;
public URLImage(URL url){
this.image = load(url);
}
//...
}
When we create the Image objects, though, we will have to wait for images to be loaded from the internet!
We can not even start drawing images in the gallery until all image data has been downloaded.
Instead, we could create a virtual proxy for images that need to be loaded from the internet which only store the URL.
We can create these quickly, then get started actually drawing our gallery without being delayed by download times.
Of course, we will still encounter delays when drawing proxied images.
Our proxies can be smart, though, so we can create a thread to do download and draw the actual image. In the meantime, we can draw a temporary image!
public class ImageProxy implements Image {
final URL url;
public ImageProxy(final URL url){
this.url = url;
}
public void draw(){
// draw temporary image
// start thread which will load, then draw real image
}
Even better, we can cache to avoid downloading the image again:
public void draw(){
if(image !=null){
image.draw();
}else{
// draw temporary image
// start download/draw thread
}
}
Another common use of proxies is to create a local object instance that corresponds to a resource or instance on another machine so that we can interact with that resource as if it were on our machine.
If we don’t want to use a proxy, but need to trigger a computation on another machine, what can we do?
First, they need to expose the function to us somehow. A common approach would be to use the HTTP protocol.
Then we could create a JSON input like:
{
"a":100,
"b":200
}
And send it to http://someserver.com/addition, which would, perhaps, return:
{
"result":300
}
We also need to create the necessary HTTP client, etc.
This is a lot of tedious work which should not be exposed to users of our code!
Instead, we could create a class which represents the computations available on the remote server and hide all of the HTTP interactions there.
public class ServerProxy{
private HttpClient client;
public ServerProxy(URL url){
client = new HttpClient(url);
}
public int add(int a, int b){
String json = buildAddReqBody(a,b);
Response response = client.get("/add", json);
int sum = extractSumFromRessponse(response);
return sum;
}
}
Now we can create a single instance of the proxy for our application:
ServerProxy proxy = new ServerProxy(url);
And anywhere we need to access the remote computation, we just interact with the local proxy instance!
int sum1 = proxy.add(10,20);
int sum2 = proxy.add(100,200);
Another interesting case is when we want to add additional protection to a resource or an object.
This pattern is more similar to the decorator pattern, as we’re wrapping some instance and adding authentication, authorization or something else to control if the actual interaction will be allowed.
The intent of a decorator is to add behavior transparently.
The intent of a proxy is to handle delegation of behavior.