Java / Java EE
1.0

Unified Modeling Language (UML)

  • Notions d’UML
    • Les éléments
      • La classe
      • L’objet
      • Les attributs
      • Les opérations
      • Attributs et opérations de classe
      • La portée
      • La responsabilité
      • Le stéréotype
      • Classe et opération abstraite
      • L’interface
    • Les relations
      • L’association
      • La dépendance
      • L’agrégation
      • La composition
      • La généralisation
      • La réalisation
    • Les diagrammes
      • Le diagramme de classes
      • Le diagramme de séquence

Introduction à Git

  • Git
    • Installation
    • Configuration
    • Initialisation d’un dépôt
    • Suivi des modifications du dépôt
    • Validation des modifications
    • Utilisation d’un dépôt distant
    • Exclusion de fichiers
    • Git Hub
    • Références
    • Exercices

Le langage Java

  • Introduction
    • L’environnement
    • Oracle JDK et Open JDK
    • Un bref historique des versions
  • Installation
    • Configuration d’Eclipse
  • Compilation & exécution
    • Un premier programme
    • La compilation
    • L’exécution
    • La liaison dynamique
    • Le classpath
    • Bibliothèques Java : les fichiers JAR
    • Création d’un projet dans Eclipse
    • Exercice
  • La structure fondamentale du langage
    • Les instructions
    • Les blocs de code
    • Les commentaires
    • Le formatage du code
    • Les conventions de nommage
    • Les mots-clés
  • Une première classe
    • Déclarer une classe
    • Anatomie d’une classe
    • Ajouter des méthodes
    • La méthode main
    • Exécuter le programme en ligne de commandes
    • Exécuter le programme depuis Eclipse
  • Les types primitifs
    • Le type booléen : boolean
    • Le type caractère : char
    • Les types entiers : byte, short, int, long
    • Les types à virgule flottante : float, double
    • Les classes enveloppes
    • L’autoboxing
  • Les opérateurs
    • L’opérateur d’affectation
    • Les opérateurs arithmétiques
    • Les opérateurs arithmétiques unaires
    • L’opérateur de concaténation de chaînes
    • Les opérateurs relationnels
    • Les opérateurs logiques
    • L’opérateur ternaire
    • Les opérateurs bitwise
    • Les opérateurs de décalage
    • Le transtypage (cast)
    • Opérateur et assignation
    • L’opérateur .
    • L’opérateur ,
  • Les structures de contrôle
    • if-else
    • return
    • while
    • do-while
    • for
    • for amélioré
    • break-continue
    • libellé
    • switch
    • Exercice
  • Les tableaux
    • Initialisation
    • Création avec new
    • Accès aux éléments d’un tableau
    • Tableau multi-dimensionnel
    • Conversion en chaîne de caractères
    • Égalité de deux tableaux
    • Tri & recherche
    • Copie d’un tableau
    • Typage d’un tableau
    • Conversion d’un tableau en liste
  • Attributs & méthodes
    • Les attributs
      • La portée
      • L’initialisation
      • attributs finaux
      • Attributs de classe
      • Attributs de classe finaux
    • Les méthodes
      • La portée
      • La valeur de retour
      • Les paramètres
      • Paramètre final
      • Les variables
      • Méthodes de classe
    • Surcharge de méthode : overloading
    • Portée des noms et this
    • Principe d’encapsulation
    • Exercice
  • Cycle de vie d’un objet
    • Le constructeur
      • Paramètres de constructeur
      • Valeur par défaut des attributs
      • Constructeur par défaut
      • Constructeur privé
      • Appel d’un constructeur dans un constructeur
      • Appel d’une méthode dans un constructeur
    • Injection de dépendances par le constructeur
    • Le bloc d’initialisation
    • Le bloc d’initialisation de classe
    • Exercice
    • Mémoire heap et stack
    • Le ramasse-miettes
    • La méthode finalize
  • Les packages
    • Déclaration d’un package
    • Sous package
    • Nom d’un package
    • Nom complet d’une classe
    • Import de noms
    • La portée de niveau package
    • Le fichier package-info.java
  • Les relations entre objets
    • L’héritage (is-a)
    • Héritage et constructeur
    • Héritage simple : Object
    • Héritage et affectation
    • Le mot-clé instanceof
    • La portée protected
    • Héritage des méthodes et attributs de classe
    • Héritage et final
    • La composition (has-a)
  • Le polymorphisme
    • Principe du polymorphisme
    • Une exception : les méthodes privées
    • Redéfinition et signature de méthode
    • Le mot-clé super
    • L’annotation @Override
    • Les méthodes de classe
    • Méthode finale
    • Constructeur et polymorphisme
    • Masquage des attributs par héritage
    • Le principe du ouvert/fermé
  • La classe Object
    • La méthode equals
    • La méthode hashCode
    • La méthode toString
    • La méthode finalize
    • La méthode clone
    • La méthode getClass
    • Les méthodes de concurrence
  • La classe String
    • String et tableau de caractères
    • Quelques méthodes utilitaires
    • Construction d’une instance de String
    • Immutabilité des chaînes de caractères
    • La classe StringBuilder
    • Formatage de texte
    • Les expressions régulières
  • Les exceptions
    • Qu’est-ce qu’une exception ?
    • Signaler une exception
    • Traiter une exception
    • Propagation d’une exception
    • Exceptions et polymorphisme
    • Le bloc finally
    • Le try-with-resources
    • Hiérarchie applicative d’exception
    • Exception cause
    • Les erreurs et les exceptions runtime
    • Choix entre checked et unchecked
  • Les classes abstraites
    • Déclarer une classe abstraite
    • Déclarer une méthode abstraite
  • Les énumérations
    • Les méthodes d’une énumération
    • Égalité entre énumérations
    • Support de switch
    • Génération d’une énumération
    • Ajout de méthodes et d’attributs
    • Ajout de constructeurs
  • Les dates
    • Date : la classe historique
    • Calendar
    • L’API Date/Time
      • Les Dates
      • La classe Instant
      • Période et durée
    • Formatage des dates
  • Les interfaces
    • Déclaration d’une interface
    • Implémentation d’une interface
    • Attributs et méthodes statiques
    • Héritage d’interface
    • Les interfaces marqueurs
    • Implémentation par défaut
    • La ségrégation d’interface
    • L’inversion de dépendance
  • Méthodes et classes génériques
    • L’exemple de la classe ArrayList
    • Création et assignation d’une classe générique
    • Notation en diamant
    • Substitution et type générique
    • Écrire une méthode générique
    • Écrire une classe générique
    • Limitations
  • Les collections
    • Les listes
      • La classe ArrayList
      • La classe LinkedList
      • La classe ArrayDeque
      • La classe PriorityQueue
      • Les classes Vector et Stack
      • Les interfaces pour les listes
    • Les ensembles (set)
      • La classe TreeSet
      • La classe HashSet
      • La classe LinkedHashSet
      • Les interfaces pour les ensembles
    • Copie d’une collection dans un tableau
    • Les tableaux associatifs (maps)
      • La classe TreeMap
      • La classe HashMap
      • La classe LinkedHashMap
      • Les classes Dictionary et Hashtable
      • Les interfaces pour les tableaux associatifs
    • La classe outil Collections
  • Les entrées/sorties
    • InputStream et classes concrètes
    • OutputStream et classes concrètes
    • Flux orientés caractères
    • Reader et classes concrètes
    • Writer et classes concrètes
    • Les décorateurs de flux
    • La classe Scanner
    • Fichiers et chemins
    • Accès au réseau
    • La sérialisation d’objets
      • Donnée transient
      • Identifiant de version de sérialisation
  • Les lambdas
    • Syntaxe des lambdas
    • Lambda et closure
    • Les interfaces fonctionnelles
    • L’opérateur :: de référence de méthode
  • Streams
    • Création d’un stream
    • La réduction
    • La collecte
    • Le filtrage
    • Le mapping
    • Le parallélisme
    • Exercice
  • Les classes internes
    • Les classes internes static
    • Les classes internes
    • Les classes anonymes
    • Accès aux éléments de l’objet englobant
    • Classe interne à une méthode
    • Interface et énumération
    • Plusieurs classes dans un même fichier
  • Les annotations
    • Utilisation des annotations
    • Déclaration d’une annotation
    • Rétention d’une annotation
    • Utilisation des annotations par introspection
    • Exercice
  • Swing : les interfaces graphiques
    • Une première application
    • Les principaux composants
    • Les layouts
      • Le BoxLayout
      • Le GridBagLayout
      • Le SpringLayout
    • Le look & feel
  • Swing : les interactions
    • Les listeners
    • Les menus
    • L’interface Action
    • Les boites de dialogue
    • Les boites de dialogues avancées
      • Boite de dialogue des fichiers
      • Boite de sélection de couleur
  • Swing : notions avancées
    • Principe du MVC
    • La classe JTable

