mysqli_real_escape_string($mysqli2,$string); 2 connections bdd

**bilobar** · 17/12/2012, 15h59

Bonjour,

J'utilise mysqli_real_escape_string($mysqli,$string);.
J'ai une 1ere connection à la bdd $mysqli, et pour utiliser mysqli_real_escape_string($mysqli,$string); je dois refaire une connection à la bdd $mysqli2 . Ce qui fait 2 connections alors que 1 seule devrait suffire.
Pour le moment je ne vois pas d'autre solution. ça fait doublon.
J'utilise mysqli car j'ai déjà du code avec mysql. Donc je veux pas utiliser pour le moment PDO.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$mysqli2 = new mysqli(HOST, USER, PASS, BASE);
 
				$string = mysqli_real_escape_string($mysqli2,$string);

db.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    $mysqli = new mysqli(HOST, USER, PASS, BASE);

Common.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
<?php
include("db.php");
 
 
class Common{
 
 
 
    function __construct($mysqli){
    	$this->mysqli = $mysqli; //now you can use the object as $this->mysqli throughout your class
    }
 
 
	// Données entrantes
	public static function bdd($string)
	{
 
		$errorMethode="bdd()";
	try{
 
			// On regarde si le type de string est un nombre entier (int)
			if(ctype_digit($string))
			{
				$string = intval($string);
			}
			// Pour tous les autres types
			else
			{
 
 
                            $mysqli2 = new mysqli(HOST, USER, PASS, BASE);
 
				$string = mysqli_real_escape_string($mysqli2,$string);
 
				// Échappement des caractères % et _
				$string = addcslashes($string, '%_');
			}
 
 
			return $string;
 
	}//fin try{
	catch(Exception $e){
 
			echo"<br><center><font color=red>Exception : ". $e->getMessage()."
		
			Error in : ".$errorMethode."<br><br>string= ".$string."<br><br></font></center><br>";
 
 
		}//fin catch(Exception $e){
 
	}
 
}
?>

User.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
<?php
include("Common.class.php");
 
 
class User{
 
    function __construct($mysqli){
    	$this->mysqli = $mysqli; //now you can use the object as $this->mysqli throughout your class
    }
 
	public function faire($param){
 
 
		$param =Common::bdd($param);
 
 
		$q = "UPDATE table SET name = '".$param."' ";
 
		$result = $this->mysqli->query($q) or die("Error SQL in : ".$errorMethode."<br><br>".$q."<br><br>MSG : "
									.$this->mysqli->error);
		if (!$result)
 		 throw new Exception
   			 ("Pb d’execution de $q. ". $this->mysqli->error);
 
		else
			return $result;
	}
 
}
?>

page.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
//include("Common.class.php");
include("User.class.php");
 
$monUser = new User($mysqli);
 
$monUser->faire("Paul");

En modifiant Common.class.php avec bdd($mysqli,$string) et $string = mysqli_real_escape_string($mysqli,$string); utilise 1 seule connection.
Problème c'est que sur toutes les méthodes il faut rajouter le paramètre $mysqli car bdd($mysqli,$string) est utilisé dans presque toutes les fonctions.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
<?php
include("db.php");
 
 
class Common{
 
 
 
    function __construct($mysqli){
    	$this->mysqli = $mysqli; //now you can use the object as $this->mysqli throughout your class
    }
 
 
	// Données entrantes
	public static function bdd($mysqli,$string)
	{
 
 
 ...
 
                            //$mysqli2 = new mysqli(HOST, USER, PASS, BASE);
 
				$string = mysqli_real_escape_string($mysqli,$string);
 
				// Échappement des caractères % et _
				$string = addcslashes($string, '%_');
 
 ...
 
			return $string;
 
 
..
 
	}
 
}
?>

User.class.php devient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
<?php
include("Common.class.php");
 
 
class User{
 
    function __construct($mysqli){
    	$this->mysqli = $mysqli; //now you can use the object as $this->mysqli throughout your class
    }
 
	public function faire($mysqli,$param){
 
 
		$param =Common::bdd($mysqli,$param);
 
...
 
			return $result;
	}
 
}
?>

page.php devient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
//include("Common.class.php");
include("User.class.php");
 
$monUser = new User($mysqli);
 
$monUser->faire($mysqli,"Paul");

**RunCodePhp** · 17/12/2012, 20h41

Salut

Problème c'est que sur toutes les méthodes il faut rajouter le paramètre $mysqli car bdd($mysqli,$string) est utilisé dans presque toutes les fonctions.

Ce n'est pas un problème en soit, c'est juste que peut être (je dis bien peut être) tu oubli ne serait-ce que temporairement c'ertaines bases sur la portée (ou visibilité) des variable ou Objet.

