1/ Ajout d’une feuille de style
Dans Eclipse, pour ajouter un fichier CSS (ou autre), allez sur le dossier WebContent et le sous dossier css (créé le dossier s’il est manquant clic droit sur WebContent > New > Folder) puis faire clic droit pour ouvrir le Menu:
Dans le Menu on peut choisir New > Other puis dans la longue liste soit choisir soit chercher ici un fichier CSS. Cela devrait donc créer dans le bon dossier WebContent\Css\ le fichier style.css.
L’ajout d’une feuille de style permet de proposer une nouvelle mise en forme. Ajouter le fichier style.css contenant le code suivant dans le dossier css du dossier WebContent:
div#central{
position:absolute;
left: 50%;
top: 10%;
width: 800px;
height: 800px;
margin-top: -50px;
margin-left: -400px;
color: black;
background-color:rgb(200,220,200);
padding: 20px;
}
ul {
list-style: none;
margin: 0;
padding: 4px 4px 4px 4px;
}
ul > li{
display: inline;
}
div#menu{
position:relative;
left:10%;
width:80%;
background-color:rgb(200,240,220);
}
Il faut ajouter deux div dans la JSP avec comme « id » central et menu, le div « menu » doit être inclus dans central et appeler le fichier style.css dans le tag <head> :
<link rel="stylesheet" type="text/css" href="css/style.css">
<div id="central">
<div id="menu">
<!-- Zone pour le menu -->
</div>
<!-- Zone pour le contenu -->
</div>
2/ Zone de menu
La zone menu va utiliser une liste d’hyperlien pour présenter un menu (voir le site alsacreation pour les étapes de construction en CSS mais arrêté vous avant l’étape « Un menu graphique, avec rollover mais sans javascript »).
Notre objectif ici est de vous montrer quelques possibilités du CSS pour la modification de tag d’une liste.
<ul><li><a href="#">Menu 1</a></li><li><a href="#">Menu 2</a></li></ul>
Après la création du menu avec la feuille de style placer ce code dans la zone div menu pour que sa forme soit similaire à l’image ci-dessous.
Je vous invite à modifier les couleurs en CSS et la mise en forme à votre gout, elle est stratégiquement moche pour vous motiver en ce sens 😉
Pour l’affichage des différentes zones, je vous recommande d’utiliser les outils intégrés avec votre navigateur pour sélectionner un élément et voir son code correspondant:
Sur cette image, nous voyons qu’en sélectionnant en bas les tags, leur équivalent sera surligné dans la partie du haut.
Autre exemple avec le site www.mines-ales.fr (oui on utiliser l’inspecteur de code Html sur tout site web), on peut sélectionner l’outil qui est représenté par une flèche puis sélectionner un élément HTMl ce qui nous indique en correspondance le tag html correspondant à cet élément et on voit aussi en partie droite de l’interface la liste des réglages CSS qui s’y applique:
Modifier les marges et les couleurs à votre convenance pour utiliser les différentes règles du CSS.
Notre menu au final devrait être plutôt de cette forme pour permettre des appels à notre contrôleur:
<ul>
<li>
<a href="./Controleur?action=pageAddTodo">Add Todo</a>
</li>
<li>
<a href="./Controleur?action=xml">Liste xml</a>
</li>
<li>
<a href="./Controleur?action=json">Liste Json</a>
</li>
</ul>
Mais on va conserver la forme initiale pour ajouter à terme par exemple des évènements en javascript dans le TP dédié à javascript.
3/ Découverte du framework bookstrap avec une mise en forme à récupéer :
Je vous invite à comprendre comment fonctionne la mise en forme du framework Bootstrap Css en utilisant par exemple le jumbotron comme exemple: Jumbotron .
Si vous ne vous sentez pas à l’aise en Css, vous pouvez ne pas le réaliser mais au moins regarder l’enchainement des actions ci-dessous notamment l’affichage de l’onglet Network/Réseau dans les outils de développement.
L’idée serait de placer votre liste de Todo dans la colonne de gauche, le formulaire pour ajouter un nouveau todo au milieu (utiliser l’inspecteur Html pour trouver le tag gérant cette zone peut être un tag <div class= »col-md-4″> qui mériterai un attribut id) :
Pour récupérer le code HTML, faire clic droit sur la page pour afficher la page HTML.
Sinon ouvrer encore une fois les Web Dev Tool du navigateur et dans l’onglet Network/Réseau vous avez la liste des fichiers téléchargés par cette page HTML.
Sélectionner les éléments Css et JS pour lister tous les fichiers et les ouvrir individuellement dans une nouvelle page pour les sauvegarder ensuite:
Il ne vous reste plus qu’à reconstruire la liste des fichiers dans votre dossier WebContent et à corriger les URL d’appel de ces fichiers dans le tag <header> de votre page JSP.
4/ Utilisation des logs
Les logs sont une solution élégante pour gérer 2 problèmes classiques, plusieurs niveaux d’informations techniques et plusieurs sources d’informations techniques.
Quand vous développez, vous avez tendance à faire une écriture dans la console via des classiques:
System.out.println("Erreur " + e);
En développement Web avec Tomcat, si vous faites des System.out.println, toutes les sorties console vont au niveau de Tomcat dans un fichier appelé catalina.out.
Si vous avez plusieurs applications sur votre serveur tomcat, toutes les sorties vers la console seront mélangées.
On peut aussi utiliser la commande vers les sorties erreur mais cela ne fait que 2 niveau System.out ou System.err.
System.err.println("Erreur " + e);
Mais encore une fois, nous n’avons que 2 niveaux séparrant les informations et tout est mélangé.
En production, les logs permettent de gérer les sorties d’informations de l’application en se limitant au maximum, et au contraire en développement, on peut avoir besoin d’un niveau très important de détails des logs.
Log4j est un framework de Log qui permet de gérer plusieurs destination aux commande de log vers la console et/ou des fichiers et/ou une base de données et/ou un serveur de log.
Nous pouvons aussi démarrer un projet avec le niveau de log que nous voulons.
Pour installer log4j, télécharger ma version disponible en version 1.2.17 sur le site habituel : http://www.master-ctn.mines-ales.fr/install/M1-Web/commun/. Vous placez ce jar dans un dossier lib (à créer) dans le dossier WEB-INF du dossier WebContent.
Nota: vous pourrez mettre d’autres librairies .jar à déployer dans votre projet web dans ce dossier pour que chaque Application Web disposent de ses propres jars. Ci-dessous un exemple d’un projet Web où j’ai eu besoin d’une petite liste de jar:
Nota 2: Une autre option est d’utiliser le dossier lib dans le dossier tomcat pour indiquer les jars disponible pour tous les projets déployés mais dans ce cas, les jars seront identiques pour toutes vos applications Web développés. Le choix est toujours soit d’un côté de normaliser pour que toutes les applications utilisent la même bibliothèque soit au contraire d’individualiser pour que chaque application disposent de ses propres bibliothèques. C’est une décision de mise en production.
NOTA : Eclipse ne scanne pas les nouveaux fichiers comme votre fichier de log, il faut faire un le refresh du projet, sur le projet, clic droit Menu > Refresh ou la touche F5 comme votre navigateur. Bien sur il faut généré un message pour le logger sinon le fichier ne sera pas créé
Pour configurer le logger, on va créer un fichier log4j.properties dans le dossier Java Resources > src (il n’a pas à être dans un package ce n’est pas un fichier java juste un fichier de configuration). Pour créer un fichier texte, faire clic droit sur le dossier > New > Other …> General > Untitled Text File.
Entrez les informations suivantes dans le fichier et sauver le dans votre projet, dans le dossier src avec comme nom log4j.properties.
Le fichier log4j.properties doit contenir ces informations:
log4j.rootLogger=DEBUG,stdout,file
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/Developpement/workspace_jee/BoostrapSample/out.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%-7p %d [%t] %c %x - %m%n
NOTA: BoostrapSample est le nom de mon projet, à modifier selon votre nom de projet bien sûr.
La première ligne indique que le niveau de log est DEBUG et qu’il y a 2 loggers: stdout et file.
Ensuite nous avons 2 sorties de notre logger, log4j.appender.stdout et log4j.appender.file. Nous pourrions envoyer des log vers d’autres sorties comme une base de données, un serveur de log, des emails, etc.
Les lignes commençant par log4j.appender.stdout indique les réglages pour le logger stdout soit une sortie d’information sur la console de l’ordinateur (là où va habituellement le System.out.println).
Les lignes commençant par log4j.appender.file indique les réglages pour le logger file soit une sortie dans un fichier. Il vous faut corriger mon exemple pour que le fichier puisse être créer dans le dossier qui correspond à votre workspace ( vous n’avez peut être pas de dossier: c:/Developpement/workspace_jee/BoostrapSample/ ).
L’instruction ConversionPattern indique la forme de la sortie:
La date: %d{ABSOLUTE}
Le niveau de log: %5p
Le nom du logger: %c{1}
La ligne du log: %L
Le message: %m
Vous pouvez trouver des exemples de pattern avec log4j
Pour utiliser le logger dans une classe, on va simplement créer une instance log de type org.apache.log4j.Logger:
private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger("BoostrapSample");
Nota: j’utilise le chemin absolut de la classe en spécifiant sont package devant (org.apache.log4j) car il existe d’autres solutions de log et Tomcat utilise d’ailleurs pour son utilisation interne org.apache.commons.logging. Il peut donc y avoir conflit entre les 2 systèmes de Log. Nous avons ici une démonstration de la force/faiblesse de Java qui va foisonner de solutions pour proposer une variété de réponses mais qui peut gêner par leur multiplicité, nous obligeant à gérer la situation.
Au moment où on veut logger une information, il suffit d’appeler l’instance avec le niveau de sévérité du message et de passer en paramètre le message.
Le niveau de sévérité permet de différencier l’importance d’un message de log.
Il y a habituellement 6 niveaux du plus critique au moins critique:
- fatal
- error
- warm
- info
- debug
- trace
Si fichier de configuration de log4j indique que je dois logger du niveau info, alors les messages de sévérité fatal, error, warm et info seront envoyés.
Je vous renvoie sur cet excellent article qui indique quelques bonnes pratiques.
Par exemple, si je veux faire un log après l’ajout d’un nouveau Todo, le niveau que je vais choisir est debug, un niveau pour le débugage qui ne sera pas envoyé par la configuration de log4j en production.
// Action1 addTodo
if ("addTodo".equals(action)) {
logger.debug( "addTodo " + texte );
}
ou en suivant les bonnes pratiques conseillé par l’article de Setu Patani en utilisant le remplacement de symbole avec la méthode String.format:
// Action1 addTodo
if ("addTodo".equals(action)) {
logger.debug( String.format( "addTodo %s", texte ) );
}
La version 2 de log4j permet directement de faire l’opération avec le symbole de remplacement mais nous nou contenterons de la version 1 de log4j pour plus de simplicaité
// Action1 addTodo
if ("addTodo".equals(action)) {
logger.debug( "addTodo {}", texte );
}
On peut donc faire des messages de différent niveau de criticité:
logger.trace("Niveau le moins important");
logger.debug("Niveau au dessus du moins important");
logger.info("Niveau habituel de fonctionnement");
logger.warm("Erreur non bloquante");
logger.error("Niveau Erreur classique");
logger.fatal("Niveau Erreur maximum");
Au final on peut utiliser qu’un nombre limité de niveaux d’erreurs ou au contraire ajouter ses propres niveaux. L’important est d’éviter de saturer d’erreurs le fichier de tomcat avec tout type de niveau d’erreur ou au contraire de trop filter l’affichage de potentiels problèmes mineurs.
C’est la première ligne du fichier log4j.properties qui indique le niveau d’erreur minimum que je filtre, avec le niveau DEBUG, log4j, va afficher les logs FATAL,ERROR,WARM, INFO et DEBUG.
log4j.rootLogger=DEBUG // affiche FATAL,ERROR,WARM, INFO et DEBUG
log4j.rootLogger=ERROR// affiche FATAL et ERROR
Je peux modifier le niveau de Log avec l’instruction suivante en cours d’exécution dans mon programme directement:
log.setLevel( org.apache.log4j.Level.INFO );
Ajouter un troisième logger en html en vous inspirant de ce code:
log4j.appender.html=org.apache.log4j.DailyRollingFileAppender log4j.appender.html.DatePattern='.'yyyy-MM-dd-HH-mm log4j.appender.html.layout=org.apache.log4j.HTMLLayout log4j.appender.HTML.layout.LocationInfo=true log4j.appender.HTML.layout.Title=Application logs log4j.appender.html.File=C:/Dev/eclipse-workspace/application.html
Ce logger a plusieurs spécificités si vous lancer des logs en nombres. Consulter régulièrement le dossier où va être stocker vos logs et si vous utilisez Eclipse pour afficher le contenu de dossier, n’hésitez pas à faire rafraîchir le contenu du dossier.
Le premier niveau d’utilisation du Logger est de tout mettre dans un seul logger appelé ici « rootLogger » mais on peut aussi utiliser des catégories de logger pour séparer des sources de logs en fonction de différentes utilisations.
Supposons que l’on veut logger pour les réquêtes SQL de manière séparée, on peut créer un logger appelé « requete » avec ses propres réglages:
log4j.rootLogger=DEBUG,stdout, file log4j.logger.requete=INFO, requete log4j.appender.requete=org.apache.log4j.RollingFileAppender log4j.appender.requete.File=c:/Developpement/requete.log log4j.appender.requete.layout=org.apache.log4j.PatternLayout log4j.appender.requete.layout.ConversionPattern=%-7p %d [%t] %c %x - %m%n log4j.appender.requete.MaxFileSize=10KB log4j.appender.requete.MaxBackupIndex=5
Dans ce cas, la fabrication de plusieurs fichiers requete.log.X sera réalisé automatiquement en préserver la taille d’un fichier au maximum à 10Kb puis au bout de 5 fichiers créé le plus ancien sera éffacé pour être recréé par un mécanisme de rotation.
5/ Installation d’un plugin Eclipse Log Viewer
Pour afficher les logs, j’utilise un plugin d’Eclipse qui s’appelle « Log Viewer« . Le but de cette partie en plus d’utiliser le Log Viewer est de voir l’ajout d’un plugin dans Eclipse ( et on a des tonnes de plugins dans Eclipse) et sont ajout dans une perspective d’Eclipse JEE.
Vous pouvez installer ce plugin en faisant glisser-deposer le bouton « Install » dans Eclipse.
Comme ceci: 
Confirmer l’acceptation de la licence, puis Accepter l’installation « Install anyway » sur la fenêtre « Security Warning »
Vous pouvez ensuite mettre dans votre pesrpective Eclipse ce nouveau plugin via le menu Windows > Show View > Other… et chercher Log Viewer
Dans la fenêtre Log Viewer, on peut ensuite ouvrir différents fichier de log, régler la coloration des logs, rafraichir l’affichage, etc.
En premier lieu, il faut ouvrir le fichier des logs créé avec le bouton Open Logfile:
.
Ensuite, on peut indiquer les règles que l’on veut appliquer au Log Viewer via le bouton Show rules preferences:
La liste des règles peut être modifiée pour mettre en surbrillance différentes lignes des logs selon un critère de recherche, dans notre cas s’il y a le mot INFO c’est en fond vert, si on a le mot ERROR, c’est en fond rouge:
L’idée par exemple est d’avoir ce type de logger
@WebServlet(urlPatterns = { "/Controleur" })
public class Control extends HttpServlet {
private Logger logger = Logger.getLogger("BoostrapSample.main.controleur");
Puis quelque part dans le code de la servlet, sur l’ajout d’un Todo:
// Action1 addTodo
if ("addTodo".equals(action)) {
String texte = request.getParameter("todo_texte");
Application.getInstance().addTodo(texte, false);
logger.debug( String.format("addTodo with parametres [%s,%s ] ", texte , actif ) );
vueFinale = "index.jsp";
}
Dans l’absolut on pourrait remplacer l’appel aux paramètre texte et actif par un todo.toString() a surcharger dans la classe Todo.
6/ Classe Helper
Le Helper, est un design pattern, c’est une classe qui « aide une autre classe ». Prenons par exemple une classe Livre qui gère classiquement les informations d’un livre (on appelle cela un POJO: Plain-Old Java Object). Sa vocation est de stocker de l’information sur un Livre dans ses propriétés (titre, nombre de page, auteur, editeur, collection, isbn, etc.).
Prenons comme exemple, une ou plusieurs méhodes qui vérifient l’intégrité des données, plutôt que de les ajouter dans la classe Livre, on pourrait les ajouter dans une classe LivreHelper. On trouverai par exemple une méthode checkISBN() qui a vocation à vérifier le ISBN, checkAuteur() qui va vérifier que l’auteur existe vraiment dans une base de données en ligne, etc.
Toutes ces méthodes n’ont pas vraiment besoin d’être dans la classe Livre mais plutôt dans une classe annexe LivreHelper. De temps en temps dans un projet, on trouve par exemple une classe Util qui a des méthodes de convertion ou de vérification mais au final cette classe devrait être renomée et lié à un POJO car c’est une classe Helper.
Par exemple, nous allons ajouter une classe ControleurHelper qui va nous permettre d’aider le Controler en réalisant le log des paramètres passés au Controleur.
private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger( "BoostrapSample.main.ControlerHelper" );
public static void logAllParameters(HttpServletRequest request){
Map<String, String[]> parameters = request.getParameterMap();
for(String parameter : parameters.keySet()) {
String[] values = parameters.get(parameter);
String value = Arrays.stream( values ).collect(Collectors.joining(","));
log.info( "Parametre " + parameter + " " + value );
}
}
ATTENTION: cette méthode utilise un fonctionnalité avancée du Java 8+ appelée stream. Quel intérêt au stream ? Le stream est une solution moderne pour exploiter les traitements multi coeurs des listes en Java. Elle permet de sérialiser des traitement en convertissant les anciens formats des différentes structures de listes (les classes/interfaces Set, List, ArrayList, Map, Array, Collection, etc.) dans un nouveau format plus rapide aux traitements.
La méthode suivante fait une convertion d’un type String[] values en stream pour permettre de réaliser des traitements plus performant et plus lisible avec les méthodes inlines.
Arrays.stream( values )
Nous allons donc faire appel à une méthode inline par exemple filtrer les informations.
NOTA: L’utilisation d’une méthode inline en Java se retrouve dans d’autres langage de programmation dont le javascript que l’on verra plus tard.
L’appel d’une méthode inline ou anonyme est une technique de programmation qui permet de créer une instance de classe avec une méthode et d’appeler tout cela en 1 ligne. Nous la retrouverons dans le code javascript notamment.
Par exemple, nous voulons une méthode qui appelle un évènement Action dans un interface graphique
Button b=new Button("Click Here");
b.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("Hello World!");
}
});
On a la construction d’une classe ActionListerner pour faire appel à une seule méthode pour réaliser l’opération actionPerformed dans notre cas.
Voici la version inline que l’on appelle aussi lamba en Java:
b.addActionListener( e -> System.out.println("Hello World!"));
On voit bien la simplification dans ce cas, on trouve parfois le terme de sucre syntaxique pour indiquer une facilité de compréhension dans le codage.
Donc avec ce sucre syntaxique, par exemple, si on souhaite traiter la liste des Todos comme un stream pour extraire le texte des Todos actifs uniquement.
Nous partons d’une liste de Todos que nous convertissons en stream
lesTodos.stream()
Maintenant nous allons utiliser une méthode filter pour n’utiliser que les Todos actif, nous pourrions passer une méthode qui donne la raison de la comparaison à la méthode filter. C’est l’opérateur -> qui indique à gauche quel est le nom paramètre sur chaque élément du stream que nous allons exploiter et à droite de l’opérateur l’action à réaliser.
todo -> todo.isActif()
est à mettre en parallèle à la création d’une classe anonyme avec une méthode qui est automatiquement appelé
Class anonyme{
public static boolean méthode_appelé_automatiquement(Todo todo){
return todo.isActif();
}
}
Cela suppose un peu de code pour une méthode qui au final ne va pas être énormément exploitée. D’où l’utilisation des appels inline plus simple à écrire:
lesTodos.stream().filter( todo -> todo.isActif())
L’idée derrière les streams qui est utilisées dans le traitement de données de type fouille de données et Big Data et de pouvoir chaîner les opérations pour permettre à la JVM d’exploiter les multiples processeurs en parallélisant les actions.
Nous allons ensuite recupérer le résultat du filtrage et indiquer quel partie du Todo nous voulons extraire le texte du todo:
lesTodos.stream().filter( todo -> todo.isActif()).map( todo -> todo.getTexte() )
Nous pouvons maintenant exploiter la méthode collect pour fusionner les données en les contenants avec un séparateur et en transformant le résultat en String:
String reponse = lesTodos.stream().filter( todo -> todo.isActif()).map( todo -> todo.getTexte() ).collect(Collectors.joining(","));
Vous trouverez sur le web énormément d’exemple sur l’utilisation des streams qui sont en train de devenir très performant pour l’exploitation de données en parallèle (voir l’exemple de la somme d’entier en stream sur le site d’Oracle).
7/ Breakpoint conditionnel
Il me parait utile d’indiquer qu’Eclipse en Java permet de créer un point d’arrêt (le breakpoint en VO) en mode conditionnel. Vous pouvez ouvrir le « Breakpoint Properties » puis indiquer que ce breakpoint est « Conditional » et d’indiquer ensuite le critère qui déclenchera la pause sur le breakpoint, « Suspend when ‘true' » :
L’utilisation des breakpoints et le débogage est un outil très utile pour le développement. Autant parfois, je passe par toute les étapes de mon débugage pour reprendre l’enchainement des lignes de codes qui arrivent avant un point compliqué. Autant parfois, je peux indiquer un breakpoint et indiquer une condition qui pose un problème particulier.
A vous de tester et de voir ce qu’il vous parait le plus utile.
8/ Ajout de la partie Base de données
Pour exploiter la base de données, nous devons ajouter un connecteur JDBC pour que notre code Java puisse se connecter s’y connecter.
Si on a une base de données Mysql, il faut le connecteur Mysql. Ce connecteur s’appelle JConnector et il est disponible à cette adresse: https://dev.mysql.com/downloads/connector/j. Autant j’utilise régulièrement Mysql, autant je le trouve parfois un peu trop compliqué dans un TP pour gérer les droits sur les bases de données.
Nous allons exploiter par contre une base de données Sqlite. Pour cela, il faut ajouter le fichier sqlite-jdbc-3.8.11.2.jar accessible sur cette adresse (http://www.master-ctn.mines-ales.fr/install/M1-Web/commun/) et à mettre dans le dossier WebContent\WEB-INF\lib\ avec le jar du log4j.
Pour utiliser sqlite, il faut une classe spécifique DaoManager qui va gérer les accès à la base de données. Vous pouvez vous inspirer de la classe DaoManager pour réaliser votre propre classe qui doit gérer la connexion et les opérations de manipulation de la base de données.
Au choix, le DaoManager peut être appelé par le Controleur ou par Application qui aura donc en charge la gestion des accès à la base de données.
Le fichier contenant la base de données s’appelle todo.db, ce dernier se trouve par défaut dans le dossier d’Eclipse. Il ne sera que quand il y aura des opérations sur les opérations sur la base de données.
Pour voir le contenu de la base de données sqlite, on peut utiliser par exemple un outil DBrower for sqlite accessible sur ce site : https://sqlitebrowser.org/dl/.
NOTA: le fichier sqlite est verrouillé (VO: Lock) si vous l’ouvrez avec sqlitebrowser. Fermer le pendant les développements. Une ancienne version permettait d’ouvrir le fichier sans le verrouillermais je ne la retrouve plus.
L’installation est assez classique, il n’y a qu’un seul endroit où il faut cocher la « bonne option » :
Ensuite après avoir lancé DBBrowser for sqlite, ouvrer le fichier de base de données todo.db
Vous avez ensuite l’option de parcourir les données pour constater que tout les données sont bien présentes:
Nous pouvons faire beaucoup de manipulation avec cet outil mais ce n’est pas un TP de base de données. La base de données sqlite est une base de données très simple et assez répandue. Vous trouverez par exemple en ouvrant le fichier Main.db dans le jeu vidéo Blood Bowl que l’on peut ouvrir la base de données des équipes:
Il ne s’agit bien sur que d’un travail de rétro ingenieuring pour comprendre le fonctionnement du jeu, mais quelque part dans ces données, il y a un endroit qui stocke le nombre de pièce d’or des équipes. 😉
Plus concrètement, vérifier que votre application peut ajouter des Todos dans la base de données et que vous pouvez recharger la liste des Todos depuis cette dernière. Actuellement, nous allons charger les todos à chaque appel sur le controleur. Il existe un mécanisme pour faire perdurer les données entre les multiples appel mais pour simplifier et pour être plus proche des techniques que l’on trouve en php/python/ASP, nous allons simplifier en rechargeant à chaque fois les données.
Maintenant le gros point de notre développement, il faut ensuite faire évoluer votre application en intégrant un identifiant numérique id produit automatiquement par la base de données.
Il faut ajouter une nouvelle propriété à notre classe Todo de type int.
Normalement, le DAOManager a créer une colonne auto incrémentée pour les Todos. La base de données génère donc l’information unique du numéro de Todo. Cette information est à retrouver avec une séries d’instructions qui commencent par un appel à la méthode getGeneratedKeys:
ResultSet rs = preparedStatment.getGeneratedKeys();
if (rs.next()) {
autoGeneratedIdFromDatabase = rs.getInt(1);
todo.setId( autoGeneratedIdFromDatabase );
} else {
logger.error( String.format("Error exception %s ", ex.getMessage() ) );
}
Une fois le todo disposant de son Id il peut être inséré dans la liste des Todos du singleton Application.
Enfin, il faut bien sur recoder l’ensemble de l’application pour exploiter cet id dans la parti HTML et donc dans le Controleur avec mise à jours et effacer le ou les Todos.
Attention : nous utilisons « Eclipse IDE for Java EE Developers » pas une autre version d’Eclipse, si vous avez une autre installation d’Eclipse elle peut ne pas contenir ce que nous avons besoin. NOTA: Windows 7/8/10 contrôle de manière très précautionneuse les fichiers se trouvant dans les dossiers Programmes, Program Files (x86), Windows et tout dossier à la racine du disque C. Il est préférable d’avoir un dossier Developpement à la racine du disque dur dans lequel on place les outils de développement.
