设计模式--注册模式

最新推荐文章于 2022-03-08 21:02:56 发布
最新推荐文章于 2022-03-08 21:02:56 发布
阅读量1.3k 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 function class 测试 php 数据库

注册表的作用是提供系统级别的对象访问功能。有的同学会说，这样是多此一举，不过小项目中的确没有必要对类进行注册，如果是大项目，还是非常有用的。


<?php 
//基础类 
class webSite {//一个非常简单的基础类
	 
	private $siteName; 
	private $siteUrl;
	
	function __construct($siteName,$siteUrl){ 
		$this->siteName=$siteName; 
		$this->siteUrl=$siteUrl; 
	} 
	
	function getName(){ 
		return $this->siteName; 
	}
	 
	function getUrl(){ 
		return $this->siteUrl; 
	} 
}

class registry {//注册表类 单例模式
	 
	private static $instance;
	private $values = array();//用数组存放类名称、注册表的内容类
	 
	private function __construct(){}//这个用法决定了这个类不能直接实例化 
	
	static function instance(){
		if (!isset(self::$instance)) {self::$instance=new self();} 
		return self::$instance; 
	} 
	function get($key) {//获取已经注册了的类 
		if (isset($this->values[$key])){ 
			return $this->values[$key]; 
		} 
		return null; 
	}
	
	function set($key,$value){//注册类方法 
		$this->values[$key]=$value; 
	} 
}

$reg=registry::instance();
 
$reg->set("website",new webSite("WEB开发笔记","www.chhua.com"));//对类进行注册 

$website=$reg->get("website");//获取类 
echo $website->getName();//输出WEB开发笔记 
echo $website->getUrl();//输出www.chhua.com 
?>

我们通常认为避免使用全局变量是一种好的选择,因此，对象经常被作为参数从一段代码传递到另一段。但是传递实例的一个问题就是对象有时候不知道将要传递给谁——?经过一个函数后才被传递到真正需要这个对象的函数。

为了编写，阅读，修改代码的方便，最好能够减少不同对象的数量，并且能够将大量广泛使用的对象统一表示为一个单一,常用的对象。

问题：

你如何通过单一的全局的对象来获取对其它对象的引用？

解决方案：

“注册模式”就像“对象的电话簿”——储存并且能够取回对对象引用的登记簿。（注：PHP中的“联合数组”也起到了类似“电话簿”的功能。事实上，“注册模式”就是围绕PHP中强大的数组完成的。）“注册模式”的一些特性经常被包含在“单一模式”中（参见第四章），使得“注册模式”成为你整个应用信息的决定性来源。

 

注释：“注册模式”类主要参考了Martin Fowlerdescribes用java语言实现的Patterns of Enterprise Application Architecture（企业应用程序体系结构模型）。Marcus Baker谢了一篇详细的PHP中应用“注册模式”的文章。该文章可在PHPPatterns.com的站点获的

（http://www.PHPpatterns.com/index.PHP/article/articleview/75/1/1/）。Baker也涉及了一些测试considerations，示范了测试驱动的开发方法。

 

样本代码：

正如Martin Flower在他的“注册模式”一文中提及的样本代码所示，你可以用各种方法，提供各种接口实现“注册模式”。让我们仔细探究这种想法，并建立PHP4中的“注册模式”的一些不同实现。

让我们以编写能储存并恢复对象实例并能对“注册模式”提供全局访问的代码开始。这个类的实例变量能够缓存对象，并且“注册模式”本身是一个“单一模式”。像以前一样，测试决定需求。我们的第一个测试要确定“注册模式”是一个“单件模式”类。

// PHP4
class RegistryPHP4TestCase extends UnitTestCase {
function testRegistryIsSingleton() {
$this->assertIsA($reg =& Registry::getInstance(), ‘Registry’);
$this->assertReference($reg, Registry::getInstance());
}
}

这里，要把你在以前几章“单件模式”中学到的知识用上，你应该能够很快写出能够通过该测试的类。以下是一个满足测试要求的“注册模式”类(ignoring the code required to enforce no direct object creation):

