CSC/ECE 517 Fall 2012/ch2b 2w39 ka

Introduction

In this section we will be discussing about the decorator pattern and its related patterns such as adapter pattern,proxy pattern and composite pattern.

Decorator Pattern

An object's state can be changed at compile time and not at run time. The change of state can be accomplished at compile time by using inheritance, however we might want to change the state of the object at run time. This can be achieved by decorator pattern. We have an instance, and we put another instance inside of it. They both support the same (or similar) interfaces. The one on the outside is a "decorator." We can use the one on the outside. It either masks, changes, or pass-throughs the methods of the instance inside of it. <ref>Decorator Pattern</ref>

Intent

Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality as provided by Gang of four. <ref>"Gang of four"</ref>

Problem

The state of an object can be changed at compile time but no change is possible at run time if the language does not permit so.

Solution

Add a decorator module , class that acts as a extender for functions at run time such that the calls are delegated to the decorator to extend the functionality of the objects at run time.

Implementation

Ruby

The example shows a Coffee class with a method cost defining its cost as 2. <ref>Decorator Pattern and more</ref>

  
If we want to calculate the cost of a cup of coffee. We have Coffee class, which implements a cost() method. 

class Coffee
  def cost
    2
  end
end

But what if we want the cost of a coffee with milk? We could have a new class:

class MilkCoffee
  def cost
    2.4
  end
end

But now if we want cream. And sprinkles. Clearly, creating new classes is going to lead to a huge number of classes in our application. It just isn’t realistic to create classes for different combinations of coffee and extras. It could get worse – what if we have different types of coffee? We would then have to have combinations of extras with each different type of coffee.Hence we will use decorator pattern.

module Decorator
  def initialize(decorated)
    @decorated = decorated
  end

  def method_missing(method, *args)
    args.empty? ? @decorated.send(method) : @decorated.send(method, args)
  end
end

And thats all you need. You can include this into any class you want to act as a decorator. You can then use that decorator as if it was the object it is decorating; by default all messages sent to the decorator are forwarded on to the decorated object. You can then decorate the methods you need to extend:

class Milk
  include Decorator

  def cost
    @decorated.cost + 0.4
  end
end

So how does this solve our original problem? The real power of decorators lies in the fact that they can act like the objects they are decorating. By taking this one step further, you can wrap decorators with other decorators as long as they share the same interface. By creating decorators for our different “extras”, we can create coffees using a combination of decorators and get the total cost of the coffee.

class Whip
  include Decorator

  def cost 
    @decorated.cost + 0.2
  end
end

class Sprinkles
  include Decorator

  def cost
    @decorated.cost + 0.3
  end
end

Whip.new(Coffee.new).cost
#=> 2.2
Sprinkles.new(Whip.new(Milk.new(Coffee.new))).cost
#=> 2.9

Java

In this java example <ref>Implementing Decorator Pattern</ref>

   basicInterface: Defines the interface for objects that can have responsibilities added to them dynamically.
   Basic: Defines an object to which additional responsibilities can be attached.
   Decorator: maintains a reference to a Basic object and defines an interface that conforms to Basic's interface.
   ConcreteDecorator: adds responsibilities to the component.

    public interface basicInterface {
    public void do();
    }

    public class Basic implements basicInterface{
    public void do() {
    System.out.println("Do basic stuff");
    }
    }

    public interface Decorator extends basicInterface {
    public void addedStuff();
    }

    public class ConcreteDecorator implements Decorator {

    basicInterface basic;

    public ConcreteDecorator(basicInterface basic) {
    super();
    this.basic = basic;
    }

    public void addedStuff() {
    System.out.println("Decorator does other stuff too");

    }

    public void do() {
    basic.do();
    addedStuff();
    }
    }

    public class Client {
    public static void main(String[] args) {
    basicInterface comp = new Basic();
    Decorator decorator = new ConcreteDecorator(comp);
    decorator.do();
    }
    }

In this way we can add concrete decorator classes to provided the added functionality to the basic class.

Adapter Pattern

