五种常见的设计模式

工厂模式

系统某个部分中的函数和类严重依赖于系统的其他部分中函数和类的行为和结构。您需要一组模式，使这些类能够相互通信，但不希望将它们紧密绑定在一起，以避免出现联锁。 在大型系统中，许多代码依赖于少数几个关键类。需要更改这些类时，可能会出现困难。例如，假设您有一个从文件读取的 User类。您希望将其更改为从数据库读取的其他类，但是，所有的代码都引用从文件读取的原始类。这时候，使用工厂模式会很方便。 工厂模式 是一种类，它具有为您创建对象的某些方法。您可以使用工厂类创建对象，而不直接使用 new。这样，如果您想要更改所创建的对象类型，只需更改该工厂即可。使用该工厂的所有代码会自动更改。 清单 1 显示工厂类的一个示列。等式的服务器端包括两个部分：数据库和一组 PHP 页面，这些页面允许您添加反馈、请求反馈列表并获取与特定反馈相关的文章。

<?php

interface IUser
{
    function getName();
} 

class User implements IUser
{
    public function __construct( $id ) { }
    public function getName()
    {
        return "Jack";
    }
}

class UserFactory
{
    public static function Create( $id )
    {
        return new User( $id );
    }
}

$uo = UserFactory::Create( 1 );

echo( $uo->getName()."\n" );

?>

  有一种工厂模式的变体使用工厂方法。类中的这些公共静态方法构造该类型的对象。如果创建此类型的对象非常重要，此方法非常有用。例如，假设您需要先创建对象，然后设置许多属性。此版本的工厂模式会将该进程封装在单个位置中，这样，不用复制复杂的初始化代码，也不必将复制好的代码在在代码库中到处粘贴。

<?php

interface IUser
{
    function getName();
}

class User implements IUser
{
    public static function Load( $id )
    {
        return new User( $id );
    }

    public static function Create( )
    {
        return new User( null );
    }

    public function __construct( $id ) { }

    public function getName()
    {
        return "Jack";
    }
}

$uo = User::Load( 1 );

echo( $uo->getName()."\n" );

?>

单元素模式

某些应用程序资源是独占的，因为有且只有一个此类型的资源。例如，通过数据库句柄到数据库的连接是独占的。您希望在应用程序中共享数据库句柄，因为在保持连接打开或关闭时，它是一种开销，在获取单个页面的过程中更是如此。 单元素模式可以满足此要求。如果应用程序每次包含且仅包含一个对象，那么这个对象就是一个单元素（Singleton）。清单 3 中的代码显示了 PHP V5 中的一个数据库连接单元素。

<?php

require_once("DB.php");

class DatabaseConnection
{
    public static function get()
    {
        static $db = null;

        if ( $db == null )

        $db = new DatabaseConnection();

        return $db;
    }

    private $_handle = null;

    private function __construct()
    {
        $dsn = 'mysql://root:password@localhost/photos';

        $this->_handle =& DB::Connect( $dsn, array() );
    }

    public function handle()
    {
        return $this->_handle;
    }
}

print( "Handle = ".DatabaseConnection::get()->handle()."\n" );

print( "Handle = ".DatabaseConnection::get()->handle()."\n" );

?>

观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者 注册自己）使本身变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因。 一个简单示例是系统中的用户列表。清单 4 中的代码显示一个用户列表，添加用户时，它将发送出一条消息。添加用户时，通过发送消息的日志观察者可以观察此列表。

<?php

interface IObserver
{
	function onChanged( $sender, $args );
}

interface IObservable
{
	function addObserver( $observer );
}

class UserList implements IObservable
{
	private $_observers = array();

	public function addCustomer( $name )
	{
		foreach( $this->_observers as $obs )
		$obs->onChanged( $this, $name );
	}

	public function addObserver( $observer )
	{
		$this->_observers []= $observer;
	}
}

