Wat binne ûntwerppatroanen: wêrom brûke se, klassifikaasje, foar- en neidielen

Yn software-engineering binne ûntwerppatroanen optimale oplossingen foar problemen dy't gewoanlik foarkomme yn software-ûntwerp.

Se binne as foarprojektendefinite, besocht en hifke ark dat jo kinne oanpasse foar in lossen in weromkommende design probleem yn jo koade.

Skatte lêstiid: 6 minuten

Wat is in ûntwerppatroan

In ûntwerppatroan is gjin koade dy't wy kinne kopiearje en ynfoegje yn ús programma, lykas wy kinne dwaan mei standertfunksjes of biblioteken. It ûntwerppatroan is in algemien konsept dat in bepaald probleem kin oplosse. Yn prinsipe in model waans details wy kinne folgje en implementearje in oplossing dy't past by de realiteit fan ús programma.

Modellen wurde faak betize mei algoritmen, om't beide begripen typyske oplossingen beskriuwe foar guon bekende problemen. Wylst in algoritme defiAs der altyd in dúdlike set fan aksjes is dy't in bepaald doel berikke kinne, is in model in heger nivo beskriuwing fan in oplossing. Koade fan itselde model tapast op twa ferskillende programma's kin oars wêze.

As wy in analogy meitsje wolle, kinne wy ​​tinke oan in kokenrezept: beide hawwe dúdlike stappen om in doel te berikken. In model is lykwols mear as in projekt, wêrfan jo kinne sjen wat it resultaat en har skaaimerken binne, mar de krekte folchoarder fan útfiering hinget ôf fan ús dy't de koade skriuwe.

Wat is in ûntwerppatroan makke fan?

De measte patroanen wurde tige formeel beskreaun, sadat minsken se yn in protte konteksten reprodusearje kinne. Litte wy hjirûnder de eleminten sjen dy't oanwêzich binne yn 'e beskriuwing fan in model:

• De bedoeling fan it model koart beskriuwt sawol it probleem as de oplossing.
• De motivaasje ferklearret fierder it probleem en de oplossing dy't it model mooglik makket.
• Struktuer fan klassen lit elk diel fan it model sjen en hoe't se besibbe binne.
• De koade foarbyld yn ien fan 'e populêrste programmeartalen makket it makliker om it idee efter it model te begripen.

Wêrom brûke se?

In programmeur kin software ûntwikkelje sûnder it bestean fan ûntwerppatroanen te witten. In protte dogge, en om dizze reden implementearje se guon regelingen sûnder it te witten. Mar wêrom moatte wy dan tiid besteegje oan it learen fan se?

• De ûntwerppatroanen binne in kit fan beproefde oplossingen ta mienskiplike problemen yn software design. Sels as jo dizze problemen noait tsjinkomme, is it kennen fan patroanen noch altyd nuttich, om't it jo leart hoe't jo allerhanne problemen kinne oplosse mei objektrjochte ûntwerpprinsipes.
• De ûntwerpmodellen defiSe meitsje in mienskiplike taal dy't jo en jo team kinne brûke om effektiver te kommunisearjen. Jo kinne sizze, "Oh, brûk gewoan in Singleton om dit te dwaan," en elkenien sil it idee efter jo suggestje begripe. It is net nedich om út te lizzen wat in singleton is as jo it patroan en syn namme kenne.

Klassifikaasje fan ûntwerppatroanen

Untwerppatroanen ferskille yn kompleksiteit, detailnivo, en skaal fan tapasberens yn it heule ûntworpen systeem.

Nei analogy kinne wy ​​in krusing feiliger meitsje troch in pear ferkearsljochten te ynstallearjen of in hiele multilevel-wikseling te bouwen mei ûndergrûnske trochgongen foar fuotgongers.

De meast basale modellen op leech nivo wurde faak neamd idioom . Se binne gewoanlik allinich fan tapassing op ien programmeartaal.

De meast universele en hege-nivo modellen binne arsjitektoanyske modellen . Untwikkelders kinne dizze patroanen yn praktysk elke taal ymplementearje. Oars as oare patroanen, kinne se brûkt wurde om de arsjitektuer fan in heule applikaasje te ûntwerpen.

Fierder kinne alle modellen wurde klassifisearre neffens har besocht of doel. De trije haadklassen binne:

• Kreatyf modellen se jouwe foarwerp oanmeitsjen meganismen dy't fergrutsje fleksibiliteit en werbrûk fan besteande koade.
• Strukturele modellen se ferklearje hoe't jo objekten en klassen kinne sammelje yn gruttere struktueren, en dizze struktueren fleksibel en effisjint hâlde.
• Gedrachsmodellen se dogge mei effektive kommunikaasje en tawizing fan ferantwurdlikheden tusken objekten.

Foarbyld fan Design Pattern in Laravel: Gevel

Fassade is in struktureel ûntwerppatroan dat in ferienfâldige ynterface leveret foar in bibleteek, ramt of in oare komplekse set fan klassen.

Problem

Litte wy oannimme dat wy software moatte meitsje wurkje, basearre op in grutte set fan objekten dy't hearre ta in ferfine bibleteek of ramt. Normaal soene wy ​​al dizze objekten moatte inisjalisearje, ôfhinklikens byhâlde, metoaden yn 'e juste folchoarder útfiere, ensfh.

As gefolch soe de saaklike logika fan 'e klassen strak keppele wurde oan de ymplemintaasjedetails fan klassen fan tredden, wêrtroch't se lestich binne te begripen en te behearjen.

Oplossing

una facade is in klasse dy't jout in ienfâldige ynterface oan in kompleks subsysteem dat befettet in protte bewegende dielen. IN facade kin beheinde funksjonaliteit leverje yn ferliking mei direkt wurkjen mei it subsysteem. It omfettet lykwols allinich de funksjes wêr't klanten echt om soarchje.

Hawwe ien facade it is nuttich as wy de app moatte yntegrearje mei in ferfine bibleteek dy't tsientallen funksjes hat, mar wy hawwe mar in lyts part fan syn funksjonaliteit nedich.

Bygelyks, in app dy't koarte grappige fideo's mei katten uploadt nei sosjale media kin mooglik in profesjonele fideokonverzjebibleteek brûke. Lykwols, alles wat wy echt nedich is in klasse mei de ienige metoade encode(filename, format). Nei it meitsjen fan sa'n klasse en it ferbinen mei de fideokonverzjebibleteek, sille wy ús earste hawwe facade.

Bygelyks, de telefoan operator fan in call sintrum is as in facade. Yn feite, as wy de telefoantsjinst fan in winkel skilje om in telefoanyske bestelling te pleatsen, is in operator fan ús facade nei alle tsjinsten en ôfdielingen fan 'e winkel. De operator leveret in ienfâldige stimynterface foar it bestelsysteem, betellingspoarten en ferskate leveringstsjinsten.

Echt foarbyld yn PHP

Tinke oer Fassade as in ienfâldige adapter foar guon komplekse subsystemen. Facade isolearret de kompleksiteit binnen ien klasse en lit oare applikaasjekoade de ienfâldige ynterface brûke.

Yn dit foarbyld, Facade ferberget de kompleksiteit fan 'e YouTube API en FFmpeg-bibleteek fan' e kliïntkoade. Yn stee fan te wurkjen mei tsientallen klassen, de klant brûkt in ienfâldige metoade op 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