Utiliser les classes en PHP (programmation en couches) [Résolu]

[West-tck]

Bonjour,

J'ai 4 couches, je prends l'exemple d'une seule entité :

- Mon IHM : où je construit mon entité via un formulaire et où je l'envoie à la BAL.
Dans l'interface j'utilise :

Code :

1
2
include'./Persistance/BAL/OperationBAL.php';
include'./Classes/Operation.php';

- Ma BAL : où l'entité de l'IHM est reçue puis transmise à DAL pour être traitée.
Ici j'utilise :

Code :

include'C:\wamp\www\test\Persistance\DAL\OperationDAL.php';

- Ma DAL : où je traite la requête et où j'insère la donnée.

- Ma couche métier : où est déclarée mon entité.

Pourriez-vous me dire si c'est correct de procéder ainsi où si je peux passer par un autre moyen pour utiliser mes classes ?
(Les include en cascade me dérangent un peu en fait).

Merci d'avance.

[Bisûnûrs]

Si tu es en PHP5, tu peux utiliser la fonction magique __autoload().

[Benjamin Delespierre]

Un mot d'explication.

En PHP, on a souvent tout un tas de classes à utiliser mais on ne peux pas s'amuser à toutes les charger pour des raisons évidentes de performances.
PHP est capable, au travers de l'autoloader, de charger dynamiquement les classes, c'est à dire au moment où elles sont effectivement utilisées. Pour cela, on va décrire toutes nos classes dans des fichiers séparés (une bonne pratique consiste à nommer ces fichier <nom_classe>.class.php). L'autoloader, lorsqu'il est invoqué va regarder dans l'include path de PHP s'il trouve un fichier correspondant à cette classe. Son comportement est entièrement surchargeable par une fonction ou méthode et il est même possible de spécifier les extension de fichiers à reconnaitre (voire une série d'extensions possibles). Par exemple, une surcharge d'autoload pourrait aller charger des classes depuis un package PHAR au lieu de regarder l'include path.
L'autoloader peut également être appelé explicitement en invoquant spl_autoload.

Dans le cadre de PHP 5.3 et l'ajout des namespaces, la donne change: plusieurs classe peuvent avoir le même nom si elles ne sont pas dans le même namespace. On peut donc mettre nos classes dans une arborescence (qui correspond à l'arborescence de nos namespaces) et surcharger l'autoloader pour qu'il trouve le "chemin" de la classe à charger.
Par exemple: si on essaie de charger \foo\bar\MaClasse, l'autoloader pourrait aller voir dans /var/www/lib/foo/bar/MaClasse.class.php.
Il me semble que l'autoloader natif est incapable d'une telle chose.

A lire:
http://php.net/manual/en/language.oop5.autoload.php
http://www.php.net/manual/en/functio...d-register.php
http://www.php.net/manual/en/functio...extensions.php
http://www.php.net/manual/en/function.spl-autoload.php

[West-tck]

Merci beaucoup pour vos réponses.

Bonne journée.

[Bisûnûrs]

A savoir aussi, l'autoload se déclenche si et seulement si le fichier de ta classe n'a pas pu être trouvé avant. Donc si tu as laissé un include de ta classe par mégarde, l'autoload ne chargera pas une deuxième fois le fichier (ce qui provoquerait une erreur fatale de classe déjà définie).


Une technique de chargement des fichiers (utilisée notamment dans des frameworks comme ZendFramework) est d'appeler les classes en fonction du dossier dans lequel elle se trouve.
Par exemple :

driver/connectiondb/mysql/mysql.class.php
driver/connectiondb/postgresql/postgresql.class.php

Code :

1
2
Class Driver_ConnectionDB_MySQL {}
Class Driver_ConnectionDB_PostGreSQL {}

Puis dans l'autoload de remplacer les "_" par des "/".

[Benjamin Delespierre]

Zend Framework utilise cette notation pour contourner le manque de namespace dans les environnements PHP < 5.3 mais ça donne des noms de classes à rallonge. Personnellement j'utilise la notation Java (ce qui est fait pour les classes natives du langage par ailleurs).

