Salut,
voila, je rencontre des soucis, je vous explique: j'en ai mare de faire des trucs qui servent presque jamais a rien alors je me suis lancé l'idée de faire un mini cms avec le model mvc...
J'ai lu quelque part q'un model mvc na comporte pas forcement 3 couches mais de 2 a autant fois que l'on désire séparer les étapes, ais-je bien compris ?
J'en reviens a mes soucis, j'ai crée cette architecture, ça marche et tous les fichiers cité existe sauf pour l'admin, ya rien il est factice

WWW/
  ├── Tadmin/ <!-- Tous ce qui intervient dans l'admin -->
  │   ├── icons/
  │   ├── css/
  │   ├── js/ 
  │   ├── liste-membres.php 
  │   ├── ajout-blog.php 
  │   ├── ajout-tutoriel.php 
  │   └── index.php 
  │
  │ 
  ├── libs/ <!-- Contient toutes les classes et fonctions des modules -->
  │   ├── classes/
  │   └── fonctions/
  │
  │  
  ├── modules/
  │   ├── blog/
  │   │   ├── exec/
  │   │   │   └── post-message.php
  │   │   ├── accueil.php
  │   │   ├── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
  │   │   └── list-blog.php
  │   │
  │   │ 
  │   ├── membres/
  │   │   ├── exec/
  │   │   │   ├── deconnexion.php
  │   │   │   └── valid-connexion.php
  │   │   ├── accueil.php
  │   │   └── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
  │   │ 
  │   │ 
  │   └── tutoriels/
  │       ├── exec/
  │       │   └── post-message.php
  │       ├── accueil.php
  │       ├── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
  │       └── list-tutoriels.php
  │
  │
  ├── template/
  │   └── model-1
  │       ├── _css/
  │       ├── _icons/
  │       ├── _img/
  │       └── _js/
  │  
  │
  ├── config.php <!-- Inclus dans module.php, config.php contient l'autoload des classes -->
  ├── index.php <!-- Est chargé d'envoyer des params $_GET au fichier module.php -->
  └── module.php <!-- Est chargé de trouver et d'inclure le fichier index.php du bon module grace a $_GET -->

Bon, ça marche pas de soucis mais comment faire pour que les classes dédié aux blog par exemple soit dans le module blog ? car la, avec la fonction autoload chargé dans le fichier module.php me pose des soucis quand je veux une classe stocké physiquement dans un module...
merci d'avance !

Bonsoir,

petit rectificatif : le modèle MVC, ce n'est pas autant de couches que l'on veut.
Il en faut au moins 3 :
- une couche d'interactions avec la base de données (modèle)
- une couche de présentation (vue)
- une couche de coordination (contrôleur)

Il peut y en avoir d'autres :
- une couche contenant la logique applicative (service, placée entre contrôleur et modèle)
- une couche de liaisons métier-IHM (form, placée entre contrôleur et IHM)
- une couche de mapping données-objets métiers (map, placée en façade de la DAL)

Concernant ton problème, PHP 5.3 introduit la notion de namespace . Je suis peut être hors sujet mais conjugé avec l'autoloading classique, cela permet de charger n'importe quelle classe, de n'importe quel module.

oui, tu as raison, je planche la dessus...
peut on utiliser plusieurs autoload pour construire une page complète ?

Oui bien sûr. La SPL propose la fonction spl_autoload_register() qui est appelé lors du mécanisme d'autoloading.

Il y a de bonnes info sur autoload : vos-contributions/autoload-php-avec-san ... 54834.html

Au passage, tu peux sortir lib de www pour que les includes ne soient pas accessible depuis le navigateur.

Mazarini, don il me manque un étage car www dans mon cas est la racine !

En fait, les bonnes pratiques incitent à alléger le webroot (www) au maximum. Cela pour des raisons de sécurité et de logique.

