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 bref 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 identificateurs
3.3. Les commentaires
3.4. La déclaration et l'utilisation de variables
3.5. Les opérations arithmétiques
3.6. La priorité des opérateurs
3.7. Les structures de contrôles
3.8. Les tableaux
3.9. Les conversions de types
3.10. 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é de Java pour 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. Le multitâche
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"
8.1. L'interface Runnable
8.2. La classe Thread
8.3. La création et l'exécution d'un thread
8.4. La classe ThreadGroup
8.5. Un thread en tâche de fond (démon)
8.6. L'exclusion mutuelle

9. JDK 1.5 (nom de code Tiger)
détaille les nouvelles fonctionnalités du langage de la version 1.5
9.1. Les nouveautés du langage Java version 1.5
9.2. L'autoboxing / unboxing
9.3. Les importations statiques
9.4. Les annotations ou métadonnées (Meta Data)
9.5. Les arguments variables (varargs)
9.6. Les generics
9.7. Les boucles pour le parcours des collections
9.8. Les énumérations (type enum)

10. Les annotations
présente les annotations qui sont des métadonnées insérées dans le code source et leurs mises en oeuvre.
10.1. La présentation des annotations
10.2. La mise en oeuvre des annotations
10.3. L'utilisation des annotations
10.4. Les annotations standards
10.5. Les annotations communes (Common Annotations)
10.6. Les annotations personnalisées
10.7. L'exploitation des annotations
10.8. L'API Pluggable Annotation Processing
10.9. Les ressources relatives aux annotations

11. Java SE 7 : le projet Coin
ce chapitre décrit les changements syntaxiques proposés par le projet Coin dans Java SE 7
11.1. Les entiers exprimés en binaire (Binary Literals)
11.2. Utilisation des underscores dans les entiers littéraux
11.3. Utilisation des strings dans l'instruction switch
11.4. L'opérateur diamant
11.5. L'instruction try-with-resources
11.6. Des types plus précis lorsqu'une exception est relevée dans une clause catch
11.7. Multiples exceptions dans une clause catch

Partie 2 : Développement des interfaces graphiques


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

13. Les éléments d'interfaces graphiques de l'AWT
recense les différents composants qui sont fournis dans la bibliothèque AWT
13.1. Les composants graphiques
13.2. La classe Component
13.3. Les conteneurs
13.4. Les menus
13.5. La classe java.awt.Desktop

14. La création d'interfaces graphiques avec AWT
indique comment réaliser des interfaces graphiques avec l'AWT
14.1. Le dimensionnement des composants
14.2. Le positionnement des composants
14.3. La création de nouveaux composants à partir de Panel
14.4. L'activation ou la désactivation des composants

15. 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
15.1. L'interception des actions de l'utilisateur avec Java version 1.0
15.2. L'interception des actions de l'utilisateur avec Java version 1.1

16. Le développement d'interfaces graphiques avec SWING
indique comment réaliser des interfaces graphiques avec Swing
16.1. La présentation de Swing
16.2. Les packages Swing
16.3. Un exemple de fenêtre autonome
16.4. Les composants Swing
16.5. Les boutons
16.6. Les composants de saisie de texte
16.7. Les onglets
16.8. Le composant JTree
16.9. Les menus
16.10. L'affichage d'une image dans une application.

17. Le développement d'interfaces graphiques avec SWT
indique comment réaliser des interfaces graphiques avec SWT
17.1. La présentation de SWT
17.2. Un exemple très simple
17.3. La classe SWT
17.4. L'objet Display
17.5. L'objet Shell
17.6. Les composants
17.7. Les conteneurs
17.8. La gestion des erreurs
17.9. Le positionnement des contrôles
17.10. La gestion des événements
17.11. Les boîtes de dialogue

18. JFace
présente l'utilisation de ce framework facilitant le développement d'applications utilisant SWT
18.1. La présentation de JFace
18.2. La structure générale d'une application
18.3. Les boites de dialogue

Partie 3 : Les API avancées


19. Les collections
propose une revue des classes fournies par le JDK pour gérer des ensembles d'objets
19.1. Présentation du framework collection
19.2. Les interfaces des collections
19.3. Les listes
19.4. Les ensembles
19.5. Les collections gérées sous la forme clé/valeur
19.6. Le tri des collections
19.7. Les algorithmes
19.8. Les exceptions du framework

