如果你是一名使用过多种框架的php程序员,你一定见过这样的查询语句:

Php代码  收藏代码
  1. $result = $mysqlDb->limit(’0,10′)->order(‘id desc’)->findall();  

上面的查询语句,连续使用->操作符进行操作,并最终返回一个查询结果,那么这是如何实现的呢。

 

我们来简单分析一下:

->操作符用来访问对象,上面的语句一共使用了3次->操作符,而最后一次返回的是查询结果,这说明,前2次->访问后,返回的 应该是一个对象,因为在php中,如果你对一个非对象使用->操作符是不可能的。这告诉我们,$mysql实例中的limit和order方法都返 回一个对其所在类自身的引用即 return $this,了解了这一点,那么我们就可以实现连贯查询了。请看站长写的示例代码:

Php代码  收藏代码
  1. <?php  
  2.    
  3. /* 
  4.  *类功能:实现数据库的连贯查询操作 
  5.  */  
  6.  class mysql_query{  
  7.  var $tbl=’user’;//要操作的表名  
  8.  var $limit=”;//存储limit语句的变量  
  9.  var $order=”;//存储order语句的变量  
  10.  var $sql=”;//存储完整sql语句的变量  
  11.    
  12. function limit($str) {  
  13.  $this->limit=’limit ‘.$str;//设置limit语句  
  14.  //返回对类自身的引用,这里不能使用return new mysql_qery(),  
  15.  //因为这样相当于又创建了类的一个新实例,那么上一步设置的limit语句,在新实例中是不存在的  
  16.  //大家可以自己实验  
  17.  //因此要返回$this,即当前类的实例  
  18.  return $this;  
  19. }  
  20.    
  21. function order($str) {  
  22.  $this->order=’order by ‘.$str;//设置order语句  
  23.  return $this;//返回对类自身的引用  
  24. }  
  25.    
  26. function findall() {  
  27.  $this->sql=’select * from ‘.$this->tbl.’ ‘.$this->order.’ ‘.$this->limit;//拼接sql语句  
  28.  echo $this->sql;//输出,由于是示例,所以没有写查询数据库的代码  
  29. }  
  30.    
  31.  }  
  32.    
  33. //Example  
  34. $mysqlDb=new mysql_query();  
  35. $result = $mysqlDb->limit(’0,10′)->order(‘id desc’)->findall();  
  36. print_r($result);  
  37. ?>  

 

============================================================


另外也有框架是使用 __call() 这个魔术方法来实现的.

Php代码  收藏代码
  1. <?php  
  2. class Test {  
  3.    
  4. protected $options = array();  
  5.    
  6. //这里就是了, 通过判断调用的函数名, 如果存在, 那么设置参数, 返回自己  
  7. public function __call($func, $args) {  
  8. if (in_array($func, array('form', 'field', 'join', 'order', 'where', 'limit', '更多....'))) {  
  9. $this->options[$func] = $args;  
  10. return $this; //这里返回了本对象  
  11. }  
  12. }  
  13.    
  14. }  
  15.    
  16. //Example  
  17. $test = new Test();  
  18. $test->form('test'); // 这样调用就相当于设置 $test->options['form'] = 'test';  

 

//在ThinkPHP中这种连贯操作都是以find或者findAll结尾的.
//所以前面这些方法的调用只是在设置查询的参数而已
//在find或者findAll方法中, 是根据$this->options参数的不同执行不同的SQL
//比如这样

Php代码  收藏代码
  1. public function find() {  
  2.  $sql = "SELECT {$this->options['field']} FROM {$this->options['form']}";  
  3.  $sql .= isset($this->options['where']) ? " WHERE {$this->options['where']}" : '';  
  4.  //.........更多处理  
  5.  echo $sql;  
  6.  }  

 

这里只是简单的讲解一下, 和官方可能有点出入.
在ThinkPHP里, 很帅的方法基本上都在__call函数中实现的比如有topN(), byXXX();

 

原文:http://blog.haohtml.com/archives/14551

 

 

实例1:TP中连贯操作的实现原理

Php代码  收藏代码
  1. <?php  
  2. class Users  
  3. {  
  4.     protected $options = array();  
  5.   
  6.     public function select()  
  7.     {  
  8.         $fields = $this->options['field'] ? $this->options['field'] : "*";  
  9.         $query = "select ".$fields." from ";  
  10.         $query .= $this->options['table']." where ";  
  11.         $query .= $this->options['where']." limit 0,";  
  12.         $query .= $this->options['limit']." order by ";  
  13.         $query .= $this->options['order'].";";;  
  14.         echo $query;  
  15.         //do something for select data from database;  
  16.     }  
  17.     public function __call($methods,$vars)  
  18.     {  
  19.         $this->options[$methods] = $vars[0];  
  20.         return $this;           //关键在这里是返回对象  
  21.     }  
  22. }  
  23. $p = new Users();  
  24. $p->table('users')->field('username,passwd')->where("uid = 12")->limit('10')->order("uid asc")->select();  

 

