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 identifiants restreints
3.5. Les commentaires
3.6. La déclaration et l'utilisation de variables
3.7. Les opérations arithmétiques
3.8. La priorité des opérateurs
3.9. Les structures de contrôles
3.10. Les tableaux
3.11. Les conversions de types
3.12. L'autoboxing et l'unboxing

4. La programmation orientée objet
explore comment Java 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 génériques (generics)
détaille la définition et l'utilisation de types génériques
5.1. Le besoin des génériques
5.2. La définition des concepts
5.3. L'utilisation de types génériques
5.4. La définition de types génériques
5.5. La pollution du heap (Heap Pollution)
5.6. La mise en oeuvre des génériques
5.7. Les méthodes et les constructeurs génériques
5.8. Les paramètres de type bornés (bounded type parameters)
5.9. Les paramètres de type avec wildcard
5.10. Les bornes multiples (Multiple Bounds) avec l'intersection de types
5.11. L'effacement de type (type erasure)
5.12. La différence entre l'utilisation d'un argument de type et un wildcard
5.13. Les conséquences et les effets de bord de l'effacement de type
5.14. Les restrictions dans l'utilisation des génériques

6. Les chaînes de caractères
détaille l'utilisation des chaînes de caractères
6.1. Les chaînes de caractères littérales
6.2. La classe java.lang.String
6.3. La création d'un objet de type String
6.4. Les opérations sur les chaînes de caractères
6.5. La conversion de et vers une chaîne de caractères
6.6. La concaténation de chaînes de caractères
6.7. La classe StringTokenizer
6.8. Les chaînes de caractères et la sécurité
6.9. Le stockage en mémoire
6.10. Les blocs de texte (Text Blocks)

7. Les packages de bases
propose une présentation rapide des principales API fournies avec le JDK
7.1. Les packages selon la version du JDK
7.2. Le package java.lang
7.3. La présentation rapide du package awt java
7.4. La présentation rapide du package java.io
7.5. Le package java.util
7.6. La présentation rapide du package java.net
7.7. La présentation rapide du package java.applet

8. Les fonctions mathématiques
indique comment utiliser les fonctions mathématiques
8.1. Les variables de classe
8.2. Les fonctions trigonométriques
8.3. Les fonctions de comparaisons
8.4. Les arrondis
8.5. La méthode IEEEremainder(double, double)
8.6. Les Exponentielles et puissances
8.7. La génération de nombres aléatoires
8.8. La classe BigDecimal

9. 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
9.1. Les mots clés try, catch et finally
9.2. La classe Throwable
9.3. Les classes Exception, RunTimeException et Error
9.4. Les exceptions personnalisées
9.5. Les exceptions chaînées
9.6. L'utilisation des exceptions
9.7. L'instruction try-with-resources
9.8. Des types plus précis lorsqu'une exception est relevée dans une clause catch
9.9. Multiples exceptions dans une clause catch

10. Les énumérations (type enum)
détaille les nouvelles fonctionnalités du langage de la version 1.5
10.1. Les énumérations locales

11. Les annotations
présente les annotations qui sont des métadonnées insérées dans le code source et leurs mises en oeuvre.
11.1. La présentation des annotations
11.2. La mise en oeuvre des annotations
11.3. L'utilisation des annotations
11.4. Les annotations standard
11.5. Les annotations communes (Common Annotations)
11.6. Les annotations personnalisées
11.7. L'exploitation des annotations
11.8. L'API Pluggable Annotation Processing
11.9. Les ressources relatives aux annotations

12. Les expressions lambda
détaille l'utilisation des expressions lambda et des références de méthodes et constructeurs.
12.1. L'historique des lambdas pour Java
12.2. Les expressions lambda
12.3. Les références de méthodes
12.4. Les interfaces fonctionnelles

13. Les records
décrit la déclaration et l'utilisation de classes records
13.1. L'introduction aux records
13.2. La définition d'un record
13.3. La mise en oeuvre des records

Partie 2 : Les API de base


14. Les collections
propose une revue des classes fournies par le JDK pour gérer des ensembles d'objets
14.1. Présentation du framework collection
14.2. Les interfaces des collections
14.3. Les collections de type List : les listes
14.4. Les collections de type Set : les ensembles
14.5. Les collections de type Map : les associations de type clé/valeur
14.6. Les collections de type Queue : les files
14.7. Le tri des collections
14.8. Les algorithmes
14.9. Les exceptions du framework

15. 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
15.1. La présentation des flux
15.2. Les classes de gestion des flux
15.3. Les flux de caractères
15.4. Les flux d'octets
15.5. La classe File
15.6. Les fichiers à accès direct
15.7. La classe java.io.Console

16. NIO 2
détaille l'API FileSystem qui facilite l'utilisation de systèmes de fichiers
16.1. Les entrées/sorties avec Java
16.2. Les principales classes et interfaces
16.3. L'interface Path
16.4. Glob
16.5. La classe Files
16.6. Le parcours du contenu de répertoires
16.7. L'utilisation de systèmes de gestion de fichiers
16.8. La lecture et l'écriture dans un fichier
16.9. Les liens et les liens symboliques
16.10. La gestion des attributs
16.11. La gestion des unités de stockages
16.12. Les notifications de changements dans un répertoire
16.13. La gestion des erreurs et la libération des ressources
16.14. L'interopérabilité avec le code existant

