A tervezési minták általános és újrahasznosítható megoldások szoftvertervezési problémákra. Egy tervezési minta a megoldás vagy egy sablon leírása, amely alkalmazható a probléma megoldására – nem pedig egy közvetlenül alkalmazható kódrészlet. Objektumorientált minták általában az osztályok vagy objektumok közötti kapcsolatokat és interakciókat mutatják be, anélkül hogy meghatároznák az érintett osztályok vagy objektumok végleges formáját.
Singleton Minta
A Singleton minta célja, hogy egy osztály példányainak számát egyetlen objektumra korlátozza. Ez lehetővé teszi, hogy az alkalmazásban egyetlen példányt használjunk egy objektumból.
Mikor hasznos?
- Logoló objektumok.
- Megosztott erőforrások, például adatbázis-kapcsolatok vagy socketek.
- Alkalmazás-konfigurációs objektumok.
- Factory objektumok.
PHP implementáció:
class Singleton {
private static $instance = null;
// Konstruktor privát, hogy ne lehessen közvetlenül példányosítani
private function __construct() {}
// Statikus metódus, amely visszaadja az egyetlen példányt
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
public function doSomething() {
echo "Singleton példány működik.\n";
}
}
// Használat
$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();
$instance1->doSomething();
// Ellenőrizhetjük, hogy ugyanaz az objektum-e
var_dump($instance1 === $instance2); // true
Factory Minta
A Factory minta olyan objektumok generálására használatos, amelyek kapcsolódó osztályok példányait hozzák létre (például egy közös interfészt vagy absztrakt osztályt implementálnak).
Mikor hasznos?
- Amikor el akarjuk választani az objektumokat a tényleges példányosítási logikától.
- Ha az objektum létrehozása összetett (például több lépést igényel).
PHP implementáció:
interface Product {
public function getType();
}
class ProductA implements Product {
public function getType() {
return "Ez egy A típusú termék.";
}
}
class ProductB implements Product {
public function getType() {
return "Ez egy B típusú termék.";
}
}
class Factory {
public static function createProduct($type) {
switch ($type) {
case 'A':
return new ProductA();
case 'B':
return new ProductB();
default:
throw new Exception("Ismeretlen termék típus.");
}
}
}
// Használat
$product1 = Factory::createProduct('A');
$product2 = Factory::createProduct('B');
echo $product1->getType(); // Ez egy A típusú termék.
echo $product2->getType(); // Ez egy B típusú termék.
Observer Minta
Az Observer minta egy 1:n függőségi kapcsolatot definiál objektumok között. Amikor egy objektum állapota megváltozik, az összes ráépülő objektum (megfigyelő) automatikusan értesül és frissül.
Mikor hasznos?
- Amikor több osztály függ egy másik osztály viselkedésétől.
- Például eseményfigyelés, GUI frissítések.
PHP implementáció:
class Subject {
private $observers = [];
public function attach($observer) {
$this->observers[] = $observer;
}
public function detach($observer) {
$key = array_search($observer, $this->observers);
if ($key !== false) {
unset($this->observers[$key]);
}
}
public function notify() {
foreach ($this->observers as $observer) {
$observer->update();
}
}
public function changeState() {
echo "A Subject állapota megváltozott.\n";
$this->notify();
}
}
interface Observer {
public function update();
}
class ConcreteObserver implements Observer {
private $name;
public function __construct($name) {
$this->name = $name;
}
public function update() {
echo "Observer {$this->name} értesítve lett!\n";
}
}
// Használat
$subject = new Subject();
$observer1 = new ConcreteObserver("1");
$observer2 = new ConcreteObserver("2");
$subject->attach($observer1);
$subject->attach($observer2);
$subject->changeState(); // Az összes observer értesítve lesz
Zárszó
Ezek a példák bemutatják, hogy a Singleton, Factory és Observer minták hogyan valósíthatók meg PHP-ben. Ezek az alapvető minták gyakran használtak különböző problémák megoldására az objektumorientált szoftvertervezésben.