[West-tck]

J'utilise également la notation JAVA qui est plus légère à mon sens

J'ai pu tester __autoload() , voici le code de la fonction :
Fichier Autoloader.php :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
function __autoload($classname)
{
    if(file_exists('./Classes/'.$classname.'.php'))
    {
        require_once ('./Classes/'.$classname.'.php');
    }
    elseif(file_exists('./Persistance/BAL/'.$classname.'.php'))
    {
        require_once ('./Persistance/BAL/'.$classname.'.php');
    }
    elseif(file_exists('./Persistance/DAL/'.$classname.'.php'))
    {
        require_once ('./Persistance/DAL/'.$classname.'.php');
    }
    else
    {
        throw new Exception('Classe not found');
    }
}
?>

J'ai simplement eu à inclure mon fichier Autoloader.php dans mon IHM et cela fonctionne parfaitement.

A savoir aussi, l'autoload se déclenche si et seulement si le fichier de ta classe n'a pas pu être trouvé avant. Donc si tu as laissé un include de ta classe par mégarde, l'autoload ne chargera pas une deuxième fois le fichier (ce qui provoquerait une erreur fatale de classe déjà définie).

J'ai rencontré ce cas, c'est vrai il faut bien être vigilent.

Merci pour votre aide.

[Benjamin Delespierre]

Tu verras si tu fais un profiling que les file_exists sont très couteux en cycle CPU (chez moi ça représente environ 30% pour un appli de moyenne envergure alors imagine avec 500 classes).
Tu peux te servir du retour de la directive include qui renvoie un booléen en faisant:

Code :

return @include $file;

Tu peux réduire tout ça:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
$include_path = explode(PATH_SEPARATOR, get_include_path()) + array(
  './Classes/',
  './Persistance/BAL/',
  './Persistance/DAL/',
);
 
if (!set_include_path(implode(PATH_SEPARATOR, $include_path)))
  die('Cannot Start Application: include path defintition failed');
 
spl_autoload_extensions(".class.php, .php");
spl_autoload_register();

Tout simplement

[West-tck]

Merci bien pour l'info, je ne savais pas du tout. Je vais passer plus de temps la dessus pour approfondir ça alors.

[ovh]

Pourquoi réinventer la roue et ne pas utiliser un framework ?

[West-tck]

Code :

return @include $file;

Code :

1
2
3
4
5
6
7
8
9
10
11
$include_path = explode(PATH_SEPARATOR, get_include_path()) + array(
  './Classes/',
  './Persistance/BAL/',
  './Persistance/DAL/',
);
 
if (!set_include_path(implode(PATH_SEPARATOR, $include_path)))
  die('Cannot Start Application: include path defintition failed');
 
spl_autoload_extensions(".class.php, .php");
spl_autoload_register();

Je ne comprends pas la première partie avec le return, où effectuer ce code ? A quoi correspond-il ?

Pour la deuxième partie du code je n'arrive pas à saisir non plus, y aurait-il une partie du cours qui traite de cela, où pourriez-vous me donner quelques explications (car je débute vraiment).

Merci d'avance pour vos réponses.

[Benjamin Delespierre]

Tout est expliqué dans le manuel. Dans mon exemple on se sert du comportement classique de l'autoloader - comportement qui consiste à chercher dans l'include path de PHP un fichier portant le nom de la classe et qui à une extension qui correspond aux extensions autorisées.

Donc résumons nous:
1 - Définition de l'include path
2 - Définition de(s) extension(s) autorisée(s)
3 - Activation de l'autoloading

La première partie servait à montrer comment faire un include de manière à ne pas avoir à se servir de file_exists. Elle n'est pas utile à la compréhension de mon exemple.

[West-tck]

Ok merci bien, je vais commencer par ça alors.

[West-tck]

J'ai remplacé :

