Développons en Java
v 2.20   Copyright (C) 1999-2019 .   
    Imprimer Index Index avec sommaire Télécharger le PDF


Développons en Java
  

Préambule
  
   A propos de ce document
   Remerciements
   Notes de licence
   Marques déposées
   Historique des versions

Partie 1 : Les bases du langage Java
  

1. Présentation de Java
  introduit le langage Java en présentant les différentes éditions et versions du JDK, les caractéristiques du langage et décrit l'installation du JDK
  1.1. Les caractéristiques
  1.2. Les logos de Java
  1.3. Un rapide historique de Java
  1.4. Les différentes éditions et versions de Java
  1.5. Un rapide tour d'horizon des API et de quelques outils
  1.6. Les différences entre Java et JavaScript
  1.7. L'installation du JDK

2. Les notions et techniques de base en Java
  présente rapidement quelques notions de base et comment compiler et exécuter une application
  2.1. Les concepts de base
  2.2. L'exécution d'une applet

3. La syntaxe et les éléments de bases de Java
  explore les éléments du langage d'un point de vue syntaxique
  3.1. Les règles de base
  3.2. Les mots réservés du langage Java
  3.3. Les identifiants
  3.4. Les commentaires
  3.5. La déclaration et l'utilisation de variables
  3.6. Les opérations arithmétiques
  3.7. La priorité des opérateurs
  3.8. Les structures de contrôles
  3.9. Les tableaux
  3.10. Les conversions de types
  3.11. La manipulation des chaînes de caractères

4. La programmation orientée objet
  explore comment Java utilise et permet d'utiliser la programmation orientée objet
  4.1. Le concept de classe
  4.2. Les objets
  4.3. Les modificateurs d'accès
  4.4. Les propriétés ou attributs
  4.5. Les méthodes
  4.6. L'héritage
  4.7. Les packages
  4.8. Les classes internes
  4.9. La gestion dynamique des objets

5. Les packages de bases
  propose une présentation rapide des principales API fournies avec le JDK
  5.1. Les packages selon la version du JDK
  5.2. Le package java.lang
  5.3. La présentation rapide du package awt java
  5.4. La présentation rapide du package java.io
  5.5. Le package java.util
  5.6. La présentation rapide du package java.net
  5.7. La présentation rapide du package java.applet

6. Les fonctions mathématiques
  indique comment utiliser les fonctions mathématiques
  6.1. Les variables de classe
  6.2. Les fonctions trigonométriques
  6.3. Les fonctions de comparaisons
  6.4. Les arrondis
  6.5. La méthode IEEEremainder(double, double)
  6.6. Les Exponentielles et puissances
  6.7. La génération de nombres aléatoires
  6.8. La classe BigDecimal

7. La gestion des exceptions
  explore la faculté qu'a Java de traiter et gérer les anomalies qui surviennent lors de l'exécution du code
  7.1. Les mots clés try, catch et finally
  7.2. La classe Throwable
  7.3. Les classes Exception, RunTimeException et Error
  7.4. Les exceptions personnalisées
  7.5. Les exceptions chaînées
  7.6. L'utilisation des exceptions

8. JDK 1.5 (nom de code Tiger)
  détaille les nouvelles fonctionnalités du langage de la version 1.5
  8.1. Les nouveautés du langage Java version 1.5
  8.2. L'autoboxing (boxing/unboxing)
  8.3. Les importations statiques
  8.4. Les annotations ou métadonnées (Meta Data)
  8.5. Les arguments variables (varargs)
  8.6. Les generics
  8.7. Les boucles pour le parcours des collections
  8.8. Les énumérations (type enum)

9. Les annotations
  présente les annotations qui sont des métadonnées insérées dans le code source et leurs mises en oeuvre.
  9.1. La présentation des annotations
  9.2. La mise en oeuvre des annotations
  9.3. L'utilisation des annotations
  9.4. Les annotations standard
  9.5. Les annotations communes (Common Annotations)
  9.6. Les annotations personnalisées
  9.7. L'exploitation des annotations
  9.8. L'API Pluggable Annotation Processing
  9.9. Les ressources relatives aux annotations

10. Java SE 7, le projet Coin
  ce chapitre décrit les changements syntaxiques proposés par le projet Coin dans Java SE 7
  10.1. Les entiers exprimés en binaire (Binary Literals)
  10.2. Utilisation des underscores dans les entiers littéraux
  10.3. Utilisation des strings dans l'instruction switch
  10.4. L'opérateur diamant
  10.5. L'instruction try-with-resources
  10.6. Des types plus précis lorsqu'une exception est relevée dans une clause catch
  10.7. Multiples exceptions dans une clause catch

11. Les expressions lambda
  ce chapitre détaille l'utilisation des expressions lambda et des références de méthodes et constructeurs.
  11.1. L'historique des lambdas pour Java
  11.2. Les expressions lambda
  11.3. Les références de méthodes
  11.4. Les interfaces fonctionnelles

Partie 2 : Les API de base
  

12. Les collections
  propose une revue des classes fournies par le JDK pour gérer des ensembles d'objets
  12.1. Présentation du framework collection
  12.2. Les interfaces des collections
  12.3. Les collections de type List : les listes
  12.4. Les collections de type Set : les ensembles
  12.5. Les collections de type Map : les associations de type clé/valeur
  12.6. Les collections de type Queue : les files
  12.7. Le tri des collections
  12.8. Les algorithmes
  12.9. Les exceptions du framework

13. Les flux d'entrée/sortie
  explore les classes utiles à la mise en oeuvre d'un des mécanismes de base pour échanger des données
  13.1. La présentation des flux
  13.2. Les classes de gestion des flux
  13.3. Les flux de caractères
  13.4. Les flux d'octets
  13.5. La classe File
  13.6. Les fichiers à accès direct
  13.7. La classe java.io.Console