Java EE pour le Web

  • L’environnement de développement
    • Téléchargement des outils
    • Installation des outils
    • Configuration de Java dans Eclipse
    • Intégration de Wildfly dans Eclipse
    • Accès à la console d’administration du serveur
  • Une première application
    • Qu’est-ce qu’une application Java EE ?
    • Création d’un projet dans Eclipse
    • Déploiement depuis Eclipse et test de l’application
      • Le contexte racine de déploiement (root context)
    • Packaging de l’application
  • Introduction à Maven
    • Pourquoi utiliser Maven ?
    • Caractéristiques principales de Maven
    • Installation de Maven
    • Un premier projet avec Maven
    • Le fichier pom.xml
    • Import du projet Maven dans Eclipse
    • Test de l’application dans Wildfly
    • Gérer le projet avec Maven
    • Exécution de Maven dans Eclipse
    • Exercice
  • Les Servlets
    • Structure d’une servlet HTTP
    • Configuration du déploiement d’une servlet
      • Chemin absolu d’URL dans une application Web
      • Motif d’URL d’une Servlet
    • Utilisation du fichier de déploiement web.xml
    • Exercice
  • Le conteneur Web
    • Cycle de vie des servlets
    • Exercice
    • Servlet et programmation concurrente
    • Exercice
  • Les attributs d’une application Web
    • Attribut de portée requête
    • Attribut de portée session
      • Session HTTP : comment cela marche-t-il ?
    • Les attributs de portée application
    • Exercices
  • JSP : Java Server Pages
    • Développer des JSP avec Wildfly
    • Exercice
    • EL : Expression Language
    • Les opérateurs dans l’expression language
    • Les objets implicites dans une JSP
    • La résolution de portée des attributs dans une JSP
      • Expression Language et gestion des exceptions
    • Les directives de JSP
      • La directive page
      • La directive include
    • Les balises d’action JSP
    • Les Taglibs et la JSTL
      • JSTL core
      • JSTL formater
      • JSTL functions
      • JSTL SQL
      • JSTL XML
    • Exercices
  • RequestDispatcher et MVC
    • Le request dispatcher
    • Le modèle MVC
    • Exercice
  • Web listeners et filtres
    • Les listeners Web
    • Déclaration des listeners Web
    • Exemple d’utilisation d’un listener
    • Les filtres de Servlet
    • Déclaration des filtres
    • Implémentation d’un filtre
    • Cas d’utilisation de filtres
      • Gestion de l’UTF-8
      • Génération de log
  • Java Server Faces (JSF)
    • Créer un projet avec JSF
    • La vue : facelets
    • Activer le support de JSF dans Eclipse
    • Une introduction à CDI
    • Déclarer un objet avec CDI
    • Le fichier de déploiement beans.xml
    • Le modèle
    • Le contrôleur
    • La navigation
    • La validation de formulaire
    • La validation avec Bean Validation
    • Les requêtes Ajax
    • Pour aller plus loin
  • Les API Web avec JAX-RS
    • La notion de ressource
    • Configurer une application Web pour JAX-RS
    • Implémenter des ressources avec JAX-RS
      • Les annotations de méthodes
      • Paramètre dans le chemin d’URI
    • Data binding
    • Générer une réponse
    • Gérer des exceptions
    • La validation avec Bean Validation
    • Implémenter un client HTTP

