Play-Doh: Modelling your Objects Matthew Weier O'Phinney Project Lead Zend Framework

What we've learned and what we do

Oooh! Let's create the schema!

Write code that uses the DB

Object Relational Mapping (ORM) ActiveRecord Table/Row Data Gateway Plain Old Mysql (POM)

Object Relational Mapping (ORM)

ActiveRecord

Table/Row Data Gateway

Plain Old Mysql (POM)

And then …

we start lamenting about performance we end up refactoring for every new feature (esp. caching, logging) we need to go to a Service Oriented Architecture, and refactor twice

we start lamenting about performance

we end up refactoring for every new feature (esp. caching, logging)

we need to go to a Service Oriented Architecture, and refactor twice

STOP THE MADNESS!

Step One

Models are just classes. Create classes.

< ?php class Person { protected $_email ; protected $_password ; protected $_username ; public function __get ( $name ) { $local = '_' . $name ; if ( property_exists ( $this , $local )) { return $this -> $local ; } return null ; } public function __set ( $name , $value ) { $local = '_' . $name ; if (! property_exists ( $this , $local )) { throw new InvalidArgumentException (); } $this -> $local = $value ; } }

Step Two

Identify what data you need to persist Identify how you'll persist the data Write code for persisting data (Data Access Layer)

Identify what data you need to persist

Identify how you'll persist the data

Write code for persisting data (Data Access Layer)

CREATE TABLE person ( username VARCHAR PRIMARY KEY , password VARCHAR , email VARCHAR , ); < ?php class PersonTable extends Zend_Db_Table_Abstract { protected $_name = 'person' ; protected $_primary = 'username' ; }

Step Three

Map your model to your data: Data Mapper Transaction Script

Map your model to your data:

Data Mapper

Transaction Script

< ?php class PersonMapper { public function save ( Person $person ) { $data = array ( 'username' => $person -> username , 'password' => $person -> password , 'email' => $person -> email , ); $this -> getTable ()-> save ( $data ); } public function fetch ( $username ); public function getTable (); public function setTable ( $table ); }

Step Four

Move application logic to a Service Layer Allows easy consumption of the application via your MVC layer Allows easy re-use of your application via services Write CLI scripts that consume the Service Layer

Move application logic to a Service Layer

Allows easy consumption of the application via your MVC layer

Allows easy re-use of your application via services

Write CLI scripts that consume the Service Layer

What kind of application logic? Validation and filtering Authentication and Authorization Transactions and interactions between models

What kind of application logic?

Validation and filtering

Authentication and Authorization

Transactions and interactions between models

< ?php class PersonService { public function create ( array $data ) { $person = new Person (); if (! $data = $this -> getValidator ()-> isValid ( $data )) { throw new InvalidArgumentException (); } $person -> username = $data [ 'username' ]; $person -> password = $data [ 'password' ]; $person -> email = $data [ 'email' ]; $this -> getMapper ()-> save ( $person ); return $person ; } }

Decorating for Fun and Profit

Refactor to add caching? No! Decorate!

< ?php class CachingPersonMapper { protected $_mapper ; public function __construct ( PersonMapper $mapper ) { $this -> _mapper = $mapper ; } public function fetch ( $username ) { $cache = $this -> getCache (); if (! $person = $cache -> load ( $username )) { $person = $this -> _mapper -> fetch ( $username ); $cache -> save ( $person , $username ); } return $person ; } }

Refactor or extend to change the return value (e.g., JSON vs XML vs ...)? No! Decorate!

< ?php class JsonPerson { protected $_person ; public function __construct ( Person $person ) { $this -> _person = $person ; } public function __toString () { $data = array ( 'username' => $this -> _person -> username , 'email' => $this -> _person -> email , ); return json_encode ( $data ); } }

Congratulations!

Rebuilding and refactoring is costly and painful Good OOP and encapsulation CAN make your life easier Testing is easier than debugging

Rebuilding and refactoring is costly and painful

Good OOP and encapsulation CAN make your life easier

Testing is easier than debugging

Think beyond the DB!

Thank you.