Ce sunt modelele de design: de ce să le folosiți, clasificare, argumente pro și contra

În ingineria software, modelele de proiectare sunt soluții optime la problemele care apar de obicei în proiectarea software.

Sunt ca pre-proiecteledefiinstrumente complete, încercate și testate, pe care le puteți personaliza pentru a rezolva o problemă recurentă de proiectare în codul dvs.

Timp de citire estimat: 6 minute

Ce este un model de design

Un model de design nu este un cod pe care îl putem copia și introduce în programul nostru, așa cum putem face cu funcțiile sau bibliotecile standard. Modelul de proiectare este un concept general capabil să rezolve o anumită problemă. Practic un model ale cărui detalii le putem urmări și implementa o soluție care se potrivește realității programului nostru.

Modelele sunt adesea confundate cu algoritmi, deoarece ambele concepte descriu soluții tipice la unele probleme cunoscute. În timp ce un algoritm defiDacă există întotdeauna un set clar de acțiuni care pot atinge un anumit scop, un model este o descriere de nivel superior a unei soluții. Codul din același model aplicat la două programe diferite poate fi diferit.

Dorind să facem o analogie, ne putem gândi la o rețetă de gătit: ambele au pași clari pentru a atinge un obiectiv. Cu toate acestea, un model seamănă mai mult cu un proiect, al cărui rezultat puteți vedea care sunt rezultatul și caracteristicile sale, dar ordinea exactă de implementare depinde de noi cei care scriem codul.

Din ce este făcut un model de design?

Majoritatea tiparelor sunt descrise foarte formal, astfel încât oamenii să le poată reproduce în multe contexte. Să vedem mai jos elementele care sunt prezente în descrierea unui model:

• Intentia a modelului descrie pe scurt atât problema cât și soluția.
• Motivația explică în continuare problema și soluția pe care modelul o face posibilă.
• Structura de clase arată fiecare parte a modelului și modul în care acestea sunt legate.
• Exemplul de cod într-unul dintre cele mai populare limbaje de programare facilitează înțelegerea ideii din spatele modelului.

De ce să le folosești?

Un programator poate dezvolta software fără să cunoască existența modelelor de design. Mulți o fac, și din acest motiv implementează unele scheme fără să știe. Dar atunci de ce ar trebui să petrecem timp învățându-le?

• Modelele de design sunt un kit de solutii incercate si testate la probleme comune în proiectarea software-ului. Chiar dacă nu întâmpinați niciodată aceste probleme, cunoașterea tiparelor este totuși utilă, deoarece vă învață cum să rezolvați tot felul de probleme folosind principiile de proiectare orientate pe obiecte.
• Modelele de design defiEle creează un limbaj comun pe care tu și echipa ta îl poți folosi pentru a comunica mai eficient. Ai putea spune: „O, folosește doar un Singleton pentru a face asta”, și toată lumea va înțelege ideea din spatele sugestiei tale. Nu este nevoie să explici ce este un singleton dacă cunoști modelul și numele acestuia.

Clasificarea modelelor de proiectare

Modelele de proiectare diferă în complexitate, nivel de detaliu și scară de aplicabilitate în întregul sistem proiectat.

Prin analogie, putem face o intersecție mai sigură prin instalarea câtorva semafoare sau construirea unui întreg schimbător pe mai multe niveluri cu pasaje subterane pentru pietoni.

Cele mai de bază, modele de nivel scăzut sunt adesea numite idiomuri . De obicei, acestea se aplică doar unui singur limbaj de programare.

Cele mai universale și de nivel înalt modele sunt modele arhitecturale . Dezvoltatorii pot implementa aceste modele în aproape orice limbă. Spre deosebire de alte modele, acestea pot fi folosite pentru a proiecta arhitectura unei întregi aplicații.

În plus, toate modelele pot fi clasificate în funcție de acestea încercat sau scop. Cele trei clase principale sunt:

• Modele creative oferă mecanisme de creare a obiectelor care măresc flexibilitatea și reutilizarea codului existent.
• Modele structurale ei explică cum să asamblați obiecte și clase în structuri mai mari, păstrând aceste structuri flexibile și eficiente.
• Modele comportamentale se ocupă de comunicarea eficientă și repartizarea responsabilităților între obiecte.

Exemplu de model de design în Laravel: Fațadă

Faţadă este un model de proiectare structurală care oferă o interfață simplificată pentru o bibliotecă, cadru sau orice alt set complex de clase.

Ediția

Să presupunem că trebuie să facem software-ul să funcționeze, pe baza unui set mare de obiecte care aparțin unei biblioteci sau unui cadru sofisticat. În mod normal, ar trebui să inițializam toate aceste obiecte, să ținem evidența dependențelor, să executăm metodele în ordinea corectă și așa mai departe.

Ca urmare, logica de afaceri a claselor ar deveni strâns cuplată cu detaliile de implementare ale claselor terțe, făcându-le dificil de înțeles și de gestionat.