Java EE ORM

  • Accès aux bases de données : JDBC
    • Préambule : try-with-resources
    • Le pilote de base de données
    • Création d’une connexion
    • L’URL de connexion et la classe des pilotes
    • Les requêtes SQL (Statement)
    • Le Statement
    • Le ResultSet
    • Le PreparedStatement
      • L’injection SQL
    • Le CallableStatement
    • La transaction
  • Les entités JPA
    • Les ORM (Object-Relational Mapping)
    • Les entités JPA
    • L’EntityManager
      • Obtenir un EntityManager
      • Créer une fabrique d’EntityManager
    • Manipuler des entités à partir d’un EntityManager
      • La méthode persist
      • La méthode find
      • La méthode refresh
      • La méthode merge
      • La méthode detach
      • La méthode remove
  • Les requêtes JPA
    • Les requêtes Natives
    • Les requêtes JPQL
      • Les requêtes par programmation
  • L’héritage avec JPA
    • L’annotation @Inheritance
      • Héritage avec une seule table
    • Héritage avec jointure de tables
    • Héritage avec une table par classe
    • Fusion de la super classe
  • Les relations avec JPA
    • La relation 1:1 (one to one)
      • La relation n:1 (many to one)
    • La relation 1:n (one to many)
    • La relation n:n (many to many)
    • Les relations bi-directionnelles
    • La propagation en cascade
    • Fetch lazy ou fetch eager
  • JDBC dans une application Web
    • Déclaration d’une DataSource
    • Déclaration de la DataSource dans le fichier web.xml
    • Déclaration d’une DataSource dans Wildfly
      • Déploiement automatique du driver MySQL (méthode 1)
      • Ajout du driver MySQL comme nouveau module (méthode 2)
  • Les EJB
    • Le conteneur d’EJB
      • Les types d’EJB
    • Les EJB session
    • EJB session stateful
    • EJB session stateless
    • EJB session singleton
    • Accès à un EJB session
    • La gestion des transactions
      • JTA (Java Transaction API)
      • La démarcation transactionnelle
  • JPA dans une application Web
    • Obtenir un EntityManager dans un serveur Java EE
    • JPA et JTA