J'ai l'impression qu'en mettant un include('db.php') dans Common.class.php la variable (Objet) $mysqi sera visible dans la classe Common, or il en est rien et c'est normal.

Tu dis à un moement exploiter mysql (je dis bien des fonction mysql et non mysqli), le problème vient peut être de là, de son comportement qui à mon sens est un défaut (d'autre diront un avantage).
Je m'explique.
Quand on crée une connexion avec mysql, MySQL ou/Php (peu importe) conserve en mémoire la connexion.
Ce qui fait que n'importe où dans son code (fonction, Méthode de classe, etc ... peu importe) cette connexion pourra être exploitée sans devoir y faire référence.
Au 1er abord c'est hyper pratique car on peu en faisant un simple include du fichier de connexion et après faire des requêtes (mysql_query) n'importe où et quand sans se soucier de la portée, sans faire référence à la ressource de connexion.
En 2ème ça n'est pas si naturel que ça, ça passe outre en partie un problème de portée qu'on aurait dû avoir.
Pas loin d'être un piège.

Maintenant, en créant tes différentes classes comme ci-dessus tu ne fait que rencontrer un problème de portée de tout ce qui est de plus naturel.
$mysqli n'est pas visible dans Common, il n'y a rien d'anormal à ça.

D'ailleurs, la logique veut qu'il ne faudrait pas inclure dp.php dans Common.class.php car il va avoir une dépendance entre ces 2 Objets, faut le savoir.

Si tu as pour objectif de faire des connexions à des Objets de connexion différents (genre db1, db2, etc ... sur des serveurs différents) ce n'est pas correcte (dépendance justement).

Par contre, si tu sais par avance qu'il y aura qu'une seule et unique connexion sur un seul et unique serveur MySQL, cela toujours, et bien il n'y a pas lieu de sépararer les choses, comme créer un fichier/classe pour instancier l'Objet MySQL.
Autant le faire directement dans Common.

Faudrait faire le point sur cet éventuel problème de portée (ce n'est qu'une hypothèse).
Et aussi sur le but recherché en créant tes différentes classes.
Tout cela sauf erreur comme toujours.

**bilobar** · 17/12/2012, 22h41

En fait je veux faire qu'une connexion à une seule base de donnée et aussi mettre les valeurs des constantes de connexion à mysqli dans un fichier séparé.

J'ai trouvé une autre solution pour la connexion à mysqli : le singleton de connexion

DBAccess.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
/*PHP5 MYSQLi DB Connection Class implementing Singleton Design Pattern 
 *  
 *  
 *  Usage: 
 *   $db = DBAccess::getConnection(); 
 *   $query = "select * from TABLE"; 
 *   $result=$db->selectQuery($query); 
 */  
//error_reporting(E_NOTICE);  
 
class DBAccess{  
 
 const DB_SERVER="localhost";   
 const DB_USER="root";  
 const DB_PASS="pass";  
 const DB_NAME="dbname";  
 
 private $_connection;  
 private static $_dbinstance;  
 
/* Made the constructor private,  
* to ensures that the class can only be instantiated  
* from within itself. 
*/  
 private function __construct(){  
  try{  
   $this->_connection= new mysqli(self::DB_SERVER,  
                                     self::DB_USER,  
                                     self::DB_PASS,  
                                     self::DB_NAME);  
   if ($this->_connection->connect_error){  
       throw new Exception("Could not connect to Database.");  
   }  
  }catch(Exception $err){  
   echo $err->getMessage();  
   die();  
  }  
 
 }  
 public static function getConnection(){  
  if (is_null(self::$_dbinstance)){  
   self::$_dbinstance= new DBAccess();  
  }  
  return self::$_dbinstance;  
 }  
 /* Execute a SQL query and returns the results*/  
 public function selectQuery($query){  
  $rs=$this->_connection->query($query);  
  return $rs;   
 }  
 
//rajout
	/** 
	 * Close connection to MySQL database
	 *
	 * @access public
	 * @return void
	 */
	public function close() {
		$this->_connection->close();
	}
 
	/**
	 * Execute query and return results
	 *
	 * @access public
	 * @param string $sql MySQL statement to execute
	 * @return mixed
	 */
	public function query($sql) {
		if (!$result = $this->_connection->query($sql)) {
			return false;
		} else {
			return $result;
		}
	}
 
	/**
	 * Make data safe for database
	 *
	 * @access public
	 * @param string $data Data to be escaped
	 * @return string Sanitized data
	 */
	public function escape($data) {
		return $this->_connection->real_escape_string($data);
	}
 
	/**
	 * Prevent cloning of this class
	 *
	 * @access public
	 * @return void
	 */
	public function __clone() {
		# Issue E_USER_ERROR if clone attempted
		trigger_error('Cloning <em>mysqli_database</em> is forbidden.', E_USER_ERROR);
	}
 
 
}

en utilisant j'ai une erreur

pour la requête car
* $db = DBAccess::getConnection();
* $query = "select * from TABLE";
* $result=$db->selectQuery($query);

fait une erreur :Fatal error: Call to a member function selectQuery() on a non-object

Common.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
<?php
 
 
 
class Common{
 
 
 
    function __construct(){
    	$db = DBAccess::getConnection();
    }
 
 
	// Données entrantes
	public static function bdd($string)
	{
 
 
 ...
 
				$string = mysqli_real_escape_string($db,$string);
 
				// Échappement des caractères % et _
				$string = addcslashes($string, '%_');
 
 ...
 
			return $string;
 
 
..
 
	}
 
}
?>

User.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
<?php
class User{
 
    function __construct(){
    	$db = DBAccess::getConnection();
    }
 
	public function faire($param){
 
 
		$param =Common::bdd($param);
 
 
		$q = "UPDATE table SET name = '".$param."' ";
 
		 $result=$this->db->selectQuery($q)  or die("Error SQL in : ".$errorMethode."<br><br>".$q."<br><br>MSG : "	.$db->error);
		if (!$result)
 		 throw new Exception
   			 ("Pb d’execution de $q. ". $$db->error);
 
		else
			return $result;
	}
 
}
?>

là ça marche mieux
User.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
<?php
class User{
 
private $db;
 
    function __construct(){
    	$this->db = DBAccess::getConnection();
    }
 
	public function faire($param){
 
 
		$param =Common::bdd($param);
 
 
		$q = "UPDATE table SET name = '".$param."' ";
 
 
		 $result=$this->db->selectQuery($q)  or die("Error SQL in : ".$errorMethode."<br><br>".$q."<br><br>MSG : "	.$db->error);
 
		if (!$result)
 		 throw new Exception
   			 ("Pb d’execution de $q. ". $$db->error);
 
		else
			return $result;
	}
 
}
?>

page.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
include("DBAccess.class.php");
include("Common.class.php");
include("User.class.php");
 
$monUser = new User();
 
$monUser->faire("Paul");

**Exia_** · 18/12/2012, 08h14

Envoyé par bilobar

pour la requête car
* $db = DBAccess::getConnection();
* $query = "select * from TABLE";
* $result=$db->selectQuery($query);

fait une erreur :Fatal error: Call to a member function selectQuery() on a non-object

Common.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
<?php
class Common{
    function __construct(){
    	$db = DBAccess::getConnection();
    }
 ... 
}
?>

Bonjour,

dans ton Common.php $bd fait référence à quoi ? Une variable de la class Common ?

En POO tu ne peut pas faire référence à une variable à l'intérieur de ta classe sans utiliser $this->exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
class Test{
    private $db;
 
    public __construct(){
        $db = new mysqli(...); //Ne fonctionnera psas
        $this->db = new mysqli(...); //Fonctionnce
    }
}

Dans ton fichier Common.php tu ne déclare pas de variable $db et tu n'utilise pas $this-> dans ton constructeur :

class Common{
function __construct(){
$db = DBAccess::getConnection();
}
...
}]

