Software Design Patterns

1
Design Patterns
Daniel Waligóra
Wrocław 09/01/2012

2
Bibliography
• Martin Fowler,Patterns of Enterprise Appication Architecture
• Matt Zandstra , PHP5 Objects, Patters, and Practice
• http://www.ustream.tv - NewYork PHP channel
• Symfony Live Berlin 2012 - https://joind.in/event/view/1114
• http://scholar.google.pl
• http://pzielinski.com

4
Breakdown Design
Patterns by GoF
Design PatternsDesign Patterns
creationalcreational structuralstructural behavioralbehavioral
- abstract factory
- builder
- prototype
- decorator
- facade
- composite
- observer
- strategy
- command

7
Implementation related
to the context
programmingprogramming
languagelanguage
scalabilityscalability
modularitymodularity
testabletestable
(integration test)(integration test)
time-consumingtime-consuming size of projectsize of project

8
ContextContext ISIS
related to therelated to the
languagelanguage
Design patternsDesign patterns
IS NOTIS NOT relatedrelated
to theto the
languagelanguage

9
Transaction Script1. class Hotel
2. {
3.     private
4.         $_gateway;
5.     public function __construct(Data_Access_Gateway $gateway)
6.     {
7.         $this->_gateway = $gateway;
8.     }
9.
10.     public function bookRoom($userId, $fromDate, $toDate)
11.     {
12.         $roomId = $this->_gateway->_getRoomIdBetweenDates($fromDate, $toDate);
13.
14.         if (!$roomId) {
15.             return false;
16.         }
17.
18.         $days = $this->_getAmountOfDays($fromDate, $toDate);
19.
20.         if ($days < = 7) {
21.             $price = $days * 100;
22.         } else {
23.             $price = $days * 80;
24.         }
25.
26.         $data = array(
27.             'userId' => $userId,
28.             'roomId' => $roomId,
29.             'fromDate' => $fromDate,
30.             'toDate' => $toDate,
31.             'price' => $price,
32.         );
33.
34.         $bookingId = $this->_gateway->insert('bookings', $data);
35.
36.         return $bookingId;
37.     }
38. }

10
Transaction Script
• simple procedural model
• works well with a simple
data access layer
• easy implementation of use
cases
• difficult to maintenance
• code duplication
Disadvantages:Advantages:

11
Table Module #11. class Hotel
2. {
3.     public function __construct(Data_Access_Gateway $gateway, Booking $booking)
•     {
•         $this->_gateway = $gateway;
•         $this->_booking = $booking;
•     }
•
•     public function bookRoom($userId, $fromDate, $toDate)
•     {
•         $roomId = $this->_booking->getRoomBetweenDates($fromDate, $toDate);
•
•         if (!$roomId) {
•             return false;
•         }
•
•         $days = $this->_getAmountOfDays($fromDate, $toDate);
•
•         if ($days < = 7) {
•             $price = $days * 100;
•         } else {
•             $price = $days * 80;
•         }
•
•         $bookingId = $this->_booking-
>addBooking($userId, $roomId, $fromDate, $toDate, $price);
•
•         return $bookingId;
•     }
• }
•

12
Table Module #2
1. class Booking
2. {
3.     public function __construct(Data_Access_Gateway $gateway)
4.     {
5.         $this->_gateway = $gateway;
6.     }
7.
8.     public function getRoomBetweenDates($dateFrom, $dateTo)
9.     {
10.        return $this->_gateway->getRoomBetweenDates($dateFrom, $dateTo);
11.    }
12.
13.    public function addBooking($userId, $roomId, $fromDate, $toDate, $price)
14.    {
15.        $data = array(
16.            'userId' => $userId,
17.            'roomId' => $roomId,
18.            'fromDate' => $fromDate,
19.            'toDate' => $toDate,
20.            'price' => $price,
21.        );
22.
23.        $bookingId = $this->_gateway->insert('bookings', $data);
24.
25.        return $bookingId;
26.    }
27.}

13
Table Module vs
Transaction Script
• less duplication
• encapsulation
• more organized and
structured code
• easy implementation by
technology support
• weak support for
polymorphism
• no support ORM

