Anwendungsfallanalyse des PHP-Single-Responsibility-Prinzips (SRP).

Dieses Mal werde ich Ihnen eine Fallanalyse des PHP-Single-Responsibility-Prinzips (SRP) vorstellen. Was sind die Vorsichtsmaßnahmen für die Verwendung des PHP-Single-Responsibility-Prinzips (SRP)?

Prinzip der Einzelverantwortung (SRP)

Einzelverantwortung hat zwei Bedeutungen: Die eine besteht darin, zu vermeiden, dass die gleichen Verantwortlichkeiten auf verschiedene Klassen verteilt werden. die andere besteht darin, zu vermeiden, dass eine Klasse zu viele Verantwortlichkeiten übernimmt

Warum sollten wir SRP einhalten?

(1) Es kann die Kopplung zwischen Klassen verringern

Wenn Sie die Kopplung zwischen Klassen reduzieren, wird bei Änderung der Anforderungen nur eine Klasse geändert, wodurch die Änderung isoliert wird. Wenn eine Klasse mehrere unterschiedliche Verantwortlichkeiten hat, sind diese miteinander gekoppelt, und wenn sich eine Verantwortlichkeit ändert, kann es zu Konflikten mit anderen kommen Verantwortlichkeiten.

(2) Verbessern Sie die Wiederverwendbarkeit von Klassen

Das Modifizieren eines Computers ist viel einfacher als das Reparieren eines Fernsehers. Der Hauptgrund ist, dass die Kopplung zwischen den verschiedenen Komponenten des Fernsehgeräts zu hoch ist, aber der Speicher, die Festplatte, die Soundkarte, die Netzwerkkarte, die Tastaturbeleuchtung und andere Komponenten des Computers können leicht zerlegt und zusammengebaut werden separat. Wenn ein Teil kaputt ist, ersetzen Sie es einfach durch ein neues. Das obige Beispiel zeigt die Vorteile der Einzelverantwortung. Aufgrund der Einzelverantwortung können „Komponenten“ einfach „zerlegt“ und „zusammengebaut“ werden.

Die Nichteinhaltung von SRP wirkt sich auf die Wiederverwendbarkeit von Klassen aus. Wenn Sie nur eine bestimmte Verantwortung der Klasse verwenden müssen, ist es schwierig, diese zu trennen, da sie mit anderen Verantwortlichkeiten gekoppelt ist.

Hat die Einhaltung von SRP irgendeine Anwendung in der tatsächlichen Codeentwicklung? manche. Am Beispiel der Datenpersistenzschicht bezieht sich die sogenannte Datenpersistenzschicht hauptsächlich auf Datenbankoperationen und natürlich auf die Cache-Verwaltung usw. Zu diesem Zeitpunkt muss die Datenpersistenzschicht mehrere Datenbanken unterstützen. Was ist zu tun? Mehrere Datenbankoperationsklassen definieren? Die Idee ist schon sehr nah und der nächste Schritt besteht darin, das Fabrikmuster zu verwenden.

Factory-Muster (Faction) ermöglicht es Ihnen, Objekte zu instanziieren, wenn der Code ausgeführt wird. Es wird Factory Pattern genannt, weil es für die „Produktion von Objekten“ verantwortlich ist. Am Beispiel der Datenbank muss die Fabrik verschiedene instanziierte Objekte basierend auf unterschiedlichen Parametern generieren. Die einfachste Factory besteht darin, ein Objekt basierend auf dem übergebenen Typnamen zu instanziieren. Wenn es an MySQL übergeben wird, ruft es die MySQL-Klasse auf und instanziiert es. Wenn es sich um SQLite handelt, ruft es die SQLite-Klasse auf und instanziiert es sogar Behandeln Sie TXT, Execl usw. 'Klassendatenbank'.

Die Factory-Klasse ist eine solche Klasse. Sie ist nur für die Produktion von Objekten verantwortlich, nicht jedoch für den spezifischen Inhalt der Objekte.

Das Folgende ist ein Beispiel

Definieren Sie eine Adapterschnittstelle