class Registry {
function &getInstance() {
static $instance = array();
if (!$instance) $instance[0] =& new Registry;
return $instance[0];
}
}

一个简单的静态数组就足够记录这个单一实例了。

接下来，让我们转到“注册模式”独特的特性上面。一个“注册模式”应该提供get() 和set()方法来存储和取得对象（用一些属性key）而且也应该提供一个isValid()方法来确定一个给定的属性是否已经设置。

这三个方法的一个简单实现在接下来讨论。这里是两个isValid():方法的测试方法。

代码：

class RegistryPHP4TestCase extends UnitTestCase
{function testRegistryIsSingleton() { /*...*/ }
function testEmptyRegistryKeyIsInvalid() 
{$reg =& Registry::getInstance()
$this->assertFalse($reg->isValid('key'));
}
function testEmptyRegistryKeyReturnsNull() 
{$reg =& Registry::getInstance();
$this->assertNull($reg->get('key'));
}
}

 

作者注：assertFalse()

assertFalse()仅仅是assertTrue()的反面，如果第一个参数预期是PHP中的布尔值false，测试通过。

通过基于测试驱动的开发方式，你可以编写尽可能少的代码来符合你现阶段的测试需求，你也可以增加测试——如果你还未满足这个类的需求。

以下为满足前述测试要求的最简单的代码：

 代码：

class Registry 
{function isValid() {return false;}
function get() {}
function &getInstance() 
{static $instance = array();
if (!$instance) $instance[0] =& new Registry;
return $instance[0];
}
}


确实，isValid() 和 get()方法的代码片断并不是非常好，但是所有的测试通过了！下面我们添加更丰富的测试用例。

 代码：

class RegistryPHP4TestCase extends UnitTestCase 
{function testRegistryIsSingleton() { /*...*/ }
function testEmptyRegistryKeyIsInvalid() { /*...*/ }
function testEmptyRegistryKeyReturnsNull() { /*...*/ }
function testSetRegistryKeyBecomesValid() 
{$reg =& Registry::getInstance();
$test_value = 'something';$reg->set('key', $test_value);
$this->assertTrue($reg->isValid('key'));
}
}


为了满足testSetRegistryKeyBecomesValid()方法，“注册模式”类必须要有追踪（tracking）的功能——如果特定的属性用set()方法设置了。 很明显的一种实现方式是利用PHP4中的联合数组作为实例变量，并利用PHP的array_key_exists()函数来检测我们想要的索引是否被创建了。

下面是“注册模式类”更进一步的实现。

代码：

class Registry {var $_store = array();
function isValid($key) 
{return array_key_exists($key, $this->_store);}
function set($key, $obj)
{$this->_store[$key] = $obj;
function get() {}
function &getInstance() 
{static $instance = array()
if (!$instance) $instance[0] =& new Registry;
return $instance[0];
}
}


通过在声明时初始化$_store变量，就没有设置构造函数的必要了。（注：在PHP4中没有适当的访问控制标记，以下代码遵循私有变量以下划线作前缀的约定）



测试又通过了！现在我们想最终特性进发：给定一个属性key，注册模式类的get()方法将返回一个对特定对象的引用。一下为符合这一要求的测试用例。

  代码：

class RegistryPHP4TestCase extends UnitTestCase 
{function testRegistryIsSingleton() { /*...*/ }
function testEmptyRegistryKeyIsInvalid() { /*...*/ }
function testEmptyRegistryKeyReturnsNull() { /*...*/ }
function testSetRegistryKeyBecomesValid() { /*...*/ }
function testSetRegistryValueIsReference()
{$reg =& Registry::getInstance();$test_value =  'something';
$reg->set('key', $test_value);
$this->assertReference($test_value, $reg->get('key'));
//another way to test the reference
$test_value  .= ' else';
$this->assertEquual('something else',$reg->get('key'));
}
}

以下为注册模式类的完整实现代码。

