Développons en Java   1.90  
Copyright (C) 1999-2013 Jean-Michel DOUDOUX    (date de publication : 25/02/2013)

[ 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 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é 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. 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. NIO 2
détaille l'API FileSystem qui facilite l'utilisation de systèmes de fichiers
21.1. Les entrées/sorties avec Java
21.2. Les principales classes et interfaces
21.3. L'interface Path
21.4. Glob
21.5. La classe Files
21.6. Le parcourt du contenu de répertoires
21.7. L'utilisation de systèmes de gestion de fichiers
21.8. La lecture et l'écriture dans un fichier
21.9. Les liens et les liens symboliques
21.10. La gestion des attributs
21.11. La gestion des unités de stockages
21.12. Les notifications de changements dans un répertoire
21.13. La gestion des erreurs et la libération des ressources
21.14. L'interopérabilité avec le code existant

22. La sérialisation
ce procédé permet de rendre un objet persistant
22.1. Les classes et les interfaces de la sérialisation
22.2. Le mot clé transient
22.3. La sérialisation personnalisée

23. 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
23.1. L'introduction aux concepts liés au réseau
23.2. Les adresses internet
23.3. L'accès aux ressources avec une URL
23.4. L'utilisation du protocole TCP
23.5. L'utilisation du protocole UDP
23.6. Les exceptions liées au réseau
23.7. Les interfaces de connexions au réseau

24. 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
24.1. La classe Class
24.2. La recherche des informations sur une classe
24.3. La définition dynamique d'objets
24.4. L'exécution dynamique d'une méthode

25. L'appel de méthodes distantes : RMI
étudie la mise en oeuvre de la technologie RMI pour permettre l'appel de méthodes distantes
25.1. La présentation et l'architecture de RMI
25.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI
25.3. Le développement coté serveur
25.4. Le développement coté client
25.5. La génération de la classe stub
25.6. La mise en oeuvre des objets RMI

26. L'internationalisation
traite d'une façon pratique de la possibilité d'internationaliser une application
26.1. Les objets de type Locale
26.2. La classe ResourceBundle
26.3. Un guide pour réaliser la localisation

27. Les composants Java beans
examine comment développer et utiliser des composants réutilisables
27.1. La présentation des Java beans
27.2. Les propriétés.
27.3. Les méthodes
27.4. Les événements
27.5. L'introspection
27.6. Paramétrage du bean ( Customization )
27.7. La persistance
27.8. La diffusion sous forme de jar

28. 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
28.1. La présentation du logging
28.2. Log4j
28.3. L'API logging
28.4. Jakarta Commons Logging (JCL)
28.5. D'autres API de logging

29. 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
29.1. La sécurité dans les spécifications du langage
29.2. Le contrôle des droits d'une application
29.3. JCE (Java Cryptography Extension)
29.4. JSSE (Java Secure Sockets Extension)
29.5. JAAS (Java Authentication and Authorization Service)

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

31. JNDI (Java Naming and Directory Interface)
introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
31.1. La présentation de JNDI
31.2. La mise en oeuvre de l'API JNDI
31.3. L'utilisation d'un service de nommage
31.4. L'utilisation avec un DNS
31.5. L'utilisation du File System Context Provider
31.6. LDAP
31.7. L'utilisation avec un annuaire LDAP
31.8. JNDI et J2EE/Java EE

32. 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.
32.1. L'API Scripting

33. 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
33.1. La présentation de JMX
33.2. L'architecture de JMX
33.3. Un premier exemple
33.4. La couche instrumentation : les MBeans
33.5. Les MBeans standard
33.6. La couche agent
33.7. Les services d'un agent JMX
33.8. La couche services distribués
33.9. Les notifications
33.10. Les Dynamic MBeans
33.11. Les Model MBeans
33.12. Les Open MBeans
33.13. Les MXBeans
33.14. L'interface PersistentMBean
33.15. Le monitoring d'une JVM
33.16. Des recommandations pour l'utilisation de JMX
33.17. Des ressources

Partie 4 : L'utilisation de documents XML


34. 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
34.1. La présentation de XML
34.2. Les règles pour formater un document XML
34.3. La DTD (Document Type Definition)
34.4. Les parseurs
34.5. La génération de données au format XML
34.6. JAXP : Java API for XML Parsing
34.7. Jaxen

35. 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
35.1. L'utilisation de SAX

36. 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
36.1. Les interfaces du DOM
36.2. L'obtention d'un arbre DOM
36.3. Le parcours d'un arbre DOM
36.4. La modification d'un arbre DOM
36.5. L'envoie d'un arbre DOM dans un flux

37. XSLT (Extensible Stylesheet Language Transformations)
présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
37.1. XPath
37.2. La syntaxe de XSLT
37.3. Un exemple avec Internet Explorer
37.4. Un exemple avec Xalan 2

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

39. 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.
39.1. JAXB 1.0
39.2. JAXB 2.0

40. 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
40.1. La présentation de StAX
40.2. Les deux API de StAX
40.3. Les fabriques
40.4. Le traitement d'un document XML avec l'API du type curseur
40.5. Le traitement d'un document XML avec l'API du type itérateur
40.6. La mise en oeuvre des filtres
40.7. L'écriture un document XML avec l'API de type curseur
40.8. L'écriture un document XML avec l'API de type itérateur
40.9. La comparaison entre SAX, DOM et StAX

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


41. 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)
41.1. La correspondance entre les modèles relationnel et objet
41.2. L'évolution des solutions de persistance avec Java
41.3. Le mapping O/R (objet/relationnel)
41.4. L'architecture et la persistance de données
41.5. Les différentes solutions
41.6. Les API standards
41.7. Les frameworks open source
41.8. L'utilisation de procédures stockées

