Filière Objet, UML, Java/J2EE

Contenu

Présentation du design

- Rappel des notions fondamentales de la programmation OO et d'UML. Les diagrammes de la notation UML. Ses apports pour la conception.
- Les enjeux de la conception : accroître la réutilisation sans freiner les évolutions.
- La réutilisation par l'héritage : avantages et inconvénients.

Principes fondamentaux en conception objet

- La stratégie d'évolution avec le principe d'ouverture/fermeture (OCP).
- Une réutilisation efficace par l'héritage et les interfaces : le principe de substitution de Liskov (LSP)
- Le concept de polymorphisme.
- L'impact de la conception objet sur le cycle de vie des projets.

Travaux pratiques

Illustration du découpage des responsabilités entre les classes.

Principes d'organisation en packages

- Le package comme unité de conception avec les principes d'équivalence livraison/réutilisation (REP) et de réutilisation commune (CRP).
- Le découpage des packages gr'ce au principe de fermeture commune (CCP).
- L'organisation entre packages : principes des dépendances acycliques (ADP) et de relation dépendance/stabilité (SDP).

Travaux pratiques

Construction et hiérarchisation des packages.

Principes de construction des classes

- La gestion raisonnée des dépendances avec l'inversion de dépendance (DIP).
- La réduction de la complexité apparente par la séparation des interfaces (ISP).
- La répartition des responsabilités avec le principe de GRASP.

Principes des design patterns

- Les principes techniques de la conception d'une application objet.
- Comment réutiliser de l'expérience lors de la conception et du développement d'applications objet : les design patterns ou « patrons de conception » comme solutions logicielles.
- Origine et portée des patterns.
- Les avantages et les limites des design patterns.
- Les design patterns comme réponse aux problèmes techniques.
- Résoudre des problèmes récurrents et assurer la pérennité des développements.

Les patterns fondateurs de Gamma et Gof

- Le catalogue de patterns de la "bande des quatre".
- Les objectifs et les avantages.
- Isoler la création des objets de leur utilisation avec les patterns de création d'objets : fabrique, singleton et prototype.
- Affiner l'affectation des responsabilités grâce aux patterns comportementaux : chaîne de responsabilité, patron de méthode et observateur.
- Améliorer la structuration des classes avec les patterns de structure : adaptateur, façade et composite.

Travaux pratiques

Exemple de conception et programmation avec des patterns GoF.

Lien externe

Programme

Principes et démarche

Enjeux
Types de tests
Démarche
Processus Unifié
Rational Unified Process
eXtrem Programming

Bases du framework JUnit

Présentation des tests unitaires
Framework jUnit
Cas de test
Initialisation et finalisation
Réutilisation
Suite de tests
Bonnes pratiques

Techniques avancé avec JUnit

Unité des tests
Objets de leurre
Automatisation des tests
Extensions à JUnit

Tests unitaires en architecture Java EE

Architecture Java EE
Tests d?EJB 3
Tests avec le framework Spring
Tests des classes persistantes d?Hibernate

Programme

Les bonnes pratiques de conception

- Les enjeux de la conception
- La conception avec ou sans UML
- La réutilisation : techniques et limites
- Le rôle des interfaces et classes abstraites dans la stratégie d?évolution d?un système
- L?organisation du sous-système ou modules
- La gestion de l?évolutivité par les dépendances
- Le rôle du paquetage dans la conception
- La notion de responsabilité dans l?organisation du système
- Les design patterns pour résoudre les problèmes de conception récurrents

Les bonnes architectures pour Java EE

- L?importance de l?architecture dans la conception
- L?architecture multi-couches pour orienter le graphe de dépendances
- Les design patterns dans l?architecture
- Les technologies Java EE dans l?architecture
- Les frameworks Java EE

Les bonnes pratiques de développement

- Les techniques pour économiser la mémoire (instanciation, pool et cache)
- Les transactions
- La sécurité

Les outils pour bien développer

- Améliorer la productivité individuelle (eclipse, ant)
- Améliorer la productivité de l?équipe (eclipse, subversion, maven)
- Préparer l?exploitation avec de bonnes traces (Apache Log4J et Common Logging ou SLF4J)
- Suivre la mémoire (jconsole, profiling)

