设计模式之 六大原则

一.单一职责

定义: 一个类承担的职责不宜过多，或者说就一个类而言，应该仅有一个引起它变化的原因

如果一个类的职责承担过多，如果涉及到其中每一个职责变动的时候，都要修改这个类，而且在我们要复用这个类中的其中一个职责的时候也没法做到复用。

class Act{
    
    public function run(){
        $data = $this->curl($url);
    }
    
    public function curl($url, $data = array(), $timeout = 5) {
        $ch = curl_init();
        if (!empty($data) && $data) {
            if(is_array($data)){
                $formdata = http_build_query($data);
            } else {
                $formdata = $data;
            }
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $formdata);
        }
        
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
        curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
        curl_setopt($ch, CURLOPT_ENCODING, '');
        $result = curl_exec($ch);
        curl_close($ch);
        return $result;
    }
}

看到项目里经常有把请求第三方接口的curl方法写在当前类里，比如上面的活动类Act耦合了curl方法，如果此时又有另外一个类要使用curl方法，这个类并不需要活动类的其它功能此时就不能复用Act的curl方法
只能在这个类里在增加一个curl方法，如此下去,随着类越来越多，项目里到处是curl方法，假如某一天需要把超时改成10秒，那就惨了，得一个个类里去修改。其实我们完全可以把curl方法放到curl类里，将Act类和curl解耦,
这样项目统一使用curl类的curl方法，新增功能的时候可复用Curl的curl方法，修改的时候只需修改Curl类。

class Act{
    
    public function run(){
        $data = Curl::curl($url);
    }
}

class Curl{
    public static function curl($url, $data = array(), $timeout = 5) {
        /***代码略***/
    }
}

二.开放封闭原则

定义: 软件实体(类，函数模块) 应该是可以扩展的，但是不可以修改

这应该是软件开发的理想境界，其实我们不可能做到完全对修改关闭，只是尽量做到即可。
比如游戏里的支付回调，可以抽象为3个步骤,验证第三方参数，发道具给玩家，返回报文给第三方。

abstract class Notify{
    //回调状态码
    protected $_status = 0;
    protected abstract function checkSign();
    protected abstract function SendProp();
    protected abstract function OutputMessage();
    
    public final function run(){
        if($this->checkSign()){
            if($this->SendProp()){
                //成功写入数据记录
                $this->_writeDBLog();
                $this->_status = 1;
            }else{
                $this->_status = -1;//发道具错误
            }
        }else{
            $this->_status = 2;//第三方参数错误
        }
        $this->OutputMessage();
    }
    private function _writeDBLog(){
        echo "写入DB日志
";
    }
}

class Weixin extends Notify{
    protected function checkSign(){
        return true;
    }
    protected function SendProp(){
        return true;
    }
    protected function OutputMessage(){
        if($this->_status == 1){
            die('ok');
        }else{
            die('fail');
        }
    }
}

$weixin = new Weixin();
$weixin ->run();

上面是一个第三方回调的主体代码，我抽掉了其他的业务逻辑，每个支付子类继承子一个抽象父类，这样做的好处是可以把公共的逻辑放到父类里，无需每个子类重复写公共逻辑，假如要新增支付宝，
只需要新增一个支付宝类，然后实现子类特有的业务逻辑即可。当然如果某天要新增文件日志，那必须改父类了，团队里开发人员水平参差不齐，我们可以把 Notify父类这个文件设置为指定人员可改。
这样基本做到了对扩展开防，对修改关闭。

三.里氏替换原则

定义: 子类型必须能够替换掉他们的父类型

意思是尽量不要重写父类的方法，因为父类的方法一般是公用的

由于世界上最好的语言是弱类型,这个原则PHP实在无法理解，这里使用java来理解这个原则

class Car{
    String carType;
    public Car(String carType){
        this.carType = carType;
    }   
    public void run(){
        System.out.println(carType + "跑");
    }   
}

class HondaCar extends Car{
    public HondaCar(String carType){
        super(carType);
    }   
    
    /*  
    public void run(){
        throw new Exception();
    }
    */
}

class FordCar extends Car{
    public FordCar(String carType){
        super(carType);
    }   
}

public class Client {
    public static void main(String[]agrs){
        Car h = new HondaCar("丰田");   
        h.run();

        FordCar f = new FordCar("福特");
        f.run();    
    }   
}