14. NIO 2
  détaille l'API FileSystem qui facilite l'utilisation de systèmes de fichiers
  14.1. Les entrées/sorties avec Java
  14.2. Les principales classes et interfaces
  14.3. L'interface Path
  14.4. Glob
  14.5. La classe Files
  14.6. Le parcours du contenu de répertoires
  14.7. L'utilisation de systèmes de gestion de fichiers
  14.8. La lecture et l'écriture dans un fichier
  14.9. Les liens et les liens symboliques
  14.10. La gestion des attributs
  14.11. La gestion des unités de stockages
  14.12. Les notifications de changements dans un répertoire
  14.13. La gestion des erreurs et la libération des ressources
  14.14. L'interopérabilité avec le code existant

15. La sérialisation
  ce procédé offre un mécanisme standard pour transformer l'état d'un objet en un flux de données qui peut être rendu persistant ou échangé sur le réseau pour permettre de recréer un objet possédant le même état.
  15.1. La sérialisation standard
  15.2. La documentation d'une classe sérialisable
  15.3. La sérialisation et la sécurité
  15.4. La sérialisation en XML

16. L'interaction avec le réseau
  propose un aperçu des API fournies par Java pour utiliser les fonctionnalités du réseau dans les applications
  16.1. L'introduction aux concepts liés au réseau
  16.2. Les adresses internet
  16.3. L'accès aux ressources avec une URL
  16.4. L'utilisation du protocole TCP
  16.5. L'utilisation du protocole UDP
  16.6. Les exceptions liées au réseau
  16.7. Les interfaces de connexions au réseau

17. L'internationalisation
  traite d'une façon pratique de la possibilité d'internationaliser une application
  17.1. Les objets de type Locale
  17.2. La classe ResourceBundle
  17.3. Un guide pour réaliser la localisation

18. Les composants Java beans
  examine comment développer et utiliser des composants réutilisables
  18.1. La présentation des Java beans
  18.2. Les propriétés.
  18.3. Les méthodes
  18.4. Les événements
  18.5. L'introspection
  18.6. Paramétrage du bean ( Customization )
  18.7. La persistance
  18.8. La diffusion sous forme de jar

19. Le logging
  indique comment mettre en oeuvre deux API pour la gestion des logs : Log4J du projet open source Jakarta et l'API Logging du JDK 1.4
  19.1. La présentation du logging
  19.2. Log4j
  19.3. L'API logging
  19.4. Jakarta Commons Logging (JCL)
  19.5. D'autres API de logging

20. L'API Stream
  L'API Stream permet au travers d'un approche fonctionnelle de manipuler des données d'une source dans le but de produire un résultat. Les traitements sont exprimés de manière déclarative et peuvent être exécutés au besoin en parallèle.
  20.1. Le besoin de l'API Stream
  20.2. Le pipeline d'opérations d'un Stream
  20.3. Les opérations intermédiaires
  20.4. Les opérations terminales
  20.5. Les Collectors
  20.6. Les Streams pour des données primitives
  20.7. L'utilisation des Streams avec les opérations I/O
  20.8. Le traitement des opérations en parallèle
  20.9. Les optimisations réalisées par l'API Stream
  20.10. Les Streams infinis
  20.11. Le débogage d'un Stream
  20.12. Les limitations de l'API Stream
  20.13. Quelques recommandations sur l'utilisation de l'API Stream

Partie 3 : Les API avancées
  

21. La gestion dynamique des objets et l'introspection
  ces mécanismes permettent dynamiquement de connaître le contenu d'une classe et de l'utiliser
  21.1. La classe Class
  21.2. La recherche des informations sur une classe
  21.3. La définition dynamique d'objets
  21.4. L'invocation dynamique d'une méthode
  21.5. L'API Reflection et le SecurityManager
  21.6. L'utilisation de l'API Reflection sur les annotations

22. L'appel de méthodes distantes : RMI
  étudie la mise en oeuvre de la technologie RMI pour permettre l'appel de méthodes distantes
  22.1. La présentation et l'architecture de RMI
  22.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI
  22.3. Le développement coté serveur
  22.4. Le développement coté client
  22.5. La génération de la classe stub
  22.6. La mise en oeuvre des objets RMI

23. La sécurité
  partie intégrante de Java, elle revêt de nombreux aspects dans les spécifications, la gestion des droits d'exécution et plusieurs API dédiées
  23.1. La sécurité dans les spécifications du langage
  23.2. Le contrôle des droits d'une application
  23.3. La cryptographie
  23.4. JCA (Java Cryptography Architecture) et JCE (Java Cryptography Extension)
  23.5. JSSE (Java Secure Sockets Extension)
  23.6. JAAS (Java Authentication and Authorization Service)

24. JCA (Java Cryptography Architecture)
  détaille l'utilisation de l'API proposant des fonctionnalités cryptographiques de base
  24.1. L'architecture de JCA
  24.2. Les classes et interfaces de JCA
  24.3. Les fournisseurs d'implémentations
  24.4. La classe java.security.Provider
  24.5. La classe java.security.Security
  24.6. La classe java.security.MessageDigest
  24.7. Les classes java.security.DigestInputStream et java.security.DigestOuputStream
  24.8. La classe java.security.Signature
  24.9. La classe java.security.KeyStore
  24.10. Les interfaces de type java.security.Key
  24.11. La classe java.security.KeyPair
  24.12. La classe java.security.KeyPairGenerator
  24.13. La classe java.security.KeyFactory
  24.14. La classe java.security.SecureRandom
  24.15. La classe java.security.AlgorithmParameters
  24.16. La classe java.security.AlgorithmParameterGenerator
  24.17. La classe java.security.cert.CertificateFactory
  24.18. L'interface java.security.spec.KeySpec et ses implémentations
  24.19. La classe java.security.spec.EncodedKeySpec et ses sous-classes
  24.20. L'interface java.security.spec.AlgorithmParameterSpec

25. JCE (Java Cryptography Extension)
  détaille l'API pour l'encryptage et le décryptage, la génération de clés et l'authentification de messages avec des algorithmes de type MAC
  25.1. La classe javax.crypto.KeyGenerator
  25.2. La classe javax.crypto.SecretKeyFactory
  25.3. La classe javax.crypto.Cipher
  25.4. Les classes javax.crypto.CipherInputStream et javax.crypto.CipherOutputStream
  25.5. La classe javax.crypto.SealedObject
  25.6. La classe javax.crypto.Mac