20. Les flux
explore les classes utiles à la mise en oeuvre d'un des mécanismes de base pour échanger des données
20.1. La présentation des flux
20.2. Les classes de gestion des flux
20.3. Les flux de caractères
20.4. Les flux d'octets
20.5. La classe File
20.6. Les fichiers à accès direct
20.7. La classe java.io.Console

21. La sérialisation
ce procédé permet de rendre un objet persistant
21.1. Les classes et les interfaces de la sérialisation
21.2. Le mot clé transient
21.3. La sérialisation personnalisée

22. 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
22.1. L'introduction aux concepts liés au réseau
22.2. Les adresses internet
22.3. L'accès aux ressources avec une URL
22.4. L'utilisation du protocole TCP
22.5. L'utilisation du protocole UDP
22.6. Les exceptions liées au réseau
22.7. Les interfaces de connexions au réseau

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

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. L'internationalisation
traite d'une façon pratique de la possibilité d'internationaliser une application
25.1. Les objets de type Locale
25.2. La classe ResourceBundle
25.3. Un guide pour réaliser la localisation

26. Les composants Java beans
examine comment développer et utiliser des composants réutilisables
26.1. La présentation des Java beans
26.2. Les propriétés.
26.3. Les méthodes
26.4. Les événements
26.5. L'introspection
26.6. Paramétrage du bean ( Customization )
26.7. La persistance
26.8. La diffusion sous forme de jar

27. 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
27.1. La présentation du logging
27.2. Log4j
27.3. L'API logging
27.4. Jakarta Commons Logging (JCL)
27.5. D'autres API de logging

28. 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
28.1. La sécurité dans les spécifications du langage
28.2. Le contrôle des droits d'une application
28.3. JCE (Java Cryptography Extension)
28.4. JSSE (Java Secure Sockets Extension)
28.5. JAAS (Java Authentication and Authorization Service)

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

30. JNDI (Java Naming and Directory Interface)
introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
30.1. La présentation de JNDI
30.2. La mise en oeuvre de l'API JNDI
30.3. L'utilisation d'un service de nommage
30.4. L'utilisation avec un DNS
30.5. L'utilisation du File System Context Provider de Sun
30.6. LDAP
30.7. L'utilisation avec un annuaire LDAP
30.8. JNDI et J2EE/Java EE

31. 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.
31.1. L'API Scripting

32. 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
32.1. La présentation de JMX
32.2. L'architecture de JMX
32.3. Un premier exemple
32.4. La couche instrumentation : les MBeans
32.5. Les MBeans standards
32.6. La couche agent
32.7. Les services d'un agent JMX
32.8. La couche services distribués
32.9. Les notifications
32.10. Les Dynamic MBeans
32.11. Les Model MBeans
32.12. Les Open MBeans
32.13. Les MXBeans
32.14. L'interface PersistentMBean
32.15. Le monitoring d'une JVM
32.16. Des recommandations pour l'utilisation de JMX
32.17. Des ressources

Partie 4 : L'utilisation de documents XML


33. Java et XML
présente XML qui est une technologie qui s'est imposée pour les échanges de données et explore les API Java pour utiliser XML
33.1. La présentation de XML
33.2. Les règles pour formater un document XML
33.3. La DTD (Document Type Definition)
33.4. Les parseurs
33.5. La génération de données au format XML
33.6. JAXP : Java API for XML Parsing
33.7. Jaxen

34. 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
34.1. L'utilisation de SAX

35. 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
35.1. Les interfaces du DOM
35.2. L'obtention d'un arbre DOM
35.3. Le parcours d'un arbre DOM
35.4. La modification d'un arbre DOM
35.5. L'envoie d'un arbre DOM dans un flux

36. XSLT (Extensible Stylesheet Language Transformations)
présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
36.1. XPath
36.2. La syntaxe de XSLT
36.3. Un exemple avec Internet Explorer
36.4. Un exemple avec Xalan 2

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

38. 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.
38.1. JAXB 1.0
38.2. JAXB 2.0

