有三个类:

1,过滤输入,轻量级的 class input_filter,负责将参数,如$_GET,$_POST 这些过滤,返回值类型为 数组,用作 made_sql 类的参数.

2,转换成SQL语句 class made_sql,参数的类型为数组和表名(字符串),数组的键名为表的列名,值为插入值.返回值类型为 字符串,用作 mysql ->query方法的参数.

3,数据库查询 class mysql 用到了单列模式,用静态方法来获取对象,具体参看 instanceof操作符的作用.

1,过滤输入 class input_filter 类代码如下:

1.   class input_filter 
2.   { 
3.    
4.        private $input_all; // 要过滤的数组 
5.        private $rustle;     // 过滤后的结果 
6.         
7.       //构造函数 参数可以是$_GET or $_POST 这些 
8.      public function __construct($input_C)  
9.      { 
10.          if(is_array($input_C)) 
11.               $this->input_all = $input_C ; 
12.          else 
13.               echo 'Parameter is not valid';  
14.           
15.          //初始化，不然后面第一次合并数组PHP不知道这是什么类型       
16.          $this->rustle = array();   
17.      } 
18.        
19.      private function filter_arr()  // 主函数  
20.      { 
21.           
22.          foreach ($this->input_all as  $key_input => $val_input) 
23.          { 
24.              //如果键名不是字符串，那么返回错误信息 
25.              // for key 
26.              if(!is_string($key_input))  // error 
27.                 { 
28.                   echo 'This key is not string'; 
29.                   return false; 
30.                 } 
31.              // The # is mysql Note .   
32.              $key_one = str_replace('#','',$key_input);  
33.              $key = htmlspecialchars($key_one,ENT_QUOTES,'UTF-8'); 
34.                
35.              // 我没找 # 的HTML转义符，所以用空代替 
36.              $val_one = str_replace('#','',$val_input); 
37.              // 这个函数只转化 < > ' "  ，还有个类似函数会转义所有符号 
38.              $val = htmlspecialchars($val_one,ENT_QUOTES,'UTF-8'); 
39.               
40.              // merger       
41.              $rustle_one = array($key=>$val); 
42.              //合并数组 
43.              $this->rustle = array_merge($this->rustle,$rustle_one); 
44.          } 
45.           
46.      } 
47.       
48.      //这个函数有点多余，留下以后扩展用 
49.      public function get_filter_rustle() 
50.      {//开源代码phpfensi.com 
51.          $this->filter_arr(); 
52.          return  $this->rustle ; 
53.      } 
54.  
55.  } 
56.  
57. 调用方法： 
58.  
59. $filter = new filter_input($_GET) ; // or $_POST 
60. $input_data = $filter->get_filter(); 

2,转换成SQL语句,class madesql类代码如下:

1. class madesql 
2.     { 
3.         private $Cnow_ary;   // type array  传入的参数 
4.         private $Cname_str; 
5.          
6.         private $insert_sql;  //最终的sql语句  string type 
7.          
8.         
9.  
10.   
11.         
12.        public function  __construct($Cary,$Cname) 
13.        { 
14.           //检查传入参数类型是否为数组 
15.           if (! is_array($Cary))   
16.               return false;  
17.           else 
18.               $this->Cnow_ary = $Cary;  // 写入的值 
19.          
20.           $this->Cname_str = $Cname;  // 数据库表名称  
21.          
22.  
23.        } 
24.         
25.        private function setSql()  // 主函数 ，生产SQL语句 
26.        { 
27.     
28.             foreach ( $this->Cnow_ary as  $key_ary => $val_ary ) 
29.             { 
30.                 $cols_sql = $cols_sql.','.$key_ary; //列名组合 
31.                 $vals_sql = $vals_sql.', ''.$val_ary.''' ; //值 组合 
32.             } 
33.              // 因为前面foreach的算法有点问题，第一个字符是逗号 
34.              // 所以用sunstr_replace()删除 ,自第一位起（0），只替换一个字符（1）     
35.              $cols_sql = substr_replace($vals_sql,'',0,1);    
36.              $vals_sql = substr_replace($vals_sql,'',0,1); 
37.                
38.              $this->insert_sql =  
39.              'INSERT INTO '.$this->Cname_str.' ( ' 
40.                                 .$cols_sql.' ) VALUES ( '.$vals_sql.' )'; // 语句成型 
41.        } 
42.        //扩展用 
43.        public function getSql() 
44.        { 
45.            $this->setSql(); 
46.            return $this->insert_sql; 
47. } 
48.     } 

3,数据库查询,mysql类代码如下:

数据库查询类是参照书上的单列模式,用静态方法获取对象,这样在一个脚本里只有一个数据库查询类的实例.我想单例模式用于这个类还是有点用的.

1. class mysql 
2.      { 
3.          private $connect;  
4.          static  $objectMysql; // 存放对象 
5.           
6.          private function  __construct()  
7.  
8.          {     
9.             // 创建对象的时候这个构造函数会被调用，用来初始化 
10.             $connect = mysql_connect('db address','password','dbname'); 
11.            $this->db = mysql_select_db('db',$connect);     
12.         } 
13.   
14.         public static function Mysql_object() 
15.         {     
16.             //instanceof 操作符用于检查对象是否属于某个类或者接口的实例。我说的不是很规范... 
17.            //如果$objectMysql不是mysql(self)的实例，那么就创建一个 
18.             if(! self::$objectMysql instanceof self) 
19.                  self::$objectMysql = new mysql(); 
20.   
21.             //这时候的$objectMysql就已经是一个对象 
22.             return self::$objectMysql;    
23.         } 
24.         public function query($sql) 
25.         { 
26.             return mysql_query($sql,$this->db); 
27.         } 
28.    
29.   } 

归纳一下使用方法:

1. $filter = new filter_input($_GET) ; // or $_POST http://www.111cn.net  
2. $input_data = $filter->get_filter();  
3.  
4. $madeSql = new madesql($input_data,'tableName'); 
5. $sql = $madeSql->getSql(); 
6.  
7. $mysql = mysql::Mysql_object() ;  
8. if( $mysql->query($sql) ) 
9.     echo 'Ok'; 
10. lse 
11.    echo 'failure'; 

只需要这几行调用代码即可以完成写入数据库的操作.

另外再说一下构造函数的私有公有问题,书上的mysql单例模式中构造函数是声明为了private,而没有单例模式的类如此则会产生编译错误,即 PHP 不能创建一个对象,查了下.

原因在于创建对象往往在类外面进行,这样就产生了无法访问构造函数的问题,而单列模式是在自身类中创建对象,因此访问private方法没有限制.

原先以为单例模式只是防止创建相同的对象,现在看来单例模式可以将构造函数封装起来,确实提高了安全性.

Tags: php数据库类 sql注入类

分享到：