HTTP, REST et les API Web

  • Le protocole HTTP
    • Structure des messages
    • Exercice
    • Les codes de statut
    • Les méthodes HTTP
    • Propriétés des méthodes HTTP
    • Les en-têtes HTTP
    • Exercice
  • HTTP : les cas d’utilisation
    • Obtenir la représentation d’une ressource
    • Obtenir uniquement les meta-informations d’une ressource
    • Créer une ressource dont on connait l’URI
    • Créer une ressource dont on ne connait pas l’URI
    • Supprimer l’accès à une ressource
    • Mettre à jour une ressource
    • Mettre à jour partiellement une ressource
    • Exécuter un processus de traitement
    • Connaître les méthodes autorisées
    • Traitement asynchrone d’une requête
    • Les redirections
      • Évolution du service
      • URI volatile et canonicalisation d’URI
      • Séparer le traitement de la requête de son résultat
    • Exercice
  • HTTP : la négociation de contenu
    • La négociation de type de contenu
    • La négociation de jeu de caractères
    • La négociation de langue
    • L’en-tête Vary
    • Exercice
  • HTTP : les requêtes conditionnelles
    • Demander une représentation à jour
    • Créer une ressource si elle n’existe pas déjà
    • Altérer une ressource sous condition
    • Altérer une ressource si elle existe
    • Exercice
  • HTTP : la gestion du cache
    • Serveur d’origine et intermédiaires
    • Principe générale de la gestion du cache
    • La fraîcheur d’une réponse
    • La revalidation
    • Les directives de stratégie de cache
    • L’invalidation de cache
    • Enrichissement des en-têtes par les intermédiaires
  • HTTP : les liens
    • L’en-tête Link
    • Les types de relation
    • Les attributs optionnels d’un lien
  • REST
    • La ressource
    • URI informative ou URI opaque ?
    • Ressource contre RPC
    • La représentation
    • Les contraintes REST
      • Client/Serveur
      • Interface uniforme
      • Sans état (stateless)
      • Mise en cache (caching)
      • Layered system
      • Code on demand
    • Hypermédia
      • Les formats hypermédias
      • L’en-tête Link
      • Les apports de l’hypermédia
    • REST : ça veut dire quoi ?
    • Les API Web
    • Références
      • Sites Web & articles
      • Livres
      • Applications de démo
    • Exercices
Java / Java EE
  • Docs »
  • Recherche

© Copyright David Gayerie - david.gayerie.epsi@mailoo.org - CC-BY-SA.