17. 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.
17.1. La sérialisation standard
17.2. La documentation d'une classe sérialisable
17.3. La sérialisation et la sécurité
17.4. La sérialisation en XML

18. 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
18.1. L'introduction aux concepts liés au réseau
18.2. Les adresses internet
18.3. L'accès aux ressources avec une URL
18.4. L'utilisation du protocole TCP
18.5. L'utilisation du protocole UDP
18.6. Les exceptions liées au réseau
18.7. Les interfaces de connexions au réseau

19. L'internationalisation
traite d'une façon pratique de la possibilité d'internationaliser une application
19.1. Les objets de type Locale
19.2. La classe ResourceBundle
19.3. Un guide pour réaliser la localisation

20. Les composants Java beans
examine comment développer et utiliser des composants réutilisables
20.1. La présentation des Java beans
20.2. Les propriétés.
20.3. Les méthodes
20.4. Les événements
20.5. L'introspection
20.6. Paramétrage du bean ( Customization )
20.7. La persistance
20.8. La diffusion sous forme de jar

21. 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
21.1. La présentation du logging
21.2. Log4j
21.3. L'API logging
21.4. Jakarta Commons Logging (JCL)
21.5. D'autres API de logging

22. 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.
22.1. Le besoin de l'API Stream
22.2. Le pipeline d'opérations d'un Stream
22.3. Les opérations intermédiaires
22.4. Les opérations terminales
22.5. Les Collectors
22.6. Les Streams pour des données primitives
22.7. L'utilisation des Streams avec les opérations I/O
22.8. Le traitement des opérations en parallèle
22.9. Les optimisations réalisées par l'API Stream
22.10. Les Streams infinis
22.11. Le débogage d'un Stream
22.12. Les limitations de l'API Stream
22.13. Quelques recommandations sur l'utilisation de l'API Stream

Partie 3 : Les API avancées


23. 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
23.1. La classe Class
23.2. La recherche des informations sur une classe
23.3. La définition dynamique d'objets
23.4. L'invocation dynamique d'une méthode
23.5. L'API Reflection et le SecurityManager
23.6. L'utilisation de l'API Reflection sur les annotations

24. L'appel de méthodes distantes : RMI
étudie la mise en oeuvre de la technologie RMI pour permettre l'appel de méthodes distantes
24.1. La présentation et l'architecture de RMI
24.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI
24.3. Le développement coté serveur
24.4. Le développement coté client
24.5. La génération de la classe stub
24.6. La mise en oeuvre des objets RMI

25. 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
25.1. La sécurité dans les spécifications du langage
25.2. Le contrôle des droits d'une application
25.3. La cryptographie
25.4. JCA (Java Cryptography Architecture) et JCE (Java Cryptography Extension)
25.5. JSSE (Java Secure Sockets Extension)
25.6. JAAS (Java Authentication and Authorization Service)

26. JCA (Java Cryptography Architecture)
détaille l'utilisation de l'API proposant des fonctionnalités cryptographiques de base
26.1. L'architecture de JCA
26.2. Les classes et interfaces de JCA
26.3. Les fournisseurs d'implémentations
26.4. La classe java.security.Provider
26.5. La classe java.security.Security
26.6. La classe java.security.MessageDigest
26.7. Les classes DigestInputStream et DigestOuputStream
26.8. La classe java.security.Signature
26.9. La classe java.security.KeyStore
26.10. Les interfaces de type java.security.Key
26.11. La classe java.security.KeyPair
26.12. La classe java.security.KeyPairGenerator
26.13. La classe java.security.KeyFactory
26.14. La classe java.security.SecureRandom
26.15. La classe java.security.AlgorithmParameters
26.16. La classe java.security.AlgorithmParameterGenerator
26.17. La classe java.security.cert.CertificateFactory
26.18. L'interface java.security.spec.KeySpec et ses implémentations
26.19. La classe java.security.spec.EncodedKeySpec et ses sous-classes
26.20. L'interface java.security.spec.AlgorithmParameterSpec

27. 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
27.1. La classe javax.crypto.KeyGenerator
27.2. La classe javax.crypto.SecretKeyFactory
27.3. La classe javax.crypto.Cipher
27.4. Les classes javax.crypto.CipherInputStream et javax.crypto.CipherOutputStream
27.5. La classe javax.crypto.SealedObject
27.6. La classe javax.crypto.Mac

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

29. JNDI (Java Naming and Directory Interface)
introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
29.1. La présentation de JNDI
29.2. La mise en oeuvre de l'API JNDI
29.3. L'utilisation d'un service de nommage
29.4. L'utilisation avec un DNS
29.5. L'utilisation du File System Context Provider
29.6. LDAP
29.7. L'utilisation avec un annuaire LDAP
29.8. JNDI et J2EE/Java EE

30. 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.
30.1. L'API Scripting

