PHP常用设计模式

最新推荐文章于 2021-08-26 12:01:27 发布
最新推荐文章于 2021-08-26 12:01:27 发布
阅读量6.4k 收藏 4
点赞数
分类专栏： 浅入浅出PHP 文章标签： 设计模式 PHP 工厂模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39815001/article/details/88942758
版权

工厂模式

通过工厂类的方法返回对象，而不是用的时候在代码中直接new对象。
对比
代码直接new：某一个类或者方法改变之后，所有用到的地方都要修改
使用工厂类：只需要改变相应的工厂类

<?php

class Test1{
    static function aaa(){
        echo '1111111';
    }
}

class Test2{
    static function aaa(){
        echo '22222';
    }
}

class Factory{
    static function createTest1(){
        $bb = new Test1();
        return $bb;
    }

    static function createTest2(){
        $bb = new Test2();
        return $bb;
    }
}
$obj = Factory::createTest1();
$obj2 = Factory::createTest2();
$obj->aaa();
$obj2->aaa();

单例模式

单例模式顾名思义，就是只有一个实例。作为对象的创建模式， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
单例模式的要点有三个：
1.某个类只能有一个实例；
2.它必须自行创建这个实例；
3.它必须自行向整个系统提供这个实例。
为什么要使用PHP单例模式
1. php的应用主要在于数据库应用, 一个应用中会存在大量的数据库操作, 在使用面向对象的方式开发时, 如果使用单例模式, 则可以避免大量的new 操作消耗的资源,还可以减少数据库连接这样就不容易出现 too many connections情况。
2. 如果系统中需要有一个类来全局控制某些配置信息, 那么使用单例模式可以很方便的实现. 这个可以参看zend Framework的FrontController部分。
3. 在一次页面请求中, 便于进行调试, 因为所有的代码(例如数据库操作类db)都集中在一个类中, 我们可以在类中设置钩子, 输出日志，从而避免到处var_dump, echo。

<?php
 /**
 * 设计模式之单例模式
 * $_instance必须声明为静态的私有变量
 * 构造函数必须声明为私有,防止外部程序new类从而失去单例模式的意义
 * getInstance()方法必须设置为公有的,必须调用此方法以返回实例的一个引用
 * ::操作符只能访问静态变量和静态函数
 * new对象都会消耗内存
 * 使用场景:最常用的地方是数据库连接。
 * 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
  */
 class man
 {
     private static $_instance;      //保存例实例在此属性中
     private function __construct()        //构造函数声明为private,防止直接创建对象
     {
               echo '实例化成功';
     }
     //单例方法
     public static function get_instance()
     {
               var_dump(isset(self::$_instance));  //self::指向当前类的指针  this指向当前对象的指针
         if(!isset(self::$_instance))
                     {
                         self::$_instance=new self();
         }
         return self::$_instance;
     }
     //阻止用户复制对象实例
     private function __clone()
     {
               trigger_error('Clone is not allow' ,E_USER_ERROR);
     }
     function test()
     {
               echo("test");
     }
 }
 // 这个写法会出错，因为构造方法被声明为private
 //$test = new man;
 // 下面将得到Example类的单例对象
 $test = man::get_instance();
 $test = man::get_instance();
 $test->test();
 // 复制对象将导致一个E_USER_ERROR.
// $test_clone = clone $test;

注册模式

注册模式，解决全局共享和交换对象。已经创建好的对象，挂在到某个全局可以使用的数组上，在需要使用的时候，直接从该数组上获取即可。将对象注册到全局的树上。任何地方直接去访问。

<?php

class Register
 {
     protected static  $objects;
     static function set($alias,$object)//将对象注册到全局的树上
     {
         self::$objects[$alias]=$object;//将对象放到树上
     }
     static function get($name){
         return self::$objects[$name];//获取某个注册到树上的对象
     }
     static function _unset($alias)
     {
         unset(self::$objects[$alias]);//移除某个注册到树上的对象。
     }
 }

 $reg = new Register();