26. JNI (Java Native Interface)
  technologie qui permet d'utiliser du code natif dans une classe Java et vice versa
  26.1. La déclaration et l'utilisation d'une méthode native
  26.2. La génération du fichier d'en-tête
  26.3. L'écriture du code natif en C
  26.4. Le passage de paramètres et le renvoi d'une valeur (type primitif)
  26.5. Le passage de paramètres et le renvoi d'une valeur (type objet)

27. JNDI (Java Naming and Directory Interface)
  introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
  27.1. La présentation de JNDI
  27.2. La mise en oeuvre de l'API JNDI
  27.3. L'utilisation d'un service de nommage
  27.4. L'utilisation avec un DNS
  27.5. L'utilisation du File System Context Provider
  27.6. LDAP
  27.7. L'utilisation avec un annuaire LDAP
  27.8. JNDI et J2EE/Java EE

28. Le scripting
  L'utilisation d'outils de scripting avec Java a longtemps été possible au travers de produits open source. Depuis la version 6.0 de Java, une API standard est proposée.
  28.1. L'API Scripting

29. JMX (Java Management Extensions)
  ce chapitre détaille l'utilisation de JMX. C'est une spécification qui définit une architecture, une API et des services pour permettre de surveiller et de gérer des ressources en Java
  29.1. La présentation de JMX
  29.2. L'architecture de JMX
  29.3. Un premier exemple
  29.4. La couche instrumentation : les MBeans
  29.5. Les MBeans standard
  29.6. La couche agent
  29.7. Les services d'un agent JMX
  29.8. La couche services distribués
  29.9. Les notifications
  29.10. Les Dynamic MBeans
  29.11. Les Model MBeans
  29.12. Les Open MBeans
  29.13. Les MXBeans
  29.14. L'interface PersistentMBean
  29.15. Le monitoring d'une JVM
  29.16. Des recommandations pour l'utilisation de JMX
  29.17. Des ressources

Partie 4 : La programmation parallèle et concurrente
  

30. Le multitâche
  décrit les principaux fondamentaux des traitements multitaches et de leurs mises en oeuvre avec Java

31. Les threads
  présente et met en oeuvre les mécanismes des threads qui permettent de répartir différents traitements d'un même programme en plusieurs unités distinctes exécutées de manière "simultanée"
  31.1. L'interface Runnable
  31.2. La classe Thread
  31.3. Le cycle de vie d'un thread
  31.4. Les démons (daemon threads)
  31.5. Les groupes de threads
  31.6. L'obtention d'informations sur un thread
  31.7. La manipulation des threads
  31.8. Les messages de synchronisation entre threads
  31.9. Les restrictions sur les threads
  31.10. Les threads et les classloaders
  31.11. Les threads et la gestion des exceptions
  31.12. Les piles

32. L'association de données à des threads
  détaille les solutions utilisables pour permettre d'associer des données à un thread
  32.1. La classe ThreadLocal
  32.2. La classe InheritableThreadLocal
  32.3. La classe ThreadLocalRandom

33. Le framework Executor
  détaille l'utilisation du framework Executor
  33.1. L'interface Executor
  33.2. Les pools de threads
  33.3. L'interface java.util.concurrent.Callable
  33.4. L'interface java.util.concurrent.Future
  33.5. L'interface java.util.concurrent.CompletionService

34. La gestion des accès concurrents
  détaille différentes solutions pour gérer les accès concurrents dans les traitements en parallèle
  34.1. Le mot clé volatile
  34.2. Les races conditions
  34.3. La synchronisation avec les verrous
  34.4. Les opérations atomiques
  34.5. L'immutabilité et la copie défensive

Partie 5 : Le développement des interfaces graphiques
  

35. Le graphisme
  entame une série de chapitres sur les interfaces graphiques en détaillant les objets et méthodes de base pour le graphisme
  35.1. Les opérations sur le contexte graphique

36. Les éléments d'interfaces graphiques de l'AWT
  recense les différents composants qui sont fournis dans la bibliothèque AWT
  36.1. Les composants graphiques
  36.2. La classe Component
  36.3. Les conteneurs
  36.4. Les menus
  36.5. La classe java.awt.Desktop

37. La création d'interfaces graphiques avec AWT
  indique comment réaliser des interfaces graphiques avec l'AWT
  37.1. Le dimensionnement des composants
  37.2. Le positionnement des composants
  37.3. La création de nouveaux composants à partir de Panel
  37.4. L'activation ou la désactivation des composants

38. L'interception des actions de l'utilisateur
  détaille les mécanismes qui permettent de réagir aux actions de l'utilisateur via une interface graphique
  38.1. L'interception des actions de l'utilisateur avec Java version 1.0
  38.2. L'interception des actions de l'utilisateur avec Java version 1.1

39. Le développement d'interfaces graphiques avec SWING
  indique comment réaliser des interfaces graphiques avec Swing
  39.1. La présentation de Swing
  39.2. Les packages Swing
  39.3. Un exemple de fenêtre autonome
  39.4. Les composants Swing
  39.5. Les boutons
  39.6. Les composants de saisie de texte
  39.7. Les onglets
  39.8. Le composant JTree
  39.9. Les menus
  39.10. L'affichage d'une image dans une application.

40. Le développement d'interfaces graphiques avec SWT
  indique comment réaliser des interfaces graphiques avec SWT
  40.1. La présentation de SWT
  40.2. Un exemple très simple
  40.3. La classe SWT
  40.4. L'objet Display
  40.5. L'objet Shell
  40.6. Les composants
  40.7. Les conteneurs
  40.8. La gestion des erreurs
  40.9. Le positionnement des contrôles
  40.10. La gestion des événements
  40.11. Les boîtes de dialogue

41. JFace
  présente l'utilisation de ce framework facilitant le développement d'applications utilisant SWT
  41.1. La présentation de JFace
  41.2. La structure générale d'une application
  41.3. Les boites de dialogue

Partie 6 : L'utilisation de documents XML et JSON
  