31. 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
31.1. La présentation de JMX
31.2. L'architecture de JMX
31.3. Un premier exemple
31.4. La couche instrumentation : les MBeans
31.5. Les MBeans standard
31.6. La couche agent
31.7. Les services d'un agent JMX
31.8. La couche services distribués
31.9. Les notifications
31.10. Les Dynamic MBeans
31.11. Les Model MBeans
31.12. Les Open MBeans
31.13. Les MXBeans
31.14. L'interface PersistentMBean
31.15. Le monitoring d'une JVM
31.16. Des recommandations pour l'utilisation de JMX
31.17. Des ressources

32. L'API Service Provider (SPI)
ce chapitre détaille la mise en oeuvre de services en utilisant l'API ServiceLoader
32.1. Introduction
32.2. La mise en oeuvre
32.3. La consommation d'un service
32.4. Un exemple complet
32.5. Les services de JPMS

Partie 4 : Le système de modules


33. Le système de modules de la plateforme Java
ce chaptitre décrit le système de modules de la plateforme Java
33.1. La modularisation
33.2. Les difficultés pouvant être résolues par les modules
33.3. Java Plateform Module System (JPMS)
33.4. L'implémentation du système de modules

34. Les modules
ce chapitre détaille les modules et les descripteurs de module
34.1. Le contenu d'un module
34.2. Le code source d'un module
34.3. Le descripteur de module
34.4. Les règles d'accès
34.5. La qualité des descripteurs de module

Partie 5 : La programmation parallèle et concurrente


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

36. 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"
36.1. L'interface Runnable
36.2. La classe Thread
36.3. Le cycle de vie d'un thread
36.4. Les démons (daemon threads)
36.5. Les groupes de threads
36.6. L'obtention d'informations sur un thread
36.7. La manipulation des threads
36.8. Les messages de synchronisation entre threads
36.9. Les restrictions sur les threads
36.10. Les threads et les classloaders
36.11. Les threads et la gestion des exceptions
36.12. Les piles

37. L'association de données à des threads
détaille les solutions utilisables pour permettre d'associer des données à un thread
37.1. La classe ThreadLocal
37.2. La classe InheritableThreadLocal
37.3. La classe ThreadLocalRandom

38. Le framework Executor
détaille l'utilisation du framework Executor
38.1. L'interface Executor
38.2. Les pools de threads
38.3. L'interface java.util.concurrent.Callable
38.4. L'interface java.util.concurrent.Future
38.5. L'interface java.util.concurrent.CompletionService

39. La gestion des accès concurrents
détaille différentes solutions pour gérer les accès concurrents dans les traitements en parallèle
39.1. Le mot clé volatile
39.2. Les races conditions
39.3. La synchronisation avec les verrous
39.4. Les opérations atomiques
39.5. L'immutabilité et la copie défensive

Partie 6 : Le développement des interfaces graphiques


40. 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
40.1. Les opérations sur le contexte graphique

41. Les éléments d'interfaces graphiques de l'AWT
recense les différents composants qui sont fournis dans la bibliothèque AWT
41.1. Les composants graphiques
41.2. La classe Component
41.3. Les conteneurs
41.4. Les menus
41.5. La classe java.awt.Desktop

42. La création d'interfaces graphiques avec AWT
indique comment réaliser des interfaces graphiques avec l'AWT
42.1. Le dimensionnement des composants
42.2. Le positionnement des composants
42.3. La création de nouveaux composants à partir de Panel
42.4. L'activation ou la désactivation des composants

43. 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
43.1. L'interception des actions de l'utilisateur avec Java version 1.0
43.2. L'interception des actions de l'utilisateur avec Java version 1.1

44. Le développement d'interfaces graphiques avec SWING
indique comment réaliser des interfaces graphiques avec Swing
44.1. La présentation de Swing
44.2. Les packages Swing
44.3. Un exemple de fenêtre autonome
44.4. Les composants Swing
44.5. Les boutons
44.6. Les composants de saisie de texte
44.7. Les onglets
44.8. Le composant JTree
44.9. Les menus
44.10. L'affichage d'une image dans une application.

45. Le développement d'interfaces graphiques avec SWT
indique comment réaliser des interfaces graphiques avec SWT
45.1. La présentation de SWT
45.2. Un exemple très simple
45.3. La classe SWT
45.4. L'objet Display
45.5. L'objet Shell
45.6. Les composants
45.7. Les conteneurs
45.8. La gestion des erreurs
45.9. Le positionnement des contrôles
45.10. La gestion des événements
45.11. Les boîtes de dialogue

46. JFace
présente l'utilisation de ce framework facilitant le développement d'applications utilisant SWT
46.1. La présentation de JFace
46.2. La structure générale d'une application
46.3. Les boites de dialogue

Partie 7 : L'utilisation de documents XML et JSON


47. 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
47.1. La présentation de XML
47.2. Les règles pour formater un document XML
47.3. La DTD (Document Type Definition)
47.4. Les parseurs
47.5. La génération de données au format XML
47.6. JAXP : Java API for XML Parsing
47.7. Jaxen

48. 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
48.1. L'utilisation de SAX de type 1
48.2. L'utilisation de SAX de type 2

