f.pfister

Exit Redhat Developer Studio

2007-12-19T06:44:00.000-08:00

A peine le temps d'essayer Redhat Developer Studio, de passer de la version bêta à la candidate release 1, le produit s'appelle maintenant JBoss Developer Studio, il est devenu payant (99$).

Cependant, tous les composants restent gratuits, on peut facilement les assembler manuellement, et malgré la baisse du dollar, c'est encore intéressant de gagner 99$ en 15 minutes. De plus, la procédure décrite ci-dessous permet de mettre à jour une installation d'Eclipse déjà existante, et aussi de remplacer la version des JBossTools par un version plus récente, ou de partager une installation des JBossTools par plusieurs installations d'Eclipse.
Téléchargez Eclipse Europa
dézippez cette archive dans un répertoire <eclipse>

Téléchargez JBossTools-2.0.0
dézippez cette archive dans un répertoire <jbosstools>

Téléchargez JBoss 4.2.2
dézippez cette archive dans un répertoire <jbossas>

Installez Eclipse
Eclipse est déjà installé dans le répertoire <eclipse> sans opération supplémentaire.

Installez JBossTools
Dans <jbosstools>\eclipse, créez un fichier nommé .eclipseextension
(sous windows, dans une console msdos, tapez: echo "" > .eclipseextension)
Démarrez Eclipse
menu Help/Software Updates/Manage Configuration/Eclipse Platform/Add/Extension Location
choisissez le répertoire <jbosstools>\eclipse
Relancez Eclipse, les jboss tools sont installées.

Installez JBoss 4.2.2
exemple: si <jbossas> est E:\dev\java\jbossas, le serveur sera ici: E:\dev\java\jbossas\jboss-4.2.2.GA
Déclarez le serveur dans Eclipse:
Window/Preferences/Server/Installed Runtimes/Add/JBoss v4.2
Next/Application Server Directory=<jbossas>\jboss-4.2.2.GA

Afficher la console JBoss:
Window/Show View/Server/JBoss Server View

Sauvegarder cette console
Window/Save Perspective as...

Dans la console, bouton droit/New Server/JBoss AS 4.2
Next/Home Directory/<jbossas>\jboss-4.2.2.GA
Configuration:default
Next/next/Finish
Bouton droit sur le serveur ainsi créé/start
Ouvrez un navigateur à l'adresse http://localhost:8080/ pour constater le bon fonctionnement du serveur.

Créez un projet jsf
File/New/Other/JBoss Tools Web/JSF/JSF project
Project Name:jsftest
JSF Environement: JSF 1.2
Template: JSFKickStartWithoutLibs
Next/Finish

Racine du projet jsftest/clic droit/Run As/Run on server
On doit voir une page Hello Demo Application dans le navigateur.

Attention, lorsqu'on modifie du code java, il faut redéployer l'application. Dans l'onglet JBoss Server View, deuxième volet, modules/[nom du projet], bouton droit sur Full Publish

P-S
Après enquête approfondie, Redhat Developer Studio est encore disponible gratuitement ici.
P-P-S
Pour utiliser VisualEditor (développement swing et swt) pourtant notoirement incompatible avec Europa, installez le plugin modifié ici.

Android

2007-11-29T05:01:00.000-08:00

Android est une plate-forme de logiciel mobile basée sur Linux, promue par Google et l'Open Handset Alliance, consortium qui rassemble 34 industriels.
L'ensemble du modèle est open-source (licence Apache 2).
Le kit de développement est disponible.
Les applications sont développées en java. En effet, l'api J2ME a été portée sur Android, la machine virtuelle n'est pas une JVM mais une VM spécifique nommée Dalvik, ce qui permet à Google de contourner la licence protégeant J2ME.
Un émulateur Windows/Mac/Linux est disponible.
Sans préjuger des batailles juridiques qui semblent inévitables, Google Android Challenge est un concours qui récompense les meilleures applications sur la plate-forme Android. Une somme de 10 millions de dollars est annoncée par Google.
A vos claviers!

lancement d'un kit pour développeurs
dicodunet
android-after-all
openhandsetalliance.com
googleblog.blogspot.com
Dalvik: how Google routed around Sun's IP-based licensing restrictions on Java ME

Java Enterprise Edition

2007-11-22T10:00:00.000-08:00

Objectif
Se former sur les technologies web en java
Modalités
Ratio:
30% de théorie - 70% de pratique
Outils utilisés:
Eclipse, Netbeans, Jboss
Durée:
32 heures
Evaluation:
par binôme, dossier de projet et démo lors de la dernière séance.
Cours
Les technologies JEE5
TP