Adapter pattern acts as a bridge between objects. It adapts to the changing needs of the classes using interface. In real world we have adapters for power supplies, adapters for camera memory cards etc.If a class is expecting some type of object and we have an object offering the same features, but exposing a different interface we want to use both of them so instead of implementing them again and changing existing classes,we can create an adapter.

Intent

Match an existing object to a particular interface.

Problem

A system has the right data and behavior but the wrong interface. Typically used when you have to make something a derivative of an abstract class you already have or are defining.

Solution

Convert original interface component into another one through an intermediate adapter.Solution: The adapter provides a “wrapper” with the desired interface

Implementation

Ruby

The Adapter offers exactly the same interface as the adaptee, but it can override any method or add new ones. In the below code the adapter code delegates the call to the adaptee and performs operations according to the client requirements by performing additional operation to the results returned by the adaptee. features <ref>Gof Adapter Pattern</ref>

 
class Adaptee 
def talk 
puts "I'm Adaptee"
end
def whine
 puts "Stop bullying me!"
end
end

class Adapter
def initialize
@adaptee=Adaptee.new
end
def talk
#override
 puts "Let me introduce you to Adaptee!"
@adaptee.talk
 puts "That was my adaptee"
end
def do_other_stuff
 puts "I'm versatile"
end
def method_missing method
if
@adaptee.respond_to? method@adaptee.sendmethod
else 
raise NotImplementedError,"This method is not "+\ "available on this interface"
end
end
end
if__FILE__==$0
adapter=Adapter.new
adapter.talk
adapter.whine
adapter.do_other_stuff
end

output - Let me introduce you to Adaptee! I'm Adaptee That was my adaptee Stop bullying me! I'm versatile

Java

The following example shows a simple implementation of the pattern. Consider that we have a third party library that provides sorting functionality through it's NumberSorter class.This is our adaptee, a third party implementation of a number sorter that deals with Lists, not arrays.[1]

  public class NumberSorter
  {
  public List<Integer> sort(List<Integer> numbers)
  {
  //sort and return
  return new ArrayList<Integer>();
  }
  }

Our Client deals with primitive arrays rather than Lists. For the sake of this example, lets say we can't change the client to use Lists.

int[] numbers = new int[]{34, 2, 4, 12, 1}; 
Sorter sorter = new SortListAdapter();
sorter.sort(numbers);

We've provided a Sorter interface that expects the client input. This is our target.

public interface Sorter
{
public int[] sort(int[] numbers);
}

Finally, the SortListAdapter implements our target interface and deals with our adaptee, NumberSorter

public class SortListAdapter implements Sorter
{
@Override
public int[] sort(int[] numbers)
{
//convert the array to a List
List<Integer> numberList = new ArrayList<Integer>();
//call the adapter
NumberSorter sorter = new NumberSorter();
numberList = sorter.sort(numberList);

//convert the list back to an array and return 
return sortedNumbers;
}
}

Difference between Decorator Pattern and Adapter Pattern

Adapters can be used for decorating but their primary aim is to for enabling classes of different types not able to communicate because of incompatible interface to interact via a adapter interface. Inheritance and composition is used to achieve this.Decorators on the other hand are not used to add different methods to all the instances instead they are used to add specific behavior to some specific instances. Though Adapters making use of composition may also be used here, but the intention is different here with what it's in case of a Adapter. <ref>Structural Patterns</ref>

Proxy Pattern

Sometimes we need the ability to control the access to an object. For example if we need to use only a few methods of some costly objects we'll initialize those objects when we need them entirely. Until that point we can use some light objects exposing the same interface as the heavy objects. These light objects are called proxies and they will instantiate those heavy objects when they are really need and by then we'll use some light objects instead.

Intent

"Provide a surrogate or placeholder for another object to control access to it” is the intent provided by GoF

Problem

You need to support resource-hungry objects, and you do not want to instantiate such objects unless and until they are actually requested by the client.

Solution

Design a surrogate, or proxy, object that: instantiates the real object the first time the client makes a request of the proxy, remembers the identity of this real object, and forwards the instigating request to this real object. Then all subsequent requests are simply forwarded directly to the encapsulated real object.