49. 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
49.1. Les interfaces du DOM
49.2. L'obtention d'un arbre DOM
49.3. Le parcours d'un arbre DOM
49.4. La modification d'un arbre DOM
49.5. L'envoi d'un arbre DOM dans un flux

50. XSLT (Extensible Stylesheet Language Transformations)
présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
50.1. XPath
50.2. La syntaxe de XSLT
50.3. Un exemple avec Internet Explorer
50.4. Un exemple avec Xalan 2

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

52. 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.
52.1. JAXB 1.0
52.2. JAXB 2.0

53. 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
53.1. La présentation de StAX
53.2. Les deux API de StAX
53.3. Les fabriques
53.4. Le traitement d'un document XML avec l'API du type curseur
53.5. Le traitement d'un document XML avec l'API du type itérateur
53.6. La mise en oeuvre des filtres
53.7. L'écriture un document XML avec l'API de type curseur
53.8. L'écriture un document XML avec l'API de type itérateur
53.9. La comparaison entre SAX, DOM et StAX

54. JSON
présente le format JSON
54.1. La syntaxe de JSON
54.2. L'utilisation de JSON
54.3. JSON ou XML

55. Gson
Présente l'API Gson de Google pour la lecture et la génération de documents JSON
55.1. La classe Gson
55.2. La sérialisation
55.3. La désérialisation
55.4. La personnalisation de la sérialisation/désérialisation
55.5. Les annotations de Gson
55.6. L'API Streaming
55.7. Mixer l'utilisation du model objets et de l'API Streaming
55.8. Les concepts avancés

56. JSON-P (Java API for JSON Processing)
détaille l'utilisation de l'API JSON-P spécifiée dans la JSR 353
56.1. La classe Json
56.2. L'API Streaming
56.3. L'API Object Model

57. 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
57.1. La sérialisation/désérialisation d'un objet
57.2. Le moteur JSON-B
57.3. Le mapping par défaut
57.4. La configuration du moteur JSON-B
57.5. La personnalisation du mapping

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


58. 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)
58.1. La correspondance entre les modèles relationnel et objet
58.2. L'évolution des solutions de persistance avec Java
58.3. Le mapping O/R (objet/relationnel)
58.4. L'architecture et la persistance de données
58.5. Les différentes solutions
58.6. Les API standards
58.7. Les frameworks open source
58.8. L'utilisation de procédures stockées

59. JDBC (Java DataBase Connectivity)
indique comment utiliser cette API historique pour accéder aux bases de données
59.1. Les outils nécessaires pour utiliser JDBC
59.2. Les types de pilotes JDBC
59.3. L'enregistrement d'une base de données dans ODBC sous Windows 9x ou XP
59.4. La présentation des classes de l'API JDBC
59.5. La connexion à une base de données
59.6. L'accès à la base de données
59.7. L'obtention d'informations sur la base de données
59.8. L'utilisation d'un objet de type PreparedStatement
59.9. L'utilisation des transactions
59.10. Les procédures stockées
59.11. Le traitement des erreurs JDBC
59.12. JDBC 2.0
59.13. JDBC 3.0
59.14. MySQL et Java
59.15. L'amélioration des performances avec JDBC

60. JDO (Java Data Object)
API qui standardise et automatise le mapping entre des objets Java et un système de gestion de données
60.1. La présentation de JDO
60.2. Un exemple avec Lido
60.3. L'API JDO
60.4. La mise en oeuvre
60.5. Le parcours de toutes les occurrences
60.6. La mise en oeuvre de requêtes

61. Hibernate
présente Hibernate, un framework de mapping Objets/Relationnel open source
61.1. La création d'une classe qui va encapsuler les données
61.2. La création d'un fichier de correspondance
61.3. Les propriétés de configuration
61.4. L'utilisation d'Hibernate
61.5. La persistance d'une nouvelle occurrence
61.6. L'obtention d'une occurrence à partir de son identifiant
61.7. L'obtention de données
61.8. La mise à jour d'une occurrence
61.9. La suppression d'une ou plusieurs occurrences
61.10. Les relations
61.11. Le mapping de l'héritage de classes
61.12. Les caches d'Hibernate
61.13. Les outils de génération de code

62. 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.
62.1. L'installation de l'implémentation de référence
62.2. Les entités
62.3. Le fichier de configuration du mapping
62.4. L'utilisation du bean entité
62.5. Le fichier persistence.xml
62.6. La gestion des transactions hors Java EE
62.7. La gestion des relations entre tables dans le mapping
62.8. Le mapping de l'héritage de classes
62.9. Les callbacks d'événements

Partie 9 : La machine virtuelle Java (JVM)


63. La JVM (Java Virtual Machine)
ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
63.1. La mémoire de la JVM
63.2. Le cycle de vie d'une classe dans la JVM
63.3. Les ClassLoaders
63.4. Le bytecode
63.5. Le compilateur JIT
63.6. Les paramètres de la JVM HotSpot
63.7. Les interactions de la machine virtuelle avec des outils externes
63.8. Service Provider Interface (SPI)
63.9. Les JVM 32 et 64 bits

