关于设计模式:一文搞懂│工厂模式单例模式策略模式适配器模式观察者模式的原理和使用

工厂模式的原理
作用： 就是你只有传你须要的类进去，你就能失去他的实例化对象
其实工厂就是帮你实例化你所须要的类

<?php
/**
* 工厂类
*/
class factory
{public static function create($className) {return new $className();
    }
}
 
class A {}
class B {}
 
$a = factory::create('A');
$b = factory::create('B');
 
var_dump($a); // object(A)#1 (0) {}
var_dump($b); // object(B)#2 (0) {}

工厂模式的利用
实例化多个类来解决不同业务时候应用，这里以求矩形和圆形的周长和面积为案例

<?php
/**
 * Interface shape
 */
interface shape
{public function area();
    public function perimeter();}
 
/**
 * 矩形
 * Class rectangle
 */
class rectangle implements shape
{
    private $width;
    private $height;
 
    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }
 
    public function area() {return $this->width * $this->height;}
 
    public function perimeter() {return 2 * ($this->width + $this->height);
    }
}
 
/**
 * 圆
 * Class circle
 */
class circle implements shape
{
    private $radius;
 
    public function __construct($radius) {$this->radius = $radius;}
 
    public function area() {return M_PI * pow($this->radius, 2);
    }
 
    public function perimeter() {return 2 * M_PI * $this->radius;}
}
 
/**
 * 工厂类
 * Class factory
 */
class factory
{public static function create() {switch (func_num_args()) {
            case 1:
                return new circle(func_get_arg(0));
                break;
            case 2:
                return new rectangle(func_get_arg(0), func_get_arg(1));
                break;
        }
    }
}
 
$a = factory::create(4, 5);
$b = factory::create(2);
 
echo '矩形的周长为：' . $a->perimeter();
echo '矩形的面积为：' . $a->area();
echo '圆的周长为：' . $a->perimeter();
echo '圆的面积为：' . $a->area();

单例模式的原理
作用： 当你实例化屡次类的时候，让其只存在在惟一的内存空间中，缩小资源的耗费
一般类的实例化，一个 new 将会创立一个实例化内存空间，因为空间不同，这将会导致系统内存开销增大
然而同一个类，性能都一样，没必要放在不同的内存空间中

<?php
/**
 * Class A
 */
class A {}
 
$a = new A();
$b = new A();

// 非单例模式中能够看到其中 #1，#2 分属不同的内存空间
var_dump($a); // object(A)#1 (0) {}
var_dump($b); // object(A)#2 (0) {}

单例模式的定义
单例模式的入门口诀是：三私一公
公有的构造方法： 避免人为内部应用 new 进行创立这就是下面一般内的实例化了
公有的克隆办法： 避免人为内部应用 clone 办法后进行实例化
公有的动态属性： 用来存储繁多的实例化对象
私有的静态方法： 用来实现繁多的实例化逻辑
从后果来看：两个类的对象内存空间都指向了 #1，实现了单例模式的根底构建

<?php
/**
 * Class database
 */
class database
{
    /**
     * @var $instance
     */
    private static $instance;
 
    /**
     * 公有的构造方法，禁止内部实例化
     * database constructor.
     */
    private function __construct() {}
 
    /**
     * 公有的克隆办法，禁止内部克隆
     */
    private function __clone() {}
 
    /**
     * 获取单例
     * @return database
     */
    public static function getInstance()
    {if(!self::$instance instanceof self) {self::$instance = new self();
        }
 
        return self::$instance;
    }
}
 
$a = database::getInstance();
$b = database::getInstance();

var_dump($a); // object(database)#1 (0) {}
var_dump($b); // object(database)#1 (0) {}

单例模式的利用
其实在我的项目中单例模式的利用很多，无非就是有些货色只须要实例化一个对象就行了，不须要屡次进行实例化
这其中的利用场景常见的就包含 PDO 连贯数据库，Redis的连贯等等

<?php
/**
 * Class mysql
 */
class mysql
{
    /**
     * @var \PDO
     */
    private $pdo;
 
    /**
     * @var $instance
     */
    private static $instance;
 
    /**
     * @var array
     */
    private $_config = [
        'host' => '127.0.0.1',
        'post' => 3306,
        'user' => 'root',
        'password' => '','charset'=>'utf8','dbname'=>'autofelix','except'=>'PDO::ERRMODE_EXCEPTION'
    ];
 
    /**
     * mysql constructor.
     */
    private function __construct() {}
 
