Zend vient de diffuser une première version de développement de Zend Framework 2.0 afin de faire découvrir les quelques nouveautés de la bibliothèque PHP5.

Au programme, tout comme Symfony 2, Zend Framework 2.0 sera entièrement conçu pour PHP 5.3 avec les « namespaces ».

Pas de nouvelle pour Zend Tool à l'heure actuelle

Toutefois rien de bien nouveau sur cette version de développement. Elle correspondant principalement aux librairies de ZF 1.10.

Les seuls nouveautés concernent apparemment les tests unitaires qui seraient plus simplifiés, une ré-écriture totale de Zend_Session ainsi que l’ajout d’une nouvelle librairie Zend_stdlib permettant d’appeller les librairies standard de PHP d’une façon plus orienté objet et plus harmonisée.

Structure identique à Zend Framework 1.10

Il est très utile dans une application Web d’avoir un système de navigation capable de cartographier les pages d’un site et d’en déduire des plan de site, fils d’arianes, menus, sitemap.xml, …

Zend_Navigation a été conçu dans cette optique, il propose un système de gestion de pages et des helpers pour générer des composants graphiques.

Nous allons voir dans ce tutoriel une façon simple de mettre en place Zend_Navigation :

Tout d’abord il nous faut définir la navigation et le conteneur de donnée. Dans notre cas, on stockera l’arborescence dans un fichier XML appellé ‘navigation.xml’ dans le répertoire « config ».

protected function _initNavigation() {
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();
$config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/navigation.xml', 'nav');
$container = new Zend_Navigation($config);
$view->navigation($container);
}
<div>

Ensuite, on remplit le fichier « navigation.xml » pour créer notre navigation, on y indiquera la page d’accueil et une page de listing.
On se basera sur le système de routes pour donner le lien.

<configdata>
 <nav>
 <home>
 <label>Accueil</label>
 <route>index</route>
 <pages>
 <listing>
 <label>Liste CRUD</label>
 <route>listing</route>
 </listing>
</pages>
</home>
</nav>
</configdata>

Et voilà la mise en place de Zend_Navigation est fini. Il ne vous reste plus qu’à utiliser des helpers pour appeler vos composants :
Pour le breadcrumb par exemple :

$this->navigation()->breadcrumbs()->setSeparator(" -> ");

Il existe d’autres façon d’intégrer Zend_Navigation sur une application notamment en intervenant directement sur le code. Cette méthode reste très simple mais très fonctionnelle. On y pourra voir des améliorations comme mettre en place un cache pour augmenter les performances.

La preuve c’est qu’ il s’agit du 3ème point qui influe le plus le référencement d’une page. Et puis on peut également avoir besoin internationaliser ses urls.

Zend Framework possède un routeur, qui permet de manipuler plus facilement les liens entre les pages au sein d’une application et également de faire de la réécriture.

Cette étape se fait au sein du Bootstrap d’une application Zend Framework et grâce à Zend_Controller.

Il faut tout d’abord surcharger la méthode _initAutoLoad() du Bootstrap et récupérer l’instance de Zend_Controller

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

return $moduleLoader;
}

}

Ensuite il suffit simplement de créer ses routes et de les rajouter au routeur du contrôleur.
Pour cela on a plusieurs possibilités, on peut créer des routes statiques, des routes basées sur les modules, etc …
Le plus efficace est de créer des routes à partir d’URL pré-formatées grâce à des expressions régulières.
On devra donc créer des instances de la classe Zend_Controller_Router_Route_Regex.

On la construira avec les arguments suivants :

1) La route : sous forme d’expression régulière (exemple : ‘produits/(.+)/(.+)/article-(.+)-(.+).html’)
2) Le lien MVC : il faut donner les éléments statiques pour accéder à la page, c’est à dire le module, le contrôleur et l’action cible (exemple : array(‘module’ => ‘default’, ‘controller’ => ‘products’, ‘action’ => ‘showProduct’))
3)Le mapping des paramètre : on donne dans l’ordre le nom des paramètres que l’on passera dans l’Url (exemple : array(1 => ‘category’, 2=> ‘subcategory’, 3 => ‘product_title’, 4 => ‘product_ref’))
4) Le chemin inverse : une version de l’url interprétable par la fonction sprintf() de PHP (exemple : ‘produits/%s/%s/article-%s-%d.html’)

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

