PHP 디자인 패턴(창의적)

서문

프로그래밍 프로젝트 경험이 늘어나면서 비즈니스 로직 제공부터 프로젝트의 전반적인 디자인까지. 개발 과정에서 디자인 패턴의 중요성을 인식하고 S.O.L.I.D의 5가지 벤치마크 원칙을 따릅니다. 시야가 넓어지고, 코드가 더욱 유연해지고, 더욱 아름다워졌습니다. 아름다움은 모든 것을 만드는 철학입니다.

우리가 배우는 디자인 패턴은 크리에이터 패턴, 구조 패턴 패턴의 세 가지 범주로 나뉩니다. , 행동 패턴은 객체 생성과 관련이 있습니다. 구조적 패턴은 클래스나 객체의 조합을 다루고, 행동 패턴은 클래스나 객체가 상호 작용하는 방식과 책임을 할당하는 방법을 설명합니다. 이 기사에서는 PHP 디자인 패턴의 생성을 소개합니다. 포함: 싱글톤 모드, 멀티톤 모드, 팩토리 메소드 모드, 추상 팩토리 모드, 단순 팩토리 모드, 프로토타입 모드, 객체 풀 모드(풀), 빌더 패턴(빌더)

권장: "

PHP 튜토리얼

"

(1) 싱글톤 패턴( 싱글톤)

● 정의

클래스에는 인스턴스가 하나만 있고 이에 액세스할 수 있는 전역 액세스 지점을 제공합니다. 시스템 메모리에는 이 클래스의 개체가 하나만 있으므로 시스템 리소스가 절약됩니다. 자주 생성되고 삭제되어야 하는 일부 개체의 경우 싱글톤 모드를 사용하면 시스템 성능이 향상될 수 있습니다.

● 코드 예시

class Singleton
{
    /**
    * @var Singleton
    */
    private static $instance;
    /**
    * 不允许从外部调用以防止创建多个实例
    * 要使用单例，必须通过 Singleton::getInstance() 方法获取实例
    */
    private function __construct()
    {
    }
    /**
    * 通过懒加载获得实例（在第一次使用的时候创建）
    */
    public static function getInstance(): Singleton
    {
        if (null === static::$instance) {
            static::$instance = new static();
        }
        return static::$instance;
    }
    /**
    * 防止实例被克隆（这会创建实例的副本）
    */
    private function __clone()
    {
    }
    /**
    * 防止反序列化（这将创建它的副本）
    */
    private function __wakeup()
    {
    }
}

(2) 다중 인스턴스 모드(Multiton)

● 정의#🎜🎜 #

멀티 인스턴스 패턴에서 멀티 인스턴스 클래스는 여러 인스턴스를 가질 수 있으며, 멀티 인스턴스 클래스는 자체 인스턴스를 생성 및 관리하고 자체 인스턴스를 외부 세계에 제공해야 합니다. 1. 인스턴스 컨테이너를 통해 컨테이너를 저장합니다. 2. 외부 공사를 방지하기 위해 민간 공사를 이용하십시오. 3. 인스턴스를 얻기 위해 getInstantce() 메서드를 제공합니다.

● 코드 예시 두 객체가 하나의 클래스를 통해 여러 번 인스턴스화됩니다.

abstract class Multiton { 
    private static $instances = array(); 
    public static function getInstance() { 
        $key = get_called_class() . serialize(func_get_args());
        if (!isset(self::$instances[$key])) { 
            $rc = new ReflectionClass(get_called_class());
            self::$instances[$key] = $rc->newInstanceArgs(func_get_args());
        }
        return self::$instances[$key]; 
    }
    /**
     * 该私有对象阻止实例被克隆
     */
    private function __clone()
    {
    }
    /**
     * 该私有方法阻止实例被序列化
     */
    private function __wakeup()
    {
    }
} 
class Hello extends Multiton { 
    public function __construct($string = 'World') { 
        echo "Hello $string\n"; 
    } 
} 
class GoodBye extends Multiton { 
    public function __construct($string = 'my', $string2 = 'darling') { 
        echo "Goodbye $string $string2\n"; 
    }
}
$a = Hello::getInstance('World'); 
$b = Hello::getInstance('bob'); 
// $a !== $b 
$c = Hello::getInstance('World'); 
// $a === $c 
$d = GoodBye::getInstance(); 
$e = GoodBye::getInstance();
// $d === $e 
$f = GoodBye::getInstance('your'); 
// $d !== $f

