Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :

Google+
Facebook
Twitter
RSS

 

Développons en Java   2.10  
Copyright (C) 1999-2016 Jean-Michel DOUDOUX    (date de publication : 19/03/2016)

[ 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. Un rapide historique de Java
1.3. Les différentes éditions et versions de Java
1.4. Un rapide tour d'horizon des API et de quelques outils
1.5. Les différences entre Java et JavaScript
1.6. 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 identificateurs
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
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

Partie 3 : Les API avancées


20. 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
20.1. La classe Class
20.2. La recherche des informations sur une classe
20.3. La définition dynamique d'objets
20.4. L'invocation dynamique d'une méthode
20.5. L'API Reflection et le SecurityManager
20.6. L'utilisation de l'API Reflection sur les annotations

21. L'appel de méthodes distantes : RMI
étudie la mise en oeuvre de la technologie RMI pour permettre l'appel de méthodes distantes
21.1. La présentation et l'architecture de RMI
21.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI
21.3. Le développement coté serveur
21.4. Le développement coté client
21.5. La génération de la classe stub
21.6. La mise en oeuvre des objets RMI

22. 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
22.1. La sécurité dans les spécifications du langage
22.2. Le contrôle des droits d'une application
22.3. La cryptographie
22.4. JCA (Java Cryptography Architecture) et JCE (Java Cryptography Extension)
22.5. JSSE (Java Secure Sockets Extension)
22.6. JAAS (Java Authentication and Authorization Service)

23. JCA (Java Cryptography Architecture)
détaille l'utilisation de l'API proposant des fonctionnalités cryptographiques de base
23.1. L'architecture de JCA
23.2. Les classes et interfaces de JCA
23.3. Les fournisseurs d'implémentations
23.4. La classe java.security.Provider
23.5. La classe java.security.Security
23.6. La classe java.security.MessageDigest
23.7. Les classes java.security.DigestInputStream et java.security.DigestOuputStream
23.8. La classe java.security.Signature
23.9. La classe java.security.KeyStore
23.10. Les interfaces de type java.security.Key
23.11. La classe java.security.KeyPair
23.12. La classe java.security.KeyPairGenerator
23.13. La classe java.security.KeyFactory
23.14. La classe java.security.SecureRandom
23.15. La classe java.security.AlgorithmParameters
23.16. La classe java.security.AlgorithmParameterGenerator
23.17. La classe java.security.cert.CertificateFactory
23.18. L'interface java.security.spec.KeySpec et ses implémentations
23.19. La classe java.security.spec.EncodedKeySpec et ses sous-classes
23.20. L'interface java.security.spec.AlgorithmParameterSpec

24. 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
24.1. La classe javax.crypto.KeyGenerator
24.2. La classe javax.crypto.SecretKeyFactory
24.3. La classe javax.crypto.Cipher
24.4. Les classes javax.crypto.CipherInputStream et javax.crypto.CipherOutputStream
24.5. La classe javax.crypto.SealedObject
24.6. La classe javax.crypto.Mac

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

26. JNDI (Java Naming and Directory Interface)
introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
26.1. La présentation de JNDI
26.2. La mise en oeuvre de l'API JNDI
26.3. L'utilisation d'un service de nommage
26.4. L'utilisation avec un DNS
26.5. L'utilisation du File System Context Provider
26.6. LDAP
26.7. L'utilisation avec un annuaire LDAP
26.8. JNDI et J2EE/Java EE

27. 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.
27.1. L'API Scripting

28. 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
28.1. La présentation de JMX
28.2. L'architecture de JMX
28.3. Un premier exemple
28.4. La couche instrumentation : les MBeans
28.5. Les MBeans standard
28.6. La couche agent
28.7. Les services d'un agent JMX
28.8. La couche services distribués
28.9. Les notifications
28.10. Les Dynamic MBeans
28.11. Les Model MBeans
28.12. Les Open MBeans
28.13. Les MXBeans
28.14. L'interface PersistentMBean
28.15. Le monitoring d'une JVM
28.16. Des recommandations pour l'utilisation de JMX
28.17. Des ressources

Partie 4 : La programmation parallèle et concurrente


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

30. 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"
30.1. L'interface Runnable
30.2. La classe Thread
30.3. Le cycle de vie d'un thread
30.4. Les démons (daemon threads)
30.5. Les groupes de threads
30.6. L'obtention d'informations sur un thread
30.7. La manipulation des threads
30.8. Les messages de synchronisation entre threads
30.9. Les restrictions sur les threads
30.10. Les threads et les classloaders
30.11. Les threads et la gestion des exceptions
30.12. Les piles

31. L'association de données à des threads
détaille les solutions utilisables pour permettre d'associer des données à un thread
31.1. La classe ThreadLocal
31.2. La classe InheritableThreadLocal
31.3. La classe ThreadLocalRandom

32. Le framework Executor
détaille l'utilisation du framework Executor
32.1. L'interface Executor
32.2. Les pools de threads
32.3. L'interface java.util.concurrent.Callable
32.4. L'interface java.util.concurrent.Future
32.5. L'interface java.util.concurrent.CompletionService

33. La gestion des accès concurrents
détaille différentes solutions pour gérer les accès concurrents dans les traitements en parallèle
33.1. Le mot clé volatile
33.2. Les races conditions
33.3. La synchronisation avec les verrous
33.4. Les opérations atomiques
33.5. L'immutabilité et la copie défensive

Partie 5 : Le développement des interfaces graphiques


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

35. Les éléments d'interfaces graphiques de l'AWT
recense les différents composants qui sont fournis dans la bibliothèque AWT
35.1. Les composants graphiques
35.2. La classe Component
35.3. Les conteneurs
35.4. Les menus
35.5. La classe java.awt.Desktop

36. La création d'interfaces graphiques avec AWT
indique comment réaliser des interfaces graphiques avec l'AWT
36.1. Le dimensionnement des composants
36.2. Le positionnement des composants
36.3. La création de nouveaux composants à partir de Panel
36.4. L'activation ou la désactivation des composants

37. 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
37.1. L'interception des actions de l'utilisateur avec Java version 1.0
37.2. L'interception des actions de l'utilisateur avec Java version 1.1

38. Le développement d'interfaces graphiques avec SWING
indique comment réaliser des interfaces graphiques avec Swing
38.1. La présentation de Swing
38.2. Les packages Swing
38.3. Un exemple de fenêtre autonome
38.4. Les composants Swing
38.5. Les boutons
38.6. Les composants de saisie de texte
38.7. Les onglets
38.8. Le composant JTree
38.9. Les menus
38.10. L'affichage d'une image dans une application.

39. Le développement d'interfaces graphiques avec SWT
indique comment réaliser des interfaces graphiques avec SWT
39.1. La présentation de SWT
39.2. Un exemple très simple
39.3. La classe SWT
39.4. L'objet Display
39.5. L'objet Shell
39.6. Les composants
39.7. Les conteneurs
39.8. La gestion des erreurs
39.9. Le positionnement des contrôles
39.10. La gestion des événements
39.11. Les boîtes de dialogue

40. JFace
présente l'utilisation de ce framework facilitant le développement d'applications utilisant SWT
40.1. La présentation de JFace
40.2. La structure générale d'une application
40.3. Les boites de dialogue

Partie 6 : L'utilisation de documents XML et JSON


41. 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
41.1. La présentation de XML
41.2. Les règles pour formater un document XML
41.3. La DTD (Document Type Definition)
41.4. Les parseurs
41.5. La génération de données au format XML
41.6. JAXP : Java API for XML Parsing
41.7. Jaxen

42. 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
42.1. L'utilisation de SAX de type 1
42.2. L'utilisation de SAX de type 2

43. 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
43.1. Les interfaces du DOM
43.2. L'obtention d'un arbre DOM
43.3. Le parcours d'un arbre DOM
43.4. La modification d'un arbre DOM
43.5. L'envoi d'un arbre DOM dans un flux

44. XSLT (Extensible Stylesheet Language Transformations)
présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
44.1. XPath
44.2. La syntaxe de XSLT
44.3. Un exemple avec Internet Explorer
44.4. Un exemple avec Xalan 2

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

46. 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.
46.1. JAXB 1.0
46.2. JAXB 2.0

47. 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
47.1. La présentation de StAX
47.2. Les deux API de StAX
47.3. Les fabriques
47.4. Le traitement d'un document XML avec l'API du type curseur
47.5. Le traitement d'un document XML avec l'API du type itérateur
47.6. La mise en oeuvre des filtres
47.7. L'écriture un document XML avec l'API de type curseur
47.8. L'écriture un document XML avec l'API de type itérateur
47.9. La comparaison entre SAX, DOM et StAX

48. JSON
présente le format JSON
48.1. La syntaxe de JSON
48.2. L'utilisation de JSON
48.3. JSON ou XML

49. Gson
Présente l'API Gson de Google pour la lecture et la génération de documents JSON
49.1. La classe Gson
49.2. La sérialisation
49.3. La désérialisation
49.4. La personnalisation de la sérialisation/désérialisation
49.5. Les annotations de Gson
49.6. L'API Streaming
49.7. Mixer l'utilisation du model objets et de l'API Streaming
49.8. Les concepts avancés

50. JSON-P (Java API for JSON Processing)
détaille l'utilisation de l'API Json-P spécifiée dans la JSR 353
50.1. La classe Json
50.2. L'API Streaming
50.3. L'API Object Model

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


51. 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)
51.1. La correspondance entre les modèles relationnel et objet
51.2. L'évolution des solutions de persistance avec Java
51.3. Le mapping O/R (objet/relationnel)
51.4. L'architecture et la persistance de données
51.5. Les différentes solutions
51.6. Les API standards
51.7. Les frameworks open source
51.8. L'utilisation de procédures stockées