子类型FordCar f对象，可以替换掉父类型Car h对象,但假如 HondaCar类重写父类的run方法，显然替换会造成程序异常。
然而有的时候我们不得不重写父类的方法，只要重写父类方法能给我们带来大利大于弊的时候即可。

 

四.依赖倒转原则 

定义 : 抽象不应该依赖于细节，细节应该依赖于抽象,要针对接口编程而不是对具体实现编程

这个原则还是用java来理解

class Members{
    public void set(){
        Redis redis = new Redis();
        redis.set("u_key", "u_value");
    }   
}

class Redis{
    public void set(String key, String val){
        System.out.println("Redis设置key:" + key + "value :" + val + "成功!");
    }   
}

public class Client {
    public static void main(String[]agrs){
        Members m = new Members();
        m.set();
    }   
}

假如存贮换为Mysql那么我们得修改Members类,我们改下代码，增加一个Istore接口,Redis和Mysql类实现set方法。具体的类名我们可以写到配置文件里，然后通过反射实例化相应的对象，
换存贮只需要修改配置文件，增加对应的存储类即可做到符合开闭原则。

interface Istore{
    public void set(String key, String val);
}

class Members{
    public void set(){
        Istore store  = new Mysql();
        store.set("u_key", "u_value");
    }   
}

class Mysql implements Istore{
    public void set(String key, String val){
        System.out.println("Mysql设置key:" + key + "value :" + val + "成功!");
    }   
}

class Redis implements Istore{
    public void set(String key, String val){
        System.out.println("Redis设置key:" + key + "value :" + val + "成功!");
    }   
}

public class Client {
    public static void main(String[]agrs){
        Members m = new Members();
        m.set();
    }   
}

五.迪米特法则 

定义 : 一个类应该尽量降低自己成员的访问权限，如果两个类不必发生直接通讯，那么这两个类就不应该直接发生相互作用，如果其中一个类要调用另外一个类的方法，可以通过第三者转发这个调用

这个原则强调尽量降低类和类之间的耦合度，一个处于松耦合的类一旦被修改，不会对关联的类造成太大的影响

class Cache{
    function getResult(){
        return array('id'=>1, 'name'=>'PHP');
    }
}

class Mysql{
    function getResult(){
        return array('id'=>1, 'name'=>'PHP');
    }
}

class Client{
    public static function main(){
        $data = array();
        $cache = new Cache();
        if(!$data = $cache->getResult()){
            $db = new Mysql();
            $data = $db->getResult();
        }
        print_r($data);
    }
}
Client::main();

上面这个是我们经常碰到的业务场景，先从cache里取数据，取不到就从db里取，万一要加个文件里取，就得修改客户端配置，如果调用的地方很多，每个地方都得改。
此时根据迪米特法则完全可以引入一个对象当中间人，使得客户端不用直接和db,cache交互。

class Cache{
    function getResult(){
        return array('id'=>1, 'name'=>'PHP');
    }
}

class Mysql{
    function getResult(){
        return array('id'=>1, 'name'=>'PHP');
    }
}

class Proxy{
    static function getResult(){
        $data = array();
        $cache = new Cache();
        if(!$data = $cache->getResult()){
            $db = new Mysql();
            $data = $db->getResult();
        }
        return $data;
    }
}

class Client{
    public static function main(){
        $data = Proxy::getResult();
        print_r($data);
    }
}
Client::main();

六.接口隔离原则 

定义 : 不要建立庞大臃肿的接口，接口中的方法尽量少

 如果违反这一原则，有时候不需要这些方法子类也不得不实现这个方法。

 下面以高考作为一个栗子(纯属虚构), 最初教育部规定各省市考试有7科，部分文理，这样造成喜欢文科的也不得不考理科，喜欢理科的不得不考文科，上海表示抗议，要分文理科,于是上海私自做决定, 考试我还是考(实现全国卷统一接口)，但是文科生理综不计入总分(空方法实现)，理科生分科不计入总分(空方法实现), 接着北京，天津等直辖市纷纷效仿，深圳广州等城市还是按照综合考试，觉得这样有利于学生综合能力发展，这时候教育部想了个办法把学科分成主课+文+理(三个接口，这样做到了接口最小化), 愿意分文理就靠文科的，愿意综合的就靠所有的,这样大家都没意见了。

如果某些时候遵守规则让你开发效率更低，那还不如违反规则以得到更好的开发效率，规则是死的，人是活的，我们开发的时候尽量遵守这些规则即可