深入分析PHP设计模式

这篇文章主要介绍了PHP设计模式的相关知识,文中讲解非常细致,代码帮助大家更好的理解学习,感兴趣的朋友可以参考下。

1、单例模式

一个类,只能允许有一个对象存在

  1. <?php
  2. class test{
  3. protected function __construct(){
  4. }
  5. public static function getInstance(){
  6. $_test = new test();
  7. return $_test;
  8. }
  9. }
  10. $test = test::getInstance();
  11. var_dump($test);
  12. ?>

2、工厂模式

工厂模式,顾名思义,如同工厂一样,你把原材料放入工厂中,出来的是成品,而你并不需要知道工厂里做了什么,工厂模式主要用于解耦。

把对象的创建和使用的过程分开,比如: ClassA 调用 ClassB,那么 ClassA 只调用ClassB 的方法,至于实例化 ClassB 则在工厂内实现。这样既减少了代码的重复使用,也方便对 ClassB 的后期维护。

如果 ClassB 实例化过程很复杂,使用简单工厂模式就会发现外部无需关注复杂的实例化,只管调用 ClassB 的方法即可,减少错误

  1. interface mysql{
  2. public function connect();
  3. }
  4. class mysqli2 implements mysql{
  5. public function connect(){
  6. echo 'mysqli';
  7. }
  8. }
  9. class pdo2 implements mysql{
  10. public function connect(){
  11. echo 'pdo';
  12. }
  13. }
  14. class mysqlFactory{
  15. static public function factory($class_name){
  16. return new $class_name();
  17. }
  18. }
  19. $obj = mysqlFactory::factory('pdo2');
  20. $obj->connect();

3、注册模式

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

  1. <?php
  2. class Register
  3. {
  4. protected static $objects;
  5. function set($alias,$object)//将对象注册到全局的树上
  6. {
  7. self::$objects[$alias]=$object;//将对象放到树上
  8. }
  9. static function get($name){
  10. return self::$objects[$name];//获取某个注册到树上的对象
  11. }
  12. function _unset($alias)
  13.   {
  14. unset(self::$objects[$alias]);//移除某个注册到树上的对象。
  15. }
  16. }
  17. \Auto\Register::set('single',$single);
  18. $single = \Auto\Register::get('single');
  19. var_dump($single);

4、适配器模式

将一个类的接口转换成客户希望的另外一个接口。

  1. //目标角色
  2. interface Aims
  3. {
  4. public function newMethod1();
  5. public function newMethod2();
  6. }
  7. //需要被适配的类(Adaptee)
  8. Class Man
  9. {
  10. public function oldMethod1()
  11. {
  12. echo 'man';
  13. }
  14. public function oldMethod2()
  15. {
  16. echo '男人';
  17. }
  18. }
  19. //需要被适配的类(Adaptee)
  20. Class Woman
  21. {
  22. public function oldMethod1()
  23. {
  24. echo 'woman';
  25. }
  26. public function oldMethod2()
  27. {
  28. echo '女人';
  29. }
  30. }
  31. //适配器,
  32. Class Adapters implements Aims
  33. {
  34. private $adaptee;
  35. public function __construct($adaptee)
  36. {
  37. $this->adaptee = $adaptee;
  38. }
  39. public function newMethod1()
  40. {
  41. //以少量的代码对被适配者作出适配
  42. echo 'sex :';
  43. $this->adaptee->oldMethod1();
  44. }
  45. public function newMethod2()
  46. {
  47. echo 'sex name :';
  48. $this->adaptee->oldMethod2();
  49. }
  50. }
  51. $adapter1 = new Adapters(new Man);
  52. $adapter1->newMethod1();
  53. $adapter2 = new Adapters(new Woman);
  54. $adapter2->newMethod2();

5、策略模式

这是一个男人和女人的问题,将一组特定的行为和算法封装成类,以适应某些特定的上下文环境。

UserStrategy.php

  1. <?php
  2. /*
  3. * 声明策略文件的接口,约定策略包含的行为。
  4. */
  5. interface UserStrategy
  6. {
  7. function showAd();
  8. function showCategory();
  9. }
  10. FemaleUser.php
  11. <?php
  12. class FemaleUser implements UserStrategy
  13. {
  14. function showAd(){
  15. echo "2016冬季女装";
  16. }
  17. function showCategory(){
  18. echo "女装";
  19. }
  20. }
  21. MaleUser.php
  22. <?php
  23. class MaleUser implements UserStrategy
  24. {
  25. function showAd(){
  26. echo "IPhone6s";
  27. }
  28. function showCategory(){
  29. echo "电子产品";
  30. }
  31. }
  32. Page.php//执行文件
  33. <?php
  34. require_once 'Loader.php';
  35. class Page
  36. {
  37. protected $strategy;
  38. function index(){
  39. echo "AD";
  40. $this->strategy->showAd();
  41. echo "<br>";
  42. echo "Category";
  43. $this->strategy->showCategory();
  44. echo "<br>";
  45. }
  46. function setStrategy(UserStrategy $strategy){
  47. $this->strategy=$strategy;
  48. }
  49. }
  50. $page = new Page();
  51. if(isset($_GET['male'])){
  52. $strategy = new MaleUser();
  53. }else {
  54. $strategy = new FemaleUser();
  55. }
  56. $page->setStrategy($strategy);
  57. $page->index();

6、原型模式

不常用,大的对象类才使用,表现在clone

7、观察者模式

从面向过程的角度来看,首先是观察者向主题注册,注册完之后,主题再通知观察者做出相应的操作,整个事情就完了。

  1. /**
  2. * 事件产生类
  3. * Class EventGenerator
  4. */
  5. abstract class EventGenerator
  6. {
  7. private $ObServers = [];
  8. //增加观察者
  9. public function add(ObServer $ObServer)
  10. {
  11. $this->ObServers[] = $ObServer;
  12. }
  13. //事件通知
  14. public function notify()
  15. {
  16. foreach ($this->ObServers as $ObServer) {
  17. $ObServer->update();
  18. }
  19. }
  20. }
  21. /**
  22. * 观察者接口类
  23. * Interface ObServer
  24. */
  25. interface ObServer
  26. {
  27. public function update($event_info = null);
  28. }
  29. /**
  30. * 观察者1
  31. */
  32. class ObServer1 implements ObServer
  33. {
  34. public function update($event_info = null)
  35. {
  36. echo "观察者1 收到执行通知 执行完毕!\n";
  37. }
  38. }
  39. /**
  40. * 观察者1
  41. */
  42. class ObServer2 implements ObServer
  43. {
  44. public function update($event_info = null)
  45. {
  46. echo "观察者2 收到执行通知 执行完毕!\n";
  47. }
  48. }
  49. /**
  50. * 事件
  51. * Class Event
  52. */
  53. class Event extends EventGenerator
  54. {
  55. /**
  56. * 触发事件
  57. */
  58. public function trigger()
  59. {
  60. //通知观察者
  61. $this->notify();
  62. }
  63. }
  64. //创建一个事件
  65. $event = new Event();
  66. //为事件增加旁观者
  67. $event->add(new ObServer1());
  68. $event->add(new ObServer2());
  69. //执行事件 通知旁观者
  70. $event->trigger();