php设计模式(四)：行为型模式

  1     /**
  2      *
  3      * 模板方法模式 Template
  4      *
  5      */
  6          
  7     function output($string) {
  8         echo    $string . "n";
  9     }
 10          
 11     class Request {
 12          
 13         public $token = ‘‘;
 14          
 15         public function __construct() {
 16             $this->token    = ‘0c6b7289f5334ed2b697dd461eaf9812‘;
 17         }
 18          
 19     }
 20          
 21     class Response {
 22          
 23         public function render($content) {
 24             output(sprintf(‘response-render: %s‘, $content));
 25         }
 26          
 27         public function redirect($uri) {
 28             output(sprintf(‘response-redirect: %s‘, $uri));
 29         }
 30          
 31         public function json($data) {
 32             output(sprintf(‘response-data: %s‘, json_encode($data)));
 33         }
 34          
 35     }
 36          
 37      //父类，抽象类
 38     abstract class Controller{
 39         //封装了输入输出
 40         protected $request;
 41         protected $response;
 42          
 43         //返回数据
 44         protected $data = ‘data‘;
 45          
 46         public function __construct($request, $response){
 47             $this->request = $request;
 48             $this->response = $response;
 49         }
 50          
 51         //执行请求函数，定义总体算法（template method），final防止被复写（不允许子类改变总体算法）
 52         public final function execute(){
 53             $this->before();
 54             if ($this->valid()){
 55                 $this->handleRequest();
 56             }
 57             $this->after();
 58         }
 59          
 60         //定义hook method before，做一些具体请求的前置处理
 61         //非abstract方法，子类可以选择覆盖或不覆盖，默认什么都不做
 62         protected function before(){
 63          
 64         }
 65          
 66         //定义hook method valid，做请求的数据验证
 67         //非abstract方法，子类可以选择覆盖或不覆盖，默认返回验证通过
 68         protected function valid(){
 69             return true;
 70         }
 71          
 72         //定义hook method handleRequest，处理请求
 73         //定义为abstract方法，子类必须实现或也声明为抽象方法(由子类的子类负责实现)
 74         abstract function handleRequest();
 75          
 76         //定义hook method after，做一些请求的后置处理
 77         //非abstract方法，子类可以选择覆盖或不覆盖，默认直接输出数据
 78         protected function after(){
 79             $this->response->render($this->data);
 80         }
 81     }
 82          
 83     //子类1，实现父类开放的具体算法
 84     class User extends Controller{
 85         //覆盖before方法，实现具体算法，这是一个处理用户数据操作的控制器
 86         //因此，我们选择在before里面判断用户是否已经登录了，这里简单判断下session数据
 87         function before(){
 88             if (empty($_SESSION[‘auth‘])){
 89                 //没登录就直接跳转了，不再执行后续的操作
 90                 $this->response->redirect("user/login.php");
 91             }
 92         }
 93          
 94         //覆盖valid方法，这里我们验证用户提交数据中有没有带验证token
 95         function valid(){
 96             if (isset($this->request->token)){
 97                 return true;
 98             }
 99             return false;
100         }
101          
102         //覆盖handleRequest方法，必选，以为父类中声明了abstract了
103         function handleRequest(){
104             //做具体处理，一般根据参数执行不同的业务逻辑
105         }
106          
107         //这个类我们选择不覆盖after方法，使用默认处理方式
108     }
109          
110     //子类2，实现父类开放的具体算法
111     class Post extends Controller{
112         //这个类我们选择不覆盖before方法，使用默认处理方式
113          
114         //这个类我们选择不覆盖valid方法，使用默认处理方式
115          
116         //覆盖handleRequest方法，必选，以为父类中声明了abstract了
117         function handleRequest(){
118             //做具体处理，一般根据参数执行不同的业务逻辑
119             $this->data = array(‘title‘ => ‘ucai‘);
120         }
121          
122         //覆盖after方法，使用json格式输出数据
123         function after(){
124             $this->response->json($this->data);
125         }
126     }
127          
128          
129          
130     class Client {  
131                
132         public static function test(){  
133          
134             $request        = new Request();
135             $response       = new Response();
136          
137             //最终调用
138             $user = new User($request, $response);
139             $user->execute();
140          
141          
142             //最终调用
143             $post = new Post($request, $response);
144             $post->execute();
145          
146         }  
147                
148     }  
149            
150     Client::test();

  1     /**
  2      *
  3      * 命令模式 Command
  4      *
  5      */
  6           
  7     function output($string) {
  8         echo    $string . "n";
  9     }
 10           
 11     class Document {
 12           
 13         private $name = ‘‘;
 14           
 15         public function __construct($name) {
 16             $this->name = $name;
 17         }
 18           
 19         public function showText() {
 20             output(sprintf("showText: %s", $this->name));
 21         }
 22           
 23         public function undo() {
 24             output(sprintf("undo-showText: %s", $this->name));
 25         }
 26           
 27     }
 28           
 29     class Graphics {
 30           
 31         private $name = ‘‘;
 32           
 33         public function __construct($name) {
 34             $this->name = $name;
 35         }
 36           
 37         public function drawCircle() {
 38             output(sprintf("drawCircle: %s", $this->name));
 39         }
 40           
 41         public function undo() {
 42             output(sprintf("undo-drawCircle: %s", $this->name));
 43         }
 44           
 45     }
 46           
 47     class Client {
 48               
 49         public static function test() {
 50           
 51             $document       = new Document(‘A‘);
 52             $graphics       = new Graphics(‘B‘);
 53           
 54             $document->showText();
 55             $graphics->drawCircle();
 56           
 57             $document->undo();
 58           
 59         }
 60           
 61     }
 62           
 63     Client::test();
 64           
 65           
 66     <?php
 67           
 68     /*
 69     *
 70      * 命令模式 Command
 71      *
 72      */
 73           
 74     function output($string) {
 75         echo    $string . "n";
 76     }
 77           
 78     interface Command {
 79         public function execute();
 80         public function undo();
 81     }
 82           
 83     class Document implements Command {
 84           
 85         private $name = ‘‘;
 86           
 87         public function __construct($name) {
 88             $this->name = $name;
 89         }
 90           
 91         public function execute() {
 92             output(sprintf("showText: %s", $this->name));
 93         }
 94           
 95         public function undo() {
 96             output(sprintf("undo-showText: %s", $this->name));
 97         }
 98           
 99     }