class UserListLogger implements IObserver
{
	public function onChanged( $sender, $args )
	{
		echo( "'$args' added to user list\n" );
	}
}

$ul = new UserList();

$ul->addObserver( new UserListLogger() );

$ul->addCustomer( "Jack" );

?>

  测试代码创建 UserList，并将 UserListLogger 观察者添加到其中。然后添加一个消费者，并将这一更改通知 UserListLogger。 认识到 UserList 不知道日志程序将执行什么操作很关键。可能存在一个或多个执行其他操作的侦听程序。例如，您可能有一个向新用户发送消息的观察者，欢迎新用户使用该系统。这种方法的价值在于 UserList 忽略所有依赖它的对象，它主要关注在列表更改时维护用户列表并发送消息这一工作。 此模式不限于内存中的对象。它是在较大的应用程序中使用的数据库驱动的消息查询系统的基础。

责任链模式

我们的意图就是要DNS服务器192.168.10.1解析出www.xxx.com.cn的IP地址，那DNS服务器是如何工作的呢？也就是我们图中的182.168.10.1这个DNS Server，它存储着全球的域名和IP之间的对应关系吗？不可能，目前全球的域名数量是1.7亿个，如此庞大的数字，每个DNS服务都存储一份，还怎么快速响应？DNS解析响应时间一般都是毫秒级别的，如此高的性能要求还怎么让DNS Server遍地开花呢？而且域名变更也非常频繁，数据读写的量也非常大，不可能这1.7亿数据每个DNS服务器都保留一条，那是怎么设计的呢？DNS协议还是很聪明的，它规定了每个区域的DNS服务器(Local DNS)只保留自己区域的域名解析，对于不能解析的域名，则提交上级域名解析器解析，最终由一台位于美国洛杉矶的顶级域名服务器进行解析，返回结果，这非常明显是一个事物的链结构处理，我们使用两种模式来实现该解析过程。 猜想大家看到这里，肯定非责任链模式莫属，好，我们就用责任链模式来实现，首先我们定义一下业务场景，这里有三个DNS服务器：上海DNS服务器（区域服务器）、中国顶级DNS服务器（父服务器）、全球顶级DNS服务器

public class Recorder {
	//域名
	private String domain;
	//IP地址
	private String ip;
	//属主
	private String owner;
	public String getDomain() {
		return domain;
	}
	public void setDomain(String domain) {
		this.domain = domain;
	}
	public String getIp() {
		return ip;
	}
	public void setIp(String ip) {
		this.ip = ip;
	}
	public String getOwner() {
		return owner;
	}
	public void setOwner(String owner) {
		this.owner = owner;

	}
	//输出记录信息
	@Override
	public String toString(){
		String str= "域名：" + this.domain;
		str = str + "\nIP地址：" + this.ip;
		str = str + "\n解析者：" + this.owner;
		return str;
	}
}

public abstract class DnsServer {
	//上级DNS是谁
	private DnsServer upperServer;
	//解析域名
	public final Recorder resolve(String domain){
		Recorder recorder=null;
		if(isLocal(domain)){//是本服能解析的域名
			recorder = echo(domain);
		}else{//本服不能解析
			//提交上级DNS进行解析
			recorder = upperServer.resolve(domain);
		}
		return recorder;
	}
	//指向上级DNS
	public void setUpperServer(DnsServer _upperServer){
		this.upperServer = _upperServer;
	}
	//每个DNS都有一个DNS的数据处理区（ZONE）,检查域名是否在本zone中
	protected abstract boolean isLocal(String domain);
	//每个DNS服务器都必须实现解析任务
	protected Recorder echo(String domain){
		Recorder recorder = new Recorder();
		//获得IP地址
		recorder.setIp(genIpAddress());
		recorder.setDomain(domain);
		return recorder;
	}
	//随机产生一个IP地址，工具类
	private String genIpAddress(){
		Random rand = new Random();
		String address = rand.nextInt(255) + "." + rand.nextInt(255) + "."+ rand.nextInt(255) + "."+ rand.nextInt(255);
		return address;
	}
}