14
Domain Model #11. class Hotel
2. {
3.     protected $_hotelId;
4.     protected $_rooms;
5.
6.     public function bookRoom(User $user, $fromDate, $toDate)
7.     {
8.         $room = $this->_getRoomBetweenDates($fromDate, $toDate);
9.
10.         if (is_null($room)) {
11.             return false;
12.         }
13.
14.         $booking = $room->bookRoom(User $user, $fromDate, $toDate);
15.
16.         return $booking;
17.     }
18. }
19.
20. class Room
21. {
22.     protected $_roomId;
23.     protected $_bookings = array();
24.
25.     public function bookRoom(User $user, $fromDate, $toDate)
26.     {
27.         $days = $this->_getAmountOfDays($fromDate, $toDate);
28.
29.         if ($days < = 7) {
30.             $booking = new Booking($user, new ShortBookingStrategy($user, $days));
31.         } else {
32.             $booking = new Booking($user, new NormalBookingStrategy($user, $days));
33.         }
34.
35.         return $booking;
36.     }
37. }

15
Domain Model #2
1. class NormalBookingPriceStrategy extends BookingPriceStrategy
2. {
3.     public function getPrice()
4.     {
5.         $price = $this->_days * 80;
6.
7.         if ($this->_user->isLoyal()) {
8.             $price = $price / 2;
9.         }
10.
11.        return $price;
12.    }
13.}
14.
15.class ShortBookingPriceStrategy extends BookingPriceStrategy
16.{
17.    public function getPrice()
18.    {
19.        return $this->_days * 100;
20.    }
21.}

16
Domain Model vs
Procedural Pattern
• prevents logic duplication
• more code readability
• independence from the data
source
• much easier to unit test
• time-consuming
implementation
• additional patterns
- ORM
- data source

17
SUMMARY
languagelanguage
scalabilityscalability
modularitymodularity
testabletestable
(integration test)(integration test)
time-consumingtime-consuming
size of projectsize of project
skill of the developers

18
Don’t be STUPID,
GRASP SOLID!

19
Sorry, but your code is
STUPID!

20
1.class DB
2.{
3.    private static $instance;
4.    public static function getInstance()
5.    {
6.        if(!isset(self::$instance)) {
7.            self::$instance = new self;
8.        }
9.
10.        return self::$instance;
11.    }
12.}
•Singleton
21
Dupleton?

21
•Singleton (ctd)
1.class DB
2. {
3.     private static $instance;
•     public static function getInstance()
•     {
•         if(!isset(self::$instance)) {
•             self::$instance = new self;
•         }
•
•         return self::$instance;
•     }
• }
• class Order
• {
•     protected $db;
•     public function __construct()
•     {
•         $this->db = DB::getInstance();
•     }
• }

22
•Singleton (ctd)
1.class DB
2. {
3.     //body
4. }
5.class Order
6. {
•     protected $db;
•     public function __construct(DB $db)
•     {
•         $this->db = $db;
•     }
• }

23
•Tight Coupling
1.Order::buy();
1.class House
2. {
3.     public function __construct()
•     {
•          $this->door = new Door();
•          $this->window = new Window();
•     }
• }
1.class House
2. {
3.     public function __construct(Door $door, Window
$window)
•     {
•          $this->door = $door;
•          $this->window = $window;
•     }
• }

24
•Untestable Code
I donI don’’tt
have ahave a
time!time!

25
Never Make Code
Faster Than Necessary,
Something Important Is
Always Lost When You Do
•Premature Optimization

26
•Premature Optimization (ctd)
PerformancePerformance
problemsproblems
20%20% of codeof code

27
•Indescriptive Naming
char * strpbrk ( const char *, const char * );
??

28
•Indescriptive Naming (ctd)
Code is Read Far More Often Than Written

29
DRY (Don’t Repeat Yourself!)
KISS (Keep It Smile, Stupid!)
•Duplication

30
•Singleton
•Tight Coupling
•Untestable Code
•Premature Optimization
•Indescriptive Naming
•Duplication

31
•Single Responsibility Principle
•Open/Closed Principle
•Liskov Substitution Principle
•Interface Segregation Principle
•Dependency Inversion Principle
•Single Responsibility Principle
•Open/Closed Principle
•Liskov Substitution Principle
•Interface Segregation Principle
•Dependency Inversion Principle

34
Advantages of Design
Pattern?
• speed up the development process,
• helps to prevent issues that can cause
major problems,
• patterns allow developers to communicate
using well-known, well understood names
for software interactions

Software Design Patterns

More Related Content

Similar to Software Design Patterns (20)

Recently uploaded (20)

Software Design Patterns