42. JDBC (Java DataBase Connectivity)
indique comment utiliser cette API historique pour accéder aux bases de données
42.1. Les outils nécessaires pour utiliser JDBC
42.2. Les types de pilotes JDBC
42.3. L'enregistrement d'une base de données dans ODBC sous Windows 9x ou XP
42.4. La présentation des classes de l'API JDBC
42.5. La connexion à une base de données
42.6. L'accès à la base de données
42.7. L'obtention d'informations sur la base de données
42.8. L'utilisation d'un objet de type PreparedStatement
42.9. L'utilisation des transactions
42.10. Les procédures stockées
42.11. Le traitement des erreurs JDBC
42.12. JDBC 2.0
42.13. JDBC 3.0
42.14. MySQL et Java
42.15. L'amélioration des performances avec JDBC
42.16. Les ressources relatives à JDBC

43. JDO (Java Data Object)
API qui standardise et automatise le mapping entre des objets Java et un système de gestion de données
43.1. La présentation de JDO
43.2. Un exemple avec Lido
43.3. L'API JDO
43.4. La mise en oeuvre
43.5. Le parcours de toutes les occurrences
43.6. La mise en oeuvre de requêtes

44. Hibernate
présente Hibernate, un framework de mapping Objets/Relationnel open source
44.1. La création d'une classe qui va encapsuler les données
44.2. La création d'un fichier de correspondance
44.3. Les propriétés de configuration
44.4. L'utilisation d'Hibernate
44.5. La persistance d'une nouvelle occurrence
44.6. L'obtention d'une occurrence à partir de son identifiant
44.7. L'obtention de données
44.8. La mise à jour d'une occurrence
44.9. La suppression d'une ou plusieurs occurrences
44.10. Les relations
44.11. Les caches d'Hibernate
44.12. Les outils de génération de code

45. 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.
45.1. L'installation de l'implémentation de référence
45.2. Les entités
45.3. Le fichier de configuration du mapping
45.4. L'utilisation du bean entité
45.5. Le fichier persistence.xml
45.6. La gestion des transactions hors Java EE
45.7. La gestion des relations entre tables dans le mapping
45.8. Les callbacks d'événements

Partie 6 : La machine virtuelle Java (JVM)


46. La JVM (Java Virtual Machine)
ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
46.1. La mémoire de la JVM
46.2. Le cycle de vie d'une classe dans la JVM
46.3. Les ClassLoaders
46.4. Le bytecode
46.5. Le compilateur JIT
46.6. Les paramètres de la JVM HotSpot
46.7. Les interactions de la machine virtuelle avec des outils externes
46.8. Service Provider Interface (SPI)
46.9. Les JVM 32 et 64 bits