64. 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.
64.1. Le ramasse-miettes (Garbage Collector ou GC)
64.2. Le fonctionnement du ramasse-miettes de la JVM Hotspot
64.3. Le paramétrage du ramasse-miettes de la JVM HotSpot
64.4. Le monitoring de l'activité du ramasse-miettes
64.5. Les différents types de référence
64.6. L'obtention d'informations sur la mémoire de la JVM
64.7. Les fuites de mémoire (Memory leak)
64.8. Les exceptions liées à un manque de mémoire

65. 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.
65.1. Décompiler du bytecode
65.2. Obfusquer le bytecode

66. Programmation orientée aspects (AOP)
ce chapitre présente le concept de l'AOP (Apsect Oriented Programming
66.1. Le besoin d'un autre modèle de programmation
66.2. Les concepts de l'AOP
66.3. La mise en oeuvre de l'AOP
66.4. Les avantages et les inconvénients
66.5. Des exemples d'utilisation
66.6. Des implémentations pour la plate-forme Java

67. Terracotta
Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
67.1. La présentation de Terrocatta
67.2. Les concepts utilisés
67.3. La mise en oeuvre des fonctionnalités
67.4. Les cas d'utilisation
67.5. Quelques exemples de mise en oeuvre
67.6. La console développeur
67.7. Le fichier de configuration
67.8. La fiabilisation du cluster
67.9. Quelques recommandations

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


68. J2EE / Java EE
introduit la plate-forme Java Entreprise Edition
68.1. La présentation de J2EE
68.2. Les API de J2EE / Java EE
68.3. L'environnement d'exécution des applications J2EE
68.4. L'assemblage et le déploiement d'applications J2EE
68.5. J2EE 1.4 SDK
68.6. La présentation de Java EE 5.0
68.7. La présentation de Java EE 6
68.8. La présentation de Java EE 7
68.9. La présentation de Java EE 8/Jakarta EE 8

69. JavaMail
traite de l'API qui permet l'envoi et la réception d'e-mails
69.1. Le téléchargement et l'installation
69.2. Les principaux protocoles
69.3. Les principales classes et interfaces de l'API JavaMail
69.4. L'envoi d'un e-mail par SMTP
69.5. La récupération des messages d'un serveur POP3
69.6. Les fichiers de configuration

70. 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
70.1. La présentation de JMS
70.2. Les services de messages
70.3. Le package javax.jms
70.4. L'utilisation du mode point à point (queue)
70.5. L'utilisation du mode publication/abonnement (publish/subscribe)
70.6. La gestion des erreurs
70.7. JMS 1.1
70.8. Les ressources relatives à JMS

71. 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
71.1. La présentation des EJB
71.2. Les EJB session
71.3. Les EJB entité
71.4. Les outils pour développer et mettre en oeuvre des EJB
71.5. Le déploiement des EJB
71.6. L'appel d'un EJB par un client
71.7. Les EJB orientés messages

72. 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.
72.1. L'historique des EJB
72.2. Les nouveaux concepts et fonctionnalités utilisés
72.3. EJB 2.x vs EJB 3.0
72.4. Les conventions de nommage
72.5. Les EJB de type Session
72.6. Les EJB de type Entity
72.7. Un exemple simple complet
72.8. L'utilisation des EJB par un client
72.9. L'injection de dépendances
72.10. Les intercepteurs
72.11. Les EJB de type MessageDriven
72.12. Le packaging des EJB
72.13. Les transactions
72.14. La mise en oeuvre de la sécurité

73. Les EJB 3.1
ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
73.1. Les interfaces locales sont optionnelles
73.2. Les EJB Singleton
73.3. EJB Lite
73.4. La simplification du packaging
73.5. Les améliorations du service Timer
73.6. La standardisation des noms JNDI
73.7. L'invocation asynchrone des EJB session
73.8. L'invocation d'un EJB hors du conteneur

74. 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
74.1. La présentation des services web
74.2. Les standards
74.3. Les différents formats de services web SOAP
74.4. Des conseils pour la mise en oeuvre
74.5. Les API Java pour les services web
74.6. Les implémentations des services web
74.7. Inclure des pièces jointes dans SOAP
74.8. WS-I
74.9. Les autres spécifications

75. Les WebSockets
présente le procotole WebSocket
75.1. Les limitations du protocole HTTP
75.2. La spécification du protocole WebSocket
75.3. La connexion à une WebSocket
75.4. La mise en oeuvre des WebSockets

76. L'API WebSocket
détaille l'utilisation de l'API Java API for WebSocket spécifiée par la JSR 356
76.1. Les principales classes et interfaces
76.2. Le développement d'un endpoint
76.3. Les encodeurs et les décodeurs
76.4. Le débogage des WebSockets
76.5. Des exemples d'utilisation
76.6. L'utilisation d'implémentations

Partie 11 : Le développement d'applications web


77. Les servlets
plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
77.1. La présentation des servlets
77.2. L'API servlet
77.3. Le protocole HTTP
77.4. Les servlets http
77.5. Les informations sur l'environnement d'exécution des servlets
77.6. L'utilisation des cookies
77.7. Le partage d'informations entre plusieurs échanges HTTP
77.8. Packager une application web
77.9. L'utilisation de Log4J dans une servlet