39. 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 peut de mémoire tout en permettant de garder le contrôle sur les opérations d'analyse ou d'écriture
39.1. La présentation de StAX
39.2. Les deux API de StAX
39.3. Les fabriques
39.4. Le traitement d'un document XML avec l'API du type curseur
39.5. Le traitement d'un document XML avec l'API du type itérateur
39.6. La mise en oeuvre des filtres
39.7. L'écriture un document XML avec l'API de type curseur
39.8. L'écriture un document XML avec l'API de type itérateur
39.9. La comparaison entre SAX, DOM et StAX

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


40. 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)
40.1. La correspondance entre le modèle relationnel et objet
40.2. L'évolution des solutions de persistance avec Java
40.3. Le mapping O/R (objet/relationnel)
40.4. L'architecture et la persistance de données
40.5. Les différentes solutions
40.6. Les API standards
40.7. Les frameworks open source
40.8. L'utilisation de procédures stockées

41. JDBC (Java DataBase Connectivity)
indique comment utiliser cette API historique pour accéder aux bases de données
41.1. Les outils nécessaires pour utiliser JDBC
41.2. Les types de pilotes JDBC
41.3. L'enregistrement d'une base de données dans ODBC sous Windows 9x ou XP
41.4. La présentation des classes de l'API JDBC
41.5. La connexion à une base de données
41.6. L'accès à la base de données
41.7. L'obtention d'informations sur la base de données
41.8. L'utilisation d'un objet PreparedStatement
41.9. L'utilisation des transactions
41.10. Les procédures stockées
41.11. Le traitement des erreurs JDBC
41.12. JDBC 2.0
41.13. JDBC 3.0
41.14. MySQL et Java
41.15. L'amélioration des performances avec JDBC
41.16. Les ressources relatives à JDBC

42. JDO (Java Data Object)
API qui standardise et automatise le mapping en des objets Java et un système de gestion de données
42.1. La présentation de JDO
42.2. Un exemple avec Lido
42.3. L'API JDO
42.4. La mise en oeuvre
42.5. Le parcours de toutes les occurrences
42.6. La mise en oeuvre de requêtes

43. Hibernate
présente Hibernate, un framework de mapping Objets/Relationnel open source
43.1. La création d'une classe qui va encapsuler les données
43.2. La création d'un fichier de correspondance
43.3. Les propriétés de configuration
43.4. L'utilisation d'Hibernate
43.5. La persistance d'une nouvelle occurrence
43.6. L'obtention d'une occurrence à partir de son identifiant
43.7. L'obtention de données
43.8. La mise à jour d'une occurrence
43.9. La suppression d'une ou plusieurs occurrences
43.10. Les relations
43.11. Les outils de génération de code

44. 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.
44.1. L'installation de l'implémentation de référence
44.2. Les entités
44.3. Le fichier de configuration du mapping
44.4. L'utilisation du bean entité
44.5. Le fichier persistence.xml
44.6. La gestion des transactions hors Java EE
44.7. La gestion des relations entre tables dans le mapping
44.8. Les callbacks d'événements

Partie 6 : La machine virtuelle Java (JVM)


45. La JVM (Java Virtual Machine)
ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
45.1. La mémoire de la JVM
45.2. Le cycle de vie d'une classe dans la JVM
45.3. Les ClassLoaders
45.4. Le bytecode
45.5. Le compilateur JIT
45.6. Les paramètres de la JVM HotSpot
45.7. Les interactions de la machine virtuelle avec des outils externes
45.8. Service Provider Interface (SPI)

46. 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.
46.1. Le ramasse miettes (Garbage Collector ou GC)
46.2. Le fonctionnement du ramasse miettes de la JVM Hotspot
46.3. Le paramétrage du ramasse miettes de la JVM HotSpot
46.4. Le monitoring de l'activité du ramasse miettes
46.5. Les différents types de référence
46.6. L'obtention d'informations sur la mémoire de la JVM
46.7. Les fuites de mémoire (Memory leak)
46.8. Les exceptions liées à un manque de mémoire

47. 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.
47.1. Décompiler du bytecode
47.2. Obfusquer le bytecode

