M1 informatique Module Génie Logiciel

Transcription

1 M1 informatique Module Génie Logiciel CM5 : Design Patterns (DP), automatisation et IC Céline ROUDET Celine.Roudet@u-bourgogne.fr

2 Motivations des DP et bonnes pratiques Bonne conception, program. : Extensibilité, Flexibilité Maintenabilité, Réutilisabilité Pour cela : diminuer le couplage augmenter la cohésion du code et créer des interfaces segmenter interfaces et code par responsabilité métier (packages) limiter l héritage (pas plus de 5 niveaux, sinon trop complexe) dans le code : séparer les traitements, limiter leur nb de lignes (pas + de 100) limiter les imbrications multiples de boucles et conditions,... 2

3 Motivations des DP Évoluer par ajout vs évoluer par modification : plusieurs implémentations différentes usage des interfaces, favoriser composition plutôt qu'héritage permet d'anticiper les évolutions du programme Indépendance fonctionnelle (wikipedia) : métrique la + importante en architecture logicielle : évaluée par le rapport cohésion / couplage autonomie et possibilité de réutilisation d'1 composant logiciel donne des indicateurs sur : possibilité d'extraction d'1 composant se trouvant dans 1 logiciel existant sa simplicité d'intégration dans 1 autre logiciel 3

4 Couplage fort : exemple Ex. d'un chien à qui on donne des croquettes. En début de mois c'est du Royal Kanin et en fin de mois du Lidol. public class Chien() { private Croquettes bouffe; public Chien() { // les deux éléments implémentent l'interface Croquettes if debutmois { bouffe = new RoyalKanin(); } else { bouffe = new BouffeLidol(); } } } Que se passe-t-il si on veut donner du Frolik ou si Lidol fait faillite? On doit retoucher la classe Chien qui dépend de l'implémentation des Croquettes. Il y a un fort couplage. 4

5 Couplage : métrique (wikipedia) Niveau d'interaction entre 2 ou plusieurs composants logiciels (fonctions, modules, objets ou applications) 2 composants sont dits couplés s'ils échangent de l'information bonne architecture logicielle = couplage le plus faible possible Inconvénients d'un couplage fort : génère l'antipattern «plat de spaghetti» : on ne peut pas déterminer le qui, quoi et le comment d 1 modification de données implique nécessairement 1 faible indépendance fonctionnelle : composant logiciel difficilement réutilisable et testable risque d'interblocage (si 2 tâches accèdent par couplage fort à 1 ressource commune) difficile de remplacer 1 composant par 1 autre (structures peu souples et peu ouvertes) : il perd son autonomie 5

6 Couplage fort : solution par injection de dépendance Solution : la classe Chien n'utilise que l'interface. Le choix de l'implémentation étant donnée au composant appelant : public class Chien { private Croquettes bouffe; public Chien() {} public setcroquettes(croquettes croquettes) { bouffe = croquettes; } } public class Maitre { private Chien medor; public Maitre() { pas de couplage entre le Chien et les Croquettes C'est Maitre qui décide comment nourrir son chien injection de dépendance dans la classe Chien medor = new Chien(); } public void nourritchiendebutmois() { medor.setcroquettes(new RoyalKanin()); } public void nourritchienfinmois() { medor.setcroquettes(new BouffeLidol()); } } 6

7 Inversion de dépendance Un objet de type A dépend d'un objet de type B si : A possède 1 attribut de type B (dépendance par composition) ; A est de type B (dépendance par héritage) ; A dépend d'1 autre objet de type C qui dépend d'1 objet de type B (dépendance par transitivité) ; une méthode de A appelle une méthode de B. Pour inverser la dépendance, un moyen possible consiste à : créer une interface I qui contiendra toutes les méthodes que A peut appeler sur B (méthodes de B), indiquer que B implémente l'interface I, A remplacer toutes les références au type B par des références à l'interface I dans A. B 7

