บทนำสู่รูปแบบการออกแบบใน PHP

เผยแพร่แล้ว: 2020-04-14

รูปแบบการออกแบบ PHP ได้รับการพิสูจน์แล้วว่ามีประโยชน์อย่างยิ่งต่อนักพัฒนาและเป็นเครื่องมือแก้ปัญหาที่สำคัญ ในการเขียนโค้ดที่มีประสิทธิภาพ นักพัฒนาต้องปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด รูปแบบการออกแบบ PHP เป็นแนวคิดการเขียนโปรแกรมเชิงวัตถุ (OOP) ซึ่งตอนนี้ยังใช้ในโครงการ Drupal 8 ด้วย Drupal 8 ที่นำแนวคิด PHP และ OOP ที่ทันสมัยมาใช้ รูปแบบการออกแบบสามารถใช้ประโยชน์ได้สำหรับการเขียนโปรแกรมที่สะอาดขึ้นและมีประสิทธิภาพมากขึ้น

รูปแบบการออกแบบใน PHP

Design Pattern ใน PHP คืออะไร?

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

ประโยชน์ของการใช้รูปแบบการออกแบบ PHP

ประโยชน์หลักของรูปแบบการออกแบบใน PHP คือ:

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

รูปแบบการออกแบบที่ใช้กันอย่างแพร่หลายใน PHP

Design Patterns สามารถใช้ในสถานการณ์ต่างๆ เพื่อแก้ปัญหาที่คล้ายคลึงกัน รูปแบบการออกแบบมีประมาณ 23 รูปแบบที่สามารถแบ่งออกได้เป็น 3 ประเภทใหญ่ๆ คือ รูปแบบการออกแบบ - รูปแบบการสร้างสรรค์ โครงสร้าง และพฤติกรรม

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

รูปแบบโครงสร้าง: สิ่งนี้ทำให้การออกแบบง่ายขึ้นโดยระบุวิธีง่ายๆ ในการตระหนักถึงความสัมพันธ์ระหว่างหน่วยงาน

รูปแบบพฤติกรรม: ใช้ในการจัดการความสัมพันธ์ ความรับผิดชอบ และอัลกอริธึมระหว่างอ็อบเจกต์

แบบโรงงาน

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

 อินเตอร์เฟซ FamilyFactoryInterface {
    สาธารณะ การทำงาน สร้าง () : ครอบครัว
}

ถัดไป ใช้ส่วนต่อประสานโรงงานกับคลาสต่อไปนี้:

ระดับ FamilyFactory ดำเนินการ FamilyFactoryInterface {

สาธารณะ การทำงาน สร้าง () : ครอบครัว {

ครอบครัว $ ครอบครัว = ครอบครัว ใหม่ ();

// เริ่มต้นครอบครัวของคุณ

ส่งคืนครอบครัว $;

}

}

รูปแบบอะแดปเตอร์

ในรูปแบบการออกแบบอแด็ปเตอร์ คลาสจะเปลี่ยนอินเทอร์เฟซของคลาสหนึ่งเป็นคลาสอื่น ในตัวอย่างนี้ เรามีคลาส TextBook ที่มีเมธอด getTitle() และ getAuthor() ลูกค้าคาดหวังเมธอด getTitleAndAuthor() เพื่อ "ปรับ" SimpleBook สำหรับ demoAdapter เรามีคลาสอแด็ปเตอร์ BookAdapter ซึ่งรับอินสแตนซ์ของ TextBook และใช้เมธอด TextBook getTitle() และ getAuthor() ในเมธอด getTitleAndAuthor ของตัวเอง

<?php

ระดับ หนังสือเรียน {

ชื่อ $ ส่วนตัว ;
ผู้เขียน $ ส่วนตัว ;
การทำงาน __construct ($title_in, $author_in) {
$this ->title = $title_in;

$นี้ ->ผู้เขียน = $author_in;
}

การทำงาน getTitle () {
กลับ $นี้ ->ชื่อ;
}
การทำงาน getAuthor () {
กลับ $นี้ ->ผู้เขียน;
}
}

ระดับ หนังสืออะแดปเตอร์ {
หนังสือ $ ส่วนตัว ;
การทำงาน __construct (ตำรา $ book_in) {
$นี้ ->หนังสือ = $book_in;
}
การทำงาน getTitleAndAuthors () {
กลับ $นี้ ->book->getTitle() ' โดย ' . $นี้ ->book->getAuthor();
}
}

// ลูกค้า

writeln( 'เริ่มต้นการทดสอบรูปแบบอะแดปเตอร์' );
writeln( '' );

$book = new TextBook( "Gamma, Helm, Johnson และ Vlissides" , "Design Patterns" );
$bookAdapter = ใหม่ BookAdapter($ หนังสือ);
writeln( 'ผู้แต่งและชื่อเรื่อง: ' .$bookAdapter->getTitleAndAuthor());
writeln( '' );

writeln( 'สิ้นสุดการทดสอบรูปแบบอะแดปเตอร์' );

การทำงาน writeln ($ line_in) {
ก้อง $line_in. "<br/>" ;
}

?>

รูปแบบ PHP Singleton

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

