Què són els patrons de disseny: per què utilitzar-los, classificació, pros i contres

En enginyeria de programari, els patrons de disseny són solucions òptimes als problemes que es produeixen habitualment en el disseny de programari.

Són com projectes previsdefiEines clares, provades i provades que podeu personalitzar per resoldre un problema de disseny recurrent al vostre codi.

Temps estimat de lectura: 6 acta

Què és un patró de disseny

Un patró de disseny no és un codi que podem copiar i inserir al nostre programa, com podem fer amb funcions o biblioteques estàndard. El patró de disseny és un concepte general capaç de resoldre un problema particular. Bàsicament un model els detalls del qual podem seguir i implementar una solució que s'ajusti a la realitat del nostre programa.

Els models sovint es confonen amb algorismes, perquè tots dos conceptes descriuen solucions típiques a alguns problemes coneguts. Mentre que un algorisme defiSi sempre hi ha un conjunt clar d'accions que poden assolir un objectiu determinat, un model és una descripció de nivell superior d'una solució. El codi del mateix model aplicat a dos programes diferents pot ser diferent.

Amb ganes de fer una analogia, podem pensar en una recepta de cuina: tots dos tenen clars els passos per aconseguir un objectiu. Tanmateix, un model s'assembla més a un projecte, del qual es pot veure quin és el resultat i les seves característiques, però l'ordre exacte d'implementació depèn de nosaltres qui escrivim el codi.

De què està fet un patró de disseny?

La majoria de patrons es descriuen de manera molt formal perquè la gent els pugui reproduir en molts contextos. Vegem a continuació els elements que estan presents en la descripció d'un model:

• La intenció del model descriu breument tant el problema com la solució.
• La motivació explica encara més el problema i la solució que el model fa possible.
• Estructura de classes mostra cada part del model i com es relacionen.
• L'exemple de codi en un dels llenguatges de programació més populars facilita la comprensió de la idea darrere del model.

Per què utilitzar-los?

Un programador pot desenvolupar programari sense conèixer l'existència de patrons de disseny. Molts sí, i per això implementen alguns esquemes sense saber-ho. Però llavors per què hem de dedicar temps a aprendre-les?

• Els patrons de disseny són un kit de solucions provades i provades a problemes comuns en el disseny de programari. Fins i tot si no us trobeu mai amb aquests problemes, conèixer els patrons segueix sent útil perquè us ensenya a resoldre tot tipus de problemes utilitzant principis de disseny orientat a objectes.
• Els models de disseny defiCreen un llenguatge comú que vosaltres i el vostre equip podeu utilitzar per comunicar-vos de manera més eficaç. Podríeu dir: "Oh, només feu servir un Singleton per fer-ho" i tothom entendrà la idea que hi ha darrere del vostre suggeriment. No cal explicar què és un singleton si coneixeu el patró i el seu nom.

Classificació dels patrons de disseny

Els patrons de disseny difereixen en complexitat, nivell de detall i escala d'aplicabilitat al llarg del sistema dissenyat.

Per analogia, podem fer una intersecció més segura instal·lant uns quants semàfors o construint tot un intercanviador multinivell amb passos subterranis per a vianants.

Els models més bàsics i de baix nivell s'anomenen sovint modismes . Normalment només s'apliquen a un únic llenguatge de programació.

Els models més universals i d'alt nivell són models arquitectònics . Els desenvolupadors poden implementar aquests patrons en pràcticament qualsevol idioma. A diferència d'altres patrons, es poden utilitzar per dissenyar l'arquitectura d'una aplicació sencera.

A més, tots els models es poden classificar segons la seva intent o finalitat. Les tres classes principals són:

• Models de creació proporcionen mecanismes de creació d'objectes que augmenten la flexibilitat i la reutilització del codi existent.
• Models estructurals expliquen com muntar objectes i classes en estructures més grans, mantenint aquestes estructures flexibles i eficients.
• Models de comportament s'ocupen de la comunicació eficaç i l'assignació de responsabilitats entre objectes.

Exemple de patró de disseny a Laravel: Façana

façana és un patró de disseny estructural que proporciona una interfície simplificada a una biblioteca, marc o qualsevol altre conjunt complex de classes.

problema

Suposem que hem de fer que el programari funcioni, basant-nos en un gran conjunt d'objectes que pertanyen a una biblioteca o marc sofisticat. Normalment, hauríem d'inicialitzar tots aquests objectes, fer un seguiment de les dependències, executar mètodes en l'ordre correcte, etc.

Com a resultat, la lògica empresarial de les classes s'acoblaria estretament als detalls d'implementació de les classes de tercers, cosa que dificultaria la seva comprensió i gestió.

Solució

Una facade és una classe que proporciona una interfície senzilla a un subsistema complex que conté moltes parts mòbils. A facade pot proporcionar una funcionalitat limitada en comparació amb treballar directament amb el subsistema. No obstant això, només inclou les funcions que realment importen als clients.

Tens un facade és útil quan necessitem integrar l'aplicació amb una biblioteca sofisticada que té desenes de funcions, però només necessitem una petita part de la seva funcionalitat.

Per exemple, una aplicació que penja vídeos curts i divertits amb gats a les xarxes socials podria utilitzar una biblioteca de conversió de vídeo professional. Tanmateix, tot el que necessitem és una classe amb el mètode únic encode(filename, format). Després de crear aquesta classe i connectar-la a la biblioteca de conversió de vídeo, tindrem la nostra primera facade.

Per exemple, l'operador telefònic d'un centre de trucades és com a facade. De fet, quan truquem al servei telefònic d'una botiga per fer una comanda telefònica, un operador és nostre facade cap a tots els serveis i departaments de la botiga. L'operador proporciona una interfície de veu senzilla al sistema de comandes, passarel·les de pagament i diversos serveis de lliurament.

Exemple real en PHP

Pensar sobre façana com un simple adaptador per a alguns subsistemes complexos. Facade aïlla la complexitat dins d'una sola classe i permet que altres codis d'aplicació utilitzin la interfície senzilla.

En aquest exemple, Facade amaga la complexitat de l'API de YouTube i la biblioteca FFmpeg del codi del client. En lloc de treballar amb desenes de classes, el client utilitza un mètode senzill a Façade.

<?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