Filière Objet, UML, Java/J2EE

Objectifs

Tomcat est un serveur de Servlets et JSP. La maîtrise de ses fonctionnalités, notamment d'optimisation peut se révéler complexe. Ce cours vous apportera toutes les connaissances nécessaires en vue de l'installer, de l'administrer et de l'intégrer au serveur Apache. Il vous
montrera comment configurer, déployer, sécuriser vos applications et assurer leur connectivité aux bases de données.

Pré-requis

Certaines connaissances des applications Web en JSP et Servlet d'un point de vue architecture et fonctionnement ainsi qu'une certaine expérience avec un serveur Web. Quelques connaissances des technologies XML, HTML, réseaux et techniques d'administration seront appréciées.

Contexte des applications J2EE

Concepts de base
- Les projets Apache.
- Les distributions de Tomcat.
- Utilisation de Tomcat avec le serveur Web Apache.
- Servlet, JSP et composants : architecture.
- Architecture d'un site Java.
Exercices
Démonstration d'une application Web avec et sans serveur Web.

Installation

- Installation de la Java Virtual Machine.
- Configuration de la JVM pour de meilleures performances.
- Les différents paquetages d'installation.
- Les options du serveur.
- Installation de Ant.
- Installation et compilation de Tomcat avec Ant.
- Astuces et résolution des problèmes.
- Analyse des répertoires de Tomcat.
- Analyse des classes de Tomcat : moteur, connecteurs...
Exercices
Installation de Tomcat et modification des paramètres de base.

Configuration

Introduction
- Configuration des composants.
- Les fichiers de configuration : utilisateurs, descripteur de déploiement, contrôle d'accès.
- Configuration d'une application Web.
- Etude du fichier Web.XML
- Outils de configuration de Tomcat.
- Configuration et automatisation avec Ant.
Fonctions avancées de Tomcat
- Filtrage de requêtes : les « Valves ».
- Activation et configuration du filtre de logging.
- Implémentation de l'authentification unique (Single Sign On).
- Restriction d'accès par filtre de requêtes.
- Configuration de la persistance de sessions.
- Les ressources JNDI : JDBC et Mail.
- Les différents types de « Realms ».
- Analyse du chargement des classes Java.
Exercices
Configuration d'une application fournie.

Les connecteurs

- HTTP 1.0 et 1.1 et connecteur Coyote.
- Utilisation de Tomcat avec un serveur Proxy.
- Optimisation de performances.
- Connecteurs pour serveur Web.
- Intégration avec IIS et Apache.
- Protocoles AJP et WARP.
- Configuration Tomcat In-Process et Out-of-Process.
- Répartition de la charge.
- Connecteurs JDBC : alternative et configuration.
Exercices
Accès à l'application fournie à travers un serveur Web et connexion à une base de données.

Sécurité

- Considérations de base concernant la sécurité.
- Sécurisation du système de fichiers : utilisateurs et groupes.
- Les permissions de Tomcat.
- Java Security Manager et Tomcat.
- Les « Realms » : message Digest, rôles, fichiers, JDBC.
- SSL : JSSE et PureTLS.
Exercices
Sécurisation de l'application.

Journalisation

- Introduction au projet Open Source Log4J.
- Choix de sorties : console, fichier, syslog et WinNT Event Logger.
- Destinations multiples.
- Configuration du Logger.
- Niveaux de log.
- Configuration par XML ou Java.
- Lecture du journal.
Exercices
Implémentation et configuration de logging de l'application.

Performances et tests

- Hébergement virtuel.
- Configuration « standalone » ou avec serveur Web.
- Séparation des machines virtuelles.
- Limitation de l'usage de la mémoire.
- Mise à l'échelle.
- Tests de charge avec Jmeter.
- Test de charge distribuée.
- Interprétation des résultats.
- Charge du serveur et charge de l'application.
Exercices
Etablissement d'un plan de test pour l'application.

Contenu

Introduction aux JSF

