后端,PHP

五种常见的PHP设计模式

1.策略模式

策略模式是对象的行为模式,用意是对一组算法的封装。动态的选择需要的算法并使用。

策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大,因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。

策略模式的三个角色:

1.抽象策略角色

2.具体策略角色

3.环境角色(对抽象策略角色的引用)

实现步骤:

1.定义抽象角色类(定义好各个实现的共同抽象方法)

2.定义具体策略类(具体实现父类的共同方法)

3.定义环境角色类(私有化申明抽象角色变量,重载构造方法,执行抽象方法)

就在编程领域之外,有许多例子是关于策略模式的。例如:

如果我需要在早晨从家里出发去上班,我可以有几个策略考虑:我可以乘坐地铁,乘坐公交车,走路或其它的途径。每个策略可以得到相同的结果,但是使用了不同的资源。

策略模式的代码实例:

<?php

//抽象策略类
abstract class baseAgent
{
    abstract function PrintPage();
}

//用于客户端是IE时调用的类(环境角色)
class ieAgent extends baseAgent
{
    function PrintPage()
    {
        return 'IE';
    }
}

//用于客户端不是IE时调用的类(环境角色)
class otherAgent extends baseAgent
{
    function PrintPage()
    {
        return 'not IE';
    }
}

//具体策略角色类
class Browser
{
    public function call($object)
    {
        return $object->PrintPage();
    }
}

//实例化具体策略角色类
$bro = new Browser ();
//调用策略角色方法传入环境角色类
echo $bro->call(new otherAgent());

2.工厂模式

工厂模式是我们最常用的实例化对象模式,是用工厂方法代替new操作的一种模式。

使用工厂模式的好处是,如果你想要更改所实例化的类名等,则只需更改该工厂方法内容即可,不需逐一寻找代码中具体实例化的地方(new处)修改了。为系统结构提供灵活的动态扩展机制,减少了耦合。

工厂模式的代码实例:

<?php

/**
 * 工厂模式
 * 用工厂方法代替new操作的一种模式
 */

//定义抽象类
abstract class people
{
    abstract function say();
}

//具体产物man类
class man extends people
{
    public function say()
    {
        return "我是男生<br/>";
    }
}

//具体产物woman类
class woman extends people
{
    public function say()
    {
        return "我是女生<br/>";
    }
}

//定义工厂函数类
class factory
{
    //生产方法createMan
    public function createMan()
    {
        return new man();
    }

    //生产方法createWoman
    public function createWoman()
    {
        return new woman();
    }
}

//实例化工厂函数类
$f = new factory();
//调用生产方法createMan
echo $f->createMan()->say();
//调用生产方法createWoman
echo $f->createWoman()->say();

3.单例模式

单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

单例模式是一种常见的设计模式,在计算机系统中,线程池、缓存、日志对象、对话框、打印机、数据库操作、显卡的驱动程序常被设计成单例。

单例模式分3种:懒汉式单例、饿汉式单例、登记式单例。

单例模式有以下3个特点:

1.只能有一个实例。

2.必须自行创建这个实例。

3.必须给其他对象提供这一实例。

那么为什么要使用PHP单例模式?

PHP一个主要应用场合就是应用程序与数据库打交道的场景,在一个应用中会存在大量的数据库操作,针对数据库句柄连接数据库的行为,使用单例模式可以避免大量的new操作。因为每一次new操作都会消耗系统和内存的资源。

单例模式的代码实例:

<?php

/**
 * 三私一公
 * 私有静态成员变量
 * 私有构造函数
 * 私有克隆函数
 * 公共静态方法
 */

class Single
{
    //声明一个私有的实例变量
    private $name;

    //声明私有构造方法,防止外部代码使用new来创建对象
    private function __construct()
    {
    }

    //声明私有克隆函数,防止对象被克隆
    private function __clone()
    {
    }

    //声明一个静态变量(保存在类中唯一的一个实例)
    private static $instance;

    //声明一个getInstance()静态方法,用于检测是否有实例对象
    public static function getInstance()
    {
        //判断自己有没有$instance,如果没有则实例化自己赋值给$instance
        if (!self::$instance) self::$instance = new self();
        //返回$instance(整个Single类)
        return self::$instance;
    }

    //创建公共方法setName
    public function setName($name)
    {
        $this->name = $name;
    }

    //创建公共方法getName
    public function getName()
    {
        return $this->name;
    }
}

//调用Single类静态方法getInstance
$oa = Single::getInstance();
//调用setName方法
$oa->setName('Java');

//调用Single类静态方法getInstance
$ob = Single::getInstance();
//调用setName方法
$ob->setName('PHP');

echo $oa->getName();//PHP
echo '<br/>';
echo $ob->getName();//PHP

4.观察者模式

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

观察者模式的代码实例:

<?php

/*
 * 观察者模式
 * 当一个对象状态发生变化时,依赖它的对象全部收到触发操作
 */

//定义event抽象类
abstract class event
{
    abstract function run();
}

//定义e1事件类
class e1 extends event
{
    public function run()
    {
        //输出执行方法名
        echo __METHOD__ . "<br/>";
    }
}

//定义e2事件类
class e2 extends event
{
    public function run()
    {
        //输出执行方法名
        echo __METHOD__ . "<br/>";
    }
}

//定义observer观察类
class observer
{
    //定义静态属性$obs,用于以数组方式保存事件类
    static $obs;

    /**
     * 向$obs添加事件类
     * @param $name 事件名
     * @param $obj  事件对象
     */
    function addObs($name, $obj)
    {
        self::$obs[$name] = $obj;
    }

    //触发事件
    function trigger()
    {
        foreach (self::$obs as $val) {
            $val->run();
        }
    }
}

//实例化observer观察类
$o = new observer();
//添加事件对象e1
$o->addObs('e1', new e1());
//添加事件对象e2
$o->addObs('e2', new e2());
//触发事件
$o->trigger();

5.适配器模式

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

适配器模式的代码实例:

<?php

/*
 * 适配器模式
 * 把不同的方法封装成统一的方法以供调用
 * 用在 数据库 mysqli, pdo 等
 */

//声明接口db
interface db
{
    //连接方法
    public function connect();

    //查询方法
    public function query();

    //关闭方法
    public function close();
}

//mysqli连接类
class mysqlA implements db
{
    protected $conn;

    //连接方法
    public function connect($host, $user, $passwd, $dbname)
    {
        $this->conn = mysqli_connect($host, $user, $passwd, $dbname);
    }

    //查询方法
    public function query($sql)
    {
        return mysqli_query($this->conn, $sql);
    }

    //关闭方法
    public function close()
    {
        mysqli_close($this->conn);
    }
}

//PDO连接类
class mysqlB implements db
{
    protected $db;

    //连接方法
    public function connect()
    {
        $this->db = new PDO($dsn, $username, $password);
    }

    //查询方法
    function query($sql)
    {
        return $this->db->query($sql);
    }

    //关闭方法
    public function close()
    {
        $this->db = null;
    }
}

回复

This is just a placeholder img.