52. JDBC (Java DataBase Connectivity)
indique comment utiliser cette API historique pour accéder aux bases de données
52.1. Les outils nécessaires pour utiliser JDBC
52.2. Les types de pilotes JDBC
52.3. L'enregistrement d'une base de données dans ODBC sous Windows 9x ou XP
52.4. La présentation des classes de l'API JDBC
52.5. La connexion à une base de données
52.6. L'accès à la base de données
52.7. L'obtention d'informations sur la base de données
52.8. L'utilisation d'un objet de type PreparedStatement
52.9. L'utilisation des transactions
52.10. Les procédures stockées
52.11. Le traitement des erreurs JDBC
52.12. JDBC 2.0
52.13. JDBC 3.0
52.14. MySQL et Java
52.15. L'amélioration des performances avec JDBC
52.16. Les ressources relatives à JDBC

53. JDO (Java Data Object)
API qui standardise et automatise le mapping entre des objets Java et un système de gestion de données
53.1. La présentation de JDO
53.2. Un exemple avec Lido
53.3. L'API JDO
53.4. La mise en oeuvre
53.5. Le parcours de toutes les occurrences
53.6. La mise en oeuvre de requêtes

54. Hibernate
présente Hibernate, un framework de mapping Objets/Relationnel open source
54.1. La création d'une classe qui va encapsuler les données
54.2. La création d'un fichier de correspondance
54.3. Les propriétés de configuration
54.4. L'utilisation d'Hibernate
54.5. La persistance d'une nouvelle occurrence
54.6. L'obtention d'une occurrence à partir de son identifiant
54.7. L'obtention de données
54.8. La mise à jour d'une occurrence
54.9. La suppression d'une ou plusieurs occurrences
54.10. Les relations
54.11. Le mapping de l'héritage de classes
54.12. Les caches d'Hibernate
54.13. Les outils de génération de code

