PHP设计模式的六大设计原则
１ 简介
软件设计最大的难题就是应对需求的变化，但是纷繁复杂的需求变化却是不可预料的．此时，我们可以通过六大设计原则良好的应对未来的变化．
２ 讲解
2.1 单一职责原则(Single Responsibility Principle)
一个类只负责一个职责
简单的例子，用户发送一个请求到服务器，当我们所有的操作只用一个action类来完成
<?php
$action = new action;
$action->getResp();
class action{
public function getResp(){
// １检查路由
// ２安全检查
// ３检查缓存
// ４查询数据库及返回
// ５...
echo 'hello world';
}
}那么当需求业务比如安全检查逻辑有变动时，我们都将修改这个类，繁琐而没有条理，极不容易维护．
若我们把路由－安全－缓存等都封装成类，就仅在getResp()调用即可，简单优雅．
2.2 开闭原则(Open Closed Principle)
一个软件实体比如类－模块－函数，应该对扩展开放，对修改关闭小孩每天要做家庭作业
<?php
class Child{
public function doHomework( IHomework $homework ){
$homework -> finHomework();
}
}
interface IHomework{
public function finHomework();
}
class Homework implements IHomework{
private $work;
public function __construct( $work ){
$this->work = $work;
}
public function getWork(){
return $this->work;
}
public function finHomework(){
echo "do homework : $this->work ".PHP_EOL.'<br/>';
}
}
$xiaoming = new Child();
$xiaoming -> doHomework( new Homework('math') );do homework : math 突然有一天老实宣布，临近期中考试了，作业要做两次．考完恢复成做一次．倘若我们直接修改Homework类的finHomework函数，虽然可以解决问题，但是期中考试结束后又需要把函数改回来．最好的解决办法就是利用开闭原则：
class HomeworkTwice extends Homework{
public function __construct( $work ){
parent::__construct($work);
}
public function finHomework(){
$work = parent::getWork();
echo "do homework : ".$work." 1".PHP_EOL.'<br/>';
echo "do homework : ".$work." 2".PHP_EOL.'<br/>';
}
}
$xiaoming = new Child();
$xiaoming -> doHomework( new HomeworkTwice('math') );do homework : math 1
do homework : math 2 2.3 里氏替换原则(Liskov Substitution Principle)
所有引用基类的地方必须能透明地使用其子类的对象
子类必须完全实现父类的方法，可以拓展自己的方法和属性．即子类可以扩展父类的功能，但不能改变父类原有的功能我们设计了Mp4类，它具有听歌和看视频的功能．
interface IMp4{
public function listenMusic();
public function watchVedio();
}
class Mp4 implements IMp4{
public function listenMusic(){
echo ' listenMusic'.PHP_EOL.'<br/>';
}
public function watchVedio(){
echo ' watchVedio'.PHP_EOL.'<br/>';
}
}
class User1{
public function litenM(IMp4 $mp4){
echo 'user1';
$mp4->listenMusic();
}
public function watchV(IMp4 $mp4){
echo 'user1';
$mp4->watchVedio();
}
}
$user1 = new User1;
$mp4 = new Mp4;
$user1->litenM($mp4);
$user1->watchV($mp4);user1 listenMusic
user1 watchVedio 有一天我们要构建mp3的类，继续依照mp4的接口来生成类的话，会发现播放视频的功能用不了．
class Mp3 implements IMp4{
public function listenMusic(){
echo ' listenMusic'.PHP_EOL.'<br/>';
}
public function watchVedio(){
//不能播放视频
}
}
$user1 = new User1;
$mp3 = new Mp3;
$user1->litenM($mp3);
$user1->watchV($mp3);user1 listenMusic
user1 此时我们可以构造IMp3接口来适应此种情况，我们还可以拓展处lookMini功能函数，符合里氏替换原则．
interface IMp3{
public function listenMusic();
}
class Mp3 implements IMp3{
public function listenMusic(){
echo ' listenMusic'.PHP_EOL.'<br/>';
}
public function lookMini(){
echo ' lookMini'.PHP_EOL.'<br/>';
}
}2.4 迪米特法则(Law of Demeter)
一个对象应该对其他对象保持最少的了解系统判定英雄是否赢取lol游戏，需要观察英雄完成三步：清理兵线－推塔－胜利．
class Hero{
//清理兵线
public function cleanLine(){
echo ' killed little soldiers '.PHP_EOL.'<br/>';
return true;
}
//推塔
public function pushtower(){
echo ' destroyed their towers '.PHP_EOL.'<br/>';
return true;
}
//胜利
public function vitory(){
echo ' victory '.PHP_EOL.'<br/>';
}
}
class system{
public function judgeVictory(Hero $hero){
if($hero->cleanLine()){
if($hero->pushtower()){
$hero->vitory();
}
}
}
}
$system = new system;
$jax = new Hero;
$system->judgeVictory($jax);killed little soldiers
destroyed their towers
victory以上的Hero类中暴露了太多方法给system类，两者的耦合关系异常牢固．以下设计方法可以解决此问题．
class Hero{
//清理并线
private function cleanLine(){
echo ' killed little soldiers '.PHP_EOL.'<br/>';
return true;
}
//推塔
private function pushtower(){
echo ' destroyed their towers '.PHP_EOL.'<br/>';
return true;
}
//胜利
private function vitory(){
echo ' victory '.PHP_EOL.'<br/>';
}
//获取胜利
public function getVictory(){
if($this->cleanLine()){
if($this->pushtower()){
$this->vitory();
}
}
}
}
class player{
public function playLol(Hero $hero){
$hero->getVictory();
}
}
$player = new player;
$jax = new Hero;
$player->playLol($jax);2.5 接口隔离原则(INterface Segregation Principle)
类间的依赖应该建立在最小的接口上。有两个手机用户，用户１拿手机听歌，用户２拿手机打游戏接电话，场景实现如下：
interface IPhone{
public function call();
public function playGame();
public function listenMusic();
}
class Phone1 implements IPhone{
public function call(){
echo 'Phone1 call'.PHP_EOL.'<br/>';
}
public function playGame(){
echo 'Phone1 playGame'.PHP_EOL.'<br/>';
}
public function listenMusic(){
echo 'Phone1 listenMusic'.PHP_EOL.'<br/>';
}
}
class Phone2 implements IPhone{
public function call(){
echo 'Phone2 call'.PHP_EOL.'<br/>';
}
public function playGame(){
echo 'Phone2 playGame'.PHP_EOL.'<br/>';
}
public function listenMusic(){
echo 'Phone2 listenMusic'.PHP_EOL.'<br/>';
}
}
class User1{
public function litenM(IPhone $phone){
echo 'user1 use ';
$phone->listenMusic();
}
}
class User2{
public function playG(IPhone $phone){
echo 'user2 use ';
$phone->playGame();
}
public function call(IPhone $phone){
echo 'user2 use ';
$phone->call();
}
}
$phone1 = new Phone1;
$user1 = new User1;
$user1->litenM($phone1);
$phone2 = new Phone2;
$user2 = new User2;
$user2->playG($phone2);
$user2->call($phone2);我们发现，接口 IPhone 中出现的方法，不管依赖于它的类有没有作用，实现类的时候都要实现这些方法．若我们依据接口隔离原则，便可以解决以上问题．
interface IlandlineTelephone{
public function call();
}
interface IGameMachine{
public function playGame();
}
interface IMp3{
public function listenMusic();
}
/*interface IPhone extends IlandlineTelephone,IGameMachine,IMp3{
}*/
interface IPhone1 extends IMp3{
}
interface IPhone2 extends IlandlineTelephone,IGameMachine{
}
class Phone1 implements IPhone1{
public function listenMusic(){
echo 'Phone1 listenMusic'.PHP_EOL.'<br/>';
}
}
class Phone2 implements IPhone2{
public function call(){
echo 'Phone2 call'.PHP_EOL.'<br/>';
}
public function playGame(){
echo 'Phone2 playGame'.PHP_EOL.'<br/>';
}
}
class User1{
public function litenM(IPhone1 $phone){
echo 'user1 use ';
$phone->listenMusic();
}
}
class User2{
public function playG(IPhone2 $phone){
echo 'user2 use ';
$phone->playGame();
}
public function call(IPhone2 $phone){
echo 'user2 use ';
$phone->call();
}
}
$phone1 = new Phone1;
$user1 = new User1;
$user1->litenM($phone1);
$phone2 = new Phone2;
$user2 = new User2;
$user2->playG($phone2);
$user2->call($phone2);2.6 依赖倒置原则(Dependence Inversion Principle)
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。以下是用户吃晚餐的场景：
class Rice{
public function taste(){
echo ' rice is delicious'.PHP_EOL.'<br/>';
}
}
class User{
public function haveDinner(Rice $rice){
$rice->taste();
}
}
$user = new User;
$rice = new Rice;
$user->haveDinner($rice);soup is delicious 但是如果我们不止吃米饭，还喝汤呢，发现Rice并不适用了。我们引入一个抽象的接口Ifood，代表读物。让Mother类与接口Ifood发生依赖关系，而Rice和Soup都属于食物的范畴，让他们各自都去实现IReader接口，这样就符合高层不应该依赖低层，应该依赖于接口的依赖倒置原则，修改后代码如下：
用户吃完米饭后想要喝点汤，我们发现 haveDinner() 方法的依赖 Rice 不再适用．此时我们若依赖倒置，将haveDinner与更大范围的Ifood进行依赖，而Rice 和 Soup 实现Ifood接口，就可以解决所述问题．
interface Ifood{
public function taste();
}
class Rice implements Ifood{
public function taste(){
echo ' rice is delicious'.PHP_EOL.'<br/>';
}
}
class Soup implements Ifood{
public function taste(){
echo ' soup is delicious'.PHP_EOL.'<br/>';
}
}
class User{
public function haveDinner(Ifood $food){
$food->taste();
}
}
$user = new User;
$rice = new Rice;
$soup = new Soup;
$user->haveDinner($rice);
$user->haveDinner($soup);rice is delicious
soup is delicious ３ 结尾
六大设计原则的首字母联合起来为SOLID－稳定的（两个L合成一个）．使用六大设计原则，可以建立灵活健壮的系统．