PHP 실용적인 디자인 패턴: PHP의 디자인 패턴

이 글은 번역된 글입니다

원본 주소: Design Patterns in PHP
PHP를 배울 계획이라면 저자가 작성한 프로그래밍 언어 학습 지식 시스템의 핵심 목록을 참고하세요

이 글에서는 주로 웹 개발, 정확히 말하면 PHP 개발에 관련된 디자인 패턴과 그 적용에 대해 논의합니다. 숙련된 개발자라면 분명 디자인 패턴에 매우 익숙할 것입니다. 그러나 이 문서는 주로 주니어 개발자를 대상으로 합니다. 먼저 디자인 패턴이 무엇인지 이해해야 합니다. 디자인 패턴은 설명을 위한 패턴이 아니며, 연결 목록과 같은 일반적인 데이터 구조도 아니고, 특별한 애플리케이션이나 프레임워크 디자인도 아닙니다. 실제로 디자인 패턴은 다음과 같이 설명됩니다.

특정 상황에서 일반적인 디자인 문제를 해결하기 위해 사용자 정의된 통신 개체 및 클래스에 대한 설명

반면 디자인 패턴은 일상적인 프로그래밍에서 자주 직면하는 문제를 해결하기 위해 광범위하게 재사용 가능한 방법을 제공합니다. 디자인 패턴은 반드시 클래스 라이브러리나 타사 프레임워크는 아니며 아이디어에 가깝고 시스템에서 널리 사용됩니다. 또한 다양한 시나리오에서 문제를 해결하는 데 사용할 수 있는 패턴이나 템플릿으로도 나타납니다. 디자인 패턴을 사용하면 개발 속도를 높이고 많은 큰 아이디어나 디자인을 간단한 방법으로 구현할 수 있습니다. 물론 디자인 패턴은 개발에 매우 ​​유용하지만 부적절한 시나리오에서는 오용되지 않도록 해야 합니다.

현재 23개의 공통 디자인 패턴이 있으며, 이는 다양한 사용 목적에 따라 다음 세 가지 범주로 나눌 수 있습니다.

생성 패턴: 객체를 구현에서 분리하기 위해 객체를 생성하는 데 사용됩니다.

아키텍처 패턴: 서로 다른 객체 사이에 큰 객체 구조를 구성하는 데 사용됩니다.

행동 패턴: 서로 다른 개체 간의 알고리즘, 관계 및 책임을 관리하는 데 사용됩니다.

창의적인 패턴 싱글톤(단일 케이스 모드)

싱글턴 패턴은 웹 애플리케이션 개발에서 가장 일반적인 패턴 중 하나이며 런타임 시 특정 클래스의 액세스 가능한 인스턴스를 생성하는 데 자주 사용됩니다.

/**
 * 싱글톤 클래스
*/
최종수업 제품
{

 /**
 * @var self
*/
 private static $instance;

 /**
 * @var 혼합
*/
 public $mix;


 /**
 * 셀프 인스턴스 반환
 *
 * @return self
*/
 public static function getInstance() {
 if (!(self::$instance instanceof self)) {
 self::$instance = new self();
 }
 return self ::$instance;
 }

 개인 함수 __construct() {
 }

 개인 함수 __clone() {
 }
}

$firstProduct = 제품::getInstance();
$secondProduct = 제품::getInstance();

$firstProduct->mix = 'test';
$secondProduct->mix = '예';

print_r($firstProduct->mix);
// 예
print_r($secondProduct->mix);
// 예

많은 경우 시스템의 여러 클래스에 대한 싱글톤 생성 방법을 생성해야 합니다. 이러한 방식으로 보편적인 추상 상위 팩토리 방법을 설정할 수 있습니다.

추상 클래스 FactoryAbstract {

 protected static $instances = array();

 공용 정적 함수 getInstance() {
 $className = static::getClassName();
 if (!(self::$instances[$className] 인스턴스of $className)) {
 self::$instances [$ className] = new $className();
 }
 return self::$instances[$className];
 }

 공개 정적 함수 RemoveInstance() {
 $ className = static::getClassName();
 if (array_key_exists($className, self::$instances)) {
 unset(self::$instances[$className]);
 }
 }

 최종 보호 정적 함수 getClassName() {
 return get_called_class();
 }

 보호 함수 __construct() { }

 최종 보호 함수 __clone () { }
}

추상 클래스 Factory 확장 FactoryAbstract {

 final public static function getInstance() {
 return parent::getInstance();
 }

 최종 공용 정적 함수 RemoveInstance() {
 parent::removeInstance();
 }
}
// using:

class FirstProduct 확장 Factory {
 public $a = [];
}
class SecondProduct는 FirstProduct {
}

FirstProduct::getInstance()->a[] = 1;
SecondProduct를 확장합니다. :: getInstance()->a[] = 2;
FirstProduct::getInstance()->a[] = 3;
SecondProduct::getInstance()->a[] = 4;