42. Java et XML
  présente XML qui s'est imposée pour les échanges de données et explore les API Java pour utiliser XML
  42.1. La présentation de XML
  42.2. Les règles pour formater un document XML
  42.3. La DTD (Document Type Definition)
  42.4. Les parseurs
  42.5. La génération de données au format XML
  42.6. JAXP : Java API for XML Parsing
  42.7. Jaxen

43. SAX (Simple API for XML)
  présente l'utilisation de l'API SAX avec Java. Cette API utilise des événements pour traiter un document XML
  43.1. L'utilisation de SAX de type 1
  43.2. L'utilisation de SAX de type 2

44. DOM (Document Object Model)
  présente l'utilisation avec Java de cette spécification du W3C pour proposer une API qui permet de modéliser, de parcourir et de manipuler un document XML
  44.1. Les interfaces du DOM
  44.2. L'obtention d'un arbre DOM
  44.3. Le parcours d'un arbre DOM
  44.4. La modification d'un arbre DOM
  44.5. L'envoi d'un arbre DOM dans un flux

45. XSLT (Extensible Stylesheet Language Transformations)
  présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
  45.1. XPath
  45.2. La syntaxe de XSLT
  45.3. Un exemple avec Internet Explorer
  45.4. Un exemple avec Xalan 2

46. Les modèles de documents
  présente quelques API open source spécifiques à Java pour traiter un document XML : JDom et Dom4J
  46.1. L'API JDOM
  46.2. dom4j

47. JAXB (Java Architecture for XML Binding)
  détaille l'utilisation de cette spécification qui permet de faire correspondre un document XML à un ensemble de classes et vice versa.
  47.1. JAXB 1.0
  47.2. JAXB 2.0

48. StAX (Streaming Api for XML)
  détaille l'utilisation de cette API qui permet de traiter un document XML de façon simple en consommant peu de mémoire tout en permettant de garder le contrôle sur les opérations d'analyse ou d'écriture
  48.1. La présentation de StAX
  48.2. Les deux API de StAX
  48.3. Les fabriques
  48.4. Le traitement d'un document XML avec l'API du type curseur
  48.5. Le traitement d'un document XML avec l'API du type itérateur
  48.6. La mise en oeuvre des filtres
  48.7. L'écriture un document XML avec l'API de type curseur
  48.8. L'écriture un document XML avec l'API de type itérateur
  48.9. La comparaison entre SAX, DOM et StAX

49. JSON
  présente le format JSON
  49.1. La syntaxe de JSON
  49.2. L'utilisation de JSON
  49.3. JSON ou XML

50. Gson
  Présente l'API Gson de Google pour la lecture et la génération de documents JSON
  50.1. La classe Gson
  50.2. La sérialisation
  50.3. La désérialisation
  50.4. La personnalisation de la sérialisation/désérialisation
  50.5. Les annotations de Gson
  50.6. L'API Streaming
  50.7. Mixer l'utilisation du model objets et de l'API Streaming
  50.8. Les concepts avancés

51. JSON-P (Java API for JSON Processing)
  détaille l'utilisation de l'API JSON-P spécifiée dans la JSR 353
  51.1. La classe Json
  51.2. L'API Streaming
  51.3. L'API Object Model

52. JSON-B (Java API for JSON Binding)
  détaille l'utilisation de l'API JSON-B qui propose une API standard pour permettre de convertir un document JSON en objet Java et vice versa
  52.1. La sérialisation/désérialisation d'un objet
  52.2. Le moteur JSON-B
  52.3. Le mapping par défaut
  52.4. La configuration du moteur JSON-B
  52.5. La personnalisation du mapping

Partie 7 : L'accès aux bases de données
  

53. La persistance des objets
  expose les difficultés liées à la persistance des objets vis à vis du modèle relationnel et présente rapidement des solutions architecturales et techniques (API standards et open source)
  53.1. La correspondance entre les modèles relationnel et objet
  53.2. L'évolution des solutions de persistance avec Java
  53.3. Le mapping O/R (objet/relationnel)
  53.4. L'architecture et la persistance de données
  53.5. Les différentes solutions
  53.6. Les API standards
  53.7. Les frameworks open source
  53.8. L'utilisation de procédures stockées

54. JDBC (Java DataBase Connectivity)
  indique comment utiliser cette API historique pour accéder aux bases de données
  54.1. Les outils nécessaires pour utiliser JDBC
  54.2. Les types de pilotes JDBC
  54.3. L'enregistrement d'une base de données dans ODBC sous Windows 9x ou XP
  54.4. La présentation des classes de l'API JDBC
  54.5. La connexion à une base de données
  54.6. L'accès à la base de données
  54.7. L'obtention d'informations sur la base de données
  54.8. L'utilisation d'un objet de type PreparedStatement
  54.9. L'utilisation des transactions
  54.10. Les procédures stockées
  54.11. Le traitement des erreurs JDBC
  54.12. JDBC 2.0
  54.13. JDBC 3.0
  54.14. MySQL et Java
  54.15. L'amélioration des performances avec JDBC
  54.16. Les ressources relatives à JDBC

55. JDO (Java Data Object)
  API qui standardise et automatise le mapping entre des objets Java et un système de gestion de données
  55.1. La présentation de JDO
  55.2. Un exemple avec Lido
  55.3. L'API JDO
  55.4. La mise en oeuvre
  55.5. Le parcours de toutes les occurrences
  55.6. La mise en oeuvre de requêtes

56. Hibernate
  présente Hibernate, un framework de mapping Objets/Relationnel open source
  56.1. La création d'une classe qui va encapsuler les données
  56.2. La création d'un fichier de correspondance
  56.3. Les propriétés de configuration
  56.4. L'utilisation d'Hibernate
  56.5. La persistance d'une nouvelle occurrence
  56.6. L'obtention d'une occurrence à partir de son identifiant
  56.7. L'obtention de données
  56.8. La mise à jour d'une occurrence
  56.9. La suppression d'une ou plusieurs occurrences
  56.10. Les relations
  56.11. Le mapping de l'héritage de classes
  56.12. Les caches d'Hibernate
  56.13. Les outils de génération de code