    /**
     * 数据库链接
     */
    public function connect()
    {
        try {$dsn = "mysql:host={$this->_config['host']};port={$this->_config['post']};dbname={$this->_config['dbname']};charset={$this->_config['charset']}";
            $this->pdo = new PDO($dsn, $this->_config['user'], $this->_config['password']);
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, $this->_config['except']);
        } catch (PDOException $e) {exit('数据库连贯失败：' . $e->getMessage());
        }
    }
 
    /**
     * @param $sql
     * @return array
     */
    public function getAll($sql)
    {
        $this->sql = $sql;
        $pdostatement = $this->pdo->query($sql);
        return $pdostatement->fetchAll(PDO::FETCH_ASSOC);
    }
 
    /**
     * @return mysql
     */
    public static function getInstance()
    {if(!self::$instance instanceof self) {self::$instance = new self();
        }
        return self::$instance;
    }
 
    private function __clone() {}
}
 
$mysql = mysql::getInstance();
$mysql->connect();
 
$sql = 'select * from autofelix_users where 1';
$result = $mysql->getAll($sql);
echo json_encode($result);

策略模式的原理
作用： 比方你去淘宝上买货色，如果你是男生，它的首页会给你举荐男生喜爱的物品，如果你是女生呢，它会给你举荐女生罕用的物品，策略模式其实就是给 对象进行分类
由下面可知，编程中的策略模式，就是会晓得你是什么人，而后给你举荐你喜爱的货色，让营销最大化
这里必然波及到，程序在运行的时候，给你这个人进行分门别类，而后执行了不同的办法导致的
这里咱们定义两个类，领有雷同的办法，执行的内容却不同
策略模式须要做的就是当用户进来时候，同一个入口让他依据这个人的行为去执行其中某一个类中的办法

<?php
/**
 * Class A
 */
class A {public function name()
    {echo "我是 A 类";}
}
 
/**
 * Class B
 */
class B {public function name()
    {echo "我是 B 类";}
}
 
/**
 * Class strategy
 */
class strategy
{
    /**
     * @var $obj
     */
    private $obj;
 
    /**
     * @return mixed
     */
    public function getName()
    {return $this->obj->name();
    }
 
    /**
     * @param $class
     */
    public function setClass($class)
    {$this->obj = $class;}
}
 
$strategy = new strategy();
// 分门别类
// $strategy->setClass(new A());
$strategy->setClass(new B());
// 同一个入口
$strategy->getName(); // 我是 B 类

策略模式的利用
情景: 一个用户去某酒店网站定住宿为例，页面上依据你的历史生产记录，会为你显示低等住宿和丰盛的晚餐，或者仅仅显示公众住宿和便宜的自助餐
咱们先定义接口去实现住房和晚餐的办法
而后定义两个群里的类去实现这个接口，别离是尊贵的人群和一般的人群
当有个 autofelix 用户去订房间，给他注入公众用户的类

<?php
/**
 * 定义接口
 * Interface userStrategy
 */
interface userStrategy
{public function hotel();
    public function dinner();}
 
/**
 * 尊贵的客人享有的待遇
 * Class rich
 */
class rich implements userStrategy
{public function hotel()
    {return "你是高贵的客人，为你举荐了高级住宿";}
 
    public function dinner()
    {return "你是高贵的客人，为你举荐了烛光晚餐";}
}
 
/**
 * 一般的客人享有的待遇
 * Class poor
 */
class poor implements userStrategy
{public function hotel()
    {return "你是一般的客人，为你举荐了公众住宿";}
 
    public function dinner()
    {return "你是一般的客人，为你举荐了自助餐";}
}
 
/**
 * Class user
 */
class user
{
    private $_userClass;
 
    public function getHotel() {return $this->_userClass->hotel();
    }
 
    public function getDinner() {return $this->_userClass->dinner();
    }
 
    public function setUserClass(userStrategy $userStrategy) {$this->_userClass = $userStrategy;}
}
 
/**
 * 这时候有个 autofelix 用户过去网站预约房间
 * Class autofelix
 */
class autofelix extends user {}
 
$people = new autofelix();
 
// 设置群体
$people->setUserClass(new poor());
 
// 获取该群体的住宿和晚餐
$hotel = $people->getHotel();
$dinner = $people->getDinner();
 
echo json_encode([
    'hotel' => $hotel,
    'dinner' => $dinner
]);

// 后果如下
{
    hotel: "你是一般的客人，为你举荐了公众住宿",
    dinner: "你是一般的客人，为你举荐了自助餐"
}

适配器模式的原理
作用： 将一个类的接口转换成客户心愿的另一个接口，适配器模式使得本来的因为接口不兼容而不能一起工作的那些类能够一起工作
比方：在某个场景中，老我的项目写了很多接口公你调用，但忽然有一天，下属说要换个接口办法名调用，须要你用另一个办法名去实现雷同的性能
你是间接改后端代码的办法名称？这必定行不通，因为我的项目不止你这一个中央调用这个接口，一旦批改，其余中央就崩了，还是去从新复制那段逻辑代码，改个名字，这样不是不行，只是写了反复代码，显得臃肿了