Appréhender les outils de développement
Appréhender les technologies jsp-servlet-jsf-jpa etc...
Rédiger une spécification fonctionnelle simplifiée
Concevoir un modèle métier simplifié (6 classes)

Banque
Client
Compte
Compte-epargne
Compte-courant
Ville

Implémenter les classes
Réaliser des jeux de test unitaire
Concevoir l'architecture technique (serveur web)
Réaliser le serveur web
Concevoir l'interface utilisateur
Choisir la technologie de persistance des objets métier
Coder les classes d'accès aux données
Intégration et tests

TP: Crud Create-Retrieve-Update-Delete

2007-11-22T05:07:00.000-08:00

Architecture
L'application est vue comme un modèle de données du domaine fortement structuré et typé et couplé.

Cette couche métier à caractère statique côtoie une couche d'interface utilisateur (swing, html, jsp, dans notre cas jsf), ainsi qu'une couche applicative constituée par les contrôleurs, à caractère dynamique.

Ce modèle du domaine est bien découplé des deux autres couches, ainsi que des couches techniques (persistance par exemple).

Dans le cas où le modèle est connecté avec un ou plusieurs modèles externes, cette connection s'effectuera au travers d'une API consitutée d'interfaces.

Les classes métier comportent des règles-métier de base (l'âge d'un personne ne peut être négatif....)
Les contrôleurs comportent des règles métier applicatives (on ne peut changer de département pour telle adresse, le solde du compte ne peut être inférieur à une limite autorisée).

Développer une application revient à concevoir et à coder le modèle statique, la mécanique navigationnelle (Crud = create-retrieve-update-delete), les règles de gestion et les exceptions-métier, l'interface utilisateur, après avoir choisi une infrastructure technique (jsf dans notre cas) et une solution de persistance du modèle (jdbc, hibernate, ejb, etc...), conformément aux spécifications fonctionnelles qui auront été rédigées pour satisfaire le besoin.

Organisation du code

La première tâche est de structurer le projet.
Les classes de l'application se situent dans un package bank. Les classes du modèle dans un package bank.model. Les exceptions métier ont également un package réservé, ainsi que les contrôleurs.

L'organisation du code proposée est le fruit d'un parti-pris architectural, et n'est en rien obligatoire. Cependant, cette méthode met en évidence le modèle MVC sous-jacent à JSF, et tend à établir une bonne pratique.

Les contrôleurs sont au nombre d'un par entité, ils ont tous la même structure.
Les composants graphiques sont extraits des contrôleurs et placés dans une classe View (package bank.view).
Les vues sont génériques, il ne doit pas y avoir d'adhérence au modèle, sauf décision de conception différente.

Afin d'éviter l'adhérence au modèle, on utilise éventuellement des classes utilitaires afin de peupler certains composants (voir classe KeyValuePair par exemple).

Les classes du modèle ne doivent comporter aucune adhérence aux contrôleurs ni aux vues. Vérifiez le en examinant la liste des imports.

L'organisation proposée n'est pas totalement aboutie. Il sera nécessaire, par la suite, de déresponsabiliser les contrôleurs des fonctionalités de navigation dans le modèle(crud). Ces fonctionnalités seront, plus tard, confiées à des classes DAO (Data Access Object), les contrôleurs conservant simplement une fonction d'aiguilleur.

Structure du projet

Interface utilisateur

Exemples de code

dans bankControler:

dans ListView

la classe KeyValuePair

dans bankForm.jsp

corrigé ici

Frameworks JSF - Ajax

2007-11-21T01:05:00.000-08:00

Outre les bibiliothèques référencées par jsfmatrix déjà citées, voici deux autres bibliothèques JSF basées sur Ajax
Les composants Yahoo: Yui4jsf démo
Un framework Sun: jMaki démo

TP: Application bancaire simplifiée

2007-11-06T16:12:00.000-08:00

L'exemple est tiré de Netbeans: UMLBankAppSample

Spécifications:

L'application permet de créer banques, des clients et des comptes bancaires.
Les comptes sont de trois types:

Checking: compte courant
Saving: compte épargne
Platinum: compte de type carte de paiement

Tous les types de comptes ont les attributs suivants:

double balance; // le solde
String accountNumber; Le numéro de compte
double interestRate; //un taux d'intérêt

En outre ils possèdent un historique et ils sont liés à un client:

History history;
Customer customer;

Le client possède plusieurs comptes et possède les attributs suivants:

int id;
String name;
String forName;
String address;
String zipCode;