47. 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.
47.1. Le ramasse-miettes (Garbage Collector ou GC)
47.2. Le fonctionnement du ramasse-miettes de la JVM Hotspot
47.3. Le paramétrage du ramasse-miettes de la JVM HotSpot
47.4. Le monitoring de l'activité du ramasse-miettes
47.5. Les différents types de référence
47.6. L'obtention d'informations sur la mémoire de la JVM
47.7. Les fuites de mémoire (Memory leak)
47.8. Les exceptions liées à un manque de mémoire

48. 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.
48.1. Décompiler du bytecode
48.2. Obfusquer le bytecode

49. Terracotta
Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
49.1. La présentation de Terrocatta
49.2. Les concepts utilisés
49.3. La mise en oeuvre des fonctionnalités
49.4. Les cas d'utilisation
49.5. Quelques exemples de mise en oeuvre
49.6. La console développeur
49.7. Le fichier de configuration
49.8. La fiabilisation du cluster
49.9. Quelques recommandations

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


50. J2EE / Java EE
introduit la plate-forme Java 2 Entreprise Edition
50.1. La présentation de J2EE
50.2. Les API de J2EE
50.3. L'environnement d'exécution des applications J2EE
50.4. L'assemblage et le déploiement d'applications J2EE
50.5. J2EE 1.4 SDK
50.6. La présentation de Java EE 5.0
50.7. La présentation de Java EE 6

51. JavaMail
traite de l'API qui permet l'envoi et la réception d'e-mails
51.1. Le téléchargement et l'installation
51.2. Les principaux protocoles
51.3. Les principales classes et interfaces de l'API JavaMail
51.4. L'envoi d'un e-mail par SMTP
51.5. La récupération des messages d'un serveur POP3
51.6. Les fichiers de configuration

52. 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
52.1. La présentation de JMS
52.2. Les services de messages
52.3. Le package javax.jms
52.4. L'utilisation du mode point à point (queue)
52.5. L'utilisation du mode publication/abonnement (publish/subscribe)
52.6. La gestion des erreurs
52.7. JMS 1.1
52.8. Les ressources relatives à JMS

53. 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
53.1. La présentation des EJB
53.2. Les EJB session
53.3. Les EJB entité
53.4. Les outils pour développer et mettre en oeuvre des EJB
53.5. Le déploiement des EJB
53.6. L'appel d'un EJB par un client
53.7. Les EJB orientés messages

54. 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.
54.1. L'historique des EJB
54.2. Les nouveaux concepts et fonctionnalités utilisés
54.3. EJB 2.x vs EJB 3.0
54.4. Les conventions de nommage
54.5. Les EJB de type Session
54.6. Les EJB de type Entity
54.7. Un exemple simple complet
54.8. L'utilisation des EJB par un client
54.9. L'injection de dépendances
54.10. Les intercepteurs
54.11. Les EJB de type MessageDriven
54.12. Le packaging des EJB
54.13. Les tests des EJB
54.14. Les transactions
54.15. La mise en oeuvre de la sécurité

55. Les EJB 3.1
ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
55.1. Les interfaces locales sont optionnelles
55.2. Les EJB Singleton
55.3. EJB Lite
55.4. La simplification du packaging
55.5. Les améliorations du service Timer
55.6. La standardisation des noms JNDI
55.7. L'invocation asynchrone des EJB session
55.8. L'invocation d'un EJB hors du conteneur

56. 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
56.1. La présentation des services web
56.2. Les standards
56.3. Les différents formats de services web SOAP
56.4. Des conseils pour la mise en oeuvre
56.5. Les API Java pour les services web
56.6. Les implémentations des services web
56.7. Inclure des pièces jointes dans SOAP
56.8. WS-I
56.9. Les autres spécifications

Partie 8 : Le développement d'applications web


57. Les servlets
plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
57.1. La présentation des servlets
57.2. L'API servlet
57.3. Le protocole HTTP
57.4. Les servlets http
57.5. Les informations sur l'environnement d'exécution des servlets
57.6. L'utilisation des cookies
57.7. Le partage d'informations entre plusieurs échanges HTTP
57.8. Packager une application web
57.9. L'utilisation de Log4J dans une servlet

58. 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
58.1. La présentation des JSP
58.2. Les outils nécessaires
58.3. Le code HTML
58.4. Les Tags JSP
58.5. Un exemple très simple
58.6. La gestion des erreurs
58.7. Les bibliothèques de tags personnalisés (custom taglibs)