public class SHDnsServer extends DnsServer {
	@Override
	protected Recorder echo(String domain) {
		Recorder recorder= super.echo(domain);
		recorder.setOwner("上海DNS服务器");
		return recorder;
	}
	//定义上海的DNS服务器能处理的级别
	@Override
	protected boolean isLocal(String domain) {
		return domain.endsWith(".sh.cn");
	}
}

public class ChinaTopDnsServer extends DnsServer {
	@Override
	protected Recorder echo(String domain) {
		Recorder recorder = super.echo(domain);
		recorder.setOwner("中国顶级DNS服务器");
		return recorder;
	}
	@Override
	protected boolean isLocal(String domain) {
		return domain.endsWith(".cn");
	}
}

public class TopDnsServer extends DnsServer {
	@Override
	protected Recorder echo(String domain) {
		Recorder recorder = super.echo(domain);
		recorder.setOwner("全球顶级DNS服务器");
		return recorder;
	}
	@Override
	protected boolean isLocal(String domain) {
		//所有的域名最终的解析地点
		return true;
	}
}

public class Client {
	public static void main(String[] args) throws Exception {
		//上海域名服务器
		DnsServer sh = new SHDnsServer();
		//中国顶级域名服务器
		DnsServer china = new ChinaTopDnsServer();
		//顶级域名服务器
		DnsServer top = new TopDnsServer();
		//定义查询路径
		china.setUpperServer(top);
		sh.setUpperServer(china);
		//解析域名
		System.out.println("=====域名解析模拟器=====");
		while(true){
			System.out.print("\n请输入域名(输入N退出):");
			String domain = (new BufferedReader(new InputStreamReader(System.in))).readLine();
			if(domain.equalsIgnoreCase("n")){
				return;
			}
			Recorder recorder = sh.resolve(domain);
			System.out.println("----DNS服务器解析结果----");
			System.out.println(recorder);
		}
	}
}

策略模式

我们讲述的最后一个设计模式是策略 模式。在此模式中，算法是从复杂类提取的，因而可以方便地替换。例如，如果要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择。思考一下搜索引擎的几个部分 —— 一部分遍历页面，一部分对每页排列，另一部分基于排列的结果排序。在复杂的示例中，这些部分都在同一个类中。通过使用策略模式，您可将排列部分放入另一个类中，以便更改页排列的方式，而不影响搜索引擎的其余代码。 作为一个较简单的示例，清单 6 显示了一个用户列表类，它提供了一个根据一组即插即用的策略查找一组用户的方法。

<?php

interface IStrategy
{
  function filter( $record );
}

class FindAfterStrategy implements IStrategy
{
  private $_name;

  public function __construct( $name )
  {
    $this->_name = $name;
  }

  public function filter( $record )
  {
    return strcmp( $this->_name, $record ) <= 0;
  }
}

class RandomStrategy implements IStrategy
{
  public function filter( $record )
  {
    return rand( 0, 1 ) >= 0.5;
  }
}

class UserList
{
  private $_list = array();

  public function __construct( $names )
  {
    if ( $names != null )
    {
      foreach( $names as $name )
      {
        $this->_list []= $name;
      }
    }
  }

  public function add( $name )
  {
    $this->_list []= $name;
  }

  public function find( $filter )
  {
    $recs = array();
    foreach( $this->_list as $user )
    {
      if ( $filter->filter( $user ) )
        $recs []= $user;
    }
    return $recs;
  }
}

$ul = new UserList( array( "Andy", "Jack", "Lori", "Megan" ) );
$f1 = $ul->find( new FindAfterStrategy( "J" ) );
print_r( $f1 );

$f2 = $ul->find( new RandomStrategy() );
print_r( $f2 );

?>

  策略模式非常适合复杂数据管理系统或数据处理系统，二者在数据筛选、搜索或处理的方式方面需要较高的灵活性。