适配器模式

将各种截然不同的函数接口封装成统一的API。
PHP中的数据库操作有MySQL,MySQLi,PDO三种，可以用适配器模式统一成一致，使不同的数据库操作，统一成一样的API。类似的场景还有cache适配器，可以将memcache,redis,file,apc等不同的缓存函数，统一成一致。
首先定义一个接口(有几个方法，以及相应的参数)。然后，有几种不同的情况，就写几个类实现该接口。将完成相似功能的函数，统一成一致的方法。

接口文件

<?php


namespace Common;

interface IDatabase
{
    function connect($host, $user, $passwd, $dbname);
    function query($sql);
    function close();
}

mysql实例

<?php

namespace Common\Database;

use Common\IDatabase;

class MySQL implements IDatabase
{
    protected $conn;
    function connect($host, $user, $passwd, $dbname)
    {
        // TODO: Implement connect() method.
        $conn = mysql_connect($host, $user, $passwd);
        mysql_select_db($dbname, $conn);
        $this->conn = $conn;
    }

    function query($sql)
    {
        $res = mysql_query($sql, $this->conn);
        return $res;
    }

    function close()
    {
        // TODO: Implement close() method.
        mysql_close($this->conn);
    }
}

mysqli实例

<?php

namespace Common\Database;

use Common\IDatabase;

class MySQLi implements IDatabase
{
    protected $conn;
    function connect($host, $user, $passwd, $dbname)
    {
        // TODO: Implement connect() method.
        $conn = mysqli_connect($host, $user, $passwd, $dbname);
        $this->conn = $conn;
    }
    function query($sql)
    {
        // TODO: Implement query() method.
        return mysqli_query($this->conn, $sql);
    }

    function close()
    {
        // TODO: Implement close() method.
        mysqli_close($this->conn);
    }
}

PDO实例

<?php

namespace Common\Database;

use Common\IDatabase;

class PDO implements IDatabase
{
    protected $conn;
    function connect($host, $user, $passwd, $dbname)
    {
        // TODO: Implement connect() method.
        $conn = new \PDO("mysql:host=$host;dbname=$dbname", $user, $passwd);
        $this->conn = $conn;
    }

    function query($sql)
    {
        // TODO: Implement query() method.
        return $this->conn->query($sql);
    }

    function close()
    {
        // TODO: Implement close() method.
        unset($this->conn);
    }
}

策略模式
策略模式，将一组特定的行为和算法封装成类，以适应某些特定的上下文环境。 【使用策略模式可以实现 控制反转 IOC、依赖倒置 DIP、依赖注入 DI】
eg：假如有一个电商网站系统，针对男性女性用户要各自跳转到不同的商品类目，并且所有的广告位展示不同的广告。在传统的代码中，都是在系统中加入各种if else的判断，硬编码的方式。如果有一天增加了一种用户，就需要改写代码。使用策略模式，如果新增加一种用户类型，只需要增加一种策略就可以。其他所有的地方只需要使用不同的策略就可以。
首先声明策略的接口文件，约定了策略的包含的行为。然后，定义各个具体的策略实现类。

策略接口文件

<?php


namespace Common;


interface UserStrategy
{
    /**
     * @desc 策略接口文件
     */
    function showAd();
    function showCategory();
}

男性用户策略

<?php


namespace Common;


class MaleUserStrategy implements UserStrategy
{
    function showAd()
    {
        // TODO: Implement showAd() method.
        echo 'IPhoneXX';
    }

    function showCategory()
    {
        // TODO: Implement showCategory() method.
        echo '电子产品';
    }
}

女性用户策略

<?php


namespace Common;


class FemaleUserStrategy implements UserStrategy
{
    function showAd()
    {
        // TODO: Implement showAd() method.
        echo "2002新款女装";
    }

    function showCategory()
    {
        // TODO: Implement showCategory() method.
        echo "女装";
    }
}

