Witam,

Chciałem się dowiedzieć czy mój tok myślenia odnośnie programowania obiektowego jest właściwy. Napisałem klasę do obsługi produktu jest to oczywiście mały zalążek tej klasy jednak nim zacznę pisać dalej chciałem się upewnić czy rozwiązania przyjmowane prze zemnie są prawidłowe.

[PHP] pobierz, plaintext 
<?php
 
class product {
 
	/**
	 * Uchwyt do bazy danych.
	 * 
	 * @var myPDO
	 */
	private $db;
 
	/**
	 * Przechowuje identyfikator produktu.
	 * 
	 * @var int
	 */
	private $id;
 
	/**
	 * Przechowuje nazwę produktu.
	 *
	 * @var string
	 */
	private $name;
 
	/**
	 * Przechowuje cenę produktu.
	 * 
	 * @var float
	 */
	private $price;
 
	/**
	 * Przechowuje listę parametrów przypisanych do produktu.
	 * 
	 * @var array
	 */
	private $parameters;
 
	/**
	 * Konstruktor tworzy uhcwyt do bazy danych.
	 */
	public function __construct() {
		$this->db = myPDO::getInstance();
	}
 
	/**
	 * Ustawia identyfikator produktu.
	 * 
	 * @access public
	 * @param int $id - identyfikator produktu
	 * @return void
	 */
	public function setID($id) {
 
		$this->id = (int)$id;
 
		//jeśli został przypisany identyfikator różny od zera 
		//pobieramy informacje z bazy danych
		if($id)
			$this->_getInfo();
	}
 
	/**
	 * Ustawia nazwę produktu.
	 * 
	 * @access public
	 * @param string $name - nazwa produktu
	 * @return void
	 */
	public function setName($name) {
		$this->name = $name;
	}
 
	/**
	 * Ustawia cenę produktu.
	 * 
	 * @access public
	 * @param float $price - cena produktu
	 * @return void
	 */
	public function setPrice($price) {
		$this->price = $price;
	}
 
	/**
	 * Zwraca nazwę produktu.
	 * 
	 * @access public
	 * @return string
	 */
	public function getName() {
		return $this->nazwa;
	}
 
	/**
	 * Zwraca cenę produktu.
	 * 
	 * @access public
	 * @return float
	 */
	public function getPrice() {
		return $this->price; 
	}
 
	/**
	 * Zwraca identyfikator produktu.
	 * 
	 * @access public 
	 * @return int
	 */
	public function getID() {
		return $this->id;
	}
 
	/**
	 * Pobiera informacje z bazy danych o produkcie.
	 *
	 * @access private
	 */
	private function _getInfo() {
 
		$stmt = $this->db->query('	SELECT 
										*
 
									FROM 
										'.PRODUCTS.' 
 
									WHERE 
										id = '.$this->id);
 
		$arrProduct = $stmt -> fetch(PDO::FETCH_ASSOC);
 
		$stmt->closeCursor();
 
		//przypisanie danych z bazy do zmiennych
		$this->name	 = $arrProduct['name'];
		$this->price	 = $arrProduct['price'];
	}
}
?>
[PHP] pobierz, plaintext 

Pierwsze moje pytanie dotyczy samego pobierania danych produktu z bazy danych czy przyjęte rozwiązanie jest prawidłowe czy też można to rozwiązać w jakiś lepszy sposób

Kolejna sprawa dotyczy aktualizacji danych produktu, gdzieś wyczytałem (niestety obecnie nie jestem w stanie określić źródła tych informacji), że dobrym podejściem jest aktualizacja danych produktu w bazie przy niszczeniu obiektu (pisząc odpowiednią funkcję w destruktorze). Czy rzeczywiście jest to dobre rozwiązanie

Ja bym dazyl do osiagniecia takiego mechanizmu:

[PHP] pobierz, plaintext 
<?php
$objProductManager = new ProductManager;
 
$objProductManager->addProduct(new Product('Ksiazka', 32.50, 300));
 
$objProduct = $objProductManager->getProductById(30);
 
print $objProduct->getName();
 
while($objProduct = $objProductManager->getProducts()){
	print $objProduct->getId();
	print $objProduct->getName();
}
?>
[PHP] pobierz, plaintext 

Rozdzielilbym operacja na bazie danych/zrodla danych od jednostki elementarnej czyli produktu.
Manager przyjmuje obiekt produktu i go dodaje do bazy, manager zwraca obiekt produktu z bazy, na ktorym pozniej mozesz prowadzic dalsze operacje.

W OOP jestem poczatkujacy, ale tak to rozumuje.

Czyli rozumiem że w tym wypadku funkcja _getInfo która pobiera informacje z bazy o produkcie miała by zostać przerzucona do klasy ProductManager jako getProductById i mniej więcej miło by to wyglądać w następujący sposób:

[PHP] pobierz, plaintext 
<?php
class ProductManager {
 
	public function getProductById($id) {
 
		$stmt = $this->db->query('	SELECT 
														*
 
													FROM 
														'.PRODUCTS.' 
 
													WHERE 
														id = '.$id);
 
		$arrProduct = $stmt -> fetch(PDO::FETCH_ASSOC);
 
		$stmt->closeCursor();
 
		$objProduct = new product();
 
		$objProduct->setName($arrProduct['name']);
		$objProduct->setPrice($arrProduct['price']);
		$objProduct->setID($arrProduct['id']);
 
		return $objProduct;
	}
 
}
?>
[PHP] pobierz, plaintext 

Mam jeszcze takie pytanko bowiem Ty w swoim przykładzie pokazywałeś że podstawowe dane produktu są przesyłane przez konstruktor, czy należy tak robić nawet w przypadku bardzo dużej ilości parametrów ?

Wedlug mnie twoja metoda wybierajaca dane z bazy powinna zwrocic tablice na ktorej potem bedziesz operowal, a co do konstruktora to powinienes tam wsadzic tylko to co bedzie ci potrzebne przy tworzeniu obiektu klasy

Rzeczywiście zgadzam się z Tobą że lepszym rozwiązaniem będzie zwracanie tablicy. Tak się zastanawiam czy przydakiem obiekt "product" nie będzie już zbędny, gdyż zwrócone dane w postaci tablicy mogę bezpośrednio przekazać do szablonu np. smarty gdzie dane te zostaną wyświetlone. Czy w takim wypadku tworzenie obiektu "product" nie zatraca sensu ? W jakim przypadku obiekt "product" może się przydać ?

W oczywsity sposób - nie musisz pisać kod SQL za każdym razem. Lepszym rozwiązaniem jest stosowanie obiektu Product i productsManager.
Wtedy sam Product to odzwierciedlenie tabeli/tabel bazy danych i operacje na niej, natomiast productsManager, jak nazwa wskazuje - zarządza obektami typu Product. Może zawierać metody np, takie (one nie sa statyczne - tylko tak się zapisuje): productsManager::getAsArray(), productsManager::getProducts(), productsManager::addToCollection() itp.

Pozdrawiam.