100           
101     class Graphics implements Command {
102           
103         private $name = ‘‘;
104           
105         public function __construct($name) {
106             $this->name = $name;
107         }
108           
109         public function execute() {
110             output(sprintf("drawCircle: %s", $this->name));
111         }
112           
113         public function undo() {
114             output(sprintf("undo-drawCircle: %s", $this->name));
115         }
116           
117     }
118           
119     class Client {
120               
121         public static function test() {
122           
123             $array          = array();
124           
125             array_push($array, new Document(‘A‘));
126             array_push($array, new Document(‘B‘));
127             array_push($array, new Graphics(‘C‘));
128             array_push($array, new Graphics(‘D‘));
129                   
130             foreach ($array as $command) {
131                 $command->execute();
132             }
133           
134             $top            = array_pop($array);
135             $top->undo();
136           
137         }
138           
139     }
140           
141     Client::test();
142           
143           
144     <?php
145           
146     /**
147      *
148      * 命令模式 Command
149      *
150      */
151           
152     function output($string) {
153         echo    $string . "n";
154     }
155           
156     interface Command {
157         public function execute();
158         public function undo();
159     }
160           
161     class Document {
162           
163         private $name = ‘‘;
164           
165         public function __construct($name) {
166             $this->name = $name;
167         }
168           
169         public function showText() {
170             output(sprintf("showText: %s", $this->name));
171         }
172           
173         public function undo() {
174             output(sprintf("undo-showText: %s", $this->name));
175         }
176           
177     }
178           
179     class Graphics {
180           
181         private $name = ‘‘;
182           
183         public function __construct($name) {
184             $this->name = $name;
185         }
186           
187         public function drawCircle() {
188             output(sprintf("drawCircle: %s", $this->name));
189         }
190           
191         public function undo() {
192             output(sprintf("undo-drawCircle: %s", $this->name));
193         }
194           
195     }
196           
197     class DocumentCommand implements Command {
198           
199         private $obj = ‘‘;
200           
201         public function __construct(Document $document) {
202             $this->obj = $document;
203         }
204           
205         public function execute() {
206             $this->obj->showText();
207         }
208           
209         public function undo() {
210             $this->obj->undo();
211         }
212           
213     }
214           
215     class GraphicsCommand implements Command {
216           
217         private $obj = ‘‘;
218           
219         public function __construct(Graphics $graphics) {
220             $this->obj = $graphics;
221         }
222           
223         public function execute() {
224             $this->obj->drawCircle();
225         }
226           
227         public function undo() {
228             $this->obj->undo();
229         }
230           
231     }
232           
233           
234     class Client {
235               
236         public static function test() {
237           
238             $array          = array();
239           
240             array_push($array, new DocumentCommand(new Document(‘A‘)));
241             array_push($array, new DocumentCommand(new Document(‘B‘)));
242             array_push($array, new GraphicsCommand(new Graphics(‘C‘)));
243             array_push($array, new GraphicsCommand(new Graphics(‘D‘)));
244                   
245             foreach ($array as $command) {
246                 $command->execute();
247             }
248           
249             $top            = array_pop($array);
250             $top->undo();
251           
252         }
253           
254     }
255           
256     Client::test();

  1     /**
  2      *
  3      * 迭代器模式 Iterator
  4      *
  5      */
  6           
  7     function output($string) {
  8         echo    $string . "n";
  9     }
 10           
 11     class RecordIterator implements Iterator{
 12           
 13         private $position = 0;
 14           
 15         //注意：被迭代对象属性是私有的
 16         private $records = array();  
 17           
 18         public function __construct(Array $records) {
 19             $this->position = 0;
 20             $this->records = $records;
 21         }
 22           
 23         function rewind() {
 24             $this->position = 0;
 25         }
 26           
 27         function current() {
 28             return $this->records[$this->position];
 29         }
 30           
 31         function key() {
 32             return $this->position;
 33         }
 34           
 35         function next() {
 36             ++$this->position;
 37         }
 38           
 39         function valid() {
 40             return isset($this->records[$this->position]);
 41         }
 42     }
 43           
 44     class PostListPager {
 45           
 46         protected $record   = array();
 47         protected $total    = 0;
 48         protected $page     = 0;
 49         protected $size     = 0;
 50           
 51         public function __construct($category, $page, $size) {
 52           
 53             $this->page     = $page;
 54             $this->size     = $size;
 55           
 56             // query db
 57           
 58             $total          = 28;
 59             $this->total    = $total;
 60           
 61             $record     = array(
 62                             0 => array(‘id‘ => ‘1‘),
 63                             1 => array(‘id‘ => ‘2‘),
 64                             2 => array(‘id‘ => ‘3‘),
 65                             3 => array(‘id‘ => ‘4‘),
 66                         );
 67           
 68             //
 69             $this->record   = $record;
 70           
 71         }
 72           
 73         public function getIterator() {
 74             return  new RecordIterator($this->record);
 75         }
 76           
 77         public function getMaxPage() {
 78             $max    = intval($this->total / $this->size);
 79             return  $max;
 80         }
 81           
 82         public function getPrevPage() {
 83             return  max($this->page - 1, 1);
 84         }
 85           
 86         public function getNextPage() {
 87             return  min($this->page + 1, $this->getMaxPage());
 88         }
 89           
 90     }
 91           
 92     class Client {  
 93                 
 94         public static function test(){  
 95           
 96             $pager      = new PostListPager(1, 2, 4);
 97           
 98             foreach ($pager->getIterator() as $key => $val) {
 99                 output(sprintf(‘Key[%d],Val[%s]‘, $key, json_encode($val)));
100             }
101           
102             output(sprintf(‘MaxPage[%d]‘, $pager->getMaxPage()));
103             output(sprintf(‘Prev[%d]‘, $pager->getPrevPage()));
104             output(sprintf(‘Next[%d]‘, $pager->getNextPage()));
105           
106             $iterator       = $pager->getIterator();
107             while($iterator->valid()){
108                 print_r($iterator->current());
109                 $iterator->next();
110             }
111             $iterator->rewind();
112           
113         }  
114                 
115     }  
116             
117     Client::test();

  1     /**
  2      *
  3      * 观察者模式 Observer
  4      *
  5      */
  6           
  7     function output($string) {
  8         echo    $string . "n";
  9     }
 10           
 11           
 12     //订单数据对象简单模拟，这个是实际需要被观察的对象(Subject)，但是我们将其独立，然后
 13     //通过构造方法传入到我们模式中的Subject中，这样使具体业务更加独立
 14     class Order{
 15         //订单号
 16         private $id = ‘‘;
 17           
 18         //用户ID
 19         private $userId = ‘‘;
 20           
 21         //用户名
 22         private $userName = ‘‘;
 23           
 24         //价格
 25         private $price = ‘‘;
 26           
 27         //下单时间
 28         private $orderTime = ‘‘;
 29           
 30         //订单数据填充简单模拟，实际应用中可能会读取用户表单输入并处理
 31         public function __set($name, $value){
 32             if (isset($this->$name)){
 33                 $this->$name = $value;
 34             }
 35         }
 36           
 37         //获取订单属性
 38         public function __get($name){
 39             if (isset($this->$name)){
 40                 return $this->$name;
 41             }
 42             return "";
 43         }
 44     }
 45           
 46     //假设的DB类，便于测试，实际会存入真实数据库
 47     class FakeDB{
 48         public function save($data){
 49             return true;
 50         }
 51     }
 52           
 53           
 54     class Client {
 55               
 56         public static function test() {
 57           
 58             //初始化一个订单数据
 59             $order = new Order();
 60             $order->id = 1001;
 61             $order->userId = 9527;
 62             $order->userName = "God";
 63             $order->price = 20.0;
 64             $order->orderTime = time();
 65           
 66             //向数据库保存订单
 67             $db = new FakeDB();
 68             $result = $db->save($order);
 69             if ($result){
 70           
 71                 //实际应用可能会写到日志文件中，这里直接输出
 72                 output( "[OrderId:{$order->id}] [UseId:{$order->userId}] [Price:{$order->price}]" );
 73           
 74                 //实际应用会调用邮件发送服务如sendmail，这里直接输出
 75                 output( "Dear {$order->userName}: Your order {$order->id} was confirmed!" );
 76           
 77                 //实际应用会调用邮件发送服务如sendmail，这里直接输出
 78                 output( "Dear Manager: User {$order->userName}(ID:{$order->userId}) submitted a new order {$order->id}, please handle it ASAP!" );
 79           
 80             }
 81           
 82         }
 83           
 84     }
 85           
 86     Client::test();
 87           
 88           
 89     <?php
 90           
 91     /**
 92      *
 93      * 观察者模式 Observer
 94      *
 95      */
 96           
 97     function output($string) {
 98         echo    $string . "n";
 99     }