Le suivi de la qualité

- Les différents types de tests
- La mise en oeuvre des tests unitaires automatisés (junit, jcover)
- L?automatisation des tests d?intégration
- Les outils de mesure de la qualité (CodeStyle, PMD, jDepend,...)

Les bonnes démarches de projet

- L?organisation d?un projet autour d?UML : UP, le processus unifié
- Centrer un projet sur les modèles : MDA (Model Driven Architecture)
- Centrer un projet sur l?agilité des développeurs : eXtreme Programming

Les techniques « objet »

- Les principes généraux de la modélisation et de la programmation « objet ». L'abstraction et l'encapsulation : les interfaces. Les différentes formes d'héritage, le polymorphisme.
- Une introduction aux modèles et à la notation UML : le modèle statique, le modèle dynamique, le modèle de coopération, les scénarii.
_ Travaux pratiques : La spécification UML d'une étude de cas qui sera l'un des fils directeurs des exercices suivants.

Une première approche du langage

- Les variables : déclaration et typage.
- La définition des champs.
- Les méthodes : définition.
- Les expressions.
- Les instructions de contrôle : les instructions conditionnelles, de boucle, de branchement.
- Les tableaux.
- Les Unités de compilation et packages : le contrôle de la visibilité des classes, le mécanisme d'import.
_ Travaux pratiques : Suite d'exercices simples permettant la prise en main de l'environnement de développement et la réalisation d'un programme simple.
Utilisation des packages.

La définition et l'instanciation des classes

- Les classes et les objets.
- Les champs, les méthodes.
- Les constructeurs.
- L'autoréférence.
- Les champs et méthodes statiques.
- Les aspects méthodologiques : la conception des classes.
_ Travaux pratiques : Programmation de l'étude de cas.

L'héritage

- Les différentes formes d'héritage : l'extension et l'implémentation.
- Les interfaces et l'implémentation des interfaces. Le polymorphisme et sa mise en oeuvre.
- L'extension. La définition des classes dérivées, les constructeurs, les références. Les aspects méthodologiques. La construction de hiérarchies de classes. La factorisation de code : les classes abstraites.
- L'utilisation simultanée de l'implémentation et de l'extension. Les classes abstraites. Les aspects méthodologiques : le regroupement des constantes, la spécification de services. La construction de hiérarchies de classes et d'interfaces.
_ Travaux pratiques : Conception et construction d'une hiérarchie de classes et d'interfaces.
Mise en place du polymorphisme et de la généricité dans l'étude de cas.

Les exceptions

- Les blocs de try, la génération des exceptions.
- L'algorithme de sélection du catch().
- Les aspects méthodologiques : la construction d'une hiérarchie d'exception, l'utilisation des exceptions.
_ Travaux pratiques : Introduction des exceptions dans l'étude de cas.

Présentation de quelques classes et librairies standard

- La programmation des entrées/sorties

- La hiérarchie des classes d'entrée/sortie.
- Quelques classes de manipulation des systèmes de fichiers.
- Quelques classes d'entrées/sortie travaillant sur les flots de bytes, sur les flots de char.
- Les entrées/sorties clavier.

- La programmation graphique

- Les concepts de base : les principes de la visualisation et de la gestion des événements depuis jdk1.1.
- La visualisation des composants graphiques : les conteneurs et les Layouts.
- Quelques composants graphiques : labels, boutons, zones de texte.
- La gestion des événements : les Listeners et Adapters. L'association de gestionnaires aux composants graphiques.

- La programmation des applets

- Les applets : les principes, le cycle de vie, etc.
- La classe Applet.
- L'intégration dans une page HTML.

- Quelques classes utilitaires

- Les classes système.
- Les classes de conteneur.

Les nouveautés de Java-Tiger

- La nouvelle instruction de boucle.
- Les types énumérés, l'autoboxing.
- Les méthodes à nombre variable d'arguments.
- Les imports statiques.
- Les types génériques.

Conclusion