78. 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
78.1. La présentation des JSP
78.2. Les outils nécessaires
78.3. Le code HTML
78.4. Les Tags JSP
78.5. Un exemple très simple
78.6. La gestion des erreurs
78.7. Les bibliothèques de tags personnalisés (custom taglibs)

79. JSTL (Java server page Standard Tag Library)
est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
79.1. Un exemple simple
79.2. Le langage EL (Expression Language)
79.3. La bibliothèque Core
79.4. La bibliothèque XML
79.5. La bibliothèque I18n
79.6. La bibliothèque Database

80. Struts
présente et détaille la mise en oeuvre du framework open source de développement d'applications web le plus populaire
80.1. L'installation et la mise en oeuvre
80.2. Le développement des vues
80.3. La configuration de Struts
80.4. Les bibliothèques de tags personnalisés
80.5. La validation de données

81. 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.
81.1. La présentation de JSF
81.2. Le cycle de vie d'une requête
81.3. Les implémentations
81.4. Le contenu d'une application
81.5. La configuration de l'application
81.6. Les beans
81.7. Les composants pour les interfaces graphiques
81.8. La bibliothèque de tags Core
81.9. La bibliothèque de tags Html
81.10. La gestion et le stockage des données
81.11. La conversion des données
81.12. La validation des données
81.13. La sauvegarde et la restauration de l'état
81.14. Le système de navigation
81.15. La gestion des événements
81.16. Le déploiement d'une application
81.17. Un exemple d'application simple
81.18. L'internationalisation
81.19. Les points faibles de JSF

82. D'autres frameworks pour les applications web
présente rapidement quelques frameworks open source pour le développement d'applications web
82.1. Les frameworks pour les applications web
82.2. Les moteurs de templates

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


83. 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.
83.1. Les applications de type RIA
83.2. Les applications de type RDA
83.3. Les contraintes
83.4. Les solutions RIA
83.5. Les solutions RDA

84. Les applets
plonge au coeur des premières applications qui ont rendu Java célèbre
84.1. L'intégration d'applets dans une page HTML
84.2. Les méthodes des applets
84.3. Les interfaces utiles pour les applets
84.4. La transmission de paramètres à une applet
84.5. Les applets et le multimédia
84.6. Une applet pouvant s'exécuter comme une application
84.7. Les droits des applets

85. Java Web Start (JWS)
est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
85.1. La création du package de l'application
85.2. La signature d'un fichier jar
85.3. Le fichier JNLP
85.4. La configuration du serveur web
85.5. Le fichier HTML
85.6. Le test de l'application
85.7. L'utilisation du gestionnaire d'applications
85.8. L'API de Java Web Start

86. 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é.
86.1. La présentation d'AJAX
86.2. Le détail du mode de fonctionnement
86.3. Un exemple simple
86.4. Des frameworks pour mettre en oeuvre AJAX

87. GWT (Google Web Toolkit)
GWT est un framework pour le développement d'applications de type RIA
87.1. La présentation de GWT
87.2. La création d'une application
87.3. Les modes d'exécution
87.4. Les éléments de GWT
87.5. L'interface graphique des applications GWT
87.6. La personnalisation de l'interface
87.7. Les composants (widgets)
87.8. Les panneaux (panels)
87.9. La création d'éléments réutilisables
87.10. Les événements
87.11. JSNI
87.12. La configuration et l'internationalisation
87.13. L'appel de procédures distantes (Remote Procedure Call)
87.14. La manipulation des documents XML
87.15. La gestion de l'historique sur le navigateur
87.16. Les tests unitaires
87.17. Le déploiement d'une application
87.18. Des composants tiers
87.19. Les ressources relatives à GWT

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


88. Spring
ce chapitre est une présentation générale de Spring
88.1. Le but et les fonctionnalités proposées par Spring
88.2. L'historique de Spring
88.3. Spring Framework
88.4. Les projets du portfolio Spring
88.5. Les avantages et les inconvénients de Spring
88.6. Spring et Java EE

89. 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
89.1. Les fondements de Spring
89.2. Le conteneur Spring
89.3. Le fichier de configuration
89.4. L'injection de dépendances
89.5. Spring Expression Langage (SpEL)
89.6. La configuration en utilisant les annotations
89.7. Le scheduling

90. La mise en oeuvre de l'AOP avec Spring
présente la mise en oeuvre de l'AOP avec Spring
90.1. Spring AOP
90.2. AspectJ
90.3. Spring AOP et AspectJ
90.4. L'utilisation des namespaces

91. La gestion des transactions avec Spring
ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
91.1. La gestion des transactions par Spring
91.2. La propagation des transactions
91.3. L'utilisation des transactions de manière déclarative
91.4. La déclaration des transactions avec des annotations
91.5. La gestion du rollback des transactions
91.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
91.7. L'utilisation des transactions via l'API
91.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