<?php
 
class A
{
    private $str;
 
    public function __construct($str)
    {$this->str = $str;}
 
    public function getStr()
    {return $this->str;}
 
    // 谬误示范，间接复制 getStr 中的代码改个办法名，臃肿
    public function getString()
    {return $this->str;}
}
 
// 适配器模式前
$a = new A('i am autofelix');
$result = $a->getStr();
var_dump($result);

适配器模式的利用
而正确的常见，应该是应用适配器模式解决这类问题
通过定义对立接口，而后通过实现接口去实现

<?php
// 我的项目本来代码
class A
{
    private $str;
 
    public function __construct($str)
    {$this->str = $str;}
 
    public function getStr()
    {return $this->str;}
}

// 定义对立接口
interface AInterface {function getString();
}
 
class B implements AInterface
{
    /**
     * @var A
     */
    private $_A;
 
    public function __construct($class)
    {$this->_A = $class;}
 
    public function getString()
    {return $this->_A->getStr();
    }
}
 
// 适配器模式前
$a = new A('i am autofelix');
$result = $a->getStr();
var_dump($result);

// 适配器模式后
$b = new B($a);
$result = $b->getString();
var_dump($result);

观察者模式的原理
作用： 用来监控用户的某些操作，而后依据用户这些操作来解决一些后续的事件
举个例子：一个用户去网上购买电影票，付款胜利后，零碎须要发短信给用户，顺便记录用户购票的日志等其余多个逻辑操作

// 零碎自带的观察者接口
// 默认须要实现 onListen 和 getObserverName 这两个办法
// 如果是自定义观察者接口名，肯定要实现 onListen 同性能的办法
// onListen 注册监听行为
interface InterfaceObserver
{public function onListen($sender, $args);
    public function getObserverName();}

// 定义可被观察者的接口
// 其实就是用来监听事件的产生
// addObserver 办法咱们是用来依赖注入一些用户购票之后零碎的行为操作
// removeObserver 办法，是用来移除某个后续操作的，咱们临时不去实现
interface InterfaceObservable
{public function addObserver($observer);
    public function removeObserver($observer_name);
}

观察者模式的利用
这里以用户购票后须要给用户发送信息和记录购票日志

<?php
/**
 * Interface InterfaceObserver
 * 观察者接口
 */
interface InterfaceObserver
{public function onListen($sender, $args);
    public function getObserverName();}
 
/**
 * Interface InterfaceObservable
 * 被察看对象接口
 */
interface InterfaceObservable
{public function addObserver($observer);
    public function removeObserver($observer_name);
}
 
class Ticket implements InterfaceObservable
{
    /**
     * @var array
     */
    private $_observers = [];
 
    /**
     * @param $observer
     */
    public function addObserver($observer)
    {if ($observer instanceof InterfaceObserver) {$this->_observers[] = $observer;
        }
    }
 
    /**
     * @param $observer_name
     */
    public function removeObserver($observer_name) {}
 
    /**
     * 用户购票行为
     */
    public function buy()
    {
        // 用户购票逻辑, 这里不具体阐明, 仅仅以参数代之
        $result = [
            'code' => 200,
            'msg' => '用户购票胜利',
            'sign' => 'ea5070bec29826cc0f8e0b7b6861fd75'
        ];
 
        // 购票胜利，开始前期解决
        if($result['code'] == 200) {foreach ($this->_observers as $observer) {$observer->onListen($this, $result['sign']);
            }
        }
    }
}
 
 
/**
 * 记录用户购票日志
 * Class TicketRecord
 */
class ticketRecord implements InterfaceObserver
{public function onListen($sender, $args)
    {echo "记录用户购票胜利, 编号为:{$args}<br/>";
    }
 
    public function getObserverName() {}
}
 
/**
 * 给用户发送观影短信
 * Class sendMsg
 */
class sendMsg implements InterfaceObserver
{public function onListen($sender, $args)
    {echo "您的电影票购买胜利, 请凭编号:{$args}观影 <br/>";
    }
 
    public function getObserverName() {}
}
 
$ticket = new Ticket();
$ticket->addObserver(new ticketRecord());
$ticket->addObserver(new sendMsg());
$ticket->buy();

关于设计模式:一文搞懂│工厂模式单例模式策略模式适配器模式观察者模式的原理和使用

🎈 工厂模式

🎈 单例模式

🎈 策略模式

🎈 适配器模式

🎈 观察者模式

Just My Socks（注册教程内含优惠码）

关于设计模式:一文搞懂│工厂模式单例模式策略模式适配器模式观察者模式的原理和使用

🎈 工厂模式

🎈 单例模式

🎈 策略模式

🎈 适配器模式

🎈 观察者模式

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）