- Les premiers bilans sur le langage.
- Les tendances actuelles.
- Eléments de bibliographie.

Introduction au modèle MVC

- Le modèle MVC.
- Présentation de MVC avec des Servlet/JSP.
- Limites du modèle MVC.
- Présentation de MVC2.
- Présentation de Struts, framework MVC2 du projet Jakarta.
- Les propositions concurrentes.

Le paquetage Struts

- Les composants de Struts.
- Les classes de base.
- Le contrôleur et la « correspondance » d'action.
- Définition de vue.
- Validation.
- Encapsulation et « Beans ».
- Présentation par JSP.
_ Exercices : Implémentation d'une application de base incluant les divers composants de Struts.

Librairies de balises JSP

- Définition de balises personnalisées.
- Balises de présentation HTML.
- Balises d'intégration de Bean.
- Balises logiques.
- Balises de modélisation.
- Imbrication de balises.
- Paramétrisation d'application et support multilangue.
- Fichier de ressources.
- Concept de « sous-application ».
_ Exercices : Implémentation des balises de base et paramétrisation de l'application.

Déploiement d'application

- Configuration d'une application Web.
- Gestion d'erreurs et exceptions.
- Fichier de configuration Struts.
- Configuration de sources de données.
- Notion de plug-in.
- Hiérarchisation d'une application.
_ Exercices : Développement et déploiement d'une application structurée.

Les composants de contrôle

- Description de la méthodologie « contrôleur frontal ».
- Les différents mécanismes de contrôle.
- Définition de règles métier.
- Extension des classes de base.
- Les actions prédéfinies du paquetage.
- Les classes utilitaires.
_ Exercices : Développement de la vitrine d'un magasin en ligne.

Les composants modèles de données

- Les objets métier.
- Etats, comportements, entités, processus et événements.
- Différents objets de modélisation.
- Accès à une base de données et persistance.
_ Exercices : Accès à une base de données à travers des objets métier.

Présentation générale

- Introduction.
- Principes fondateurs de l'objet : abstraction/encapsulation.
- Mise en oeuvre de l'abstraction/encapsulation.
- Principes fondateurs de l'objet : héritage.
- Présentation générale : le langage.
- Présentation générale : les outils.
- Présentation générale : la bibliothèque.
- Distributions de Java.

Aspects syntaxiques, types et expressions

- Structuration syntaxique d'une application Java.
- Exemple de syntaxe sur une application simplifiée.
- Notion de type.
- Utilisation comparée des types de base et des types objet.
- Utilisation simple des types de base : les nombres entiers, les nombres flottants, le type char, le type boolean.
- Notion d'expression.
- Exemples de déclarations : variables et constantes.
- Désignation comparée des types de base et des types objet.
- Utilisation des opérateurs avec les objets.
- Complément sur les types : utilisation de base des tableaux.
- Conversion types de base/type objet.
- Programme minimum : récapitulatif.
- Conventions d'écriture.

Méthodes et instructions

- Syntaxe d'invocation des méthodes.
- Exécution de méthodes de classes et de méthodes d'instances.
- Complément sur l'exécution des méthodes.
- La surcharge des méthodes.
- Notion de sous-bloc.
- Catégories d'instructions.
- Instructions de contrôle principales : if, while, for, return, break.

Utilisation de l'abstraction

- Exemple simple d'utilisation d'un objet de la classe Date.
- L'instanciation des objets : exemple de la classe Date.
- La documentation en ligne : exemple de la classe Date.
- Une classe très spéciale : la classe String (1).
- Une classe très spéciale : la classe String (2).
- Utilisation de la classe StringBuffer.

Utilisation de l'héritage

- Rappel du principe d'héritage et terminologie.
- Utilisation de l'héritage.
- Exemple de graphe d'héritage.
- La classe Object et la généricité.
- Utilisation du polymorphisme.
- Spécialisation d'une référence polymorphe.
- Typage des références/typage des objets.
- Comportement des méthodes et typage.
- Généricité des classes conteneurs : exemple de la classe Vector.

Utilisation du mécanisme d'interface

