Design attern in php

Design pattern in PHP

Filippo De Santis - fd@ideato.it - @ﬁlippodesantis


Web developer

Working in @ideato since 2009

XP and Kanban user

What is a design pattern?


“Each pattern describes a problem which occurs over and
over again in our environment, and then describes the core
of the solution to that problem, in such a way that you can
use this solution a million times over, without ever doing it
the same way twice”

Christopher Alexander


“A pattern is a [general] solution to a problem in a context”

Gang of four

Elements of a design pattern

Name

Used to describe a design problem, its solution and its
consequences in a word or two


Problem

Describes when to apply a pattern


Solution

Describes the elements that make up the design, their
relationships, responsibilities, and collaborations


Consequences

The results and trade-offs of applying the pattern

Singleton

Singleton

Ensures that a class has one instance only
Provides a global point of access to it

Singleton

Access control
Only one instance

YES!

Singleton

Used to replace global variables
[changing the name does not change the problem]

Violates the Single Responsibility Principle
[creation + singleton class functionality]

NO!

Singleton

private function __construct() {}

Singleton

private static $instance = false;

Singleton

public static function getInstance() {
if (false == self::$instance) {
self::$instance = new self();
}

return self::$instance;
}

Singleton
class Singleton {

private static $instance = false;

private function __construct() {}

public static function getInstance() {
if (false == self::$instance) {
self::$instance = new self();
}

return self::$instance;
}
}

$instance = Singleton::getInstance();

Factory method

Factory method

Classes delegate responsibility of building objets
Localize the knowledge of which class is the delegate

Factory method

PHP most used implementation:
Parameterized factory method

Factory method

class Factory {

public function build($condition) {...}

}

Factory method

interface Document {
...
}

Factory method

MyDoc implements Document {...}

YourDoc implements Document {...}

TheirDoc implements Document {...}

Factory method

class Factory {

/* @return Document */
public function build($condition) {...}

}

Factory method
class DocumentReaderFactory {
public function build($type) {
switch ($type) {
case 'txt':
return new TxtReader();
case 'doc':
return new DocReader();
//...
}
}
}

foreach ($documents as $document) {
$factory = new DocumentReaderFactory();
$reader = $factory->build($document->getType());
$reader->read($document);
}

Adapter

Adapter

Converts the interface of a class into another interface

Adapter

An existing class interface does not match what you need

To create a reusable class

Adapter

interface AdapterInterface {
...
}

Adapter
by class inheritance

Adapter exteds Adaptee implements AdapterInterface {
...
}

Adapter
by objects composition

Adapter implements AdapterInterface {

public function __construct(Adaptee $adaptee){
$this->adaptee = $adaptee;
}

...
}

Adapter

interface FileOperationsInterface {

public function getContent($filename);

public function putContent($filename, $data);

public function removeFile($filename);

}

Adapter
by class inheritance

class FTPFileAdapter extends FTPFileRepository
implements FileOperationsInterface {

public function getContent($filename) {
…
}
public function putContent($local_file, $data) {
…
}
public function removeFile($filename) {
…
}
}

Adapter
class FTPFileAdapter implements FileOperationsInterface {
by objects composition
public function __construct(FTPFileRepository $repository) {
$this->repository = $repository;
}

public function getContent($filename) {
$this->repository->download($local_file, $filename);
return file_get_content($local_file);
}

public function putContent($local_file, $data) {
file_put_contents($local_file, $data);
$this->repository->upload($remote_file, $local_file);
}

public function removeFile($filename){
$this->repository->remove($filename);
}
}

Template method

Template method

Deﬁnes the skeleton of an algorithm in an operation,
deferring some steps to subclasses

Template method

Implements the invariant parts of an algorithm once
Leaves it up to subclasses the behavior that can vary

Common behavior localized in a common class

To control subclasses extensions

Template method

Classes implementing a template method should:

specify hooks (may be overridden)

specify abstract operations (must be overridden)

Template method

abstract operations (must be overridden)

ie: use preﬁx “DO”
DoRead()
DoWrite()
DoSomething()

Template method

abstract class Reader {

abstract protected function openFile($filename);
abstract protected function readFile();
abstract protected function closeFile();

public function readFileAlgorithm($filename) {
$this->openFile($filename);
$content = $this->readFile();
$this->closeFile();

return $content
}

Design pattern in PHPmethod
Template

class XMLReader extends Reader {

protected function openFile($filename) {
$this->xml = simplexml_load_file($filename);
}

protected function readFile() {
return $this->xml->description;
}

public function closeFile(){}

}

Template

class CSVReader extends Reader {

protected function openFile($ﬁlename) {
$this->handle = fopen($ﬁlename, "r");
}

protected function closeFile() {
fclose($this->handle);
}

protected function readFile() {
$data = fgetcsv($this->handle);

return $data[3]; //description
}
}

Template
Hooks

class Parent {
protected function hook() {}

public function doSomething() {
//...
$this->hook();
}
}

Template
Hooks

class Child extends Parent {

protected function hook() {
//My logic to add into the doSomething method
}

}

Dependency Injection


Components are given their dependencies through
their constructors, methods, or directly into ﬁelds


Those components do not get their dependencies
themselves, or instantiate them directly

Dependency
Injection

class A {

public function doSomething() {
$b = new B();
//...
}
}
NO!

Dependency
Injection

class A {

public function construct(B $b) {
$this->b = $b;
}

//...
}
YES!

Dependency
Injection

class A {

public function setB(B $b) {
$this->b = $b;
}

//...
}
YES!

Dependency
Injection

class A {

public $b;

//...
}

$a = new A();
$a->b = new B();
YES!

Dependency
Injection
class A implements DiInterface{
}

interface DiInterface {

public function setB(B $b);

}

YES!


Dependency Injection Container
Dependency &
Injection Inversion of control

References
Design Patterns: Elements of Reusable Object-Oriented Software
E. Gamma, R. Helm, R. Johnson, J.Vlissides
Addison-Wesley 1974

Martin Fowler - http://martinfowler.com/bliki/InversionOfControl.html

PicoContainer Documentation: http://picocontainer.org/injection.html

SourceMaking - Design Patterns: http://sourcemaking.com/design_patterns

PHP best practices - Pattern in PHP: http://www.phpbestpractices.it

Thank you!

Filippo De Santis - fd@ideato.it - @ﬁlippodesantis

Design attern in php

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Design attern in php (20)

Recently uploaded (20)

Design attern in php