55. 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.
55.1. L'installation de l'implémentation de référence
55.2. Les entités
55.3. Le fichier de configuration du mapping
55.4. L'utilisation du bean entité
55.5. Le fichier persistence.xml
55.6. La gestion des transactions hors Java EE
55.7. La gestion des relations entre tables dans le mapping
55.8. Le mapping de l'héritage de classes
55.9. Les callbacks d'événements

Partie 8 : La machine virtuelle Java (JVM)


56. La JVM (Java Virtual Machine)
ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
56.1. La mémoire de la JVM
56.2. Le cycle de vie d'une classe dans la JVM
56.3. Les ClassLoaders
56.4. Le bytecode
56.5. Le compilateur JIT
56.6. Les paramètres de la JVM HotSpot
56.7. Les interactions de la machine virtuelle avec des outils externes
56.8. Service Provider Interface (SPI)
56.9. Les JVM 32 et 64 bits

57. 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.
57.1. Le ramasse-miettes (Garbage Collector ou GC)
57.2. Le fonctionnement du ramasse-miettes de la JVM Hotspot
57.3. Le paramétrage du ramasse-miettes de la JVM HotSpot
57.4. Le monitoring de l'activité du ramasse-miettes
57.5. Les différents types de référence
57.6. L'obtention d'informations sur la mémoire de la JVM
57.7. Les fuites de mémoire (Memory leak)
57.8. Les exceptions liées à un manque de mémoire

