一.单一职责
定义: 一个类承担的职责不宜过多,或者说就一个类而言,应该仅有一个引起它变化的原因
如果一个类的职责承担过多,如果涉及到其中每一个职责变动的时候,都要修改这个类,而且在我们要复用这个类中的其中一个职责的时候也没法做到复用。
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科,部分文理,这样造成喜欢文科的也不得不考理科,喜欢理科的不得不考文科,上海表示抗议,要分文理科,于是上海私自做决定, 考试我还是考(实现全国卷统一接口),但是文科生理综不计入总分(空方法实现),理科生分科不计入总分(空方法实现), 接着北京,天津等直辖市纷纷效仿,深圳广州等城市还是按照综合考试,觉得这样有利于学生综合能力发展,这时候教育部想了个办法把学科分成主课+文+理(三个接口,这样做到了接口最小化), 愿意分文理就靠文科的,愿意综合的就靠所有的,这样大家都没意见了。
如果某些时候遵守规则让你开发效率更低,那还不如违反规则以得到更好的开发效率,规则是死的,人是活的,我们开发的时候尽量遵守这些规则即可