使用

<?php

namespace Common;

class Page
{
    protected $strategy;
    function index()
    {
        echo "AD：";
        $this->strategy->showAd();
        echo "<br/>";

        echo 'Category：';
        $this->strategy->showCategory();
    }

    function setStrategy(\Common\UserStrategy $strategy)
    {
        $this->strategy = $strategy;
    }
}

$page = new Page();
if (isset($_GET['female'])) {
    $strategy = new \Common\FemaleUserStrategy();
} else {
    $strategy = new \Common\MaleUserStrategy();
}
$page->setStrategy($strategy);
$page->index();

控制反转（设计思想，不是设计模式） IOC：不在类中主动new对象（不依赖对象），而是依赖接口
实现方法： 1.构造函数
2.直接设置属性
3.set方法

下面以构造函数方法为例：

<?php

class Page
{
    protected $strategy;
    public function __construct(\Common\UserStrategy $strategy)
    {
        $this->strategy = $strategy;
    }

    function index()
    {
        echo "AD：";
        $this->strategy->showAd();
        echo "<br/>";

        echo 'Category：';
        $this->strategy->showCategory();
    }
}

if (isset($_GET['female'])) {
    $page = new Page(new \Common\FemaleUserStrategy());
} else {
    $page = new Page(new \Common\MaleUserStrategy());
}
$page->index();

数据对象映射模式
将对象和数据存储映射起来，对一个对象的操作会映射为对数据存储的操作，如框架中的 ORM 类

User模型 （对应user表）

<?php

namespace App\Model;

use Common\Database\MySQLi;

class User
{
    public $id;
    public $name;
    public $mobile;
    public $regtime;

    protected $db;

    function __construct($id)
    {
        $this->db = new MySQLi();
        $this->db->connect('127.0.0.1', 'root', 'root', 'test');
        $res = $this->db->query('select * from user limit 1');
        $data = $res->fetch_assoc();

        $this->id = $data['id'];
        $this->name = $data['name'];
        $this->mobile = $data['mobile'];
        $this->regtime = $data['regtime'];
    }

    function __destruct()
    {
        // TODO: Implement __destruct() method.
        $this->db->query("update user set name = '{$this->name}',
        mobile = '{$this->mobile}',
        regtime = '{$this->regtime}' where id = {$this->id}");
    }
}

使用

<?php

$user = new \App\Model\User(1);


$user->mobile = '188832490';
$user->name = '名字阿信';
$user->regtime = date('Y-m-d H:i:s');

数据库适配器

<?php
namespace Common;

interface IDatabase
{
    function connect($host, $user, $passwd, $dbname);
    function query($sql);
    function close();
}

实现ORM进阶：数据对象映射模式 + 工厂模式 + 注册模式

<?php

namespace Common;

use App\Model\User;

class Factory
{
    /**
     * @param $id
     * @return User
     */
    static function getUser($id)
    {
        $key = 'user_'.$id;
        $user = Register::get($key);
        if (!$user) {
            $user = new User($id);
            Register::set($key, $user);
        }
        return $user;
    }
}

观察者模式
1：观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。
2：场景:一个事件发生后，要执行一连串更新操作。传统的编程方式，就是在事件的代码之后直接加入处理的逻辑。当更新的逻辑增多之后，代码会变得难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件的主体代码。
3：观察者模式实现了低耦合，非侵入式的通知与更新机制。

<?php

abstract class EventGenerator{
    private $observers = array();
    function addObserver(Observer $observer){
        $this->observers[]=$observer;
     }
    function notify(){
        foreach ($this->observers as $observer){
              $observer->update();
         }
     }
 }

interface Observer{
    function update();//这里就是在事件发生后要执行的逻辑
}

class Event extends EventGenerator{
    function triger(){
        echo "Event<br>";
     }
}

class Observer1 implements Observer{
     function update(){
        echo "逻辑1<br>";
     }
 }