58. 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.
58.1. Décompiler du bytecode
58.2. Obfusquer le bytecode

59. Programmation orientée aspects (AOP)
ce chapitre présente le concept de l'AOP (Apsect Oriented Programming
59.1. Le besoin d'un autre modèle de programmation
59.2. Les concepts de l'AOP
59.3. La mise en oeuvre de l'AOP
59.4. Les avantages et les inconvénients
59.5. Des exemples d'utilisation
59.6. Des implémentations pour la plate-forme Java

60. Terracotta
Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
60.1. La présentation de Terrocatta
60.2. Les concepts utilisés
60.3. La mise en oeuvre des fonctionnalités
60.4. Les cas d'utilisation
60.5. Quelques exemples de mise en oeuvre
60.6. La console développeur
60.7. Le fichier de configuration
60.8. La fiabilisation du cluster
60.9. Quelques recommandations

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


61. J2EE / Java EE
introduit la plate-forme Java 2 Entreprise Edition
61.1. La présentation de J2EE
61.2. Les API de J2EE
61.3. L'environnement d'exécution des applications J2EE
61.4. L'assemblage et le déploiement d'applications J2EE
61.5. J2EE 1.4 SDK
61.6. La présentation de Java EE 5.0
61.7. La présentation de Java EE 6
61.8. La présentation de Java EE 7

62. JavaMail
traite de l'API qui permet l'envoi et la réception d'e-mails
62.1. Le téléchargement et l'installation
62.2. Les principaux protocoles
62.3. Les principales classes et interfaces de l'API JavaMail
62.4. L'envoi d'un e-mail par SMTP
62.5. La récupération des messages d'un serveur POP3
62.6. Les fichiers de configuration

63. JMS (Java Messaging Service)
indique comment utiliser cette API qui permet l'échange de données entre applications grâce à un système de messages
63.1. La présentation de JMS
63.2. Les services de messages
63.3. Le package javax.jms
63.4. L'utilisation du mode point à point (queue)
63.5. L'utilisation du mode publication/abonnement (publish/subscribe)
63.6. La gestion des erreurs
63.7. JMS 1.1
63.8. Les ressources relatives à JMS

64. 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
64.1. La présentation des EJB
64.2. Les EJB session
64.3. Les EJB entité
64.4. Les outils pour développer et mettre en oeuvre des EJB
64.5. Le déploiement des EJB
64.6. L'appel d'un EJB par un client
64.7. Les EJB orientés messages