interface Db_Adpater
{
  /**
   * 数据库连接
   * @param $config 数据库配置
   * @return mixed resource
   */
  public function connect($config);
  /**
   * 执行数据库查询
   * @param $query 数据库查询的SQL字符串
   * @param $handle 连接对象
   * @return mixed
   */
  public function query($query,$handle);
}

Definieren Sie eine MySQL-Datenbankoperation-Klasse, die den DB_Adpater implementiert Schnittstelle

class Db_Adapter_Mysql implements Db_Adpater
{
  private $_dbLink;  //数据库连接字符串标识
  /**
   * 数据库连接函数
   * @param $config 数据库配置
   * @return resource
   * @throws Db_Exception
   */
  public function connect($config)
  {
    if($this->_dbLink = @mysql_connect($config->host . (empty($config->port) ? '' : ':' . $config->prot) ,$config->user, $config->password, true))
    {
      if(@mysql_select_db($config->database, $this->_dbLink))
      {
        if($config->charset)
        {
          mysql_query("SET NAME '{$config->charset}'", $this->_dbLink);
        }
        return $this->_dbLink;
      }
    }
    throw new Db_Exception(@mysql_error($this->_dbLink));
  }
  /**
   * 执行数据库查询
   * @param $query 数据库查询SQL字符串
   * @param $handle 连接对象
   * @return resource
   */
  public function query($query,$handle)
  {
    if($resource = @mysql_query($query,$handle))
      return $resource;
  }
}

Definieren Sie eine SQLite-Datenbankbetriebsklasse, die die DB_Adpater-Schnittstelle implementiert

class Db_Adapter_sqlite implements Db_Adpater
{
  private $_dbLink;  //数据库连接字符串标识
  public function connect($config)
  {
    if($this->_dbLink = sqlite_open($config->file, 0666, $error))
    {
      return $this->_dbLink;
    }
    throw new Db_Exception($error);
  }
  public function query($query, $handle)
  {
    if($resource = @sqlite_query($query,$handle))
    {
      return $resource;
    }
  }
}

Wenn Sie nun eine Datenbankbetriebsmethode benötigen, müssen Sie nur eine Factory-Klasse definieren und verschiedene Generierungsanforderungen übergeben Wenn Sie

class sqlFactory
{
  public static function factory($type)
  {
    if(include_once 'Drivers/' . $type . '.php')
    {
      $classname = 'Db_Adapter_'.$type;
      return new $classname;
    }
    else
      throw new Exception('Driver not found');
  }
}

aufrufen, können Sie

$db = sqlFactory::factory('MySQL');
$db = sqlFactory::factory('SQLite');

schreiben. Wir trennen das Verbindungsprogramm Datenbank erstellen separat, und Sie müssen sich keine Sorgen um den CURD im Programm machen. Egal Um welche Datenbank es sich handelt, verwenden Sie einfach die entsprechende Methode gemäß den Spezifikationen.

Factory-Methoden geben konkrete Objekte frei, sodass sie nicht mehr von konkreten Klassen, sondern von der Abstraktion abhängen. Das Befehlsmuster im

-Entwurfsmuster ist auch die Verkörperung von SRP. Das Befehlsmuster trennt die Verantwortlichkeiten von „Befehlsanforderer “ und „Befehlsumsetzer “. Um ein gut verständliches Beispiel zu nennen: Wenn Sie in ein Restaurant gehen, um eine Mahlzeit zu bestellen, hat das Restaurant drei Rollen: Kunde, Kellner und Koch. Als Kunde muss man das Menü auflisten und an den Kellner weiterreichen, der dann den Koch mit der Umsetzung beauftragt. Als Kellner müssen Sie nur die Art und Weise der Zubereitung von Mahlzeiten nennen (dem Koch „Es ist Zeit zum Braten“) sagen. Wenn der Koch die Aufforderung zum Braten hört, wird er sofort kochen. Dabei sind Anforderung und Umsetzung des Befehls vollständig entkoppelt.

