PHP 実践デザインパターン: PHP のデザインパターン

この記事は翻訳記事です

元のアドレス: Design Patterns in PHP
PHP を学習する予定がある場合は、プログラミング言語学習知識システムの著者の重要なポイントのリストを参照してください

この記事では主に、Web 開発、正確には PHP 開発における関連するデザイン パターンとそのアプリケーションについて説明します。経験豊富な開発者は確かにデザイン パターンに精通していますが、この記事は主に若手開発者を対象としています。まず、デザイン パターンとは何かを理解する必要があります。デザイン パターンは、リンク リストのような一般的なデータ構造でも、特別なアプリケーションやフレームワークのデザインでもありません。実際、デザインパターンは次のように説明されます:

特定のコンテキストにおける一般的な設計上の問題を解決するためにカスタマイズされた通信オブジェクトとクラスの説明。

その一方で、デザイン パターンは、日常のプログラミングでよく遭遇する問題を解決するための、広く再利用可能な方法を提供します。デザイン パターンは必ずしもクラス ライブラリやサードパーティのフレームワークである必要はなく、アイデアのようなものであり、システムで広く使用されています。これらは、さまざまなシナリオで問題を解決するために使用できるパターンまたはテンプレートとしても表示されます。デザイン パターンを使用すると、開発をスピードアップし、多くの大きなアイデアやデザインを簡単な方法で実装できます。もちろん、デザイン パターンは開発において非常に役立ちますが、不適切なシナリオでの誤用は避けなければなりません。

現在 23 の一般的なデザイン パターンがあり、さまざまな使用目的に応じて次の 3 つのカテゴリに分類できます。

作成パターン: オブジェクトをその実装から分離するためにオブジェクトを作成するために使用されます。

アーキテクチャパターン: 異なるオブジェクト間に大きなオブジェクト構造を構築するために使用されます。

行動モデル: 異なるオブジェクト間のアルゴリズム、関係、責任を管理するために使用されます。

創造的なパターン シングルトン (シングルケースモード) シングルトン パターンは、Web アプリケーションの開発において、実行時に特定のクラスのアクセス可能なインスタンスを作成できるようにするためによく使用されるパターンの 1 つです。

/**

* シングルトンクラス

*/

final class Product

{

/**

* @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 = Product::getInstance();

$secondProduct = Product::getInstance();

$firstProduct->mix = 'test';

$secondProduct->mix = 'example';

print_r($firstProduct->mix);

// example

print_r($secondProduct->mix);

// example

コードをコピー

多くの場合、共通の抽象化を確立できるように、システム内の複数のクラスに対してシングルトン構築メソッドを作成する必要があります。親ファクトリ メソッド:

abstract class FactoryAbstract {

protected static $instances = array();

public static function getInstance() {

$className = static::getClassName();

if (!(self::$instances[$className] instanceof $className)) {

self::$instances[$className] = new $className();

}

return self::$instances[$className] ;

}

public static function RemoveInstance() {

$className = static::getClassName();

if (array_key_exists($className, self::$instances)) {

unset(self::$instances[$className]) ]);

}

}

最終保護された静的関数 getClassName() {

return get_called_class();

}

保護関数 __construct() { }

最終保護関数 __clone() { }

}

抽象クラスFactory extends FactoryAbstract {

final public static function getInstance() {

returnparent::getInstance();

}

final public static function RemoveInstance() {

parent::removeInstance();

}

}

// using:

class FirstProduct extends Factory {

public $a = [];

}

class SecondProduct extends 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)

コードをコピー

レジストリ

登録デスク モードはあまり一般的ではなく、静的メソッドを使用してデータに簡単にアクセスするためのものです。

/**
* レジストリ クラス
*/
class Package {

 protected static $data = array();

 public static function set($key, $value) {
 self: :$data[$key] = $value;
 }

 public static function get($key) {
 return isset(self::$data[$key]) : null ;
 }

 最終的なパブリック静的関数 RemoveObject($key) {
 if (array_key_exists($key, self::$data)) {
 unset(self::$data[$key]);
 }
 }
 }


Package::set('name', 'パッケージ名');

print_r(Package::get('name'));
//パッケージ名

Factory(ファクトリーモード) ）

ファクトリ パターンも非常によく使用されるパターンで、その名前が示すように、実際にはオブジェクト インスタンスの生産ファクトリです。ある意味、ファクトリ パターンは、オブジェクトの特定の内部実装を気にせずにオブジェクトを取得するのに役立つ一般的なメソッドを提供します。

interface Factory {
 public function getProduct();
}

interface Product {
 public function getName();
}

class FirstFactoryimplements Factory {

 public function getProduct( ) {
 return new FirstProduct();
 }
}

class SecondFactory 実装 Factory {

