Design pattern Servant

Design pattern Servant

Servant is a design pattern used to offer some functionality to a group of classes without defining that functionality in each of them. A Servant is a class whose instance (or even just class) provides methods that take care of a desired service, while objects for which (or with whom) the servant does something, are taken as parameters.

Contents

Description and simple example

Servant is used for providing some behavior to a group of classes. Instead of defining that behavior in each class - or when we cannot factor out this behavior in the common parent class - it is defined once in the Servant.

For example: we have a few classes representing geometric objects (rectangle, ellipse, and triangle). We can draw these objects on some canvas. When we need to provide a “move” method for these objects we could implement this method in each class, or we can define an interface they implement and then offer the “move” functionality in a servant. An interface is defined to ensure that serviced classes have methods, that servant needs to provide desired behavior. If we continue in our example, we define an Interface “Movable” specifying that, every class implementing this interface needs to implement method “getPosition” and “setPosition”. The first method gets the position of an object on a canvas and second one sets the position of an object and draws it on a canvas. Then we define a servant class “MoveServant”, which has two methods “moveTo(Movable movedObject, Position where)” and moveBy(Movable movedObject, int dx, int dy). The Servant class can now be used to move every object which implements the Movable. Thus the “moving” code appears in only one class which respects the “Separation of Concerns” rule.

Two ways of implementation

There are two ways to implement this design pattern.

  1. User knows the servant (in which case he doesn’t need to know the serviced classes) and sends messages with his requests to the servant instances, passing the serviced objects as parameters.
  2. Serviced instances know the servant and the user sends them messages with his requests (in which case she doesn’t have to know the servant). The serviced instances then send messages to the instances of servant, asking for service.
  1. The serviced classes (geometric objects from our example) don’t know about servant, but they implement the “IServiced” interface. The user class just calls the method of servant and passes serviced objects as parameters. This situation is shown on figure 1.
User uses servant to achieve some functionality and passes the serviced objects as parameters.
  1. On figure 2 is shown opposite situation, where user don’t know about servant class and calls directly serviced classes. Serviced classes then asks servant themselves to achieve desired functionality.
User requests operations from serviced instances, which then asks servant to do it for them.

How to implement Servant

  1. Analyze what behavior servant should take care of. State what methods servant will define and what these methods will need from serviced parameter. By other words, what serviced instance must provide, so that servants methods can achieve their goals.
  2. Analyze what abilities serviced classes must have, so they can be properly serviced.
  3. We define an interface, which will enforce implementation of declared methods.
  4. Define an interface specifying requested behavior of serviced objects. If some instance wants to be served by servant, it must implement this interface.
  5. Define (or acquire somehow) specified servant (his class).
  6. Implement defined interface with serviced classes.

Example

This simple example shows the situation described above. This example is only illustrative and will not offer any actual drawing of geometric objects, nor specifying how they look like.

// Servant class, offering its functionality to classes implementing
// Movable Interface
public class MoveServant {
        // Method, which will move Movable implementing class to position where
        public void moveTo(Movable serviced, Position where) {
                // Do some other stuff to ensure it moves smoothly and nicely, this is
                // the place to offer the functionality
                serviced.setPosition(where);
        }
 
        // Method, which will move Movable implementing class by dx and dy
        public void moveBy(Movable serviced, int dx, int dy) {
                // this is the place to offer the functionality
                dx += serviced.getPosition().xPosition;
                dy += serviced.getPosition().yPosition;
                serviced.setPosition(new Position(dx, dy));
        }
}
 
// Interface specifying what serviced classes needs to implement, to be
// serviced by servant.
public interface Movable {
        public void setPosition(Position p);
 
        public Position getPosition();
}
 
// One of geometric classes
public class Triangle implements Movable {
        // Position of the geometric object on some canvas
        private Position p;
 
        // Method, which returns position of geometric object
        public void setPosition(Position p) {
                this.p = p;
        }
 
        // Method, which sets position of geometric object
        public Position getPosition() {
                return this.p;
        }
}
 
// One of geometric classes
public class Ellipse implements Movable {
        // Position of the geometric object on some canvas
        private Position p;
 
        // Method, which returns position of geometric object
        public void setPosition(Position p) {
                this.p = p;
        }
 
        // Method, which sets position of geometric object
        public Position getPosition() {
                return this.p;
        }
}
 