Um diesen Prozess zu simulieren, definieren Sie zunächst die Rolle des Kochs. Der Koch übernimmt dann tatsächlich die Arbeit des Kochens und Zubereitens der Suppe.

Das Folgende ist ein Beispiel

/**
 * 厨师类，命令接受者与执行者
 * Class cook
 */
class cook
{
  public function meal()
  {
    echo '番茄炒鸡蛋',PHP_EOL;
  }
  public function drink()
  {
    echo '紫菜蛋花汤',PHP_EOL;
  }
  public function ok()
  {
    echo '完毕',PHP_EOL;
  }
}
//然后是命令接口
interface Command
{
  public function execute();
}

Der Kellner ist der Übermittler der Bestellungen. Normalerweise kann man den Kellner nicht anrufen Rufen Sie direkt den Koch an. Normalerweise rufen Sie den Kellner an und bringen mir einen Teller mit gebratenen Tomaten. Daher ist der Kellner der Übermittler der Bestellungen zwischen dem Kunden und dem Koch.

class MealCommand implements Command
{
  private $cook;
  //绑定命令接受者
  public function construct(cook $cook)
  {
    $this->cook = $cook;
  }
  public function execute()
  {
    $this->cook->meal();//把消息传给厨师，让厨师做饭，下同
  }
}
class DrinkCommand implements Command
{
  private $cook;
  //绑定命令接受者
  public function construct(cook $cook)
  {
    $this->cook = $cook;
  }
  public function execute()
  {
    $this->cook->drink();
  }
}

Kunden können jetzt den Kellner entsprechend der Speisekarte anrufen

class cookControl
{
  private $mealcommand;
  private $drinkcommand;
  //将命令发送者绑定以命令接收器上面来
  public function addCommand(Command $mealcommand, Command $drinkcommand)
  {
    $this->mealcommand = $mealcommand;
    $this->drinkcommand = $drinkcommand;
  }
  public function callmeal()
  {
    $this->mealcommand->execute();
  }
  public function calldrink()
  {
    $this->drinkcommand->execute();
  }
}

好了，现在完成整个过程

$control = new cookControl;
$cook = new cook;
$mealcommand = new MealCommand($cook);
$drinkcommand = new DrinkCommand($cook);
$control->addCommand($mealcommand,$drinkcommand);
$control->callmeal();
$control->calldrink();

从上面的例子可以看出，原来设计模式并非纯理论的东西，而是来源于实际生活，就连普通的餐馆老板都懂设计模式这门看似高深的学问。其实，在经济和管理活动中对流程的优化就是对各种设计模式的摸索和实践。所以，设计模式并非计算机编程中的专利。事实上，设计模式的起源并不是计算机，而是源于建筑学。

在设计模式方面，不仅以上这两种体现了SRP，还有别的（比如代理模式）也体现了SRP。SRP不只是对类设计有意义，对以模块、子系统为单位的系统架构设计同样有意义。

模块、子系统也应该仅有一个引起它变化的原因，如MVC所倡导的各个层之间的相互分离就是SRP在系统总体设计中的应用。

SRP是最简单的原则之一，也是最难做好的原则之一。我们会很自然地将职责连接在一起。找到并且分离这些职责是软件设计需要达到的目的

一些简单的应用遵循的做法如下：

根据业务流程，把业务对象提炼出来。如果业务的流程的链路太复杂，就把这个业务对象分离为多个单一业务对象。当业务链标准化后，对业务对象的内部情况做进一步处理，把第一次标准化视为最高层抽象，第二次视为次高层抽象，以此类推，直到“恰如其分”的设计层次

职责的分类需要注意。有业务职责，还要有脱离业务的抽象职责，从认识业务到抽象算法是一个层层递进的过程。就好比命令模式中的顾客，服务员和厨师的职责，作为老板（即设计师）的你需要规划好各自的职责范围，即要防止越俎代庖，也要防止互相推诿。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

PHP里氏替换案例详解

Bootstrap+PHP实现多图上传步骤详解

Das obige ist der detaillierte Inhalt vonAnwendungsfallanalyse des PHP-Single-Responsibility-Prinzips (SRP).. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!