59. JSTL (Java server page Standard Tag Library)
est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
59.1. Un exemple simple
59.2. Le langage EL (Expression Langage)
59.3. La bibliothèque Core
59.4. La bibliothèque XML
59.5. La bibliothèque I18n
59.6. La bibliothèque Database

60. Struts
présente et détaille la mise en oeuvre de ce framework open source de développement d'applications web le plus populaire
60.1. L'installation et la mise en oeuvre
60.2. Le développement des vues
60.3. La configuration de Struts
60.4. Les bibliothèques de tags personnalisés
60.5. La validation de données

61. 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.
61.1. La présentation de JSF
61.2. Le cycle de vie d'une requête
61.3. Les implémentations
61.4. Le contenu d'une application
61.5. La configuration de l'application
61.6. Les beans
61.7. Les composants pour les interfaces graphiques
61.8. La bibliothèque de tags Core
61.9. La bibliothèque de tags Html
61.10. La gestion et le stockage des données
61.11. La conversion des données
61.12. La validation des données
61.13. La sauvegarde et la restauration de l'état
61.14. Le système de navigation
61.15. La gestion des événements
61.16. Le déploiement d'une application
61.17. Un exemple d'application simple
61.18. L'internationalisation
61.19. Les points faibles de JSF

62. D'autres frameworks pour les applications web
présente rapidement quelques frameworks open source pour le développement d'applications web
62.1. Les frameworks pour les applications web
62.2. Les moteurs de templates

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


63. 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.
63.1. Les applications de type RIA
63.2. Les applications de type RDA
63.3. Les contraintes
63.4. Les solutions RIA
63.5. Les solutions RDA

64. Les applets
plonge au coeur des premières applications qui ont rendu Java célèbre
64.1. L'intégration d'applets dans une page HTML
64.2. Les méthodes des applets
64.3. Les interfaces utiles pour les applets
64.4. La transmission de paramètres à une applet
64.5. Les applets et le multimédia
64.6. Une applet pouvant s'exécuter comme une application
64.7. Les droits des applets

65. Java Web Start (JWS)
est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
65.1. La création du package de l'application
65.2. La signature d'un fichier jar
65.3. Le fichier JNLP
65.4. La configuration du serveur web
65.5. Le fichier HTML
65.6. Le test de l'application
65.7. L'utilisation du gestionnaire d'applications
65.8. L'API de Java Web Start

66. 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é.
66.1. La présentation d'Ajax
66.2. Le détail du mode de fonctionnement
66.3. Un exemple simple
66.4. Des frameworks pour mettre en oeuvre Ajax

67. GWT (Google Web Toolkit)
GWT est un framework pour le développement d'applications de type RIA
67.1. La présentation de GWT
67.2. La création d'une application
67.3. Les modes d'exécution
67.4. Les éléments de GWT
67.5. L'interface graphique des applications GWT
67.6. La personnalisation de l'interface
67.7. Les composants (widgets)
67.8. Les panneaux (panels)
67.9. La création d'éléments réutilisables
67.10. Les événements
67.11. JSNI
67.12. La configuration et l'internationalisation
67.13. L'appel de procédures distantes (Remote Procedure Call)
67.14. La manipulation des documents XML
67.15. La gestion de l'historique sur le navigateur
67.16. Les tests unitaires
67.17. Le déploiement d'une application
67.18. Des composants tiers
67.19. Les ressources relatives à GWT

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


68. Spring
ce chapitre est une présentation générale de Spring
68.1. Le but et les fonctionnalités proposées par Spring
68.2. L'historique de Spring
68.3. Spring Framework
68.4. Les projets du portfolio Spring
68.5. Les avantages et les inconvénients de Spring
68.6. Spring et Java EE

69. 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
69.1. Les fondements de Spring
69.2. Le conteneur Spring
69.3. Le fichier de configuration
69.4. L'injection de dépendances
69.5. Spring Expression Langage (SpEL)
69.6. La configuration en utilisant les annotations
69.7. Le scheduling

70. La mise en oeuvre de l'AOP avec Spring
présente la mise en oeuvre de l'AOP avec Spring
70.1. Spring AOP
70.2. AspectJ
70.3. Spring AOP et AspectJ
70.4. L'utilisation des namespaces