- Les technologies Java Web
-- servlet, JSP, JSTL, portlets
-- principe du MVC 2
-- les frameworks du marché
- JSF et Java Web
-- fonctionnalités
-- positionnement
-- intégration aux frameworks existants
-- caractéristiques
- JSF et développement RAD
-- définition du RAD
-- complexité des applications web
-- développement RAD pour les applications web
-- caractéristiques JSF accessibles depuis un outil RAD
-- les outils Java du marché

Premier pas

- Configurer l'application web
- Créer un backing-bean
- Créer un formulaire
- Configurer JSF
- Travaux pratiques

Concepts JSF

- Composants graphiques
-- représentation des composants côté serveur
-- représentation des composants côté client
-- l'arbre des composants
-- identifiant d'un composant
- Le code client
-- génération du code client
-- renderer et render kit
- Validation des données saisies
-- principe
-- validation dans les backing beans
-- validation avec un validator
- Backing beans
-- rôle dans le MVC
-- lier les données
-- lier un composant graphique
-- ajouter un listener
-- déclarer un backing bean dans le fichier de configuration
- Conversion des données
-- principe
-- effectuer la conversion dans une JSP
- Evènements et listeners
-- notion d'évènement de type web
-- les évènements existants
- Afficher des messages utilisateur
-- les types de messages
-- afficher un message dans une JSP
- Naviguer entre les pages principe
- Définir une règle de navigation simple
- Travaux pratiques

Composants standards

- Généralités
-- les familles dce composants
-- les propriétés communes
-- cas des attributs HTML
- Vue racine
-- le composant UIViewRoot
- Paramètres
-- le composant UIParameter
- Facets
- Sorties formattées
- Images
- Formulaires
- Saisies simples
- Commandes
- Panneaux
- Sélections
- Datagrid
- Travaux pratiques

Cycle de traitement d'une requête

- Diagramme d'activité du cycle
- Les phases
-- récupération de la vue
-- appliquer les paramètres
-- effectuer les validations
-- mise à jour du modèle
-- invoquer l'application
-- renvoyer la réponse
- Phase Listener
-- l'évènement PhaseEvent
-- coder un PhaseListener
-- abonner un PhaseListener
- Travaux pratiques

Langage d'expression (EL)

- Caractéristiques
- Différences avec les EL JSP
- Accéder aux propriétés des objets
-- accéder à une propriété simple
-- accéder à une propriété de type collection
- Accéder aux méthodes des objets
- Expressions avec opérateurs
- Variables implicites
- Travaux pratiques

Configurer une application JSF

- Archive web
- Configurer le fichier web.xml
-- déclarer la servlet JSF
-- cas de JSF-RI
-- cas de MyFaces
- Structure du fichier de configuration JSF
-- configuration quotidienne
-- configuration des extensions du framework
-- configuration avancée
-- organisation des fichiers de configuration
- Configurer les backing beans
-- déclarer un bean
-- injecter une propriété simple
-- injecter des collections d'objets
-- associer des backing-beans
- Configurer la navigation
-- le navigation handler
-- rappel : configuration d'une règle de navigation simple
-- configuration avancée
(les outcomes, effectuer une redirection,
règles de navigation pour un groupe de pages,
commenter une règle de navigation)
- Travaux pratiques

Afficher des messages utilisateur

- Principe des messages JSF
- Afficher un message dans une JSP
- Créer un message applicatif

Conversion et validation des données

- Principe des converters
- Les converters standards
- Utiliser un converter personnalisé
- Principe des validators
- Effectuer la validation avec un backing bean
- Les validators standards
- Utiliser un validator personnalisé
- Travaux pratiques

Internationalisation

- Locales
- Libellés
- Messages de conversion / validation
- Messages applicatifs
- Travaux pratiques

Notions avancées

- La classe FacesContext
- La classe Application
- La classe ExternalContext
- Travaux pratiques

Intégrer JSF avec les autres technologies

- JSP
-- effectuer un include dynamique
-- effectuer un include statique
-- utiliser des tags non JSF
-- cas des tags JSTL
- Struts
-- objectifs d'une intégration Struts / JSF
-- problématique de l'intégration Struts / JSF
-- principe de fonctionnement
-- mise en oeuvre
- Travaux pratiques

