Une première application web en java

Nous allons voir, après avoir installer notre environnement de développement, comment mettre en place un squelette d'application web avec Java, Eclipse et Tomcat.

Après avoir lancé Eclipse, nous allons le configurer pour pouvoir lancer Tomcat directement depuis Eclipse.
Si la vue "Servers" n'est pas visible, nous allons l'ouvrir en allant dans le menu Window -> Show View -> Others... ou en utilisant le raccourci Alt+Shift+Q, Q
Nous selectionnons alors la vue Server->Servers qui va alors s'ouvrir en bas d'Eclipse.
Nous cliquons-droit dedans et choisissons dans le menu contextuel new -> server
Une fenêtre de configuration s'ouvre.
Nous devons d'abord donner un nom à notre serveur. Comme il est installé sur notre machine, le nom "localhost" s'impose.
Nous choisissons notre type de serveur, dans notre cas Apache Tomcat v5.5.
A l'étape suivante, il faut indiquer le répertoire de tomcat (par exemple : F:\Program Files\Apache Software Foundation\Tomcat 5.5) et la jre associée (à choisir dans la liste déroulante). Nous cliquons sur Finish et nous retrouvons notre serveur configuré dans la vue servers.
Un pseudo nouveau projet s'est aussi créé, qui contient en fait les fichiers de config de nos serveurs.

Nous allons maintenant créer un nouveau projet web.
Dans la vue "package explorer", nous cliquons droit et choisissons dans le menu new -> project...
Nous selectionnons web->Dynamic Web Project et cliquons sur next.
Nous donnons un nom à notre projet (par exemple "HelloProject").
Nous choisissons dans la liste déroulante notre serveur fraichement configuré ainsi que la configuration par défaut et nous cliquons sur Finish. Eclipse nous configure notre projet et nous le retrouvons dans le package explorer.
Pour le tester, nous allons écrire une page jsp qui vérifiera bien que le projet fonctionne avec Tomcat.
Dans le répertoire WebContent, nous créeons un nouveau répertoire "jsp" (clic-droit sur "WebContent" -> new -> folder).
Dans ce nouveau répertoire, nous créons un nouveau fichier hello.jsp



<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>Hello</title>
  </head>
  <body>
    <% out.println("Hello!!!"); %>
  </body>
</html>



Il ne reste plus qu'à associer notre projet à notre serveur.
En cliquant-droit sur notre serveur et en choisissant "add and remove projects...", on peut alors ajouter notre nouveau projet à la liste des projets associés au serveur.
Il faut maintenant lancer le serveur (clic-droit dessus et start).
Dans notre navigateur préféré, on va à l'URL : http://localhost:8080/HelloProject/jsp/hello.jsp
et nous devons voir apparaitre un beau "Hello!!!".

Tester PHP6 avec Wamp2

Un nouveau module pour Wamp2 vient de sortir, qui permet d'installer et tester PHP6.
Le module est téléchargeable sur le site de Wamp, sur la page dédiée aux add-ons. Pour l'occasion, une nouvelle rubrique a été créée pour accueillir les modules de tests, comme celui-ci car PHP6 est encore en développement. http://www.wampserver.com/addons_dev.php

Merci à Romain, le développeur de Wamp2, pour ce module et le message sur son blog nous informant de sa sortie.

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

Installer un environnement de développement Java

3 choses à installer:

1. Le sdk java
A télécharger ici :
http://java.sun.com/javase/downloads/index.jsp
La version actuelle est JDK 6 Update 3.
L'installation n'est pas compliquée, il n'y a qu'à suivre les différentes étapes.


Pour voir si l'installation s'est bien déroulée, dans une ligne de commande, il suffit en ligne de commande de taper :
java -version
Si java est bien installée, l'instruction doit renvoyer la version java installée (ici java version 1.6.0_03)

2. Apache Tomcat
Pour faire tourner des applications web, il nous faut un conteneur de servlets, j'ai choisi Tomcat, développé par la fondation Apache.
Nous allons installer la version 5.5 de Tomcat, téléchargeable ici :
http://tomcat.apache.org/download-55.cgi
Pour plus de facilités, nous allons prendre le Windows Service Installer.
L'installation consiste encore à passer les étapes en cliquant la plupart du temps sur next.
Une étape importante est la configuration du compte administrateur.

J'ai choisi pour ma version de développement le login admin et le mot de passe password.
Il faut ensuite indiquer le répertoire du java sdk. Normalement, l'installeur le détecte automatiquement.

Tomcat doit se lancer automatiquement à la fin de l'installation.
Le manager se loge dans le system tray et permet d'arrêter ou de relancer le service Tomcat.
Pour tester que Tomcat a bien été installé et lancé, il faut aller à l'url http://localhost:8080/
La page d'accueil de Tomcat doit alors s'afficher.


3. Eclipse WTP
Reste à installer Eclipse.
J'ai choisi la distribution WTP, équipé de plug-ins pour le développement web.
L'url pour le télécharger : http://download.eclipse.org/webtools/downloads/
J'ai choisi la version Released 2.0.1 All-In-One.
On télécharge alors un fichier zip qu'il suffit de dezipper.

En lançant Eclipse, il nous demande de choisir un répertoire qui servira de workspace, là où tous les projets seront enregistrés.

L'environnement de travail est maintenant installé. Au travail! (la suite au prochain numéro)