- Terminologie et syntaxe.
- Extension et implémentation multiple des interfaces.
- Utilisation des interfaces pour les méthodes.
- Intérêt du mécanisme d'interface pour les méthodes.
- Utilisation des interfaces pour les constantes.
- Exemple d'utilisation des interfaces pour les constantes.
- Exemple d'utilisation des interfaces pour les méthodes.

Développement de classes

- Approche méthodologique, notation UML.
- Squelette d'une classe.
- Compléments sur les droits d'accès.
- Organisation en packages.
- Contraintes liées aux packages.
- Ecriture des constructeurs.
- Constructeur par défaut.
- Compléments sur l'écriture des constructeurs.
- L'auto-référence this.
- Champs statiques.
- Méthodes statiques.
- La méthode main.

Développement d'interfaces

- Rappels et compléments sur les principes.
- Syntaxe associée aux interfaces, cas des constantes.
- Définition d'interfaces pour les méthodes.
- Implémentation et extensions multiples d'interfaces.
- Implémentation partielle d'interface.
- Exemples et compléments sur l'utilisation d'interfaces.

Développement de classes dérivées

- Rappels des principes.
- Approche méthodologique pour le découpage en classes.
- Méthodes abstraites.
- Classes abstraites et interfaces.
- Droit d'accès aux champs et héritage.
- Constructeurs et héritage.
- Redéfinition et surcharge.

Les exceptions

- Principes et cinématique générale.
- Détection et constat d'une situation exceptionnelle.
- Notification d'une situation exceptionnelle.
- Report d'une exception : clause throws de la signature.
- Report d'une exception : bloc try/catch.
- Exceptions non vérifiées.
- Exemple avec exceptions : un aspirateur Web.

Quelques aspects avancés du langage

Cette partie du présente essentiellement les éléments nouveaux du langage. Elle insiste sur les points les plus intéressants mais aussi les plus complexes, à savoir les types génériques et les annotations.
- Les inner classes.
- Les classes anonymes.
- La redéfinition covariante des méthodes (jdk1.5).
- Les nouvelles boucles for (jdk1.5).
- Les import static (jdk1.5).
- Les varargs (jdk1.5).
- L'auto-boxing, auto-unboxing (jdk1.5).
- Les types énumérés (jdk1.5). L'utilisation et la définition.
- Les types génériques (jdk1.5). L'utilisation et la définition de types génériques simples. La généricité et la relation de sous-typage : le type ? Le mécanisme d'effacement et ses conséquences : les types génériques à l'exécution, les types génériques et l'instanciation, les types génériques et les tableaux. Les méthodes génériques. L'utilisation simultanée des types génériques et non génériques.
- Les annotations (jdk1.5). Les objectifs et les principes. Les annotations prédéfinies (@override, @deprecated, @suppress§Warnings). La définition de nouvelles annotations. Les méta-annotations (@Retention, @Target, @Documented, @Inherited). L'utilisation réflexive des annotations à l'exécution.
_ Travaux pratiques : Utilisation des types génériques et des annotations.

La programmation concurrente

- La programmation concurrente est un aspect important du langage : elle offre une solution élégante et efficace à de nombreux problèmes difficiles à résoudre autrement (en particulier la construction de serveurs performants). Cette forme de programmation comporte cependant des pièges. On étudie le plus courant d'entre eux : l'interblocage.
- Définitions relatives à la programmation concurrente : les threads. La création/destruction des threads. Ordonnancement des threads
- La synchronisation des threads. Le verrouillage des méthodes et des instructions (synchronized). Les moniteurs.
- Principes méthodologiques pour la conception d'applications multithreadées.
- Les problèmes posés par la programmation multithread. Le problème de l'interblocage (caractérisation, évitement, prévention, détection). Le problème de la famine.
- La librairie concurrente de JDK1.5. Les nouvelles collections. Les nouveaux outils de synchronisation : les verrous partagés/exclusifs, les sémaphores, les barrières cycliques, ....
_ Travaux pratiques : Construction d'une application concurrente avec synchronisation et résolution d'interblocage.

La programmation des communications distantes

- Le langage propose de nombreuses librairies de communication. On présente les plus utilisées et représentatives en insistant sur leurs particularités et leurs domaines d'application.

