Forum d'entraide PHPFrance

Bonjour,

Aujourd'hui, j'ai décider de me mettre au PHPOO. Donc pour commencer, j'ai chercher comment faire un module de connexion.
Ah oui, j'ai oublié de dire que j'ai quelques petites connaissance en POO dû à Java

Donc j'ai chercher un module sur internet et j'ai trouver un exemple qui fonctionne très bien. Je l'ai adapté à mon projet et j'ai même créé une fonction supplémentaire me permettant de sortir une requête sous forme d'array.
Voici ce que ça donne :
Classe Connexion :

<?php
class Connexion {

private $id;
private $host;
private $user;
private $pass;
private $base;
private static $instance;

	private function __construct($host, $user, $pass, $base)
    {
    $this->setHost($host);
    $this->setUser($user);
    $this->setPass($pass);
    $this->setBase($base);
		try {
		$this->id = $this->connect($this->host, $this->user, $this->pass);
		}
		catch (Exception $e) {
		header("Location:./erreur.php?erreur='" . $e->getMessage() . "'&code='1'");
		// DEBUGAGE echo $e->getMessage().'<br>Fichier: '.$e->getFile().'<br>Ligne: '.$e->getLine();
		}
    
		try {
		$this->selection($base, $this->id);
		}
		catch (Exception $e) {
		header("Location:./erreur.php?erreur='" . $e->getMessage() . "'&code='1'");
		// DEBUGAGE echo $e->getMessage().'<br>Fichier: '.$e->getFile().'<br>Ligne: '.$e->getLine();
		}
	}
    
    private function setHost($host)
    {
		if (!isset($host))
		header("Location:./erreur.php?erreur='serveur_vide'&code='1'");
		else
		$this->host = $host;
	}
    
	private function setUser($user)
    {
		if (!isset($user))
		header("Location:./erreur.php?ereur='user_vide'&code='1'");
		else
		$this->user = $user;
	}
    
    private function setPass($pass)
    {
		if (!isset($pass))
		header("Location:./erreur.php?erreur='pass_vide'&code='1'");
		else
		$this->pass = $pass;
    }
    
    private function setBase($base)
    {
		if (!isset($base))
		header("Location:./erreur.php?erreur='base_vide'&code='1'");
		else
		$this->base = $base;
    }
    
    private function selection ($base, $db)
    {
	$ret = mysql_select_db($base, $db);
		if (isset($ret) && empty($ret))
		throw new Exception("selection_base_impossible");
	return $ret;
    }
    
	private function connect($host, $user, $pass)
    {
    $ret = mysql_connect($host, $user, $pass) or die();
		if (isset($ret) && empty($ret))
		throw new Exception("connexion_base_impossible");
    return $ret;
    }
    
	public static function getConnexion($host, $user, $pass, $base)
    {
		if ((!isset($instance)))
		$instance = new Connexion($host, $user, $pass, $base);
	return $instance;
    }
    
	public function execute($requete)
    {
		if (!isset($this->id) && empty($this->id))
		$this->getConnexion($host, $user, $pass, $base);
		else {
			if (!isset($requete) && empty($requete))
			header("Location:./erreur.php?erreur='requete_invalide'&code='1'");
			else {
				try {
				mysql_query($requete) or die("Erreur" . mysql_error());
				}
				catch(Exception $e) {
				header("Location:./erreur.php?erreur='requete_impossible'&code='1'");
				}
			}
		}
    }
    
	public function getNbLignes()
    {
		if (!isset($this->id) && empty($this->id))
		$this->getConnexion($host, $user, $pass, $base);
		else
		return mysql_affected_rows($this->id);
    }
    
    public function select($req)
    {
		if (!isset($this->id) && empty($this->id))
		$this->getConnexion($host, $user, $pass, $base);
		else {
			if (!isset($req) && empty($req))
			header("Location:./erreur.php?erreur='requete_invalide'&code='1'");
			else {
				try {
				$resultat = mysql_query($req);
				}
				catch(Exception $e) {
				header("Location:./erreur.php?erreur='requete_impossible'&code='1'");
				}
			return $resultat;
			}
		}
	}
	public function resultab($req)
	{
		if (!isset($this->id) && empty($this->id))
		$this->getConnexion($host, $user, $pass, $base);
		else {
			if (!isset($req) && empty($req))
			header("Location:./erreur.php?erreur='requete_invalide'&code='1'");
			else {
				try {
					$i = 0;
					$sql = $this -> select($req);
					while($result = mysql_fetch_array($sql)){
					$resultat[$i] = $result[0];
					$i++;
					}
				}
				catch(Exception $e) {
				header("Location:./erreur.php?erreur='requete_impossible'&code='1'");
				}
			return $resultat;
			}
		}
	}
    
	
	public function __destruct()
    {
		if ( !isset($this->instance) && empty($this->instance))
		{
			try
			{
			mysql_close($this->id);
			}
			catch(Exception $e)
			{
			header("Location:./erreur.php?erreur='fermeture_impossible'&code='1'");
			}
		}
		else
		header("Location:./erreur.php?erreur='fermeture_impossible'&code='1'");
	}
}