57. JPA (Java Persistence API)
  JPA est la spécification de l'API standard dans le domaine du mapping O/R utilisable avec Java EE mais aussi avec Java SE à partir de la version 5.
  57.1. L'installation de l'implémentation de référence
  57.2. Les entités
  57.3. Le fichier de configuration du mapping
  57.4. L'utilisation du bean entité
  57.5. Le fichier persistence.xml
  57.6. La gestion des transactions hors Java EE
  57.7. La gestion des relations entre tables dans le mapping
  57.8. Le mapping de l'héritage de classes
  57.9. Les callbacks d'événements

Partie 8 : La machine virtuelle Java (JVM)
  

58. La JVM (Java Virtual Machine)
  ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
  58.1. La mémoire de la JVM
  58.2. Le cycle de vie d'une classe dans la JVM
  58.3. Les ClassLoaders
  58.4. Le bytecode
  58.5. Le compilateur JIT
  58.6. Les paramètres de la JVM HotSpot
  58.7. Les interactions de la machine virtuelle avec des outils externes
  58.8. Service Provider Interface (SPI)
  58.9. Les JVM 32 et 64 bits

59. La gestion de la mémoire
  ce chapitre détaille la gestion de la mémoire dans la JVM et notamment les concepts et le paramétrage du ramasse-miettes.
  59.1. Le ramasse-miettes (Garbage Collector ou GC)
  59.2. Le fonctionnement du ramasse-miettes de la JVM Hotspot
  59.3. Le paramétrage du ramasse-miettes de la JVM HotSpot
  59.4. Le monitoring de l'activité du ramasse-miettes
  59.5. Les différents types de référence
  59.6. L'obtention d'informations sur la mémoire de la JVM
  59.7. Les fuites de mémoire (Memory leak)
  59.8. Les exceptions liées à un manque de mémoire

60. La décompilation et l'obfuscation
  ce chapitre présente la décompilation qui permet de transformer du bytecode en code source et l'obfuscation qui est l'opération permettant de limiter cette transformation.
  60.1. Décompiler du bytecode
  60.2. Obfusquer le bytecode

61. Programmation orientée aspects (AOP)
  ce chapitre présente le concept de l'AOP (Apsect Oriented Programming
  61.1. Le besoin d'un autre modèle de programmation
  61.2. Les concepts de l'AOP
  61.3. La mise en oeuvre de l'AOP
  61.4. Les avantages et les inconvénients
  61.5. Des exemples d'utilisation
  61.6. Des implémentations pour la plate-forme Java

62. Terracotta
  Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
  62.1. La présentation de Terrocatta
  62.2. Les concepts utilisés
  62.3. La mise en oeuvre des fonctionnalités
  62.4. Les cas d'utilisation
  62.5. Quelques exemples de mise en oeuvre
  62.6. La console développeur
  62.7. Le fichier de configuration
  62.8. La fiabilisation du cluster
  62.9. Quelques recommandations

Partie 9 : Le développement d'applications d'entreprises
  

63. J2EE / Java EE
  introduit la plate-forme Java 2 Entreprise Edition
  63.1. La présentation de J2EE
  63.2. Les API de J2EE
  63.3. L'environnement d'exécution des applications J2EE
  63.4. L'assemblage et le déploiement d'applications J2EE
  63.5. J2EE 1.4 SDK
  63.6. La présentation de Java EE 5.0
  63.7. La présentation de Java EE 6
  63.8. La présentation de Java EE 7

64. JavaMail
  traite de l'API qui permet l'envoi et la réception d'e-mails
  64.1. Le téléchargement et l'installation
  64.2. Les principaux protocoles
  64.3. Les principales classes et interfaces de l'API JavaMail
  64.4. L'envoi d'un e-mail par SMTP
  64.5. La récupération des messages d'un serveur POP3
  64.6. Les fichiers de configuration

65. JMS (Java Message Service)
  indique comment utiliser cette API qui permet l'échange de données entre applications grâce à un système de messages
  65.1. La présentation de JMS
  65.2. Les services de messages
  65.3. Le package javax.jms
  65.4. L'utilisation du mode point à point (queue)
  65.5. L'utilisation du mode publication/abonnement (publish/subscribe)
  65.6. La gestion des erreurs
  65.7. JMS 1.1
  65.8. Les ressources relatives à JMS

66. Les EJB (Entreprise Java Bean)
  propose une présentation de l'API et les spécifications pour des objets chargés de contenir les règles métiers
  66.1. La présentation des EJB
  66.2. Les EJB session
  66.3. Les EJB entité
  66.4. Les outils pour développer et mettre en oeuvre des EJB
  66.5. Le déploiement des EJB
  66.6. L'appel d'un EJB par un client
  66.7. Les EJB orientés messages

67. Les EJB 3
  ce chapitre détaille la version 3 des EJB qui est une évolution majeure de cette technologie car elle met l'accent sur la facilité de développement sans sacrifier les fonctionnalités qui font la force des EJB.
  67.1. L'historique des EJB
  67.2. Les nouveaux concepts et fonctionnalités utilisés
  67.3. EJB 2.x vs EJB 3.0
  67.4. Les conventions de nommage
  67.5. Les EJB de type Session
  67.6. Les EJB de type Entity
  67.7. Un exemple simple complet
  67.8. L'utilisation des EJB par un client
  67.9. L'injection de dépendances
  67.10. Les intercepteurs
  67.11. Les EJB de type MessageDriven
  67.12. Le packaging des EJB
  67.13. Les transactions
  67.14. La mise en oeuvre de la sécurité

68. Les EJB 3.1
  ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
  68.1. Les interfaces locales sont optionnelles
  68.2. Les EJB Singleton
  68.3. EJB Lite
  68.4. La simplification du packaging
  68.5. Les améliorations du service Timer
  68.6. La standardisation des noms JNDI
  68.7. L'invocation asynchrone des EJB session
  68.8. L'invocation d'un EJB hors du conteneur

69. Les services web de type Soap
  permettent l'appel de services distants en utilisant un protocole de communication et une structuration des données échangées avec XML de façon standardisée
  69.1. La présentation des services web
  69.2. Les standards
  69.3. Les différents formats de services web SOAP
  69.4. Des conseils pour la mise en oeuvre
  69.5. Les API Java pour les services web
  69.6. Les implémentations des services web
  69.7. Inclure des pièces jointes dans SOAP
  69.8. WS-I
  69.9. Les autres spécifications