essaye comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Common{
    private $db;
    function __construct(){
    	$this->db = DBAccess::getConnection();
    }
 ... 
}

pareil pour ta première class User.class.php, tu résout ce problème dans ta seconde classe User.class.php en déclarant ton attribut $db et en utilisant $this->

**bilobar** · 18/12/2012, 09h40

Dans Common.class.php j'ai rajouté la variable $bd. Je me demande si elle devrait pas être static car dans User.class.php on a : $param =Common::bdd($param);

j'ai une erreur :
Fatal error: Using $this when not in object context in ligne

$string = mysqli_real_escape_string($this->db,$string);

Common.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
<?php
class Common{
 
 
//private static $db; 
 
private  $db; 
 
    function __construct(){
 
	$this->db = DBAccess::getConnection();
 
    }
 
 
	// Données entrantes
	public static function bdd($string)
	{
 
 
				$string = mysqli_real_escape_string($this->db,$string);
 
 
				// Échappement des caractères % et _
				$string = addcslashes($string, '%_');
 
 
 
			return $string;
 
 
	}
 
}
?>

En ajoutant $db=DBAccess::getConnection();
$db->escape($string);

à la place de $string = mysqli_real_escape_string($this->db,$string);
ça semble marcher pour $param='new\y%"j_=éà'; j'obtiens : newy\%"j\_=éà
mais dans le constructeur j'ai déjà $this->db = DBAccess::getConnection();
ça fait pas un doublon ?
et la class DBAccess va être grosse à force de lui rajouter des fonctions, alors qu'elle n'est sensée etre que pour la connexion à la base.

Common.class.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
<?php
class Common{
 
 
//private static $db; 
 
private  $db; 
 