?>

Et voici l'index :

<?php
require('classe/connexion.php');
$connexion = Connexion::getConnexion("localhost", "root", "", "projet");

$sql = "SELECT nom_client FROM client";
$result = $connexion -> resultab($sql);
$i = 0;
while($i != count($result)){
echo $result[$i].'<br />';
$i++;
}
?>

Bon, c'est bien beau tout ça. Mais pour moi c'est de la bidouille et j'aime bien comprendre ce que je fais.
J'ai donc créer un autre module de connexion et un autre index, fait par moi même cette fois ci.
Ma classe Connexion :

<?php
class Connexion
{

	public function __construct($host, $login, $pass, $base)
	{
	$connect = mysql_connect($host, $login, $pass);
	mysql_select_db($base, $connect);
	}
	
	public function lire($champ, $table)
	{
	$sql = "SELECT $champ FROM $table";
	$query = mysql_query($sql) or die('impossible');
	$i=0;
		while($data = mysql_fetch_array($query))
		{
		$result[$i] = $data[0];
		$i++;
		}
	return $result;
	}
}
?>

Mon index :

<?php
require('classe/Connexion.php');
$connexion = new Connexion("localhost", "root", "", "projet");

$result = $connexion -> lire("nom_client","client");
$i=0;
	while($i != count($result))
	{
	echo $result[$i].'<br />';
	$i++;
	}
?>

Voila, quand je charge les deux pages, j'ai exactement le même résultat.
Bon, je comprend bien que le premier que j'ai trouvé sur le net est beaucoup plus sophistiqué et plus performant je pense.
Cependant, j'aimerais comprendre la différence, la fonctionnalité qui y diffère?

Pouvez vous m'éclaircir sur ce point?

Merci d'avance

Albat90

La class que tu as trouvé réalise une connexion statique. Concernant la connexion c'est une version plus sophistiquée (car elle vérifie tous les paramètres) de cette version de base

Essaies à partir de la version de base puis voit ensuite les fonctions ajoutées.

Tu verras que ce sont des fonctions de contrôles de paramètres qui sont au début de ta classe (différence par rapport au lien que je t'ai donné ci-dessus)

Ensuite tu trouve une fonction "public function execute" qui te permet d'effectuer une requête (sans retourner de résultat).

Puis une fonction "public function getNbLignes()" qui te permet de retourner le nombre de lignes affectées par la requête.

Une public function select($req) qui te permet d'effectuer une requête et qui retourne un résultat.

Une fonction public function resultab($req) qui effectue une requête en utilisant la fonction select($req) précédente et qui retourne un tableau.

Et enfin une fonction public function __destruct() qui te permet de fermer la connexion (perso je laisse faire php pour clore automatiquement les connexions sinon il peux y avoir des pb pour une re connexion).

Donc ben voilà, par rapport à ton code la connexion est faite en statique avec des vérifications des paramètres et puis, il y a des fonctions préparées que tu n'utilise pas pour ton besoin précis mais qui pourraient servir dans d'autre cas.

Merci beaucoup pour ta réponse.
Je vais essayer d'arriver à ce résultat en passant par la connexion de base.
La fonction "resultab" n'était pas incluse à l'origine, c'est moi qui l'ai créé pour assouvir mes besoins, en essayant de respecter au maximum la manière employée pour développer les autres fonction

Albat90

Ah je me disais aussi... Dans une classe on ne met que des fonctions génériques que l'on utilise ensuite suivant ses besoins.

La bonne méthode est d'utiliser les fonctions de la classe et non pas de créer une fonction spécifique pour chaque besoin particulier.

Ici tu veux mettre tes résultats dans un tableau. Donc tu utilises les fonctions de la classe et tu fais par exemple :

<?php
require('classe/connexion.php');
$connexion = Connexion::getConnexion("localhost", "root", "", "projet");

$sql = "SELECT nom_client FROM client";
$result = $connexion -> select($sql);

$tab_result = array();

while ($ligne = mysql_fetch_assoc($result))
{
$tab_result[] = $ligne['nom_client'];
}

//vérification du résultat
echo '<pre>';
print_r($tab_result);
echo '</pre>';
?>

Voilà sur le principe d'utilisation d'une classe.


Sinon, la fonction de base que je t'ai donnée en lien possède un avantage par rapport à celle que tu as trouvée, c'est qu'elle évite d'avoir à faire apparaître les paramètres de connexion dans chaque script php. Et au cas où tu aurais plusieurs bases à utiliser dans le même projet il te suffirait de t'inspirer du message de Zeus qui suit ma réponse dans le même sujet.

C'est plus sécurisant de ne pas avoir les paramètres de connexion (mot de passe etc.) inscris dans toutes les pages php.

Dans l'idéal je ferais donc un mélange pour reprendre le meilleur de ces deux classes