70. Les WebSockets
  présente le procotole WebSocket
  70.1. Les limitations du protocole HTTP
  70.2. La spécification du protocole WebSocket
  70.3. La connexion à une WebSocket
  70.4. La mise en oeuvre des WebSockets

71. L'API WebSocket
  détaille l'utilisation de l'API Java API for WebSocket spécifiée par la JSR 356
  71.1. Les principales classes et interfaces
  71.2. Le développement d'un endpoint
  71.3. Les encodeurs et les décodeurs
  71.4. Le débogage des WebSockets
  71.5. Des exemples d'utilisation
  71.6. L'utilisation d'implémentations

Partie 10 : Le développement d'applications web
  

72. Les servlets
  plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
  72.1. La présentation des servlets
  72.2. L'API servlet
  72.3. Le protocole HTTP
  72.4. Les servlets http
  72.5. Les informations sur l'environnement d'exécution des servlets
  72.6. L'utilisation des cookies
  72.7. Le partage d'informations entre plusieurs échanges HTTP
  72.8. Packager une application web
  72.9. L'utilisation de Log4J dans une servlet

73. Les JSP (Java Server Pages)
  poursuit la discussion sur les servlets en explorant un mécanisme basé sur celles-ci pour réaliser facilement des pages web dynamiques
  73.1. La présentation des JSP
  73.2. Les outils nécessaires
  73.3. Le code HTML
  73.4. Les Tags JSP
  73.5. Un exemple très simple
  73.6. La gestion des erreurs
  73.7. Les bibliothèques de tags personnalisés (custom taglibs)

74. JSTL (Java server page Standard Tag Library)
  est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
  74.1. Un exemple simple
  74.2. Le langage EL (Expression Language)
  74.3. La bibliothèque Core
  74.4. La bibliothèque XML
  74.5. La bibliothèque I18n
  74.6. La bibliothèque Database

75. Struts
  présente et détaille la mise en oeuvre du framework open source de développement d'applications web le plus populaire
  75.1. L'installation et la mise en oeuvre
  75.2. Le développement des vues
  75.3. La configuration de Struts
  75.4. Les bibliothèques de tags personnalisés
  75.5. La validation de données

76. JSF (Java Server Faces)
  détaille l'utilisation de la technologie Java Server Faces (JSF) dont le but est de proposer un framework qui facilite et standardise le développement d'applications web avec Java.
  76.1. La présentation de JSF
  76.2. Le cycle de vie d'une requête
  76.3. Les implémentations
  76.4. Le contenu d'une application
  76.5. La configuration de l'application
  76.6. Les beans
  76.7. Les composants pour les interfaces graphiques
  76.8. La bibliothèque de tags Core
  76.9. La bibliothèque de tags Html
  76.10. La gestion et le stockage des données
  76.11. La conversion des données
  76.12. La validation des données
  76.13. La sauvegarde et la restauration de l'état
  76.14. Le système de navigation
  76.15. La gestion des événements
  76.16. Le déploiement d'une application
  76.17. Un exemple d'application simple
  76.18. L'internationalisation
  76.19. Les points faibles de JSF

77. D'autres frameworks pour les applications web
  présente rapidement quelques frameworks open source pour le développement d'applications web
  77.1. Les frameworks pour les applications web
  77.2. Les moteurs de templates

Partie 11 : Le développement d'applications RIA / RDA
  

78. Les applications riches de type RIA et RDA
  présente les caractéristiques des applications riches et les principales solutions qui permettent de les développer.
  78.1. Les applications de type RIA
  78.2. Les applications de type RDA
  78.3. Les contraintes
  78.4. Les solutions RIA
  78.5. Les solutions RDA

79. Les applets
  plonge au coeur des premières applications qui ont rendu Java célèbre
  79.1. L'intégration d'applets dans une page HTML
  79.2. Les méthodes des applets
  79.3. Les interfaces utiles pour les applets
  79.4. La transmission de paramètres à une applet
  79.5. Les applets et le multimédia
  79.6. Une applet pouvant s'exécuter comme une application
  79.7. Les droits des applets

80. Java Web Start (JWS)
   est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
  80.1. La création du package de l'application
  80.2. La signature d'un fichier jar
  80.3. Le fichier JNLP
  80.4. La configuration du serveur web
  80.5. Le fichier HTML
  80.6. Le test de l'application
  80.7. L'utilisation du gestionnaire d'applications
  80.8. L'API de Java Web Start

81. AJAX
  présente ce concept qui permet de rendre les applications web plus conviviales et plus dynamiques. Le framework open source DWR est aussi détaillé.
  81.1. La présentation d'AJAX
  81.2. Le détail du mode de fonctionnement
  81.3. Un exemple simple
  81.4. Des frameworks pour mettre en oeuvre AJAX

82. GWT (Google Web Toolkit)
  GWT est un framework pour le développement d'applications de type RIA
  82.1. La présentation de GWT
  82.2. La création d'une application
  82.3. Les modes d'exécution
  82.4. Les éléments de GWT
  82.5. L'interface graphique des applications GWT
  82.6. La personnalisation de l'interface
  82.7. Les composants (widgets)
  82.8. Les panneaux (panels)
  82.9. La création d'éléments réutilisables
  82.10. Les événements
  82.11. JSNI
  82.12. La configuration et l'internationalisation
  82.13. L'appel de procédures distantes (Remote Procedure Call)
  82.14. La manipulation des documents XML
  82.15. La gestion de l'historique sur le navigateur
  82.16. Les tests unitaires
  82.17. Le déploiement d'une application
  82.18. Des composants tiers
  82.19. Les ressources relatives à GWT

Partie 12 : Le développement d'applications avec Spring
  

83. Spring
  ce chapitre est une présentation générale de Spring
  83.1. Le but et les fonctionnalités proposées par Spring
  83.2. L'historique de Spring
  83.3. Spring Framework
  83.4. Les projets du portfolio Spring
  83.5. Les avantages et les inconvénients de Spring
  83.6. Spring et Java EE