L'approche Objet

Comprendre les principales notions de l'approche objet
- Rappel sur les paradigmes de programmation (logique, impératif, objet...).
- Les objets : identité, état et comportement. Relations au monde réel et aux systèmes
informatiques.
- Popularité, avantages de l'Orienté Objet.
- Abstraction, encapsulation, classification. Classes et instances. Classes abstraites.
Concept d'héritage.
- Méthodes et envois de messages entre objets. Polymorphisme. Surcharge et redéfinition.
Exercices
Démonstrations d'environnements pour le développement objet et d'applications présentant
les notions abordées.

Analyse et conception objets, introduction à l'UML

Pourquoi modéliser ? Appréhender le spectre de l'analyse et de la conception
- Domaine métier et modélisation d'une solution informatique. Le modèle, un artefact central
du processus projet.
- Analyse et conception d'une solution informatique. Impacts des langages de
programmation.
- Evolution vers l'analyse/conception Objet. Avantages.
Présentation générale d'UML
- Historique, évolution et objectifs. Vues de l'architecte.
- Le coeur de l'UML : les différents types de diagrammes. Différences entre diagrammes
statiques et dynamiques.
- Présentation de plusieurs démarches de modélisation.
- Extensions UML : stéréotype, profils, contraintes, etc.
Exercices
Présentation des études de cas. Analyse des domaines métiers.

Diagramme UML des cas d'utilisation

Capture et description des besoins fonctionnels de l'application
- Principaux objectifs et utilisation. Décrire les fonctionnalités du système.
- Eléments du diagramme : cas d'utilisation, acteurs et frontière du système.
- Etapes de construction du modèle des cas d'utilisation.
- Comment identifier les acteurs ? Comment décrire un cas d'utilisation ? Les scénarios.
- Formats, pré-conditions, post-conditions, relations (utilisation, inclusion, extension).
Exercices
Capture des besoins sur des cas concrets et expressions de ces besoins via les
diagrammes de cas d'utilisation. Mise en situation réelle.

Diagrammes UML de modélisation statique

Montrer une vue d'ensemble du système, de ces éléments et de leurs
relations
- Diagramme de classe : son rôle et son utilisation. Exemples.
- Comment identifier les classes utiles ?
- Une classe en UML : nom, attributs et opérations. Visibilité (publique, privée et protégée).
- Formalisme et notation.
- Relations entre classes (association, généralisation, agrégation et composition).
- Multiplicités, rôles, contraintes, etc.
- Classes abstraites, interfaces, packages.
- Diagramme d'objets et instances de classes.
Exercices
Acquérir sur les études de cas le savoir-faire nécessaire à la conception de classes et à la
modélisation objet.

Diagrammes UML de modélisation dynamique

Montrer l'évolution du système et les interactions entre objets
- Diagramme de séquence : interactions entre objets au cours du temps. Message
(synchrone et asynchrone).
- Diagramme de collaboration : rôle des objets, interactions, concurrence de traitements...
- Diagramme d'état transition : états possibles d'un objet et événements déclenchant les
transitions.
- Diagramme d'activité : flux des activités pour réaliser une opération, objets en charge de
ces activités.
- Notations et exemples.
Exercices
Compléter les études de cas par la modélisation de la dynamique du système. Contexte
d'utilisation des diagrammes dynamiques.

Finalisation du système

L'architecture logicielle et matérielle du système
- Modèles d'architectures. Organisation en couches. Sous systèmes.
- Les paquetages et leurs relations.
- Diagramme de composants : organisation du code en modules, dépendances.
- Diagramme de déploiement : déploiement physique du système (machines, réseaux, etc.).
Exercices
Définir l'architecture des solutions proposées. Imbrication finale des diagrammes UML.

Concepts avancés, outillage

