Wzorce projektowe – Pyłek
Pyłek (flyweight) jest strukturalnym wzorcem projektowy, stosowany wszędzie tam gdzie wymagane jest tworzenie bardzo dużej liczby identycznych lub podobnych obiektów, którymi można zarządzać w jednolity sposób. Artykuł opisuje użycie wzorca oraz wyjaśnia w jakich sytuacjach zasadne jest jego wykorzystanie.
Charakterystyka wzorca pyłek
Pyłek (flyweight) jest jednym z prostszych wzorców projektowych, którego celem jest tworzenie mniejszej ilości obiektów a co za tym idzie zmniejszenie zużycia zasobów sprzętowych (pamięci i procesora). Może być wykorzystywany wszędzie tam, gdzie istnieje konieczność wykorzystania bardzo dużej ilości takich samych lub podobnych obiektów.
Istotą wzorca jest podział stanów (danych) przechowywanych w obiektach (pyłkach) na wewnętrzne i zewnętrzne:
- Stan wewnętrzny (współdzielony) jest przechowywany w pyłku i składa się zdanych, które nie zależą od kontekstu. Współdzielenie stanów zmniejsza wykorzystanie pamięci i poprawia efektywność programu, ponieważ dane nie są za każdym razem powielane.
- Stan zewnętrzny są unikatowe dla każdego obiektu i zmieniają się wraz ze zmianą kontekstu. Za przekazanie do pyłku stanu zewnętrzny odpowiada obiekt klient, wywołujący działanie wzorca.
Poniższy diagram UML przedstawia główne elementy wzorca oraz relacje między nimi.
Mamy tutaj kilka charakterystycznych elementów, wartych omówienia:
- Interfejs Pyłek – deklaruje metody, przez które konkretne pyłki mogą otrzymać stan zewnętrzny i wykorzystać go do wykonania odpowiedniej logiki.
- Konkretny Pyłek – obejmuje implementację interfejsu, przechowuje stan wewnętrzny, niezależny od kontekstu działania obiektów.
- Fabryka Pyłków – odpowiedzialna za tworzenie i zarządzanie pyłkami; dba o to, że pyłki są odpowiednio współużytkowane.
- Klient – inicjuje działanie logiki aplikacji z wykorzystaniem wzorca, przechowuje referencje do pyłków, oblicza i przetwarza zewnętrzny stan pyłków.
Przykład zastosowania wzorca pyłek – rysowanie mozaiki kolorowych kształtów
Najlepiej działanie wzorca przedstawić na prostym przykładzie. Poniżej przedstawiony został kod aplikacji, która może być wykorzystywana do rysowania mozaiki kolorowych kształtów. Takich kształtów może być tysiące, a więc jest to idealny przykład do wykorzystania omawianego wzorca.
Na wstępie warto się zastanowić co będzie stanem wewnętrznym (współdzielonym) dla naszych pyłków, a co stanem zewnętrznym (unikalnym dla pyłków). Sam kształt (np. okrąg, kwadrat) będzie implementowany przez konkretny pyłek, a każdy z nich będzie zawierał następujące stany: kolor, współrzędna X i współrzędna Y. Kolorów będzie kilka, natomiast współrzędnych może być bardzo wiele (w zależności od wielkości powierzchni na której będziemy rysowali naszą mozaikę). Dla takiej implementacji kolor będzie stanem wewnętrznym, ponieważ jak już zadeklarujemy konkretny kolor kształtu, to on się w żaden sposób nie zmieni i będzie współdzielony dla wszystkich innych kształtów o tym samym kolorze. Współrzędne natomiast będą różne dla każdego z pyłków, więc powinny być dostarczone z zewnątrz.
Po tym krótkim wstępie, przystępujemy do działania. Zacznijmy od prostego interfejsu dla naszych pyłków. Będzie zawierał deklarację konstruktora oraz metody rysującej kształty.
|
1 2 3 4 5 6 7 8 9 |
<?php namespace DesignPatterns\Flyweight\Shapes; Interface ShapeInterface { public function __construct(string $color); public function draw(int $x, int $y): void; } |
Konstruktor inicjuje kolor, czyli stan współdzielony, natomiast funkcja draw rysuje kształt dla przekazanych współrzędnych.
Dalej przystępujemy do napisania konkretnych pyłków, implementujących przygotowany interfejs. Napiszemy obiekty dla dwóch rodzajów kształtów – okręgu (Circle) i kwadratu (Rectangle) . Konstruktor jest w zasadzie taki sam dla każdego z tych obiektów, dlatego napiszemy również abstrakcyjną klasę, zawierającą wspólny kod pyłków.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
<?php namespace DesignPatterns\Flyweight\Shapes; abstract class AbstractShape implements ShapeInterface { /** * @var string */ protected $color; /** * AbstractShape constructor. * * @param string $color */ public function __construct(string $color) { $this->color = $color; } /** * @param int $x * @param int $y */ abstract public function draw(int $x, int $y): void; } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<?php namespace DesignPatterns\Flyweight\Shapes; class Rectangle extends AbstractShape { /** * @param $x * @param $y */ public function draw(int $x, int $y): void { echo 'Drawing Rectangle of '.$this->color.' color, on position '.$x.', '.$y; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<?php namespace DesignPatterns\Flyweight\Shapes; class Circle extends AbstractShape { /** * @param $x * @param $y */ public function draw(int $x, int $y): void { echo 'Drawing Circle of '.$this->color.' color, on position '.$x.', '.$y; } } |
Jak narazie nie ma tu nic specjalnego – proste klasy rozszerzający abstrakcję, implementującą wspólny interfejs. Oczywiście dla uproszczenia, sama funkcjonalność rysowania jest pominięta – chodzi tylko o pokazanie istoty działania wzorca.
Teraz przystąpmy do napisania fabryki pyłków, czyli klasy która będzie zarządzała logiką zwracania pyłków – tzn. albo będzie tworzyła nowy obiekt albo zwracała już istniejący egzemplarz w zależności od kształtu i koloru.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
<?php namespace DesignPatterns\Flyweight\Shapes; class ShapeFactory { /** * @var array */ private static $shapesByColor = []; /** * @param string $type * @param string $color * @return ShapeInterface * @throws \Exception */ public static function getShape(string $type, string $color): ShapeInterface { $key = $type.'_'.$color; if(isset(self::$shapesByColor[$key])) { return self::$shapesByColor[$key]; } switch ($type) { case 'rectangle': self::$shapesByColor[$key] = new Rectangle($color); break; case 'circle': self::$shapesByColor[$key] = new Circle($color); break; default: throw new \Exception('Shape is not defined fpr type: ' . $type); } return self::$shapesByColor[$key]; } } |
Klasa implementuje jedną statyczna metodę getShape, która przyjmuje dwa argumenty typ kształtu i kolor. Na podstawie tych parametrów funkcja sprawdza czy taki pyłek już istnieje i jeżeli tak to zwraca jego egzemplarz, a jeżeli nie to tworzy nowy obiekt pyłku, który oczywiście również zostaje zwrócony. Poszczególne egzemplarze pyłków są zapisywane do tablicy, pełniącej zadanie prostego cache-u.
Ostatnim krokiem jest napisanie prostego klienta, który wykorzysta wszystkie powyżej opisane elementy.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
<?php require_once '../../../vendor/autoload.php'; use DesignPatterns\Flyweight\Shapes\ShapeFactory; try { for($i = 0 ; $i < 10000 ; ++$i) { $shape = ShapeFactory::getShape(getRandomShapeType(), getRandomShapeColor()); $shape->draw(getRandomPositionCord(), getRandomPositionCord()); echo '<br>'; } } catch (Exception $e) { echo 'Error: ' . $e->getMessage(); } function getRandomShapeType(): string { return getRandomArrayElement(['rectangle', 'circle']); } function getRandomShapeColor(): string { return getRandomArrayElement(['red', 'green', 'blue', 'yellow', 'grey', 'pink', 'black', 'white']); } function getRandomPositionCord(): int { return rand(1,100); } function getRandomArrayElement(array $array) { return $array[rand(0, count($array) - 1)]; } |
Zadaniem klienta jest wyrysowanie 10 tyś. obiektów o losowym kształcie, kolorze i współrzędnych w obrębie zadanej powierzchni. Kształty zwracane są za pośrednictwem fabryki pyłków, która w zależności od przekazanych parametrów tworzy nowy kształt albo zwraca już istniejący. Gdyby wzorzec nie został wykorzystany, to musielibyśmy utworzyć 10000 unikalnych obiektów. W tym przypadku tworzymy jedynie 16 obiektów (iloraz kształtów i kolorów), które współdzielą wspólny stan, jakim jest kolor.
Wynikiem działania jest nasz mozaika.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Drawing Rectangle of green color, on position 25, 87 Drawing Circle of pink color, on position 93, 50 Drawing Rectangle of yellow color, on position 25, 52 Drawing Circle of green color, on position 33, 36 Drawing Circle of grey color, on position 65, 3 Drawing Rectangle of pink color, on position 64, 90 Drawing Circle of yellow color, on position 45, 2 Drawing Circle of grey color, on position 80, 92 Drawing Rectangle of green color, on position 59, 45 Drawing Circle of yellow color, on position 15, 9 Drawing Rectangle of yellow color, on position 76, 20 Drawing Rectangle of green color, on position 35, 27 Drawing Circle of grey color, on position 76, 42 Drawing Circle of white color, on position 82, 29 Drawing Rectangle of yellow color, on position 5, 64 Drawing Circle of white color, on position 37, 85 Drawing Circle of green color, on position 36, 4 Drawing Rectangle of black color, on position 91, 32 Drawing Rectangle of red color, on position 38, 2 Drawing Circle of white color, on position 26, 25 Drawing Rectangle of green color, on position 84, 8 ... |
Powyższy przykład można zobaczyć i pobrać na GitHub: https://github.com/molitorys/design-patterns/tree/master/src/Flyweight/Shapes
Podsumowanie
Wzorzec projektowy pyłek powinien być używany wszędzie tam, gdzie:
- aplikacja wymaga tworzenia bardzo dużej liczby podobnych obiektów i z uwagi na ich dużą liczbę, koszty przechowywania tych obiektów byłyby duże
- większość stanów tych obiektów mogą być zapisywane poza nimi, a po przeniesieniu tych stanów na zewnątrz można utworzyć stosunkowo nieliczną grupę obiektów z współdzielonymi stanami wewnętrznymi
- aplikacja nie jest uzależniona od tożsamości obiektów.
Zalety stosowania tego wzorca są tym większe im więcej pyłków jest współużytkowanych oraz im więcej stanów jest współdzielonych.
Serdecznie zapraszam do zapoznania się z wzorcem projektowym pyłek i zastosowania go w praktyce jak tylko nadarzy się okazja. W razie jakichkolwiek pytań lub nieścisłości, proszę o wpisanie komentarza.