نمط واجهة المبنى
المحتويات
- class HardDrive {
- عملاء
- مخطط الصنفUML ومخطط التسلسل
- نظرة عامة
- computer_facade = ComputerFacade
- class Memory {
- class HardDrive {
- HardDrive read 0 1024
- /**
- بوويرشيل PowerShell
- الاستخدام
- @processor.freeze
- بايثون
- };
- "$this read $lba $size" | Out-Host
- }
- class CPU {
- self.cpu.freeze
- /**
- عادة ما يتم استخدام نمط الواجهة عندما
- {
- cpu_->Freeze;
- مثال
- Jumping to: 0x00
- # Complex computer parts
- class ComputerFacade {
- $this.cpu.freeze
- processor.freeze;
- $this->cpu->freeze;
- {
- واجهة مبنى
- self.ssd = SolidStateDrive
- accessories.SetAccessories;
- /**
- class Memory {
قبل الخوض في التفاصيل، نمط واجهة المبنى (يلفظ (فساد) façade كذلك) هو نمط تصميم برامج شائع الاستخدام في البرمجة كائنية التوجه. تشبه الواجهة في العمارة، الواجهة هي كائن يعمل كواجهة أمامية تخفي كودًا أساسيًا أو بنيويًا أكثر تعقيدًا. يمكن للواجهة:
كذلك، بمثابة نقطة انطلاق لمُعدِّل أوسع للأنظمة المتآلفة أو المترابطة بإحكام لصالح كود أكثر ترابطاً.
وفي السياق ذاته، غالبًا ما يستعمل المطورون نمط تصميم الواجهة عندما يكون النظام معقدًا للغاية أو يصعب فهمه لأن النظام يحتوي على الكثير من الأصناف المترابطة أو لأن الكود المصدري غير متوفر. يخفي هذا النمط تعقيدات النظام الأكبر ويوفر واجهة أبسط للعميل. وعادةً ما تتضمن صنف مغلّف واحد يحتوي على مجموعة من الأعضاء التي يطلبها العميل. يدخل هؤلاء الأعضاء إلى النظام نيابة عن عميل الواجهة ويخفي تفاصيل التنفيذ.
كذلك، تحسين إمكانية قراءة مكتبة البرامج وإمكانية استخدامها من خلال إخفاء التفاعل مع المكونات الأكثر تعقيدًا وراء واجهة برمجة تطبيقات واحدة (وغالبًا ما تكون مبسطة)
علاوةً على ذلك، توفير واجهة خاصة بالسياق لمزيد من الوظائف العامة (كاملة مع التحقق من صحة المدخلات الخاصة بالسياق)
class HardDrive {
}
public byte[] read(long lba, int size) { ... }
عملاء
تستعمل الكائنات نمط الواجهة للوصول إلى الموارد من الحزم.
مخطط الصنفUML ومخطط التسلسل
مخطط الصنف UML
في هذا الإطار، في الرسم التخطيطي لصنف UML أعلاه، لا يصل صنف Client إلى أصناف النظام الفرعي مباشرة. بدلاً من ذلك، يعمل العميل Client من خلال صنف الواجهة Facade التي تطبق واجهة بسيطة من حيث (عن طريق التفويض إلى) أصناف النظام الفرعي ( Class1 و Class2 و Class3 ). يعتمد Client فقط على واجهة Facade البسيطة وهو مستقل عن النظام الفرعي المعقد. يعرض الرسم التخطيطي للتسلسل تفاعلات وقت التشغيل: يعمل كائن عميل Client خلال كائن واجهة Facade الذي يفوض الطلب إلى مثيلات الأصناف التالية Class1 و Class2 و Class3 التي تقوم بتنفيذ الطلب.
نظرة عامة
ومن ناحية أخرى، نمط تصميم الواجهة هو واحد من ثلاثة وعشرون نمطًا من أنماط تصميم GoF المعروفة التي تصف كيفية حل مشاكل التصميم المتكررة لتصميم برنامج مرن وقابل لإعادة الاستخدام، أي الكائنات التي يسهل تنفيذها، وتغييرها، اختبار وإعادة استخدامها.
وفي هذا السياق، لتسهيل استخدام نظام فرعي معقد، يجب توفير واجهة بسيطة لمجموعة من الواجهات في النظام الفرعي.
كذلك، يشير العملاء الذين يصلون إلى نظام فرعي معقد مباشرة (يعتمد على) الكثير من الكائنات المختلفة التي لها واجهات مختلفة (اقتران ضيق)، مما يجعل العملاء صعب التنفيذ والتغيير والاختبار وإعادة الاستخدام.
ما هي المشاكل التي يمكن أن يحلها نمط تصميم الواجهة؟
ومن ناحية أخرى، يتيح هذا العمل من خلال كائن واجهة Facade لتقليل التبعيات على نظام فرعي. انظر كذلك صنف UML ومخطط التسلسل أدناه.
يجب تقليل التبعيات على نظام فرعي.
- ما الحل الذي يصفه نمط تصميم الواجهة؟
- تعريف كائن واجهة Facade من أجل ذلك.
- ينفذ واجهة بسيطة من حيث (بتفويض) الواجهات في النظام الفرعي
- قد تؤدي وظائف إضافية قبل/ بعد إعادة توجيه الطلب.
computer_facade = ComputerFacade
من جانب آخر، Loading from 0x00 data: 'Some data from sector 100 with size 1024'.
computer_facade.start Output: Freezing processor.
class Memory {
public:
void Load(long position, char* data);
class HardDrive {
- public:
- char* Read(long lba, int size);
- };
HardDrive read 0 1024
- Memory load 0 (some data)
- CPU jump to 10
- CPU execute
/**
- * The facade that users would be interacting with.
- */
- class ComputerFacade
- {
- protected CPU $cpu;
- protected Memory $memory;
- protected HardDrive $hd;
- public function __construct
- {
- $this->cpu = new CPU;
- $this->memory = new Memory;
- $this->hd = new HardDrive;
- }
- public function start : void
- {
بوويرشيل PowerShell
- """
- Facade pattern example.
- """
- class CPU {
- freeze {
- "$this freezing" | Out-Host
- }
- jump($position) {
- "$this jump to $position" | Out-Host
- }
- execute {
- "$this execute" | Out-Host
- }
- }
- class Memory {
- load($position, $data) {
- "$this load $position $data" | Out-Host
- }
- }
- class HardDrive {
- [object] read($lba, $size) {
الاستخدام
من جهة ثانية، يتم استخدام الواجهة عند الرغبة في استخدام واجهة أسهل أو أبسط لكائن أساسي. بدلاً من ذلك، يمكن استخدام محول عندما يجب أن يلتزم الغلاف بواجهة معينة ويجب أن يدعم السلوك متعدد الأشكال. يجعل الديكور من الممكن إضافة أو تغيير سلوك واجهة في وقت التشغيل.
@processor.freeze
- @ram.load(BOOT_ADDRESS, @hd.read(BOOT_SECTOR, SECTOR_SIZE))
- @processor.jump(BOOT_ADDRESS)
- @processor.execute
- end
- end
- # Client
- computer_facade = ComputerFacade.new
- computer_facade.start
- PHP
بايثون
- """
- Facade pattern example.
- """
};
// Facade:
"$this read $lba $size" | Out-Host
- return "(some data)"
- }
- }
- # Façade
- class Computer {
- hidden [CPU]$cpu
- hidden [Memory]$memory
- hidden [HardDrive]$hardDrive
- Computer {
- $this.cpu = New-Object CPU
- $this.memory = New-Object Memory
- $this.hardDrive = New-Object HardDrive
- }
- StartComputer {
}
- private:
- std::unique_ptr cpu_ = std::make_unique;
- std::unique_ptr memory_ = std::make_unique;
- std::unique_ptr hard_drive_ = std::make_unique;
- };
- int main {
- ComputerFacade computer;
- computer.Start;
- }
- #C
- التنفيذ
- namespace DesignPattern.Facade
- {
- class SubsystemA
- {
- public string OperationA1
- {
- return "Subsystem A, Method A1\n";
- }
- public string OperationA2
- {
- return "Subsystem A, Method A2\n";
- }
- }
- class SubsystemB
- {
- public string OperationB1
- {
- return "Subsystem B, Method B1\n";
- }
- public string OperationB2
- {
- return "Subsystem B, Method B2\n";
- }
- }
- class SubsystemC
- {
- public string OperationC1
- {
- return "Subsystem C, Method C1\n";
- }
- public string OperationC2
- {
- return "Subsystem C, Method C2\n";
- }
- }
- public class Facade
- {
- private readonly SubsystemA a = new SubsystemA;
- private readonly SubsystemB b = new SubsystemB;
- private readonly SubsystemC c = new SubsystemC;
- public void Operation1
- {
- Console.WriteLine("Operation 1\n" +
- a.OperationA1 +
- b.OperationB1 +
- c.OperationC1);
- }
- public void Operation2
- {
- Console.WriteLine("Operation 2\n" +
- a.OperationA2 +
- b.OperationB2 +
- c.OperationC2);
- }
- }
- }
- عينة من الكود
- namespace DesignPattern.Facade.Sample
- {
- // The 'Subsystem ClassA' class
- class CarModel
- {
- public void SetModel
- {
- Console.WriteLine(" CarModel - SetModel");
- }
- }
- ///
- /// The 'Subsystem ClassB' class
- ///
- class CarEngine
- {
- public void SetEngine
- {
- Console.WriteLine(" CarEngine - SetEngine");
- }
- }
- // The 'Subsystem ClassC' class
- class CarBody
- {
- public void SetBody
- {
- Console.WriteLine(" CarBody - SetBody");
- }
- }
- // The 'Subsystem ClassD' class
- class CarAccessories
- {
- public void SetAccessories
- {
- Console.WriteLine(" CarAccessories - SetAccessories");
- }
- }
- // The 'Facade' class
- public class CarFacade
- {
- private readonly CarAccessories accessories;
- private readonly CarBody body;
- private readonly CarEngine engine;
- private readonly CarModel model;
- public CarFacade
- {
- accessories = new CarAccessories;
- body = new CarBody;
- engine = new CarEngine;
- model = new CarModel;
- }
- public void CreateCompleteCar
class CPU {
- public:
- void Freeze;
- void Jump(long position);
- void Execute;
- };
self.cpu.freeze
- self.memory.load("0x00", self.ssd.read("100", "1024"))
- self.cpu.jump("0x00")
- self.cpu.execute
/**
- * How a user could start the computer.
- */
- $computer = new ComputerFacade;
- $computer->start;
عادة ما يتم استخدام نمط الواجهة عندما
نظام معقد للغاية أو يصعب فهمه،
- هناك حاجة إلى نقطة دخول لكل مستوى من مستويات البرامج، أو
- تجريدات وتنفيذات نظام فرعي مرتبطة بإحكام.
- بناء
يكون المطلوب واجهة بسيطة للوصول إلى نظام معقد،
{
- static void Main(string[] args)
- {
- var facade = new CarFacade;
- facade.CreateCompleteCar;
- Console.ReadKey;
- }
- }
- }
- جافا
- /* Comp
- class CPU {
- public void freeze { ... }
- public void jump(long position) { ... }
- public void execute { ... }
- }
cpu_->Freeze;
- memory_->Load(kBootAddress, hard_drive_->Read(kBootSector, kSectorSize));
- cpu_->Jump(kBootAddress);
- cpu_->Execute;
مثال
علاوةً على ذلك، هذا مثال تجريدي لكيفية تفاعل العميل ("you") مع واجهة ("computer") لنظام معقد (أجزاء الكمبيوتر الداخلية، مثل وحدة المعالجة المركزية والأجهزة).
#include
++C
Jumping to: 0x00
Executing.
# Complex computer parts
- class CPU(object):
- """
- Simple CPU representation.
- """
- def freeze(self) -> None:
- print("Freezing processor.")
- def jump(self, position) -> None:
- print("Jumping to:", position)
- def execute(self) -> None:
- print("Executing.")
- class Memory(object):
- """
- Simple memory representation.
- """
- def load(self, position, data):
- print("Loading from {0} data: '{1}'.".format(position, data))
- class SolidStateDrive(object):
- """
- Simple solid state drive representation.
- """
- def read(self, lba, size):
- return "Some data from sector {0} with size {1}".format(lba, size)
- class ComputerFacade(object):
- """
- Represents a facade for various computer parts.
- """
- def __init__(self) -> None:
- self.cpu = CPU
- self.memory = Memory
class ComputerFacade {
public:
void Start {
$this.cpu.freeze
- $this.memory.load(0, $this.hardDrive.read(0, 1024))
- $this.cpu.jump(10)
- $this.cpu.execute
- }
- }
- $façade = [Computer]::new
- $façade.StartComputer Output: CPU freezing
processor.freeze;
- ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
- processor.jump(BOOT_ADDRESS);
- processor.execute;
- }
- }
- /* Client */
- class You {
- public static void main(String[] args) {
- ComputerFacade computer = new ComputerFacade;
- computer.start;
- }
- }
- روبي
- # Complex Parts
- class CPU
- def freeze; end
- def jump(position); end
- def execute; end
- end
- class Memory
- def load(position, data); end
- end
- class HardDrive
- def read(lba, size); end
- end
- # Facade
- class ComputerFacade
- def initialize
- @processor = CPU.new
- @ram = Memory.new
- @hd = HardDrive.new
- end
- def start
$this->cpu->freeze;
- $this->memory->load(BOOT_ADDRESS, $this->hd->read(BOOT_SECTOR, SECTOR_SIZE));
- $this->cpu->jump(BOOT_ADDRESS);
- $this->cpu->execute;
- }
- }
{
- Console.WriteLine("******** Creating a Car **********");
- model.SetModel;
- engine.SetEngine;
- body.SetBody;
واجهة مبنى
تلخص صنف الواجهة الحزم 1 و 2 و 3 من بقية التطبيق.
self.ssd = SolidStateDrive
def start(self) -> None:
accessories.SetAccessories;
- Console.WriteLine("******** Car creation is completed. **********");
- }
- }
- // Facade pattern demo
- class Program
/**
- * The complicated, underlying logic.
- */
- class CPU
- {
- public function freeze {/* ... */}
- public function jump($position) {/* ... */}
- public function execute {/* ... */}
- }
- class Memory
- {
- public function load($position, $data) {/* ... */}
- }
- class HardDrive
- {
- public function read($lba, $size) {/* ... */}
- }
class Memory {
- public void load(long position, byte[] data) { ... }
- }
- /* Facade */
- class ComputerFacade {
- private final CPU processor;
- private final Memory ram;
- private final HardDrive hd;
- public ComputerFacade {
- this.processor = new CPU;
- this.ram = new Memory;
- this.hd = new HardDrive;
- }
- public void start {
📝 هل في هذه المقالة خطأ؟
إذا وجدت معلومة تحتاج تصحيحاً أو إضافة، أو أردت حذف المقالة، أرسل لنا طلباً وسنراجعه.
ما رأيك في هذه المقالة؟