65. 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.
65.1. L'historique des EJB
65.2. Les nouveaux concepts et fonctionnalités utilisés
65.3. EJB 2.x vs EJB 3.0
65.4. Les conventions de nommage
65.5. Les EJB de type Session
65.6. Les EJB de type Entity
65.7. Un exemple simple complet
65.8. L'utilisation des EJB par un client
65.9. L'injection de dépendances
65.10. Les intercepteurs
65.11. Les EJB de type MessageDriven
65.12. Le packaging des EJB
65.13. Les transactions
65.14. La mise en oeuvre de la sécurité

66. Les EJB 3.1
ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
66.1. Les interfaces locales sont optionnelles
66.2. Les EJB Singleton
66.3. EJB Lite
66.4. La simplification du packaging
66.5. Les améliorations du service Timer
66.6. La standardisation des noms JNDI
66.7. L'invocation asynchrone des EJB session
66.8. L'invocation d'un EJB hors du conteneur

67. 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
67.1. La présentation des services web
67.2. Les standards
67.3. Les différents formats de services web SOAP
67.4. Des conseils pour la mise en oeuvre
67.5. Les API Java pour les services web
67.6. Les implémentations des services web
67.7. Inclure des pièces jointes dans SOAP
67.8. WS-I
67.9. Les autres spécifications

68. Les WebSockets
présente le procotole WebSocket
68.1. Les limitations du protocole HTTP
68.2. La spécification du protocole WebSocket
68.3. La connexion à une WebSocket
68.4. La mise en oeuvre des WebSockets

69. L'API WebSocket
détaille l'utilisation de l'API Java API for WebSocket spécifiée par la JSR 356
69.1. Les principales classes et interfaces
69.2. Le développement d'un endpoint
69.3. Les encodeurs et les décodeurs
69.4. Le débogage des WebSockets
69.5. Des exemples d'utilisation
69.6. L'utilisation d'implémentations

Partie 10 : Le développement d'applications web


70. Les servlets
plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
70.1. La présentation des servlets
70.2. L'API servlet
70.3. Le protocole HTTP
70.4. Les servlets http
70.5. Les informations sur l'environnement d'exécution des servlets
70.6. L'utilisation des cookies
70.7. Le partage d'informations entre plusieurs échanges HTTP
70.8. Packager une application web
70.9. L'utilisation de Log4J dans une servlet

71. 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
71.1. La présentation des JSP
71.2. Les outils nécessaires
71.3. Le code HTML
71.4. Les Tags JSP
71.5. Un exemple très simple
71.6. La gestion des erreurs
71.7. Les bibliothèques de tags personnalisés (custom taglibs)

72. JSTL (Java server page Standard Tag Library)
est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
72.1. Un exemple simple
72.2. Le langage EL (Expression Language)
72.3. La bibliothèque Core
72.4. La bibliothèque XML
72.5. La bibliothèque I18n
72.6. La bibliothèque Database

73. Struts
présente et détaille la mise en oeuvre du framework open source de développement d'applications web le plus populaire
73.1. L'installation et la mise en oeuvre
73.2. Le développement des vues
73.3. La configuration de Struts
73.4. Les bibliothèques de tags personnalisés
73.5. La validation de données

74. 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.
74.1. La présentation de JSF
74.2. Le cycle de vie d'une requête
74.3. Les implémentations
74.4. Le contenu d'une application
74.5. La configuration de l'application
74.6. Les beans
74.7. Les composants pour les interfaces graphiques
74.8. La bibliothèque de tags Core
74.9. La bibliothèque de tags Html
74.10. La gestion et le stockage des données
74.11. La conversion des données
74.12. La validation des données
74.13. La sauvegarde et la restauration de l'état
74.14. Le système de navigation
74.15. La gestion des événements
74.16. Le déploiement d'une application
74.17. Un exemple d'application simple
74.18. L'internationalisation
74.19. Les points faibles de JSF