48. Terracotta
Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
48.1. La présentation de Terrocatta
48.2. Les concepts utilisés
48.3. La mise en oeuvre des fonctionnalités
48.4. Les cas d'utilisation
48.5. Quelques exemples de mise en oeuvre
48.6. La console développeur
48.7. Le fichier de configuration
48.8. La fiabilisation du cluster
48.9. Quelques recommandations

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


49. J2EE / Java EE
introduit la plate-forme Java 2 Entreprise Edition
49.1. La présentation de J2EE
49.2. Les API de J2EE
49.3. L'environnement d'exécution des applications J2EE
49.4. L'assemblage et le déploiement d'applications J2EE
49.5. J2EE 1.4 SDK
49.6. La présentation de Java EE 5.0
49.7. La présentation de Java EE 6

50. JavaMail
traite de l'API qui permet l'envoi et la réception d'e-mails
50.1. Le téléchargement et l'installation
50.2. Les principaux protocoles
50.3. Les principales classes et interfaces de l'API JavaMail
50.4. L'envoi d'un e-mail par SMTP
50.5. La récupération des messages d'un serveur POP3
50.6. Les fichiers de configuration

51. JMS (Java Messaging Service)
indique comment utiliser cette API qui permet l'utilisation de système de messages pour l'échange de données entre applications
51.1. La présentation de JMS
51.2. Les services de messages
51.3. Le package javax.jms
51.4. L'utilisation du mode point à point (queue)
51.5. L'utilisation du mode publication/abonnement (publish/subscribe)
51.6. La gestion des erreurs
51.7. JMS 1.1
51.8. Les ressources relatives à JMS

52. 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
52.1. La présentation des EJB
52.2. Les EJB session
52.3. Les EJB entité
52.4. Les outils pour développer et mettre en oeuvre des EJB
52.5. Le déploiement des EJB
52.6. L'appel d'un EJB par un client
52.7. Les EJB orientés messages

53. 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.
53.1. L'historique des EJB
53.2. Les nouveaux concepts et fonctionnalités utilisés
53.3. EJB 2.x vs EJB 3.0
53.4. Les conventions de nommage
53.5. Les EJB de type Session
53.6. Les EJB de type Entity
53.7. Un exemple simple complet
53.8. L'utilisation des EJB par un client
53.9. L'injection de dépendances
53.10. Les intercepteurs
53.11. Les EJB de type MessageDriven
53.12. Le packaging des EJB
53.13. Les tests des EJB
53.14. Les transactions
53.15. La mise en oeuvre de la sécurité

54. Les EJB 3.1
ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
54.1. Les interfaces locales sont optionnelles
54.2. Les EJB Singleton
54.3. EJB Lite
54.4. La simplification du packaging
54.5. Les améliorations du service Timer
54.6. La standardisation des noms JNDI
54.7. L'invocation asynchrone des EJB session
54.8. L'invocation d'un EJB hors du conteneur

55. 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
55.1. La présentation des services web
55.2. Les standards
55.3. Les différents formats de services web SOAP
55.4. Des conseils pour la mise en oeuvre
55.5. Les API Java pour les services web
55.6. Les implémentations des services web
55.7. Inclure des pièces jointes dans SOAP
55.8. WS-I
55.9. Les autres spécifications

Partie 8 : Le développement d'applications web


56. Les servlets
plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
56.1. La présentation des servlets
56.2. L'API servlet
56.3. Le protocole HTTP
56.4. Les servlets http
56.5. Les informations sur l'environnement d'exécution des servlets
56.6. L'utilisation des cookies
56.7. Le partage d'informations entre plusieurs échanges HTTP
56.8. Packager une application web
56.9. L'utilisation de Log4J dans une servlet

57. Les JSP (Java Server Pages)
poursuit la discussion avec les servlets en explorant un mécanisme basé sur celles-ci pour réaliser facilement des pages web dynamiques
57.1. La présentation des JSP
57.2. Les outils nécessaires
57.3. Le code HTML
57.4. Les Tags JSP
57.5. Un exemple très simple
57.6. La gestion des erreurs
57.7. Les bibliothèques de tags personnalisés (custom taglibs)

58. JSTL (Java server page Standard Tag Library)
est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
58.1. Un exemple simple
58.2. Le langage EL (Expression Langage)
58.3. La bibliothèque Core
58.4. La bibliothèque XML
58.5. La bibliothèque I18n
58.6. La bibliothèque Database