 public function getProduct() {
 return new SecondProduct();
 }
}

class FirstProductimplements Product {

 public function getName() {
 return '最初の製品';
 }
}

class SecondProductimplements Product {

 public function getName() {
 return '2 番目の製品';
 }
}

$factory = new FirstFactory( );
$firstProduct = $factory->getProduct();
$factory = new SecondFactory();
$secondProduct = $factory->getProduct();

print_r($firstProduct->getName()) ;
// 最初の製品
print_r($secondProduct->getName());
// 2 番目の製品

AbstractFactory (抽象ファクトリーパターン)

場合によっては、異なる選択ロジックに基づいて異なる構築ファクトリを提供する必要があり、複数のファクトリの場合は、統合された抽象ファクトリが必要です。

}

オブジェクトプール
オブジェクト プールを使用して、一連のオブジェクトを構築して保存し、必要に応じて呼び出しを取得できます: 

class Product {

 protected $id;

 public function __construct($id) {
 $this->id = $id;
 }

 public function getId() {
 return $this->id;
 }
}

class Factory {

 protected static $products = array() ;

 public static function PushProduct(Product $product) {
 self::$products[$product->getId()] = $product;
 }

 public static function getProduct($id) {
 return isset( self ::$products[$id]) ? self::$products[$id] : null;
 }

 public static function RemoveProduct($id) {
 if (array_key_exists($id, self::$products) ) {
 unset(self::$products[$id]);
 }
 }
}


Factory::pushProduct(new Product('first'));
Factory::pushProduct(new Product('first') ' ));

print_r(Factory::getProduct('first')->getId());
// first
print_r(Factory::getProduct('first')->getId());
 / /secondLazy Initialization (遅延初期化)
特定の変数の遅延初期化もよく使用されます。クラスでは、どの関数が使用されるかが不明であることが多く、一部の関数は 1 回だけ必要になることがよくあります。 

interface Product {
 public function getName();
}

class Factory {

 protected $firstProduct;
 protected $secondProduct;

 public function getFirstProduct() {
 if ( !$this->firstProduct) {
 $this->firstProduct = new FirstProduct();
 }
 return $this->firstProduct;
 }

 public function getSecondProduct() {
 if (!$this- >secondProduct) {
 $this->secondProduct = new SecondProduct();
 }
 return $this->secondProduct;
 }
}

class FirstProductimplements Product {
 public function getName() {
 return '最初の製品';
 }
}

クラス SecondProduct は Product {
 public function getName() {
 return '2 番目の製品';
 }
}


$factory = new Factory();

print_r($ Factory->getFirstProduct()->getName());
// 最初の製品
print_r($factory->getSecondProduct()->getName());
// 2 番目の製品
print_r($factory ->getFirstProduct()->getName());
// 最初の製品Prototype (プロトタイプ モード)
場合によっては、一部のオブジェクトを複数回初期化する必要があります。特に初期化に多くの時間とリソースが必要な場合は、これらのオブジェクトを事前に初期化して保存してください。 

interface Product {
}

class Factory {

 private $product;

 public function __construct(Product $product) {
 $this->product = $product;
 }

 public function getProduct() {
 return clone $this->product;
 }
}

class SomeProduct は Product を実装します {
 public $name;
}


$prototypeFactory = new Factory(new SomeProduct() );

$firstProduct = $prototypeFactory->getProduct();
$firstProduct->name = '最初の製品';

$secondProduct = $prototypeFactory->getProduct();
$secondProduct-> name = '2 番目の製品';

print_r($firstProduct->name);
// 最初の製品
print_r($nextProduct->name);
// 2 番目の製品ビルダー(造造者)
造者モード主にいくつかのオブジェクトを作成するオブジェクト:

class Product {

 private $name;

 public function setName($name) {
 $this->name = $name;
 }

 public function getName() {
 return $this->name;
 }
}

抽象クラス Builder {

 protected $product;

 Final public function getProduct() {
 return $ this->product;
 }

 public function buildProduct() {
 $this->product = new Product();
 }
}

class FirstBuilder extends Builder {

 public function buildProduct() {
parent ::buildProduct();
 $this->product->setName('最初のビルダーの製品');
 }
}

class SecondBuilder extends Builder {

 public function buildProduct() {
parent: :buildProduct();
 $this->product->setName('2 番目のビルダーの製品');
 }
}

class Factory {

 private $builder;

 public function __construct(Builder $builder ) {
 $this->builder = $builder;
 $this->builder->buildProduct();
 }

 public function getProduct() {
 return $this->builder->getProduct( );
 }
}

$firstDirector = new Factory(new FirstBuilder());
$secondDirector = new Factory(new SecondBuilder());

print_r($firstDirector->getProduct()->getName( ));
// 最初のビルダーの産物
print_r($secondDirector->getProduct()->getName());
// 2 番目のビルダーの産物 構造パターン
Decorator(装饰器模式)
プラグインモードでは、実行時のさまざまな状況に応じて、特定のオブジェクトに対して前後に異なる実行動作を追加することが許可されています。  class Template1 extends HtmlTemplate { $this->gt;_html = "__text__";
 }

 public function set($html) {
 $this->gt;_html = $html;
 }

 public function render() {
 echo $this->gt;_html;
 }
}

