찾다

집  >  기사  >  백엔드 개발  >  PHP 실용적인 디자인 패턴: PHP의 디자인 패턴

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

WBOY
WBOY원래의
2016-07-23 08:54:42797검색

이 글은 번역된 글입니다

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

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

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

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

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

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

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

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

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

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

  1. /**
  2. * 싱글톤 클래스
  3. */
  4. 최종수업 제품
  5. {
  7. /**
  8. * @var self
  9. */
  10. private static $instance;
  12. /**
  13. * @var 혼합
  14. */
  15. public $mix;
  18. /**
  19. * 셀프 인스턴스 반환
  20. *
  21. * @return self
  22. */
  23. public static function getInstance() {
  24. if (!(self::$instance instanceof self)) {
  25. self::$instance = new self();
  26. }
  27. return self ::$instance;
  28. }
  30. 개인 함수 __construct() {
  31. }
  33. 개인 함수 __clone() {
  34. }
  35. }
  37. $firstProduct = 제품::getInstance();
  38. $secondProduct = 제품::getInstance();
  40. $firstProduct->mix = 'test';
  41. $secondProduct->mix = '예';
  43. print_r($firstProduct->mix);
  44. // 예
  45. print_r($secondProduct->mix);
  46. // 예
코드 복사

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

  2. 추상 클래스 FactoryAbstract {
  4. protected static $instances = array();
  6. 공용 정적 함수 getInstance() {
  7. $className = static::getClassName();
  8. if (!(self::$instances[$className] 인스턴스of $className)) {
  9. self::$instances [$ className] = new $className();
  10. }
  11. return self::$instances[$className];
  12. }
  14. 공개 정적 함수 RemoveInstance() {
  15. $ className = static::getClassName();
  16. if (array_key_exists($className, self::$instances)) {
  17. unset(self::$instances[$className]);
  18. }
  19. }
  21. 최종 보호 정적 함수 getClassName() {
  22. return get_called_class();
  23. }
  25. 보호 함수 __construct() { }
  27. 최종 보호 함수 __clone () { }
  28. }
  30. 추상 클래스 Factory 확장 FactoryAbstract {
  32. final public static function getInstance() {
  33. return parent::getInstance();
  34. }
  36. 최종 공용 정적 함수 RemoveInstance() {
  37. parent::removeInstance();
  38. }
  39. }
  40. // using:
  42. class FirstProduct 확장 Factory {
  43. public $a = [];
  44. }
  45. class SecondProduct는 FirstProduct {
  46. }
  48. FirstProduct::getInstance()->a[] = 1;
  49. SecondProduct를 확장합니다. :: getInstance()->a[] = 2;
  50. FirstProduct::getInstance()->a[] = 3;
  51. SecondProduct::getInstance()->a[] = 4;
  53. print_r(FirstProduct::getInstance()->a);
  54. // array(1, 3)
  55. print_r(SecondProduct::getInstance()->a);
  56. / /array(2, 4)
코드 복사
기재 등록 데스크 모드는 그다지 일반적이지 않으며 일반적인 제작 모드도 정적 메소드를 사용하여 데이터에보다 편리하게 액세스하는 것입니다.