84. Spring Core
  ce chapitre détaille la configuration et la mise en oeuvre du conteneur Spring qui gère le cycle de vie des beans
  84.1. Les fondements de Spring
  84.2. Le conteneur Spring
  84.3. Le fichier de configuration
  84.4. L'injection de dépendances
  84.5. Spring Expression Langage (SpEL)
  84.6. La configuration en utilisant les annotations
  84.7. Le scheduling

85. La mise en oeuvre de l'AOP avec Spring
  présente la mise en oeuvre de l'AOP avec Spring
  85.1. Spring AOP
  85.2. AspectJ
  85.3. Spring AOP et AspectJ
  85.4. L'utilisation des namespaces

86. La gestion des transactions avec Spring
  ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
  86.1. La gestion des transactions par Spring
  86.2. La propagation des transactions
  86.3. L'utilisation des transactions de manière déclarative
  86.4. La déclaration des transactions avec des annotations
  86.5. La gestion du rollback des transactions
  86.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
  86.7. L'utilisation des transactions via l'API
  86.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

87. Spring et JMS
  ce chapitre couvre la mise en oeuvre de JMS dans Spring
  87.1. Les packages de Spring JMS
  87.2. La classe JmsTemplate : le template JMS de Spring
  87.3. La réception asynchrone de messages
  87.4. L'espace de nommage jms

88. Spring et JMX
  ce chapitre détaille la façon dont Spring facilite la mise en oeuvre de JMX
  88.1. L'enregistrement d'un bean en tant que MBean
  88.2. Le nommage des MBeans
  88.3. Les Assembler
  88.4. L'utilisation des annotations
  88.5. Le développement d'un client JMX
  88.6. Les notifications

Partie 13 : Les outils pour le développement
  

89. Les outils du J.D.K.
  indique comment utiliser les outils fournis avec le JDK
  89.1. Le compilateur javac
  89.2. L'interpréteur java/javaw
  89.3. L'outil jar
  89.4. L'outil appletviewer pour tester des applets
  89.5. L'outil javadoc pour générer la documentation technique
  89.6. L'outil Java Check Update pour mettre à jour Java
  89.7. La base de données Java DB
  89.8. L'outil JConsole
  89.9. VisualVM

90. JavaDoc
  explore l'outil de documentation fourni avec le JDK
  90.1. La mise en oeuvre
  90.2. Les tags définis par javadoc
  90.3. Un exemple
  90.4. Les fichiers pour enrichir la documentation des packages
  90.5. La documentation générée

91. Les outils libres et commerciaux
  tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
  91.1. Les environnements de développement intégrés (IDE)
  91.2. Les serveurs d'application
  91.3. Les conteneurs web
  91.4. Les conteneurs d'EJB
  91.5. Les outils divers
  91.6. Les MOM
  91.7. Les outils concernant les bases de données
  91.8. Les outils de modélisation UML

92. Ant
  propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
  92.1. L'installation de l'outil Ant
  92.2. L'exécution de l'outil Ant
  92.3. Le fichier build.xml
  92.4. Les tâches (task)

93. Maven
  présente l'outil open source Maven qui facilite et automatise certaines tâches de la gestion d'un projet
  93.1. Les différentes versions de Maven
  93.2. Maven 1
  93.3. Maven 2

94. Tomcat
  Détaille la mise en oeuvre du conteneur web Tomcat
  94.1. L'historique des versions
  94.2. L'installation
  94.3. L'exécution de Tomcat
  94.4. L'architecture
  94.5. La configuration
  94.6. L'outil Tomcat Administration Tool
  94.7. Le déploiement des applications WEB
  94.8. Tomcat pour le développeur
  94.9. Le gestionnaire d'applications (Tomcat manager)
  94.10. L'outil Tomcat Client Deployer
  94.11. Les optimisations
  94.12. La sécurisation du serveur

95. Des outils open source pour faciliter le développement
  présentation de quelques outils de la communauté open source permettant de simplifier le travail des développeurs.
  95.1. CheckStyle
  95.2. Jalopy

Partie 14 : La conception et le développer des applications
  

96. Java et UML
  propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
  96.1. La présentation d'UML
  96.2. Les commentaires
  96.3. Les cas d'utilisations (use cases)
  96.4. Le diagramme de séquence
  96.5. Le diagramme de collaboration
  96.6. Le diagramme d'états-transitions
  96.7. Le diagramme d'activités
  96.8. Le diagramme de classes
  96.9. Le diagramme d'objets
  96.10. Le diagramme de composants
  96.11. Le diagramme de déploiement

97. Les motifs de conception (design patterns)
  présente certains modèles de conception en programmation orientée objet et leur mise en oeuvre avec Java
  97.1. Les modèles de création
  97.2. Les modèles de structuration
  97.3. Les modèles de comportement

98. Des normes de développement
  propose de sensibiliser le lecteur à l'importance de la mise en place de normes de développement sur un projet et propose quelques règles pour définir de telles normes
  98.1. Les fichiers
  98.2. La documentation du code
  98.3. Les déclarations
  98.4. Les séparateurs
  98.5. Les traitements
  98.6. Les règles de programmation

99. Les techniques de développement spécifiques à Java
  couvre des techniques de développement spécifiques à Java
  99.1. L'écriture d'une classe dont les instances seront immuables
  99.2. La redéfinition des méthodes equals() et hashCode()
  99.3. Le clonage d'un objet

100. L'encodage des caractères
  ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
  100.1. L'utilisation des caractères dans la JVM
  100.2. Les jeux d'encodages de caractères
  100.3. Unicode
  100.4. L'encodage de caractères
  100.5. L'encodage du code source
  100.6. L'encodage de caractères avec différentes technologies

101. Les frameworks
  présente les frameworks et propose quelques solutions open source dans divers domaines
  101.1. La présentation des concepts
  101.2. Les frameworks pour les applications web
  101.3. L'architecture pour les applications web
  101.4. Le modèle MVC type 1
  101.5. Le modèle MVC de type 2
  101.6. Les frameworks de mapping Objet/Relationel
  101.7. Les frameworks de logging

102. La génération de documents
  ce chapitre présente plusieurs API open source permettant la génération de documents dans différents formats notamment PDF et Excel
  102.1. Apache POI
  102.2. iText