- La communication par socket

- Rappels sur les principaux concepts réseaux.
- La programmation en mode non connecté (par datagram). Le modèle peer to peer
- La communication en mode connecté (par stream). Le modèle client/serveur. Serveur séquentiel vs serveur concurrent. Utilisation de la sérialisation.
- La librairie nio. Les buffers, channels. Les sélecteurs et leur utilisation.

- La communication par invocation de méthode distante : RMI

- Les principes généraux.
- Les classes de base.
- Le service de nommage.
- Le processus de développement du client et du serveur.
- Les contraintes de sécurité et de chargement de classes.

- La communication par messages : JMS

- Les principes généraux de la communication par messages.
- Les concepts de JMS, les interfaces et les classes correspondantes.
- Les différentes formes de messages.
- La communication en mode point à point.
- La communication en mode publish/subscribe.

L'administration et la supervision

- L'administration et la supervision des applications prennent une importance de plus en plus grande. JMX est le standard qui semble s'imposer aujourd'hui dans le monde Java, en particulier grâce à son modèle simple mais puissant mais aussi grâce à sa nature peu intrusive.

- Présentation de JMX (Java Management Extension)

- La distinction entre l'application à administrer et l'application d'administration.
- Les concepts de JMX : MBean, MBeanServer, Agent, Connector.
- Les API JMX.
- La mise en oeuvre des différentes catégories de Mbeans (standard, dynamiques, model).
- L'utilisation des adaptateurs et des connecteurs.
- Les consoles d'administration.

- La programmation réflexive

La sécurité et le chargement de classes

On aborde ici des aspects avancés et moins connus de la JVM.
- Les mécanismes liés à la JVM pour assurer la sécurité. Le modèle de sécurité de Jdk1.2 : les permissions, les politiques, les domaines de sécurité. Le gestionnaire de sécurité et le contrôleur d'accès.
- Les mécanismes de chargement de classes.
- Le développement de chargeurs de classes spécifiques.

Introduction

- Les éléments intervenant dans l'optimisation et les actions correspondantes.
- Le choix d'un environnement d'exécution performant.
- Les outils d'aide à l'optimisation.
- Comparaison avec C++.

Méthodologie pour l'optimisation et quelques outils associés

L'optimisation des performances est souvent présentée comme une activité principalement basée sur l'usage d'astuces. En fait une approche méthodologique rigoureuse et systématique existe qui par ailleurs conduit souvent à une amélioration de la conception. On présente ici cette méthodologie ainsi que les outils associés. Le reste de la session met en pratique cette méthodologie.
- Les éléments de la méthodologie.
- Quelques outils associés : jmp, hprof, Eclipse TPTP, junit.
_ Travaux pratiques : Utilisation des profilers hprof et jmp. Utilisation de junit. Profiling d'une application simple.

L'optimisation et l'environnement d'exécution

- Le choix du compilateur.
- Le choix de la JVM.

L'optimisation et le langage

Une approche objective du langage Java relativise montre que la plupart des problèmes de performances ne sont pas liés au langage lui-même mais à une mauvaise utilisation du langage (en particulier une mauvaise gestion des objets et des évaluations). Il est donc important de savoir identifier les vraies sources d'inefficacité et de connaître les bons usages qui les évitent.
- L'optimisation et la gestion des objets.
- L'optimisation et les évaluations.
- L'optimisation et les tests.
- L'optimisation et les nouveautés de Java5.
_ Travaux pratiques : Suite d'optimisation d'une application par une meilleure gestion des objets, des évaluations et des tests.

L'optimisation et les librairies standard

- La manipulation des String.
- Les classes « Collection ».
_ Travaux pratiques : Suite d'optimisation d'une application par une meilleure manipulation des Strings.

L'optimisation et quelques Design Patterns

