Шаблоны проектирования

26.11.2019

Interface

Facade
Decorator
Adapter
Delegation pattern
Bridge
Composite

Пример пидаль у машины. Скрывает всю работу, показываю только один рычаг

основной шаблон проектирования, являющийся общим методом для структурирования компьютерных программ для того, чтобы их было проще понять. В общем, интерфейс — это класс, который обеспечивает программисту простой или более программно-специфический способ доступа к другим классам.

Интерфейс может содержать набор объектов и обеспечивать простую, высокоуровневую функциональность для программиста (например, Шаблон Фасад); он может обеспечивать более чистый или более специфический способ использования сложных классов («класс-обёртка»); он может использоваться в качестве «клея» между двумя различными API (Шаблон Адаптер); и для многих других целей.

Другими типами интерфейсных шаблонов являются: Шаблон делегирования, Шаблон компоновщик, и Шаблон мост.

SOLID переместить Интерфейсы

    
interface LoggerInterface {
    public function write($message);
}

class LogToFile implements LoggerInterface {
    public function write($message){
        echo $message;
    }
}

class LogToDatsbase implements LoggerInterface {
    public function write($message){
        echo $message;
    }
}

class Users {
    private $logger;
    function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
        $this->logger->write('1');
    }
    
}

$user = new Users(new LogToFile);

Property container

Обеспечение возможности уже построенного и развернутого приложения. Например добавление свойств для товаров.

    

    class PropertyContainerInterface {
        function addProperty($name, $value);
        function deleteProperty($name);
        function getProperty($name);
        function setProperty($name, $value);
    }

    class PropertyContainer implements PropertyContainerInterface{
        private $propertyContainer = [];

        public function addProperty ($name, $value) {
            $this->propertyContainer[$name] = $value;
        }
        public function deleteProperty ($name) {
            unset($this->propertyContainer[$name]); 
        }
        public function setProperty ($name, $value) {
            if(!isset($this->propertyContainer[$name])){
                throw new \Exception();
            }
            return $this->propertyContainer[$name] = $value; 
        }
        public function getProperty ($name) {
            return $this->propertyContainer[$name] ?? null; 
        }
    }


    class Movie extends PropertyContainer{

    }

    $move = new Movie();
    $move->addProperty("time", "92");

Delegation pattern

mixins
aspects
композиция (агрегациия)

Объект внешне выражает некоторое поведение, но в реальности передаёт ответственность за выполнение этого поведения связанному объекту. Шаблон делегирования является фундаментальной абстракцией, на основе которой реализованы другие шаблоны - композиция (также называемая агрегацией), примеси (mixins) и аспекты (aspects).

    

interface MessageInterface {
    public function setSender($value): MessageInterface;
    public function setRecipient($value): MessageInterface;
    public function setMessage($value): MessageInterface;
    public function send(): bool;

}
class AbstractMessenger implements MessageInterface {

    protected $sender;
    protected $recipient;
    protected $message;

    public function setSender($value) : MessageInterface
    {
        $this->sender = $value;
        return $this;
    }

    public function setRecipient($value) : MessageInterface
    {
        $this->recipient = $value;
        return $this;
    }
    public function setMessage($value): \MessageInterface
    {
        $this->message = $value;
        return $this;
    }

    public function send() : bool
    {
        return true;
    }
}
class SmsMessenger extends AbstractMessenger {
    public function send() : bool
    {
        return parent::send();
    }
}
class EmailMessenger extends AbstractMessenger {
    public function send() : bool
    {
        return parent::send();
    }
}

class AppMessenger implements MessageInterface
{
    private $messager;

    function __construct()
    {
        $this->toEmail();
    }

    private function toEmail()
    {
        $this->messager = new EmailMessenger();
        return $this;
    }
    private function toSms()
    {
        $this->messager = new SmsMessenger();
        return $this;
    }

    public function setSender($value) : MessageInterface
    {
        $this->messenger->sender = $value;
        return $this->messager;
    }

    public function setRecipient($value) : MessageInterface
    {
        $this->messenger->recipient = $value;
        return $this->messager;
    }
    public function setMessage($value): \MessageInterface
    {
        $this->messenger->message = $value;
        return $this->messager;
    }

    public function send() : bool
    {
        return $this->messager->send();
    }
}
$item = new AppMessenger();

// Отправиться по email 
$item->setSender('email@gmail.com')
->setRecipient('email@gmail.com')
->setMessage('testmessage')
->send();

// Отправиться по sms 
$item->toSms()
->setSender('email@gmail.com')
->setRecipient('email@gmail.com')
->setMessage('testmessage')
->send();

Event channel

Создание канала связи и коммуникации посредством событий. Этот канал обеспечивает возможность разным издателям публиковать события и подписчикам, подписываясь на них, получать уведомления.

    

