Transparent Object Persistence (within FLOW3)

Inspiring people toshare

Transparent Object Persistence

(within FLOW3)Karsten Dambekalns <[email protected]>

Samstag, 16. Mai 2009


“DDD persistence”Domain Models encapsulate behavior and data

Concerned about the problem – only

Infrastructure is of no relevance

Unfortunately you need to be aware of the infrastructure at some point – at least a little



EntitiesIdentity is important

Are not defined by their attributes

Examples could be...

• Projects

• Developers



Value objectsHave no indentity

Their value is of importance

Are interchangeable

Examples could be...

• Colors

• Numbers

• Tags in Forge



AggregatesCluster associated objects

Have a boundary and a root

The root is a specific entity

References from outside point to the root

An example for an aggregate:

• Project



RepositoriesProvide access to entities (and aggregates)

Allow to find a starting point for traversal

Persisted objects can be searched for

Queries can be built in various ways

Handle storage of additions and updates



A Domain ModelProject

Repository

Project

twitter Account

Developer

SVN Account




Repository

Project

twitter Account

Developer

SVN Account

Reposit




Repository

Project

twitter Account

Developer

SVN Account

Reposit

Aggre-gates



A Domain Model

twitter Account

Developer

SVN Account



Using FLOW3...You just implement the model

No need to care about persisting your model

FLOW3 handles this for you – transparently

Even a Repository only needs little work

Define relevant metadata in the source file using annotations



@nnotations used



@nnotations used@entity




@valueobject




@valueobject

@var




@valueobject

@var

@transient




@valueobject

@var

@transient

@uuid




@valueobject

@var

@transient

@uuid

@identity




@valueobject

@var

@transient

@uuid

@identity

@lazy



Persistence ManagerMostly invisible to developers

Manages additions of and updates to objects

Concerned only about objects in repositories

Collects objects and hands over to backend

Allows for objects being persisted at any time

Automatically called to persist at end of script run



Simplified stack

SQLite PgSQL MySQL ...



Simplified stack


PDO ...



Simplified stack


TYPO3 Content Repository

PDO ...



Simplified stack



PDO ...

FLOW3 Persistence



Simplified stack



PDO ...

FLOW3 Persistence

Application Application



Simplified stack

TYPO3 CR

FLOW3 Persistence

Persistence Backend



FLOW3TYPO3 CR



Transparent persistenceExplicit support for Domain-Driven Design

Class Schemata are defined by the Domain Model class

• No need to write an XML or YAML schema definition

• No need to define the database model and object model multiple times at different places

Automatic persistence in the JSR-283 based Content Repository

Legacy data sources can be mounted



Query FactoryCreates a query for you

Decouples persistence layer from backend

Must be implemented by backend

API with one method:

• public function create($className);



Query objectsRepresent a query for an object type

Allow criteria to be attached

Must be implemented by backend

Simple API

• execute()

• matching()

• equals(), lessThan(), ...

• ...



Object reconstitutionWhen fetching objects the content repository looks for matching nodes

The nodes are mapped to objects by a data mapper

Reconstitution

• does not call __construct()

• restores all non-transient properties

• reinjects dependencies (skips constructor arguments)



public function map(\F3\PHPCR\NodeIteratorInterface $nodes) { $objects = array(); foreach ($nodes as $node) { $object = $this->mapSingleNode($node); $this->persistenceManager->getSession()->registerReconstitutedObject($object); $objects[] = $object; }

return $objects;}

Object reconstitution

\F3\TYPO3CR\FLOW3\Persistence\DataMapper



$explodedNodeTypeName = explode(':', $node->getPrimaryNodeType()->getName(), 2);$className = str_replace('_', '\\', $explodedNodeTypeName[1]);$classSchema = $this->persistenceManager->getClassSchema($className);$objectConfiguration = $this->objectManager->getObjectConfiguration($className);

$object = $this->objectBuilder->createEmptyObject($className, $objectConfiguration);$this->identityMap->registerObject($object, $node->getIdentifier());

$this->objectBuilder->reinjectDependencies($object, $objectConfiguration);$this->thawProperties($object, $node, $classSchema);$object->FLOW3_Persistence_memorizeCleanState();





public function createEmptyObject($objectName, \F3\FLOW3\Object\Configuration $objectConfiguration) {

$className = $objectConfiguration->getClassName();

if (!in_array('F3\FLOW3\AOP\ProxyInterface', class_implements($className))) {throw new \F3\FLOW3\Object\Exception\CannotReconstituteObject('Cannot create empty instance of the class "' . $className . '" because it does not implement the AOP Proxy Interface.', 1234386924);

}

$object = unserialize('O:' . strlen($className) . ':"' . $className . '":0:{};'); $object->FLOW3_AOP_Proxy_setProperty('objectFactory', $this->objectFactory); $object->FLOW3_AOP_Proxy_setProperty('objectManager', $this->objectManager); $object->FLOW3_AOP_Proxy_declareMethodsAndAdvices();

return $object;}


\F3\FLOW3\Object\Builder



Lazy LoadingLoading a full object tree makes sense – or not

It does most of the time

If your domain model has small aggregates eager loading makes sense

If you have expensive to create objects or a lot of smaller ones you don’t always need, lazy loading helps

Example: displaying a list of projects doesn’t need the projects details, just the names



Lazy LoadingIdeally you would not think about lazy loading beyond the addition of the @lazy annotation

In practice you need to be aware of some technical issues

In place of the real object you get a proxy, so

• you can’t use it at type hinted places

• pass it around without some thinking

Using it otherwise works as expected

After first use the proxy will be completely gone



public function _loadRealInstance() { $realInstance = $this

->F3_FLOW3_Persistence_LazyLoadingProxy_population->__invoke();

$this->F3_FLOW3_Persistence_LazyLoadingProxy_parent->FLOW3_AOP_Proxy_setProperty(

$this->F3_FLOW3_Persistence_LazyLoadingProxy_propertyName, $realInstance

);

return $realInstance;}

The LazyLoadingProxy

\F3\FLOW3\Persistence\LazyLoadingProxy



$dataMapper = $this; // make available to closure...$objectStorage = new \F3\FLOW3\Persistence\LazyLoadingProxy( $parent, $propertyName, function() use ($proxyNode, $dataMapper) { $objectStorage = new \SplObjectStorage(); $itemNodes = $proxyNode->getNodes(); foreach ($itemNodes as $itemNode) { $objectNode = $itemNode->getNode('flow3:object'); if ($objectNode->getPrimaryNodeType()->getName() ===

\F3\TYPO3CR\FLOW3\Persistence\Backend::NODETYPE_OBJECTPROXY) { $object = $dataMapper->mapObjectProxyNode($objectNode); } else { $object = $dataMapper->mapSingleNode($objectNode); } $objectStorage->attach($object); } return $objectStorage; });




Node structurePHP has more data structures than a content repository, e.g.

• JSR-283 defines multi-valued properties without keys and without stable ordering

• Arrays in PHP have keys and order that are stable and might be important for your code

Thus we do some more mapping to node structures



Questions!



LinksFLOW3http://flow3.typo3.org/

TYPO3CRhttp://forge.typo3.org/projects/show/package-typo3cr

JSR-283http://jcp.org/en/jsr/detail?id=283



Flickr photo credits:megapixel13 (barcode), rmrayner (ring), Ducatirider (grapes), Here’s Kate (book shelf)Pumpkin pictures:http://ptnoticias.com/pumpkinway/


Transparent Object Persistence (within FLOW3)

Technology

Transcript of Transparent Object Persistence (within FLOW3)