92. Spring et JMS
ce chapitre couvre la mise en oeuvre de JMS dans Spring
92.1. Les packages de Spring JMS
92.2. La classe JmsTemplate : le template JMS de Spring
92.3. La réception asynchrone de messages
92.4. L'espace de nommage jms

93. Spring et JMX
ce chapitre détaille la façon dont Spring facilite la mise en oeuvre de JMX
93.1. L'enregistrement d'un bean en tant que MBean
93.2. Le nommage des MBeans
93.3. Les Assembler
93.4. L'utilisation des annotations
93.5. Le développement d'un client JMX
93.6. Les notifications

Partie 14 : Les outils pour le développement


94. Les outils du J.D.K.
indique comment utiliser les outils fournis avec le JDK
94.1. Le compilateur javac
94.2. L'interpréteur java/javaw
94.3. L'outil jar
94.4. L'outil appletviewer pour tester des applets
94.5. L'outil javadoc pour générer la documentation technique
94.6. L'outil Java Check Update pour mettre à jour Java
94.7. La base de données Java DB
94.8. L'outil JConsole

95. JavaDoc
explore l'outil de documentation fourni avec le JDK
95.1. La mise en oeuvre
95.2. Les tags définis par javadoc
95.3. Un exemple
95.4. Les fichiers pour enrichir la documentation des packages
95.5. La documentation générée

96. JShell
détaille l'utilisation de l'outil JShell
96.1. Les outils de type REPL
96.2. Introduction à JShell
96.3. La saisie d'éléments dans JShell
96.4. Les fragments
96.5. Les commandes de JShell
96.6. L'édition
96.7. Les fonctionnalités de l'environnement
96.8. Les scripts
96.9. Les modes de feedback
96.10. L'utilisation de classes externes
96.11. Les options de JShell
96.12. JShell API

97. Les outils libres et commerciaux
tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
97.1. Les environnements de développement intégrés (IDE)
97.2. Les serveurs d'application
97.3. Les conteneurs web
97.4. Les conteneurs d'EJB
97.5. Les outils divers
97.6. Les MOM
97.7. Les outils concernant les bases de données
97.8. Les outils de modélisation UML

98. Ant
propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
98.1. L'installation de l'outil Ant
98.2. L'exécution de l'outil Ant
98.3. Le fichier build.xml
98.4. Les tâches (task)

99. Maven
présente l'outil open source Maven qui facilite et automatise certaines tâches de la gestion d'un projet
99.1. Les différentes versions de Maven
99.2. Maven 1
99.3. Maven 2

100. Tomcat
Détaille la mise en oeuvre du conteneur web Tomcat
100.1. L'historique des versions
100.2. L'installation
100.3. L'exécution de Tomcat
100.4. L'architecture
100.5. La configuration
100.6. L'outil Tomcat Administration Tool
100.7. Le déploiement des applications WEB
100.8. Tomcat pour le développeur
100.9. Le gestionnaire d'applications (Tomcat manager)
100.10. L'outil Tomcat Client Deployer
100.11. Les optimisations
100.12. La sécurisation du serveur

101. 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.
101.1. CheckStyle
101.2. Jalopy

Partie 15 : La conception et le développement des applications


102. Java et UML
propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
102.1. La présentation d'UML
102.2. Les commentaires
102.3. Les cas d'utilisations (use cases)
102.4. Le diagramme de séquence
102.5. Le diagramme de collaboration
102.6. Le diagramme d'états-transitions
102.7. Le diagramme d'activités
102.8. Le diagramme de classes
102.9. Le diagramme d'objets
102.10. Le diagramme de composants
102.11. Le diagramme de déploiement

103. 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
103.1. Les modèles de création
103.2. Les modèles de structuration
103.3. Les modèles de comportement

104. 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
104.1. Les fichiers
104.2. La documentation du code
104.3. Les déclarations
104.4. Les séparateurs
104.5. Les traitements
104.6. Les règles de programmation

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

106. L'encodage des caractères
ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
106.1. L'utilisation des caractères dans la JVM
106.2. Les jeux d'encodages de caractères
106.3. Unicode
106.4. L'encodage de caractères
106.5. L'encodage du code source
106.6. L'encodage de caractères avec différentes technologies

107. Les frameworks
présente les frameworks et propose quelques solutions open source dans divers domaines
107.1. La présentation des concepts
107.2. Les frameworks pour les applications web
107.3. L'architecture pour les applications web
107.4. Le modèle MVC type 1
107.5. Le modèle MVC de type 2
107.6. Les frameworks de mapping Objet/Relationel
107.7. Les frameworks de logging

108. 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
108.1. Apache POI
108.2. iText

109. 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.
109.1. Quelques recommandations sur la validation des données
109.2. L'API Bean Validation (JSR 303)
109.3. D'autres frameworks pour la validation des données

110. L'utilisation des dates
ce chapitre détaille l'utilisation des dates en Java
110.1. Les classes standard du JDK pour manipuler des dates
110.2. Des exemples de manipulations de dates
110.3. La classe SimpleDateFormat
110.4. Joda Time
110.5. La classe FastDateFormat du projet Apache commons.lang
110.6. L'API Date and Time

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