interface EventChannelInterface 
    {
        // Всем кто подписан на $topic отправить $data 
        public function publish($topic, $data);
        // Подписка на канал $topic
        public function subscribe($topic, SubscriberInterface $subscriber);
    }
    class EventChannel implements EventChannelInterface
    {
        private $topic = [];

        public function publish($topic, $data)
        {
            if(empty($this->topic[$topic])){
                return;
            }
            foreach ($this->topics[$topic] as $subscriber) {
                $subscriber->notify($data);
            }
            
        }
        public function subscribe($topic, \SubscriberInterface $subscriber)
        {
            $this->topic[$topic][] = $subscriber;
        }
    }


    interface PublisherInterface
    {
        public function publish($data);
    }

    class Publisher implements PublisherInterface {

        private $topic;
        private $eventChannel;

        function __construct($topic, EventChannelInterface $eventChannel){
            $this->topic = $topic;
            $this->eventChannel = $eventChannel;
        }

        public function publish($data)
        {
            $this->eventChannel->publish($this->topic, $data);
        }
    }

    interface SubscriberInterface {
        public function notify($data);
    }

    class Subscriber implements SubscriberInterface 
    {
        private $name;

        function __construct($name)
        {
            $this->name = $name;
        }
        public function notify($data)
        {
            echo $data;
        }
    }

    // Создаем канал, сюда поместим массив групп, со списком пользователей
    $newsChannel = new EventChannel();
    
    // Создаем оповещение по группам
    $userGroupCar = new Publisher('car-news', $newsChannel);
    $userGroupTravel = new Publisher('travel-news', $newsChannel);
    $userGroupNature = new Publisher('travel-news', $newsChannel);

    // Создаем подписчиков
    $user1 = new Subscriber('Petr Ivanov');
    $user2 = new Subscriber('Suzan Krok');
    $user3 = new Subscriber('Ella Summer');

    // Помещаем подписчиков в группы
    $newsChannel->subscribe('car-news', $user1);
    $newsChannel->subscribe('car-news', $user2);
    $newsChannel->subscribe('travel-news', $user1);
    $newsChannel->subscribe('travel-news', $user3);



    // Рассылаем ползователям новости по группам
    $userGroupCar->publish('New Car post');
    $userGroupTravel->publish('New Travel post');
    $userGroupNature->publish('New Nature post');

Abstract factory

Класс, который представляет собой интерфейс для создания компонентов системы.

    


    class Controller
    {
        private $guiKit;

        function __construct()
        {
            $this->guiKit = (new GuiFactory())->getFactory('bootstrap');
        }
        public function AbstractFctory()
        {
            $result[] = $this->guiKit->buildButton()->draw();
            $result[] = $this->guiKit->buildCheckBox()->draw();
        }
    }

    interface GuiFactoryInterface
    {
        public function buildButton():ButtonInterface;
        public function buildCheckBox():CheckBoxInterface;
    }
    Interface ButtonInterface
    {
        public function draw();
    }
    Interface CheckBoxInterface
    {
        public function draw();
    }

    class GuiFactory
    {
        public function getFactory($type): GuiFactoryInterface
        {
            switch ($type) {
                case 'bootstrap':
                    return new BootstrapFactory();
                    break;
                case 'sematicui':
                    return new SemanticUiFactory();
                    break;
                default:
                    throw new \Exception('Неизвестный тип фабрики [{$type}]');

            }
        }
    }
    class BootstrapFactory implements GuiFactoryInterface
    {
        public function buildButton()
        {
            return new ButtonBootstrap;
        }
        public function buildCheckBox()
        {
            return new checkBoxBootstrap;
        }
    }

    class SemanticUiFactory implements GuiFactoryInterface
    {
        public function buildButton()
        {
            return new ButtonSemantic;
        }
        public function buildCheckBox()
        {
            return new checkBoxSemantic;
        }
    }

    class ButtonBootstrap implements ButtonInterface
    {
        public function draw()
        {
            // для примера сделано
            return __CLASS__;
        }
    }
    class checkBoxBootstrap implements checkBoxInterface
    {
        public function draw()
        {
            // для примера сделано
            return __CLASS__;
        }
    }
    class ButtonSemantic implements ButtonInterface
    {
        public function draw()
        {
            // для примера сделано
            return __CLASS__;
        }
    }
    class checkBoxSemantic implements checkBoxInterface
    {
        public function draw()
        {
            // для примера сделано
            return __CLASS__;
        }
    }

Decorator

Класс, расширяющий функциональность другого класса без использования наследования.

    


interface CarService {
    public function getCoast();
    public function getDescription();
}

class BasicInspection implements CarService {
    public function getCoast()
    {
        return 25;
    }
    public function getDescription()
    {
        return 'Basic inspection';
    }
}


class OilChange implements CarService {
    protected $carService;

    function __construct(CarService $carService) {
        $this->carService = $carService;
    }
    public function getCoast()
    {
        return 12 + $this->carService->getCoast;
    }
    public function getDescription()
    {
        return $this->carService->getDescription(). ' and oil change';
    }
}

class TireRotation implements CarService {
    protected $carService;

    function __construct(CarService $carService) {
        $this->carService = $carService;
    }
    public function getCoast()
    {
        return 15 + $this->carService->getCoast;
    }
    public function getDescription()
    {
        return $this->carService->getDescription(). 'and tire rotation';
    }
}

echo (new TireRotation(new BasicInspection()))->getCoast(); //40

$service = new OilChange(new BasicInspection);
$service2 = new TireRotation(new OilChange(new BasicInspection));
echo $service->getCoast(); // 52
echo $service->getDescription(); // Basic inspection and oil change and tire rotation