// Nouvelle route pour accéder à produit
$article = new Zend_Controller_Router_Route_Regex(
 'produits/(.+)/(.+)/article-(.+)-(.+).html',
 array('module' => 'default', 'controller' => 'products', 'action' => 'showProduct'),
 array(1 => 'category', 2=> 'subcategory', 3 => 'product_title', 4 => 'product_ref'),
 'produits/%s/%s/article-%s-%d.html');
$router->addRoute($article);

return $moduleLoader;
}

}

Ainsi on pourra créer et appeler une url de type : « www.maboutique.com/produits/processeurs/dual-core/article-intelcore2duo-PI5421.html »

Zend Framework possède son propre outil pour gérer les formulaires correctement : Zend_Form est là pour ça !
Il s’agit d’une librairie qui gère vos composants de formulaires (y compris leur rendu), les validations, le filtrage des données, et la gestion de sous-formulaires.
La librairie Zend_Validate qui gère les validateurs sera aussi utiliser dans ce tutoriel afin d’illustrer les validations de formulaire et ce de façon personnalisé.

Tout d’abord nous allons voir les principes basiques des formulaires avec Zend Framework : il nous faudra ajouter un dossier « forms » dans notre répertoire « application ».

Voici un premier example de la création d’un formulaire dans notre fichier « Author.php ». Il s’agit d’une classe qui correspondra à un formulaire d’inscription d’un auteur :

class Form_Author extends Zend_Form
{
  /**
   * Surcharge du constructeur du formulaire
   */
  public function __construct($options = null)
  {
    parent::__construct($options = null)
    $this->setName('subscription'); // On nomme le formulaire

    $id = new Zend_Form_Element_Hidden('id'); // On rajoute un champs caché

    $email = new Zend_Form_Element_Text('email');
    $email->setRequired(true)
          ->setLabel('Veuillez saisir votre e-mail');

     // Nous avons rajouter un attribut obligatoire à notre email et nous lui avons donné un libellé avant le champs texte

    // Ensuite on peut insérer les composants (elements) dans le formulaire
    $this->addElements($id, $email);

  }
}

Nous avons réaliser une ébauche de formulaire, pour l’utiliser dans notre contrôleur et vue, rien de plus simple

AuthorController.php

function suscribeAction ()

{

$form = new Form_Author(); // On instancie le formulaire

$this->view->form = $form // On le renvoie à la vue

}

// Pour l'éditer il faut renvoyer les informations au formulaire

function editsubscriptionAction()

{

$form = new Form_Author();

$model = new Model_DbTable_Author();

$data = $model->getAuthor('5'); // On récupère toutes les données d'un auteur dans la base de données

$form->populate ($data); // On propulse les données dans le formulaire

$this->view->form = $form;

}

Ensuite dans la vue, on affiche le formulaire et on définit son action :

Author.phtml

echo $this->form;
$this->form>setAction(author/save); // On définit l'action qui récupère le formulaire

Voici un exemple beaucoup plus complet d’un formulaire avec des validateurs, internationalisation et un captcha :

