On peut en profiter pour changer de paradigme de programmation PHP.
En effet, la page PHP peut être conçue comme un objet et ainsi éviter la programmation linéaire quon retrouve dans la majorité des codes d'aujourd'hui.
Cette méthode adoptée aujourd'hui est devenue un classique bavare. PHP en souffre, puisque la programmation linéaire ou procédurale présente l'incenvénient majeur de non lisibilité = non spécialisétion du code = difficulté de maintanance.
En effet, PHP est souvent confondu avec HTML puisque les deux cohabitent parfaitement dans la même page.
PHP s'est lancé exactement comme BASIC, les programmeurs débutant s'y lancent sans prérequis de programmeurs, sans connaissances approfondis ou naicéssaires du langage PHP ou HTML et sans même la connaissance suffisante de l'environnement PHP, du serveur Web le motorisant.
Certains abordent l'approche base de données (MYSQL souvent) sans connaisance du modèle relationnel.
Ils avancent avec les erreurs.
Cette approche de PHP, prétend à tord servir le programmeur. Certes, PHP peut être assimilé à BASIC, mais le programmeur doit faire des efforts pour mieux le connaitre avec le temps en étendant ses connaissances et son savoir-faire sur les domaine connexes (configuration de l'environnement, spécialité de HTML, spécialité du SGBDR, ...)
L'approche Objet est souvent absente, les programmeurs croient à tord que ce domaine est floue voir difficile à aborder où alors c'est un terrain professionnel difficile d'accès.
Ne soyons pas péssimiste, le modèle objet clarifie et organise la solution.
C'est une approche conceptuelle plus qu'elle n'est une technique de programmation. Une solution sans méthodologie conceptuelle n'est pas construite sur des bases solides.
PHP OBJET permet de remplir ce vide conceptuel. Le programmeur a deux cassequettes alors :
"L'analyste" et "le programmeur" = "le développeur de solutions"
Un exemple conceptuel :
Dans un environnement client/serveur Web, les fonctions doivent se spécialiser :
Le Client : gére le dialogue avec utilisateur et avec le serveur
Le Serveur : (Main) oriente les tâches vers un module de traitement (décision, calcul ...) et/ou un système spécialisé dans le traitement de données (SGBDR, système de fichiers ...)
Les modules de traitement sont des objets spécialisés qui peuvent se diviser en deux types :
- Des objets métiers
- Des objets techniques (services)
Les objets métiers se consacrent aux traitements de requêtes de données métiers. Ils prennent en charge les communications avec le SGBDR (la base de données métier)
Ces objet doivent être ouverts, ils reçoivent des requêtes et revoient des données non formatées. ce qui rend leurs méthodes de fonctionnement totalement indépendantes de celles de leurs environnement (client, le module maitre (main), ou autres objets techniques...)
C'est là même la définition d'un objet, qui doit être architecturé (modélisé selon une classe unique), autonome, ouvert(interfaçable, régulable et senssibles aux évennements et execptions), réutilisable, extenssible, facilement maintenable et abstrait par rapport au langage de programmation.
Le niveau d'abstraction d'une classe d'objet est forcement élevé par-rapport à l'objet réellement exécutable dans un environnement physique.
C'est une pur approche analytique à la base de l'objet.
Dans le cadre d'une architecture 3-tiers, le modèle objet peut être conçu de la façon suivant en utilisant PHP.
1. HTML/et le script-côté-client (javascript ou vbscript) qui représentent le client : Un objet Client doit donc se pécialiser dans le dialogue bi-directionnel utilisateur/serveur
2. PHP étant le script exécuté côté serveur doit servir à créer des objets serveurs spécialisés notamment : le maitre d'opérations (main), l'objet base de données métier et d'autres objets techniques qui coopérent pour effectuer des actions techniques (calcul, organisation et formatage des données, gestion des exéceptions, des sessions et des paramètres reçus du clients...)
Voici un exemple où tout est objet :
Description de la Solution :
Le client se connecte en donnant son login et mot de passe, le serveur reçoit ses paramètres, intérroge la base de données des comptes logée sous MYSQL et communique au client le résultat qu'il attend. Deux résultats sont attendues :
Règle d'emission du résultat :
- 1. Si la connexion est approuvée le client se voit redérigé vers le site d'accueil
2. Dans tous les cas d'erreurs ou de connexion non approuvée, le résultat est un message explicatif selon le cas.
C'est une analyse ascendante qu'il faut entreprendre pour construire les classes d'objets.
1. Cerner les fonctionnalités qui permettent de réaliser un certain nombre d'objectifs non héterogènes dans un même groupe
A cette étape on peut déjà séparer deux groupes :
a. l'interface qui permet au client d'envoyer son login et mot de passe et
de recevoir un message d'erreur venant du serveur
b. la validation de la connexion en recevant les paramètres (login et mot de passe) de l'utilisateur et en décidant de l'action résultat
On peut parler ici d'une table de décision, qui représente conceptuellement parlant les contraintes ou règles de gestion et qui selon la méthode booléenne, est représentée par une étude d'états logiques de plusieurs variable logiques afin de déclencher des actions (physiqument représentée par la structure conditionnelle SI ou IF)
On sait que pour qu'une décision soit prise une condition logique doit être évaluée.
Dans ce cadre, on peut sudiviser le groupe "b" en deux types de rôles :
b1. est la table de décision selon l'état logique retourné par la fonction de validation des connexion (cf. la règle d'emission du résultat)
b2. permet à b1 de décider en validant la connexion à partir de la base des comptes
Selon ce découpage simple, 3 objets surgissent :
OBJET FORM : groupe a (interagit avec b1) spécialisé dans l'affichage et la capture des paramètres utilisateur
OBJET CONNEXION : groupe b1 (interagit avec a et b2) et décide de l'action à faire selon l'état de validation de la connexion
OBJET COMPTE : groupe b2 (interagit avec b1) spécialisé dans l'interaction avec la base de données
L'objet CONNEXION est le programme maitre d'opérations puisqu'il joue le rôle d'intemédiaire entre (a) l'utilisateur et (b) le SGBDR
En créant une instance de cet objet le système de validation démarre, en démarrant l'objet (a) et en intérrogeant (b2).
Les principaux flux de données entre Objets sont :
f1 : Paramètres de connexion prévalidés (contiennent des données) envoyés par (a) à (b2) via (b1)
f2 : Etat logique d'acceptation ou pas de la connexion envoyé par (b2) à (b1)
f3 : Message d'erreur envoyé par (b1) vers (a) dans le cas d'un f2 faux
f4 : Entête HTTP contenant le document d'accueil, dans le cas d'un f2 vrai
Bien entendu, d'autres flux peuvent exister.
Les classes d'objets :
Toutes les classes sont écrites dans la page : mes_classes.cls
Vous pouvez ajouter des modificateurs "public ou private" aux membres
des classes pour les publier ou pas.
N.B: que dans ce site Objet exemple, il n'ya que la page de démarrage
connexion.php et la page mes_classes.cls qui contient toutes les ressources (ou pages) du site sous forme de classes.
Il est aussi possible de créer une seule classe modèle de page HTML dont
peuvent hériter toutes les autres classe à caractère "interface utilisateur".
<?php
//Objet a: définissant le comportement de l'interface utilisateur
Code : Tout sélectionner
class form {
var $login;
var $motDePasse;
var $message;
var $fin;
//Construction d'un formulaire
function form() {
//si des paramètres sont issus du précedent dialogue
//alors Pré validation
$this->login = null; $this->$this->motDePasse = null;
$this->fin = false;
if (!isset ($_POST["login"])
|| trim($_POST["login"]) == "" ) $this->message = "Login obligatoire!";
else if (!isset ($_POST["motDePasse"])
|| trim($_POST["motDePasse"]) == "" ) $this->message = "Mot de passe obligatoire";
else {
//login et mot de passe correctement passés
$this->login = $_POST["login"];
$this->motDePasse = $_POST["motDePasse"];
}
}
function afficher() {
echo "
<h1>Connexion</h1>
<form method=post>
<table>
<tr><td>Login* <td><input name=login value=$this->login>
<tr><td>Mot de passe* <td><input type=password name=motDePasse>
<tr><td colspan=2><input type=submit value=Ok>
<input type=reset value=Effacer>
<tr><td colspan=2><div id=message>$this->message</div>
</table>
</form>";
}
} Code : Tout sélectionner
class connexion {
//interlocuteur principal avec l'objet (a) form et l'objet (b2) compte
var $form;
var $compte;
//Construction de l'objet
function connexion() {
//Démarre la validation des connexions
$this->valider();
}
//Gérer le dialogue utilisateur
function valider() {
//En créant un objet form, des paramètres de la session précédente
// sont capturés et validés s'ils existent
$this->form = new form();
if ($this->form->login != null
&& $this->form->motDePasse != null) {
//Valider la connexion
$this->compte = new compte();
//passage du flux f1
$this->compte->login = $this->form->login ;
$this->compte->motDePasse= $this->form->motDePasse;
//Demande d'approbation (Table de décision) et flus f2
if ($this->compte->approuvé()) {
//Ouvrir le site pour une bonne connexion (flux f4)
$_SESSION["compte"] = $this->compte;
//Arrêt du dialogue = accès à la page d'accueil
$this->form->fin = true;
}
//envoyer un message pour une mauvaise connexion (flus f3)
else $this->form->message = "Connexion échouée!";
}
//Afficher le formulaire de dialogue
if (!$this->form->fin ) $this->form->afficher();
}
} Code : Tout sélectionner
class compte {
//source de données
var $source;
//Identité d'un utilisateur
var $login;
var $motDePasse;
var $nom;
var $email;
//construction de compte = relier l'objet à une source de données
function compte() {
$this->source = mysql_connect("localhost","root","");
if (!$this->source) $this->source = null;
else if (!mysql_select_db("ma_base", $this->source))
$this->source = null;
}
//Approuver un utilisateur
function approuvé() {
//erreur de connexion
if ($this->source == null ) return false;
//Vérifier si l'utilisateur identifié par le login et motdePasse existe
$sql = "SELECT nom, email FROM compte WHERE login='$this->login' AND motDePasse = '$this->motDePasse'" ;
$reponse = mysql_query($sql,$this->source);
if (mysql_num_rows($reponse) > 0) {
//completer les informations approuvées
$user = mysql_fetch_object($reponse);
$this->nom = $user->nom;
$this->email = $user->email;
return true;
} else return false;
}
} Code : Tout sélectionner
class accueil {
//Compte d'accès à cette page
var $compte;
var $message;
//Construction de la page
function accueil() {
//Accès autorisé si un compte est passé par la session
$this->compte = null;
if (!isset ($_SESSION["compte"])) $this->message = "Page sécurisée, connectez-vous!";
else
{
//Récupérer le compte
$this->compte = new compte();
$this->compte = $_SESSION["compte"];
}
$this->afficher();
}
function afficher() {
if ($this->compte != null) {
$nom = $this->compte->nom;
echo "
<h1>Accueil</h1>
bienvenue $nom
";
}
else echo "<div id=message>$this->message</div>";
}
} Pour Exécuter la validation des connexion il suffit de créer une instance de l'objet (b1) connexion puisqu'il est programmé pour construire un dialogue entre l'utilisateur (a) et la base des comptes (b2)
Exemple de page de démarrage :
Page connexion.php
Code : Tout sélectionner
<?
session_start();
//Exemple de page de démarrage :
//Page connexion.php
include_once "mes_classes.cls";
$connexion = new connexion();
//Si le dialogue s'arrête = la connexion est valide = accès à la page d'accueil
if ($connexion->form->fin) $accueil = new accueil();
?>contient toutes les classes, cette page est chargée une fois, Cependant
selon l'avancement de l'algorithme l'interpréteur n'a pas besoin de la
description de toutes les classes, il est possible alors de diviser la page
des classes en plusieurs pages et ne les charger qu'en cas de besoin.