Let's take a look at the diagram definition before we go into more detail.

As usual, when dealing with design patterns we code to interfaces. In this case, the interface that the client knows about is the Subject. Both the Proxy and RealSubject objects implement the Subject interface, but the client may not be able to access the RealSubject without going through the Proxy. It's quite common that the Proxy would handle the creation of the RealSubject object, but it will at least have a reference to it so that it can pass messages along.

Let's take a look at this in action with a sequence diagram.

As you can see it's quite simple - the Proxy is providing a barrier between the client and the real implementation.

There are many different flavours of Proxy, depending on it's purpose. You may have a protection proxy, to control access rights to an object. A virtual proxy handles the case where an object might be expensive to create, and a remote proxy controls access to a remote object.

You'll have noticed that this is very similar to the Adapter pattern. However, the main difference between bot is that the adapter will expose a different interface to allow interoperability. The Proxy exposes the same interface, but gets in the way to save processing time or memory.

Example

There are four common situations in which the Proxy pattern is applicable <ref>Proxy Pattern</ref> .

• A virtual proxy is a placeholder for “expensive to create” objects.

The real object is only created when a client first requests/accesses the object. In place of a complex or heavy object use a skeleton representation. When an underlying image is huge in size, just represent it using a virtual proxy object and on demand load the real object. You feel that the real object is expensive in terms of instantiation and so without the real need we are not going to use the real object. Until the need arises we will use the virtual proxy.

• A remote proxy provides a local representative for an object that resides in a different address space.

This is what the “stub” code in RPC and CORBA provides. Think of an ATM implementation, it will hold proxy objects for bank information that exists in the remote server. RMI is an example of proxy implmenetation for this type in java.

• A protective proxy controls access to a sensitive master object.

The “surrogate” object checks that the caller has the access permissions required prior to forwarding the request. You might be well aware of the proxy server that provides you internet. Saying more than provides, the right word is censores internet. The management feels its better to censor some content and provide only work related web pages. Proxy server does that job. This is a type of proxy design pattern. Lighter part of censor is, we search for something critical in Google and click the result and you get this page is blocked by proxy server. You never know why this page is blocked and you feel this is genuine. How do you overcome that, over a period you learn to live with it.

• A smart proxy interposes additional actions when an object is accessed. Typical uses include:
  • Counting the number of references to the real object so that it can be freed automatically when there are no more references (aka smart pointer),
  • Loading a persistent object into memory when it’s first referenced,
  • Checking that the real object is locked before it is accessed to ensure that no other object can change it.

Implementation

Ruby

Let’s assume you need to log all method calls made to a bank Account object without changing the original Account definition. You can create a new class to wrap the Account object, log any method call then forward the request to the target object. Here’s a super simple bank Account.

   class Account

  def initialize(amount)
    @amount = amount
  end

  def deposit(amount)
    @amount += amount
  end

  def withdraw(amount)
    @amount -= amount
  end

  def balance
    @amount
  end

  def inspect
    puts "Amount: #{@amount}"
  end

end

and here’s our AccountLogger class.

class AccountLogger < BasicObject

  def initialize(amount)
    @operations = []

    @target = Account.new(amount)
    @operations << [:initialize, [amount]]
  end

  def method_missing(method, *args, &block)
    @operations << [method, args]
    @target.send(method, *args, &block)
  end

  def operations
    @operations
  end

end

The AccountLogger is our Proxy object. It doesn’t know anything about the target object, in fact it limits itself to log method calls and forward the request to the underlying @target using the method_missing hook.BasicObject actually prevents this issue by exposing a limited set of instance methods. Simply put, it copes with the problem from a different point of view: instead of taking a rich object and removing all the unnecessary methods, take a poor object and only define what you actually need.

Java

From JDK 1.3 java has direct support for implementing proxy design pattern. We need not worry on mainting the reference and object creation. Java provides us the needed utilities. Following example implementation explains on how to use java’s api for proxy design pattern.