& lt;? php
    /** * 레지스트리 클래스 */
  1. 클래스 패키지 {
  2. 보호 된 정적 $ data = array () ;
  3. public static function set ($ key, $ value) { self :: $ data [$ key] = $ value;
  4. public static function get ( $ key) { return isset (self :: $ data [$ key])? key) { if (array_key_exists ($ key, self :: $ data)) { unset (self :: $ data [$ key]);
  5. }
  6. }
  7. }
  9. package :: set ( 'name', 'package name');
  10. print_r (package :: get ( 'name'));
  11. // 패키지 이름
  12. 공장 (공장 모드) 공장 패턴은 이름에서 알 수 있듯이 매우 일반적으로 사용되는 또 다른 패턴입니다. 실제로 객체 인스턴스의 생산 공장입니다. 어떤 의미에서, 공장 패턴은 특정 내부 구현에 관심을 갖지 않고 객체를 얻는 데 도움이되는 일반적인 방법을 제공합니다.
  15. & lt;? php
  17. 인터페이스 팩토리 {
  18. public function getProduct ();
  19. }
  21. 인터페이스 제품 { 공개 함수 getName ();
  22. }
  23. 클래스 FirstFactory Ampess Factory {
  24. public function getProduct () {
  25. return new FirstProduct ();
public function getName () {
> return '첫 번째 제품'; } 클래스 SecondProduct 제품을 구현합니다. > public function getName () {
return 'Second Product';

} } }

$ factory = new FirstFactory (); $ firstProduct = $ factory- & gt; GetProduct ( // 첫 번째 제품 print_r ($ SecondProduct- & gt; getName ());
    cover code
  1. AbstractFactory (추상 공장 패턴) 어떤 경우에는 다른 선택 논리에 따라 다른 건설 공장을 제공해야하며, 여러 공장의 경우 통일 된 추상 공장이 필요합니다 🎜>
  2. 클래스 구성 { public static $ factory = 1;
  3. }
  4. 인터페이스 제품 {
  5. public function getName ();
  6. }
  8. 추상 클래스 AbstractFactory {
  9. public static function getFactory () {
  10. switch (config :: $ factory) { case 1 :
  11. return new FirstFactory (); case 2 : > 새로운 SecondFactory ()를 반환합니다. class firstFactory 확장 atbractFactory {
  12. public function getProduct () {
  13. return new FirstProduct (); }
  14. 클래스 FirstProduct는 제품 {
  15. public function getName () { '첫 번째 공장에서 제품을 반환합니다'; }
  17. 클래스 SecondFactory 확장 extractFactory {
  18. public function getProduct () {
  19. return new SecondProduct () ;
  20. }
  21. }
  22. 클래스 SecondProduct는 제품을 구현합니다 {
  23. public function getName () {
  24. 'Sec 🎜> $ firstProduct = actractory :: getFactory ()-& gt; getProduct ();
  25. config :: $ factory = 2;
  26. $ secondProduct = AbstractFactory :: getFactory ()-& gt; getProduct ();
  28. print_r ($ FirstProduct- & gt; getName ()); // 첫 번째 공장
  29. print_r ($ secondProduct- & gt; getName ());
  30. ////////////////////////// second 두 번째 공장에서
  32. 복사 코드
  33. 객체 풀 객체 풀은 일련의 객체를 구성하고 저장하고 필요할 때 호출을 얻는 데 사용될 수 있습니다. 보호 된 $ id;

    공개 함수 __construct ($ id) {
    $ this- & gt; id = $ id;
    }
    1. 공개 기능 getID () { return $ this- & gt; id; }
    3. 클래스 팩토리 {
    5. 보호 된 정적 $ products = array ();
    7. public static function pushproduct (Product $ product) { self :: $ products [$ product- & gt; getId ()] = $ product;
    8. public static function getProduct ($ id) { return isset (self :: $ products [$ id])? { if (array_key_exists ($ id, self :: $ products))) {
    9. unset (self :: $ products [$ id]);
    10. }
    11. }
    12. }
    13. factory :: 푸시 제품 (신제품 ( 'First'));
    14. factory :: PushProduct (신제품 ( 'second'));
    15. print_r (Factory :: getProduct (getProduct '첫 번째')-& gt; getId ());
    16. // first print_r (팩토리 :: getProduct ( 'Second')-& gt; getId ());
    17. 코드 복사
    19. 게으른 초기화 (게으른 초기화) 특정 변수의 초기화도 종종 클래스에 사용됩니다. 종종 어떤 기능이 사용될 지 알 수 없으며 일부 기능은 종종 한 번만 필요합니다.
    21. & lt;? php
    23. 인터페이스 제품 {
    24. public function getName ();
    25. }
    27. 클래스 팩토리 { 보호 된 $ firstProduct;
    28. 보호 된 $ secondProduct;
    29. public function getFirstProduct () { if (! $ this- & gt; firstProduct) { return $ this- & gt; firstProduct; public function getSecondProduct () {
    30. if (! $ this- & gt; SecondProduct) {
    31. $ this- & gt; SecondProduct = New SecondProduct (); return $ this- & gt; SecondProduct;
    32. }
    33. }
    35. 클래스 첫 번째 프로듀트 릴리즈 곱 {
    36. public function getName () {
    return 'the First Product'; } 클래스 SecondProduct Product { public function getName () { return 'Sec & gt; getName ());

    // 첫 번째 제품 print_r ($ factory- & gt; getSecondProduct ()-& gt; getName ());

    // print_r ($ factory -& gt; getFirstProduct ()-& gt; getName ()); // 첫 번째 제품
    복사 코드
    프로토 타입 (프로토 타입 모드) 때로는 일부 객체를 여러 번 초기화해야합니다. 특히 초기화에 많은 시간과 리소스가 필요한 경우 이러한 개체를 사전 시작하고 저장합니다.
    2. & lt;? php
    4. 인터페이스 제품 {
    5. }
    7. 클래스 팩토리 {
    9. 개인 $ 제품 ;
    10. public function __construct (Product $ product) { $ this- & gt; product = $ product;
    11. }
    13. public function getProduct () {
    14. 반환 클론 $ this- & gt; product;
    15. }
    16. }
    18. 클래스 일부 제품은 제품 { public $ name;
    19. }
    20. $ prototypefactory = new 공장 (새로운 someproduct ());
    21. $ FirstProduct = $ protoTypefactory- & gt; getProduct ();
    22. $ firstProduct- & gt; name = '첫 번째 제품'; $ SecondProduct = $ protoTypeFactory- & gt; getProduct ();
    23. $ secondProduct- & gt; name = 'Second Product'; intrint_r ($ firstProduct- & gt; name); // 첫 번째 제품
    24. print_r ($ SecondProduct- & gt; name);
    25. // Sec빌더(构造者)

      构造建一些复杂的对象：

      2. 클래스 제품 {
      4. 비공개 $ name;
      6. public function setName($name) {
      7. $this->name = $name;
      8. }
      10. public function getName() {
      11. return $ this->name;
      12. }
      13. }
      15. 추상 클래스 Builder {
      17. protected $product;
      19. 최종 공개 함수 getProduct() {
      20. return $this->product;
      21. }
      23. public function buildProduct() {
      24. $this->product = new Product();
      25. }
      26. }
      28. class FirstBuilder는 Builder {
      30. public function buildProduct() {
      31. parent::buildProduct();
      32. $this->product->setName('첫 번째 제품의 제품 builder');
      33. }
      34. }
      36. class SecondBuilder는 Builder {
      38. public function buildProduct() {
      39. parent::buildProduct();
      40. $this를 확장합니다. ->product->setName('두 번째 빌더의 제품');
      41. }
      42. }
      44. class Factory {
      46. private $builder;
      48. 공개 함수 __construct(Builder $builder) {
      49. $this->builder = $builder;
      50. $this->builder->buildProduct();
      51. }
      53. 공개 function getProduct() {
      54. return $this->builder->getProduct();
      55. }
      56. }
      58. $firstDirector = new Factory(new FirstBuilder());
      59. $secondDirector = new Factory(new SecondBuilder());
      61. print_r($firstDirector->getProduct()->getName());
      62. // 첫 번째 빌더의 제품
      63. print_r($secondDirector->getProduct()->getName());
      64. // 세컨드 빌더의 제품
      复代码
      구조 패턴 데코레이터(装饰器模式)

      装饰器模式允许我们根据运行时不同情景动态地为某个对象调用前后添加不同的行为动작품.

      1. class HtmlTemplate {
      2. // 모든 상위 클래스 메서드
      3. }
      5. class Template1은 HtmlTemplate {
      6. protected $_html;
      8. public function __construct() {
      9. $ this->_html = "

        __text__

        ";
      10. }
      12. 공개 함수 집합($html) {
      13. $this->_html = $html;
      14. }
      16. 공용 함수 render() {
      17. echo $this->_html;
      18. }
      19. }
      21. class Template2 확장 HtmlTemplate {
      22. protected $ _element;
      24. 공개 함수 __construct($s) {
      25. $this->_element = $s;
      26. $this->set("

        " . $this-> ;_html . "

        ");
      27. }
      29. 공개 함수 __call($name, $args) {
      30. $this->_element->$name($args [0]);
      31. }
      32. }
      34. class Template3 확장 HtmlTemplate {
      35. protected $_element;
      37. 공용 함수 __construct($s) {
      38. $this ->_element = $s;
      39. $this->set("" . $this->_html . "");
      40. }
      42. 공개 함수 __call($name, $args) {
      43. $this->_element->$name($args[0] );
      44. }
      45. }
      复代码
      어댑터(适配器模式) php

      class SimpleBook {
      private $author;
        private $title;
      2. function __construct($author_in, $title_in) {
      3. $this->author = $author_in ;
      4. $this->title = $title_in;
      5. }
      7. function getAuthor() {
      8. return $this->author;
      9. }
      11. function getTitle() {
      12. return $this->title;
      13. }
      14. }
      16. class BookAdapter {
      18. private $book;
      20. 함수 __construct(SimpleBook $book_in) {
      21. $this->book = $book_in;
      22. }
      23. function getAuthorAndTitle() {
      24. return $this->book->getTitle().' by '.$this->book->getAuthor();
      25. }
      26. }
      28. // 사용법
      29. $book = new SimpleBook("Gamma, Helm, Johnson 및 Vlissides", "디자인 패턴");
      30. $bookAdapter = new BookAdapter($book);
      31. echo '저자 및 제목: '.$bookAdapter->getAuthorAndTitle();
      33. function echo $line_in) {
      34. echo $line_in."
        ";
      35. }
      38. 复主代码
      40. 행동 패턴 전략(전략 모드)

        테스트 모드는 주로 클라이언트 클래스가 특정 구현을 알지 못해도 특정 알고리즘을 더 잘 사용할 수 있도록 하는 것입니다.

        2. interface OutputInterface {
        3. public function load();
        4. }
        6. class SerializedArrayOutput 구현 OutputInterface {
        7. 공용 함수 로드() {
        8. return serialize($arrayOfData);
        9. }
        10. }
        12. class JsonStringOutput은 OutputInterface를 구현합니다. {
        13. 공용 함수 load() {
        14. return json_encode($arrayOfData);
        15. }
        16. }
        18. class ArrayOutput은 OutputInterface를 구현합니다. {
        19. public function load() {
        20. return $arrayOfData;
        21. }
        22. }
        코드 복사
        관찰자(관찰자 모드)

        다른 객체가 어떤 방식으로든 관찰자로 등록되도록 허용하여 객체를 관찰 가능하게 만들 수 있습니다. 관찰된 객체가 변경될 때마다 관찰자에게 메시지가 전송됩니다.

        2. 인터페이스 관찰자 {
        3. 함수 onChanged($sender, $args);
        4. }
        6. interface Observable {
        7. function addObserver($observer);
        8. }
        10. class CustomerList는 Observable을 구현합니다. {
        11. private $_observers = array();
        13. public function addCustomer( $name) {
        14. foreach($this->_observers as $obs)
        15. $obs->onChanged($this, $name);
        16. }
        18. 공개 함수 addObserver( $observer) {
        19. $this->_observers []= $observer;
        20. }
        21. }
        23. class CustomerListLogger는 Observer를 구현합니다. {
        24. 공개 함수 onChanged($sender, $args ) {
        25. echo( "'$args' 고객이 목록 n에 추가되었습니다." );
        26. }
        27. }
        29. $ul = new UserList();
        30. $ul ->addObserver( new CustomerListLogger() );
        31. $ul->addCustomer( "Jack" );
        코드 복사
        책임 사슬(책임 사슬) 모델 )

        이 모드에는 제어 체인 모드라는 또 다른 이름이 있습니다. 이는 주로 특정 명령에 대한 일련의 프로세서로 구성됩니다. 각 쿼리는 프로세서에 의해 형성된 책임 체인에 전달됩니다. 각 교차점에서 프로세서는 해당 쿼리에 응답하고 처리해야 하는지 여부를 결정합니다. 프로세서가 요청을 처리할 수 있는 동안 각 핸들러는 일시 중지됩니다.

        2. 인터페이스 명령 {
        3. function onCommand($name, $args);
        4. }
        6. class CommandChain {
        7. private $_commands = array();
        9. public function addCommand($cmd) {
        10. $this->_commands[]= $cmd;
        11. }
        13. 공용 함수 runCommand($name, $args) {
        14. foreach($this->_commands as $cmd) {
        15. if ($cmd->onCommand($name, $args))
        16. return;
        17. }
        18. }
        19. }
        21. class CustCommand는 Command {
        22. public function onCommand($name, $args) {
        23. if ($name ! = 'addCustomer')
        24. return false;
        25. echo("'addCustomer'n을 처리하는 CustomerCommand입니다.");
        26. return true;
        27. }
        28. }
        30. class MailCommand Implements Command {
        31. public function onCommand($name, $args) {
        32. if ($name != 'mail')
        33. return false;
        34. echo("이것은 'mail'n을 처리하는 MailCommand입니다. ");
        35. 반환 true;
        36. }
        37. }
        39. $cc = new CommandChain();
        40. $cc->addCommand( new CustCommand());
        41. $cc->addCommand( new MailCommand());
        42. $cc->runCommand('addCustomer', null);
        43. $cc->runCommand('mail', null);
        코드 복사
PHP


성명：
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
이전 기사：PHP 프로그래밍 효율성을 향상시키는 20가지 요소다음 기사：PHP 프로그래밍 효율성을 향상시키는 20가지 요소

관련 기사

더보기