รูปแบบการออกแบบคืออะไร: ทำไมต้องใช้มัน การจำแนกประเภท ข้อดีและข้อเสีย

ในวิศวกรรมซอฟต์แวร์ รูปแบบการออกแบบเป็นวิธีแก้ปัญหาที่เหมาะสมที่สุดสำหรับปัญหาที่มักเกิดขึ้นในการออกแบบซอฟต์แวร์

พวกเขาเป็นเหมือนโครงการก่อนdefiเครื่องมือ Nite ที่ผ่านการทดลองและทดสอบแล้วซึ่งคุณสามารถปรับแต่งเพื่อแก้ไขปัญหาการออกแบบที่เกิดซ้ำในโค้ดของคุณ

เวลาในการอ่านโดยประมาณ: 6 นาที

รูปแบบการออกแบบคืออะไร

รูปแบบการออกแบบไม่ใช่โค้ดที่เราสามารถคัดลอกและแทรกลงในโปรแกรมของเราได้ เช่นเดียวกับที่เราสามารถทำได้กับฟังก์ชันมาตรฐานหรือไลบรารี รูปแบบการออกแบบเป็นแนวคิดทั่วไปที่สามารถแก้ไขปัญหาเฉพาะได้ โดยพื้นฐานแล้วเป็นโมเดลที่มีรายละเอียดที่เราสามารถติดตามและปรับใช้โซลูชันที่เหมาะกับความเป็นจริงของโปรแกรมของเรา

โมเดลมักสับสนกับอัลกอริธึม เนื่องจากทั้งสองแนวคิดอธิบายวิธีแก้ไขปัญหาทั่วไปสำหรับปัญหาที่ทราบบางประการ ในขณะที่อัลกอริทึม defiหากมีชุดการดำเนินการที่ชัดเจนที่สามารถบรรลุเป้าหมายที่แน่นอนได้เสมอ แบบจำลองจะเป็นคำอธิบายระดับที่สูงกว่าของโซลูชัน รหัสจากรุ่นเดียวกันที่ใช้กับสองโปรแกรมที่แตกต่างกันอาจแตกต่างกัน

หากต้องการเปรียบเทียบ เราสามารถนึกถึงสูตรการทำอาหารได้ ทั้งสองมีขั้นตอนที่ชัดเจนในการบรรลุเป้าหมาย อย่างไรก็ตาม โมเดลก็เหมือนกับโปรเจ็กต์มากกว่า ซึ่งคุณสามารถดูได้ว่าผลลัพธ์และคุณลักษณะของมันคืออะไร แต่ลำดับที่แน่นอนของการนำไปปฏิบัตินั้นขึ้นอยู่กับเราที่เขียนโค้ด

Design Pattern ทำมาจากอะไร?

รูปแบบส่วนใหญ่ได้รับการอธิบายอย่างเป็นทางการเพื่อให้ผู้คนสามารถทำซ้ำได้ในหลายบริบท มาดูองค์ประกอบด้านล่างที่มีอยู่ในคำอธิบายของโมเดล:

• เจตนา ของแบบจำลองอธิบายโดยย่อทั้งปัญหาและวิธีแก้ไข
• แรงจูงใจ อธิบายปัญหาและแนวทางแก้ไขเพิ่มเติมที่แบบจำลองทำให้เป็นไปได้
• โครงสร้าง ของคลาสจะแสดงแต่ละส่วนของโมเดลและความสัมพันธ์กันอย่างไร
• ตัวอย่างโค้ด ด้วยภาษาโปรแกรมยอดนิยมภาษาหนึ่งทำให้ง่ายต่อการเข้าใจแนวคิดเบื้องหลังโมเดล

ทำไมต้องใช้มัน?

โปรแกรมเมอร์สามารถพัฒนาซอฟต์แวร์ได้โดยไม่ต้องรู้ว่ามีรูปแบบการออกแบบอยู่หรือไม่ หลายคนทำ และด้วยเหตุนี้พวกเขาจึงใช้แผนการบางอย่างโดยที่ไม่รู้ตัว แต่ทำไมเราจึงควรใช้เวลาเรียนรู้สิ่งเหล่านั้น?

• การออกแบบลวดลายเป็นชุดของ วิธีแก้ปัญหาที่ทดลองและทดสอบแล้ว ถึงปัญหาทั่วไปในการออกแบบซอฟต์แวร์ แม้ว่าคุณจะไม่เคยประสบปัญหาเหล่านี้มาก่อน แต่การรู้รูปแบบก็ยังมีประโยชน์ เนื่องจากจะสอนวิธีแก้ปัญหาทุกประเภทโดยใช้หลักการออกแบบเชิงวัตถุ
• การออกแบบโมเดล defiพวกเขาสร้างภาษากลางที่คุณและทีมของคุณสามารถใช้เพื่อสื่อสารได้อย่างมีประสิทธิภาพมากขึ้น คุณสามารถพูดว่า “โอ้ ใช้ซิงเกิลตันเพื่อทำสิ่งนี้” แล้วทุกคนจะเข้าใจแนวคิดเบื้องหลังข้อเสนอแนะของคุณ ไม่จำเป็นต้องอธิบายว่าซิงเกิลตันคืออะไรหากคุณรู้รูปแบบและชื่อของมัน

การจำแนกรูปแบบการออกแบบ

รูปแบบการออกแบบแตกต่างกันไปตามความซับซ้อน ระดับรายละเอียด และขนาดของการนำไปใช้ทั่วทั้งระบบที่ออกแบบ

ในการเปรียบเทียบ เราสามารถทำให้ทางแยกปลอดภัยยิ่งขึ้นโดยการติดตั้งสัญญาณไฟจราจรสองสามอัน หรือสร้างทางแยกหลายระดับทั้งหมดที่มีทางเดินใต้ดินสำหรับคนเดินถนน