Généralement, le webroot contient les ressources statiques "publiques" (js, css, images) + un fichier PHP qui sert de point d'entrée à l'application.
Hors de ce webroot, tu as un dossier non accessible par navigateur contenant tous tes fichiers applicatifs (contenant tes couches MVC + les librairies).
En général tu as également un dossier "vendor", "library" ou "lib" qui contient les librairies tierces.

Tu as donc cette structure "standards" (le nommage peut être différents) [+ = dossier ; - = fichier] :
www
+ static
++ js
++ css
++ img
- index.php
app
+ models
+ views
+ controllers
vendors
+ lib1
+ lib2
+ lib3

Edit : quelques explications. Le index.php permet d'initialiser le "framework" et appelle un routeur (appelé Dispatcher, Router ou autre). Ce routeur se charge d'analyser l'URL et en déduit un module/contrôleur/action. Le contrôleur prend la main et traite l'action en utilisant la couche modèle (ou non), et en renvoyant une vue.

Alors, que je reprenne pour être sur de bien comprendre:
le dossier www que je nomme est WAMP, le www de wamp...
Voici l'archi modifier:

  WWW/
  ├── libs/ <!-- Contient toutes les classes et fonctions de l'applicatoon -->
  │   ├── classes/
  │   └── fonctions/
  │
  └── STIE/
      ├── admin/ <!-- Tous ce qui intervient dans l'admin -->
      │   ├── icons/
      │   ├── css/ 
      │   ├── js/ 
      │   ├── liste-membres.php 
      │   ├── ajout-blog.php 
      │   ├── ajout-tutoriel.php 
      │   └── index.php 
      │  
      ├── modules/ 
      │   └── membres/
      │       ├── libs/
      │       │   └── classes/ <!-- Les classes dédiés au module -->
      │       ├── exec/
      │       │   ├── deconnexion.php
      │       │   └── valid-connexion.php
      │       ├── accueil.php
      │       └── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
      │
      │
      ├── template/
      │   └── model-1
      │       ├── _css/
      │       ├── _icons/
      │       ├── _img/
      │       └── _js/
      │  
      │
      ├── config.php <!-- Inclus dans module.php, config.php contient l'autoload des classes -->
      ├── index.php <!-- Est chargé d'envoyer des params $_GET au fichier module.php -->
      └── module.php <!-- Est chargé de trouver et d'inclure le fichier index.php du bon module grace a $_GET -->

est ce que je m'n aproche ?

En fait, tu peux mettre le répertoire libs n'importe ou et ajouter ce répertoire dans l'include_path de php.