75. D'autres frameworks pour les applications web
présente rapidement quelques frameworks open source pour le développement d'applications web
75.1. Les frameworks pour les applications web
75.2. Les moteurs de templates

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


76. 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.
76.1. Les applications de type RIA
76.2. Les applications de type RDA
76.3. Les contraintes
76.4. Les solutions RIA
76.5. Les solutions RDA

77. Les applets
plonge au coeur des premières applications qui ont rendu Java célèbre
77.1. L'intégration d'applets dans une page HTML
77.2. Les méthodes des applets
77.3. Les interfaces utiles pour les applets
77.4. La transmission de paramètres à une applet
77.5. Les applets et le multimédia
77.6. Une applet pouvant s'exécuter comme une application
77.7. Les droits des applets

78. Java Web Start (JWS)
est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
78.1. La création du package de l'application
78.2. La signature d'un fichier jar
78.3. Le fichier JNLP
78.4. La configuration du serveur web
78.5. Le fichier HTML
78.6. Le test de l'application
78.7. L'utilisation du gestionnaire d'applications
78.8. L'API de Java Web Start

79. 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é.
79.1. La présentation d'AJAX
79.2. Le détail du mode de fonctionnement
79.3. Un exemple simple
79.4. Des frameworks pour mettre en oeuvre AJAX

80. GWT (Google Web Toolkit)
GWT est un framework pour le développement d'applications de type RIA
80.1. La présentation de GWT
80.2. La création d'une application
80.3. Les modes d'exécution
80.4. Les éléments de GWT
80.5. L'interface graphique des applications GWT
80.6. La personnalisation de l'interface
80.7. Les composants (widgets)
80.8. Les panneaux (panels)
80.9. La création d'éléments réutilisables
80.10. Les événements
80.11. JSNI
80.12. La configuration et l'internationalisation
80.13. L'appel de procédures distantes (Remote Procedure Call)
80.14. La manipulation des documents XML
80.15. La gestion de l'historique sur le navigateur
80.16. Les tests unitaires
80.17. Le déploiement d'une application
80.18. Des composants tiers
80.19. Les ressources relatives à GWT

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


81. Spring
ce chapitre est une présentation générale de Spring
81.1. Le but et les fonctionnalités proposées par Spring
81.2. L'historique de Spring
81.3. Spring Framework
81.4. Les projets du portfolio Spring
81.5. Les avantages et les inconvénients de Spring
81.6. Spring et Java EE

82. 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
82.1. Les fondements de Spring
82.2. Le conteneur Spring
82.3. Le fichier de configuration
82.4. L'injection de dépendances
82.5. Spring Expression Langage (SpEL)
82.6. La configuration en utilisant les annotations
82.7. Le scheduling

83. La mise en oeuvre de l'AOP avec Spring
présente la mise en oeuvre de l'AOP avec Spring
83.1. Spring AOP
83.2. AspectJ
83.3. Spring AOP et AspectJ
83.4. L'utilisation des namespaces

84. La gestion des transactions avec Spring
ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
84.1. La gestion des transactions par Spring
84.2. La propagation des transactions
84.3. L'utilisation des transactions de manière déclarative
84.4. La déclaration des transactions avec des annotations
84.5. La gestion du rollback des transactions
84.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
84.7. L'utilisation des transactions via l'API
84.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

85. Spring et JMS
ce chapitre couvre la mise en oeuvre de JMS dans Spring
85.1. Les packages de Spring JMS
85.2. La classe JmsTemplate : le template JMS de Spring
85.3. La réception asynchrone de messages
85.4. L'espace de nommage jms

86. Spring et JMX
ce chapitre détaille la façon dont Spring facilite la mise en oeuvre de JMX
86.1. L'enregistrement d'un bean en tant que MBean
86.2. Le nommage des MBeans
86.3. Les Assembler
86.4. L'utilisation des annotations
86.5. Le développement d'un client JMX
86.6. Les notifications