    function __construct(){
 
	$this->db = DBAccess::getConnection();
 
    }
 
 
	// Données entrantes
	public static function bdd($string)
	{
 
 
				//$string = mysqli_real_escape_string($this->db,$string);
				$db=DBAccess::getConnection();
				$db->escape($string);
 
 
				// Échappement des caractères % et _
				$string = addcslashes($string, '%_');
 
 
 
			return $string;
 
 
	}
 
}
?>

Pour fermer la connexion $monUser->$db->close(); ne marche pas.
page.php

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
include("DBAccess.class.php");
include("Common.class.php");
include("User.class.php");
 
$monUser = new User();
 
$monUserFait=$monUser->faire("Paul");
 
    /* free result set */
$monUserFait->->close();
 
/* close connection */
//$monUser->$db->close();

**Exia_** · 18/12/2012, 19h05

Bonjour,

Attention quand tu utilise les fonctions, attributs static.

Une fonction static peut être appelée alors que tu n'a pas instacié d'objet, quand tu fait juste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
//fichier Common.class.php
 
include("DBAccess.class.php");
class Common{
    private $bd;
 
    public __construct(){
        $this->bd = DBAccess::getConnection();
    }
    public static bdd($string){
        $string = mysqli_real_escape_string($this->db,$string);
        ...
    }
}
 
//Fichier User.class.php
include("Common.class.php");
class User{
 
    public function faire($param){
        $param = Common::bdd($param);
        ....
 
}
 
//Fichier index.php
$monUser = new User();
$monUserFaire = $monUser->faire("Paul");

Dans ce bout de code (qui est le tien) tu instancie un objet User puis fait appel à la fonction faire de la class User,

dans cette fonction tu déclare une variable $param et lui attribut le résultat de la fonction static bdd de la class Common,

donc tu n'a pas instancié d'objet Common donc tu n'a pas fait appel au constructeur de la class Common qui attribut à la variable bd de la class Common la valeur de retour de la fonction static getConnection() de la class DBAccess(qui est la connexion MySQL),

je pense qu'il vaudrait mieux faire un system "descendant" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
//Fichier Common.class.php
include("DBAccess.class.php");
class Common{
    private $bd;
 
    public __construct(){
        $this->bd = DBAccess::getConnection();
    }
 
    //La fonction n'est plus static donc elle nécessite l'instanciation d'un objet de type Common pour être utilisé
    public escapeString($string){
        $string = mysqli_real_escape_string($this->db,$string);
        ...
    }
}
 
//Fichier User.class.php
include("Common.class.php");
class User{
    private $bdd;
 
    public __contruct(){
        $this->bdd = new Common();
    }
 
    public function faire($param){
        $param = $this->bdd->escapeString($param);
        ....
}

Donc on déclare un objet Common comme attribut de la class User, puis on l'instancie dans le constructeur et on passe par cet objet pour pouvoir communiquer avec les fonctions de la class Common,

ou alors tu peut déclarer dans ton fichier index.php un objet Common et un objet User,

puis passer par l'objet Common pour pouvoir utiliser ses fonctions,

cependant tu va devoir revoir le code de tes deux class car tu devra passer en paramètre à la fonction faire de ta class User une connexion Mysql et la chaîne de caractère.

L'inconvénient avec la première méthode est que si tu à plusieurs objet User tu te retrouvera avec plusieurs connexion MySQL à moins que ta fonction getConnexion de la class DBAccess soit un singleton au quel cas tu n'en aura q'une seul.

**bilobar** · 19/12/2012, 00h29

Oui je n'ai pas instancié la class Common et fait appel à son constructeur qui permet de faire une une connexion à MySQL. ça veut dire que pour utiliser la méthode static $param = Common::bdd($param); il faut lui ajouter une autre connexion à la BDD et répéter pour chaque méthode static la connexion à la BDD
$db=DBAccess::getConnection();

La 1ere solution est plus facile à mettre en place.

Donc on déclare un objet Common comme attribut de la class User, puis on l'instancie dans le constructeur et on passe par cet objet pour pouvoir communiquer avec les fonctions de la class Common,

j'ai plusieurs objets User, qui ont un bon paquet fonctions.
la class DBAccess est un singleton. La fonction getConnexion() vérifie s'il existe déjà une instance de DBAccess. Il y a une seule connexion je pense.

Pour fermer la connexion à la BDD dans User j'ai rajouté une fonction close.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<?php
class User{
 
 
	....
 
	public function close() {
		$this->db->close();
	}
 
}
?>

//Fichier index.php
$monUser = new User();
$monUserFaire = $monUser->faire("Paul");
$monUserFaire->close();
$monUser ->close();

mysqli_real_escape_string($mysqli2,$string); 2 connections bdd

Langage PHP

Discussions similaires

Partager

Partager