(3) 팩토리 method 패턴(팩토리 메소드)

● 정의

클래스 인스턴스화(특정 제품 생성)를 팩토리 클래스(특정 팩토리)의 하위 클래스로 지연합니다. ) 완료됨, 즉 어떤 클래스를 인스턴스화(생성)해야 하는지 결정하는 것은 하위 클래스에 달려 있습니다.

● 코드 예: Xiaocheng에는 플라스틱 가공 공장이 있습니다(고객으로서 클래스 A 제품만 생산). 변화가 필요하면 고객은 클래스 B 제품을 생산해야 합니다. 원래 플라스틱 가공 공장의 구성과 변경을 변경하는 것은 매우 어렵습니다. 고객이 다음 번에 변경을 요구한다고 가정하면 Xiaocheng은 클래스 B 제품을 생산하기 위해 플라스틱 지점 공장 B를 구입하기로 결정했습니다.

abstract class Product{
    public abstract function Show();
}
//具体产品A类
class  ProductA extends  Product{
    public function Show() {
        echo "生产出了产品A";
    }
}
//具体产品B类
class  ProductB extends  Product{
    public function Show() {
        echo "生产出了产品B";
    }
}
abstract class Factory{
    public abstract function Manufacture();
}
//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    public function Manufacture() {
        return new ProductA();
    }
}
//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    public function Manufacture() {
        return new ProductB();
    }
}

(4) 추상 팩토리 패턴(Abstract Factory)

● 정의

특정 클래스를 지정하지 않고 일련의 관련 개체 또는 종속 개체를 만듭니다. 일반적으로 동일한 인터페이스를 구현하는 클래스가 생성됩니다. 추상 팩토리의 클라이언트는 객체가 어떻게 생성되는지 신경 쓰지 않고 객체가 어떻게 함께 작동하는지 알고 있습니다.

● 코드 예시: 두 개의 공장이 있는데, A 공장은 운송을 담당하고, B 공장은 디지털 제품을 생산합니다.

interface Product
{
    public function calculatePrice(): int;
}
class ShippableProduct implements Product
{
    /**
     * @var float
     */
    private $productPrice;
    /**
     * @var float
     */
    private $shippingCosts;
    public function __construct(int $productPrice, int $shippingCosts)
    {
        $this->productPrice = $productPrice;
        $this->shippingCosts = $shippingCosts;
    }
    public function calculatePrice(): int
    {
        return $this->productPrice + $this->shippingCosts;
    }
}
class DigitalProduct implements Product
{
    /**
     * @var int
     */
    private $price;
    public function __construct(int $price)
    {
        $this->price = $price;
    }
    public function calculatePrice(): int
    {
        return $this->price;
    }
}
class ProductFactory
{
    const SHIPPING_COSTS = 50;
    public function createShippableProduct(int $price): Product
    {
        return new ShippableProduct($price, self::SHIPPING_COSTS);
    }
    public function createDigitalProduct(int $price): Product
    {
        return new DigitalProduct($price);
    }
}

(5) 간단한 공장 패턴. )

● 정의

간단한 팩토리 패턴은 팩토리 패턴의 간소화된 버전입니다. 공장 역할 - 구체적인 제품 - 추상적인 제품

● 코드 예:

농장이 과일을 시장에 판매하려고 합니다. 농장에는 사과와 포도라는 세 가지 종류의 과일이 있다고 상상합니다. 1. 과일에는 여러 속성이 있으며 각 속성은 다르지만 재배, 심기, 수확 및 먹기에는 공통점이 있습니다. 앞으로 새로운 과일이 추가될 수 있으며, 구현해야 하는 메서드를 표준화하기 위한 인터페이스를 정의해야 합니다. #

●Definition

일반적인 객체 생성과 비교(new Foo() ), 먼저 프로토타입을 만든 다음 복제하는 것이 더 비용 효율적일 것입니다.

● 코드 예시: 각 책의 제목 설정