59. Struts
présente et détaille la mise en oeuvre de ce framework open source de développement d'applications web le plus populaire
59.1. L'installation et la mise en oeuvre
59.2. Le développement des vues
59.3. La configuration de Struts
59.4. Les bibliothèques de tags personnalisés
59.5. La validation de données

60. 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.
60.1. La présentation de JSF
60.2. Le cycle de vie d'une requête
60.3. Les implémentations
60.4. Le contenu d'une application
60.5. La configuration de l'application
60.6. Les beans
60.7. Les composants pour les interfaces graphiques
60.8. La bibliothèque de tags Core
60.9. La bibliothèque de tags Html
60.10. La gestion et le stockage des données
60.11. La conversion des données
60.12. La validation des données
60.13. La sauvegarde et la restauration de l'état
60.14. Le système de navigation
60.15. La gestion des événements
60.16. Le déploiement d'une application
60.17. Un exemple d'application simple
60.18. L'internationalisation
60.19. Les points faibles de JSF

61. D'autres frameworks pour les applications web
présente rapidement quelques frameworks open source pour le développement d'applications web
61.1. Les frameworks pour les applications web
61.2. Les moteurs de templates

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


62. 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.
62.1. Les applications de type RIA
62.2. Les applications de type RDA
62.3. Les contraintes
62.4. Les solutions RIA
62.5. Les solutions RDA

63. Les applets
plonge au coeur des premières applications qui ont rendu Java célèbre
63.1. L'intégration d'applets dans une page HTML
63.2. Les méthodes des applets
63.3. Les interfaces utiles pour les applets
63.4. La transmission de paramètres à une applet
63.5. Les applets et le multimédia
63.6. Une applet pouvant s'exécuter comme une application
63.7. Les droits des applets

64. Java Web Start (JWS)
est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
64.1. La création du package de l'application
64.2. La signature d'un fichier jar
64.3. Le fichier JNLP
64.4. La configuration du serveur web
64.5. Le fichier HTML
64.6. Le test de l'application
64.7. L'utilisation du gestionnaire d'applications
64.8. L'API de Java Web Start

65. Ajax
présente ce concept qui permet de rendre les applications web plus conviviale et plus dynamique. Le framework open source DWR est aussi détaillé.
65.1. La présentation d'Ajax
65.2. Le détail du mode de fonctionnement
65.3. Un exemple simple
65.4. Des frameworks pour mettre en oeuvre Ajax

66. GWT (Google Web Toolkit)
GWT est un framework pour le développement d'applications de type RIA
66.1. La présentation de GWT
66.2. La création d'une application
66.3. Les modes d'exécution
66.4. Les éléments de GWT
66.5. L'interface graphique des applications GWT
66.6. La personnalisation de l'interface
66.7. Les composants (widgets)
66.8. Les panneaux (panels)
66.9. La création d'éléments réutilisables
66.10. Les événements
66.11. JSNI
66.12. La configuration et l'internationalisation
66.13. L'appel de procédures distantes (Remote Procedure Call)
66.14. La manipulation des documents XML
66.15. La gestion de l'historique sur le navigateur
66.16. Les tests unitaires
66.17. Le déploiement d'une application
66.18. Des composants tiers
66.19. Les ressources relatives à GWT

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


67. Spring
ce chapitre est une présentation générale de Spring
67.1. Le but et les fonctionnalités proposées par Spring
67.2. L'historique de Spring
67.3. Spring Framework
67.4. Les projets du portfolio Spring
67.5. Les avantages et les inconvénients de Spring
67.6. Spring et Java EE

68. 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
68.1. Les fondements de Spring
68.2. Le conteneur Spring
68.3. Le fichier de configuration
68.4. L'injection de dépendances
68.5. Spring Expression Langage (SpEL)
68.6. La configuration en utilisant les annotations
68.7. Le scheduling

69. La mise en oeuvre de l'AOP avec Spring
xxx
69.1. Spring AOP
69.2. AspectJ
69.3. Spring AOP et AspectJ
69.4. L'utilisation des namespaces