class Template2 extends HtmlTemplate {
 protected $_element;

 public function __construct($s) {
 $this->_element = $s;
 $this->set("" . $this->_html . "");
 }

 public function __call($name, $args) {
 $this->element->$name($args[0]);
 }
}

class Template3 extends HtmlTemplate {
 protected $_element;

 public function __construct($s) {
 $this->_element = $s;
 $this->set("" . $this->_html . "") ;
 }

 public function __call($name, $args) {
 $this->_element->$name($args[0]);
 }
}


复制代码

Adapter(适器モード)
このモードでは、異なるインターフェイスを使用して特定の種類を構築することができ、異なるインターフェイスを使用して実行することができます:


 private $author; private $title;  $this->title = $title_in;
 }

 function getAuthor() {
 return $this-> author;
 }

 function getTitle() {
 return $this->title;
 }
}

class BookAdapter {

 private $book;

 function __construct(SimpleBook $book_in) {
 $this-> ;book = $book_in;
 }
 function getAuthorAndTitle() {
 return $this->book->getTitle().' by '.$this->book->getAuthor();
 }
}

// 使い方
$book = new SimpleBook("Gamma、Helm、Johnson、Vlissides", "Design Patterns");
 $bookAdapter = new BookAdapter($book);
echo '著者とタイトル: '.$bookAdapter->getAuthorAndTitle();

function echo $line_in) {
 echo $line_in."";
}


复制代

行動パターン
ストラテジー(ストラテジーモード)
テスト モードは主に、クライアント クラスが特定の実装を知らなくても特定のアルゴリズムをより適切に使用できるようにすることを目的としています。 

interface OutputInterface {
 public functionload();
}

class SerializedArrayOutputimplements OutputInterface {
 public function load() {
 return Serialize($arrayOfData);
 }
}

クラス JsonStringOutput は OutputInterface {
 パブリック関数load() {
 return json_encode($arrayOfData);
 }
}

クラス ArrayOutput 実装 OutputInterface {
 パブリック関数load() {
 return $arrayOfData;
 }
}オブザーバー (オブザーバーモード)
他のオブジェクトが何らかの方法でオブザーバーとして登録できるようにすることで、オブジェクトを監視可能にすることができます。観察されるオブジェクトが変化するたびに、メッセージが観察者に送信されます。 
interface Observer {
 function onChanged($sender, $args);
}

interface Observable {
 function addObserver($observer);
}

class CustomerListimplements Observable {
 private $_observers = array();

 public function addCustomer($name) {
 foreach($this->_observers as $obs)
 $obs->onChanged($this, $name);
 }

 public function addObserver($observer) {
 $this->_observers []= $observer;
 }
}

class CustomerListLogger は Observer を実装します {
 public function onChanged($sender, $args) {
 echo( "'$ args の顧客がリストに追加されました n" );
 }
}

$ul = new UserList();
$ul->addObserver( new CustomerListLogger() );
$ul->addCustomer( " Jack" );責任の連鎖 (責任の連鎖モデル)
このモードには別名、コントロールチェーンモードがあります。これは主に、特定のコマンドに対する一連のプロセッサで構成され、各クエリはプロセッサによって形成された一連の責任の中で渡され、プロセッサは応答して処理する必要があるかどうかを判断します。プロセッサがリクエストを処理できる間、各ハンドラは一時停止されます。 

interface Command {
 function onCommand($name, $args);
}

class CommandChain {
 private $_commands = array();

 public function addCommand($cmd) {
 $this->_commands[]= $cmd;
 }

 public function runCommand($name, $args) {
 foreach($this->_commands as $cmd) {
 if ($cmd-> ;onCommand($name, $args))
 return;
 }
 }
}

class CustCommand は Command を実装します {
 public function onCommand($name, $args) {
 if ($name != 'addCustomer')
 return false;
 echo("これは 'addCustomer'n を処理する CustomerCommand です");
 return true;
 }
}

class MailCommand は Command {
 public function onCommand($name, $args) {
 if ($name) を実装します!= 'mail')
 return false;
 echo("これは 'mail'n を処理する MailCommand です");
 return true;
 }
}

$cc = new CommandChain();
$cc->addCommand ( new CustCommand());
$cc->addCommand( new MailCommand());
$cc->runCommand('addCustomer', null);
$cc->runCommand('mail', null) ;

PHP