Sortie de Wamp 2

La dernière version de la plateforme de développement PHP/Mysql est sorti!
Au programme des nouveautés, on retiendra surtout la possibilité d'installer différentes versions d'Apache, de PHP et de Mysql pour reproduire les conditions du serveur de production.
Après leur installation, on peut changer à la volée de version et Wamp nous indique si les versions choisies d'Apache et de Php sont incompatibles entre elles!

Pour le télécharger, direction le site officiel wampserver.com

Sortie d'Appfuse 2.0.1

La nouvelle version d'Appfuse vient de sortir.
Elle corrige certains bugs et supporte la dernière version de Spring 2.5 avec les annotations de configuration.

Appfuse permet de démarrer rapidement une application J2EE en créant un squelette d'application utilisant les meilleurs frameworks.

Plus d'infos par ici

Utiliser Mysql dans notre application Grails

Lorsque nous avons créé notre application, celle-ci se servait d'une base de données embarquée HSQLDB.
A chaque lancement de l'application, la base de données est initialisée et nous perdons donc les données d'un lancement à l'autre.
Nous allons voir comment utiliser une base de données Mysql pour notre application, pour avoir des données persistantes, même lorsque nous coupons notre serveur web Grails (basé sur Jetty).

Le premier pré-requis est d'avoir une base de données Mysql installée sur notre poste.
Vous pouvez installer Wamp, un installeur tout-en-un proposant un serveur Apache, Mysql et un interpréteur Php, c'est ce que j'ai fait car je travaille aussi sur Php.
Sinon, vous pouvez installer uniquement Mysql, par exemple en suivant ce tutoriel : Installation et configuration de Mysql 5.0 par Maximilian (developpez.com)

Pour manipuler simplement Mysql, un bon client que j'utilise : SqlYog.

Il nous faut aussi un connecteur JDBC Mysql, téléchargeable ici : Connector/J 5.1
Dezippez-le et copiez le fichier mysql-connector-java-5.1.5-bin.jar dans le répertoire annuaire\lib de notre application.

Avec le client sql, créez trois bases de données annuaire_dev, annuaire_test, annuaire_prod.

Enfin, éditez le fichier annuaire\grails-app\conf\DataSource.groovy, qui indique les paramètres de connexion aux bases de données nécessaires pour notre base de données.
Pour le moment, il se connecte à un serveur HSQLDB avec les paramètres :

dataSource {
pooled = false
driverClassName = "org.hsqldb.jdbcDriver"
username = "sa"
password = ""
}
hibernate {
cache.use_second_level_cache=true
cache.use_query_cache=true
cache.provider_class='org.hibernate.cache.EhCacheProvider'
}
// environment specific settings
environments {
development {
dataSource {
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
url = "jdbc:hsqldb:mem:devDB"
}
}
test {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:mem:testDb"
}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}

modifiez avec vos paramètres de connexion username et password.
Le driver pour se connecter à mysql est la classe com.mysql.jdbc.Driver.
Et il faut modifier les trois url des bases de dev, test et prod pour qu'elles pointent sur celles que l'on vient de créer.
Voici à quoi ressemble mon fichier de configuration modifié :

dataSource {
pooled = false
driverClassName = "com.mysql.jdbc.Driver"
username = "root"
password = ""
}
hibernate {
cache.use_second_level_cache=true
cache.use_query_cache=true
cache.provider_class='org.hibernate.cache.EhCacheProvider'
}
// environment specific settings
environments {
development {
dataSource {
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
url = "jdbc:mysql://localhost/annuaire_dev"
}
}
test {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost/annuaire_test"
}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost/annuaire_prod"
}
}
}

Il ne reste plus qu'à tester en relançant le serveur web Grails :
grails run-app
Si tout se passe bien, le script va créer automatiquement une table personne dans la base de dev qui stockera les données correspondant à notre classe Groovy Personne.

Tester Grails et son déploiement sur Tomcat

1. Installation

J'ai téléchargé la derniere version de Grails sur cette page : http://grails.codehaus.org/Download
(J'ai choisi le zip binary release)
J'ai dezippé l'archive dans mon répértoire Program Files, ajouté une variable d'environnement GRAILS_HOME désignant le répertoire de Grails et ajouté %GRAILS_HOME%\bin au path.
Pour tester mon installation, j'ai tapé dans une invite de commandes
grails -help

2. Création d'une première application

Tout d'abord, j'ai créé un répertoire "Projets Grail" pour stocker mes futures applications.
Avec l'invite de commandes, je me suis placé dans ce répertoire et j'ai lancé la commande :
grails create-app
Un script de création d'application se lance et demande un nom d'application:
Application name not specified. Please enter:
annuaire
Mon application "annuaire" qui servira de premier test grails va gérer une liste de personnes et leurs coordonnées.
Lorsque le script est terminé, je peux lancer la commande:
cd annuaire
grails run-app
Un serveur d'applications Jetty est lancé et on peut acceder à l'application via l'url http://localhost:8080/annuaire
On doit arriver à cette page:

3. Codage d'une première classe

Pour gérer la liste de personnes, j'ai besoin d'une classe.... Personne!
Pour créer cette classe, il faut lancer la commande :
grails create-domain-class Personne

Un fichier annuaire/grails-app/domain/Personne.groovy est créé que je vais modifier pour décrire une personne:

class Personne {
String nom
String prenom
Date dateNaissance
Integer nombreEnfants
}
Il faut maintenant créer le controleur qui gérera cette liste de personnes.
Pour se faire, il faut éxecuter la commande:
grails create-controller Personne
Cela créé le fichier annuaire\grails-app\controllers\PersonneController.groovy
Pour avoir une interface de CRUD classique, je vais modifier ce fichier comme ceci:

class PersonneController {
def scaffold = Personne
}
Il ne reste plus qu'à tester en relançant le serveur de test:
grails run-app
et aller à l'url http://localhost:8080/annuaire/personne
Voilà une première application Grails fonctionnelle réalisée en moins de 30 minutes!

4. Test d'une application Grails sur un serveur Tomcat
Reste une dernière chose: déployer cette application sur un serveur Tomcat et ne plus se servir du serveur de test Jetty.
Dans le répertoire "annuaire", je lance la commande
grails war
et cela me créé un fichier war (équivalent des jar pour une application web).
Pour le déployer simplement dans Tomcat, il suffit d'aller dans l'interface Manager de tomcat et utiliser l'interface de déploiement

Dans "Select WAR file to upload", je sélectionne mon fichier war et je clique sur Deploy.
Après le chargement (qui peut être un peu long), l'application est disponible sur le serveur tomcat à travers l'URL http://localhost:8080/annuaire