2. WE FACE SIMILAR
PROBLEMS.
—OFTEN—

3. THOSE PROBLEMS HAVE
COMMON SOLUTIONS.

7. “DESIGN PATTERNS”
=
COMMON SOLUTIONS
TO COMMON PROBLEMS

8. DESIGN PATTERN BENEFITS
• Presents a common solution to a problem.
• Common solution = faster implementation
• Recognizable to other developers.
• Encourages more legible and maintainable code.

9. TERMINOLOGY
• Interface:
• An outline or a blueprint for classes. Cannot be instantiated.
• Abstract class:
• A class that can serve as an outline, while providing base
functionality of its own. Can implement an interface. Cannot be
instantiated.

10. TERMINOLOGY
• Concrete class:
• A “creatable” class. Can implement an interface or extend an
abstract or concrete class. Can be instantiated.

11. DEPENDENCY INJECTION
FACTORY
STRATEGY
CHAIN OF RESPONSIBILITY (COR)

12. class Session()
{
function __construct() {
session_start();
}
function getCreatedTime()
{
return $_SESSION[…];
}
}
public function getSession()
{
return new Session();
}

13. $app = new App();
echo $app->getSession()->getCreatedTime();
sleep(2);
echo $app->getSession()->getCreatedTime();

15. SINGLETONS
The way it used to be done: a global means to access
one instance of an object

16. SOLUTION?
• Use static class methods to track single instance
of object:
public static function getInstance()
{
if (!self::$instance) {
self::$instance = new self();
}
return self::$instance;
}

17. SOLUTION?
• Then, get the class like so:
public function getSession()
{
return Session::getInstance();
}

18. Model needs session
class Session
Create instance and
store it.
self::
$_instance?
Return instance.
No
Yes

19. SINGLETON’S PROBLEMS:
• Hard links the session to its consuming class.
• Makes testing more difficult.
• Breaks Single Responsibility Principle, as the class
manages its own instance.

20. DEPENDENCY INJECTION (DI)
Providing classes the variables they need.

21. S
Title Text

23. DI DESIGN
new Model($session);
$session = new Session();

24. DI DESIGN
new Model($session);
$session = new Session();
new Controller($session);

25. DI DESIGN
new Model($session);
$session = new Session();
new Controller($session);
new DataStorage($session);

26. DI
• We create the objects and then “inject” them into
each class that depends on them.
• Benefits:
• Easier to follow Single Responsibility Principle.
• Makes testing easier: we can inject mocks or
stubs.
• Good visibility into what each class needs.

27. protected $session;
public function __construct(Session $session)
{
$this->session = $session;
}
public function saveToSession($value)
{
$this->session->save(‘time’, $value);
}
public function getFromSession()
{
return $this->session->get(‘time’);
}

28. $session = new Session();
$app = new App($session);
$app->saveToSession(time());
echo $app->getFromSession();

29. DI CONTAINERS
Grouping variables into an object to be inserted into a class.

30. new App(); new Session(); DI Container
class App {
protected $session;
function __construct(Container $container) {
$this->session = $container->get(‘session’);
}
}