Compléments de conception
- Modèles de données. Mapping Objet/Relationnel. Autres modèles.
- Conception des écrans d'IHMs.
- Répondre à des problèmes récurrents
- Design Patterns (ex : singleton, adaptateur, proxy, façade...), leur rôle dans la conception.
- Frameworks, réutilisation.
Ateliers de modélisation
- Génération de rapports, de code. Création de stéréotypes, etc.
- Format XMI d'échange de modèles UML entre AGLs.
UML et les méthodes projet
- Différentes approches. Intégration d'UML.
- Introduction au Rational Unified Process (RUP), itérations, phases et activités.
- Autres possibilités (XP, etc.).
Exercices
Test des fonctionnalités avancées de l'AGL.

Contexte des applications J2EE

- Principes fondamentaux de Java.
- La plateforme J2EE (Java 2 Edition Entreprise).
- Problématique des objets distribués.
- Les différents types d'EJB et leurs rôles.
- JMS (Java Message Services) : les bases.
- L'essentiel d'XML.

Le projet JBoss

- Licence et fonctionnement du JBoss group.
- JBoss un serveur J2EE à part entière.
- JMX : le plus de JBoss.
- Arrêt/Redémarrage.
Les points clés de l'architecture de JBoss
- Le micro kernel.
- La couche service.
- Introduction à l'AOP dans JBoss.

Installation de JBoss

- Les vérifications à faire avant d'installer.
- Installation, tests de post-installation (ou télécharger les bons binaires).
- Présentation des différents répertoires.
- La configuration par défaut de JBoss : présentation des différents fichiers de configuration.
- Les différentes configurations dans JBoss.
- Démarrage de Jboss. Installer JBoss comme un service (Windows, Unix).
- Les tests basiques d'installation.

Configuration de JBoss

- Configuration de base.
- Une introduction au Managed Beans. Le classLoader de JBoss, la séquence de démarrage
du serveur.
- Inspecter le serveur grâce à l'application Web jmx-console, les autres accès à la
jmx-console.
- L'ajout de services, spécifier les dépendances entre services, déploiement à chaud des
composants.
- L'architecture de déploiement de JBoss.
Gérer les logs avec Log4J
- Présentation de log4j, configurer le niveau de trace de la console.
- Utilisation de la console d'administration de Log4J : Chainsaw.
Les différents types de déploiements disponibles
- Servlet, EJBs, Connecteurs, JAR, etc.
- Anatomie d'un .SAR.
Intégration d'un moteur de servlet
- La notion d'« AbstractWebContainer ».
- Intégration de Tomcat.
- Intégration avec Jetty.

Administration avancée

Mise en cluster
- Les fonctionnalités disponibles et points clefs.
- Le farming.
- Notion de service singleton.
- Avec Mbean, codage du service.
Optimiser son conteneur
- Personnaliser la chaîne d'invocations (intercepteurs).
- Optimisation d'une application : pools, transactions.
JBoss et les connecteurs
- Introduction à JCA.
- Configurer les sources de données JDBC.
- Configurer des connecteurs génériques.

JBoss et la sécurité

- Gérer la sécurité avec JAAS.
- Le modèle de sécurité dans JBoss.
- Autoriser la sécurité déclarative avec JBoss, définition de l'identité, des rôles, fixer les
permissions.
- Mise en place de SSL avec JBoss.
- JBoss et les firewall.

Outillage connexe

- Outil d'administration JMS, mise en oeuvre avec Hermes.
- Proxy JDBC, mise en oeuvre de Irongrid.
- Déploiement, utilisation de ANT & Xdoclet.

Qu'est-ce que la persistance ?

* Définition
- persistance en programmation objet

* Les solutions de stockage des données
- SGBDR, SGBDO, BDD XML, fichiers plats, sérialisation

* Accéder aux SGBDR avec Java
- JDBC

* Framework de persistance
- nécessité de l'utilisation d'un framework
- application de designs pattern appropriés
- framework maison ou framework existant ?
- frameworks de type Data Mapper
- frameworks de type ORM

* Hibernate
- Présentation du projet Hibernate
- Ce qui n'est pas pris en charge par hibernate
- Hibernate dans la couche de persistance

Premier pas

* Définir une classe persistante
- classe POJO