100           
101           
102     //订单数据对象简单模拟，这个是实际需要被观察的对象(Subject)，但是我们将其独立，然后
103     //通过构造方法传入到我们模式中的Subject中，这样使具体业务更加独立
104     class Order{
105         //订单号
106         private $id = ‘‘;
107           
108         //用户ID
109         private $userId = ‘‘;
110           
111         //用户名
112         private $userName = ‘‘;
113           
114         //价格
115         private $price = ‘‘;
116           
117         //下单时间
118         private $orderTime = ‘‘;
119           
120         //订单数据填充简单模拟，实际应用中可能会读取用户表单输入并处理
121         public function __set($name, $value){
122             if (isset($this->$name)){
123                 $this->$name = $value;
124             }
125         }
126           
127         //获取订单属性
128         public function __get($name){
129             if (isset($this->$name)){
130                 return $this->$name;
131             }
132             return "";
133         }
134     }
135           
136     //被观察者, 负责维护观察者并在变化发生是通知观察者
137     class OrderSubject implements SplSubject {
138         private $observers;
139         private $order;
140           
141         public function __construct(Order $order) {
142             $this->observers = new SplObjectStorage();
143             $this->order = $order;
144         }
145           
146         //增加一个观察者
147         public function attach(SplObserver $observer) {
148             $this->observers->attach($observer);
149         }
150           
151         //移除一个观察者
152         public function detach(SplObserver $observer) {
153             $this->observers->detach($observer);
154         }
155           
156         //通知所有观察者
157         public function notify() {
158             foreach ($this->observers as $observer) {
159                 $observer->update($this);
160             }
161         }
162           
163         //返回主体对象的具体实现，供观察者调用
164         public function getOrder() {
165             return $this->order;
166         }
167     }
168           
169     //记录业务数据日志 (ActionLogObserver)，实际可能还要抽象一层以处理不同的Action(业务操作)，这里省略
170     class ActionLogObserver implements SplObserver{
171         public function update(SplSubject $subject) {
172              $order = $subject->getOrder();
173              //实际应用可能会写到日志文件中，这里直接输出
174              output( "[OrderId:{$order->id}] [UseId:{$order->userId}] [Price:{$order->price}]" );
175         }
176     }
177           
178     //给用户发送订单确认邮件 (UserMailObserver)
179     class UserMailObserver implements SplObserver{
180         public function update(SplSubject $subject) {
181              $order = $subject->getOrder();
182              //实际应用会调用邮件发送服务如sendmail，这里直接输出
183              output( "Dear {$order->userName}: Your order {$order->id} was confirmed!" );
184         }
185     }
186           
187     //给管理人员发订单处理通知邮件 (AdminMailObserver)
188     class AdminMailObserver implements SplObserver{
189         public function update(SplSubject $subject) {
190              $order = $subject->getOrder();
191              //实际应用会调用邮件发送服务如sendmail，这里直接输出
192              output( "Dear Manager: User {$order->userName}(ID:{$order->userId}) submitted a new order {$order->id}, please handle it ASAP!" );
193         }
194     }
195           
196     //假设的DB类，便于测试，实际会存入真实数据库
197     class FakeDB{
198         public function save($data){
199             return true;
200         }
201     }
202           
203           
204     class Client {
205               
206         public static function test() {
207           
208             //初始化一个订单数据
209             $order = new Order();
210             $order->id = 1001;
211             $order->userId = 9527;
212             $order->userName = "God";
213             $order->price = 20.0;
214             $order->orderTime = time();
215           
216             //绑定观察者
217             $subject = new OrderSubject($order);
218             $actionLogObserver = new ActionLogObserver();
219             $userMailObserver = new UserMailObserver();
220             $adminMailObserver = new AdminMailObserver();
221             $subject->attach($actionLogObserver);
222             $subject->attach($userMailObserver);
223             $subject->attach($adminMailObserver);
224             //向数据库保存订单
225             $db = new FakeDB();
226             $result = $db->save($order);
227             if ($result){
228                 //通知观察者
229                 $subject->notify();
230             }
231           
232         }
233           
234     }
235           
236     Client::test();