IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

 

Développons en Java   2.20  
Copyright (C) 1999-2019 Jean-Michel DOUDOUX    (date de publication : 06/01/2019)

[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]


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

 


[ Précédent ] [ Sommaire ] [ Suivant ] [Télécharger ]      [Accueil ]

78 commentaires Donner une note à l'article (5)

 

Copyright (C) 1999-2019 Jean-Michel DOUDOUX. Vous pouvez copier, redistribuer et/ou modifier ce document selon les termes de la Licence de Documentation Libre GNU, Version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation; les Sections Invariantes étant constitués du chapitre Préambule, aucun Texte de Première de Couverture, et aucun Texte de Quatrième de Couverture. Une copie de la licence est incluse dans la section GNU FreeDocumentation Licence. La version la plus récente de cette licence est disponible à l'adresse : GNU Free Documentation Licence.