71. La gestion des transactions avec Spring
ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
71.1. La gestion des transactions par Spring
71.2. La propagation des transactions
71.3. L'utilisation des transactions de manière déclarative
71.4. La déclaration des transactions avec des annotations
71.5. La gestion du rollback des transactions
71.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
71.7. L'utilisation des transactions via l'API
71.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

72. Spring et JMS
ce chapitre couvre la mise en oeuvre de JMS dans Spring
72.1. Les packages de Spring JMS
72.2. La classe JmsTemplate : le template JMS de Spring
72.3. La réception asynchrone de messages
72.4. L'espace de nommage jms

73. Spring et JMX
ce chapitre détaille la façon dont Spring facilite la mise en oeuvre de JMX
73.1. L'enregistrement d'un bean en tant que MBean
73.2. Le nommage des MBeans
73.3. Les Assembler
73.4. L'utilisation des annotations
73.5. Le développement d'un client JMX
73.6. Les notifications

Partie 11 : Les outils pour le développement


74. Les outils du J.D.K.
indique comment utiliser les outils fournis avec le JDK
74.1. Le compilateur javac
74.2. L'interpréteur java/javaw
74.3. L'outil jar
74.4. L'outil appletviewer pour tester des applets
74.5. L'outil javadoc pour générer la documentation technique
74.6. L'outil Java Check Update pour mettre à jour Java
74.7. La base de données Java DB
74.8. L'outil JConsole
74.9. VisualVM

75. JavaDoc
explore l'outil de documentation fourni avec le JDK
75.1. La mise en oeuvre
75.2. Les tags définis par javadoc
75.3. Un exemple
75.4. Les fichiers pour enrichir la documentation des packages
75.5. La documentation générée

76. Les outils libres et commerciaux
tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
76.1. Les environnements de développement intégrés (IDE)
76.2. Les serveurs d'application
76.3. Les conteneurs web
76.4. Les conteneurs d'EJB
76.5. Les outils divers
76.6. Les MOM
76.7. Les outils concernant les bases de données
76.8. Les outils de modélisation UML

77. Ant
propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
77.1. L'installation de l'outil Ant
77.2. Exécuter ant
77.3. Le fichier build.xml
77.4. Les tâches (task)

78. Maven
présente l'outil open source Maven qui facilite et automatise certaines taches de la gestion d'un projet
78.1. L'installation
78.2. Les plug-ins
78.3. Le fichier project.xml
78.4. L'exécution de Maven
78.5. La génération du site du projet
78.6. La compilation du projet

79. Tomcat
Détaille la mise en oeuvre du conteneur web Tomcat
79.1. L'historique des versions
79.2. L'installation
79.3. L'exécution de Tomcat
79.4. L'architecture
79.5. La configuration
79.6. L'outil Tomcat Administration Tool
79.7. Le déploiement des applications WEB
79.8. Tomcat pour le développeur
79.9. Le gestionnaire d'applications (Tomcat manager)
79.10. L'outil Tomcat Client Deployer
79.11. Les optimisations
79.12. La sécurisation du serveur

80. 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.
80.1. CheckStyle
80.2. Jalopy
80.3. XDoclet
80.4. Middlegen

Partie 12 : Concevoir et développer des applications


81. Java et UML
propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
81.1. La présentation d'UML
81.2. Les commentaires
81.3. Les cas d'utilisations (uses cases)
81.4. Le diagramme de séquence
81.5. Le diagramme de collaboration
81.6. Le diagramme d'états-transitions
81.7. Le diagramme d'activités
81.8. Le diagramme de classes
81.9. Le diagramme d'objets
81.10. Le diagramme de composants
81.11. Le diagramme de déploiement

82. 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
82.1. Les modèles de création
82.2. Les modèles de structuration
82.3. Les modèles de comportement

83. 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
83.1. Les fichiers
83.2. La documentation du code
83.3. Les déclarations
83.4. Les séparateurs
83.5. Les traitements
83.6. Les règles de programmation

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

85. L'encodage des caractères
ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
85.1. L'utilisation des caractères dans la JVM
85.2. Les jeux d'encodages de caractères
85.3. Unicode
85.4. L'encodage de caractères
85.5. L'encodage du code source
85.6. L'encodage de caractères avec différentes technologies