Autoloader.php :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
function __autoload($classname)
{
    if(file_exists('./Classes/'.$classname.'.php'))
    {
        require_once ('./Classes/'.$classname.'.php');
    }
    elseif(file_exists('./Persistance/BAL/'.$classname.'.php'))
    {
        require_once ('./Persistance/BAL/'.$classname.'.php');
    }
    elseif(file_exists('./Persistance/DAL/'.$classname.'.php'))
    {
        require_once ('./Persistance/DAL/'.$classname.'.php');
    }
    else
    {
        throw new Exception('Classe not found');
    }
}
?>

par

Autoloader.php :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
$include_path = explode(PATH_SEPARATOR, get_include_path()) + array(
  './Classes/',
  './Persistance/BAL/',
  './Persistance/DAL/',
);
 
if (!set_include_path(implode(PATH_SEPARATOR, $include_path)))
  die('Cannot Start Application: include path defintition failed');
 
spl_autoload_extensions(".class.php, .php");
spl_autoload_register();
?>

J'obtiens l'erreur suivante :
Fatal error: spl_autoload() [function.spl-autoload]: Class OperationBAL could not be loaded in C:\wamp\www\Moprojet\IHM\AfficherOperation.php on line 21

Faut-il mettre ce bout de code dans une fonction ? ou est-ce que l'implémentation que j'en ai fait est incorrecte ?

Je bloque un peu à ce niveau

Merci pour votre aide.

[Benjamin Delespierre]

Vérifie bien que les paths relatifs dans l'include path sont valides. Tu n'as pas besoin de mettre tout ça dans une fonction, tu peux le mettre directement dans le bootstrap de ton application.

[West-tck]

Au niveau de mon fichier Autoloader.php :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
$include_path = explode(PATH_SEPARATOR, get_include_path()) + array(
        './Classes/',
        './Persistance/BAL/',
        './Persistance/DAL/',
    );
 
    if (!set_include_path(implode(PATH_SEPARATOR, $include_path)))
        die('Cannot Start Application: include path defintition failed');
 
    spl_autoload_extensions(".class.php, .php");
    spl_autoload_register();

Si j'ai bien compris : la variable $include_path va contenir un chemin du type
- C:/wamp/www/Monprojet/Classes/
- C:/wamp/www/Monprojet/Persistance/BAL/
- C:/wamp/www/Monprojet/Persistance/DAL/
?

Car j'ai lu la doc mais je ne saisit pas très bien comment utiliser ces fonctions.
Au niveau du bootstrap : à quoi correspond-il ? pour le moment j'ai un fichier Autoloader.php que j'inclut dans tous les fichiers qui utilisent des classes.

[West-tck]

Je ne suis pas arrivé à adapter le code pour mon autoload.

Néamoins j'ai modifié mon code initial :
Autoloader.php :

Code :

1
2
3
4
5
6
7
8
 
set_include_path(get_include_path().PATH_SEPARATOR.dirname(__FILE__).'/Classes');
set_include_path(get_include_path().PATH_SEPARATOR.dirname(__FILE__).'/Persistance/BAL');
set_include_path(get_include_path().PATH_SEPARATOR.dirname(__FILE__).'/Persistance/DAL');
function  __autoload($className)
{
    require $className.'.php';
}

Cette implémentation se comporte de façon à peu près similaire que votre implémentation (si j'ai bien compris ).

Merci pour votre aide.

[Benjamin Delespierre]

Code :

1
2
3
4
5
6
7
8
9
10
11
$include_path = array_merge(explode(PATH_SEPARATOR, get_include_path()), array(
  dirname(__FILE__) . '/Classes/',
  dirname(__FILE__) . '/Persistance/BAL/',
  dirname(__FILE__) . '/Persistance/DAL/',
));
 
if (!set_include_path(implode(PATH_SEPARATOR, $include_path)))
  die('Cannot Start Application: include path defintition failed');
 
spl_autoload_extensions(".class.php, .php");
spl_autoload_register();

Un seul set_include_path suffit. Je m'étais trompé, il fallait un array_merge et non une addition ici