interface fruit{
    /**
     * 生长
     */
    public function grow();
    /**
     * 种植
     */
    public function plant();
    /**
     * 收获
     */
    public function harvest();
    /**
     * 吃
     */
    public function eat();
}
class apple implements fruit{
    //苹果树有年龄
    private $treeAge;
    //苹果有颜色
    private $color;
    public function grow(){
        echo "grape grow";
    }
    public function plant(){
        echo "grape plant";
    }
    public function harvest(){
        echo "grape harvest";
    }
    public function eat(){
        echo "grape eat";
    }
    //取苹果树的年龄
    public function getTreeAge(){
        return $this->treeAge;
    }
    //设置苹果树的年龄
    public function setTreeAge($age){
        $this->treeAge = $age;
        return true;
    }
}
class grape implements fruit{
    //葡萄是否有籽
    private $seedLess;
    public function grow(){
        echo "apple grow";
    }
    public function plant(){
        echo "apple plant";
    }
    public function harvest(){
        echo "apple harvest";
    }
    public function eat(){
        echo "apple eat";
    }
    //有无籽取值
    public function getSeedLess(){
        return $this->seedLess;
    }
    //设置有籽无籽
    public function setSeedLess($seed){
        $this->seedLess = $seed;
        return true;
    }
}
class farmer
{
    //定义个静态工厂方法
    public static function factory($fruitName){
        switch ($fruitName) {
            case 'apple':
                return new apple();
                break;
            case 'grape':
                return new grape();
                break;
            default:
                throw new badFruitException("Error no the fruit", 1);
                break;
        }
    }
}
class badFruitException extends Exception
{
    public $msg;
    public $errType;
    public function __construct($msg = '' , $errType = 1){
        $this->msg = $msg;
        $this->errType = $errType;
    }  
}
/**
 * 获取水果实例化的方法
 */
try{
    $appleInstance = farmer::factory('apple');
    var_dump($appleInstance);
}catch(badFruitException $err){
    echo $err->msg . "_______" . $err->errType;
}

(7) 개체 풀 모드(Pool)

# 🎜 🎜#●정의

개체 풀을 사용하여 일련의 개체를 구성 및 저장하고 필요할 때 호출을 받을 수 있습니다. 인스턴스 초기화 비용이 높고, 인스턴스화 속도가 높으며, 사용 가능한 인스턴스가 부족한 상황에서는 개체 풀을 사용하여 성능을 크게 향상시킬 수 있습니다. 객체를 생성하는 데 소요되는 시간(특히 네트워크를 통해)이 불확실한 상황에서는 객체 풀을 통해 짧은 시간 내에 필요한 객체를 얻을 수 있습니다.

● 코드 예

abstract class BookPrototype
{
    /**
    * @var string
    */
    protected $title = 0;
    /**
    * @var string
    */
    protected $category;
    abstract public function __clone();
    public function getTitle(): string
    {
        return $this->title;
    }
    public function setTitle($title)
    {
       $this->title = $title;
    }
}
class BarBookPrototype extends BookPrototype
{
    /**
    * @var string
    */
    protected $category = 'Bar';
    public function __clone()
    {
    }
}
class FooBookPrototype extends BookPrototype
{
    /**
    * @var string
    */
    protected $category = 'Foo';
    public function __clone()
    {
    }
}
$fooPrototype = new FooBookPrototype();
$barPrototype = new BarBookPrototype();
for ($i = 5; $i < 10; $i++) {
    $book = clone $fooPrototype;
    $book->setTitle(&#39;Foo Book No &#39; . $i);
    var_dump(new FooBookPrototype == $book);
}
for ($i = 0; $i < 5; $i++) {
    $book = clone $barPrototype;
    $book->setTitle(&#39;Bar Book No &#39; . $i);
    var_dump(new BarBookPrototype == $book);
}

(8) 빌더 모드(Builder)

● 정의 #🎜🎜 #

복잡한 객체의 구성과 표현을 분리하여 동일한 구성 프로세스가 다른 표현을 만들 수 있도록

● 2) 코드 예 동일한 표준의 트럭과 자동차를 만듭니다. Transformers와 마찬가지로 동일한 부품을 다른 방식으로 결합할 수 있습니다.

● 건설을 담당하는 Director, 인터페이스 구축, 건설 표준 표준화를 담당하는 BuilderInterface, 트럭 클래스 구축을 위한 TruckBuilder, 자동차 구축을 담당하는 CarBuilder로 나누어집니다. classes#🎜🎜 #자동차부품 공개수업, 트럭자동차 엔진 휠도어 부품수업, DirectorTest 시험수업

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('second'));
print_r(Factory::getProduct('first')->getId());
// first
print_r(Factory::getProduct('second')->getId());
// second

위 내용은 PHP 디자인 패턴(창의적)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!