103. La validation des données
  la validation des données est une tâche commune, nécessaire et importante dans chaque application de gestion de données.
  103.1. Quelques recommandations sur la validation des données
  103.2. L'API Bean Validation (JSR 303)
  103.3. D'autres frameworks pour la validation des données

104. L'utilisation des dates
  ce chapitre détaille l'utilisation des dates en Java
  104.1. Les classes standard du JDK pour manipuler des dates
  104.2. Des exemples de manipulations de dates
  104.3. La classe SimpleDateFormat
  104.4. Joda Time
  104.5. La classe FastDateFormat du projet Apache commons.lang
  104.6. L'API Date and Time

105. La planification de tâches
  ce chapitre propose différentes solutions pour planifier l'exécution de tâches dans une application Java
  105.1. La planification de tâches avec l'API du JDK
  105.2. Quartz

106. Des bibliothèques open source
  présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
  106.1. JFreeChart
  106.2. Beanshell
  106.3. Apache Commons
  106.4. JGoodies
  106.5. Apache Lucene

107. Apache Commons
  Ce chapitre décrit quelques fonctionnalités de la bibliothèque Apache Commons
  107.1. Apache Commons Configuration
  107.2. Apache Commons CLI

Partie 15 : Les tests automatisés
  

108. Les frameworks de tests
  propose une présentation de frameworks et d'outils pour faciliter les tests du code
  108.1. Les tests unitaires
  108.2. Les frameworks et outils de tests

109. JUnit
  présente en détail le framework de tests unitaires le plus utilisé
  109.1. Un exemple très simple
  109.2. L'écriture des cas de tests
  109.3. L'exécution des tests
  109.4. Les suites de tests
  109.5. L'automatisation des tests avec Ant
  109.6. JUnit 4

110. JUnit 5
  la version 5 de JUnit est une réécriture complète qui supporte Java 8 et de nombreuses nouvelles fonctionnalités
  110.1. L'architecture
  110.2. Les dépendances
  110.3. L'écriture de tests
  110.4. L'écriture de tests standard
  110.5. Les assertions
  110.6. Les suppositions
  110.7. La désactivation de tests
  110.8. Les tags
  110.9. Le cycle de vie des instances de test
  110.10. Les tests imbriqués
  110.11. L'injection d'instances dans les constructeurs et les méthodes de tests
  110.12. Les tests répétés
  110.13. Les tests paramétrés
  110.14. Les tests dynamiques
  110.15. Les tests dans une interface
  110.16. Les suites de tests
  110.17. La compatibilité
  110.18. La comparaison entre JUnit 4 et JUnit 5

111. Les objets de type mock
  ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
  111.1. Les doublures d'objets et les objets de type mock
  111.2. L'utilité des objets de type mock
  111.3. Les tests unitaires et les dépendances
  111.4. L'obligation d'avoir une bonne organisation du code
  111.5. Les frameworks
  111.6. Les inconvénients des objets de type mock

Partie 16 : Java et le monde informatique
  

112. La communauté Java
  ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
  112.1. Le JCP
  112.2. Les ressources proposées par Oracle
  112.3. Oracle Technology Network
  112.4. La communauté Java.net
  112.5. Les JUG
  112.6. D'autres User Groups
  112.7. Les Cast Codeurs Podcast
  112.8. Parleys.com
  112.9. Les conférences
  112.10. Webographie
  112.11. Les communautés open source

113. Les plate-formes Java et .Net
  ce chapitre présente rapidement les deux plate-formes
  113.1. La présentation des plate-formes Java et .Net
  113.2. La compilation
  113.3. Les environnements d'exécution
  113.4. Le déploiement des modules
  113.5. Les version des modules
  113.6. L'interopérabilité inter-language
  113.7. La décompilation
  113.8. Les API des deux plate-formes

114. Java et C#
  ce chapitre détaille les principales fonctionnalités des langages Java et C#
  114.1. La syntaxe
  114.2. La programmation orientée objet
  114.3. Les chaînes de caractères
  114.4. Les tableaux
  114.5. Les indexeurs
  114.6. Les exceptions
  114.7. Le multitâche
  114.8. L'appel de code natif
  114.9. Les pointeurs
  114.10. La documentation automatique du code
  114.11. L'introspection/reflection
  114.12. La sérialisation

Partie 17 : Le développement d'applications mobiles
  

115. J2ME / Java ME
  présente la plate-forme Java pour le développement d'applications sur des appareils mobiles tels que des PDA ou des téléphones cellulaires
  115.1. L'historique de la plate-forme
  115.2. La présentation de J2ME / Java ME
  115.3. Les configurations
  115.4. Les profiles
  115.5. J2ME Wireless Toolkit 1.0.4
  115.6. J2ME wireless toolkit 2.1

116. CLDC
  présente les packages et les classes de la configuration CLDC
  116.1. Le package java.lang
  116.2. Le package java.io
  116.3. Le package java.util
  116.4. Le package javax.microedition.io

117. MIDP
  propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
  117.1. Les Midlets
  117.2. L'interface utilisateur
  117.3. La gestion des événements
  117.4. Le stockage et la gestion des données
  117.5. Les suites de midlets
  117.6. Packager une midlet
  117.7. MIDP for Palm O.S.

118. CDC
  présente les packages et les classes de la configuration CDC

119. Les profils du CDC
  propose une présentation et une mise en oeuvre des profils pouvant être utilisés avec la configuration CDC
  119.1. Foundation profile
  119.2. Le Personal Basis Profile (PBP)
  119.3. Le Personal Profile (PP)

120. Les autres technologies pour les applications mobiles
  propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
  120.1. KJava
  120.2. PDAP (PDA Profile)
  120.3. PersonalJava
  120.4. Java Phone
  120.5. JavaCard
  120.6. Embedded Java
  120.7. Waba, Super Waba, Visual Waba

Partie 18 : Annexes
  
   Annexe A : GNU Free Documentation License
   Annexe B : Glossaire

    Imprimer Index Index avec sommaire Télécharger le PDF    
Développons en Java
v 2.20   Copyright (C) 1999-2019 .