 class Observer2 implements Observer{
     function update(){
         echo "逻辑2<br>";
     }
 }

 $event = new Event();
 $event->addObserver(new Observer1());
 $event->addObserver(new Observer2());
 $event->triger();
 $event->notify();

原型模式
原型模式（对象克隆以避免创建对象时的消耗）
1：与工厂模式类似，都是用来创建对象。
2：与工厂模式的实现不同，原型模式是先创建好一个原型对象，然后通过clone原型对象来创建新的对象。这样就免去了类创建时重复的初始化操作。
3：原型模式适用于大对象的创建，创建一个大对象需要很大的开销，如果每次new就会消耗很大，原型模式仅需要内存拷贝即可。

//new一个原形对象
$prototype = new \Common\TestObject();
//对象初始化操作（可以不止一个初始化操作）
$prototype->init();

//克隆对象
$canvas1 = clone $prototype;
//调用方法
$canvas1->funcname();

$canvas2 = clone $prototype;
$canvas2->funcname();

装饰器模式
1：装饰器模式，可以动态的添加修改类的功能
2：一个类提供了一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类继承它，并重写实现类的方法
3：使用装饰器模式，仅需要在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性。

迭代器模式
1、在不需要了解内部实现的前提下，遍历一个聚合对象的内部元素
2、相对于传统的编程模式，迭代器模式可以隐藏遍历元素的所需的操作

代理模式
在客户端和实体之间建立一个代理对象，客户端对实体进行操作全部委派给代理对象，隐藏实体的具体实现细节
比如说数据库主从结构，修改数据需要 new 主库， 查询数据需要 new 从库。如果使用了代理，则可以将查询和修改方法封装进代理类，用户只需要 new 代理类，而不用关心应该 new 从库还是主库。

想出家的霸天虎
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP 中最全的设计模式（23种）
ITYangs的博客
11-27 6784
PhpDesignPatterns 【PHP 中的设计模式】一、 Introduction【介绍】 设计模式：提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架，它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板，可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发，并且将很多大的想法或者设计以一种简单地方
PHP设计模式大全与应用场景
代元培
10-27 1755
PHP常用设计模式与应用场景
PHP常用六大设计模式
james_huba的博客
05-13 505
单例模式 特点： 三私一公：私有的静态变量（存放实例），私有的构造方法（防止创建实例），私有的克隆方法(防止克隆对象)，公有的静态方法（对外界提供实例） 应用场景： 程序应用中，涉及到数据库操作时，如果每次操作的时候连接数据库，会带来大量的资源消耗。可以通过单例模式，创建唯一的数据库连接对象。 <?php class Singleton { private static $_instance; private function __construct(){} private f
PHP八大设计模式
casey的博客
08-26 100
设计模式 单例模式解决的是如何在整个项目中创建唯一对象实例的问题，工厂模式解决的是如何不通过new建立实例对象的方法。 单例模式 $_instance必须声明为静态的私有变量 构造函数和析构函数必须声明为私有,防止外部程序new 类从而失去单例模式的意义 getInstance()方法必须设置为公有的,必须调用此方法 以返回实例的一个引用 ::操作符只能访问静态变量和静态函数 new对象都会消耗内存 使用场景:最常用的地方是数据库连接。 使用单例模式生成一个对象后， 该对象可以被其它众多对
php常用设计模式.pdf
03-29
php常用设计模式.pdf
PHP常用设计模式之委托设计模式
12-19
模式定义 委托是对一个类的功能进行扩展和复用的方法。它的做法是：写一个附加的类提供附加的功能，并使用原来的类的实例提供原有的功能。 假设我们有一个 TeamLead 类，...设计了一个cd类，类中有mp3播放模式，和mp4
PHP常用的三种设计模式
10-20
本文为大家介绍常用的三种php设计模式：单例模式、工厂模式、观察者模式，具有很好的参考价值，下面跟着小编一起来看下吧
PHP中的几种设计模式
05-29
PHP中的几种设计模式 一、 开发环境 1、环境搭建：Windows 7+Apache 2.4.18+...本案例主要使用PHP 7中的面向对象程序设计思想以及常用的几种设计模式：包括工厂模式、适配器模式、代理模式、命令模式、单例模式等。
PHP常用的六大设计模式
qq_36596869的博客
07-12 416
单例模式 由于单例模式在内存中只有一个实例，减少内存开支，减少系统的性能开销，常用与数据库的连接 //三私一公 class Singleton { //存储实例化对象 private static $instance; private function __construct() {} final protected function __clone() {} #不允许被重写并且会被子类继承 public static function getInstance
php23种完整设计模式（完整代码）
07-05
php23种完整设计模式（完整代码）
五种PHP设计模式
03-05
本文介绍的五种PHP应用程序中使用的几种最常见的设计模式。分别是工厂模式，单元素模式，观察者模式，命令链模式，策略模式。本文介绍的仅仅是 PHP 应用程序中使用的几种最常见的设计模式。在设计模式 一书中演示了更多的设计模式。不要因架构的神秘性而放弃。模式是一种绝妙的理念，适用于任何编程语言、任何技能水平。
php中常见的几种设计模式
apollo__的博客
08-31 3226
1. 单例模式 单例模式可以说是面向对象语言里最常用、也是最简单的一种模式。单例就是单个实例，单个对象的意思，就是说我们去实例化一个类的时候，不管调用多少次，都永远只有一个实例, 不会有多个，这样就节省了内存分配开支。 先简单说下单例模式的原理：将构造函数__construct设置为私有的private, 对外提供一个static静态方法比如：getInstance获得实例，在getInst
[转]五种常见的PHP设计模式
heiyeluren的blog（黑夜路人的开源世界）
11-03 4583
 五种常见的PHP设计模式设计模式只是为 Java 架构师准备的 —— 至少您可能一直这样认为。实际上，设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 的专利，那么它们又是什么？为什么说它们在 应用程序中非常有用？本文解释了这些问题。PHP设计模式 一书将设计模式引入软件社区，该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson
PHP开发中常用六大设计模式
梦中几时的博客
11-11 3301
PHP常用六大设计模式 单例模式 特点： 三私一公：私有的静态变量（存放实例），私有的构造方法（防止创建实例），私有的克隆方法(防止克隆对象)，公有的静态方法（对外界提供实例） 应用场景： 程序应用中，涉及到数据库操作时，如果每次操作的时候连接数据库，会带来大量的资源消耗。可以通过单例模式，创建唯一的数据库连接对象。 <?php class Singleton { private static $_instance; private function __construct(){}
php几种设计模式,php三种基本设计模式
weixin_28936857的博客
03-10 677
PSR，是PHP开发的事实标准;PSR-0 自动加载:命名空间必须与绝对路径一致。类名首字母必须大写。除入口文件外，其他”.php”必须只有一个类。开发符合PSR-0规范的基础框架严格全部使用命名空间。所有PHP文件必须自动载入，不能有include/require。单一入口。SPL(PHP标准库)SqlStack，SqlQueue，SplHeap，SqlFixedArray等数据结构类。Arra...
五种常见的 PHP 设计模式
成长足迹
01-23 9093
设计模式只是为 Java 架构师准备的 —— 至少您可能一直这样认为。实际上，设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 的专利，那么它们又是什么？为什么说它们在 PHP 应用程序中非常有用？本文解释了这些问题。设计模式 一书将设计模式引入软件社区，该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides
PHP设计模式初探 以前写的完整PPT!!!!!
最新发布
03-02
设计模式是一种在软件开发中常用的最佳实践，它提供了一种解决常见问题的标准方法，使得代码更易于复用、维护和扩展。这份PPT主要围绕以下几个核心主题展开： 1. 面向过程与面向对象编程： - 面向过程的编程（如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值