Le compte Checking est soumis à une pénalité en cas de découvert:

double overdraftPenalty = 25.00;

Le Platinum possède une autorisation maxi et une réserve d'argent qui diminue en cas de retrait si le solde n'est pas suffisant.

static final double overdraftLimit = 2500.00;
double availableFunds;

Le compte Saving rapporte des intérêts quand le solde est positif.
La classe History possède un seul attribut qui compte les opérations:

int transaction;

Créer un cas de test:

public static void main(String[] args) { BankApplication app = new BankApplication(); System.out.println("-----Creating customers-----"); Customer c1 = new Customer(1,"Dupont","Jean","10, rue des lilas","30000"); app.add(c1); Customer c2 = new Customer(2,"Poulain","Amélie","20, rue des mimosas","34000"); app.add(c2); System.out.println("-----Creating accounts-----"); Checking checkingAccount1 = new Checking("1234",150); app.add(checkingAccount1); Saving savingAccount1 = new Saving("12399", 100,0.06); app.add(savingAccount1); Checking checkingAccount2 = new Checking("9234",1501); app.add(checkingAccount2); Saving savingAccount2 = new Saving("92399", 1000,0.07); app.add(savingAccount2); c1.addAccount(checkingAccount1); c1.addAccount(savingAccount1); c2.addAccount(checkingAccount2); c2.addAccount(savingAccount2); System.out.println("-----writings-----"); savingAccount1.deposit(700.00); checkingAccount1.deposit(360.00); checkingAccount1.deposit(10.00); checkingAccount1.deposit(20.00); try{ checkingAccount1.withdraw(10.00); checkingAccount1.withdraw(20.00); checkingAccount1.withdraw(60.00); } catch(Exception ex){ //ex.printStackTrace(); } checkingAccount2.deposit(10.00); try{ checkingAccount2.withdraw(10660.00); } catch(Exception ex){ //ex.printStackTrace(); } System.out.println("-----Bank Application balances-----"); System.out.print(app.toString()); }

Créer un modèle de classes du domaine à base de simples javabeans (la persistence sera implémentée ultérieurement)

A l'exécution du test , on obtient:


-----Creating customers-----
-----Creating accounts-----
Account created: Checking Account:        Number:  1234
Balance:  150.0 history is empty
Account created: Saving Account:        Number:  12399
Balance:  100.0
Account created: Checking Account:        Number:  9234
Balance:  1501.0 history is empty
Account created: Saving Account:        Number:  92399
Balance:  1000.0
-----writings-----
1 Jean Dupont Saving Account:        12399 deposit 700.0
1 Jean Dupont Checking Account:        1234 deposit 360.0
1 Jean Dupont Checking Account:        1234 deposit 10.0
1 Jean Dupont Checking Account:        1234 deposit 20.0
1 Jean Dupont Checking Account:        1234 withdraw 10.0
1 Jean Dupont Checking Account:        1234 withdraw 20.0
1 Jean Dupont Checking Account:        1234 withdraw 60.0
2 Amélie Poulain Checking Account:        9234 deposit 10.0
2 Amélie Poulain Checking Account:        9234 withdraw 10660.0
2 Amélie Poulain Checking Account:        9234 noAvailableFunds
-----Bank Application balances-----
1 Jean Dupont
Checking Account:        Number:  1234
Balance:  450.0    Transaction count is 3
Saving Account:        Number:  12399
Balance:  800.0
------------
2 Amélie Poulain
Checking Account:        Number:  9234
Balance:  1511.0 history is empty
Saving Account:        Number:  92399
Balance:  1000.0
------------

Intégrer l'application dans une application web, au moyen d'un backing bean.

Créer les pages permettant de naviguer dans l'application, de créer, de supprimer, modifier des banques, des clients, des comptes, et d'effectuer des opérations.
Vérifier la non régression des règles de gestion.

Pour chaque entité, il faut prévoir une vue en liste basée sur une DataTable, et une vue d'édition basée sur un formulaire, voir tp jee-jsf et guide de référence
le modèle ici.
le corrigé v1 ici.

Myfaces et JBoss 4.2

2007-11-06T02:27:00.000-08:00

Pour utiliser l'implémentation Apache MyFaces avec JBoss 4.2 et Redhat Developer Studio, il est nécessaire d'effectuer les opérations suivantes:

Créer un nouveau projet jsf

choisir MyFaces 1.1.4

Tester: Run as/Run on server ...

On obtient l'erreur suivante car il y a un conflit entre l'implémentation MyFaces déployée avec la webapp et l'implémentation de référence fournie avec JBoss.

10:04:44,796 ERROR [[/myfaces-examples]] Erreur lors de la configuration de la classe d'écoute de l'application (application listener) org.apache.myfaces.webapp.StartupServletContextListener
java.lang.ClassNotFoundException: org.apache.myfaces.webapp.StartupServletContextListener

Solution: Supprimer l'implémentation JSF-RI de JBoss

Stopper le serveur JBoss
Supprimer les bibliothèques jsf livrées avec Jboss

ici: [jboss server dir]\server\default\deploy\jboss-web.deployer\jsf-libs

Mettre hors service les listeners jsf dans web.xml

ici: [jboss server dir]\server\default\deploy\jboss-web.deployer\conf\web.xml

ainsi que le paramètre suivant:

Redémarrer le serveur Jboss, vérifier que le serveur démarre sans exception et qu'il n'y ait pas d'erreur au déploiement de la webapp.

Installer les exemples MyFaces

2007-11-05T04:53:00.000-08:00

Les exemples de l'implémentation MyFaces subissent quelques modifications pour s'exécuter avec JBoss 4.2 et Eclipse.

Le site des exemples MyFaces original est ici.
Un projet MyFaces-examples modifié se trouve ici.
Créer un projet MyFaces comme il est décrit ici.
Copier le répertoire WebContent et JavaSource du projet téléchargé dans ce nouveau projet créé.

Modifier web.xml (répertoire WEB-INF) pour permettre l'affichage des codes sources, en adaptant le path (init-param source.dir) du code source du projet:

Run as / Run on server pour tester

Ajouter un exemple: ValueChangeListener et Validation.
Comment concilier un submit destiné à rafraichir une page, sans effectuer la validation du formulaire, avec un submit destiné à appliquer la règle de gestion et de navigation de la vue?

Créer un formulaire dans une jsp:

code de la jsp:

<?xml version="1.0" encoding="ISO-8859-1" ?> <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%> <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%> <%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%> <%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>ValueChangeListeners et validations</title> </head> <body> <%@include file="inc/head.inc"%> <f:view> <h:panelgroup id="body"> <h:outputlabel styleclass="header18" value="ValueChangeListeners et validations"></h:outputLabel> <h:form id="f1"> <h:panelgrid columns="3" border="1" rules="all"> <h:panelgroup> <h:outputlabel value="foobar" for="ip1"></h:outputLabel> <f:verbatim>, une valeur entre 5 et 10</f:verbatim> </h:panelGroup> <h:inputtext value="#{selectModel.dummyValue}" id="ip1" required="true"> <f:validatelongrange minimum="5" maximum="10"> </h:inputText> <t:message id="foobarError" for="ip1" styleclass="error"> <h:selectonemenu id="selone_menu_options" value="o2" styleclass="selectOneMenu" onchange="submit()" immediate="true" valuechangelistener="#{selectModel.menuChanged}"> <f:selectitem itemvalue="" itemlabel="choose"> <f:selectitems value="#{selectModel.optionItems}"> </h:selectOneMenu> <h:outputtext value="#{selectModel.counter}"></h:outputText> <h:commandbutton action="#{selectModel.confirm}" value="ok"></h:commandButton> </h:panelGrid> </h:form> <t:messages id="messageList" styleclass="error" summaryformat="{0} dans {1}"> </h:panelGroup> <jsp:include page="inc/mbean_source.jsp"> </f:view> <%@include file="inc/page_footer.jsp"%> </body> </html>

code du bean:

package org.apache.myfaces.examples.listener; import java.util.ArrayList; import java.util.List; import javax.faces.context.FacesContext; import javax.faces.event.ValueChangeEvent; import javax.faces.model.SelectItem; /** * @author Martin Marinschek */ public class SelectModel { private List<string> options; private List<selectitem> optionItems; private long dummyValue = 100; public long getDummyValue() { return dummyValue; } public void setDummyValue(long dummyValue) { this.dummyValue = dummyValue; } public List getOptions() { if (options == null) { initOptions(); } return options; } public void setOptions(List options) { this.options = options; } public List getOptionItems() { if (optionItems == null) { initOptions(); } return optionItems; } static int counter = 5; /** * chaque fois on ajoute une option dans la boite * * @param event */ public void menuChanged(ValueChangeEvent event) { options.add("o" + counter); optionItems.add(new SelectItem("o" + counter, "Option " + counter)); counter++; FacesContext.getCurrentInstance().renderResponse(); // pour // court-circuiter // le cycle } public int getCounter() { return counter; } public String confirm() { System.out.println("confirmed"); return "ok"; } private void initOptions() { options = new ArrayList<string>(); options.add("o1"); options.add("o2"); options.add("o3"); options.add("o4"); optionItems = new ArrayList<selectitem>(); optionItems.add(new SelectItem("o1", "Option 1")); optionItems.add(new SelectItem("o2", "Option 2")); optionItems.add(new SelectItem("o3", "Option 3")); optionItems.add(new SelectItem("o4", "Option 4")); } }

Lorem Ipsum

2007-11-01T15:56:00.000-07:00

Lorem Ipsum est un générateur de textes aléatoires. Vous choisissez le nombre de paragraphes ou de mots. Vous obtenez alors un texte aléatoire que vous pourrez ensuite utiliser dans vos maquettes.
Le texte généré est du pseudo latin et peut donner l'impression d'être du vrai texte.

Illud tamen te esse admonitum volo, primum ut qualis es talem te esse omnes existiment ut, quantum a rerum turpitudine abes, tantum te a verborum libertate seiungas; deinde ut ea in alterum ne dicas, quae cum tibi falso responsa sint, erubescas. Quis est enim, cui via ista non pateat, qui isti aetati atque etiam isti dignitati non possit quam velit petulanter, etiamsi sine ulla suspicione, at non sine argumento male dicere? Sed istarum partium culpa est eorum, qui te agere voluerunt; laus pudoris tui, quod ea te invitum dicere videbamus, ingenii, quod ornate politeque dixisti.

Et licet quocumque oculos flexeris feminas adfatim multas spectare cirratas, quibus, si nupsissent, per aetatem ter iam nixus poterat suppetere liberorum, ad usque taedium pedibus pavimenta tergentes iactari volucriter gyris, dum exprimunt innumera simulacra, quae finxere fabulae theatrales.

Et est admodum mirum videre plebem innumeram mentibus ardore quodam infuso cum dimicationum curulium eventu pendentem. haec similiaque memorabile nihil vel serium agi Romae permittunt. ergo redeundum ad textum.

Hacque adfabilitate confisus cum eadem postridie feceris, ut incognitus haerebis et repentinus, hortatore illo hesterno clientes numerando, qui sis vel unde venias diutius ambigente agnitus vero tandem et adscitus in amicitiam si te salutandi adsiduitati dederis triennio indiscretus et per tot dierum defueris tempus, reverteris ad paria perferenda, nec ubi esses interrogatus et quo tandem miser discesseris, aetatem omnem frustra in stipite conteres summittendo.

Ex turba vero imae sortis et paupertinae in tabernis aliqui pernoctant vinariis, non nulli velariis umbraculorum theatralium latent, quae Campanam imitatus lasciviam Catulus in aedilitate sua suspendit omnium primus; aut pugnaciter aleis certant turpi sono fragosis naribus introrsum reducto spiritu concrepantes; aut quod est studiorum omnium maximum ab ortu lucis ad vesperam sole fatiscunt vel pluviis, per minutias aurigarum equorumque praecipua vel delicta scrutantes.

Présentation syntaxique de code

2007-10-30T06:28:00.000-07:00

SyntaxHighlighter is here to help a developer/coder to post code snippets online with ease and have it look pretty. It's 100% Java Script based and it doesn't care what you have on your server.

/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.myfaces.examples.aliasexample; import javax.faces.component.html.HtmlPanelGroup; import javax.faces.component.html.HtmlOutputText; import javax.faces.component.UIComponent; import javax.faces.context.FacesContext; /** * @author Martin Marinschek (latest modification by $Author: matzew $) * @version $Revision: 167718 $ $Date: 2005-03-24 17:47:11 +0100 (Do, 24 Mär * 2005) $ */ public abstract class ComponentBindingHolderBase { protected HtmlPanelGroup _panelGroup; public HtmlPanelGroup getPanelGroup() { if (_panelGroup == null) { _panelGroup = (HtmlPanelGroup) createComponent(HtmlPanelGroup.COMPONENT_TYPE); _panelGroup.getChildren().add(createOutputText()); } return _panelGroup; } public void setPanelGroup(HtmlPanelGroup panelGroup) { _panelGroup = panelGroup; _panelGroup.getChildren().add(createOutputText()); } protected UIComponent createComponent(String type) { return FacesContext.getCurrentInstance().getApplication() .createComponent(type); } private HtmlOutputText createOutputText() { HtmlOutputText text = (HtmlOutputText) createComponent(HtmlOutputText.COMPONENT_TYPE); text.setValue(getText()); return text; } protected abstract String getText(); }

blabla...