L'obtention de performances impose souvent de s'adapter aux caractéristiques d'un environnement donné. La flexibilité et la configurabilité des applications sont donc parfois un facteur important, dont le traitement reste encore aujourd'hui très ad hoc. Il existe pourtant des techniques connues et éprouvées qui permettent d'augmenter la flexibilité. On présente d'une part, les solutions architecturales génériques et d'autre part, celles spécifiques à Java.
- L'utilisation des interfaces et des classes abstraites.
- L'utilisation de fabriques.
- L'utilisation d'adaptateurs, décorateurs, proxies.
- Les lanceurs d'application.
_ Travaux pratiques : Application de Design Patterns à l'optimisation de l'application.

L'optimisation et les I/O

Une programmation médiocre des IO peut avoir un effet désastreux sur les performances. Il est important d'en connaître le fonctionnement général et les facteurs sur lesquels agir.
- La bufferisation, l'encodage des données.
- Le choix des bonnes classes de Stream.
- L'optimisation de la sérialisation.
- Les classes du package java.nio.
- L'optimisation spécifique aux IO réseaux.
_ Travaux pratiques : Optimisation des IO de l'application.

L'optimisation et le multithreading

Cette formation n'aborde pas la programmation multithread dans toute sa généralité. Elle se limite à l'utilisation des threads au problème de l'optimisation des IO (en particulier des IO réseau).
- Le modèle d'activité avant Java5.
- Rappels programmatiques (création, ordonnancement, synchronisation des activités).
- Le modèle d'activité de Java5.
- La nouvelle API.
- Les threads et l'optimisation.
_ Travaux pratiques : Utilisation des threads pour l'optimisation des IO de l'application.

L'optimisation et la gestion de la mémoire

