Quels sont les modèles de conception dans PHP7.0 ?

Avec le développement continu de la technologie, les modèles de conception deviennent de plus en plus importants dans le développement de logiciels. En tant que dernière version de PHP, PHP7.0 intègre également de nombreux modèles de conception. Dans cet article, nous explorerons les modèles de conception de PHP7.0 pour aider les programmeurs PHP à mieux comprendre et appliquer ces modèles.

1. Modèle Singleton

Le modèle singleton est un modèle de création qui garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global. En PHP7.0, vous pouvez utiliser la méthode __construct et la méthode statique pour implémenter ce modèle. Voici un exemple :

class Singleton
{
    private static $instance = null;
    
    private function __construct() {}
    
    public static function getInstance()
    {
        if (null === static::$instance) {
            static::$instance = new static();
        }
        
        return static::$instance;
    }
}

Dans le code ci-dessus, la méthode getInstance() renverra la seule instance de la classe Singleton.

2. Factory pattern

Factory pattern est un autre modèle de création qui fournit une interface pour la création d'objets, mais expose uniquement la logique d'instanciation d'objet. En PHP7.0, vous pouvez utiliser des interfaces et des classes abstraites pour implémenter ce modèle. Voici un exemple :

interface ShapeInterface
{
    public function draw();
}

class Rectangle implements ShapeInterface
{
    public function draw()
    {
        // 画一个矩形
    }
}

class Square implements ShapeInterface
{
    public function draw()
    {
        // 画一个正方形
    }
}

abstract class ShapeFactory
{
    public static function create($type)
    {
        switch ($type) {
            case 'rectangle':
                return new Rectangle();
            case 'square':
                return new Square();
            default:
                throw new Exception('Invalid shape type');
        }
    }
}

Dans le code ci-dessus, la classe ShapeFactory est une classe d'usine abstraite, et sa méthode create() crée un objet basé sur la catégorie donnée et lève une exception.

3. Modèle Observateur

Le modèle Observateur est un modèle comportemental qui permet à un objet (sujet) de notifier d'autres objets (observateurs) Son statut a modifié. En PHP7.0, vous pouvez utiliser les interfaces SplObserver et SplSubject pour implémenter ce modèle. Voici un exemple :

class User implements SplSubject
{
    private $name;
    private $observers;

    public function __construct($name)
    {
        $this->name = $name;
        $this->observers = new SplObjectStorage();
    }

    public function attach(SplObserver $observer)
    {
        $this->observers->attach($observer);
    }

    public function detach(SplObserver $observer)
    {
        $this->observers->detach($observer);
    }

    public function notify()
    {
        foreach ($this->observers as $observer) {
            $observer->update($this);
        }
    }

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

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

class Logger implements SplObserver
{
    public function update(SplSubject $subject)
    {
        echo 'User "' . $subject->getName() . '" has been updated.' . PHP_EOL;
    }
}

Dans le code ci-dessus, la classe User est un sujet et implémente l'interface SplSubject. La classe Logger est un observateur et implémente l'interface SplObserver.

4. Adapter Pattern

Le modèle Adapter est un modèle structurel qui permet aux classes existantes de fonctionner avec d'autres classes, bien que ces classes aient des interfaces différentes. En PHP7.0, vous pouvez utiliser des interfaces et des classes abstraites pour implémenter ce modèle. Voici un exemple :

interface DatabaseInterface
{
    public function connect($host, $username, $password, $database);
    public function query($sql);
}

class MysqlDatabase implements DatabaseInterface
{
    protected $connection;

    public function connect($host, $username, $password, $database)
    {
        $this->connection = mysqli_connect($host, $username, $password, $database);
    }

    public function query($sql)
    {
        return mysqli_query($this->connection, $sql);
    }
}

interface DatabaseAdapterInterface
{
    public function query($sql);
}

class MysqlAdapter implements DatabaseAdapterInterface
{
    protected $mysql;

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

    public function query($sql)
    {
        return $this->mysql->query($sql);
    }
}

Dans le code ci-dessus, DatabaseAdapterInterface est l'interface de l'adaptateur et MysqlAdapter est la classe de l'adaptateur.

Résumé

Dans cet article, nous avons discuté de quatre modèles de conception en PHP7.0 : le modèle singleton, le modèle d'usine, le modèle d'observateur et le modèle d'adaptateur. Ces modèles sont très utiles dans la programmation PHP et peuvent aider les programmeurs à mieux concevoir et organiser leur code. Si vous n'avez pas encore appris ces modèles, il est maintenant temps de commencer.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!