Partie 13 : Les outils pour le développement


87. Les outils du J.D.K.
indique comment utiliser les outils fournis avec le JDK
87.1. Le compilateur javac
87.2. L'interpréteur java/javaw
87.3. L'outil jar
87.4. L'outil appletviewer pour tester des applets
87.5. L'outil javadoc pour générer la documentation technique
87.6. L'outil Java Check Update pour mettre à jour Java
87.7. La base de données Java DB
87.8. L'outil JConsole
87.9. VisualVM

88. JavaDoc
explore l'outil de documentation fourni avec le JDK
88.1. La mise en oeuvre
88.2. Les tags définis par javadoc
88.3. Un exemple
88.4. Les fichiers pour enrichir la documentation des packages
88.5. La documentation générée

89. Les outils libres et commerciaux
tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
89.1. Les environnements de développement intégrés (IDE)
89.2. Les serveurs d'application
89.3. Les conteneurs web
89.4. Les conteneurs d'EJB
89.5. Les outils divers
89.6. Les MOM
89.7. Les outils concernant les bases de données
89.8. Les outils de modélisation UML

90. Ant
propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
90.1. L'installation de l'outil Ant
90.2. L'exécution de l'outil Ant
90.3. Le fichier build.xml
90.4. Les tâches (task)

91. Maven
présente l'outil open source Maven qui facilite et automatise certaines tâches de la gestion d'un projet
91.1. Les différentes versions de Maven
91.2. Maven 1
91.3. Maven 2

92. Tomcat
Détaille la mise en oeuvre du conteneur web Tomcat
92.1. L'historique des versions
92.2. L'installation
92.3. L'exécution de Tomcat
92.4. L'architecture
92.5. La configuration
92.6. L'outil Tomcat Administration Tool
92.7. Le déploiement des applications WEB
92.8. Tomcat pour le développeur
92.9. Le gestionnaire d'applications (Tomcat manager)
92.10. L'outil Tomcat Client Deployer
92.11. Les optimisations
92.12. La sécurisation du serveur

93. 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.
93.1. CheckStyle
93.2. Jalopy

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


94. Java et UML
propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
94.1. La présentation d'UML
94.2. Les commentaires
94.3. Les cas d'utilisations (use cases)
94.4. Le diagramme de séquence
94.5. Le diagramme de collaboration
94.6. Le diagramme d'états-transitions
94.7. Le diagramme d'activités
94.8. Le diagramme de classes
94.9. Le diagramme d'objets
94.10. Le diagramme de composants
94.11. Le diagramme de déploiement

95. 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
95.1. Les modèles de création
95.2. Les modèles de structuration
95.3. Les modèles de comportement

96. 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
96.1. Les fichiers
96.2. La documentation du code
96.3. Les déclarations
96.4. Les séparateurs
96.5. Les traitements
96.6. Les règles de programmation

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

98. L'encodage des caractères
ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
98.1. L'utilisation des caractères dans la JVM
98.2. Les jeux d'encodages de caractères
98.3. Unicode
98.4. L'encodage de caractères
98.5. L'encodage du code source
98.6. L'encodage de caractères avec différentes technologies

99. Les frameworks
présente les frameworks et propose quelques solutions open source dans divers domaines
99.1. La présentation des concepts
99.2. Les frameworks pour les applications web
99.3. L'architecture pour les applications web
99.4. Le modèle MVC type 1
99.5. Le modèle MVC de type 2
99.6. Les frameworks de mapping Objet/Relationel
99.7. Les frameworks de logging

100. 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
100.1. Apache POI
100.2. iText

101. 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.
101.1. Quelques recommandations sur la validation des données
101.2. L'API Bean Validation (JSR 303)
101.3. D'autres frameworks pour la validation des données

