October 20th, 2020

Design Patterns – Strategy and Bridge

Introduction

The Strategy and Bridge patterns provide solutions to apply
polymorphism in more flexible way than you can accomplish with only
inheritance.

The patterns are almost identical, differing mostly in intent only.
Though it is this difference that create implementation variations
targeting the respective problems.

Problem

Strategy
How to use different algorithms in a flexible, polymorphic way.

Bridge
How to structurally abstract a varying concept and it’s implementations, in a way that doesn’t break encapsulation.

Solution

The key to successfully implementing the Strategy pattern is designing
a common interface that is flexible enough to support a range of
algorithms. If you can accomplish that, implementation is a snap. It
really is one of the easiest patterns. It’s really just a basic
polymorphic solution.

Let’s start by defining the named handles for the parties involved in this pattern:

  1. Strategy objects (BasicEmailAdressValidator, LooseRfc2822AdressValidator) – Objects that encapsulate the different algorithms.
  2. Context object (Mail) – Object dynamically using any algorithm.

We’ll
use a fictional Mailer class, which validates the email adress before
attempting to send it. Email validation can be done in many different
ways, so we encapsulate the validation algorithms in different Strategy
Objects.

view plaincopy to clipboard
  1. /**
  2. * Interface for validation strategies
  3. *
  4. */
  5. interface EmailValidationStrategy
  6. {
  7. /**
  8. * Check if the value is valid
  9. *
  10. * @param mixed $value
  11. */
  12. public function isValid($value);
  13. }
  15. /**
  16. * Objects representing an email
  17. *
  18. */
  19. class Mail
  20. {
  21. /**
  22. * Validation strategy
  23. *
  24. * @var EmailValidationStrategy
  25. */
  26. private $_strategy;
  28. /**
  29. * Constructor
  30. *
  31. * @param EmailValidationStrategy $strategy
  32. */
  33. public function __construct(EmailValidationStrategy $strategy)
  34. {
  35. $this->_strategy = $strategy;
  36. }
  38. /**
  39. * Check if the value is valid
  40. *
  41. * @param mixed $mixed
  42. * @return bool
  43. */
  44. public function send($email)
  45. {
  46. //Delegate validation to the strategy object
  47. if($this->_strategy->isValid($email))
  48. {
  49. //Send email
  50. }
  51. else
  52. {
  53. //throw exception
  54. }
  55. }
  56. }
  58. class BasicEmailAdressValidator implements EmailValidationStrategy
  59. {
  60. /**
  61. * Check if the value is valid
  62. *
  63. * @param string $str
  64. * @return bool
  65. */
  66. public function isValid($str)
  67. {
  68. return (is_string($str) && preg_match(“/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i”, $str));
  69. }
  70. }
  71. class LooseRfc2822AdressValidator implements EmailValidationStrategy
  72. {
  73. /**
  74. * Check if the value is valid
  75. *
  76. * @param string $str
  77. * @return bool
  78. */
  79. public function isValid($str)
  80. {
  81. return (is_string($str) && preg_match(“/[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b/i”, $str));
  82. }
  83. }

Usage:

view plaincopy to clipboard
  1. $mailer = new Mail(new BasicEmailAdressValidator);
  2. $mailer->send($email);

or

view plaincopy to clipboard
  1. $mailer = new Mail(new LooseRfc2822AdressValidator);
  2. $mailer->send($email);

The
algorithms are nicely encapsulated, and we can add different types of
validation, without having to mess with the Mailer class.

The Bridge pattern something very similar, though it’s focusus on
structure, not behaviour. Keeping the Mail example, a typical example
of Bridge that stresses the structural implications would demonstrate
that the context and implementation can vary independently.

  1. Abstraction (Mail) – Common behaviour and properties of a concept
  2. Refined Abstraction (NotificationMail, SubscriptionMail) – Variations of a concept
  3. Implementor (MailTransport) – Abstraction of a part of the implementation concerning a specific concept
  4. Concrete Implementor (SendMailTransport, SmtpTransport) – Concrete implementations of a specific concept
view plaincopy to clipboard
  1. /**
  2. * Interface for mailer implementations
  3. *
  4. */
  5. interface MailTransport
  6. {
  7. /**
  8. * Send email
  9. *
  10. */
  11. public function send($from, $to, $body);
  12. }
  14. class SendMailTransport implements MailTransport
  15. {
  16. public function send($from, $to, $body)
  17. {
  18. //send email using sendmail
  19. }
  20. }
  21. class SmtpTransport implements MailTransport
  22. {
  23. public function send($from, $to, $body)
  24. {
  25. //send email using SMTP
  26. }
  27. }
  29. /**
  30. * Objects representing an email
  31. *
  32. */
  33. abstract class Mail
  34. {
  35. /**
  36. * Mail transport implementation
  37. *
  38. * @var MailerTransport
  39. */
  40. private $_transport;
  42. /**
  43. * Email body
  44. *
  45. * @var string
  46. */
  47. private $_body;
  49. /**
  50. * Recipient
  51. *
  52. * @var string
  53. */
  54. private $_to;
  56. /**
  57. * Constructor
  58. *
  59. * @param MailerTransport $imp
  60. */
  61. public function __construct(MailerTransport $imp)
  62. {
  63. $this->_transport = $imp;
  64. }
  66. /**
  67. * Get the email body
  68. *
  69. * @param string $string
  70. */
  71. public function getBody()
  72. {
  73. return $this->_body;
  74. }
  76. /**
  77. * Set the email body
  78. *
  79. * @param string $string
  80. */
  81. public function setBody($string)
  82. {
  83. $this->_body = $string;
  84. }
  86. /**
  87. * Set the email recipient
  88. *
  89. * @param string $address
  90. */
  91. public function getTo()
  92. {
  93. return $this->_to;
  94. }
  96. /**
  97. * Set the email recipient
  98. *
  99. * @param string $address
  100. */
  101. public function setTo($address)
  102. {
  103. $this->_to = $address;
  104. }
  106. /**
  107. * Get the sender address
  108. *
  109. * @return string
  110. */
  111. public function getFrom()
  112. {
  113. return $this->_from;
  114. }
  116. /**
  117. * Set the sender address
  118. *
  119. * @param string $address
  120. */
  121. public function setFrom($address)
  122. {
  123. return $this->_from;
  124. }
  126. }
  127. class NotificationMail extends Mail
  128. {
  129. /**
  130. * Check if the value is valid
  131. *
  132. * @param mixed $mixed
  133. * @return bool
  134. */
  135. public function send()
  136. {
  137. if(!$this->_transport->send($this->getFrom(), $this->getTo(), $this->getBody()))
  138. {
  139. //a failed notice is not that much of isssue
  140. trigger_error(‘Failed to send notice’, E_USER_NOTICE);
  141. }
  142. }
  144. /**
  145. * Format the body as a notice
  146. *
  147. * @return string
  148. */
  149. public function getBody()
  150. {
  151. return “Notice: ” . parent::getBody();
  152. }
  154. }
  155. class SubscriptionMail extends Mail
  156. {
  157. /**
  158. * Check if the value is valid
  159. *
  160. * @param mixed $mixed
  161. * @return bool
  162. */
  163. public function send()
  164. {
  165. if(!$this->_transport->send($this->getFrom(), $this->getTo(), $this->getBody()))
  166. {
  167. //if it fails, we should handle that
  168. throw new Exception(‘Failed to send subscription email’);
  169. }
  170. }
  171. }
  173. $mail = new SubscriptionMail(new SmtpTransport());

By abstracting out the concept of ‘email transport’, we can allow concrete implementations of Mail to vary.

There are no comments yet, add one below.

Leave a Comment