70. La gestion des transactions avec Spring
ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
70.1. La gestion des transactions par Spring
70.2. La propagation des transactions
70.3. L'utilisation des transactions de manière déclarative
70.4. La déclaration des transactions avec des annotations
70.5. La gestion du rollback des transactions
70.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
70.7. L'utilisation des transactions via l'API
70.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

71. Spring et JMS
ce chapitre couvre la mise en oeuvre de JMS dans Spring
71.1. Les packages de Spring JMS
71.2. La classe JmsTemplate : le template JMS de Spring
71.3. La réception asynchrone de messages
71.4. L'espace de nommage jms

Partie 11 : Les outils pour le développement


72. Les outils du J.D.K.
indique comment utiliser les outils fournis avec le JDK
72.1. Le compilateur javac
72.2. L'interpréteur java/javaw
72.3. L'outil jar
72.4. L'outil appletviewer pour tester des applets
72.5. L'outil javadoc pour générer la documentation technique
72.6. L'outil Java Check Update pour mettre à jour Java
72.7. La base de données Java DB
72.8. L'outil JConsole

73. JavaDoc
explore l'outil de documentation fourni avec le JDK
73.1. La mise en oeuvre
73.2. Les tags définis par javadoc
73.3. Un exemple
73.4. Les fichiers pour enrichir la documentation des packages
73.5. La documentation générée

74. Les outils libres et commerciaux
tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
74.1. Les environnements de développement intégrés (IDE)
74.2. Les serveurs d'application
74.3. Les conteneurs web
74.4. Les conteneurs d'EJB
74.5. Les outils divers
74.6. Les MOM
74.7. Les outils concernant les bases de données
74.8. Les outils de modélisation UML

75. Ant
propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
75.1. L'installation de l'outil Ant
75.2. Exécuter ant
75.3. Le fichier build.xml
75.4. Les tâches (task)

76. Maven
présente l'outil open source Maven qui facilite et automatise certaines taches de la gestion d'un projet
76.1. L'installation
76.2. Les plug-ins
76.3. Le fichier project.xml
76.4. L'exécution de Maven
76.5. La génération du site du projet
76.6. La compilation du projet

77. Tomcat
Détaille la mise en oeuvre du conteneur web Tomcat
77.1. L'historique des versions
77.2. L'installation
77.3. L'exécution de Tomcat
77.4. L'architecture
77.5. La configuration
77.6. L'outil Tomcat Administration Tool
77.7. Le déploiement des applications WEB
77.8. Tomcat pour le développeur
77.9. Le gestionnaire d'applications (Tomcat manager)
77.10. L'outil Tomcat Client Deployer
77.11. Les optimisations
77.12. La sécurisation du serveur

78. 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.
78.1. CheckStyle
78.2. Jalopy
78.3. XDoclet
78.4. Middlegen

Partie 12 : Concevoir et développer des applications


79. Java et UML
propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
79.1. La présentation d'UML
79.2. Les commentaires
79.3. Les cas d'utilisations (uses cases)
79.4. Le diagramme de séquence
79.5. Le diagramme de collaboration
79.6. Le diagramme d'états-transitions
79.7. Le diagramme d'activités
79.8. Le diagramme de classes
79.9. Le diagramme d'objets
79.10. Le diagramme de composants
79.11. Le diagramme de déploiement

80. 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
80.1. Les modèles de création
80.2. Les modèles de structuration
80.3. Les modèles de comportement

81. 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
81.1. Les fichiers
81.2. La documentation du code
81.3. Les déclarations
81.4. Les séparateurs
81.5. Les traitements
81.6. Les règles de programmation

82. Les techniques de développement spécifiques à Java
xxx
82.1. L'écriture d'une classe dont les instances seront immuables
82.2. La redéfinition des méthodes equals() et hashCode()

83. L'encodage des caractères
ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
83.1. L'utilisation des caractères dans la JVM
83.2. Les jeux d'encodages de caractères
83.3. Unicode
83.4. L'encodage de caractères
83.5. L'encodage du code source
83.6. L'encodage de caractères avec différentes technologies

84. Les frameworks
présente les frameworks et propose quelques solutions open source dans divers domaines
84.1. La présentation des concepts
84.2. Les frameworks pour les applications web
84.3. L'architecture pour les applications web
84.4. Le modèle MVC type 1
84.5. Le modèle MVC de type 2
84.6. Les frameworks de mapping Objet/Relationel
84.7. Les frameworks de logging

