2. 程式人生 > >php 十一種設計模式

php 十一種設計模式

阿新 • • 發佈：2018-12-07

                                        php 十一種設計模式

第一種：工廠模式

工廠類：Factory.class.php

<?php
require_once 'Test.class.php';
class Factory{
	static function createTest(){
		$test = new Test();
		return $test;
	}
}
?>

需要例項化的類：Test.class.php

<?php
class Test{
	public function index(){
		return "index";
	}
}
?>

執行類：index.php

<?php
require_once 'Factory.class.php';
$test = Factory::createTest();
echo $test->index();  //index
?>

PS：工廠模式的好處就是：當要例項化的類名改變時，只需要改變工廠類裡的需要例項化的類的名字

第二種：單例模式

單例模式實現資料庫的連線以及增刪改查

DB.class.php:

<?php
// 單例模式
class DB{
	private static $_instance;    //存放例項物件
	private $_pdo = null;         //存放pdo物件
	const DB_HOST = 'localhost';
	const DB_USER = 'root';
	const DB_PW = '12345678';
	const DB_NAME = 'test';

        // 建構函式私有化 只能類內呼叫
	private function __construct(){
		// 連線資料庫
		try{
			$this->_pdo = new PDO('mysql:host='.self::DB_HOST.';dbname='.self::DB_NAME,self::DB_USER,self::DB_PW);
			// 設定字符集
			$this->_pdo->query("SET NAMES UTF8");
		}catch(PDOException $e){
			exit('資料庫連線失敗'.$e->getMessage());
		}
	}
	// 單例模式的實現
	static function getInstance(){
		if(is_null(self::$_instance)){
			self::$_instance = new self();
		}
		return self::$_instance;
	}
	// 檢視資訊
	public function getInfo($_sql){
		$_result = $this->_pdo->query($_sql,PDO::FETCH_OBJ);
		return $_result;
	}
	// 插入資訊	// 修改資訊 // 刪除資訊
	public function cud($_sql){
		$_stmt = $this->_pdo->prepare($_sql);
		$_stmt->execute();
		return $_stmt;
	}
}
?>

呼叫 index.php:

<?php
require_once 'DB.class.php';
$db = DB::getInstance();
// 查詢資料
$result = $db->getInfo("SELECT id FROM test WHERE username = '123'");
while (!!$rows = $result->fetch()) {
	print_r($rows);
}
// 插入一條資料
$stmt = $db->cud("INSERT INTO test(username) VALUES('測試')");
if($stmt->rowCount()){
	echo "插入成功";
}
?>

PS：如果再結合一下工廠模式：

Factory.class.php:

<?php
require_once 'DB.class.php';
class Factory{
	static function createDB(){
		$db = DB::getInstance();
		return $db;
	}
}
?>

index.php:

<?php
require_once 'Factory.class.php';
$db = Factory::createDB();  //使用工廠模式呼叫單例模式得到DB類
// 查詢資料
$result = $db->getInfo("SELECT id FROM test WHERE username = '123'");
while (!!$rows = $result->fetch()) {
	print_r($rows);
}
// 插入一條資料
$stmt = $db->cud("INSERT INTO test(username) VALUES('測試')");
if($stmt->rowCount()){
	echo "插入成功";
}
?>

第三種：註冊器模式

結合前面的單例模式和工廠模式 操作資料庫

Register.class.php:

<?php
class Register{
    static protected $objects;//全域性樹  array
    //設定
    static function set($alias,$object){
        self::$objects[$alias] = $object;
    }
    //獲得
    static function get($alias){
        return self::$objects[$alias];
    }
    //登出
    static function _unset($alias){
        unset(self::$objects[$alias]);
    }
}

index.php:

<?php
require_once 'Factory.class.php';
require_once 'Register.class.php';
// $db = Factory::createDB();  //使用工廠模式呼叫單例模式得到DB類
if(Register::get('db')){
	$db = Register::get('db');
}else{
	Register::set('db',Factory::createDB());  
	$db = Register::get('db');    //使用註冊器模式 
}
// 查詢資料
$result = $db->getInfo("SELECT id FROM test WHERE username = '123'");
while (!!$rows = $result->fetch()) {
	print_r($rows);
}
// 插入一條資料
$stmt = $db->cud("INSERT INTO test(username) VALUES('測試')");
if($stmt->rowCount()){
	echo "插入成功";
}
?>

PS：還可以再將Register類做成單例模式。

第四種：介面卡模式 

可以將截然不同的函式封裝成同意的API，例如php的資料庫操作，包括mysql,mysqli,PDO

還是結合一下前面的三種設計模式：

建立介面 database.class.php:

<?php
interface Database{
    public function connect();
    public function select($_sql);
    public function close();
}
?>

建立3個檔案實現這個介面分別包括使用mysql,mysqli,PDO三種方法：

這裡的PDO連線還使用之前的DB類，如下修改：

<?php
require 'Database.class.php';      //引入介面
// 單例模式
class DB implements Database{     //實現介面
	private static $_instance;    //存放例項物件
	private $_pdo = null;         //存放pdo物件
	const DB_HOST = 'localhost';
	const DB_USER = 'root';
	const DB_PW = '12345678';
	const DB_NAME = 'test';
	// 單例模式的實現
	static function getInstance(){
		if(is_null(self::$_instance)){
			self::$_instance = new self();
		}
		return self::$_instance;
	}
	// 建構函式私有化 只能類內呼叫
	private function __construct(){
		// 連線資料庫
		$this->connect();
	}
	// 實現介面的connect方法
	public function connect(){
		try{
			$this->_pdo = new PDO('mysql:host='.self::DB_HOST.';dbname='.self::DB_NAME,self::DB_USER,self::DB_PW);
			// 設定字符集
			$this->_pdo->query("SET NAMES UTF8");
		}catch(PDOException $e){
			exit('資料庫連線失敗'.$e->getMessage());
		}
	}
	
	// 實現介面的query方法
	// 檢視資訊
	public function select($_sql){
		$_result = $this->_pdo->query($_sql,PDO::FETCH_OBJ);
		return $_result;
	}
	// 實現介面的close方法
	public function close(){
		unset($this->_pdo);
	}
	// 插入資訊	// 修改資訊 // 刪除資訊
	public function cud($_sql){
		$_stmt = $this->_pdo->prepare($_sql);
		$_stmt->execute();
		return $_stmt;
	}
}
?>

剩下的兩個檔案原理一樣，逐一實現即可。

index.php呼叫：

<?php
require_once 'Factory.class.php';
require_once 'Register.class.php';
// $db = Factory::createDB();  //使用工廠模式呼叫單例模式得到DB類
if(Register::get('db')){
	$db = Register::get('db');
}else{
	Register::set('db',Factory::createDB());  
	$db = Register::get('db');    //使用註冊器模式
}
// 查詢資料
$result = $db->select("SELECT id FROM test WHERE username = '123'");
while (!!$rows = $result->fetch()) {
	print_r($rows);
}

// 插入一條資料
$stmt = $db->cud("INSERT INTO test(username) VALUES('測試')");
if($stmt->rowCount()){
	echo "插入成功";
}
?>

第五種：策略模式

將一組特定的行為和演算法封裝成類，以適應某些特定的上下文環境，例如：根據性別展示商品

1 簡單的策略模式

四個檔案：Lesson.class.php,Math.class.php,English.class.php,index.php;

通過操作Lesson.class.php,呼叫English.class.php或者Math.class.php;

Lesson.class.php:

<?php
class Lesson{
	public $_num;
	public $_strategy;    //策略因子 存放物件
	public function __construct($_num,$_strategy){
		$this->_num = $_num;
		$this->_strategy = $_strategy;
	}
	public function cost(){
		return $this->_strategy->cost($this); //傳遞自身
	}
}
?>

Math.class.php:

<?php
class Math{
	public function cost(Lesson $_lesson){
		return 100*$_lesson->_num;  //呼叫Lesson的屬性或者方法
	}
}
?>

English.class.php:

<?php
class English{
	public function cost(Lesson $_lesson){
		return 200*$_lesson->_num;    //呼叫Lesson的屬性或者方法
	}
}
?>

index.php:

<?php
require 'Lesson.class.php';
require 'English.class.php';
require 'Math.class.php';
$math = new Lesson(5,new Math());
$english = new Lesson(5,new English());
echo $english->cost();  //1000
echo "<br>";
echo $math->cost();     //500
?>

通過傳入的類改變實現的方法內容。

2 複雜的策略模式：

假設出現了文科和理科，而且兩者下的數學，英語是不一樣的，存在相應的折扣；

使用抽象類對學科進行規範：L.class.php

uml圖：

 此時無論新增一個學科還是一個類別都是非常簡單並且不會影響到之前已經寫好的類檔案

Lesson.class.php:

<?php
class Lesson{
	public $_num;
	public $_discoust;    //折扣
	public $_strategy;    //策略因子 存放物件
	public function __construct($_num,$_strategy){
		$this->_num = $_num;
		$this->_strategy = $_strategy;
	}
	public function cost(){
		return $this->_strategy->cost($this); //傳遞自身
	}
}
?>

Arts.class.php:

<?php
require_once 'Lesson.class.php';
class Arts extends Lesson{
	public $_discount = 0.8;
}

?>

Science.class.php:

<?php
require_once 'Lesson.class.php';
class Science extends Lesson{
	public $_discount = 0.6;
}
?>

L.class.php:

<?php
abstract class L{
	abstract function cost(Lesson $_sesson);
}
?>

English.class.php:

<?php
require_once 'L.class.php';
class English extends L{
	public function cost(Lesson $_lesson){
		return 200*$_lesson->_num;
	}
}
?>

Math.class.php:

<?php
require_once 'L.class.php';
class Math extends L{
	public function cost(Lesson $_lesson){
		return 100*$_lesson->_num;  
	}
}
?>

PS：如果要更改或者新增某個類別（文科/理科）的一個屬性只需要在對應的類檔案修改或新增；

如果要更改某個科目的一個屬性只需要更改對應的類檔案修改或新增；

總結：繼承要優於分支判斷，因為繼承降低了耦合提升了內聚，但在需求變化後或者功能不斷增加，繼承就會顯得特別臃腫。那麼組合的策略模式要優於繼承，因為他靈活，將子類的實現演算法高度內聚，降低了各個類的關聯耦合，實現了高內聚低耦合的特點；

第六種：觀察者模式：

事件產生基類 EventGenerator.class.php：

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

觀察物件基類：Observer.class.php：

<?php
interface Observer{
	public function update();
}
?>

觀察物件子類實現：Observer1.class.php：

<?php
require_once 'Observer.class.php';
class Observer1 implements Observer{
	public function update(){
		echo '邏輯改變了';
	}
}

?>

當邏輯改變時被觀察者改變：

index.php:

<?php
require_once 'EventGenerator.class.php';
require_once 'Observer1.class.php';

class Event extends EventGenerator{
	public function index(){
		echo "index";     //發生變化
		$this->notify();  //改變繫結的觀察物件
	}
}

$event = new Event();
$event->addObserver(new Observer1());   //繫結需要觀察的類
$event->index();     //index 邏輯改變了
?>

第七種：原型模式

與工廠模式不同，原型模式是先建立好一個物件，然後通過關鍵字clone來克隆新的物件，避免了類建立時重複的初始化操作，通常用於大的類的建立，建立一個大的物件需要一個很大的開銷，每次new 就會消耗很大，原型模式僅需要拷貝記憶體即可。

index.php：

<?php
class code{
	function __construct(){
		echo "code";
	}
	function index(){
		echo "index";
	}
	function __clone(){
		echo "clone"; 
	}
	// 其他操作。。。
}
$code = new code();    //code
$code2 = clone $code;  //clone
$code2->index();       //index
?>

第八種：裝飾者模式：

動態地新增類的功能，一個類提供了一項功能，如果要修改並新增額外的功能，傳統的程式設計模式：需要寫一個子類繼承他並重新實現類的方法，使用裝飾者僅需要在執行時新增一個裝飾器物件即可，實現了最大的靈活性。

裝飾器基類：Draw.class.php：

<?php
abstract class Draw{
	abstract function before();
	abstract function after();
}
?>

裝飾器子類：改變顏色

ColorDraw.class.php：

<?php
require_once 'Draw.class.php';
class ColorDraw extends Draw{
	protected $color;
	public function __construct($_color){
		$this->color = $_color;
	}
	public function before(){
		echo "<div style='color:".$this->color."'>";
	}
	public function after(){
		echo "</div>";
	}
}
?>

裝飾器子類：改變字型大小：

FontDraw.class.php：

<?php
require_once 'Draw.class.php';
class FontDraw extends Draw{
	protected $font;
	public function __construct($_font){
		$this->font = $_font;
	}
	public function before(){
		echo "<div style='font-size:".$this->font."'>";
	}
	public function after(){
		echo "</div>";
	}
}
?>

實現：index.php：

<?php
require_once 'ColorDraw.class.php';
require_once 'FontDraw.class.php';
class demo{
	private $decorator = array();  //存放裝飾器物件
	public function write($_info){
		$this->before();  //裝飾器功能實現
		echo $_info;
		$this->after();   //裝飾器功能實現
	}	
	// 新增裝飾者
	public function addDecorator(Draw $draw){
		$this->decorator[] = $draw;
	}
	// 實現裝飾者的方法
	public function before(){
		foreach ($this->decorator as $decorator) {
			$decorator->before();
		}
	}
	public function after(){
		$decorator = array_reverse($this->decorator);
		foreach ($this->decorator as $decorator) {
			$decorator->after();
		}
	}
}
$demo = new demo();
$demo->addDecorator(new ColorDraw('red'));
$demo->addDecorator(new FontDraw('22px'));
$demo->write('hello world');
?>

