le développement d'une application Web de type CRUD proposé par Mr Nokrou Ibrahim

Bonjour ,
Dans ce Billet Mr Nokrou Ibrahim propose dans le TP n°3 sur JSF 2.0 le développement d'une application Web de type CRUD constitué par la réunion de billets (Un blog ou blogue) , afin d'appliquer les différents concepts du Framework JSF 2.0 déjà introduit lors de la dernier séance .
Ci joint l'énoncer du TP N° 3 sur JSF 2 ,
Travail demander : vous essayer de proposer une solution individuel ,pour que ça soit plus bénéfique ,
 le 18/12/2010 on proposera une solution collectif , noté bien que vous pouvez utilisée des bibliothèques additionnelle comme PrimeFaces 2.0 (pour ajouter un éditeur de texte par exemple ).
NB:  .Un grand merci à notre coordinateur.
       . Pour tous supplément d'information contactez : nokrou_ibrahim@hotmail.fr

       .

SOA : Architecture Logique

Check out this SlideShare Presentation:

SOA : Architecture Logique

View more documents from Zubin67.

Les méta-annotations standards

Résume
Ce billet à pour but d'expliquer ce que c'est que les méta-annotations; ce sont des annotation appliqué au annotation lors de la définition;bien que  Java SE5 propose quatre annotations dédiées aux types d'annotations.
Il existe trois types d'annotations :
Jusqu’ici, nous nous sommes préoccupés que par :
• Des marqueurs (markers) : ces annotations ne possèdent pas d'attribut.
Rappel :@Override, @Deprecated ,@SuppressWarning et @Generated dans j’ai pas parlé la dernier fois car, elle a était intégré dans Java 6 .
Ces quatre annotations sont dites Built-In annotation, car ils sont prédéfinis dans la JDK.
Bien qu’il existe d’autres types d’annotations :
• Les annotations simples (single value annotations) : ces annotations ne possèdent qu'un seul attribut.
• Les annotations complètes (full annotations) : ces annotations possèdent plusieurs attributs.
Les utilisations des annotations concernent plusieurs fonctionnalités :
• Utilisation par le compilateur pour détecter des erreurs ou ignorer des avertissements, c’est ce qu’on a vu jusqu'à présent avec les annotations Buit-in.
• Documentation
• Génération de code (Jusqu'à Java 6 que nous allons voir sur le Billet Amélioration apporter à l’annotation)
• Génération de fichiers (Jusqu'à Java 6 que nous allons voir sur le Billet Amélioration apporter à l’annotation)


Exemple d’utilisation :
Supposons que je veux créer mes propres annotations et les exploitées :
• pendant l’exécution du code lui-même.
• par d’autres outils qui viendront exploiter soit les fichiers sources (.java), soit les fichiers de byte codes (.class) ;
Je préfère commencer par un simple exemple dans lequel je veux crée une annotation @Copyright qui sera afficher dans mon fichier (.class), pour dire que je suis le propriétaire de cette classe et après donné une explication des différents Méta-annotation , et faire l’appel de cette annotation sur le type Class.


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.CLASS)// l’annotation sera conservée dans les fichiers .class
@Target(ElementType.TYPE)// déclarations de type class


public @interface Copyright {


String value();//dans le cas ou on un seul attribut value est l’attribut par défaut.
//attention à ne pas la confondre avec une méthode c’est un attribut.
//vers la fin de ce Billet on verra comment faire l’appel de cette annotation dans une //classe est qui si on vérifie au niveau du fichier (.class) on trouvera la valeur de //l’appel qu’on a spécifié au niveau de @Retention.


}


Explication des différents Méta-annotation :


Il est possible d’annoter une annotation lors de sa définition, On parle alors de méta-annotations, La version Java 5 propose quatre annotations dédiées aux types d'annotations :
L'annotation :
@Target : Spécifie à quelles entités il sera possible de l’appliquer


ElementType.ANNOTATION_TYPE annotations
ElementType.CONSTRUCTOR constructeurs
ElementType.FIELD champs
ElementType.LOCAL_VARIABLE variables locales
ElementType.METHOD méthodes
ElementType.PACKAGE package
ElementType.PARAMETER paramètres d’une méthode ou d’un constructeur
ElementType.TYPE déclarations de type (class, inteface ou énumération)


L'annotation :
@Retention "durée de vie",


RetentionPolicy.SOURCE L’annotation ne sera conservée que dans les fichiers sources. Elle ne pourra donc plus être exploitée lors de l’exécution (par introspection, notamment). Elle restera toutefois exploitable par des outils d’analyse de fichiers sources.


RetentionPolicy.CLASS L’annotation sera conservée dans les fichiers .class, (en plus des fichiers sources) mais ne sera pas accessible à la machine virtuelle.
L’instrospection ne sera pas possible. L’annotation pourra cependant être exploitée par des outils qui travaillent directement sur des fichiers .class.
Il s’agit de la durée de vie par défaut (c’est-à-dire lorsque aucune méta-annotation @Retention ne figure devant la définition de l’annotation.


RetentionPolicy.RUNTIME L’annotation sera conservée dans les fichiers .class, (en plus des fichiers sources) et sera accessible à la machine virtuelle. L’instrospection sera possible.
L'annotation :


@Documented : Marquer les annotations que vous souhaitent voir prises en compte dans un outil de documentation automatique de code.


L'annotation :
@Inherited : prévoir, lors de sa définition, qu’une annotation sera héritée.


Appel de l’annotation sur une classe :
@Copyright("2010 Naoufal Ben Bouazza")
En bas de l’annotation la classe sur la quelle elle sera appliquée.
Remarque : Dans Java SE 6, la prise en compte des annotations est intégrée dans le compilateur : ceci permet un traitement à la compilation des annotations sans avoir un recours à un outil tiers comme apt.

Les Annotations en (Java SE version 6, alias Mustang)

Motivation
Les annotations s'impose aujourd'hui comme une alternative pour la configuration des fichiers XML.
Nous regarderons d’abord le principe de base des annotations (Java SE version 5, alias Tiger) propose seulement trois annotations, puis les améliorations apportées aux annotations en (Java SE version 6, alias Mustang), puis si possible celles des librairies facilitant la manipulation du XML.
Avec Java SE 6, on en voit arriver d’autres dans les packages javax.annotation ou javax.xml.bind.annotation. Mais ce sont surtout les frameworks et autres Standards qui font la part belle aux annotations : Hibernate, JPA, JDO, Spring, Guice, Java EE6... Le plus souvent il s'agit de remplacer de longs fichiers de description en XML par les annotations .
Bien que mon but reste de traiter les annotations dans JUnit 4.x.  dans les tests unitaires.




Présentation
Dans cette premier partie nous allons nous pencher sur une fonctionnalité qui ont été rajoutée depuis (Java SE version 5, alias Tiger) qui a été l'introduction des annotations ( marqueurs ) donc permet de marquer certain élément du langage Java qui sont ensuite utilisé à la compilation ou à l'exécution afin d'automatiser certains tâches.


Les annotations Java peuvent être ajoutées aux:
 Classes.
 Méthodes.
 Attributs.
 Paramètres.
 Variables locales .
 Paquets(package).


Syntaxe


Déclaration:
la déclaration d'une annotation se fait au moyenne d'une interface, mis à part le symbole @ devant le mot-clef interface qui permet de spécifier qu'il s'agit d'une interface :


public @interface MyAnnotation {




}


Utilisation:
Puisque les annotation sont un type du langage Java ,elles peuvent être utilisée sur plusieurs type d'éléments tel que j'ai mentionné en haut .Plusieurs annotations différentes peuvent être utilisées sur un même élément mais on ne peut pas utiliser deux fois la même annotation. En général l'annotation est placée devant la déclaration de l'élément qu'elle marque :
/*Annotation utilisé sur le type class */
@MyAnnotation


public class MyClass {


/* ... */


}
Les Annotations standards ( (Java SE version 5, alias Tiger) propose seulement trois annotations)

L'annotation @Override (ne peut être utilisée que sur une méthode. )

public class Entreprise {

@Override public String toString() {


return ....
}
...
}

 Cette annotation indique que la méthode est la redéfinition d'une méthode définie dans une super classe.

Elle permet, par exemple, de se prémunir contre les fautes de frappe: si vous définissez la méthode toStrinh à la place de toString par exemple, une erreur de compilation signalera que la méthode marquée par @Override n'est pas définie dans la super classe.
 
L'annotation @Deprecated(remplace le tag javadoc. )
public class Entreprise {

@Deprecated public String vieilleMethode {


return ....


}


...


}

Cette annotation remplace le tag javadoc pour signaler qu'une méthode n'est conservé que pour assurer la compatibilité avec la version précédente, et que cette méthode ne doit plus être utilisée.
L'annotation @SuppressWarnings (contient la liste des warnings à masquer.)
 

public class Entreprise {




@SuppressWarnings({"unchecked"}) public String méthode() {


List list = new ArrayList();


list.add("Warning avec le JDK 1.5.0");


}


...


}

Les nouveauté du JDK 1.5.0 peuvent provoquer l'affichage de warning, alors que le code compilait sans warning dans la version précédente. Pour pouvoir supprimer ces warning, vous pouvez ajouter l'annotation @SuppressWarnings devant la méthode concernée.
Remarquez que si vous ajoutez @SuppressWarnings pour supprimer un warning sur une classe, et que vous en ajoutez un autre pour un autre warnings sur une méthode, les deux warnings seront supprimées de la méthode lors de la compilation.


Attention, les noms des warnings ne sont pas standardisés entre les compilateurs Java.
Créer ces propres annotations
 Les annotation sont compilées par le compilateur Java et les valeurs sont stockées dans le fichier .class. Une annotation est un objet Java qui peut être accédée par la machine virtuelle (l'application Java) ou un autre programme ( la commande apt du JDK 1.5.0 ).
On peut créer une annotation très simple, permettant de marquer les classes Java dont les objets sont persistants, etc ...

Lien utile:
JSR-175 : http://www.jcp.org/en/jsr/detail?id=175

RÔLE DES TESTS

Le rôle des tests est multiple. En effet, aujourd’hui le logiciel est partout et remplit des missions très variées : gestion des paies, gestion du personnel et des clients par les systèmes d’informations des entreprises, contrôle des centrales nucléaires, aide au pilotage des avions civils et militaires, amélioration de fonctionnement des appareils ménagers, services offerts sur les téléphones portables, etc. « Il y a plus d’informatique dans la Volvo S80 que dans le chasseur F15 » déclarait en janvier 2000 Denis Griot responsable de l’électronique automobile chez Motorola.
On ne sait pas, par construction, fabriquer des logiciels sans défaut : l’homme commet des erreurs et aucun programme ne peut générer de façon sûre un autre programme ou vérifier qu’un programme fait exactement ce pour quoi il est fait. En effet, les limites théoriques montrent qu’il est impossible dans le cas général, de construire un algorithme permettant de dire si:

• étant donnés deux programmes P et P’qu’ils font la même chose.

• étant donné un programme P et un entier n, permette de dire que P ne va pas boucler indéfiniment sur l’entrée n.
• qu’étant donné un programme P et une fonction f de N dans N, il soit capable de dire si P calcule effectivement f.

 (il s’agit d’un problème de décidabilite). . Si tel était le cas, et si l’on notait Stop ce programme et Stop(P), le résultat de l’analyse de la terminaison d’un programme P par Stop, on pourrait construire un programme B contenant l’instruction « si Stop(B) alors rentrer dans une boucle sans fin, sinon arrêter ». Ce programme B mettrait en défaut systématiquement ce programme oracle Stop.
Devant ce constat d’impossibilité, différentes approches sont possibles :
1. se limiter à construire des programmes très simples que l’on sait analyser de façon certaine, mais qui ne pourront résoudre que des problèmes limités ;
2. construire des programmes complexes dont on ne pourra prédire de façon exacte le comportement, mais qui permettront dans la plupart des cas de résoudre des problèmes ambitieux.

Le rôle des tests pour assurer la qualité logiciel

Dans ce billet je vais tenter d'expliquer le rôle que joue les tests pour assurer la qualité logiciel, à l'aide des tests on peut mesurer la qualité en termes de défauts trouvés, pour des caractéristiques et exigences tant fonctionnelles que non-fonctionnelles (par exemple : fiabilité, utilisabilité, rentabilité et maintenabilité).
Les tests peuvent augmenter le niveau de confiance en la qualité d’un logiciel s’ils trouvent peu ou pas de défauts. Un test conçu correctement et qui est exécuté sans erreur réduit le niveau de risque général du système. Quand les tests trouvent des défauts, la qualité du système logiciel s’accroît quand ces défauts sont corrigés.
d'où l'intérêt des tests, je vais essayer dans les billets qui vient de couvrir :

1.     Notions de modèle vs. cycle de vie d’un logiciel

2.     Les cycles de vie du logiciel :

2.1.    Les modèles séquentiels

2.1.1.   Le modèle en « cascade »

2.1.2.   Le modèle « d’intégration »

2.1.3.   Le modèle en « V »

2.1.4.   Le modèle RAD

2.2.    Le cycle de vie « itératif »

2.2.1.   Le modèle incrémental

2.2.2.   Le modèle en « Spirale de Boehm »

2.2.3.   Le modèle UP

2.2.4.   Le modèle RUP

2.2.5.   Le modèle EUP

2.2.6.   Le modèle 2TUP

2.3.    La méthode « Agile »

2.3.1.   Le modèle « ASD »

2.3.2.   Le modèle « DSDM »

2.3.3.   Le modèle « FDD »

2.3.4.   Le modèle « Crystal »

2.3.5.   Le modèle « SCRUM »

2.3.6. Le modèle XP

3.       Les différents niveaux de tests

3.1.    Les tests unitaires

3.2.    Les tests d’intégration

3.3.    Les tests du système complet

3.4.    Les tests d’acceptation

4.       Les différentes natures de tests

4.1.    Les tests fonctionnels

4.2.    Les tests de compatibilité de plate-forme

4.3.    Les tests de robustesse

4.4.    Les tests de performance

4.5.    Les tests de montée en charge

4.6.    Les tests d’ergonomie

5.     ressource

 

N'hésitez pas à nous faire part de votre avis .