<?php
ระดับ ซิงเกิลตัน
{
สาธารณะ คงที่ การทำงาน รับอินสแตนซ์ ()
{
สแตติก $instance = null ;
ถ้า ( null === $ ตัวอย่าง) {
$instance = ใหม่ คงที่ ();
}
ส่งคืน $instance;
}
มีการป้องกัน การทำงาน __สร้าง ()
{
}
ส่วนตัว การทำงาน __โคลน ()
{
}
ส่วนตัว การทำงาน __wakeup ()
{
}
}
ระดับ SingletonChild ยืดออก ซิงเกิลตัน
{
}
$obj = ซิงเกิลตัน::getInstance();
var_dump($obj === ซิงเกิลตัน::getInstance());
$obj2 = SingletonChild::getInstance();
var_dump($obj2 === ซิงเกิลตัน::getInstance());
var_dump($obj2 === SingletonChild::getInstance());
?>

รูปแบบผู้สังเกตใน PHP

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

นี่คือลักษณะของรหัส -

ระดับ โรงละคร {

สาธารณะ การทำงาน ปัจจุบัน (ภาพยนตร์ $movie) : โมฆะ {

$วิจารณ์ = $movie->getCritics();
$this ->message->send($critics, '...' );

$movie->play();

$movie->หยุดชั่วคราว( 5 );
$this ->progress->interval($critics)
$movie->end();

$this ->response->request($วิจารณ์);
}
}

รูปแบบมัณฑนากรสำหรับ PHP

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

อินเตอร์เฟซ อินเทอร์เฟซ Sleepr {
สาธารณะ การทำงาน นอนหลับ () : โมฆะ;
}
ระดับ โซฟา ดำเนินการ อินเทอร์เฟซสำหรับผู้นอน {
สาธารณะ การทำงาน นอน () : โมฆะ {
//นอนโซฟา
}
}
ระดับ เตียง ดำเนินการ อินเทอร์เฟซสำหรับผู้นอน {
สาธารณะ การทำงาน นอน () : โมฆะ {
//นอนบนเตียง
}
}

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

ระดับ สมาร์ทโซฟา ยืดออก โซฟา {
ฟังก์ชั่นสาธารณะ sleep() : โมฆะ {
ผู้ปกครอง::sleep();
$ นี่ ->sleepHours();
}
}
ระดับ สมาร์ทเบด ยืดออก หน้าต่าง {
ฟังก์ชั่นสาธารณะ sleep() : โมฆะ {
ผู้ปกครอง::sleep();
$ นี่ ->sleepHours();
}
}

ตอนนี้เรามีทั้งหมด 4 คลาส อย่างไรก็ตาม เราสามารถแก้ปัญหานี้ได้ 3 คลาสด้วยลวดลายมัณฑนากรเท่านั้น โดยใช้วิธีดังนี้:

ระดับ SmartSleeper ดำเนินการ อินเทอร์เฟซสำหรับผู้นอน {

ส่วนตัว $ sleeper;
สาธารณะ การทำงาน __construct (SleeperInterface $ sleeper) {
$this ->sleeper = $sleeper;
}

สาธารณะ การทำงาน นอน () : โมฆะ {
$this ->sleeper->sleep();
$นี้ ->sleepHours();
}
}
$sofa = โซฟา ใหม่ ();
$bed = เตียง ใหม่ ();
$smartSofa = ใหม่ SmartSleeper($sofa);
$smartBed = ใหม่ SmartSleeper($bed);

ที่นี่ เราได้เปิดตัวสลีปรูปแบบใหม่ที่ทำหน้าที่เหมือนพร็อกซี แต่มีฟังก์ชันพิเศษอยู่ด้านบน

ใช้ประโยชน์จากรูปแบบการออกแบบใน Drupal 8

แม้ว่าจะมีรูปแบบการออกแบบมากมายที่สร้างไว้แล้วใน Drupal ก่อน Drupal 8 แต่ตอนนี้ Drupal 8 ประกอบด้วยรูปแบบมากมายที่ก่อนหน้านี้ไม่พร้อมใช้งาน รูปแบบใหม่เหล่านี้บางส่วนแทนที่รูปแบบเก่าอย่างสมบูรณ์ ในขณะที่รูปแบบอื่นๆ ได้แนะนำคุณสมบัติใหม่บางอย่างให้กับ Drupal 8

รูปแบบการออกแบบที่ใช้ใน Drupal 8 ประกอบด้วย:

  • รูปแบบการเขียนโปรแกรมเชิงวัตถุ (OOP)
  • การฉีดพึ่งพา
  • แบบโรงงาน
  • รูปแบบซิงเกิล

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

การฉีดพึ่งพา

การพึ่งพาการฉีดเป็นรูปแบบการออกแบบซอฟต์แวร์ที่จะช่วยให้คุณลบการพึ่งพาแบบฮาร์ดโค้ดและทำให้สามารถเปลี่ยนได้บนรันไทม์หรือในเวลาคอมไพล์ การเพิ่มการพึ่งพาอาศัยกันเป็นเรื่องง่ายและจะไม่เข้าไปยุ่งกับโค้ดที่มีอยู่ของคุณ Drupal 8 นำเสนอแนวคิดของบริการเพื่อแยกฟังก์ชันการทำงานที่ใช้ซ้ำได้ core.services.yml เป็นตัวอย่างสำหรับการฉีดพึ่งพาใน Drupal 8 เราได้พูดถึง Factory Pattern และ Singleton Pattern ใน PHP ข้างต้นแล้ว