Un paramétrage du Garbage Collector adapté aux caractéristiques d'une application peut se manifester par une amélioration des performances. Il est donc important d'en connaître le fonctionnement. Par ailleurs certaines applications manipulent des objets de grande taille ou de très nombreux objets. Il est nécessaire de connaître les techniques adaptées à ce type de problème.
- Les principes généraux des GC (principaux algorithmes, collaboration avec l'allocateur).
- L'organisation de la mémoire des principales JVM.
- Le GC de la JVM de Sun (fonctionnement et paramétrage).
- Le GC de la machine d'IBM (fonctionnement et paramétrage).
- L'impact des finalize sur les performances.
- La saturation mémoire (cause, diagnostic, solutions).
- Les références faibles : SoftReference, WeakReference, PhantomReference (concepts et utilisation).
- Les files de références.
_ Travaux pratiques : Utilisation de SoftReference pour un cache d'objets de grande taille.

L'optimisation et l'utilisation de librairies C et C++

L'utilisation de code C ou C++ dans une application Java est une solution possible à des problèmes locaux de performances. On présente rapidement l'interface JNI prévue à cet effet.
- Les principes généraux de JNI : les étapes du développement.
- L'API JNIEnv.
- JNI et les performances.

Introduction

- Le conteneur léger, l'injection des dépendances et l'inversion du contrôle (IOC).
- Agile, technique de modélisation pilotée par le domaine avec Spring.
- Accès aux bases de données avec Spring JDBC et Hibernate.
- Gestion déclarative des transactions.
- Programmation Orientée Aspects (AOP).
- Tests unitaires en isolation.
- Test d'intégration.
- Approche MVC avec Spring MVC et Struts.
- Sécurité, composants distants et JMX.

Développement centré sur les tests

- Fondations du développement J2EE Agile.
- Introduction au conteneur léger.
- Architecture en couches.
- Contexte d'application de Spring.
- Injection des dépendances (DI).
- Développement piloté par les tests (TDD).
- Configuration et structuration d'une architecture de test.
- Comment Spring aide à l'écriture d'un meilleur code.
- Les patrons de modélisation (Design Pattern) en présence.
- Programmation par interface et couplage faible.
- Réutilisation optimale du code.

Gestion des configurations d'applications

- Exposition de modules métier en tant que services managés.
- Contrôle de fin du cycle de vie des services.
- Insertion de comportements particuliers dans le cycle de vie des services.
- Modification du contexte à chaud.
- Création de hiérarchies de contextes modulaires avec espaces de noms.
- Non-duplication des configurations.
- Utilisation du contexte dans différents environnements (clients Swing, suite de tests d'intégration, applications autonomes...).

Architecture et intégration des bases de données

- Modélisation du tiers central sur un domaine métier.
- Construction du tiers de persistance avec les meilleures pratiques de Spring.
- Analyse des stratégies de persistance : Hibernate, Toplink, JDO, iBatis et Spring JDBC.
- DAO et infrastructure des templates.
- Stratégie de gestion des transactions avec Spring (déclarative ou programmatique).
- Tests unitaires et tests d'intégration de la couche de service.
- Mocks et Stubs pour développements parallèles et collaboration d'équipes.

Construction d'applications Web

- Illustration des différentes approches MVC.
- Comparaison avec Struts.
- Intégration de JSF et Tapestry.
- Connexion déclarative des écrans aux objets du métier.
- Gestion des flux d'écrans (Spring Web Flow).
- Intégration de différentes technologies de visualisation.
- Internationalisation.
- Stratégie de test de la couche Web.

Sécurisation et services

- Introduction à AOP et ses différentes implémentations.
- Implémentation AOP proposée par Spring.
- Utilisation et développement d'Aspects.
- Ajout de services.
- Sécurisation des niveaux Web, Services et Instances avec Acegi.
- Authentification centralisée des applications (SSO).
- Web Services avec Spring Remoting.
- Moniteur et configurateur d'application avec Spring JMX.

Introduction

- Les objectifs et les principes d'Eclipse.
- Les concepts de base : vue, éditeur, perspective, espace de travail, projet, répertoire, fichier, nature.
- Le démarrage d'Eclipse.
- Les fonctions d'aide.
- La gestion des vues et des perspectives.
- La gestion des ressources (création, destruction, liaison, copie, destruction, ...).
- Les fonctions de navigation.
- Les fonctions de recherche.
- La gestion des projets.
_ Travaux pratiques : Création de projets, manipulation générale de ressources, fonctions de base.

La programmation avec Java Development Toolkit

- Les principaux concepts.
- L'organisation du code.
- L'édition de code.
- Les mécanismes de complétion.
- Les mécanismes de correction assistée.
- Les fonctions de génération de code (génération de constructeurs, d'accesseurs, de délégués...).
- Les fonctions de refactoring (renommage, extraction d'interface, déplacement de code...).
- Le lancement des programmes.
_ Travaux pratiques : Développement d'une application minimale faisant appel à l'ensemble des fonctions offertes par l'environnement.

Le test unitaire : Junit

- Les principes du test unitaire.
- Présentation générale de Junit.
- L'écriture des cas de tests, des suites des tests, exécution du test.
- Le lancement des tests.
_ Travaux pratiques : Tests de l'application du TP n°2.

Le debug

- La perspective debugger dans Eclipse.
- Les différents breakpoints et watchpoints.
- L'inspection des variables ou expressions, la navigation dans la pile d'exécution.
- Le contrôle de l'exécution.
- Le debug réparti.
_ Travaux pratiques : Debug de l'application du TP n°2.

La gestion des versions : introduction à CVS

- Les concepts généraux liés à la gestion de versions.
- Les concepts de CVS.
- La notion de HEAD, de branches.
- Les principales opérations offertes au développeur (synchronisation, commit, update, les comparaisons, ...).
- La gestion des conflits.
- La gestion des branches.
- La perspective CVS.
_ Travaux pratiques : Gestion des versions de l'application développée dans les TP n°2, n°3 et n°4.

L'automatisation des tâches : introduction à Ant

- Les concepts fondamentaux : les projets, cibles, les tâches, les propriétés.
- Les jeux et les listes de fichiers, les modèles, les structures de chemins, les filtres.
- Les propriétés prédéfinies.
- Aperçu sur quelques tâches standard : manipulation des fichiers, la chaîne de développement Java.
- Association d'un builder à un projet.
_ Travaux pratiques : Définition d'un builder « ant » et ajout à un projet du TP n°2.

La configuration d'Eclipse

- La gestion des préférences.
- La gestion des propriétés (des projets et autres ressources).
- Les références entre projets.
- L'ajout de plug-ins et features.
- Le paramétrage d'Eclipse.