8 Cohésion (wikipedia) Module cohérent : a ses éléments étroitement liés et effectuant un nb réduit d'opérations Module peu cohérent : difficile à comprendre, à réutiliser et à maintenir fragile, puisqu'affecté par les modifications apportées aux autres modules Métrique mesurant le respect des principes : d'encapsulation des données, de masquage de l'information (cacher les détails d'implémentation pour offrir 1 interface simple à comprendre et à utiliser), et d'utilisation de patrons de conception reconnus (créer des interfaces dont l'ordre des appels est normalisé). 8

9 Principe et intérêt des interfaces en Java Interface : forme de contrat (ens. de services rendus) Classes qui l implémentent : ont un paradigme commun doivent respecter ce contrat (s'y plier) Bonnes pratiques : Référencer des interfaces plutôt que des implémentations (classes) : pour pouvoir rapidement changer de stratégie et réduire l'impact des changements Interchangeabilité des implémentations selon le contexte DP Strategy : interchangeabilité d'1 classe implémentant 1 comportement à l'exécution 9

10 Intérêt des interfaces : exemple Program TestProgram public class Appli { private Program pg;? RealProgram // Program est une interface public static void main(string[] args){ Integer context; if(args!= null && args.length > 0){ context = Integer.parseInt(args[0]); // récupère le 1er paramètre switch(context){ case 0 // stratégie de test L'implémentation est pg = new TestProgram(); pg.execute(); définie à l'exécution : break; mode test ou release case 1 // exécuter le traitement prévu pg = new RealProgram(); pg.execute(); break; } } } } public interface Program { void execute(); } TestProgram et RealProgram implémentent Program et répondent au contrat défini 10

11 Packages Java : principes Ens. de dossier et sous-dossiers contenant 1 ou plusieurs classes src main java : Java source path test java : Java source path target classes : default output folder But : gagner en lisibilité, classes plus faciles à transporter Nom soumis à 1 convention de nommage (ex : fr.univ.tp) Entièrement écrit en minuscule Arborescence «fr/univ/tp» créée dans tous les dossiers Classes déclarées «public» visibles depuis l extérieur du package qui les contient 1ère instruction d 1 classe contenue dans 1 package : package fr.univ.tp; 11

12 CM5 : DP, automatisation et IC 1- Design Patterns Introduction, intérêt et classification Quelques DP de construction Quelques DP de structuration Quelques DP de comportement Autres DP et anti-patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins 12

13 Réutilisation Constante de la conception d outils en général nécessité pratique depuis qu'il y a des outils et qu'ils évoluent En informatique : réutilisation de tout ce qui a été mis en place : codage, réseaux, normes, principes,... réutilisation de code : sous la forme de composants (à acheter / fabriquer) sous la forme de frameworks (à utiliser en les spécialisant) réutilisation de principes de conception (à connaître) Dès que des principes se révèlent pertinents abstraction / réutilisation / normalisation 13

14 Généralités sur les patterns Pattern : solution classique à 1 problème de conception fréquent, dans 1 contexte particulier Pattern de conception : solution générique, applicable à 1 problème récurrent dans la conception d 1 programme (POO) structure et comportement d 1 société de classes description nommée d 1 problème et d 1 solution éprouvée avec conseils d application (expérience de programmeurs) Ils visent tous à : renforcer la cohésion et diminuer le couplage structurer son code et partager 1 approche commune 14

15 Généralités sur les patterns (2) Les patrons sont : des solutions éprouvées à des problèmes récurrents spécifiques au domaine d utilisation une forme littéraire pour documenter des pratiques un vocabulaire partagé pour discuter de problèmes un moyen efficace de réutiliser et partager de l expérience basés sur les bonnes pratiques de la POO Les patrons ne sont pas : limités au domaine informatique, restreint à 1 langage des idées nouvelles, 1 technologie des solutions qui n ont fonctionné qu une seule fois des principes abstraits ou des heuristiques une formalisation (tel qu'un algorithme) 15

16 Généralités sur les patterns (3) Origine dans l architecture (C. Alexander ) Propriétés : Pragmatisme : solutions existantes et éprouvées Générativité : comment et quand appliquer, indépendance au langage de programmation Émergence : la solution globale émerge de l application d un ensemble de patrons Éléments d'un patron : Nom (1 ou 2 mots) : évocateur, concis Problème : comment il survient, points bloquants que le patron cherche à résoudre Description abstraite de la solution, exemple d'utilisation Discussion : conseils sur la façon de l'appliquer, variantes, 16

17 Design Patterns en bref Objectifs : éviter les erreurs classiques de conception, limiter la complexité du code,... Catégories de Design Patterns : 1) modèles de création : politique de création des instances d objets (déléguée à 1 classe particulière) ex : Singleton, Factory, Builder, 2) modèles de structuration : concevoir ses classes pour qu elles assument 1 rôle particulier ex : Adapter, Proxy, Decorator, Composite, 3) modèles de comportement : comment les classes communiquent / se répartissent les responsabilités ex : State, Strategy, Observer, Template Method, 17

18 CM5 : DP, automatisation et IC 1- Design Patterns Introduction, intérêt et classification Quelques DP de construction Quelques DP de structuration Quelques DP de comportement Autres DP et anti-patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins 18

19 Patterns de construction Abstraire les mécanismes de création d'objets Le système les utilisant devient indépendant : de la façon dont les objets sont créés, des mécanismes d'instanciation des classes concrètes. Ces patterns : encapsulent l'utilisation des classes concrètes favorisent l'utilisation des interfaces dans les relations entre objets augmentent les capacités d abstraction dans la conception globale du système Ex : pattern Singleton construire 1 classe possédant au max. 1 instance mécanisme d'accès unique à cette seule instance : encapsulé dans la classe (transparent pour les clients de cette classe) 19

20 Intérêt des patterns de construction Dans certains cas, nécessité de paramétrer la création d'objets : public Document construitdoc (String typedoc) Document resultat; if (typedoc.equals(«pdf»)) resultat = new DocumentPDF(); else if (typedoc.equals(«rtf»)) resultat = new DocumentRTF(); chaque changement dans la hiérarchie des classes à instancier demande des modifications dans le code des clients else if (typedoc.equals(«html»)) resultat = new DocumentHTML(); //suite de la méthode } difficile de paramétrer le mécanisme de création d'objets difficulté encore plus grande pour des objets composés, dont les composants sont instanciés à partir de classes différentes le client doit connaître toutes les classes possibles des composants et des composés 20

21 Pattern Factory Method Interface proposant des méthodes de création d objets, dont le détail est délégué aux implémentations introduit 1 méthode abstraite de création d'1 objet en reportant aux sous-classes concrètes la création effective Problème : comment permettre à 1 client de créer des objets conformes à 1 interface ou 1 classe abstraite, sans savoir quelle classe instancier? abstraite 21

22 Pattern Factory Method : ex. des documents Ex. : 1 application veut manipuler des documents, qui répondent à une interface Document - 1 classe Client ayant une méthode créercommande et une autre méthode pour payer comptant ou à crédit - 1 équipe veut gérer des tactiques... 22

23 Pattern Abstract Factory Création d'objets regroupés en familles sans devoir connaître les classes concrètes destinées à la création de ces objets Domaine d'utilisation : 1 système utilisant des produits a besoin d'être indépendant de la façon dont ces produits sont créés et regroupés 1 système est paramétré par plusieurs familles de produits qui peuvent évoluer La classe Client utilise 1 instance de l'une des fabriques concrètes pour créer ses produits au travers de l'interface FabriqueAbstraite Ex. : fabrique abstraite d'éléments d'ihm en Java Source : 23

24 Source : 24

25 Abstract Factory : exemple Produits concrets A1 et A2 Fabrique abstraite en fonction de l'os, créer la fabrique créerproduit Fabriques concrètes Produit abstrait A Source : 25

26 Pattern Singleton S'assurer qu'1 classe ne possède qu'1 seule instance au sein de l'appli. Fournir 1 méthode unique retournant cette instance (pt d'accès global) utilisé pour la connexion à une BD et l'accès aux données, pour récupérer des infos et les partager à tout le monde... public class DataAccess { private static DataAccess _instance = null; public static DataAccess getinstance() { Méthode de classe if(_instance == null) _instance = new DataAccess(); return _instance; Renvoie la seule instance de la classe } private DataAccess(){...} Constructeur privé ou protégé } 26

27 Pattern Singleton : UML A utiliser à la place des variables globales (plus puissant) 1 Client peut obtenir 1 réf. à ClasseSingleton avec le code : ClasseSingleton c = ClasseSingleton.getInstance(); c.getsingletondata();... Il ne peut accéder à l'instance qu'à travers la méthode spécifique : accès contrôlé 27

28 Pattern Prototype Création de nouveaux objets par duplication d'objets existants appelés prototypes, qui disposent de la capacité de clonage préparer 1 instance d'objet à l'avance et en retourner 1 copie à chaque demande (plus rapide) s'utilise avec le pattern Singleton Le Client demande à 1 ou plusieurs Prototypes de se dupliquer eux-mêmes Source : 28

29 Pattern Builder Abstraire la construction d'objets complexes de leur implantation pour qu'1 client puisse créer ces objets sans se préoccuper des différentes implantations principe de segmenter un processus de création complexe en traitements unitaires, pouvant servir dans différents contextes Source : 29

30 Pattern Builder : exemple Appel du constructeur de la pizza Implantées dans les sous-classes Source : Création de la pizza en plusieurs parties 30

31 Pattern Builder : exemple Classe abstraite pour la rendre concrète et récupérer la pizza Source : 31

32 CM5 : DP, automatisation et IC 1- Design Patterns Introduction, intérêt et classification Quelques DP de construction Quelques DP de structuration Quelques DP de comportement Autres DP et anti-patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins 32

33 Patterns de structuration Indépendance de l'interface d'1 objet ou d'1 ens. d'objets vis-à-vis de son implantation mise en avant des interfaces les rendre indépendantes de la hiérarchie des classes et de la composition des objets encapsulation de la composition des objets (augmente le niveau d'abstraction du système) transférer la structuration de l'objet à un 2nd objet (intimement lié au 1er) le 1er objet détient l'interface vis-à-vis des clients et gère la relation avec le 2nd objet le 2nd gère la composition et n'a aucune interface avec les clients souplesse de la composition qui peut être modifiée dynamiquement Séparation des classes alors qu'on aurait tendance à tout mettre dans une seule! 33

34 Composition statique Héritage d'1 interface : plusieurs implantations possibles différenciées dans les sous-classes Une fois que le choix de la classe d'implantation d'un objet est effectuée, il n'est plus possible d'en changer Interface +operation() ImplantationA ImplantationB +operation() #operationimp() +operation() #operationimp() operationimp();... 34

35 Composition dynamique : pattern Bridge Autre solution : séparer l'aspect d'implantation dans 1 autre objet Parties d'implantation gérées par : 1 instance de la classe ImplantationConcrèteA ou 1 instance de la classe ImplantationConcrèteB cette instance est référencée par l'attribut implantation et peut être substituée facilement par 1 autre instance lors de l'exécution présente aussi l'avantage d'encapsuler la partie d'implantation qui devient transparente pour les clients Pattern Bridge : séparer l'aspect d'implantation d'1 objet de son aspect de représentation et d'interface implantation totalement encapsulée implantation et représentation peuvent évoluer indépendamment et sans que l'un exerce 1 contrainte sur l'autre 35

36 Composition dynamique : pattern Bridge Interface ou classe abstraite +operation() Réalisation +operation() implantation. operationimpl()... 1 #implantation Implantation +operationimp() ImplantationConcreteA #operationimp() ImplantationConcreteB #operationimp() 36

37 Source : wiki/objet_composite Pattern Composite Conception d'1 composition d'objets dont la profondeur est variable (conception basée sur 1 arbre) cette composition est encapsulée vis-à-vis des clients des objets qui peuvent interagir sans devoir connaître la profondeur de la composition les clients envoient leurs requêtes aux composants au travers de l'interface lorsqu'1 composant reçoit 1 requête, il réagit en fonction de sa classe Client #composants for (Composant c:composants) c.operation(); 37

38 Pattern Composite : exemple On pourrait l'étendre en y ajoutant d'autres formes (rectangle...) et méthodes (translation...) Source : wiki/objet_composite classe graphique (qu'on peut imprimer) et qui peut être 1 ellipse ou 1 composition de différents graphiques les composants 38

39 Pattern Composite : exemple (2) 39

40 Pattern Decorator Ajouter dynamiquement de nouvelles fonctionnalités à 1 objet Classe en charge d'ajouter des fonctionnalités à 1 autre sans utiliser de technique d'héritage Source : 40

41 Pattern Decorator : UML ComposantAbstrait Client +operation() 1 #composant Decorateur ComposantConcret +operation() +operation() composant.operation(); DecorateurConcretA DecorateurConcretB +operation() +operation() +autreoperation() super.operation(); autreoperation(); 41

42 Les autres patterns de structuration Adapter : convertit l'interface d'1 classe existante en l'interface attendue par des clients, afin qu'ils puissent travailler ensemble classe ou interface créée dans le but d'utiliser 1 élément ou 1 librairie non compatible avec votre architecture (ex : transformateur de courant) résoudre 1 problème d incompatibilité d interfaces (API) Façade : regroupe les interfaces d'1 ens. d'objets en 1 interface unifiée rendant cet ensemble plus simple à utiliser interface simple exposant des fonctionnalités d'1 sous-système complexe Proxy : construit 1 objet qui se substitue à 1 autre objet et qui contrôle son accès objet encapsulant 1 autre objet de façon à en modifier le comportement initialement prévu ex. : résoudre 1 problème d accès à 1 objet à travers 1 réseau Flyweight, Bridge 42

43 CM5 : DP, automatisation et IC 1- Design Patterns Introduction, intérêt et classification Quelques DP de construction Quelques DP de structuration Quelques DP de comportement Autres DP et anti-patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins 43

44 Pattern Strategy Utile lorsqu'on souhaite permuter dynamiquement les algorithmes utilisés dans une application Adapte le comportement et les algorithmes d'1 objet en fonction d'1 besoin, sans changer les interactions avec les clients de cet objet Utilisation : dès lors qu'un objet peut effectuer plusieurs traitements différents, dépendant d'une variable ou d'un état. ce besoin peut relever d'aspects de présentation, d'efficacité en temps, en mémoire, de choix d'algos, de représentation interne... Ex. : on veut créer un outil de compression de fichiers gérant divers algos de compression (ZIP, RAR, ) au choix de l'utilisateur. Utilisé par Swing pour associer un algo de mise en page (layout : encapsulé dans une classe) à un conteneur graphique. 44

45 Pattern Strategy : exemple

46 Pattern State Permet à 1 objet d'adapter son comportement en fonction de son état interne Se rapproche du pattern Strategy ex. : 1 classe Commande dont les états des instances sont : EnCours, Validée ou Livrée : modifie le comportement des méthodes plutôt que d'avoir de multiples conditions dans le corps des méthodes pour résoudre ces différences de comportement 46

47 Pattern Template Method c'est la méthode de la classe parente qui appelle des opérations n'existant que dans les sous-classes Méthode socle Délégation d'étapes d'un algorithme Fixe des comportements standards qui devraient être partagés par toutes les sous-classes, même lorsque le détail des sous-opérations diffère Factorise du code qui serait redondant s'il se trouvait répété dans chaque sous-classe ex1 : calcul du montant TTC d'une commande en tenant compte des différentes TVA qu'il peut y avoir en fonction du pays ex2 : classe abstraite java.util.abstractcollection<e> implante l'interface Collection<E> et fournit un squelette d'implantation, sauf pour les méthodes iterator() et size() qui restent abstraites. Cela minimise l'effort demandé pour implanter l'interface Collection<E> 47

48 Être à l'écoute de ses objets : le DP Observer Construit 1 dépendance entre 1 sujet et des observateurs pour que chaque modif. du sujet soit notifiée aux observateurs afin qu'ils puissent mettre à jour leurs états Souvent utilisé pour les IHM (modèle événementiel en Java) Le diffuseur peut enregistrer dynamiquement les souscripteurs intéressés par un événement et le leur signaler Sujet (diffuseur / observable) : souvent 1 classe abstraite Observateur (souscripteur) : interface 48

49 Exemple : horloge digitale en Java import java.awt.*; import javax.swing.*; import Horloge; public class Fenetre extends JFrame{ private JLabel label = new JLabel(); private Horloge horloge; public Fenetre(){ //On initialise la JFrame this.setdefaultcloseoperation( JFrame.EXIT_ON_CLOSE); this.setlocationrelativeto(null); this.setresizable(false); this.setsize(200, 80); //On initialise l'horloge this.horloge = new Horloge(); //On initialise le JLabel this.label.sethorizontalalignment( JLabel.CENTER); //On ajoute le JLabel à la JFrame this.getcontentpane().add(this.label, BorderLayout.CENTER); } //Méthode main() lançant le programme public static void main(string[] args){ Fenetre fen = new Fenetre(); fen.setvisible(true); } } import java.util.calendar; public class Horloge{ //Objet calendrier : récupérer l'heure courante private Calendar cal; private String hour = ""; public void run() { while(true){ //Récupérer l'instance d'1 calendrier pour //avoir l'heure actuelle this.cal = Calendar.getInstance(); this.hour = //Les heures this.cal.get(calendar.hour_of_day) + " : " + ( //Les minutes this.cal.get(calendar.minute) < 10? "0" + this.cal.get(calendar.minute) : this.cal.get(calendar.minute) ) + " : " + ( //Les secondes (this.cal.get(calendar.second)< 10)? "0"+this.cal.get(Calendar.SECOND) : this.cal.get(calendar.second) ); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printstacktrace(); } } } Comment faire communiquer } l'horloge avec la fenêtre? 49

50 Observer : exemple package observer; package observer; public interface Observateur { public void update(string hour); } public interface Observable { public void addobservateur(observateur obs); public void updateobservateur(); public void delobservateur(); } Pb de passer l'instance de JLabel dans l'objet Horloge : couplage mauvais si on veut passer d'une IHM Swing à une IHM Awt (par ex.) package observer package vue Source : package model 50

51 Observer : exemple (2) package model; import java.util.arraylist; import java.util.calendar; import observer.observable; import observer.observateur; public class Horloge implements Observable{ private Calendar cal; private String hour = ""; //Notre collection d'observateurs private ArrayList<Observateur> listobs = new ArrayList<Observateur>(); public void run() { //Avertit les obs. que l'heure a été mise à jour this.updateobservateur(); } //Ajoute un observateur à la liste public void addobservateur(observateur obs) { this.listobs.add(obs); } //Retire tous les observateurs de la liste public void delobservateurs() { this.listobs = new ArrayList<Observateur>(); } //Avertit les obs. que l'obj. observable a changé //et invoque update() de chaque observateur public void updateobservateur() { for(observateur obs : this.listobs) obs.update(this.hour); } } package vue; import java.awt.*; import javax.swing.*; import model.horloge; import observer.observateur; public class Fenetre extends JFrame { private JLabel label = new JLabel(); private Horloge horloge; public Fenetre(){ //On initialise la JFrame //On initialise l'horloge this.horloge = new Horloge(); //On place un écouteur sur l'horloge this.horloge.addobservateur( new Observateur(){ public void update(string hour) { label.settext(hour); } }); //On initialise le JLabel //On ajoute le JLabel à la JFrame this.getcontentpane().add(this.label, BorderLayout.CENTER); this.setvisible(true); this.horloge.run(); } //Méthode main() lançant le programme public static void main(string[] args){ Fenetre fen = new Fenetre(); } } 51

52 Pattern Visitor Construit 1 opération à réaliser sur les éléments d'1 ens. d'objets de nouvelles opérations peuvent ainsi être ajoutées sans modifier les classes de ces objets ex. : panier d'éléments dont on veut calculer le montant total logique de calcul peut être réalisée dans chaque classe élément ici déplacée dans 1 autre classe : ShoppingCartVisitorImpl 52

53 Pattern Visitor : exemple (les éléments) public class Book implements ItemElement{ private int price; private String isbnnumber; public Book(int cost, String isbn){ this.price=cost; this.isbnnumber=isbn; } public int getprice(){ return price; } public String getisbnnumber(){ return isbnnumber; public int accept(shoppingcartvisitor v){ return visitor.visit(this); } } public class Fruit implements ItemElement{ private int priceperkg; private int weight; private String name; public Fruit(int pricekg, int wt, String nm){ this.priceperkg=pricekg; this.weight=wt; this.name = nm; } public int getpriceperkg(){ return priceperkg; } public int getweight(){ return weight; } public String getname(){ return this.name; public int accept(shoppingcartvisitor v){ return visitor.visit(this); } } Source : 53

54 Pattern Visitor : exemple (2) Résultat : } Instanciation des éléments Appel de accept pour chaque élément, qui appelle visit } 54

55 Les autres patterns de comportement Command : transforme 1 requête en 1 objet, facilitant des opérations comme l'annulation, la mise en file des requêtes et leur suivi encapsuler la logique métier d'1 objet derrière 1 interface standardisée décorréler 1 requête de son exécution, déléguant cette exécution à 1 ou plusieurs classes en charge d'1 action unitaire : la commande découper pour que ce soit testable facilement (ex : Ctrl-Z) Interpreter : fournit 1 cadre pour donner 1 représentation par objets de la grammaire d'1 langage afin d'évaluer, en les interprétant, des expressions écrites dans ce langage Iterator : fournit 1 accès séquentiel à 1 collection d'objets sans que les clients se préoccupent de l'implantation de cette collection 55

56 Les autres patterns de comportement (2) Chain of responsability : créé 1 chaîne d'objets telle que si 1 objet de la chaîne ne peut pas répondre à 1 requête, il puisse la transmettre à ses successeurs jusqu'à ce que l'un d'eux y réponde Mediator : construit 1 objet dont la vocation est la gestion et le contrôle des interactions au sein d'1 ens. d'objets sans que ses éléments se connaissent mutuellement réduire le couplage (ils n'interagissent qu'avec le médiateur) facilite l'évolution du protocole de coopération Memento : sauvegarde et restaure l'état d'1 objet conservation de pts de reprise 56

57 Synthèse des 23 patterns du GoF Défauts de conception Patrons concernés Dépendance à la classe concrète de création Fabrique abstraite / Prototype d'un objet Dépendance à une opération particulière Commande / Chaîne de responsabilités Dépendance à un algorithme Monteur / Itérateur / Stratégie / Patron de méthode / Visiteur Dépendance à la représentation d'un objet Fabrique abstraite / Pont / Mémento / Proxy Dépendance à une plate-forme matérielle ou logicielle Fabrique abstraite / Pont Couplage fort entre classes Façade / Médiateur / Observateur / Commande / Chaîne de responsabilités / Pont / Fabrique abstraite Impossibilité de modifier une classe Adaptateur / Décorateur / Visiteur Prolifération des classes en raison de l'ajout de fonctionnalités Composite / Décorateur / Stratégie / Pont / Observateur / Chaîne de responsabilités 57

58 CM5 : DP, automatisation et IC 1- Design Patterns Introduction, intérêt et classification Quelques DP de construction Quelques DP de structuration Quelques DP de comportement Autres DP et anti-patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins 58

59 Autres patterns : catégories Compositions et variations autours des 23 patterns Patrons architecturaux : conception de systèmes, organisation d'une application. Exemples : Architecture en couches, multi-tiers, MV* Inversion of Control (ne pas réimplémenter le code «générique» d une application) Patrons d authentification, d autorisation, de sécurité Idiomes de programmation : techniques, styles spécifiques à un langage Patrons de données, d'analyse, d'organisation Types d architectures et d outils... 59

60 Pattern Couche 60

61 Architecture multi-tiers Objectif : découpler les différentes fonctionnalités d un programme (séparation des préoccupations) Gestion des données, algorithmes métier, présentation... Fonctionnement : concevoir séparément chacune de ces fonctionnalités Les isoler les unes des autres (autant que possible) 61

62 Pattern MVC Problème : comment rendre le modèle (domaine métier) indépendant des vues (interface utilisateur) qui en dépendent? Solution : insérer 1 couche supplémentaire pour la gestion des événements et la synchronisation entre modèle et vue Modèle (logique métier) : implémente le fonctionnement du système gère les accès aux données métier Vue (interface) : présente les données en cohérence avec l'état du modèle capture et transmet les actions de l'utilisateur Contrôleur : gère les changements d'état du modèle informe le modèle des actions utilisateur sélectionne la vue appropriée 62

63 Pattern MVC : différentes versions la vue connaît le modèle ou non le contrôleur connaît la vue ou non le vue connaît le contrôleur ou non «mélange» avec le pattern Observer un ou plusieurs contrôleurs («type 1» / «type 2») Choix d'une solution : dépend des caractéristiques de l'application dépend des autres responsabilités du contrôleur Exemple : MVC Java Swing (les composants graphiques ont un «modèle» associé) de nombreux framework web utilisent MVC 63

64 Version modèle passif la vue se construit à partir du modèle le contrôleur notifie le modèle des changements que l utilisateur spécifie dans la vue le contrôleur informe la vue que le modèle a changé et qu elle doit se reconstruire 64

65 Version modèle actif quand le modèle peut changer indépendamment du contrôleur le modèle informe les abonnés à l observateur qu il s est modifié ceux-ci prennent l information en compte (contrôleur et vues) 65

66 Mixer les patterns MVC et Couche Séparation des responsabilités : Classes modèle (VO) : représentation logique de données métier Classes d accès aux données (DAO) stockées dans 1 BD par ex. Classes en charge d appliquer les règles de gestion métier Classes en charge de la présentation des données à la vue Classes de vue en charge de l affichage Contrôleur : connaissance cœur de l application -gestion des événements -contrôle -synchronisation : cœur de l IHM 66

67 Pattern MVC : architecture web à 3 couches - 3 couches : indépendantes grâce à l'utilisation d'interfaces - l'intégration des différentes couches : réalisée avec Spring Contrôleur (servlet) Couche métier (service) Couche d accès aux données (DAO) 2 Modèle (EJB) Vues (JSP) Données (BD) Utilisateur (navigateur) Couche interface utilisateur (web) SPRING : framework Java 67

68 Pattern MVC : exemple d un blog Image tirée du cours de H. Labas 68

69 Exemple d'un blog où BlogService va 1. Contrôler les droits d accès 2. Vérifier cohérence des données transmises 3. Appliquer les règles de gestion 4. Transmettre les objets vérifiés à la couche DAO 5. Éventuellement combiner différentes données issues de la couche DAO pour fournir un résultat complet Utilisateur authentifier(string login, String password); boolean ecrirebillet(utilisateur auteur, Billet billetecrit); boolean supprimerbillet(billet billetasupprimer); List<Billet> getbilletsaveccommentaires(); boolean ajoutercommentaire(commentaire comm, Billet billetcomm); boolean supprimercommentaire(commentaire commentaire); boolean deconnexion(utilisateur utilisateur); 69

70 Interfaces BilletDAO et CommentaireDAO BilletDAO : boolean ajouterbillet(billet billet); boolean supprimerbillet(integer idbillet); List<Billet> listerbillets(boolean tripardate); CommentaireDAO : boolean ajoutercommentaire(commentaire commentaireainserer); boolean supprimercommentaire(integer idcommentaire); Map< Integer, List<Commentaire> > listercommentaireparbillet(set<integer> idbillets); 70

71 Autres Patterns : GRASP General Responsability Assignment Software Patterns Relèvent du bon sens de conception, sont intuitifs S'appliquent de manière plus générale que les 23 du GoF Patterns généraux d affectation de responsabilités Faible couplage, forte cohésion, polymorphisme Indirection : découpler des classes à l'aide d'1 classe intermédiaire Protection des variations : identifier les points de variation ou d'instabilité prévisibles Expert en information : «celui qui sait fait le travail» Contrôleur : réception et traitement des événements Créateur : responsabilité de créer les instances d'1 classe Fabrication pure : entité fabriquée de toutes pièces Référence : C. Larman

72 Anti-patterns : erreurs courantes de conception Caractérisés par : lenteur du logiciel, coûts de réalisation ou de maintenance élevés, comportements anormaux, présence de bogues. Exemples Action à distance : emploi massif de variables globales, fort couplage Coulée de lave : partie de code encore immature mise en production, forçant la lave à se solidifier en empêchant sa modification... Référence : 72

73 CM5 : DP, automatisation et IC 1- Design Patterns 2- Automatisation en Java avec Ant et Maven - Construction automatique de projets - Exécution d'un script Ant dans Eclipse - Principe de Maven et utilisation 3- Intégration continue avec Jenkins 73

74 Automatisation : pourquoi? Accélérer les tâches répétitives Réduire le risque d erreurs Différentes approches : Scripts : shell / batch, Ant, Grunt.js, Gradle Avantage : aucune limite (on fait ce qu'on veut!) Inconv. : dépendant de l'os, pas de standards, complexe à échanger Métadonnées : Maven, Gradle Avantages : flexible, définit 1 standard / convention organisation du projet (hiérarchie des répertoires) prédéfinie : génération automatique des tâches en s'appuyant sur l'organis. Inconv. : temps d'apprentissage 74

75 Ant : script de build au format XML Caractéristiques : Projet Open Source (Apache Public Licence), simple Référence pour la construction automatique et portable d'applis Java Écrit en Java (multi-plateforme) et intégré dans les principaux IDE Automatisation des opérations répétitives tout au long du cycle de développement logiciel Principes (modèle de la commande make de C) : - déclarer 1 projet (project) composé de «cibles» (target) - cible = enchaînement de tâches unitaires (tasks : compile, jar, javadoc, ftp, junit, cvs, ) - description des cibles, dépendances entre les cibles : décrites dans un fichier de config. XML nommé par défaut «build.xml» - Extensible : on peut ajouter ses propres commandes / tâches (codées sous forme de classes Java) 75

76 Principales tâches Ant - définir une variable : Chemin vers lequel on veut compiler, à utiliser dans le script <property name="chemin" value="c:\temp\build" /> - afficher 1 message sur la sortie : <echo>démarrage...</echo> - définir 1 ens. de fichiers listés à partir d 1 répertoire : <fileset dir="./"> - Inclure tous les fichiers JAR (dans un fileset). Opposé : exclude <include name="**/*.jar" /> - Redéfinir le classpath utilisé par la tâche en cours d exécution : <classpath> - Compiler des fichiers Java en.class : <javac srcdir="./src" destdir="./build" /> - Créer 1 fichier JAR à partir de sources compilées : <jar jarfile="./build/malib.jar" basedir="./build" /> - Opérations sur le système de fichiers : <mkdir> <copy> <delete> 76

77 build.xml : exemple 1 fichier HelloWord.java <project name="hello" default="run"> <target name="clean"> <delete dir="bin"/> <delete dir="exe"/> </target> <target name="compile"> <mkdir dir="bin"/> <javac srcdir="src" destdir="bin"/> </target> projet src.java bin.class exe.jar L exécution de cette cible requiert l exécution de la cible "compile" <target name="jar" depends="compile"> <mkdir dir="exe"/> <jar destfile="exe/helloworld.jar" basedir="bin"> <manifest> <attribute name="main-class" value="helloworld"/> </manifest> </jar> Le fichier manifest contient le </target> nom de la classe principale <target name="run" depends="jar"> <java jar="exe/helloworld.jar" fork="true"/> </target> Exécuter le projet dans une nouvelle machine virtuelle Java </project> 77

78 Améliorations avec les propriétés <project name="hello" default="run" basedir="."> <description> Our HelloWorld build file. </description> <property name="src.dir" value="src"/> <property name="bin.dir" value="bin"/> <property name="jar.dir" value="exe"/> <target name="clean"> <delete dir="${bin.dir}"/> <delete dir="${jar.dir}"/> <echo message="nettoyage termine"/> </target> projet src.java bin.class exe.jar <target name="compile"> <mkdir dir="${bin.dir}"/> <javac srcdir="${src.dir}" destdir="${bin.dir}"/> <echo message="compilation termine"/> </target> </project> 78

79 CM5 : DP, automatisation et IC 1- Design Patterns 2- Automatisation en Java avec Ant et Maven - Construction automatique de projets - Exécution d'un script Ant dans Eclipse - Principe de Maven et utilisation 3- Intégration continue avec Jenkins 79

80 Lancer un script Ant Autres tâches : javadoc, unjar, rmic, war, unwar, ear, Comportement sur erreur : - Généralement, 1 erreur dans une tâche arrête la construction de la cible correspondante, mais certaines tâches ne provoque pas l arrêt - Ajouter l attribut "failonerror" à true pour forcer l arrêt Lancer un script Ant : Taper dans une invite de commande : ant [options] [cible] Ex : ant clean, ant jar / ant run ou ant (la cible par défaut est "run") Pour utiliser un autre fichier que build.xml : ant -buildfile file Options : -projecthelp : affiche la description du projet, si elle existe avec toutes les cibles qui ont une description -Dpropriété=valeur : pour donner une valeur à une propriété 80

81 CM5 : DP, automatisation et IC 1- Design Patterns 2- Automatisation en Java avec Ant et Maven - Construction automatique de projets - Exécution d'un script Ant dans Eclipse - Principe de Maven et utilisation 3- Intégration continue avec Jenkins 81

82 Maven 2 et 3 : outil Open Source de build Automatiser la gestion et la construction de projets Java Pour les projets Java, extensible (nbreux plugins), écrit en Java Utilisé par la majorité des projets d'entreprise Approche déclarative (basée sur le cycle de vie du projet) : le contenu et la structure du projet sont décrits aide à mettre en place les standards de développement réduit le tps nécessaire pour écrire et maintenir les scripts de build (type ant ou make) Propose un cadre standard (approche par métadonnées) organisation des sources, tests unitaires, exécutables description de l'équipe, du référentiel de sources gestion des dépendances et dépendances transitives 82

83 Maven 2 et 3 : se conformer à un cadre Dépasse la simple automatisation de tâches En support d'une gestion d'un projet Gestion de dépendances transitives Déploiement... Possible de redéfinir l'emplacement des répertoires vers 1 localisation spécifique, mais intéressant de respecter la structure standard : rend le «pom» + court et simple, l'intégration de plugins + simple projet + simple à comprendre Inconvénient : plus long à apprendre qu Ant, plus difficile d'accès 83

84 Structure de répertoires 84

85 Maven : comment l'utiliser? pom.xml : descripteur d 1 projet ( <build> : décrit les fonctions relatives à la construction d 1 projet (classpath, version de java...) <profiles> : profils de construction, pour personnaliser la totalité du pom selon des identifiants de profil <dependencies> : liste les dépendances selon 1 format «qualifié» groupid : nom d 1 groupe (en gal le préfixe du package principal) artifactid : nom de la dépendance (en général le nom du projet) version : version du projet type : format (jar, pom...) scope (périmètre/portée de la dépendance) : à la compilation (compile), uniquement à l'exécution (runtime), pendant la compilation et l'exécution des tests (test),... 85

86 pom.xml basique (POM = Project Object Model) cœur d'un projet Maven : description détaillée du projet SNAPSHOT : à 1 moment donné du dévlpt Dépendances : ex. tests unitaires Maven gère les autres dépendances liées à JUnit Placé dans le répertoire de base de votre projet 86

87 Installation de Maven ( Anatomie de l installation bin\ : contient l exécutable mvn conf\ : contient le fichier de configuration settings.xml (utile pour le proxy) Tous les.jar dont on a besoin stockés localement : référentiel local goal install : installer notre projet dans le repository local en suivant la même arborescence Notre projet devient utilisable par les autres 87

88 Config. de l'environnement de projet : settings.xml 88

89 Phases du cycle de vie du projet Utilitaire en ligne de commande, depuis l emplacement du fichier pom.xml : mvn [goal] avec [goal] = (invoquent les plugins nécessaire pour faire le travail) generate-sources : génère le code source supplémentaire nécessité par l'appli (accompli par les plugins appropriés) clean : supprimer les éléments précédemment construits compile : compile le code source du projet test-compile : compile les tests unitaires du projet test : lancer/exécuter les tests unitaires (avec Junit) package : packager le code compilé (un WAR, un JAR) Install : installer le JAR sur le dépôt local deploy : déployer l application sur le serveur cible : pour être partagé avec d'autres développeurs... 89

90 Phase du cycle de vie 90

91 Communication interne de projet Site web technique et centralisé de qualité professionnelle : vision commune d'une équipe Génération du site Maven intégrée dans le processus de build en utilisant l'ic ou les builds nocturnes automatisés Un site Maven peut publier sur une base quotidienne : Des infos générales sur le projet (membres de l'équipe, entrepôt de sources, anomalies, ) Tests unitaires et rapports de couverture des tests unitaires Revues de code automatisés avec Checkstyle ou PMD Infos sur la configuration ou le versionnage Les dépendances, la javadoc Le code source indexé et référençable (format HTML)... 91

92 Travailler avec les plugin Fonctionnalités supplémentaires au processus de build Plugin à lier à une phase du cycle de vie Maven trouve alors quand et comment l'utiliser Certains plugins sont déjà utilisés par Maven, il reste juste à les déclarer dans la section plugins du fichier pom.xml 92

93 Premier projet Maven 2/3 plug-in archetype : créer 1 projet, prêt à démarrer avec une structure de base de projet Maven 2 (mettre rapidement en place l'environnement d'un projet basique) Par défaut, archetype produit un modèle de projet pour une bibliothèque JAR. Il existe de nombreux archétypes réalisés par la communauté, pour d'autres types de projets (Android, applications web, ) On peut créer son propre archétype (sorte de template, utile si on a à utiliser souvent les mêmes choses) Exécutez la commande suivante pour mettre en place votre projet : 93

94 Pratique avec Eclipse (plugin peu stable) 94

95 Pratique avec Eclipse 95

96 Pratique : créer un projet Maven Une nouvelle catégorie apparaît, ainsi que des archétypes 96

97 Pratique : projet Maven On peut ajouter ou MAJ des dépendances 97

98 Pratique : projet Maven 98

99 Pratique : projet Maven 99

100 Résolution de dépendances Si une dépendance n'est pas dans le dépôt central : faire 1 dépôt d'entreprise (intercaler un proxy) 100

101 Proxy Maven 101

102 Proxy Maven : sonatype = proxy nexus Serveur permettant d installer des dépendances personnalisées settings.xml : Pour prendre en charge les plugins, dépendances 102

103 Maven : settings.xml Configuration du miroir pour prendre les dépendances et les plugins 103

104 CM5 : DP, automatisation et IC 1- Design Patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins Principes de l'ic Fonctionnements de base de Hudson/Jenkins Plugins et outils 104

105 Intégration continue (IC) Nom donné initialement par la communauté d'xp pour désigner la pratique de GL visant à accélérer la livraison des logiciels en réduisant le temps d'intégration L'intégration continue est le principe de faire d'un processus d'intégration logiciel un «non-évènement» - Martin Fowler - Objectifs : Définir un processus répétable Automatiser ce processus Principe : que se passe-t-il entre le moment ou vous terminez un développement et le moment où votre application est déployée et disponible pour votre client? 105

106 Principales étapes déclencher un processus de construction, déploiement 106

107 Moyens et outils «A la main» (non recommandé) : Script / Ant Basique : Maven (deploy = déploiement), Gradle Outillé (via 1 IHM) : Hudson, CruiseControl, Jenkins Hudson : ancêtre de Jenkins Jenkins : standard actuel du marché, multi-langages, simple d accès, à installer, à comprendre CruiseControl : moins «user-friendly» que Jenkins, néammoins répandu Continuum : porté par Apache 107

108 Moyens et outils Pour que l'ic puisse se faire correctement, il faut : partager les sources du projet via un serveur de Gestion de Contrôle des Sources (SCM), tel que SVN que les équipes de développement postent (commit) régulièrement les modifs apportées au code (plusieurs fois / jour) disposer de tests unitaires (exécutés par l'outil Junit par ex.) pour vérifier que le code ne subit pas de régression But : vérifier régulièrement les modifs sur le SCM afin d'assurer la non régression de l'appli. en compilant l'ens. du projet et en exécutant les tests Intérêts : - vérification fréquente du code et de sa bonne compilation, - réalisation des tests unitaires et/ou fonctionnels, voire d'intégration, - faire déployer son WAR sur un serveur Tomcat tous les jours, - créer des rapports périodiques exprimant la qualité du code, la couverture des tests, (avec maven par exemple) 108

109 CM5 : DP, automatisation et IC 1- Design Patterns 2- Automatisation en Java avec Ant et Maven 3- Intégration continue avec Jenkins Principes de l'ic Fonctionnements de base de Hudson/Jenkins Plugins et outils 109

110 Jenkins : serveur d'ic Aperçu de la qualité des projets (tableau de bord) Configuration Définir le JDK Installations Ant, Maven, ou relatives aux plugins SMTP pour mail d'avertissement Plugins : correspondent à chaque étape de l'ic Compilation (.NET, Ruby, C++...) Déploiement (FTP, CIFS, ) Notifications (Campfire, Google, Growl, IRC, Jabber...) Stats (Sonar, Selenium : tests fonctionnels pour le web) BugsTracker : lister les bugs sur les projets

111 Jenkins locale : Jobs (1 job / projet ou par module du projet) Définition d un processus d intégration continue unitaire Dashboard de suivi de l historique des exécutions de jobs Consultation de rapports d analyse Démo ( : 111

112 Jenkins : détail d'un job (file d'attente des builds) 112

113 Configurer Hudson Toute la config. (générale ou spécifique à 1 projet) se fait directement depuis l'interface en ligne Config. gale : répertoires d'instal. du JDK, Maven, config. du SCM, gestion de la sécurité,... Utile si on modifie manuellement les fichiers de config. Gestionnaire des plugins Infos. sur la config. système du serveur Exécution de scripts pour l'administration pour préparer l'arrêt de Jenkins, de façon propre A utiliser pour MAJ la version de Jenkins ou pour arrêter le serveur Tomcat. 113

114 Administrer Jenkins 114

115 Panneau de config. système de Hudson/Jenkins Nb max d'exécutions concurrentes que Jenkins peut lancer (nb de compilations simultanées qui peuvent être lancée par le serveur d'ic) Gérer la sécurité sur Jenkins, pour en limiter l'accès : qui peut accéder à la plate-forme, comment, et quels types de manipulations sont autorisés Liste des JDKs installés sur le serveur Liste des versions de Ant/Maven installées sur le serveur 115

116 Gestion des utilisateurs - sécurité Liste des utilisateurs : automatiquement MAJ par Jenkins via les infos récupérées sur le SCM. Si un nouvel utilisateur commit 1 fichier sur le SCM, Jenkins l'ajoutera lors du prochain build parmi la liste des utilisateurs On peut configurer chaque utilisateur pour lui définir mail : pour transmettre par mail les rapports d'échecs de builds Limiter l'accès ou les opérations pour 1 certain types d'utilisateurs Par défaut, non activée : toute personne peut se loguer et faire ce qu'il veut Gérée dans la config. système de Jenkins (option Activer la sécurité) Seuls les admins sont autorisés à réaliser des actions sur les projets. Tous les autres : accès en lecture seule exemple : Tomcat droits d'accès précis à chaque groupe d'utilisateurs aucune authentification demandée éviter si accès à Jenkins via Internet 116

117 Config. système : notification par En fonction des projets, équipes, de l attention que chacun porte aux mails : on peut configurer de manière un peu plus poussée le reporting par s. Les notifications par pourront aussi être activées / configurées par projet. Pour permettre la notification, vous devez indiquer un serveur de messagerie (serveur SMTP). Laissez le champ vide si vous souhaitez utiliser le serveur de messagerie par défault (localhost). Vous pouvez également spécifier le suffixe par défaut des s des utilisateurs. Vous pouvez spécifier l'adresse de l'administrateur système. Il s'agit de l'utilisateur qui va envoyer les s aux responsables du projet et/ou aux personnes qui ont cassé un build. Vous devrez finalement préciser l'url de votre serveur Hudson, afin que les URL dans les mails envoyés par Hudsons soient corrects 117

118 Premier projet (job/item) basé sur Maven 2 Créer 1 projet (job) en choisissant sa propre config. Utile pour 1 projet basé sur Ant ou par lignes de commandes batch Windows Projet pouvant disposer d'1 config. multiple Suivre l'exécution d'1 processus exécuté hors de Jenkins sur 1 machine distante Créer 1 nouveau projet à partir d'1 projet déjà existant dans Jenkins 118

119 Configuration du projet Indique si Jenkins doit supprimer les anciens builds de ce projet (utiles pour les stats et l'historique du projet), pour ne pas encombrer le serveur de fichiers (paramétrable pour ne garder qu'1 nb limité de builds ou ne les conserver que pendant 1 période donnée) Désactiver le projet sans le supprimer Configuration du SCM qui permet à Jenkins d'aller récupérer les fichiers sources. D'autres systèmes de SCM sont accessibles grâce à l'ajout de plugins 119

120 Configuration de SVN Configurer SVN pour le projet se borne à définir l'url du projet et configurer l'authentification. Entrer son login / mot de passe ici : 120

121 Configuration du projet (2) Aller vérifier périodiquement l'existence de fichiers modifiés sur le SCM pour lancer le build (ne lancer 1 build qu'en cas de modifications des sources sur le serveur SCM) Force Jenkins à faire des builds à intervalles réguliers, qu'il y ait des modifs sur le SCM ou non Explication plus approfondie de l'option quel(s) goal(s) Maven à exécuter lors d'1 build. 1 bon choix : clean install Envoyer des mails à la fin d'1 build s'il échoue, redevient correct, est instable Actions à réaliser par Jenkins une fois le build terminé 121

122 Ce qui déclenche le build Le build peut être déclenché de plusieurs manières : manuellement ou automatiquement. Dans ce dernier cas, ce peut être sur changement des sources dans le SCM, indirectement dans le cas de multi-projets ayant des dépendances (où l'on recompile le projet B chaque fois que le projet A est construit). Il y a d'autres cas plus spécifiques, voire très particuliers gérés par des plugins. Pour définir un déclenchement de build du projet sur modification du gestionnaire de source, on peut définir le mot-clef '@hourly' : 1 fois par heure, Jenkins regarde si quelque chose a changé sur SVN 122

123 Config. du projet : notification par Dans le job : une action post-build à ajouter dans la configuration est la notification par mail à l'équipe en cas d'instabilité ou d'erreur du build Là aussi on peut élaborer un système complexe, toute une catégorie de plugins existe pour s'interfacer avec des systèmes existants (SCM, Messengers) ou rester basique et envoyer une notification par

124 Options du projet ou d'un build précis Liste des dernières modifications trouvées sur le SCM depuis le précédent build Accès à l'espace de travail du projet : on peut voir l'ens. des fichiers sur lesquels Hudson travaille, les récupérer (sous forme de.zip par ex.) Lance un build manuel sur ce projet Supprime définitivement ce projet de Hudson Pour configurer ce projet Voir ce que les logs des builds affichent. 2 types : version std (pour suivre en tps réel l'écriture des logs lorsqu'1 build est en cours) et brute Pour taguer le build en cours Obtenir des infos précises sur le processus Maven en cours (propriétés système, var. d'envt) 124

125 Mojos exécutés Option disponible pour les projets Maven déjà exécutés Liste de tous les plugins Maven qui ont été lancés par le build Jenkins, le goal utilisé, ainsi que leur durée d'exécution 125

126 Indicateurs Statut d'un projet (page principale de Jenkins + page listant les sousmodules d'un projet) : icône indiquant son état Santé d'un projet : pourcentage de builds récents qui ont réussi. Plus il est élevé, meilleure est la santé du projet En plaçant le curseur de la souris sur l'icône de santé, on obtient 1 info plus précise : Rassembler plusieurs projets au sein d'1 même groupe avec les onglets 126