  代码：

class Registry
{var $_store = array();
function isValid($key) 
{return array_key_exists($key, $this->_store);}
function &get($key) 
{if (array_key_exists($key, $this->_store)) 
return $this->_store[$key];}
function set($key, &$obj) 
{$this->_store[$key] =& $obj;}
function &getInstance()
{static $instance = array();
if (!$instance) $instance[0] =& new Registry;
return $instance[0];
}
}

 “注册模式”的get()方法会返回一个对象引用。类似的，set()方法的$obj参数要求得到一个对象引用并被赋值$this->_store[$key].。get()和set()方法的联合恰当使用能够满足assertReference()测试。

作者注：

“注册模式”的get（）Registry::get()方法的代码应该写成@$this->_store[$key;]的形式，但是最好避免使用错误抑制符，使用错误抑制符的代码会变的摸棱两可，你需要花费额外的时间去了解你是否会再次访问这段代码。array_key_exists()方法指出了应该避免的错误。

PHP5中，对象句柄（引用）带来了革命性的变化——你可以从对象引用的困境中解脱出来。事实上PHP5中注册模式的实现变的简单多了。因为你再也不用担心因为没有通过引用传递对象而引起致命错误的情况下使用联合数组。在PHP5中，你甚至能在注册模式中混和使用对象和变量。

一个例子：

在实际应用中“注册模式”会是什么样子？在网络应用程序开发中，通常我们只拥有一个数据库连接。（因此，广泛使用“单一模式”管理数据连接）但是，比如，由于历史遗留原因：你的应用的客户数据库与你的在线订单数据库是分开的，你的DBA又把你的旧订单转移到一个存档数据库中，而且它与你的客户数据库及订单（现有，最近）数据库也是完全隔离的。那么，你怎么才能方便地管理三个数据库连接而不用创建三个单独的“单一模式”呢？答安就是使用“注册模式”。

      代码：

class DbConnections extends Registry {}

注：当你在你的代码中引入设计模式时，你的类名应该仍能反映他的角色和功能而没有必要使用模式的名字。使用模式的名字注释代码对与你的项目以外的程序员交流非常有帮助。但是在你的项目内，类的名字应该适合项目本身而且能够被项目成员很好的理解。虽然本章范例中的类名反映了设计模式的名字以及特定的实现方式，但是这并不是必须的。这仅仅是为了例子的清晰明了而不是好的命名规范。

DbConnections类是一个单件模式类，又继承了注册模式——DbConnections综合了两者的优点。

以下的代码片断创建并在注册模式类中存储了对每一个数据库的连接。

代码：

//initial setup, somewhere near the start of your script
$dbc =& DbConnections::getInstance();
$dbc->set(
'contacts',
new MysqlConnection('user1', 'pass1', 'db1', 'host1'));
$dbc->set(
'orders',
new MysqlConnection('user2', 'pass2', 'db2', 'host2'));
$dbc->set(
'archives',
new MysqlConnection('user3', 'pass3', 'db3', 'host3'));

在其他类中将注册模式类连同数据一起载入就可以使用不同的连接了。

