Evolution MM

Formations à l'informatique
Découvrez la différence ENI

Lien accueil

Téléchargez le Calendrier des formations

Nantes, Rennes, Niort, Nice, Paris

jusqu'à juillet 2018

Rechercher
Rechercher une formation
 

Mise en oeuvre d'un processus outillé autour de Java

Public :

  • Ce cours s'adresse à des architectes logiciels ou à des programmeurs expérimentés en charge d'un développement informatique complexe d'un point de vue purement technique ou de par sa taille (durée et équipe de production).

Objectifs :

  • Pour mener correctement à termes un projet informatique d'envergure, un processus de développement outillé doit être mis en œuvre au sein d'une équipe.
  • Il devient alors obligatoire que chacun maitrise les différentes étapes de ce processus et connaisse l'intérêt des outils qui le complètent.
  • La modélisation de l'application est une des parties clés d'un tel processus.
  • Bien souvent des projets prennent du retard parce qu'au démarrage de celui-ci, sa modélisation a été sous-estimée.
  • Le test logiciel, lui aussi, a toujours été un facteur fondamental du développement informatique mais il est devenu primordial du fait de la complexité des logiciels et des intérêts engagés.
  • Comme toute démarche d'Assurance qualité, le test logiciel est l'affaire de tous, architectes et développeurs.
  • Ce cours vous permet de découvrir les techniques et les moyens à mettre en œuvre pour dérouler un processus adapté à votre projet.

Pré-requis :

  • Connaître la syntaxe du langage Java

Contenu pédagogique

Présentation rapide d'un processus outillés complet

  • Conduite d'un projet informatique
  • Définir les exigences du logiciel et garantir leur traçabilité
  • Choisir une méthodologie de conception du logiciel
    • Le processus unifié
    • MDA (Model Driven Approach)
    • XP (eXtrem Programming)
  • Analyser et concevoir une application
  • Mettre en œuvre une solution de gestion de configuration
  • Mettre en œuvre une procédure de " Build Night "
  • Les outils de développement et de profiling
  • Mise en œuvre de tests unitaires et garantir leur traçabilité
  • Réaliser des revues de code et garantir leur traçabilité
  • Intégrer les différents éléments logiciels et réaliser les tests d'intégration
  • Tester le système

Modéliser (Analyse et Conception) votre application

  • Choix d'un modeleur UML
  • Notion d'exigences
    • Définition des exigences
    • Traçabilité des exigences
  • Modélisation des cas d'utilisations (Use cases)
    • Les cas d'utilisations définissent les tests
  • Analyse du système et de ses composants logiciels
    • Identifier les composants logiciels
    • De l'intérêt du couplage par interface
    • Définir le plan de lotissement
    • Les différents jalons d'intégration
  • Définir correctement les itérations et leur caractère incrémental
  • Conception du système
    • Conception détaillée de chacun des composants logiciels
  • Génération de code à partir du modèle
  • Génération des documentations à partir du modèle

Préparer son environnement de travail

  • Les outils de développement et de profiling
    • Choisir son IDE et les plugins adéquats
    • Les outils complémentaires indispensables
  • Mettre en œuvre une solution de gestion de configuration
    • Installation de SVN
    • Prise en main de l'outil en mode ligne de commande
    • Intégration de SVN au sein d'Eclipse
  • Mettre en œuvre une procédure de " Build Night "
    • Comparatif entre ANT et Maven
    • Quelques conseils importants (code/documentation/…)

Les différentes API de logging

  • Introduction
    • Nécessité de conserver les traces d'un jeu de tests
    • Nécessité de filtrer les traces
  • L'API de SUN (java.util.logging)
    • Fonctionnement général
    • Utilisation de l'API
  • L'API Log4J (the Apache Software Foundation)
    • Fonctionnement général
    • Utilisation de l'API
    • Editer le fichier de configuration de Log4J
  • L'API JCL (Java Commons Logging - the Apache Software Foundation)
    • Fonctionnement général
    • Utilisation de l'API

Le framework JUnit

  • Nécessité des jeux de tests unitaires
    • Garantir le fonctionnement nominal
    • Garantir la non régression de votre code
  • Mise en œuvre d'un jeu de test JUnit
    • Intégration du framework au sein d'Eclipse
    • Codage d'un test unitaire
    • Exécution de vos tests
  • Quelques axes de tests
    • Tests fonctionnels vs tests techniques
    • Tests "Black box" vs tests "White Box"
    • Quelle granularité de code tester ?
  • Associer les tests aux exigences
  • Garantir un taux de couverture du code minimal
    • Taux de couverture en termes de lignes de codes
    • Taux de couverture en termes d'exigences
    • Présentation de l'outil Cobertura

Utilisation de techniques de bouchonnage (MOCK Objects)

  • Il faut réduire les dépendances entre composants
    • Présentation de la problématique
    • Couplage par interfaces
  • Concepts généraux sur l'utilisation de bouchon
    • Présentation générale (théorie, vocabulaire, etc.)
    • Comparaison entre pratique classique du test et pratique bouchonnée
    • Présentation des frameworks JMock et EasyMock
  • Bouchonnage de composants Web J2EE
    • Tester un état
    • Tester un comportement
  • Utilisation du Framework SPRING
    • Intérêts du framework Spring
    • Exemple concret de bouchonnage via Spring

Les différents niveaux de tests de votre application

  • Les tests unitaires
  • Les tests d'intégration
  • Les tests système
    • Tests de montés en charge
    • Tests d'endurance
    • Présentation de l'outil JMeter
  • Traçabilité de vos campagnes de tests
    • Quelques outils permettant la traçabilité de campagnes de tests
    • Garantir la non régression

Utilisation des Design Patterns et autres patterns

  • Les patterns de conception et d'implémentation
    • Patterns et réduction des dépendances entre composants
    • Unifier les développements de vos composants logiciels
    • Les principaux Design Patterns
  • Les patterns d'architecture
    • Concepts de couches logicielles (3-tiers, n-tiers, ...)
    • Pattern MVC (Model-View-Controller)
    • Approche par composants

Mener des revues de code

  • Intérêt des revues de code
    • Détecter les mauvaises pratiques
    • Détecter les bonnes pratiques de développement et les partager
    • Communiquer sur ces points avec l'équipe de développement
  • Quand réaliser les revues de code ?
  • Outils utilisables pour mener une revue de code
    • Présentation du plugin Jupiter pour Eclipse
    • Besoin de traçabilité sur les revues de code

Outils graphiques de monitoring et de profiling

  • La JConsole
    • Présentation du modèle JMX (Java Monitoring eXtensions)
    • Démarrage d'une JVM supportant le monitoring
    • Lancement et attachement de la JConsole
    • Les différentes possibilités de la JConsole
  • Surveiller l'activité du garbage collector
  • Visual GC et GC Viewer
  • Présentation de JVisualVM
  • TPTP (Test and Performance Tool Platform)
    • Rappel sur l'utilisation de plugin Eclipse
    • Présentation du plugin TPTP
    • Test de détection de fuite de mémoire
    • Mesure de performances d'une application Java
    • Taux de couverture de code
    • Analyse de logs
Durée : 5 jour(s)
Tarif : Consultez-nous
Réf : T443-055

Dates des sessions

Nantes (44) Consultez-nous Rennes (35) Consultez-nous Paris (75) Consultez-nous Niort (79) Consultez-nous Nice (06) Consultez-nous in-class™