* Définir le mapping
- fichier de mapping XML

* Les propriétés de configuration
- charger les fichiers de mapping en mémoire
- définir les paramètres JDBC
- définir le dialecte pour une base de données

* Utiliser Hibernate
- Objets SessionFactory et Session

* Exécuter une requête
- Le langage HQL

* Exemple complet

Le mapping

* Le contexte
- définir les liens entre le modèle objet et le modèle relationnel
- modèle du domaine, document de mapping, schéma bdd

* Objectifs
- lier les classes aux tables
- gérer l'héritage
- gérer les associations
- gérer l'identité des objets
- gérer les différences de granularité

* Coder les classes persistantes
- découplage classes persistantes / technologie de persistance
- les classes persistantes sont des POJO
- règles de codage des POJO avec Hibernate
(constructeurs, getter/setter, associations, héritage)
- définir un identifiant

* Ecrire le schéma de la base de données
- les types de données
- les clés primaires
- cas des identifiants fonctionnels
- associations et foreign keys
- les modèles relationnels pour une hierarchie d'héritage

* Effectuer le mapping
- objectifs du mapping
- mapping des classes
- mapping des propriétés
- les types Hibernate
- contrôler les INSERT et les UPDATE
- mapping des identifiants
- gérer les différences de granularité
- mapping de l'héritage
- mapping d'une association de type many-to-one

Manipuler les objets persistants

* Cycle de vie des objets
- comprendre le cycle de vie des objets
- les états des objets gérés par Hibernate
(objets transients, objets persistants, objets détachés)

* Opérations CRUD de base
- créer un enregistrement
- mettre à jour un objet détaché
- lire un objet à partir de sa clé primaire
- mettre à jour un objet persistant
- supprimer un objet persistant
- supprimer un objet détaché
- mettre à jour un objet transient
- la méthode saveOrUpdate()

* Synchronisation avec la base de données
- synchronisation en fin de transaction
- synchronisation en cours de transaction
- synchronisation explicite
- stratégies de flushing

* Persistance en cascade
- forcer hibernate à parcourir les associations
- l'attribut cascade avec les associations de type many-to-one
- l'attribut cascade avec les associations de type one-to-many

* Charger les objets persistants
- navigation dans le graphe d'objets
- lecture par identifiant
- requêtes HQL
- requêtes par critères (QBC)
- requêtes par l'exemple (QBE)
- requêtes SQL
- les stratégies de chargement des objets(fetching)
(chargement immédiat, initialisation tardive, initialisation agressive, chargement par lot)

Mapping avancé

* Collections de valeurs
- définition des objets de valeur
- les collections set
- les collections bag
- les collections list
- les collections map
- les collections triées
- les collections ordonnées
- les collections de composants

* Mapping des associations
- les collections de type one-to-one
- les collections de type one-to-many
- les collections de type many-to-many

HQL et Criteria

* Requêtes de base
- récupérer toutes les instances d'une classe
- alias de classe
- requêtes polymorphiques
- sélection des données
- opérateurs de comparaison
- filtrage des chaînes de caractères
- opérations sur les chaînes de caractères
- opérateurs logiques
- trier les résultats

* Jointure
- les jointures implicites
- les jointures internes
- les jointures rapportées
- les jointures theta

* Projections
- définition
- instanciation dynamique
- résultats distincts

* Requêtes sur les ensembles
- fonctions d'aggrégation
- les groupements

Transaction et accès concurrent

* Propriétés d'une transaction
- les propriétés ACID

* Gestion de l'atomicité
- avec JDBC
- avec JTA
- avec Hibernate

* Gestion de l'isolation
- avec JDBC
- avec Hibernate
- choix du niveau d'isolation

* Verrouillage pessimiste
- principe
- mise en oeuvre

* Verrouillage optimiste
- principe
- mise en oeuvre

* Modes de verrouillage
- la classe LockMode

Gestion du cache

* Objectifs

* Cache de premier niveau
- principe
- controler le cache de premier niveau

* Cache de second niveau
- principe
- stratégie transactionnelle
- cache provider