  代码：

// domain model classes
class Customer {
var $db;
function Customer() {
$dbc =& DbConnections::getInstance();
$this->db =& $dbc->get('contacts');
}
//...
}
class Orders {
var $db_cur;
var $db_hist;
function Contact() {
$dbc =& DbConnections::getInstance();
$this->db_cur =& $dbc->get('orders');
$this->db_hist =& $dbc->get('archive'); 
}
//...
}

 

一个类依据客户数据库建模，另一个类依据历史和现在的客户订单建模。取得正确的数据库链接需要两个步骤：找到注册模式类，从中找出与给定的属性（key）相匹配的对象。

将注册模式实现为单件模式：

如前所述，把注册模式实现为单件模式有很多实现方式。

第一步，将注册模式实现为单件对象，（作者注：我们在第四章——The Singleton Pattern末尾简单讨论过）。

按照这种设计，注册模式类的任何一个实例都将访问同一个数组。我们把这个新类叫做RegistryGlobal以区别于我们前面开发的类，并反映这种实现方式的特性。

以下为反映这种思想的测试用例（它应该看起来很熟悉）。

代码：

class RegistryGlobalPHP4TestCase extends UnitTestCase {
function testRegistryGlobal() {
$reg =& new RegistryGlobal;
$this->assertFalse($reg->isValid('key'));
$this->assertNull($reg->get('key'));
$test_value = 'something';
$reg->set('key', $test_value);
$this->assertReference($test_value, $reg->get('key'));
}
}

 

实现代码如下所示：

class RegistryGlobal {
var $_store = array();
function isValid($key) {
return array_key_exists($key, $this->_store);
}
function &get($key) {
if (array_key_exists($key, $this->_store)) 
return $this->_store[$key];
}
function set($key, &$obj) {
$this->_store[$key] =& $obj;
}
}

isValid(), get(),和set()方法与我们前面开发的注册模式类完全相同。
下一步：我们来编写验证RegistryGlobal类是单件模式的测试用例。

代码：

class RegistryGlobalPHP4TestCase extends UnitTestCase {
function testRegistryGlobal() { /*...*/ }
function testRegistryGlobalIsMonoState() {
$reg =& new RegistryGlobal;
$reg2 =& new RegistryGlobal;
$this->assertCopy($reg, $reg2);
$test_value = 'something';
$reg->set('test', $test_value);
$this->assertReference(
$reg->get('test')
,$reg2->get('test'));
}
}

这里测试用例创建了RegistryGlobal类的两个实例，并确认他们不是对同一对象的引用——在一个实例内设置一个对象的属性值（value），最后证实两个实例返回相同的对象。若测试通过RegistryGlobal类就拥有单态的行为。

代码：

define('REGISTRY_GLOBAL_STORE', '__registry_global_store_key__');
class RegistryGlobal 
{var $_store;
function RegistryGlobal() 
{if
(!array_key_exists(REGISTRY_GLOBAL_STORE, $GLOBALS)||!is_array($GLOBALS[REGISTRY_GLOBAL_STORE])) {$GLOBALS[REGISTRY_GLOBAL_STORE] = array(); 
}
$this->_store =& $GLOBALS[REGISTRY_GLOBAL_STORE];
}
function isValid($key) 
{return array_key_exists($key, $this->_store);}
function &get($key) 
{if (array_key_exists($key, $this->_store)) return $this->_store[$key];}
function set($key, &$obj) {
$this->_store[$key] =& $obj;
}
}

 

本方法中的神奇之处在于$this->_store  =&  $GLOBALS[REGISTRY_GLOBAL_STORE;] 这一行，引用操作符将全局数组绑定到实例变量$_store上。这是单件模式实现的关键所在：每次在对象中使用$this->_store变量时，作用反映到全局变量中。

但是并不推荐基于全局变量的解决方案。如果PHP4支持这一特性的话，静态类变量会是更好的解决方案。然而，我们可以在代码中通过引用实现静态类变量吗？

测试与 RegistryGlobal 类的测试相似。

class  RegistryMonoStatePHP4TestCase  extends  UnitTestCase  {
function  testRegistryMonoState()  {
$this->assertCopy(
$reg  =&  new  RegistryMonoState;
$reg2  =&  new  RegistryMonoState);
$this->assertFalse($reg->isValid(‘key’));
$this->assertNull($reg->get(‘key’));
$test_value  =  ‘something’;
$reg->set(‘key’,  $test_value);
$this->assertReference($reg->get(‘key’),  $reg2->get(‘key’));
}
}

要自己实现类静态变量，可以将一个对函数静态变量的引用绑定到类的实例变量上。

class  RegistryMonoState  {var  $_store;
function &_initRegistry()  { static  $store  =  array(); return  $store;
}
function  RegistryMonoState()  {
$this->_store  =&  $this->_initRegistry();
}
function  isValid($key)  {
return  array_key_exists($key,  $this->_store);
}
function  &get($key)  {
if  (array_key_exists($key,  $this->_store))
return  $this->_store[$key];
}
function  set($key,  &$obj)  {
$this->_store[$key]  =&  $obj;
}
}


initRegistry()方法包含一个初始化为数组的静态变量。这个静态变量通过引用返回。在构造函数中$_store实例变量被赋于通过initRegistry()函数返回的引用——即静态数组。好！一个PHP4的类静态变量产生了。

使用类静态变量的实现：

PHP5中，没有必要自己实现类静态变量，因为PHP5直接支持类静态变量。因此，PHP5简化了实现。而且，PHP5中引用、对象不再有PHP4中的意义，但是assertReference() 处理了这种差别，如果两个变量指向同一个对象句柄也可以通过测试。

以下是为PHP5改写的类似的Registry测试用例。

//  PHP5
class  RegistryMonoStatePHP5TestCase  extends  UnitTestCase  {
function  testRegistryMonoState()  {
$this->assertCopy(
$reg  =  new  RegistryMonoState
,$reg2  =  new  RegistryMonoState);
$this->assertFalse($reg->isValid(‘key’));
$this->assertNull($reg->get(‘key’));
$test_value  =  new  TestObj;
$reg->set(‘key’,  $test_value);
$this->assertReference($test_value,  $reg2->get(‘key’));
}
}

以下是PHP5版本的使用静态类变量的Registry类。

class  RegistryMonoState  {
protected  static  $store  =  array();
function  isValid($key)  {
return  array_key_exists($key,  RegistryMonoState::$store);
}
function  get($key)  {
if  (array_key_exists($key,  RegistryMonoState::$store))
return  RegistryMonoState::$store[$key];
}
function  set($key,  $obj)  {
RegistryMonoState::$store[$key]  =  $obj;
}
}

PHP5中用这种方式编码Registry类的一个有趣的效果是你可以用相同的代码使用实例或者静态方法。以下是证明仅仅使用静态方法的测试用例。

class  RegistryMonoStatePHP5TestCase  extends  UnitTestCase  {
function  testRegistryMonoState()  {  /*...*/  }
function  testRegistryMonoStateStaticCalls()  {
$this->assertFalse(RegistryMonoState::isValid(‘key’));
$this->assertNull(RegistryMonoState::get(‘key’));
$test_value  =  new  TestObj; RegistryMonoState::set(‘key’,  $test_value);
$this->assertIdentical($test_value, RegistryMonoState::get(‘key’));
}

现在你已经看到在PHP5中的静态调用接口，下面让我们在PHP4中实现相同的接口。在前面的PHP4“静态类变量”部分，实现需要使用“函数静态变量返回引用”来跟踪。PHP4版本的静态调用接口测试与PHP5版本的测试类似。

//  PHP4
class  RegistryStaticPHP4TestCase  extends  UnitTestCase  {
function  testRegistryStatic()  {
$this->assertFalse(RegistryStatic::isValid(‘key’));
$this->assertNull(RegistryStatic::get(‘key’));
$test_value  =  ‘something’; RegistryStatic::set(‘key’,  $test_value);
$this->assertReference($test_value,  RegistryStatic::get(‘key’));
}
}

以下是符合测试要求的代码实现。

class  RegistryStatic  {
function  &_getRegistry()  { static  $store  =  array(); return  $store;
}
function  isValid($key)  {
$store  =&  RegistryStatic::_getRegistry();
return  array_key_exists($key,  $store);
}
function  &get($key)  {
$store  =&  RegistryStatic::_getRegistry();
if  (array_key_exists($key,  $store))
return  $store[$key];
}
function  set($key,  &$obj)  {
$store  =&  RegistryStatic::_getRegistry();
$store[$key]  =&  $obj;
}
}


这个实现方法的重点是getRegistry()方法返回一个对静态数组的引用。

$store  =&  RegistryStatic::_getRegistry();这一行，在随后的函数中把变量$store通过引用赋给静态数组，允许所有的函数可以静态访问数组，允许所有的方法可以被静态调用。

也可以不使用PHP4“静态类变量跟踪”达到相同的效果：将原先的基于单件模式的Registry类与一个包装类结合以达到允许静态调用。这个类与testRegistryStatic()有相同的测试代码，但是他的实现如下所示：

class  RegistryStatic  {
function  isValid($key)  {
$reg  =&  Registry::getInstance();
return  $reg->isValid($key);
}
function  &get($key)  {
$reg  =&  Registry::getInstance();
return  $reg->get($key);
}
function  set($key,  &$obj)  {
$reg  =&  Registry::getInstance();
$reg->set($key,  $obj);
}
}

结论：

虽然注册模式简化了对大量对象的访问，但是仍然有许多问题——与全局变量联合。你需要确定要求的属性Key在访问之已经被初始化了，而且设置属性的方法可以全局访问，你的对象仍然可能在你的代码的其他部分出乎意料的被替换掉。显然，全局数据非常有好处，方便，但是你需要时刻记住任何全局数据都是有一些不安全的。

 
内嵌的Registry模式

除了单独使用注册模式——如本章所示，Registry模式与其他对象结合时功能也是非常强大。例如：当对象的创建代价非常昂贵（例如需要查询大量数据库来初始化对象）时，而且对象在这个应用中被使用一次或多次，如果这样，你能创建一个结合了工作模式  (见第三章) 和注册模式 的“Finder”类以获得已经创建的对象的缓存而不用再次创建他们？

以下是一个Contact类，AddressBook类是工厂类。

class  AddressBook  {
function  &findById($id)  {
return  new  Contact($id);
}
}
class  Contact  {
function  Contact($id)  {
//  expensive  queries  to  create  object  using  $id
}
//  ...  other  methods
}

你可以在AddressBook类中插入Registry模式来提供缓存。代码可以如下所示：

class  AddressBook  {
var  $registry;
function  AddressBook()  {
$this->registry  =&  Registry::getInstance();
}
function  &findById($id)  {
if  (!$this->registry->isValid($id))  {
$this->registry->set($id,  new  Contact($id));
}
return  $this->registry->get($id);
}
}

AddressBook类的构造函数将registry绑定到一个实例变量。当创建了一个特定的ID并被findById()方法调用时，Registry被检查以确定对象是否已经被缓存。如果没有，将创建一个新的对象并存储在Registry中。被调用的对象将通过函数从Registry中取出并被返回。


相关知识：zend  http://www.cnblogs.com/analyzer/articles/1664633.html

calllmq
关注
专栏目录
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 937
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
设计模式-注册模式
ahutdbx的博客
12-21 901
注册模式常用的处理多个业务功能。 /** * <p>Description: sql Parser</p> * * @author ccc * @date 2020/6/21 9:38 * @since JDK1.8 */ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Documented public @interface Parser { String aliasName()
设计模式 -- 注册模式
dj1540225203的博客
03-08 763
注册模式其实想实现的目的是：有条理的保存和管理对象。why? 开发者想把对象一个一个存放到一个变量里面，想像操作变量一样操作对象，比如 $arr=['zhangsan'=>3,'lisi'=>4]; 如果 能通过zhangsan,lisi这个键来操作对象岂不是美滋滋？ 那就能像操作变量一样操作对象了，unset等，巴适的很！ 下面讲解一下注册模式的基本例子 <?php class Registry { protected sta
注册模式
不求前途凶吉，但求落幕无悔！
12-14 510
简介 注册模式，解决全局共享和交换对象。已经创建好的对象，挂在到某个全局可以使用的数组上，在需要使用的时候，直接从该数组上获取即可。将对象注册到全局的树上。任何地方直接去访问。 代码<?phpclass Register { protected static $objects; function set($alias,$object)//将对象注册到全局的树上 {
设计模式-行为模式.pdf
05-24
### 设计模式之行为模式详解 #### 一、行为模式概览 行为模式是一类设计模式，关注于算法和对象间职责的分配。这类模式不仅仅描述了对象或类的结构，更重要的是描述了它们之间的通信模式，即如何通过对象间的交互...
【Java设计模式-源码】组合实体模式：简化持久对象管理
最新发布
08-30
在Java中，组合实体设计模式用于将一组相互关联的持久对象作为一个单一实体进行管理。本文将详细介绍该模式的意图、解释、编程示例、适用场景、实际应用、优点和权衡。同时，还将提供示例代码的下载链接，方便读者...
一例读懂设计模式-单例模式、简单工厂模式.zip
08-31
本资源“一例读懂设计模式-单例模式、简单工厂模式.zip”旨在帮助初学者通过实例深入理解这两种重要设计模式：单例模式和简单工厂模式。以下是关于这两个模式的详细讲解。 1. **单例模式**： 单例模式是一种限制类...
设计模式之注册模式
weixin_30625691的博客
04-21 412
注册模式 解决全局共享，交换对象。也叫注册树模式。 实现 //注册树模式 class Register { //这个变量应该能是全局的 protected static $trees; //注册到注册树上方法 public static function set($alias, $obj) { self::$trees[$...
设计模式以及用户登陆注册页面
06-01
设计模式的简单介绍 有助于大家了解java设计模式 。
PHP设计模式 注册表模式(多个类的注册)
12-19
以前我也写过一个注册表类，不过那一个不能进行多个类的注册，下面用数组对类进行了存储。 复制代码 代码如下: <?php //基础类 class webSite {//一个非常简单的基础类 private $siteName; private $siteUrl; function __construct($siteName,$siteUrl){ $this->siteName=$siteName; $this->siteUrl=$siteUrl; } function getName(){ return $this->siteName; } function getUrl(){ return $
PHP设计模式之-----注册树模式
天下无敌庞成勇
09-22 445
<?php /* * 单例模式解决的是如何在整个项目中创建唯一对象实例的问题，工厂模式解决的是如何不通过new建立实例对象的方法。 那么注册树模式想解决什么问题呢？ 在考虑这个问题前，我们还是有必要考虑下前两种模式目前面临的局限。 首先，单例模式创建唯一对象的过程本身还有一种判断，即判断对象是否存在。存在则返回对象，不存在则创建对象并返回。 每次创建实例对象都要存在这么一层判断。 工厂模式更多
设计模式--注册树模式
奇葩也是花
07-02 333
&lt;?php # 注册树模式 class Register{ private static $tree = []; public static function set( $name , $object ){ $name = strtolower( $name ); self::$tree[$name] = $object; ...
PHP设计模式-注册模式
瞎玩儿~
11-16 468
一、概述 注册模式是一种常见结构型的设计模式、将实例注册到一个注册器中，供全局使用 二、核心 解决了全局共享 三、结构图 四、代码示例 <?php /* * 解决全局共享和交换对象 * 将类的对象注册到全局类上，在需要使用的时候可以直接访问 */ class Register { protected static $globalArr = array(); static function set($alias, $object) { self::$
设计模式之我见 浅谈寄存器（注册模式）
sanshi0815的专栏
04-01 2473
设计模式之我见 浅谈寄存器（注册模式）最近有个朋友一起在跟我说寄存器或者叫注册模式，然后另外一个朋友，给了我一个地址，让我去看，我看完后很茫然，对php的运行方式产生了诧异，开始怀疑自己是不是在很多地方理解错了，然后我去求证，问了一些朋友，有的朋友还做了测试，证明我当初的认识是正确的，所以可能很多朋友，也看完了 这些设计模式后，产生了很激动的表现，发现了自己会了这个模式然后就拿到了，php项目里去
设计模式 注册表模式
chuoban7047的博客
09-12 212
<?php classwebSite{//一个非常简单的基础类 private$siteName; private$siteUrl; publicfunction__construct($siteName,$siteUrl){ ...
设计模式-行为型模式-观察者模式
05-13
观察者模式是一种行为型设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会自动收到通知并更新。这种模式的核心是观察者和被观察者两个角色，被观察者维护一组观察...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值