public interface Animal {
 
   public void getSound();
 
}

public class Lion implements Animal {
 
  public void getSound() {
     System.out.println("Roar");
  }
 
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
 
public class AnimalInvocationHandler implements InvocationHandler {
  public AnimalInvocationHandler(Object realSubject) {
    this.realSubject = realSubject;
  }
 
  public Object invoke(Object proxy, Method m, Object[] args) {
    Object result = null;
    try {
      result = m.invoke(realSubject, args);
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    return result;
  }
 
  private Object realSubject = null;
}

import java.lang.reflect.Proxy;
 
public class ProxyExample {
 
  public static void main(String[] args) {
    Animal realSubject = new Lion();
    Animal proxy = (Animal) Proxy.newProxyInstance(realSubject.getClass()
        .getClassLoader(), realSubject.getClass().getInterfaces(),
        new AnimalInvocationHandler(realSubject));
    proxy.getSound();
  }
}

We have created a proxy handler that will be able to get the sound depending on the type of animal.

Difference between Decorator Pattern and Proxy Pattern

The two UML diagrams may confuse us. The two design patterns looks the same with each other. With Decorator Pattern, the decorator and the decoratee implement the same interfaces. With Proxy Pattern, the proxy class and the real class delegated implement the same interfaces. Furthermore, no matter which pattern is used, it is easy to add functions before or after the method of the real object. However, in fact, there are some differences between Decorator Pattern and Proxy Pattern. Decorator Pattern focuses on dynamically adding functions to an object, while Proxy Pattern focuses on controlling access to an object. In other words, with Proxy Pattern, the proxy class can hide the detail information of an object from its client. Therefore, when using Proxy Pattern, we usually create an instance of object inside the proxy class. And when using Decorator Pattern, we typically pass the original object as a parameter to the constructor of the decorator.We can use another sentence to conclude thire differences:

With the Proxy pattern, the relationship between a proxy and the real subject is typically set at compile time, whereas decorators can be recursively 
constructed at runtime.

Composite Pattern

When we want to represent part-whole hierarchy, use tree structure and compose objects. We know tree structure what a tree structure is and some of us don’t know what a part-whole hierarchy is. A system consists of subsystems or components. Components can further be divided into smaller components. Further smaller components can be divided into smaller elements. This is a part-whole hierarchy. Everything around us can be a candidate for part-whole hierarchy. Human body, a car, a computer, lego structure, etc. A car is made up of engine, tyre,etc. Engine is made up of electrical components, valves, etc. Electrical components is made up of chips, transistor,etc. Like this a component is part of a whole system. This hierarchy can be represented as a tree structure using composite design pattern. <ref>Composite Pattern</ref>

Intent

“Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.” is the intent by GoF.

Problem

Application needs to manipulate a hierarchical collection of “primitive” and “composite” objects. Processing of a primitive object is handled one way, and processing of a composite object is handled differently. Having to query the “type” of each object before attempting to process it is not desirable.

Solution

The figure below shows a UML class diagram for the Composite Pattern:

• Component - Component is the abstraction for leafs and composites. It defines the interface that must be implemented by the objects in the composition. For example a file system resource defines move, copy, rename, and getSize methods for files and folders.
• Leaf - Leafs are objects that have no children. They implement services described by the Component interface. For example a file object implements move, copy, rename, as well as getSize methods which are related to the Component interface.
• Composite - A Composite stores child components in addition to implementing methods defined by the component interface. Composites implement methods defined in the Component interface by delegating to child components. In addition composites provide additional methods for adding, removing, as well as getting components.
• Client - The client manipulates objects in the hierarchy using the component interface.

A client has a reference to a tree data structure and needs to perform operations on all nodes independent of the fact that a node might be a branch or a leaf. The client simply obtains reference to the required node using the component interface, and deals with the node using this interface; it doesn't matter if the node is a composite or a leaf.

Example

• GUI toolkits:

For example, Java SWT (Standard Widget Toolkit). If you want to apply a theme for a dialog, you need to apply the theme for the dialog and all its child components. A child can be a composite or a widget itself. If it is a widget, there is no child for that, and the theme needs to be applied only for the widget. But if it is a composite, we need to apply the theme for all its children. Now again, a child can be a widget or a composite. The loop continues until it covers all child widgets.

• Destruction of objects in C++:

Take any OO language without a garbage collector. Just imagine you have a data structure like tree. Each object has a reference only to his children and the client is aware of only the root node object. How will you destroy all the objects, leaving no memory leak? It is only a couple of lines of code that takes to destroy the complete code. Kill a node = Kill all its children and then kill yourself. Since the children are also of type node, the loop continues till it goes to the lowest level where there are no children.

In both the above mentioned cases using a composite pattern based recursion is a wise approach.

Implementation

Ruby

<ref>Implementation in ruby</ref> Use this in cases where your design seems to have a hierarchy. The hierarchy can be established by data/logic i.e Tasks & SubTasks, Parts & SubParts.

