PHP 设计模式极简介绍

工厂方法模式

通过工厂类的方法去创建并返回产品对象。

 

class Factory {

    public function create(){

        return new Product();
    }

}

class Product { }

(new Factory())->create();

 

抽象工厂模式

抽象工厂用来统每个工厂的标准，具体工厂里的方法根据型号生产不同产品。

 

interface AbstractFactory {
    public function create(string $type);
}

public class Factory implements AbstractFactory {

    public create(string type) {

        switch (type) {
            case "circle":
                return new CircleProduct();
            default:
                return null;
        }

    }

}

class CircleProduct {

}


(new Factory())->create('circle');

 

单例模式

保证一个类全局只有一个实例，并提供全局访问点。实现方式有两种：饿汉式和懒汉式。

饿汉式在类加载时，立即创建了唯一实例，而不管有没有使用。

懒汉式在第一次调用时才创建唯一实例，避免内存浪费，要注意多线程同步问题，避免出现多个实例。

 

class Singleton {

    private static $instance = null;

    private function __construct() {}

    public static getInstance() {

        if(self::$instance == null){
            self::$instance = new static();
        }

        return self::$instance;
    }
}


$singleton =  Singleton::getInstance();

 

建造者模式

指挥者控制建造者去创建产品。

 

// 指挥者
class Director {

    public make(Builder $builder) {

        $builder->buildColor();
    }
}

// 建造者
class Builder {

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

    public buildColor(){
        $this->product->setColor('red');
    }

}

//产品类
class Product {
    public function setColor(string $color){
        this->color = color;
    }

}


$director = new Director();
$director->make(new Builder());

 

原型模式

复制现有对象来创建新对象。

 

class Prototype {

    public function __clone(){

        $new = new self();
        $new->name = "副本";
        return $new;

    }

}


$obj = clone (new Prototype())

 

适配器模式

协调接口不兼容的对象一起工作。

 

// 被适配者
class Adaptee {

    public void runing() {
        echo "I am running!"
    }
}

// 适配器
class Adapter {

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

    public function run(){
        $this->adaptee->running();
    }

}


$target = new Adapter(new Adaptee());
$target.run();

 

桥接模式

将产品的各个部分独立出来，以方便它们能自由组装在一起，创建不同属性的产品。

 

class BossCar {

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

    public fucntion getBrand() {
        return "Boss";
    }

    public fucntion drive() {
        $this->engine->start();
        echo "Drive " . $this->getBrand() . " car...";
    }
}

class ElectricEngine {
    public function start() {
        System.out.println("Start Hybrid Engine...");
    }
}

class FuelEngine {
    public function start() {
        System.out.println("Start Hybrid Engine...");
    }
}


(new BossCar(new FuelEngine()))->drive(); // 燃油车
(new BossCar(new ElectricEngine()))->drive();// 电动车

 

组合模式

将同一类型对象组合成在一起，形成树形结构。

 

// 抽象构件
interface Component {
    public operation();
}

// 树枝构件
class Branch implements Component {

    public function add(Component c) {
        $this->child[] = c
    }

    public function operation() {

        echo "This is a Branch object.";
        foreach ($this->child as c) {
            c.operation();
        }
    }
}

//Leaf 叶子构件
class Leaf implements Component {

    public function operation() {
       echo "This is a Leaf object.";
    }

}


$leaf = new Leaf();
$branch1 = new Branch();
$branch1.add(leaf);

$branch2 = new Branch();
$branch2.add($branch1)

$branch2.operation(); //从组合对象开始遍历整颗树

 

装饰器模式

以层层嵌套的方式，扩展一个对象。

 

interface TextNode {

    public function setText($text);
    public function getText();
}

// 被装饰对象
class SpanNode implements TextNode {

    public function __construct(string $text){

        $this->text = $text;
    }

    public void setText(string $text) {
        $this->text = $text;
    }

    public String getText() {
        return "<span>" + $this->text + "</span>";
    }
}


//装饰器：加粗
class BoldDecorator extends TextNode {

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

    public String getText() {
        return "<b>" + target.getText() + "</b>";
    }
}

//装饰器：斜体
class UnderlineDecorator extends TextNode {

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

    public String getText() {
        return "<i>" + target.getText() + "</i>";
    }
}

$node = new BoldDecorator(new UnderlineDecorator(new SpanNode("Hello")));
$node->getText();

外观模式

将原本复杂的调用过程封装起来，对外提供一个简单的调用。本质上就是又封装了一层。

 

 

享元模式

缓存对象，以便共享。创建对象时，先从缓存取，缓存不存在时，再创建并缓存。

 

class Student {

    public static $cache = [];

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

    public static function create($id, $name){

        $key = $id . ":" . $name;
        $student = self::$cache[$key];

        if ($student == null) {
            $student = new self($id, $name);
            self::$cache[$key] = $student;
        }
        return $student;
    }

}


Student::create(1, 'tom');
Student::create(2, 'jim');

 

代理模式

给对象提供一个代理，以控制对该对象的访问。分为动态代理和静态代理。

 

class File {
    public function read($file) {
        return file_get_contents($file);
    }
}

class Proxy {

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

    public function read($file) {

        if (!$this->isAllowed()) {
            throw new Exception("Access denied!");
        }

        return $this->object->read($file);
    }

    private function isAllowed($file) {
        return true;
    }

}

$proxy = new Proxy(new File());
$proxy->read('a.txt');

 

责任链模式

一条请求在责任链路中进行传递，直到被处理。

 

abstract class Leader {

    protected $next = null;

    public function __construct(Leader $next){
        $this->next = $next
    }

    public abstract function handle(int $days);

    public function nextHandle(){
        if($this->next){
            $this->next->handle();
        }else{
            throw new Exception("无法处理该请求");
        }
    }

}

class ClassAdviser extends Leader {

    public function handle(int $days){
        if($days <= 2){
            echo "班主任批准请假" . $days . "天。";
        }else{
            $this->nextHandle($days); //交给上级领导处理
        }
    }
}

class DepartmentHead extends Leader {

    public function handle(int $days){
        if($days <= 7){
            echo "系主任批准请假" . $days . "天。";
        }else{
            $this->nextHandle($days); //交给上级领导处理
        }
    }
}


leader = new ClassAdviser(new DepartmentHead());
leader.handle(5);//请假5天

 

命令模式

将一个对象中的方法封装成命令对象，实现调用方法名称统一。

class Editor {

    public function copy() {
        echo "已复制！"
    }
    public function paste() {
        echo "已粘贴！"
    }

}

abstract class Command {

    public function __construct(Editor $editor){
        $this->editor = $editor
    }

    public abstract function execute();
}

class Copy extends Command {

    public void execute() {
        $this->editor->copy();
    }
}

class Paste extends Command {

    public void execute() {
        $this->editor->paste();
    }

}

$editor = new Editor();

$command = new Copy($editor);
$command->execute();

$command = new Paste($editor);
$command->execute();