31. DI CONTAINERS
• Pimple (pimple.sensiolabs.org)
• Super simple container but is rather manual.
• PHP-DI (http://php-di.org/)
• More complex to setup but injection is
automatic.
• Similar to Symphony Dependency Injection component:
https://github.com/symfony/DependencyInjection

32. USE CASES:
• Database connections
• Sessions
• Other objects in a request’s lifecycle.

33. DEPENDENCY INJECTION
FACTORY
STRATEGY
CHAIN OF RESPONSIBILITY (COR)

34. FACTORY
Allows centralization of code for class construction.

35. $controller = new HomeController(
$request,
$response,
$templateEngine,
$cookieJar,
$properties,
// …
);
Too many properties
to call frequently.

37. FACTORY
• We manufacture very little of what we own.
• Factories make most of our possessions for us.
• Single-purposed: making things.

38. FACTORY DEFINED:
• Moves the task of creating classes to a
single-purposed class, the factory.
• Factory provides a simple method to
instantiate new class.

39. $application
Constructor
Arguments
new Controller(…)

40. $application
ControllerFactory::load()
Constructor
Arguments
new Controller(…)
“I need a Controller class.”

41. $application
ControllerFactory::load()
Constructor
Arguments
new Controller(…)

42. FACTORY:
• Create a class as the factory.
• All classes instantiated should extend a
common type or implement a common
interface.
• Return the newly created class.

43. FACTORY:
• Extra kudos: you can use a configuration file
(Yaml/Xml) to control the creation of the
classes.

44. public function loadProduct($id)
{
$data = $this->getProductDataFor($id);
return ProductFactory::hydrate($data);
}

45. class ProductFactory
{
public static function hydrate($data)
{
switch ($data[‘type’]) {
case ‘simple’:
$product = new SimpleProduct($data);
break;
case ‘configurable’:
$product = new ConfigProduct($data);
break;
}
return $product;
}
}

46. products:
simple:
name: Simple Product
class: ModelProductSimple
child_selector:
name: Configurable
class: ModelProductConfigurable

47. class ProductFactory
{
public static function hydrate($data, $config)
{
$type = $data[‘type’];
$className = $config[‘products’][$type][‘class’];
$product = new $className($data);
return $product;
}
}

48. USE CASES:
• Factory is a design-pattern for instantiating classes.
• Offloading the creation of parameter-heavy
constructors:
• Dependency Injection
• Determine what type of class to setup.
• Gives means for 3rd-party developers to extend
the functionality of your software.

49. DEPENDENCY INJECTION
FACTORY
STRATEGY
CHAIN OF RESPONSIBILITY (COR)

50. STRATEGY
Pluggable objects that have the same interface but
can do different things.

51. PROBLEM:
• How to separate changeable details?
public function persist($data, $to)
{
switch($to) {
case 'mysql':
$connection = new PDO(...);
$connection->exec(...);
break;
case 'salesforce':
$connection = new HttpClient(...);
// ...
break;
}
}

52. PROBLEM:
public function persist($data, $to)
{
switch($to) {
case 'mysql':
// …
case 'salesforce':
// …
case 'redis':
// …
}
}

53. PROBLEM:
public function persist($data, $to)
{
switch($location) {
case 'mysql':
// …
case 'salesforce':
// …
case 'redis':
// …
case 'file':
// …
}
}

54. PROBLEM:
public function persist($data, $to)
{
switch($location) {
case 'mysql':
// …
case 'salesforce':
// …
case 'redis':
// …
case 'file':
// …
case 'ec2':
// …
}
}

55. PROBLEM:
public function persist($data, $to)
{
switch($location) {
case 'mysql':
// …
case 'salesforce':
// …
case 'redis':
// …
case 'file':
// …
case 'ec2':
// …
case 'dropbox':
// …
}
}

56. THIS CAN QUICKLY BECOME
UNMANAGEABLE….

57. UPDATED:
public function persist($data, $to)
{
switch($location) {
case 'mysql':
$this->persistToMysql($data);
case 'salesforce':
$this->persistToSalesForce($data);
case 'redis':
$this->persistToRedis($data);
case 'file':
$this->persistToFile($data);
case 'ec2':
$this->persistToEc2($data);
case 'dropbox':
$this->persistToDrop($data);
}
}

58. …BUT THERE’S A BETTER WAY.

59. FORD
MUSTANG
Engines:
5.2L V8
5.0L V8
2.3L EcoBoost

60. DRILL
http://www.dewalt.com/tool-categories/Drills.aspx

61. STRATEGY
• Parent class handles “what” happens.
• Child class handles “how” it happens.
• Parent doesn’t know who the child is.
• The children must all expose the same methods.

62. • Factory:
• initializes objects, returns them for use
• should expose a similar set of methods
• Strategy:
• uses objects
• must expose a similar set of methods

63. Data Storage (parent: “what happens”)
Provider (child: “how it happens”)
save()load() update()
save()load() update()
list()

64. Data Storage
MySqlProvider
save()load() update()
save()load() update()
connect()

65. Data Storage
SalesForceProvider
save()load() update()
save()load() update()
push()

66. Data Storage
MySqlProvider SalesForceProviderOR:

67. class DataStorage //parent: “what happens”
{
protected $provider; //child: “how it happens”
public function __construct ($provider)
{
$this->provider = $provider;
}
public function update ($model)
{
$this->provider->update($model);
}
}

68. interface ProviderInterface
{
/**
* This is the blueprint for the provider,
* the child.
*/
public function update($model);
}

69. class MySqlProvider implements ProviderInterface
{
/**
* Child MySqlProvider
*/
public function update($model)
{
$connection = $this->getConnection();
$connection->exec('UPDATE … SET');
return $this;
}
}

70. class SalesForceProvider
{
/**
* Child SalesForceProvider
*/
public function update($model)
{
$client = new GuzzleHttpClient();
$client->request('POST', ‘{url}’);
// ...
}
}

71. class DataStorage { /* … */ }
interface ProviderInterface { /* … */ }
class MysqlProvider { /* … */ }
class SalesForceProvider { /* … */ }
// using our strategy design pattern:
$storage = new DataStorage(new MysqlProvider);
$storage->update($data);

72. STRATEGY USES:
• Any case where different algorithms or methods
are needed to be interchangeable, but only one
used:
• Storage locations
• Computational Algorithms

73. DEPENDENCY INJECTION
FACTORY
STRATEGY
CHAIN OF RESPONSIBILITY (COR)

74. CHAIN OF RESPONSIBILITY
Handling logic through multiple links/siblings of functionality.

75. PROBLEM:
• Cascading layers of caching.
• How to get the value from the list?
• Cascading renderers for a component.
• How to have renderers determine who should
render?

76. public function get($key)
{
$redis = new Redis();
$db = new Db();
$file = new File();
if ($redisVal = $redis->get($key)) {
return $redisVal;
} else if ($dbVal = $db->get($key)) {
return $dbVal;
} else if ($fileVal = $$file->get($key)) {
return $fileVal;
}
return '';
}

77. SOLUTION #1: LOOPS
• Easier, but less flexible.
• Iterate through each member of an array of the
items and have that member check to determine
its legibility.

78. public function get($key)
{
$cacheTypes = ['Redis', 'Db', 'File'];
$value = '';
foreach ($cacheTypes as $cacheType) {
$className = new "ModelCache{$cacheType}";
$cache = new $className();
if ($value = $cache->get($key)) {
break;
}
}
return $value;
}

80. SOLUTION #2: COR
• Horizontal chaining: sibling relationships
• Parent class interacts with first item in the chain.

81. FileDBRedis
Entry Point

82. File: no next link :(
DB: $this->_nextLink
Redis: $this->_nextLink

83. SOLUTION #2: COR
• Each link inherits from a abstract class.
• Abstract class handles chaining.
• Concrete objects provide functionality for
processing and whether or not to proceed.

84. COR DESIGN
Need something
from the cache
FileSystemDBRedis
processed? processed? processed?
No
Yes!
AbstractCache

85. SETUP STEPS:
• Instantiate first link.
• Create next link.
• Append to first link.
• Continue…

86. USAGE STEPS:
• Call first link’s get method.
• Will check itself.
• If no value, and next link, call that link.
• Repeat…

87. <?php
class Request
{
protected $_key;
protected $_result;
public function setKey($value) { /**/ }
public function getResult() { /**/ }
}

88. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) { /**/ }
public function get($request) { /**/ }
public function processing($request) { /**/ }
}

89. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) { /**/ }
public function get($request) { /**/ }
public function processing($request) { /**/ }
}

90. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) { /**/ }
public function get($request) { /**/ }
public function processing($request) { /**/ }
}

91. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) { /**/ }
public function get($request) { /**/ }
public function processing($request) { /**/ }
}

92. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) { /**/ }
public function get($request) { /**/ }
public function processing($request) { /**/ }
}

93. <?php
abstract class Base
{
protected $_nextLink;
protected $_result;
protected $_data;
abstract protected function getDataFor($key);
public function append(Base $nextLink) {
if (!$this->_nextLink) {
$this->_nextLink = $nextLink;
} else {
$this->_nextLink->append($nextLink);
}
}
public function get($request) { /**/ }
public function processing($request) { /**/ }
public function getSuccessor() { /**/ }
}

94. abstract protected function getDataFor($key);
public function append(Base $nextLink) { /* … */}
public function get($request) {
if (!($request instanceof Request)) {
$key = $request;
$request = new Request();
$request->setKey($key);
}
$success = $this->processing($request);
if (!$success && $this->_nextLink) {
$this->_nextLink->get($request);
}
return $request->getResult();
}
public function processing($request) { /* … */ }

95. abstract protected function getDataFor($key);
public function append(Base $nextLink) { /* … */}
public function get($request) {
if (!($request instanceof Request)) {
$key = $request;
$request = new Request();
$request->setKey($key);
}
$success = $this->processing($request);
if (!$success && $this->_nextLink) {
$this->_nextLink->get($request);
}
return $request->getResult();
}
public function processing($request) { /* … */ }

96. public function get($request) { /* … */ }
public function processing($request) {
$key = $request->getKey();
$value = $this->getDataFor($key);
if ($value) {
$request->setResult($value);
return true;
} else {
return false;
}
}
public function getNextLink() { /* ... */}
}

97. class RedisCache extends Base
{
protected function getDataFor($key)
{
// connects to redis and returns value
}
}

98. $redis = new RedisCache();
$redis->append(new DbCache)
->append(new FileCache);
return $redis->get('key_name');

99. USAGE STEPS:
• Call first link’s get method.
• Will check itself.
• If no value, and next link, call that link.
• Repeat…

100. USE CASES:
• Layers of caching
• Rendering views with a standard input, but giving
each member the equal opportunity to display.
• Iterating through strategies to find a solution to an
algorithm.

101. DEPENDENCY INJECTION
FACTORY
STRATEGY
CHAIN OF RESPONSIBILITY (COR)

102. REVIEW
DI Factory Strategy CoR
Class has
everything it needs
on construction.
Creation: Chooses
and creates any
object from options.
Action: Similar
interface for
different
applications.
Interacts with
options to retrieve
output.
All use specific classes to maintain Single Responsibility Principle.

103. RESOURCES
• Design Patterns: Elements of Reusable Object-
Oriented Software
• (Gamma, Helm, Johnson, Vlissides; published by Addison-Wesley)
• Design Patterns PHP
• http://designpatternsphp.readthedocs.org/en/latest/
• PHP the Right Way
• http://www.phptherightway.com/

104. FEEDBACK?https://joind.in/14702