102. L'utilisation des dates
ce chapitre détaille l'utilisation des dates en Java
102.1. Les classes standard du JDK pour manipuler des dates
102.2. Des exemples de manipulations de dates
102.3. La classe SimpleDateFormat
102.4. Joda Time
102.5. La classe FastDateFormat du projet Apache commons.lang
102.6. L'API Date and Time

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

104. Des bibliothèques open source
présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
104.1. JFreeChart
104.2. Beanshell
104.3. Apache Commons
104.4. JGoodies
104.5. Apache Lucene

105. Apache Commons
Ce chapitre décrit quelques fonctionnalités de la bibliothèque Apache Commons
105.1. Apache Commons Configuration
105.2. Apache Commons CLI

Partie 15 : Les tests automatisés


106. Les frameworks de tests
propose une présentation de frameworks et d'outils pour faciliter les tests du code
106.1. Les tests unitaires
106.2. Les frameworks et outils de tests

107. JUnit
présente en détail le framework de tests unitaires le plus utilisé
107.1. Un exemple très simple
107.2. L'écriture des cas de tests
107.3. L'exécution des tests
107.4. Les suites de tests
107.5. L'automatisation des tests avec Ant
107.6. JUnit 4

108. Les objets de type mock
ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
108.1. Les doublures d'objets et les objets de type mock
108.2. L'utilité des objets de type mock
108.3. Les tests unitaires et les dépendances
108.4. L'obligation d'avoir une bonne organisation du code
108.5. Les frameworks
108.6. Les inconvénients des objets de type mock

Partie 16 : Java et le monde informatique


109. La communauté Java
ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
109.1. Le JCP
109.2. Les ressources proposées par Oracle
109.3. Oracle Technology Network
109.4. La communauté Java.net
109.5. Les JUG
109.6. D'autres User Groups
109.7. Les Cast Codeurs Podcast
109.8. Parleys.com
109.9. Les conférences
109.10. Webographie
109.11. Les communautés open source

110. Les plate-formes Java et .Net
ce chapitre présente rapidement les deux plate-formes
110.1. La présentation des plate-formes Java et .Net
110.2. La compilation
110.3. Les environnements d'exécution
110.4. Le déploiement des modules
110.5. Les version des modules
110.6. L'interopérabilité inter-language
110.7. La décompilation
110.8. Les API des deux plate-formes

111. Java et C#
ce chapitre détaille les principales fonctionnalités des langages Java et C#
111.1. La syntaxe
111.2. La programmation orientée objet
111.3. Les chaînes de caractères
111.4. Les tableaux
111.5. Les indexeurs
111.6. Les exceptions
111.7. Le multitâche
111.8. L'appel de code natif
111.9. Les pointeurs
111.10. La documentation automatique du code
111.11. L'introspection/reflection
111.12. La sérialisation

Partie 17 : Le développement d'applications mobiles


112. 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
112.1. L'historique de la plate-forme
112.2. La présentation de J2ME / Java ME
112.3. Les configurations
112.4. Les profiles
112.5. J2ME Wireless Toolkit 1.0.4
112.6. J2ME wireless toolkit 2.1

113. CLDC
présente les packages et les classes de la configuration CLDC
113.1. Le package java.lang
113.2. Le package java.io
113.3. Le package java.util
113.4. Le package javax.microedition.io

114. MIDP
propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
114.1. Les Midlets
114.2. L'interface utilisateur
114.3. La gestion des événements
114.4. Le stockage et la gestion des données
114.5. Les suites de midlets
114.6. Packager une midlet
114.7. MIDP for Palm O.S.

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

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

117. Les autres technologies pour les applications mobiles
propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
117.1. KJava
117.2. PDAP (PDA Profile)
117.3. PersonalJava
117.4. Java Phone
117.5. JavaCard
117.6. Embedded Java
117.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 ]

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

 

Copyright (C) 1999-2016 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.

Responsable bénévole de la rubrique Java : Mickael Baron -