<?php
class Form_Author extends Zend_Form
{
public function __construct($options = null)
{
parent::__construct($options);
$this->setName('Subscription');
$id = new Zend_Form_Element_Hidden('id');

$translate = Zend_Registry::get('translate');

$emptyValidator = new Zend_Validate_NotEmpty();
$emptyValidator->setMessage($translate->_("Ce champs est vide : vous devez le compléter"));

$emailValidator = new Zend_Validate_EmailAddress();
$emailValidator->setMessage($translate->_('L\'adresse email n\'est pas valide'));

$primaryValidator = new Zend_Validate_Db_NoRecordExists('users', 'username');
$primaryValidator->setMessage($translate->_("L'adresse email a déjà été utilisée"), Zend_Validate_Db_Abstract::ERROR_RECORD_FOUND);

$stringLengthValdiator = new Zend_Validate_StringLength(6, 12);
$stringLengthValdiator->setMessage($translate->_('La longueur du mot de pase doit être comprise entre 6 et 12 caractères'));

$email = new Zend_Form_Element_Text('email');
$email->setLabel($translate->_('Email'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emailValidator)
->addValidator($primaryValidator)
->addValidator($emptyValidator);

$password = new Zend_Form_Element_Password('password');
$password->setLabel($translate->_('mot de passe'));
$password->addValidator($stringLengthValdiator);
$password->addValidator($emptyValidator);

$password_verification = new Zend_Form_Element_Password ('password_confirm');
$password_verification->setLabel ($translate->_('retapez le mot de passe pour vérification'));
$password_verification->addValidator($emptyValidator);
if (isset($_POST['password'])) {
$passwordVerificationValidator = new Zend_Validate_Identical($_POST['password']);
$passwordVerificationValidator->setMessage($translate->_('Les mots de passe ne correspondent pas'));
$password_verification->addValidator($passwordVerificationValidator);
}

$sex = new Zend_Form_Element_Radio('sex', array('separator' => ' '));
$sex->setMultiOptions (array('male' => 'Homme', 'female' => 'Femme '))
->setLabel($translate->_('Sexe'))
-> isRequired(true);

$name = new Zend_Form_Element_Text('name');
$name->setLabel($translate->_('Prénom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$surname = new Zend_Form_Element_Text('surname');
$surname->setLabel($translate->_('Nom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$address = new Zend_Form_Element_Text('address_author');
$address->setLabel($translate->_('Adresse'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$zip_code = new Zend_Form_Element_Text('zip_code_author');
$zip_code->setLabel($translate->_('Code Postal'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$city = new Zend_Form_Element_Text('city_author');
$city->setLabel($translate->_('Ville'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$phone = new Zend_Form_Element_Text('phone');
$phone->setLabel($translate->_('Téléphone'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

}

$submit = new Zend_Form_Element_Submit('valid');
$submit->setAttrib('id', 'submitbutton')
->setLabel($translate->_('Enregistrer l\'annonce'));

 $this->addElements(array($id, $email,$password, $password_verification, $sex, $name, $surname, $address, $zip_code, $city, $phone, $submit));
}
}
?>

Dans le prochaine tutorial, nous verrons comment mettre en application tout ce que nous avons vu précédemment dans un « CRUD » (Create Read Update Delete) qui illustrera l’utilisateur du design-pattern MVC, Zend_Db, Zend_Form, Zend_Validate et Zend_Layout.

Très rensemblante à la debug bar de Symfony, un petit projet fait avec Zend Framework nommé ZFDebug ravira beaucoup de développeurs Symfony. Il s’agit d’une petite debug bar qui se place en haut de la page web et qui renseigne le développeur sur un grand nombre d’informations : temps de réponse, utilisation de la mémoire, requêtes à la base de données, …

Les principales informations qu’offre ZFDebug sont les suivantes :

• Cache: Informations sur Zend_Cache et APC
• Database: Liste des requêtes SQL avec les temps d’exécution
• Exception: Affichage des erreurs et des exceptions
• File: Liste de fichiers inclus et leurs tailles.
• Html: Nombre de fichiers CSS et Javascript associés à la page.
• Memory: Utilisation de la mémoire d’un contrôleur avec statistiques détaillées.
• Registry: Contenu de Zend_Registry
• Time: Temps d’exécution des actions du contrôleur
• Variables: Valeurs des variables et contenus des variables $_COOKIES et $_POST.

Nouvelle version de Zend Framework, elle corrige une quarantaine de bugs

Voici la liste issue de la changelog…

Bugs corrigés :

• [ZF-7605]: Zend_Application docs mistake
• [ZF-7550]: Bootstrap fails after checking out r17414
• [ZF-7417]: clarify confusion between ‘resource plugins’ and ‘resources’ in docs
• [ZF-7401]: Errors in QuickStart
• [ZF-7158]: No automatic creation of Zend_Application_Module_Autoloader for default module
• [ZF-7095]: Zend_Application_Resource_Modules Example is wrong
• [ZF-7091]: « scripts/load.sqlite.php » is missing « set_include_path »
• [ZF-6893]: Cannot use Zend_Application_Resource_FrontController to set baseurl for a subset of environments
• [ZF-6861]: Stripping all require_once calls makes Zend_Application unable to work
• [ZF-6803]: Zend_Application Default Module Bootstrap is Skipped
• [ZF-6679]: Items configured from Zend_Application::setOptions() via a config entry do not have their keys cast to lower case
• [ZF-6659]: Module bootstrap implementation
• [ZF-6634]: include warning with same module and namespace name
• [ZF-4730]: Add possibility to check group-membership in Zend_Auth_Adapter_Ldap
• [ZF-7358]: Zend_Cache_Backend_ZendServer_ShMem and Zend_Cache_Backend_ZendServer_Disk throws an exception in test()
• [ZF-7172]: How to instatiate the ZendServer cache backends
• [ZF-6291]: Zend_Cache::factory() denies creation of Zend_Cache_Backend_TwoLevels backend on Linux
• [ZF-5740]: Partial cleaning in Zend_Cache_Backend_TwoLevels::clean()
• [ZF-7589]: Zend_Date::setDate when parsing the date to set in an array
• [ZF-7554]: testSetLocale(Zend_DateTest) unit tests failure
• [ZF-7456]: Regression in 1.9 in ability to create Zend_Date from array
• [ZF-7454]: Timezone and Zend_Date
• [ZF-7647]: fetchAssoc() and fetchPairs() in Zend_Db_Adapter_Abstract have wrong docblock return type
• [ZF-7629]: Zend_Db_Adapter_Pdo_Mssql should pass @table_owner to sp_pkeys
• [ZF-5823]: Non-optimized SQL generated for LIMIT clause in MSSQL adapter
• [ZF-4251]: Zend_Db_Adapter_Pdo_Mssql doeas not support both LIMIT and DISTINCT in the same query
• [ZF-4099]: Zend_Db_Adapter_Pdo_Mssql – Order By in Limit Function
• [ZF-3434]: PDO_Mssql DSN includes _config['options']
• [ZF-3216]: Zend_Db_Adapter_Mysqli does not provide a proper way to catch MySQL error codes.
• [ZF-7549]: Missing prefix and type parameters in the PHPdoc for most of the addPrefixPath methods
• [ZF-7544]: Fatal Error when setting same FilterRule more than one time in script call
• [ZF-7135]: null values are treated as missing data instead of an empty value
• [ZF-7449]: Directive $element->setRegisterInArrayValidator(false) doesn’t work anymore
• [ZF-7208]: Incubator unit tests stop with fatal error ‘Class ‘Zend_Ldap_AllTests’ not found’
• [ZF-7604]: No Zend_Log_Writer_Syslog::setApplication() hence documentation
• [ZF-7614]: Incorrect function name in the #42.2 manual entry
• [ZF-7613]: There is not « factory » method in the Zend_Queue class
• [ZF-7560]: Zend_Translate_Adapter does not properly handle numeric key values
• [ZF-7648]: testNotSameMessageContainsTokenAndValue(Zend_Validate_IdenticalTest) unit tests failure
• [ZF-7643]: Empty token value in Zend_Validate_Identical::NOT_SAME
• [ZF-7631]: Zend_Validate_NotEmpty compatibility
• [ZF-7630]: Zend_Validate_Date doesn’t accept Zend_Date object
• [ZF-6457]: Zend_Validate_Date doesn’t validate a value filtered by Zend_Filter_LocalizedToNormalized
• [ZF-7597]: Reference guide minor error
• [ZF-7676]: Unit tests stop because of the « Call to undefined method Zend_XmlRpc_Server_Fault::getReturnValue() » fatal error

On appelle cela une couche d’abstraction qui sert intermédiaire entre la base de données et l’application. Le but est de modéliser le schéma d’une base de données sous forme de classes et d’objet pour ne pas travailler avec le langage SQL et les drivers de base de données car il est évident qu’une application écrite de A à Z avec des mysql_connect() et mysql_query() ne sera pas très robuste et migrera difficilement vers un autre SGBD comme Postgre ou Oracle…

Zend_Framework fournit un outil nommé Zend_Db_Table pour gérer à l’aide d’un système de DAO (Database Access Object) les transactions avec les bases de données.

Nous allons voir dans un premier temps comment configurer Zend_Framework pour mettre en place ce système :

Configuration du fichier Application.ini :

;database configuration
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "root"
resources.db.params.password = ""
resources.db.params.dbname = "announcements"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Il faut spécifier dans le « Application.ini » les paramètres pour accéder à votre base de données, il faut y spécifier l’adresse de la base, le type (pdo_mysql, postgre, sqllite, oci8, mssql, …), l’utilisateur avec le mot de passe, le nom de la base de données et le format de date et heure.

Ecrire les classes d’accès aux données (utilisation de Zend_Db_Table) :

Il nous faut maintenant écrire les classes permettant de modéliser les tables de la base de données pour cela on va utiliser Zend_Db_Table pour générer une classe permettant d’accéder à la table « posts  » de notre application :

On créer tout d’abord un dossier « models » dans notre répertoire /application avec un dossier DbTable dedans.

Nous allons générer un fichier Post.php :

Tout d’abord, on crée une classe dérivée de Zend_Db_Table que l’on nommera avec la syntaxe suivante : Model_DbTablr_NomDeLaTable en spécifiant le nom extact dans l’attribut protégé « name » :

Ensuite il ne reste plus qu’à écrire les méthodes qui permet les transactions avec les bases de données, je recommende fortement d’utiliser une méthode pour chaque transaction plutôt que de les écrire dans le contrôleur, on est dans un design-pattern MVC !

Voici le prototypage de notre classe et l’implémentation de notre classe :

fetchRow('id = '.(int)$id);
		if (!$row)
		{
			// On lance une exception en cas d'erreur
			throw new Exception ("Erreur, l'enregistrement $id n'existe pas !");
		}
		// On retourne le résultat sous forme de tableau
		return $row->toArray();
	}

	/**
	 * Ajoute un article en base de données
	 * @param $values
	 * @return unknown_type
	 */
	public function addPost ($values)
	{
		// On enregistre les valeurs sous forme de tableau [champs] => valeur
		$result = $this->insert($values);
		if (!$result)
		{
			throw new Exception ("Erreur impossible d'enregister");
		}
	}

	/**
	 * Met à jour un article en base de donneés
	 * @param $values
	 * @return unknown_type
	 */
	public function updatePost ($id,$newValues)
	{
		$result = $this->update($newValues, 'id = '.(int)$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de mettre à jour");
		}
	}

	/**
	 * Supprime l'article $id
	 * @param $id
	 * @return unknown_type
	 */
	public function removePost ($id)
	{
		$result = $this->delete('id = '.$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de supprimer");
		}
	}

	/**
	 * Requête avec jointure pour récupérer les 5 premiers
	 * articles avec les données de la table auteur en jointure
	 * et qui ont leur status publié
	 * @return unknown_type
	 */
	public function findPostsWithAuthorsInformations ()
	{
		$db = $this->getAdapter();

		$select = $db->select()
					 ->from('post')
					 ->joinInner('author', 'post.author_id = author.id')
					 ->where('status = "published"')
					 ->limit(5);
		$query = $select->query();
                $result = $query->fetchAll();

		return $result;
	}
}
?>

Pour appeler cette classe dans le contrôleur rien de plus simple, on instancie un objet « $model » et pis on appelle les méthodes que l’on a implémentée :

< ?php
	class PostController extends Zend_Controller_Action
	{
		public function init ()
		{
			// On fait rien
		}

		public function testModelAction ()
		{
			$model = new Model_DbTable_Post();

			// Ajout
			$model->addPost(array('title' => 'test', 'content' => 'ceci est mon premier post', 'status' => 'publised'));

			// Requête
			$this->view->posts = $model->findPostsWithAuthorsInformations();

			// Suppression
			$model->removePost(2);

		}
	}
?>

La prochaine fois nous verrons le fonctionnement des formulaires avec Zend_Form

Pour cela Zend propose une structure très standard et très connue des développeurs, le design-pattern MVC (Modèle Vue Contrôleur).

Petit rappel sur le modèle MVC : il consiste à séparer les trois parties fondamentales d’une application finale.

La première regroupe les traitements et l’intégritée des données. Elle s’occupe généralement des interactions avec la base de données avec une couche d’abstraction que nous verrons dans un prochain tutoriel.

La vue n’est autre que la partie interface graphique de l’application, c’est l’interface avec l’utilisateur et elle ne doit exercer aucun traitement.

Le contrôleur est l’intermédiaire entre les 2 autres couches, il récupère les actions de d’utilisateurs et déclenche les traitements à effectuer.

Voici la couche Vue de notre application Zend de départ, on remarque qu’elle contient exclusivement le code HTML et le CSS ainsi que des variables  qui ne servent qu’à afficher des données :

La couche contrôleur se comporte sous la forme d’une classe dérivée de Zend_Controller_Action, elle doit être nommé sous la forme NomController et il en est de même pour le fichier qui la contient. Dans notre IndexController, nous avons 2 méthodes par défaut : init() et indexAction(). La méthode init() est l’action à exécuter par défaut avant n’importe quelle autre action. On peut y mettre des traitements pour récupérer des variables en paramètres ou en session par exemple. La méthode IndexAction() est la méthode centrale du contrôleur, il s’agit de la page par défaut. Les vues du contrôleur doivent être regroupées dans un même répertoire et doivent porter le même nom que l’action avec l’extension *.phtml pour les templates.

Les urls fonctionnent de la façon suivante : racine/index.php/contrôleur/action

Maintenant que nous sommes à l’aise avec le contrôleur et la vue, nous allons mettre en place un template principal qui sera la base graphique de notre application : il s’agit d’un layout.

On commence d’abord à paramètrer notre application, pour cela on se rend dans le application.ini dans le répertoire configs :

On y définit le répertoire, où nous allons placer nos fichiers de mise en page, par convention on choisira le répertoire application/layouts/scripts.

En suite nous allons modifier le Bootstrap et surcharger la méthode _initDoctype() qui définiera le doctype de notre page Web.

Nous pouvons maintenant créer le layouts.phtml dans le répertoire /layours/scripts et y insérer les balises de contenue.

On pourra étendre ce layout à plusieurs fichiers comme un header, un footer, une sidebar par exemple.

C’est fini pour la structure MVC de Zend et la création de layouts, nous verrons dans le prochain tutoriel comment se comporte la couche modèle et les interactions avec la base de données et nous ferons notre première application CRUD (Create Read Upload Delete).

]]> http://www.alexandre-julien.com/php/zend-framework-tutoriel-2-layouts-et-design-pattern-mvc/feed/ 0 http://www.alexandre-julien.com/php/zend-framework-premier-tutoriel-installation-et-creation-dun-premier-projet/?utm_source=rss&utm_medium=rss&utm_campaign=zend-framework-premier-tutoriel-installation-et-creation-dun-premier-projet http://www.alexandre-julien.com/php/zend-framework-premier-tutoriel-installation-et-creation-dun-premier-projet/#comments Sun, 12 Jul 2009 14:05:10 +0000 Alexandre JULIEN http://www.alexandre-julien.com/?p=369 Voici le premier tutoriel consacré au framework PHP5, pour cette première partie nous nous contenteront uniquement de réaliser une première installation du Framework dans sa version 1.8.4.

Pour mettre votre première application en oeuvre, il vous faudra tout d’abord un serveur Apache et PHP5, il existe un grand nombre de solution pour vous faciliter son installation. Je conseille fortement les projets comme WAMP (Windows), MAMP (Mac) ou XAMPP (multi-plateforme). Les utilisateurs Linux utiliseront plutôt les paquets DEB et RPM fournient avec leur distribution ou une compilation à partir des sources pour les utilisateurs avancés.

Vérifier bien que votre installation fonctionne et que votre version de PHP est égale ou supérieur à la version 5.2.4, cela est nécessaire pour la version de Zend que nous utiliseront.

Tout d’abord il nous faut télécharger le framework sur le site de Zend, pour cela il faut impérativement créer un compte. Ensuite télécharger soit la version complète soit la version light du framework sachant que la version complète comporte quasiment que des exemples et une intégration du framework javascript Dojo.

Une fois le framework télécharger, il faudra créer un répertoire qui contiendra le framework et qui sera plus tard rélier à Apache. Dans notre exemple, on crée un dossier ZendFramework dans le workspace d’Eclipse. Il vous suffit de décompresser le contenu de l’archive téléchargée sur Zend dans le répertoire cible :

Il vous faudra ensuite utiliser la version CLI de PHP (Command Line Interface) pour générer les fichiers de notre premier projet grâce au ZendTools. Cette étape nécessite une configuration particulière si vous êtes sur Windows puisqu’il vous faudra créer une variable d’environnement pour éxécuter PHP. Les utilisateurs UNIX quant à eux pourront directement éxécuter l’application zf.php en CLI.

Pour faire cela, il suffit d’ouvrir une console et  de se rendre dans le répertoire « /bin » du framework. On constate qu’il y a deux fichiers exécutables le premier en .bat pour les utilisateurs Windows et le second en « .sh » pour les utilisateurs de systèmes UNIX.

Lorsque vous executez le script une première fois vous pourrez voir les fonctions que propose le ZendTool :

Pour créer notre premier projet que nous nommeront ZendBlog nous allons éxecutez la ligne de commande suivante :

« zf create project ZendBlog »

Nous avons générer notre première application, regardons la structure de cette dernière. En effet, elle comporte :

- un répertoire « controller » contenant les controlleurs du design-patterns MVC
- un répertoire « views » contenant les templates PHP.
- un répertoire « library » qui devra contenir les librairies du framework Zend
- un répertoire « public » contenant l’index.php qui sera la page principale de notre application et qui devra être la page accessible à Apache.
- un répertoire « test » contenant les tests unitaires de l’application.
- un répertoire « model » pour les classes correspondantes à la couche d’abstraction à la base de données.

Il vous faudra ensuite intégrer le répertoire Zend fournit avec l’archive dans le répertoire library de l’application sans cela,  rien ne pourra fonctionner et vous aurez l’erreur suivante sur votre application :

Une fois le framework installé, votre premier projet a été crée, il ne vous reste plus qu’à accéder à votre page « index.php » dans le répertoire « /public » et vous aurez le résultat suivant :

Voilà, c’est fini pour cette première partie, nous verrons prochainement comment fonctionne le modèle MVC sur le framework Zend et nous commenceront à génerer des « Layouts » pour mieux distinguer nos couches de présentations.

A très bientôt.

Le blog d’Alex vous proposera très prochainement des tutoriaux complets sur Zend Framework sous forme d’articles et de podcasts vidéos.

En effet, Zend Framework est un framework PHP 5 orienté objet basé sur une grande bibilothèque de classes et de librairies fournissant des facilités de développement.

Contrairement à ses « concurrents » comme CakePHP, Symfony, Copix, Jelix … Zend ne fournit pas de façon native une structure et une architecture de de développement, en revanche il nous fournit les moyens de la construire. Souvent critiqué par son manque de rigueur et son architecture trop exhaustive, il n’en reste pas moins qu’il est souvent plébiscité par les entreprises et il est actuellement très utilisé par les SSII. Il est actuellement le framework PHP le plus utilisé en France avec le grand Symfony (beaucoup plus rigoureux mais extrèmement professionnel et robuste).

La philosophie du Zend Framework est d’offrir un ensemble d’outils de développement d’application Web tout en offrant un maximum de flexibilité au niveau architectural. Il s’appuit sur les fonctionnalités standard que l’on retrouve dans de nombreux frameworks :

- design-pattern MVC (Modèle Vue Controlleur)
- couche d’abstraction à la base de données sous forme d’un système de DAO (Database Access Object) pour effectuer des requêtes dynamiques vers les bases de données et ce de façon générique (compatible avec Mysql, Oracle, Postgre, MS-SQL, SQL-Lite, IBM-DB2)
- système de cache pour optimiser les calculs et les transactions avec les bases de données
- des outils pour le développement RAD (Rapid Application Development)
- internationalisation I18N pour la création et la gestion d’application totalement multilingues
- un système d’authentification, d’autorisation et de gestion des sessions
- un framework pour propulser ou exploiter des Web Services
- des fonctionnalités avancées pour l’exploitation des emails et la génération de PDF
- un système de recherche puissant
- des créations de formulaires avec des fonctions de filtres, validateurs, …
- un grand nombre d’APIs comme Google App, Amazon, …
- un générateur de javascript basé sur le framework Dojo ainsi que des libraries pour jQuery depuis la version 1.7 avec ZendX

L’autre argument fort de PHP est qu’il est soutenu par Zend, l’entreprise à but commercial qui propulse PHP, cela rassure souvent les entreprises de savoir qu’il existe des entités commerciales derrière les technologies (cf succès de Sun et IBM avec Java et Microsoft .NET).
Il aura pour vocation de se placer au même rang que les grands framework « standard » des autres langages tel un (Spring, Struts pour Java ou un Ruby on Rails pour Ruby).

C’est pour ces raisons, que je vais prochainement diffuser des tutoriaux sous forme écrite et aussi sous forme vidéo podcast visant à donner un petit coup de pouce aux personnes débutants sur ce framework. Il s’agira principalement d’application simples et basique comme un CRUD mettant en pratique les principales fonctionnalités du Zend Framework, à savoir le design-pattern MVC, le routing avec le url_rewriting, les formulaires, les interactions avec les bases de données, les sessions et authentifications, …

En espérant que ces tutoriaux aideront un maximum de personnes, je compte sur votre aide pour commenter mes publications.

A très bientôt.