第九種：迭代器模式：

通過一個迭代器類對資料進行迴圈遍歷

在介面卡模式下繼續修改：

迭代器類：AllUser.class.php：

<?php
require_once 'Factory.class.php';
class AllUser implements Iterator{
	protected $ids;     //存放所有id
	protected $data = array();
	protected $index;   //索引
	public function __construct(){
		$db = Factory::createDB();
		$result = $db->select("SELECT id FROM test",PDO::FETCH_OBJ);
		$this->ids = $result->fetchAll();
	}
	public function current(){
		$db = Factory::createDB();
		$id = $this->ids[$this->index]->id;
		$result = $db->select("SELECT * FROM test WHERE id =".$id."",PDO::FETCH_OBJ);
		return $result->fetch();  //返回一個物件
	}
	public function next(){
		$this->index++;
	}
	public function valid(){
		return $this->index < count($this->ids);
	}
	public function rewind(){
		$this->index = 0;
		
	}
	public function key(){
		return $this->index;
	}
}
?>

index.php：

<?php
require_once 'Factory.class.php';
require_once 'AllUser.class.php';
$db = Factory::createDB();  //使用工廠模式呼叫單例模式得到DB類

$user = new AllUser();
foreach ($user as $key => $value) {
	echo ($value->username);  //得到所有使用者的使用者名稱
        echo ($value->id);  //得到所有使用者的id
}

?>

PS：迭代器類必須實現介面Iterator 並且實現5個方法current()，next()，valid()，rewind()，key()

第十種：代理模式：

在客戶端與實體之間建立一個代理物件proxy，客戶端對實體進行操作委託給代理物件隱藏具體的實現細節。

代理基類：Uproxy.class.php：

<?php
interface Uproxy{
	function getData($id);
}
?>

代理子類：proxy.class.php：

<?php
require_once 'Uproxy.class.php';
require_once 'Factory.class.php';
class proxy implements Uproxy{
	public function getData($id){
		$db = Factory::createDB();
		$result = $db->select("SELECT * FROM test WHERE id =".$id."",PDO::FETCH_OBJ);
		return $result->fetch();  //查詢這條記錄
	}
}
?>

index.php：

<?php
require_once 'Factory.class.php';

require_once 'proxy.class.php';
$db = Factory::createDB();   //使用工廠模式呼叫單例模式得到DB類

$proxy = new proxy();
var_dump($proxy->getData(1)); //

?>

第十一種：中介者模式

相關推薦

php 十一種設計模式

                        &nbs

php常見五種設計模式

turn pub instance blog strong utf func 創建 var php面向對象基礎知識 請點擊查看 單例模式 單例模式解決的是如何在整個項目中創建唯一對象實例的問題. (示例demo:) 1 <?php 2 //單例模式:保證某個類

二十四種設計模式、七大原則

轉自：http://www.taidous.com/thread-41942-1-3.html 程式： 1.可維護性 2.可複用性   3.可擴充套件性  4.靈活性好 通過封裝、繼承、多型把程式的耦合度降低簡單工廠模式:用一個獨立的類來做這個創造例項的過程聚合表示一種弱

Java技術_每天掌握一種設計模式（002）_使用場景及簡單例項（建立型：單例模式）

1.模式描述 一個類有且僅有一個例項，並且自行例項化並向整個系統提供。 2.模式作用 保證某個類在系統中只有一個例項物件，對於特殊需求來說非常必要。 限制了例項個數有利於GC的回收。

Java技術_每天掌握一種設計模式（006）_使用場景及簡單例項（建立型：原型模式）

