La deuxième édition du livre « Java et Internet » est paru
en novembre 2002 chez Vuibert
Informatique. Il compte 845 pages au format 17x24 et son numéro
ISBN est : 2-7117-8689-7.
Java offre de nombreuses abstractions nécessaires au développement
rapide d'applications Internet. Après la nouvelle architecture de
sécurité de Java 2, la version 1.4 du SDK apporte encore de nouvelles
fonctionnalités en terme de sécurité, de gestion des applications,
ainsi qu'une refonte des API d'entrées-sorties avec la notion de
canaux. Ces différentes fonctionnalités confortent Java dans sa
position de langage de prédilection pour le développement
d'applications Internet. Toutefois, le développement efficace et la
mise en oeuvre optimale de telles applications requièrent la
compréhension préalable des concepts et protocoles réseaux
sous-jacents.
Cet ouvrage propose d'exposer conjointement la programmation orientée
objet avec Java et les protocoles réseaux, selon un point de vue à la
fois théorique et pratique. Chaque principe est présenté de manière
conceptuelle, avant d'être illustré par des exemples de programmation.
Le premier tome de cette seconde édition s'intéresse essentiellement
au point de vue client du développement d'applications Internet en
Java, tandis que le second tome s'oriente davantage vers les
technologies et protocoles dédiés aux applications de services.
Ce livre commence par rappeler les bases essentielles de la
programmation objet avec Java, en portant un intérêt particulier aux
aspects du langage relatifs à la programmation d'applications
réseaux. Ensuite, il traite des pans de l'API de programmation qui
offrent des fonctionnalités transverses aux applications :
réflexivité, chargement de classes, conteneurs, gestion de la mémoire,
paramétrage, journalisation, flots d'entrées-sorties, sécurité et
programmation concurrente sont traités en détail. Les concepts et
protocoles réseaux sont alors abordés. Les protocoles Ethernet, IP,
UDP et TCP sont détaillés afin de donner une vue précise du support de
l'Internet. Les API de manipulation réseau de Java correspondantes
sont présentées et abondamment illustrées. Couramment utilisés pour
l'accès aux ressources Internet, les protocoles HTTP et SSL sont
étudiés ainsi que l'utilisation de Java dans les applettes et avec
Java Web Start. Enfin, le dernier chapitre est consacré aux nouvelles
classes d'entrées-sorties qui offrent une gestion plus fine et plus
performante des mécanismes de lecture et d'écriture.
Si l'approche de cet ouvrage se veut pédagogique, elle a également
pour ambition d'élaborer une référence sur le sujet, de par son souci
d'exhaustivité.
| 1.2 | | Infrastructure de la technologie Java |
| 1.3 | | Les versions de la plate-forme Java |
| 2.1 | | Textes et commentaires |
| 2.3 | | Structures de contrôle |
| 2.4 | | Variables et paramètres |
| 2.5 | | Les types et les expressions |
| 2.6.1 | | Constantes et codage des types primitifs |
| 2.6.2 | | La promotion entière |
| 2.6.4 | | Le décalage des numériques signés |
| 2.6.5 | | Les spécificités du calcul en flottants |
| 2.8 | | Variables référence, typage et sous-typage |
| 3. | | Les classes et les objets |
| 3.1.1 | | Définition et création |
| 3.1.4 | | Les membres statiques |
| 3.1.5 | | L'initialisation des champs |
| 3.1.6 | | La surcharge de méthode et de constructeur |
| 3.1.8 | | Enveloppes des types primitifs |
| 3.1.9 | | Allocation et destruction des objets |
| 3.2.1 | | étendre une classe existante |
| 3.2.2 | | Héritage et création d'objets |
| 3.2.3 | | Le sous-typage des références |
| 3.2.4 | | Le transtypage des références |
| 3.2.5 | | Le masquage et la redéfinition de membre |
| 3.2.6 | | Surcharge de méthode et héritage |
| 3.4 | | Les classes abstraites |
| 3.5.1 | | Classe interne non statique |
| 3.5.2 | | Classe interne locale |
| 3.5.4 | | Classe interne statique |
| 3.5.5 | | Classes internes et héritage |
| 3.6 | | L'organisation des classes et l'accessibilité |
| 4. | | Les exceptions, les tableaux et les chaînes de caractères |
| 4.1.1 | | La vie d'une exception |
| 4.1.2 | | Capture et propagation des exceptions |
| 4.1.3 | | Le chaînage des exceptions |
| 4.1.4 | | La redéfinition de méthode et les exceptions |
| 4.2.2 | | La création et l'initialisation |
| 4.2.4 | | Les tableaux et l'héritage |
| 4.3 | | Les chaînes de caractères |
| 4.3.2 | | Les constantes littérales |
| 4.3.3 | | La classe StringBuffer |
| 4.3.4 | | L'opérateur de concaténation |
| 4.3.5 | | L'interface CharSequence |
| 4.3.6 | | Les objets et les chaînes de caractères |
| 5. | | Les classes fondamentales |
| 5.1.4 | | Méthode testamentaire |
| 5.3 | | Le chargement de classes |
| 5.3.1 | | Le comportement par défaut |
| 5.3.2 | | La classe ClassLoader |
| 5.3.3 | | écrire son propre chargeur de classes |
| 5.3.4 | | Autres mécanismes du chargeur de classes |
| 6.1 | | Les relations d'ordre sur les objets |
| 6.1.2 | | Les objets comparateurs |
| 6.2.1 | | Les conteneurs de type Map |
| 6.2.2 | | Les conteneurs de type Collection |
| 6.3 | | Les expressions régulières |
| 6.3.1 | | Représentation et construction |
| 6.3.2 | | La recherche d'un motif |
| 6.3.3 | | Décomposer le résultat d'une recherche |
| 6.4 | | Références et gestion mémoire |
| 6.4.1 | | Les différents états d'un objet |
| 6.4.2 | | Les références faibles |
| 6.4.3 | | Les références souples |
| 6.4.4 | | Les références fantômes |
| 7. | | Paramétrage et suivi des applications |
| 7.1 | | Le paramétrage des applications |
| 7.2 | | L'internationalisation des applications |
| 7.2.2 | | Les ressources d'internationalisation |
| 7.2.3 | | Le paquetage java.text |
| 7.3.1 | | Le paquetage java.util.logging |
| 7.3.2 | | Utiliser plusieurs journaliseurs |
| 7.3.3 | | Les propriétés de journalisation |
| 7.4 | | Le générateur de documentation |
| 7.4.2 | | Documenter les classes et interfaces |
| 7.4.3 | | Documenter un paquetage |
| 7.4.4 | | Insérer ses propres documents |
| 7.4.6 | | Les doclettes et taglettes |
| 8.1.2 | | Les flots de caractères |
| 8.2.1 | | Les flots sur des fichiers |
| 8.4.1 | | Le comportement par défaut |
| 8.4.2 | | Personnaliser la sauvegarde d'un objet |
| 8.4.3 | | La sauvegarde des objets dans le flot |
| 8.4.4 | | Personnaliser un flot d'objets |
| 8.4.6 | | Le contrôle de version |
| 9.1.1 | | Le stockage des clefs |
| 9.2 | | L'architecture de sécurité |
| 9.2.2 | | L'objet politique de sécurité |
| 9.2.3 | | Utiliser la politique de sécurité |
| 9.2.4 | | écrire une classe de droit |
| 9.2.5 | | Sécuriser les accès à un objet |
| 9.2.6 | | Les droits liés à la sécurité |
| 9.3.0 | | Les services d'authentification et d'autorisation |
| 9.3.2 | | Utiliser les droits d'un sujet |
| 9.3.3 | | Les droits associés à une identité |
| 9.4 | | Le service d'authentification |
| 9.4.1 | | La configuration des modules d'authentification |
| 9.4.2 | | Le processus d'authentification |
| 10. | | La programmation concurrente |
| 10.1.2 | | Interactions entre processus |
| 10.2.2 | | La création d'un nouveau processus léger |
| 10.2.3 | | La vie d'un processus léger |
| 10.2.4 | | L'accès au processeur |
| 10.2.5 | | Les groupes de processus légers |
| 10.3 | | La gestion de la concurrence |
| 10.3.1 | | L'exclusion mutuelle |
| 10.3.2 | | La synchronisation entre processus légers |
| 10.3.3 | | Les problèmes de la synchronisation et de l'exclusion mutuelle |
| 10.4 | | La mise à jour des données entre processus légers |
| 10.4.1 | | Le mot-clef volatile |
| 10.4.2 | | Problèmes de visibilité et d'instanciation |
| 10.4.3 | | Les variables locales à un processus léger |
| 10.5 | | Autour des processus légers |
| 10.5.1 | | La planification de tâches régulières |
| 10.5.2 | | Les processus légers << shutdown hooks >> |
| 10.5.3 | | Les processus légers et la sécurité |
| 10.5.4 | | Les processus légers et le chargement de classes |
| 11. | | Internet et les réseaux |
| 11.1 | | Terminologie des réseaux |
| 11.1.2 | | Le vocabulaire de la communication |
| 11.1.3 | | Structure des réseaux physiques |
| 11.1.4 | | Les modèles en couches |
| 11.1.5 | | Interconnexion de réseaux |
| 11.2 | | Les couches basses : Ethernet |
| 11.2.2 | | La couche liaison de données |
| 11.2.3 | | Répéteur, pont et commutateur |
| 11.3 | | La couche réseau : Internet |
| 11.3.1 | | Les adresses Internet |
| 11.3.2 | | Adresses logiques et adresses physiques |
| 11.3.3 | | Le protocole Internet (IP) |
| 11.3.6 | | Les options du protocole Internet |
| 11.3.7 | | Les messages de contrôle d'IP |
| 11.3.8 | | Noms et adresses Internet |
| 11.4 | | Le protocole Internet version 6 |
| 11.4.1 | | L'architecture d'adressage |
| 11.4.2 | | Le format des datagrammes |
| 11.5 | | Le protocole Internet et Java |
| 11.5.2 | | Les interfaces réseau |
| 12.1.2 | | Le format des datagrammes |
| 12.1.3 | | L'accès au protocole |
| 12.2 | | Les adresses de sockets en Java |
| 12.3.1 | | émettre un datagramme UDP |
| 12.3.2 | | Recevoir un datagramme UDP |
| 12.3.3 | | Le modèle client-serveur |
| 12.3.4 | | La taille maximale des datagrammes |
| 12.3.6 | | Les problèmes de perte de datagrammes |
| 12.3.7 | | UDP et la concurrence |
| 12.3.8 | | La pseudo-connexion |
| 12.4 | | La communication en diffusion |
| 13.1.1 | | Le service de fiabilité |
| 13.1.3 | | De la couche applicative à IP |
| 13.1.4 | | Fenêtres coulissantes et contrôle de flot |
| 13.1.5 | | La fermeture de connexion |
| 13.1.6 | | Le diagramme des états TCP |
| 13.1.8 | | Améliorer les performances |
| 13.1.9 | | Le format de l'en-tête TCP |
| 13.2.3 | | Attacher plusieurs sockets à un même port |
| 13.2.4 | | écrire un serveur modulaire |
| 13.2.7 | | Passer par un relais SOCKS |
| 13.2.8 | | Personnaliser l'implantation des sockets |
| 14. | | L'accès aux ressources Internet |
| 14.1 | | Les standards HTML et MIME |
| 14.2.2 | | La partie dépendante du schéma |
| 14.4.1 | | Récupérer des données |
| 14.4.2 | | Envoyer des données |
| 14.4.5 | | L'accès à des parties de ressources |
| 14.5 | | Un serveur HTTP simple |
| 14.6.1 | | Création d'un objet URL |
| 14.6.2 | | L'accès aux caractéristiques des URL |
| 14.6.3 | | Récupérer le contenu de la ressource |
| 14.7 | | La classe URLConnection |
| 14.7.1 | | Les paramètres de la connexion |
| 14.7.3 | | Les résultats de la connexion |
| 14.7.4 | | Les sous-classes de URLConnection |
| 14.7.6 | | Les droits de connexion |
| 14.8.1 | | Les gestionnaires par défaut |
| 14.8.2 | | Installer ses propres gestionnaires |
| 14.8.3 | | Un exemple d'ajout de gestionnaires |
| 15. | | Les applettes et Java Web Start |
| 15.1 | | La classe URLClassLoader |
| 15.1.1 | | Hériter de la classe URLClassLoader |
| 15.1.2 | | Déterminer l'URL de chargement |
| 15.2.1 | | Les méthodes de base |
| 15.2.2 | | Les fonctionnalités d'une applette |
| 15.2.3 | | Les applettes et le navigateur |
| 15.2.4 | | Limiter les droits des applettes |
| 15.2.5 | | étendre les droits d'une applette |
| 15.3.1 | | L'environnement d'exécution |
| 15.3.3 | | Le fichier de description |
| 16.1 | | Un peu de vocabulaire |
| 16.1.2 | | L'authentification et l'intégrité |
| 16.1.3 | | Les fonctions pseudo-aléatoires |
| 16.3 | | Le protocole SSL en Java |
| 16.3.1 | | La gestion des clefs et des certificats |
| 16.3.3 | | écrire un gestionnaire de certificats de confiance pour SSL |
| 16.3.4 | | Les fabriques de sockets SSL |
| 16.3.6 | | Les URL de schéma https |
| 16.3.7 | | D'autres mécanismes des sockets SSL |
| 17. | | Les nouvelles classes d'entrées-sorties |
| 17.2 | | La gestion des jeux de caractères |
| 17.2.3 | | D'autres mécanismes |
| 17.3.1 | | Les classes et interfaces fondamentales |
| 17.3.2 | | Les canaux vers les fichiers |
| 17.3.3 | | Les canaux sur les tubes |
| 17.3.4 | | Les canaux vers les sockets UDP |
| 17.3.5 | | Les canaux vers les sockets TCP |
| 17.3.7 | | Les canaux et les processus légers |
| 17.3.8 | | Les interactions avec les classes d'entrées-sorties originales |