Soluţie

o facade este o clasă care oferă o interfață simplă unui subsistem complex care conține multe părți mobile. A facade poate oferi o funcționalitate limitată în comparație cu lucrul direct cu subsistemul. Cu toate acestea, include doar caracteristicile la care clienții le pasă cu adevărat.

Am una facade este util atunci când trebuie să integrăm aplicația cu o bibliotecă sofisticată care are zeci de caracteristici, dar avem nevoie doar de o mică parte din funcționalitatea acesteia.

De exemplu, o aplicație care încarcă scurte videoclipuri amuzante cu pisici pe rețelele sociale ar putea folosi o bibliotecă profesională de conversie video. Totuși, tot ce avem nevoie este o clasă cu metoda unică encode(filename, format). După ce am creat o astfel de clasă și am conectat-o ​​la biblioteca de conversie video, vom avea prima noastră facade.

De exemplu, operatorul de telefonie al unui call center este ca un facade. De fapt, atunci când sunăm la serviciul telefonic al unui magazin pentru a plasa o comandă telefonică, un operator este al nostru facade fata de toate serviciile si departamentele magazinului. Operatorul oferă o interfață vocală simplă pentru sistemul de comandă, gateway-uri de plată și diverse servicii de livrare.

Exemplu real în PHP

Gandeste-te Faţadă ca un simplu adaptor pentru unele subsisteme complexe. Facade izolează complexitatea într-o singură clasă și permite altor coduri de aplicație să folosească interfața simplă.

În acest exemplu, Facade ascunde complexitatea API-ului YouTube și a bibliotecii FFmpeg din codul clientului. În loc să lucreze cu zeci de clase, clientul folosește o metodă simplă pe Facade.

<?php

namespace RefactoringGuru\Facade\RealWorld;

/**
 * The Facade provides a single method for downloading videos from YouTube. This
 * method hides all the complexity of the PHP network layer, YouTube API and the
 * video conversion library (FFmpeg).
 */
class YouTubeDownloader
{
    protected $youtube;
    protected $ffmpeg;

    /**
     * It is handy when the Facade can manage the lifecycle of the subsystem it
     * uses.
     */
    public function __construct(string $youtubeApiKey)
    {
        $this->youtube = new YouTube($youtubeApiKey);
        $this->ffmpeg = new FFMpeg();
    }

    /**
     * The Facade provides a simple method for downloading video and encoding it
     * to a target format (for the sake of simplicity, the real-world code is
     * commented-out).
     */
    public function downloadVideo(string $url): void
    {
        echo "Fetching video metadata from youtube...\n";
        // $title = $this->youtube->fetchVideo($url)->getTitle();
        echo "Saving video file to a temporary file...\n";
        // $this->youtube->saveAs($url, "video.mpg");

        echo "Processing source video...\n";
        // $video = $this->ffmpeg->open('video.mpg');
        echo "Normalizing and resizing the video to smaller dimensions...\n";
        // $video
        //     ->filters()
        //     ->resize(new FFMpeg\Coordinate\Dimension(320, 240))
        //     ->synchronize();
        echo "Capturing preview image...\n";
        // $video
        //     ->frame(FFMpeg\Coordinate\TimeCode::fromSeconds(10))
        //     ->save($title . 'frame.jpg');
        echo "Saving video in target formats...\n";
        // $video
        //     ->save(new FFMpeg\Format\Video\X264(), $title . '.mp4')
        //     ->save(new FFMpeg\Format\Video\WMV(), $title . '.wmv')
        //     ->save(new FFMpeg\Format\Video\WebM(), $title . '.webm');
        echo "Done!\n";
    }
}

/**
 * The YouTube API subsystem.
 */
class YouTube
{
    public function fetchVideo(): string { /* ... */ }

    public function saveAs(string $path): void { /* ... */ }

    // ...more methods and classes...
}

/**
 * The FFmpeg subsystem (a complex video/audio conversion library).
 */
class FFMpeg
{
    public static function create(): FFMpeg { /* ... */ }

    public function open(string $video): void { /* ... */ }

    // ...more methods and classes... RU: ...дополнительные методы и классы...
}

class FFMpegVideo
{
    public function filters(): self { /* ... */ }

    public function resize(): self { /* ... */ }

    public function synchronize(): self { /* ... */ }

    public function frame(): self { /* ... */ }

    public function save(string $path): self { /* ... */ }

    // ...more methods and classes... RU: ...дополнительные методы и классы...
}


/**
 * The client code does not depend on any subsystem's classes. Any changes
 * inside the subsystem's code won't affect the client code. You will only need
 * to update the Facade.
 */
function clientCode(YouTubeDownloader $facade)
{
    // ...

    $facade->downloadVideo("https://www.youtube.com/watch?v=QH2-TGUlwu4");

    // ...
}

$facade = new YouTubeDownloader("APIKEY-XXXXXXXXX");
clientCode($facade);

Ercole Palmeri