// One of geometric classes
public class Rectangle implements Movable {
        // Position of the geometric object on some canvas
        private Position p;
 
        // Method, which returns position of geometric object
        public void setPosition(Position p) {
                this.p = p;
        }
 
        // Method, which sets position of geometric object
        public Position getPosition() {
                return this.p;
        }
}
 
// Just a very simple container class for position.
public class Position {
        public int xPosition;
        public int yPosition;
 
        public Position(int dx, int dy) {
                xPosition = dx;
                yPosition = dy;
        }
}

Similar design pattern: Command

Design patterns Command and Servant are indeed very similar and implementation is often virtually the same. Difference between them is the approach to the problem, which programmer chose.

  • In case of pattern Servant we have some objects, to which we want offer, some functionality. So we create class, whose instances offer that requested functionality and which defines an interface, which serviced objects must implement. Serviced instances are then passed as parameters to the servant.
  • In case of pattern Command we have some objects that we want to modify with some functionality (we want to add something to them). So we define an interface, which classes with desired functionality must implement. Instances of those classes are then passed to original objects as parameters of their methods.

Even though design patterns Command and Servant are similar it doesn’t mean it’s always like that. There are a number of situations where use of design pattern Command doesn’t relate to with design pattern Servant. In these situations we usually need to pass to called methods just reference to another method, which she will need in accomplishing her goal. Because we can’t pass reference to method in many languages (Java), we have to pass object implementing interface which declares signature of passed method.

Resources

Pecinovský, Rudolf; Jarmila Pavlíčková, Luboš Pavlíček (6 2006). "Let’s Modify the Objects First Approach into Design Patterns First". Eleventh Annual Conference on Innovation and Technology in Computer Science Education, University of Bologna. http://edu.pecinovsky.cz/papers/2006_ITiCSE_Design_Patterns_First.pdf. 


Wikimedia Foundation. 2010.

Игры ⚽ Поможем сделать НИР

Look at other dictionaries:

  • Software design pattern — In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a… …   Wikipedia

  • Willow pattern — The Willow pattern, or commonly Blue Willow , is a distinctive and elaborate pattern used on pottery, ceramic, and porcelain kitchen/housewares. The pattern was designed by Thomas Minton around 1790 and has been in use for over 200 years. Other… …   Wikipedia

  • stage design — Aesthetic composition of a dramatic production as created by lighting, scenery, costumes, and sound. While elements such as painted screens and wheeled platforms were used in the Greek theatre of the 4th century BC, most innovations in stage… …   Universalium

  • The Willow Pattern — is a one act comic opera with a libretto by Basil Hood and music by Cecil Cook. It was first performed at the Savoy Theatre on 14 November 1901, running for a total of 110 performances. It toured thereafter. The Willow Pattern was a companion… …   Wikipedia

  • Шаблон проектирования — У этого термина существуют и другие значения, см. Паттерн. В разработке программного обеспечения, шаблон проектирования или паттерн (англ. design pattern) повторимая архитектурная конструкция, представляющая собой решение проблемы… …   Википедия

  • Поведенческие шаблоны проектирования — Поведенческие шаблоны (англ. behavioral patterns)  шаблоны проектирования, определяющие алгоритмы и способы реализации взаимодействия различных объектов и классов. Использование В поведенческих шаблонах уровня класса используется… …   Википедия

  • List of ThunderCats characters — The following is a list of characters that appear in the American animated series ThunderCats, its 2011 reboot, and its related media. Contents 1 Heroes 1.1 Original ThunderCats 1.1.1 Jaga 1.1.2 Lion O …   Wikipedia

  • Patron de Méthode (Motif de conception) — Patron de méthode (patron de conception) Patron de méthode: diagramme de classes en UML La technique du patron de méthode (Template method pattern) est un patron de conception (design pattern) comportemental utilisé en génie logiciel. Un patron… …   Wikipédia en Français

  • Patron de methode (patron de conception) — Patron de méthode (patron de conception) Patron de méthode: diagramme de classes en UML La technique du patron de méthode (Template method pattern) est un patron de conception (design pattern) comportemental utilisé en génie logiciel. Un patron… …   Wikipédia en Français

  • Patron de méthode (Motif de conception) — Patron de méthode (patron de conception) Patron de méthode: diagramme de classes en UML La technique du patron de méthode (Template method pattern) est un patron de conception (design pattern) comportemental utilisé en génie logiciel. Un patron… …   Wikipédia en Français

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”