Personnellement, j'utilise dans l'include_path (dans l'ordre)
- . (rep courant)
- un répertoire pour un site
- un répertoire pour tous les sites d'un domaine
- un répertoire pour tous les sites

J'ai les répertoires :
/srv/domaine.com/www/htdocs (racine du site www.domaine.com)
et je mets libs à 3 niveaux : /srv, /srv/domaine.com et /srv/domaine.com/www
Autrement je peux avoir d'autres domaines en remplacant domaine.com par un autre domaine et d'autres sous-domaine en remplacant www par forum, wiki ou autre chose.

en fait je fait ça pour apprendre un peut plus et notamment:
- voir l'idée des mvc
- faire un système de module compatible avec d'autres sites du même système
- faire un système d'installation automatique du système avec choix des modules de départ puis des d'ajout de modules
- faire un système de réécriture d'url

je ne m'occupe même pas de l'admin, la vrai but n'est pas la...
je veux que tous ce qui concerne un module soit dans le module.
je veux qu'il y ai 2 types de modules: les espace clients (page web) et les outils (système de votes, sondage a intégré dans les espaces clients)

pour commencer, j'ai une séries de classes pour l'application (connexion, module, page) je commence avec ces 4 la...
- connexion crée les connexion et exécute les requêtes
- module trouve le bon module grâce a $_GET
- page trouve la bonne page grâce a module

ensuite, je veux dans les modules un dossier classes pour celle dédié au module même, ça ressemble a ça:

  WWW/
  ├── LIBS/ <!-- Contient toutes les classes et fonctions de l'applicatoon -->
  │   ├── classes/
  │   └── fonctions/
  │
  └── STIE/
      ├── ADMIN/ <!-- Tous ce qui intervient dans l'admin -->
      │   ├── class/
      │   ├── icons/
      │   ├── css/ 
      │   ├── js/ 
      │   ├── liste-membres.php 
      │   ├── ajout-blog.php 
      │   ├── ajout-tutoriel.php 
      │   └── index.php 
      │  
      ├── MODULES/
      │   ├── accueil/
      │   │   ├── class/
      │   │   │   ├── classe-1.php
      │   │   │   ├── class-2.php
      │   │   ├── exec/
      │   │   │   └── post-message.php <!-- envois les message  -->
      │   │   ├── accueil.php
      │   │   ├── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
      │   │   └── contact.php
      │   │
      │   │ 
      │   ├── BLOG/
      │   │   ├── class/
      │   │   │   ├── classe-1.php
      │   │   │   ├── class-2.php
      │   │   ├── exec/
      │   │   │   └── post-message.php
      │   │   ├── accueil.php
      │   │   ├── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
      │   │   └── list-blog.php
      │   │
      │   │
      │   └── MEMBRES/
      │       ├── class/
      │       │   ├── classe-1.php
      │       │   ├── class-2.php
      │       ├── exec/
      │       │   └── post-message.php
      │       ├── accueil.php
      │       ├── index.php <!-- Est chargé de trouver et d'inclure la page demander au module si non c'est accueil.php -->
      │       └── list-tutoriels.php
      │
      │
      ├── TEMPLATE/
      │   └── model-1/
      │       ├── _css/
      │       ├── _icons/
      │       ├── _img/
      │       └── _js/
      │  
      │
      ├── config.php <!-- Inclus dans module.php, config.php contient l'autoload des classes -->
      ├── index.php <!-- Est chargé d'envoyer des params $_GET au fichier module.php -->
      └── module.php <!-- Est chargé de trouver et d'inclure le fichier index.php du bon module grace a $_GET -->

est ce que cela vous semble cohérent ?

Pour moi, il y a 2 principes possible :
1) Faire 1 répertoire par module avec des répertoires par "type" (js, css...)
2) Faire des répertoires par type avec des sous répertoires par module

Je me sais pas qu'elle est la meilleure option entre les 2.

ok mais alors, je ne suis ni dans le vrai ni dans le faux ?
je peux donc, partant du principe que cette construction me convient parfaitement, continuer ma route ?

ok mais alors, je ne suis ni dans le vrai ni dans le faux ?
je peux donc, partant du principe que cette construction me convient parfaitement, continuer ma route ?

Bah oui, toute construction est dans le vrai sous certaines conditions.
Si dans 5ans tu t'y retrouves toujours et que tu es la seule sur le projet tu peux faire ce que tu veux (et ce même si c'est incompréhensible comme organisation pour le commun des mortels).
Si par contre dans 5ans le projet accueille de nouveaux devs il te faut une structure qu'ils pourront comprendre ou bien adapter rapidement.

Sache que tu es absolument libre de développer le système qui te convient. C'est bien là le plaisir de l'informatique !

Maintenant, dans un contexte professionnel, le respect des bonnes pratiques et l'utilisation de standards (PSR-0, PSR-1) ont le vent en poupe.
Ton idée de module est une notion qui existe dans les principaux frameworks PHP du marché. Ainsi tu auras affaire à des bundles en SF2, des modules sous Zend et des plugins sous CakePHP. Leur implémentation dans ces frameworks différe, notamment pour l'inclusion des ressources statiques : assets sous SF2 (voir assetic) ; lecteur PHP sous CakePHP.

Bref tu es libre de coder comme bon te semble, tout en sachant que des choses existent déjà. N'hésite pas à jeter un coup d'oeil, histoire de prendre des idées.

D'un autre coté quelqu'un qui s'interroge sur l'organisation de ses fichiers n'aura certainement pas tout faux quelque soit les choix faits.
Chaque organisation a ses avantages et ses défauts.