print_r(FirstProduct::getInstance()->a);
// array(1, 3)
print_r(SecondProduct::getInstance()->a);
/ /array(2, 4)

기재 등록 데스크 모드는 그다지 일반적이지 않으며 일반적인 제작 모드도 정적 메소드를 사용하여 데이터에보다 편리하게 액세스하는 것입니다.

 클래스 패키지 {
 보호 된 정적 $ data = array () ;
 public static function set ($ key, $ value) { self :: $ data [$ key] = $ value;
 public static function get ( $ key) { return isset (self :: $ data [$ key])? key) { if (array_key_exists ($ key, self :: $ data)) { unset (self :: $ data [$ key]);
}
}
}

 package :: set ( 'name', 'package name');
 print_r (package :: get ( 'name'));
 // 패키지 이름
 공장 (공장 모드)
 공장 패턴은 이름에서 알 수 있듯이 매우 일반적으로 사용되는 또 다른 패턴입니다. 실제로 객체 인스턴스의 생산 공장입니다. 어떤 의미에서, 공장 패턴은 특정 내부 구현에 관심을 갖지 않고 객체를 얻는 데 도움이되는 일반적인 방법을 제공합니다.


 & lt;? php

 인터페이스 팩토리 {
 public function getProduct ();
}

 인터페이스 제품 {  공개 함수 getName ();
}
 클래스 FirstFactory Ampess Factory {
 public function getProduct () {
 return new FirstProduct ();

return 'Second Product';

} } }

 AbstractFactory (추상 공장 패턴)
 어떤 경우에는 다른 선택 논리에 따라 다른 건설 공장을 제공해야하며, 여러 공장의 경우 통일 된 추상 공장이 필요합니다 🎜>
 클래스 구성 { public static $ factory = 1;
}
 인터페이스 제품 {
 public function getName ();
}

 추상 클래스 AbstractFactory {
 public static function getFactory () {
 switch (config :: $ factory) { case 1 :
 return new FirstFactory ();  case 2 : > 새로운 SecondFactory ()를 반환합니다.  class firstFactory 확장 atbractFactory {
 public function getProduct () {
 return new FirstProduct (); }
 클래스 FirstProduct는 제품 {
 public function getName () { '첫 번째 공장에서 제품을 반환합니다'; }

 클래스 SecondFactory 확장 extractFactory {
 public function getProduct () {
 return new SecondProduct () ;
}
}
 클래스 SecondProduct는 제품을 구현합니다 {
 public function getName () {
 'Sec 🎜> $ firstProduct = actractory :: getFactory ()-& gt; getProduct ();
 config :: $ factory = 2;
 $ secondProduct = AbstractFactory :: getFactory ()-& gt; getProduct ();

 print_r ($ FirstProduct- & gt; getName ());  // 첫 번째 공장
 print_r ($ secondProduct- & gt; getName ());
////////////////////////// second 두 번째 공장에서

 복사 코드
 객체 풀
 객체 풀은 일련의 객체를 구성하고 저장하고 필요할 때 호출을 얻는 데 사용될 수 있습니다.   보호 된 $ id;   공개 함수 __construct ($ id) { 공개 기능 getID () { return $ this- & gt; id; }

 클래스 팩토리 {

 보호 된 정적 $ products = array ();

 public static function pushproduct (Product $ product) { self :: $ products [$ product- & gt; getId ()] = $ product;
 public static function getProduct ($ id) { return isset (self :: $ products [$ id])? { if (array_key_exists ($ id, self :: $ products))) {
 unset (self :: $ products [$ id]);
}
}
}
   factory :: 푸시 제품 (신제품 ( 'First'));
 factory :: PushProduct (신제품 ( 'second'));
 print_r (Factory :: getProduct (getProduct '첫 번째')-& gt; getId ());
 // first  print_r (팩토리 :: getProduct ( 'Second')-& gt; getId ());
 코드 복사

 게으른 초기화 (게으른 초기화)
 특정 변수의 초기화도 종종 클래스에 사용됩니다. 종종 어떤 기능이 사용될 지 알 수 없으며 일부 기능은 종종 한 번만 필요합니다.

 & lt;? php

 인터페이스 제품 {
 public function getName ();
}

 클래스 팩토리 {   보호 된 $ firstProduct;
 보호 된 $ secondProduct;
 public function getFirstProduct () { if (! $ this- & gt; firstProduct) { return $ this- & gt; firstProduct;  public function getSecondProduct () {
 if (! $ this- & gt; SecondProduct) {
 $ this- & gt; SecondProduct = New SecondProduct ();  return $ this- & gt; SecondProduct;
}
}

 클래스 첫 번째 프로듀트 릴리즈 곱 {
 public function getName () {

PHP