86. Les frameworks
présente les frameworks et propose quelques solutions open source dans divers domaines
86.1. La présentation des concepts
86.2. Les frameworks pour les applications web
86.3. L'architecture pour les applications web
86.4. Le modèle MVC type 1
86.5. Le modèle MVC de type 2
86.6. Les frameworks de mapping Objet/Relationel
86.7. Les frameworks de logging

87. 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
87.1. Apache POI
87.2. iText

88. 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.
88.1. Quelques recommandations sur la validation des données
88.2. L'API Bean Validation (JSR 303)
88.3. D'autres frameworks pour la validation des données

89. L'utilisation des dates
ce chapitre détaille l'utilisation des dates en Java
89.1. Les classes standards du JDK pour manipuler des dates
89.2. Des exemples de manipulations de dates
89.3. La classe SimpleDateFormat
89.4. Joda Time
89.5. La classe FastDateFormat du projet Apache commons.lang

90. Des bibliothèques open source
présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
90.1. JFreeChart
90.2. Beanshell
90.3. Apache Commons
90.4. Quartz
90.5. JGoodies
90.6. Apache Lucene

Partie 13 : Les tests automatisés


91. Les frameworks de tests
propose une présentation de frameworks et d'outils pour faciliter les tests du code
91.1. Les tests unitaires
91.2. Les frameworks et outils de tests

92. JUnit
présente en détail le framework de tests unitaires le plus utilisé
92.1. Un exemple très simple
92.2. L'écriture des cas de tests
92.3. L'exécution des tests
92.4. Les suites de tests
92.5. L'automatisation des tests avec Ant
92.6. JUnit 4

93. Les objets de type Mock
ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
93.1. Les doublures d'objets et les objets de type mock
93.2. L'utilité des objets de type mock
93.3. Les tests unitaires et les dépendances
93.4. L'obligation d'avoir une bonne organisation du code
93.5. Les frameworks
93.6. Les outils pour générer des objets mock
93.7. Les inconvénients des objets de type mock

Partie 14 : Java et le monde informatique


94. La communauté Java
ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
94.1. Le JCP
94.2. Les ressources proposées par Sun
94.3. Oracle Technology Network
94.4. La communauté Java.net
94.5. Les JUG
94.6. D'autres User Groups
94.7. Les cast codeurs podcast
94.8. Parleys.com
94.9. Les conférences
94.10. Webographie
94.11. Les communautés open source

95. Les plateformes Java et .Net
ce chapitre présente rapidement les deux plate-formes
95.1. La présentation des plateformes Java et .Net
95.2. La compilation
95.3. Les environnements d'exécution
95.4. Le déploiement des modules
95.5. Les version des modules
95.6. L'interopérabilité inter-language
95.7. La décompilation
95.8. Les API des deux plateformes

96. Java et C#
ce chapitre détaille les principales fonctionnalités des langages Java et C#
96.1. La syntaxe
96.2. La programmation orientée objet
96.3. Les chaînes de caractères
96.4. Les tableaux
96.5. Les indexeurs
96.6. Les exceptions
96.7. Le multitâche
96.8. L'appel de code natif
96.9. Les pointeurs
96.10. La documentation automatique du code
96.11. L'introspection/reflection
96.12. La sérialisation

Partie 15 : Développement d'applications mobiles


97. 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
97.1. L'historique de la plate-forme
97.2. La présentation de J2ME / Java ME
97.3. Les configurations
97.4. Les profiles
97.5. J2ME Wireless Toolkit 1.0.4
97.6. J2ME wireless toolkit 2.1

98. CLDC
présente les packages et les classes de la configuration CLDC
98.1. Le package java.lang
98.2. Le package java.io
98.3. Le package java.util
98.4. Le package javax.microedition.io

99. MIDP
propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
99.1. Les Midlets
99.2. L'interface utilisateur
99.3. La gestion des événements
99.4. Le stockage et la gestion des données
99.5. Les suites de midlets
99.6. Packager une midlet
99.7. MIDP for Palm O.S.

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

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

102. Les autres technologies pour les applications mobiles
propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
102.1. KJava
102.2. PDAP (PDA Profile)
102.3. PersonalJava
102.4. Java Phone
102.5. JavaCard
102.6. Embedded Java
102.7. Waba, Super Waba, Visual Waba

Partie 16 : Annexes

Annexe A : GNU Free Documentation License
Annexe B : Glossaire

 


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

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

 

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

 
 
 
 
Partenaires

PlanetHoster
Ikoula