Session trochu jinak než běžně

No možná jsem to špatně formuloval. Nezajímalo mě až tak datové úložiště (tím samozřejmě může být databáze, soubor, …). Ale spíše jsem chtěl rozvinout diskuzi o tom jakým způsobem řešit nějakou obecnou třídu pro ukládání těchto uživatelských dat třeba podobně jako je tomu u session do mamespaces.

Entity-Respository-Mapper a pak je ti jedno jak to mapper persistuje :)

tady máš nějaké to počtení: http://www.phpguru.cz/…rstev-modelu

V zásadě jde o to, že si navrhneš Entitu, což je třída, do které dáš data, když je načteš z databáze. Víceméně je to DibiRow (což je ValueObject), ale má properties nadefinované tak, aby odrážely strukturu z databáze (né nezbytně, protože entita může být složená i z více tabulek v DB).

Potom máš Repository, ten by měl umět pracovat s daným interface mapperu, něco jako

interface IMapper
{
	function save($entity); // uložit entitu, sám si rozhodne, jestli aktualizuje, nebo ukládá novou

	function find($id); // najít entitu s ID

	function findBy(array $values); // předáš tomu pole hodnot, podle kterých má hledat. Vrátí entity co odpovídají

	function findOneBy(array $values); // předáš tomu pole hodnot, podle kterých má hledat. Vrátí jednu entitu

	function findAll(); // vrátí všechno

	// popř. si můžeš napsat další funkce, které budou umět nějaké velice specifické funkce
	// ale to spíše až v tom konkrétnějším mapperu
}

Potom takový mapper (třeba ShoppingCartDibiMapper), který implementuje tohle interface, předáš tomu repository a to respository už pak jenom pracuje s tímhle a je mu jedno jestli to ukládá do databáze (dibi mapper) nebo někam do session (ShoppingCartSessionMapper).

Takže máš entitu

class ShoppingCartItem // není třeba, aby entita cokoliv rozšiřovala, netřeba vytvářet ActiveRecord
{
	private $id; // přidat getter a nastavovat v mapperu reflexí, aby nešlo změnit

	public $name; // jméno položky

	public $cost; // kolik stojí

	// .. další vlastnosti

	public function getId()
	{
		return $this->id;
	}
}

*reflexe

Máš repozitář

class ShoppingCartRepository extends Nette\Object
{
	private $mapper;


	public function __construct(IShoppingCartMapper $mapper) // interface IShoppingCartMapper extends IMapper
	{
		$this->mapper = $mapper
	}


	public function save(ShoppingCartItem $item)
	{
		$this->mapper->save($item);
		// pokud ukládám novou, může mapper automaticky nastavovat ID
		return $item; // a pak můžu s ID pracovat $item = $repository->save($item); echo $item->getId();
	}


	public function find($id)
	{
		return $this->mapper->find($id);
	}


	// metody jako findByName patří spíše sem
	public function findByName($name)
	{
		return $this->mapper->findBy(array(
			'name' => $name
		));
	}

	// žádná metoda zde, by neměla šahat na úložiště, to má dělat mapper
}

jednoduchý mapper by pak mohl vypadat

class ShoppingCartDibiMapper extends Nette\Object implements IShoppingCartMapper
{
	private $conn;

	public function __construct(DibiConnection $conn)
	{
		$this->conn = $conn;
	}

	public function save(ShoppingCartItem $item)
	{
		if ($item->getId() === NULL) { // insert
			$data = $this->itemToData($item); // vytáhne data z entity a vrátí jako pole
			$id = $this->conn->insert('shopping_cart', $data)->execute();
			$this->setIdentity($item, $id);

		} else { // update
			$data = $this->itemToData($item); // vytáhne data z entity a vrátí jako pole
			// tady se velice hodí logika, která porovná v jakém stavu byla entita při načtení
			// a v jakém je teď, aby se nemuselo posílat všechno, ale to jsou hodně pokročílé funkce
			// a optimalizace se má dělat až když je potřeba, že :)

			$this->conn->update('shopping_cart', $data)
				->where('id = %i', $item->getId())->execute();
		}
	}

	public function find($id)
	{
		$data = $this->conn->select('*')->from('shopping_cart')->where('id = %i', $id)->fetch();
		return $this->load($data);
	}


	public function findAll()
	{
		$data = $this->conn->select('*')->from('shopping_cart')->where('id = %i', $id)->fetchAll();

		$result = array();
		foreach ($data as $row) {
			$result[$row->id] = $this->load($row);
		}

		return $result;
	}

	private function load($data)
	{
		$item = new ShoppingCartItem;
		$this->setIdentity($item, $data->id);

		unset($data['id']);
		foreach ($data as $prop => $val) {
			$item->$prop = $val;
		}

		return $item;
	}

	private function setIdentity($item, $id)
	{
		$ref = Nette\Reflection\ClassReflection($item);
		$idProp = $ref->getProperty('id');
		$idProp->setAccessible(TRUE);
		$idProp->setValue($item, $id);

		return $item;
	}

}

Tenhle mapper je opravu hodně jednoduchý, neumí řadit, limity, složitější věci, atd. A tohle je právě docela otrava dělat pro každou entitu. Ale je to nejlepší možné řešení. Protože je to pak krásné oddělené a moc hezky se s tím pracuje.

$repository = new ShoppingCartRepository(new ShoppingCartDibiMapper(dibi::getConnection()));

$item = new ShoppingCartItem();
$item->name = "Ponožky";
$item->cost = 20;

$item = $repository->save($item);

echo $item->getId();

$item = $repository->find(1);
echo $item->name;

Pokud chceš pokoročit pak ještě dál, tak si Repository nadefinuješ jako službu, uděláš si na něj nějakou továrniču a pracuješ s tím zase o něco hezčeji :)

// $this === $presenter
$repository = $this->getApplication()->getService('JmenoEshopu\ShoppingCart');

Tenhle přístup používá i Doctrine2 mimochodem :)

… sakra jsem se zase rozepsal :D

// přepsáno do kuchařky: https://pla.nette.org/…itory-mapper

Editoval HosipLan (19. 2. 2011 19:04)

Můj názor je takový, že by jsi se měl podívat na dokumentové databáze http://couchdb.apache.org/ a http://www.mongodb.org/ :)

HosipLan napsal(a):

	private function setIdentity($item, $id)
	{
		$ref = Nette\Reflection\ClassReflection($item);
		$idProp = $ref->getProperty('id');
		$idProp->setAccessible(TRUE);
		$idProp->setValue($item, $id);

		return $item;
	}

Narazil jsem ještě při testování tvého příkladu pětivrstvého nodelu na problém s ClassReflection a nedaří se mi přes něj přenést. Aplikace mi v mém případě spadne konkrétně na řádku:

$ref = ClassReflection($entity);

Když zakomentuji volání setIdentity tak vše funguje až na to že v entitě není samozřejmě id.

Dále jsem přišel ještě na to že v interface IShoppingCartMapper je třeba mít u parametru metody save() definovano ShoppingCartItem, jinak mi to nefungovalo.

function save(ShoppingCartItem $entity);

• new Nette\Reflection\ClassReflection($item);
• Jinak proč to nefungovalo(kvůli chybějícímu určení typu v interface)? jakou to házelo hlášku? Z důvodu, že v interface neni určen typ a v třídě ano?

Já to mám takhle (Nette dev):

<?php
$ref = \Nette\Reflection\ClassReflection::from( $entity );
?>

A HosipLan tam chybu nemá, nastínil jen obecný interface pro mapper.

Editoval studna (25. 2. 2011 17:16)