112. Des bibliothèques open source
présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
112.1. JFreeChart
112.2. Beanshell
112.3. Apache Commons
112.4. JGoodies
112.5. Apache Lucene

113. Apache Commons
Ce chapitre décrit quelques fonctionnalités de la bibliothèque Apache Commons
113.1. Apache Commons Configuration
113.2. Apache Commons CLI

Partie 16 : Les tests automatisés


114. Les frameworks de tests
propose une présentation de frameworks et d'outils pour faciliter les tests du code
114.1. Les tests unitaires
114.2. Les frameworks et outils de tests

115. JUnit
présente en détail le framework de tests unitaires le plus utilisé
115.1. Un exemple très simple
115.2. L'écriture des cas de tests
115.3. L'exécution des tests
115.4. Les suites de tests
115.5. L'automatisation des tests avec Ant
115.6. JUnit 4

116. JUnit 5
la version 5 de JUnit est une réécriture complète qui supporte Java 8 et de nombreuses nouvelles fonctionnalités
116.1. L'architecture
116.2. Les dépendances
116.3. L'écriture de tests
116.4. L'écriture de tests standard
116.5. Les assertions
116.6. Les suppositions
116.7. La désactivation de tests
116.8. Les tags
116.9. Le cycle de vie des instances de test
116.10. Les tests imbriqués
116.11. L'injection d'instances dans les constructeurs et les méthodes de tests
116.12. Les tests répétés
116.13. Les tests paramétrés
116.14. Les tests dynamiques
116.15. Les tests dans une interface
116.16. Les suites de tests
116.17. La compatibilité
116.18. La comparaison entre JUnit 4 et JUnit 5

117. Les objets de type mock
ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
117.1. Les doublures d'objets et les objets de type mock
117.2. L'utilité des objets de type mock
117.3. Les tests unitaires et les dépendances
117.4. L'obligation d'avoir une bonne organisation du code
117.5. Les frameworks
117.6. Les inconvénients des objets de type mock

Partie 17 : Les outils de profiling et monitoring


118. Arthas
Cette section détaille la mise en oeuvre de l'outil de profiling et de monitoring Arthas
118.1. Installation
118.2. Le démarrage
118.3. Les fonctionnalités
118.4. L'exécution de commandes en asynchrone
118.5. Les scripts batch
118.6. La console web

119. VisualVM
VisualVM est un outil historiquement fourni dans la JDK est maintenant en open source qui propose des fonctionnalités de monitoring et de profiling basic extensible par plug-in
119.1. L'utilisation de VisualVM
119.2. Les plugins pour VisualVM
119.3. L'utilisation de VisualVM
119.4. La connexion à une JVM
119.5. L'obtention d'informations
119.6. Le profilage d'une JVM
119.7. La création d'un snapshot
119.8. Le plugin VisualGC

Partie 18 : Java et le monde informatique


120. La communauté Java
ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
120.1. Le JCP
120.2. Les ressources proposées par Oracle
120.3. Oracle Technology Network
120.4. La communauté Java.net
120.5. Les JUG
120.6. Les Cast Codeurs Podcast
120.7. Parleys.com
120.8. Les conférences Devoxx et Voxxed Days
120.9. Les conférences
120.10. Les unconférences
120.11. Webographie
120.12. Les communautés open source

121. Les plates-formes Java et .Net
ce chapitre présente rapidement les deux plates-formes
121.1. La présentation des plates-formes Java et .Net
121.2. La compilation
121.3. Les environnements d'exécution
121.4. Le déploiement des modules
121.5. Les version des modules
121.6. L'interopérabilité inter-language
121.7. La décompilation
121.8. Les API des deux plates-formes

122. Java et C#
ce chapitre détaille les principales fonctionnalités des langages Java et C#
122.1. La syntaxe
122.2. La programmation orientée objet
122.3. Les chaînes de caractères
122.4. Les tableaux
122.5. Les indexeurs
122.6. Les exceptions
122.7. Le multitâche
122.8. L'appel de code natif
122.9. Les pointeurs
122.10. La documentation automatique du code
122.11. L'introspection/reflection
122.12. La sérialisation

Partie 19 : Le développement d'applications mobiles


123. 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
123.1. L'historique de la plate-forme
123.2. La présentation de J2ME / Java ME
123.3. Les configurations
123.4. Les profiles
123.5. J2ME Wireless Toolkit 1.0.4
123.6. J2ME wireless toolkit 2.1

124. CLDC
présente les packages et les classes de la configuration CLDC
124.1. Le package java.lang
124.2. Le package java.io
124.3. Le package java.util
124.4. Le package javax.microedition.io

125. MIDP
propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
125.1. Les Midlets
125.2. L'interface utilisateur
125.3. La gestion des événements
125.4. Le stockage et la gestion des données
125.5. Les suites de midlets
125.6. Packager une midlet
125.7. MIDP for Palm O.S.

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

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

128. Les autres technologies pour les applications mobiles
propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
128.1. KJava
128.2. PDAP (PDA Profile)
128.3. PersonalJava
128.4. Embedded Java

Partie 20 : Annexes

Annexe A : GNU Free Documentation License
Annexe B : Glossaire