1.模式描述 用原型例項指定建立物件的種類，並且通過拷貝來建立新的物件。 2.模式作用 可以一定程度上解耦，消費者和物件的構造過程隔離開，物件如何構造與消費者完全無關。 可以一定程度提升效率，複雜物件的構造往往需要較長的時間(中間可能會進行復雜運算或者資料庫

Java技術_每天掌握一種設計模式（003）_使用場景及簡單例項（建立型：工廠方法）

1.模式描述 提供一個用於建立物件的介面(工廠介面)，讓其實現類(工廠實現類)決定例項化哪一個類(產品類)，並且由該實現類建立對應類的例項。 2.模式作用 可以一定程度上解耦，消費者和

php的23種設計模式

PhpDesignPatterns 【PHP 中的設計模式】 一、 Introduction【介紹】 設計模式：提供了一種廣泛的可重用的方式來解決我們日常程式設計中常常遇見的問題。設計模式並不一定就是一個類庫或者第三方框架，它們更多的表現為一種思想並且廣泛地應用在系統中

JavaScript中常見的十五種設計模式

在程式設計中有很多實用的設計模式，而其中大部分語言的實現都是基於“類”。 在JavaScript中並沒有類這種概念，JS中的函式屬於一等物件，在JS中定義一個物件非常簡單（var obj = {}），而基於JS中閉包與弱型別等特性，在實現一些設計模式的方式上與眾不同。 本

SOA只不過是一種設計模式而已

文章中以麥當勞的服務系統舉例，稱之為“以人力為基礎的面向服務的架構(a human-based SOA)”，非常有意思。大家都知道在國外，你可以駕著車享受麥當勞的服務。不用離開車，首先你開到一個卡通人前對對講機說出你要幾號套餐，然後向前開到下一個視窗付款並拿你的食物。這個簡單的系統基本上包含了兩個服務：接受訂

為什麼MVC不是一種設計模式？ ---比較Backbone和Ext4.x在MVC實現上的差異

為什麼MVC不是一種設計模式？ ---比較Backbone和Ext4.x在MVC實現上的差異 轉載：http://damoqiongqiu.iteye.com/blog/1949256 大漠窮秋 前言 聖人云：不想做媽咪的小姐不是好碼農。 每一個碼

Mybaits 原始碼解析 （十一）----- 設計模式精妙使用：靜態代理和動態代理結合使用：@MapperScan將Mapper介面生成代理注入到Spring

上一篇文章我們講了SqlSessionFactoryBean，通過這個FactoryBean建立SqlSessionFactory並註冊進Spring容器，這篇文章我們就講剩下的部分，通過MapperScannerConfigurer將Mapper介面生成代理注入到Spring 掃描Mapper介面 我們上一

Java經典設計模式之十一種行為型模式（附例項和詳解）

Java經典設計模式共有21中，分為三大類：建立型模式（5種）、結構型模式（7種）和行為型模式（11種）。 行為型模式細分為如下11種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯

23種設計模式介紹（一）---- 創建型模式

接口 ret static 深復制 return 對象 相互 object c png 由於設計模式篇幅比較大，如果在一篇文章講完所有的設計模式的話不利於閱讀。於是我把它分為三篇文章 23種設計模式介紹（一）---- 創建型模式 23種設計模式介紹（二）---- 結構型模

設計模式（十一）——生成器模式

所有 boolean concrete @override ttr stat bsp println 無需 1.描述 將一組復雜對象的構建與他的表示相分離，使同樣的構建過程可以創建不同的表示。 2.模式的使用 ·產品(Product)：具體生成器要構造的復雜對象。 ·抽象生

C#設計模式之十一享元模式（Flyweight Pattern）【結構型】

eal 客戶 來看 滿足 對象狀態 英文 輔助 3.3 fig 原文:C#設計模式之十一享元模式（Flyweight Pattern）【結構型】一、引言 今天我們要講【結構型】設計模式的第六個模式，該模式是【享元模式】，英文名稱是：Flyweight Pattern。還

PHP常用的三種設計模式

寫代碼 comment 獲得 return interface 高級 對象 檢測 mys 本文為大家介紹常用的三種php設計模式：單例模式、工廠模式、觀察者模式，有需要的朋友可以參考下。 一、首先來看，單例模式 所謂單例模式，就是確保某個類只有一個實例，而且自行實例化並向整

java 常用十種設計模式示例歸納 | 已打包請帶走

java 設計模式 程序員 程序人生 互聯網 設計模式（Design pattern）是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。 GitHub地址DesignPattern 文章說明一個Demo，集合常用的十種設計模式，每個模式使用易被人們接受的案例講述，按模式分

常用的三種設計模式 PHP代碼

static bsp urn php代碼 ati for val pri single 　　 // 工廠模式 interface Iuser { public function getUserName(); } class UserFactory {

設計模式（二十一）—— 狀態模式

uml public bubuko interface 對象 con 原理 處理 環境 模式簡介 允許一個對象在其內部狀態改變時改變它的行為。對象看起來似乎修改了它的類。 在某些情況下，一個對象的行為取決於它當前所處的狀態，當對象屬性(狀態)在系統運行過程中發生變化，

設計模式 (二十一）直譯器模式

直譯器模式 直譯器模式的場景就是一個計算器，計算簡單的+,-運算，a+b-c， a-b+c這種，給出a,b,c的值，計算表示式結果。需要設計一個表示式分析。 直譯器是一種按照規定語法進行解析的方案，在現在專案中使用極少。 直譯器模式的優點 擴充套件性較好