85. 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
85.1. Apache POI
85.2. iText

86. 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.
86.1. Quelques recommandations sur la validation des données
86.2. L'API Bean Validation (JSR 303)
86.3. D'autres frameworks pour la validation des données

87. L'utilisation des dates
ce chapitre détaille l'utilisation des dates en Java
87.1. Les classes standards du JDK pour manipuler des dates
87.2. Des exemples de manipulations de dates
87.3. La classe SimpleDateFormat
87.4. Joda Time
87.5. La classe FastDateFormat du projet Apache commons.lang

88. Des bibliothèques open source
présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
88.1. JFreeChart
88.2. Beanshell
88.3. Apache Commons
88.4. Quartz
88.5. JGoodies
88.6. Apache Lucene

Partie 13 : Les tests automatisés


89. Les frameworks de tests
propose une présentation de frameworks et d'outils pour faciliter les tests du code
89.1. Les tests unitaires
89.2. Les frameworks et outils de tests

90. JUnit
présente en détail le framework de tests unitaires le plus utilisé
90.1. Un exemple très simple
90.2. L'écriture des cas de tests
90.3. L'exécution des tests
90.4. Les suites de tests
90.5. L'automatisation des tests avec Ant
90.6. JUnit 4

91. Les objets de type Mock
ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
91.1. Les doublures d'objets et les objets de type mock
91.2. L'utilité des objets de type mock
91.3. Les tests unitaires et les dépendances
91.4. L'obligation d'avoir une bonne organisation du code
91.5. Les frameworks
91.6. Les outils pour générer des objets mock
91.7. Les inconvénients des objets de type mock

Partie 14 : Java et le monde informatique


92. La communauté Java
ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
92.1. Le JCP
92.2. Les ressources proposées par Sun
92.3. Oracle Technology Network
92.4. La communauté Java.net
92.5. Les JUG
92.6. D'autres User Groups
92.7. Les cast codeurs podcast
92.8. Knowledge BlackBelt (Java BlackBelt)
92.9. Les conférences
92.10. Webographie
92.11. Les communautés open source

93. Les plateformes Java et .Net
ce chapitre présente rapidement les deux plate-formes
93.1. La présentation des plateformes Java et .Net
93.2. La compilation
93.3. Les environnements d'exécution
93.4. Le déploiement des modules
93.5. Les version des modules
93.6. L'interopérabilité inter-language
93.7. La décompilation
93.8. Les API des deux plateformes

94. Java et C#
ce chapitre détaille les principales fonctionnalités des langages Java et C#
94.1. La syntaxe
94.2. La programmation orientée objet
94.3. Les chaînes de caractères
94.4. Les tableaux
94.5. Les indexeurs
94.6. Les exceptions
94.7. Le multitâche
94.8. L'appel de code natif
94.9. Les pointeurs
94.10. La documentation automatique du code
94.11. L'introspection/reflection
94.12. La sérialisation

Partie 15 : Développement d'applications mobiles


95. 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
95.1. L'historique de la plate-forme
95.2. La présentation de J2ME / Java ME
95.3. Les configurations
95.4. Les profiles
95.5. J2ME Wireless Toolkit 1.0.4
95.6. J2ME wireless toolkit 2.1

96. CLDC
présente les packages et les classes de la configuration CLDC
96.1. Le package java.lang
96.2. Le package java.io
96.3. Le package java.util
96.4. Le package javax.microedition.io

97. MIDP
propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
97.1. Les Midlets
97.2. L'interface utilisateur
97.3. La gestion des événements
97.4. Le stockage et la gestion des données
97.5. Les suites de midlets
97.6. Packager une midlet
97.7. MIDP for Palm O.S.

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

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

100. Les autres technologies pour les applications mobiles
propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
100.1. KJava
100.2. PDAP (PDA Profile)
100.3. PersonalJava
100.4. Java Phone
100.5. JavaCard
100.6. Embedded Java
100.7. Waba, Super Waba, Visual Waba

Partie 16 : Annexes

Annexe A : GNU Free Documentation License
Annexe B : Glossaire