     class Part
  def initialize name
    @name = name
  end
  def weight
    0
  end
end

class Hand < Part
  def initialize
    super("Hand")
    @children = []
    5.times {add_child Finger.new}
  end

  def weight #component object
    weight  = 5
    @children.each { |c| weight += c.weight }
    weight
  end

  def add_child child
    @children << child
  end
end

class Finger < Part
  def initialize
    super("Finger")
  end

  def weight #Leaf object
    1
  end
end
hand = Hand.new
puts hand.weight #7

Note here that the complex weight methods have been implemented in the component class and not the leaf class.

Java

Here is the sample code that implements composite pattern.

    public class Block implements Group {
 
    public void assemble() {
        System.out.println("Block");
    }
}

public interface Group {
    public void assemble();
}

import java.util.ArrayList;
import java.util.List;
 
public class Structure implements Group {
  // Collection of child groups.
  private List<Group> groups = new ArrayList<Group>();
 
  public void assemble() {
    for (Group group : groups) {
      group.assemble();
    }
  }
 
  // Adds the group to the structure.
  public void add(Group group) {
    groups.add(group);
  }
 
  // Removes the group from the structure.
  public void remove(Group group) {
    groups.remove(group);
  }
}

public class ImplementComposite {
   public static void main(String[] args) {
          //Initialize three blocks
          Block block1 = new Block();
          Block block2 = new Block();
          Block block3 = new Block();
 
          //Initialize three structure
          Structure structure = new Structure();
          Structure structure1 = new Structure();
          Structure structure2 = new Structure();
 
          //Composes the groups
          structure1.add(block1);
          structure1.add(block2);
 
          structure2.add(block3);
 
          structure.add(structure1);
          structure.add(structure2);
 
          structure.assemble();
      }
}

Difference between Decorator Pattern and Composite Pattern

They usually go hand in and hand. In that using the composite pattern often leads to also using the decorator pattern. The composite pattern allows you to build a hierarchical structure (such as a tree of elements) in a way that allows your external code to view the entire structure as a single entity. So the interface to a leaf entity is exactly the same as the entity for a compound entity. Essence is that all elements in your composite structure have the same interface even though some are leafs and others are entire structures. User interfaces often use this approach to allow easy composability. However, The decorator pattern allows an entity to completely contain another entity so that using the decorator looks identical to the contained entity. This allows the decorator to modify the behavior and/or content of whatever it is encapsulating without changing the outward appearance of the entity. For example, you might use a decorator to add logging output on the usage of the contained element without changing any behavior of the contained element.

Conclusion

This article makes an attempt to explain the concept of Decorator Pattern and other similar patterns such as Proxy Pattern, Adapter Pattern and Composite Pattern. It also explains how each of these related patterns differ from decorator pattern.

References

<references />

Additional Reading

• Composite Pattern
• Brief overview of proxy pattern
• Brief overview of Composite Pattern
• Patterns in Ruby
• Proxy pattern in Ruby
• Differences between Proxy and Decorator pattern
• composite Pattern
• Real life examples
• Composite Pattern in Ruby