มักเรียกโมเดลระดับล่างขั้นพื้นฐานที่สุด สำนวน - โดยทั่วไปจะใช้กับภาษาโปรแกรมเดียวเท่านั้น

โมเดลที่เป็นสากลและระดับสูงที่สุดคือ โมเดลสถาปัตยกรรม - นักพัฒนาสามารถใช้รูปแบบเหล่านี้ได้ในแทบทุกภาษา ต่างจากรูปแบบอื่นๆ ตรงที่สามารถใช้เพื่อออกแบบสถาปัตยกรรมของแอปพลิเคชันทั้งหมดได้

นอกจากนี้ทุกรุ่นยังสามารถจำแนกตามรุ่นได้ พยายาม หรือวัตถุประสงค์ สามชั้นเรียนหลักคือ:

• โมเดลสร้างสรรค์ พวกเขามีกลไกการสร้างวัตถุที่เพิ่มความยืดหยุ่นและการนำโค้ดที่มีอยู่กลับมาใช้ใหม่
• แบบจำลองโครงสร้าง พวกเขาอธิบายวิธีประกอบวัตถุและคลาสให้เป็นโครงสร้างที่ใหญ่ขึ้น ทำให้โครงสร้างเหล่านี้มีความยืดหยุ่นและมีประสิทธิภาพ
• แบบจำลองพฤติกรรม พวกเขาจัดการกับการสื่อสารที่มีประสิทธิภาพและการมอบหมายความรับผิดชอบระหว่างวัตถุ

ตัวอย่างรูปแบบการออกแบบใน Laravel: Facade

หน้าตึก เป็นรูปแบบการออกแบบโครงสร้างที่ให้อินเทอร์เฟซที่เรียบง่ายกับไลบรารี เฟรมเวิร์ก หรือชุดคลาสที่ซับซ้อนอื่นๆ

ปัญหาที่เกิดขึ้น

สมมติว่าเราจำเป็นต้องทำให้ซอฟต์แวร์ทำงานได้ โดยอิงตามชุดวัตถุขนาดใหญ่ที่เป็นของไลบรารีหรือเฟรมเวิร์กที่ซับซ้อน โดยปกติแล้ว เราจะต้องเริ่มต้นวัตถุเหล่านี้ทั้งหมด ติดตามการขึ้นต่อกัน ดำเนินการวิธีการตามลำดับที่ถูกต้อง และอื่นๆ

เป็นผลให้ตรรกะทางธุรกิจของคลาสต่างๆ จะถูกเชื่อมโยงอย่างแน่นหนากับรายละเอียดการใช้งานของคลาสของบุคคลที่สาม ซึ่งทำให้ยากต่อการเข้าใจและจัดการ

วิธีการแก้

Una facade เป็นคลาสที่จัดเตรียมอินเทอร์เฟซที่เรียบง่ายให้กับระบบย่อยที่ซับซ้อนซึ่งมีชิ้นส่วนที่เคลื่อนไหวจำนวนมาก ก facade อาจมีฟังก์ชันการทำงานที่จำกัดเมื่อเทียบกับการทำงานโดยตรงกับระบบย่อย อย่างไรก็ตาม มันรวมเฉพาะฟีเจอร์ที่ลูกค้าให้ความสำคัญจริงๆ เท่านั้น

มีอย่างใดอย่างหนึ่ง facade มันจะมีประโยชน์เมื่อเราต้องการรวมแอพเข้ากับไลบรารีที่ซับซ้อนซึ่งมีฟีเจอร์มากมาย แต่เราต้องการเพียงส่วนเล็ก ๆ ของฟังก์ชันการทำงานเท่านั้น

ตัวอย่างเช่น แอปที่อัปโหลดวิดีโอตลกสั้นๆ ที่มีแมวไปยังโซเชียลมีเดียอาจใช้ไลบรารีการแปลงวิดีโอระดับมืออาชีพ อย่างไรก็ตาม สิ่งที่เราต้องการจริงๆ คือคลาสที่มีเมธอดเดียว encode(filename, format)- หลังจากสร้างคลาสดังกล่าวและเชื่อมต่อกับไลบรารีการแปลงวิดีโอแล้ว เราจะมีคลาสแรก facade.

ตัวอย่างเช่น เจ้าหน้าที่รับโทรศัพท์ของศูนย์บริการข้อมูลเป็นเหมือนก facade- ในความเป็นจริง เมื่อเราโทรหาบริการโทรศัพท์ของร้านค้าเพื่อสั่งซื้อทางโทรศัพท์ ผู้ดำเนินการก็เป็นของเรา facade ต่อบริการและแผนกทั้งหมดของร้านค้า ผู้ดำเนินการจัดเตรียมอินเทอร์เฟซเสียงที่เรียบง่ายให้กับระบบการสั่งซื้อ ช่องทางการชำระเงิน และบริการจัดส่งต่างๆ

ตัวอย่างจริงใน PHP

คิดเกี่ยวกับ หน้าตึก เป็นอะแดปเตอร์อย่างง่ายสำหรับระบบย่อยที่ซับซ้อนบางระบบ Facade แยกความซับซ้อนภายในคลาสเดียวและอนุญาตให้โค้ดแอปพลิเคชันอื่นใช้อินเทอร์เฟซแบบธรรมดา

ในตัวอย่างนี้ Facade ซ่อนความซับซ้อนของไลบรารี YouTube API และ FFmpeg จากโค้ดไคลเอ็นต์ แทนที่จะทำงานกับคลาสหลายสิบคลาส ลูกค้าใช้วิธีการง่ายๆ บน 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