或者在thinkphp的:lib->think->core->model.class.php文件里面(Model类)有这么一段代码:

Php代码  收藏代码
  1. /** 
  2.  +---------------------------------------------------------- 
  3.  * 利用__call方法实现一些特殊的Model方法 
  4.  +---------------------------------------------------------- 
  5.  * @access public 
  6.  +---------------------------------------------------------- 
  7.  * @param string $method 方法名称 
  8.  * @param array $args 调用参数 
  9.  +---------------------------------------------------------- 
  10.  * @return mixed 
  11.  +---------------------------------------------------------- 
  12.  */  
  13. public function __call($method,$args) {  
  14.     if(in_array(strtolower($method),array('field','table','where','order','limit','page','alias','having','group','lock','distinct'),true)) {  
  15.         // 连贯操作的实现  
  16.         $this-&gt;options[strtolower($method)] =   $args[0];  
  17.         return $this;  
  18.     }elseif(in_array(strtolower($method),array('count','sum','min','max','avg'),true)){  
  19.         // 统计查询的实现  
  20.         $field =  isset($args[0])?$args[0]:'*';  
  21.         return $this-&gt;getField(strtoupper($method).'('.$field.') AS tp_'.$method);  
  22.     }elseif(strtolower(substr($method,0,5))=='getby') {  
  23.         // 根据某个字段获取记录  
  24.         $field   =   parse_name(substr($method,5));  
  25.         $where[$field] =  $args[0];  
  26.         return $this-&gt;where($where)-&gt;find();  
  27.     }else{  
  28.         throw_exception(__CLASS__.':'.$method.L('_METHOD_NOT_EXIST_'));  
  29.         return;  
  30.     }  
  31. }  

 

代码的具体功能,我就不解释了,第一可能我也解释不清楚;第二自己去看一下里面的编程思想还是有很多值的学习的。

 

说一下他的调用方法,就能看出他的“强大”了。
调用:

Php代码  收藏代码
  1. $this->dao= M(‘table’);          //快速高性能实例化一个 table 表的模型  
  2. $this->dao->field($field)->where($where)->limit($offset . ‘,’ . $limit)->select();      
  3. //设置查询字段,查询条件,设置查询数量,最后执行查询操作。当然返回的就是数据库记录了  

 

看到“不对劲”了吧,field方法成对象了,where、limit、select方法也成对象了,其实field、where这些方法在 Model类 里面都不存在。正是因为这些方法不存在,所以这个时候__call方法被执行了,然后又会返回$this对象。所以可以实现这种“衔接”写法,一行代码搞 了所有的SQL语句。

 

 

实例2. php __call()方法实现数据库连贯操作

Php代码  收藏代码
    1. <?php  
    2.   // 使用__call()方法来实现数据库连贯操作  
    3.  // 申明一个Db类(数据库操作类)的简单操作模型  
    4.   
    5. class Db{  
    6.     private $sql = array(  
    7.         "field" => "",  
    8.         "where" => "",  
    9.         "order" => "",  
    10.         "limit" => "",  
    11.         "group" => "",  
    12.         "having" => "",  
    13.     );  
    14.      
    15.     // 连贯操作调用field() where() order() limit() group() having()方法,组合sql语句  
    16.     function __call($methodName,$args){  
    17.         // 将第一个参数(代表不存在方法的方法名称),全部转成小写方式,获取方法名称  
    18.         $methodName = strtolower($methodName);  
    19.          
    20.         // 如果调用的方法名和成员属性数组$sql下标对应上,则将第二个参数给数组中下标对应的元素  
    21.         if(array_key_exists($methodName,$this->sql)){  
    22.             $this->sql[$methodName] = $args[0];  
    23.         }else{  
    24.             echo '调用类'.get_class($this).'中的方法'.$methodName.'()不存在';  
    25.         }  
    26.         // 返回自己对象,则可以继续调用本对象中的方法,形成连贯操作  
    27.         return $this;  
    28.     }  
    29.     // 输出连贯操作后组合的一个sql语句,是连贯操作最后的一个方法  
    30.     function select(){  
    31.         echo "SELECT {$this->sql['field']} FROM  user {$this->sql['where']} {$this->sql['order']} {$this->sql['limit']} {$this->sql['group']}  
    32.                 {$this->sql['having']}";  
    33.     }  
    34. }  
    35.   
    36. $db = new Db();  
    37.   
    38. // 连贯操作  
    39. $db->field('sex, count(sex)')  
    40.    ->where('where sex in ("男","女")')  
    41.    ->group('group by sex')  
    42.    ->having('having avg(age) > 25')  
    43.    ->select();  
    44. ?> 
posted on 2016-08-17 11:50  飘渺的悠远  阅读(256)  评论(0)    收藏  举报