Developpez.com

Club des développeurs et IT pro
Plus de 4 millions de visiteurs uniques par mois

Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :



Les meilleurs livres Java

Dernière mise à jour : 25/07/2006


couverture du livre 'Java en concentré'

note du livre : 4.5

Java en concentré

Manuel de référence pour Java

de David Flanagan
Traducteur(s) : Alexandre Gachet et Anne Gachet
Public visé : Tous
Introduction : Couvre Java 5.0

Résumé de l'éditeur

Java in a Nutsbell fait peau neuve et devient Java en concentré. Les éléments qui ont fait le succès des précédentes éditions sont toujours là : découpage thématique, nombreux exemples et couverture exhaustive des classes des paquetages fondamentaux, avec en prime les nouveautés apportées par Java 5.0 et l'inventaire des outils de développement disponibles. Le must des manuels de référence. Cet ouvrage est avant tout un guide de référence, mais il servira également de tutoriel pour les programmeurs avertis qui souhaitent découvrir Java rapidement. La partie " tutoriel N donne aux développeurs tous les éléments pour comprendre ce qui fait la spécificité d'un programme écrit en java, depuis la syntaxe du langage jusqu'aux outils de développement java, en passant par les différents mécanismes de sécurité. Les notions clés sont présentées sans fioriture, mais illustrées par des exemples réalistes. Un chapitre entier inventorie les nouveautés introduites dans la version 5.0 du langage et notamment : les types génériques ; les annotations ; les types énumérés ; les conversions boxing et unboxing ; l'instruction for/in ; les méthodes varargs ; l'importation de membres statiques. La partie " référence " passe en revue les classes des paquetages essentiels de java et explique comment mener à bien des tâches courantes comme la manipulation de texte, le traitement de données au format XML, le recours aux expressions régulières ou la gestion des entrées/sorties. On trouvera une description des paquetages java. io, java.lang, java.matb, java.net, java.nio, java.security, java.text, java.util, java.crypto, javax.net,jâvax.net.ssl javax.security.autb, javax.xml, org.w3c.dom et org.xml.sax. Cet ouvrage convient à des progammeurs aguerris.

David Flanagan est diplômé en informatique du MIT (Massachusetts Institute of Technology). Programmeur consultant, spécialiste de java et de JavaScript, il est l'auteur de nombreux livres sur Java.

Critique du livre par la rédaction (Ricky81)
Voila le livre idéal pour découvrir ou redécouvrir la plate-forme Java.
Clair et concis (malgré la taille), il vous servira également de guide de référence lorsque vous aurez le malheur de ne pas pouvoir accéder facilement à des ressources en ligne ou à la Javadoc.

Cette nouvelle édition introduit les nouveautés de Java 5 en se concentrant sur l'essentiel (logique, puisque l'ouvrage anciennement "Java in a Nutshell" s'appelle désormais "Java en concentré").
Bien entendu, vous ne trouverez pas tous le détail d'une API comme les Generics, mais suffisamment pour ensuite vous débrouiller et fouiller la partie "Guide de référence".

Ce livre en impose, tant par le nombre de pages (dont les 400 premières constituent la matière grise) que par la densité des informations.
Certains passages auraient certes pu être adaptés à Java 5, mais le travail serait considérable et certains passages risqueraient de devenir trop complexes et risqueraient de mettre en arrière plan les concepts illustrés.

Mention spéciale aux traducteurs Anne et Alexandre Gachet qui ont réalisé un travail de grande qualité. On ne leur reprochera pas les quelques coquilles relevées compte tenu du nombre impressionnant de pages.

Bref, vous l'aurez compris, cet ouvrage est plus qu'un livre de chevet, une vraie bible comme on aimerait en voir plus souvent.

Sommaire

  1. Introduction
    1. Qu'est ce que Java ?
    2. Les avantages clés de Java ?
    3. Un exemple de programme
  2. La syntaxe Java
    1. Programmes Java dans leur ensemble
    2. Types de données primitifs
    3. Expressions et opérateurs
    4. Instructions
    5. Méthodes
    6. Introduction aux classes et objets
    7. Tableaux
    8. Types références
    9. Paquetages et espace de désignation en Java
    10. Structure des fichiers Java
    11. Définir et exécuter des programmes Java
    12. Différences entre C et Java
  3. La programmation orientée objet en Java
    1. Syntaxe de la définition des classes
    2. Champs et méthodes
    3. Création et initialisation d'objets
    4. Destruction et finalisation d'objets
    5. Sous-classes et héritage
    6. Masquage des données et encapsulation
    7. Classes et méthodes abstraites
    8. Méthodes importantes de java.lang.Object
    9. Interfaces
    10. Types emboîtés
    11. Résumé des modificateurs
    12. Caractéristiques de C++ absentes en Java
  4. Nouveautés du langage Java 5.0
    1. Types génériques
    2. Types énumérés
    3. Annotations
  5. La plate-forme Java
    1. Vue d'ensemble de la plate-forme Java
    2. Texte
    3. Nombre de Maths
    4. Dates et heures
    5. Tableaux
    6. Collections
    7. Threads et programmation concurrente
    8. Fichiers et répertoires
    9. Flux d'entrée et de sortie avec java.io
    10. Interconnexion de réseaux avec java.net
    11. Entrées/sorties et interconnexion de réseaux avec java.nio
    12. XML
    13. Types, réflexion et chargement dynamique
    14. Persistence des objets
    15. Sécurité
    16. Cryptographie
    17. Fonctionnalités diverses
  6. La sécurité en Java
    1. Risques liés à la sécurité
    2. Sécurité de la machine virtuelle Java et vérification des fichiers de classe
    3. Authentification et cryptographie
    4. Contrôle d'accès
    5. Sécurité pour tout le monde
    6. Classes de permissions
  7. Conventions de programmation et de documentation en Java
    1. Conventions liées à l'attribution des noms et à la capitalisation
    2. Conventions de portabilité
    3. Commentaires de documentation en Java
    4. Conventions propres aux JavaBeans
  8. Outils de développement Java
  9. Guide de référence

1418 pages, 5ème édition, février 2006 Editions O'Reilly, ISBN: 284177371X , 18 x 6 x 24 cm
Commandez sur www.amazon.fr :
51,30 EUR TTC (prix éditeur 54 EUR TTC) - Livraison Gratuite !
couverture du livre 'Les cahiers du programmeur'

note du livre : 4.5

Les cahiers du programmeur

Java 1.4 et 5.0

de Emmanuel Puybaret

Résumé de l'éditeur

A travers la réalisation d'un forum de discussion et plus de 50 études de cas, ce cahier montre à tous les programmeurs comment exploiter la richesse de Java pour créer sans mal des applications fiables et évolutives. Ce cahier met à la portée de tous les développeurs les meilleures pratiques Java, depuis l'installation des outils de développement et la création d'un premier objet jusqu'à la programmation multitâche, en passant par l'accès aux bases de données, la conception d'interfaces utilisateur, la gestion de formulaires, de fichiers, la maîtrise des subtilités objet...

Critique du livre par la rédaction (Vincent Brabant )
Cette 3ème édition du cahier des programmeurs Java d'Emmanuel Puybaret est un remaniement total comparé à la 1ère édition :

  • une centaine de pages en plus
  • 1 CD-ROM est maintenant joint avec
  • 2 nouveaux chapitres, couvrant java.io et XML
  • dernier chapitre fortement enrichi d'une partie dédiée à la synchronisation et au multi-threading, superbement bien expliqué
  • rajout d'appartés (notes marginales) à l'intention des développeurs C, C++ et C#
  • rajout d'appartés concernant les principales nouveautés du JDK 5.0
J'avais déjà lu la 1ère édition de ce livre, et la façon dont Emmanuel Puybaret explique les choses ma plue énormément. Les illustrations apportent beaucoup à la compréhension. Le code vous est expliqué, décortiqué. Vous n'avez presque plus l'impression de lire, mais de l'entendre vous parler. Ce livre est captivant. J'ai eu des difficultés à m'en détacher contrairement à d'autres livres, pour lesquels il m'a fallu me faire violence pour les lire jusqu'au bout (Le livre d'Anne Tassot en est un exemple).

Ce livre est AMHA le meilleur de la collection "Cahiers du programmeur", du point de vue approche pédagogique, illustration des propos, ... Emmanuel Puybaret a une approche pédagogique qui fait merveille.

Deux bémols :

  • Le chapitre XML m'a paru très pauvre. Mais XML est tellement vaste, et ses librairies Java également, qu'un livre dédié qu'à cela ne suffirait pas.
  • Le prix est passé de 23 à 29
A conseiller à tous les débutants Java.

Sommaire

  1. Présentation des études de cas
  2. Principes du langage et installation de l'environnement
  3. Création de classes
  4. Contrôle des traitements avec les opérateurs, boucles et branchements
  5. Réutilisation des classes
  6. Les classes de base de la bibliothèque Java
  7. Abstraction et interface
  8. Gestion des erreurs avec les exceptions
  9. Lecture et écriture des fichiers
  10. Interfaces utilisateur avec Swing
  11. Connexion à la base de données avec JDBC
  12. Programmation Web avec les servlets, JSP et JavaBeans
  13. Interface utilisateur du forum
  14. Echanger des informations avec XML
  15. Messagerie instantanée avec la programmation multitâche

367 pages, 3ème édition, mars 2006 Editions Eyrolles, ISBN: 221211916X , 21 x 2 x 24 cm
Commandez sur www.amazon.fr :
27,55 EUR TTC (prix éditeur 29 EUR TTC) - Livraison Gratuite !
couverture du livre 'Aide-Mémoire de Java'

note du livre : 5.0

Aide-Mémoire de Java

de Vincent Granet, Jean-Pierre Regourd

Résumé de l'éditeur

Etudiants en formation initiale ou continue, cet ouvrage constitue une base de référence pour vous initier au monde Java. Forts de leur expérience d'enseignants, les deux auteurs traitent les fonctionnalités de ce langage de façon didactique, suivant une progression logique. L'ensemble des possibilités offertes par Java est ainsi couvert : du modèle objet à l'environnement de programmation, des processus aux entrées-sorties, des API aux exceptions, de la généricité au graphisme : chaque notion est appuyée par un ou plusieurs exemples et cas pratiques. Aucune connaissance en Java n'est pré-requise. Vous pouvez donc aborder cet ouvrage en toute quiétude, pour mieux réussir vos examens et développer les bons réflexes de programmation en Java !

Critique du livre par la rédaction (Vincent Brabant )
Un livre à avoir dans votre poche

Cet aide-mémoire, de petit format, devrait être tout le temps dans votre poche.

Dès les premières pages de cet aide-mémoire, je fus surpris par sa qualité tant du point de vue du texte, que du point de vue des bouts de code Java donnés.

Ainsi, d'entrée de jeu (chapitre 1 et 2), on vous apprend comment afficher la date du jour dans un format donné, la nouvelle boucle ForEach, la classe StringBuilder, la classe Collator (Est-ce que Éléonor précède Fabian ou pas ?), les énumérations (enum).

J'aime également beaucoup la façon dont les auteurs vous expliquent les mécanismes de la programmation par objet, la généricité (nouveauté du JDK 5.0) et le contrôle d'exécution.

Le chapitre 8, dédié aux API Java, aborde les collections, les tables, les URL et Sockets, AWT, Swing et les applets. Cela ne couvre évidemment pas tout ce qu'un livré dédié à Swing pourrait couvrir, bien évidemment, mais vous y avez vraiment l'essentiel (composants, événements, conteneurs et systèmes d'agencement (layout))

Dans le dernier chapitre (le 9), ils y ont même consacré une petite partie sur la sécurité, et l'utilitaire policytool.

J'oubliais également la partie consacrée aux entrées-sorties, ainsi que celle consacrée aux threads.

Quand je vous dis que malgré sa petite taille, il couvre une multitude de choses, je n'exagère pas. Ce n'est pas un ouvrage de référence, qui passe en revue toutes les API du JDK. Mais un excellent aide-mémoire, illustré abondamment d'extraits de code, très bien pensés.

Un excellent rapport qualité/prix

Sommaire

Aide-Mémoire de Java

  • Avant-propos
  • Java, les bases
  • Les Objets de base
  • Le modèle Objet de Java
  • Les mécanisme de programmation par objets
  • La généricité
  • Le contrôle de l'exécution
  • Les entrées-sorties
  • L'API
  • L'environnement Java
  • Bibliographie
  • Annexe
  • Index

246 pages, septembre 2005 Editions Dunod, ISBN: 2-10-049145-8
Commandez sur www.amazon.fr :
15.20 EUR TTC seulement (au lieu de 16 EUR TTC : prix éditeur) - Livraison Gratuite ! (voir conditions)
couverture du livre 'Le livre de Java'

note du livre : 2.5

Le livre de Java

premier langage

de Anne Tasso
Public visé : Débutant

Résumé de l'éditeur

Vous avez décidé de vous initier à la programmation et souhaitez opter pour un langage largement utilisé dans le monde professionnel ? Java se révèle un choix idéal comme vous le découvrirez dans ce livre conçu pour les vrais débutants en programmation. Vous apprendrez d'abord, à travers des exemples simples en Java, à maîtriser les notions communes à tous les langages : variables, types de données, boucles et instructions conditionnelles, etc. Vous franchirez un nouveau pas en découvrant par la pratique les concepts de la programmation orientée objet (classes, objets, héritage), puis le monde des interfaces graphiques avec les librairies AWT et Swing (fenêtres, gestion de la souris). Vous découvrirez enfin les applications de Java pour Internet, côté client (applets) et côté serveur (JSP, JavaBeans), ainsi que les dernières nouveautés de J2SE 5.0.

Chaque chapitre est accompagné de deux types de travaux pratiques : des exercices, dont le corrigé est fourni sur le CD-Rom d'accompagnement, et un projet développé au fil de l'ouvrage, qui vous montrera comment combiner toutes les techniques de programmation étudiées pour construire une véritable application Java.

Á qui s'adresse ce livre ?
  • Aux étudiants de 1er cycle universitaire (IUT, Deug...) ou d'écoles d'ingénieurs.
  • Aux vrais débutants en programmation : passionnés d'informatique et programmeurs autodidactes, concepteurs de sites Web souhaitant aller au-delà de HTML et JavaScript, etc.
  • Aux enseignants et formateurs à la recherche d'une méthode pédagogique et d'un support de cours structuré pour enseigner Java à des débutants.
Critique du livre par la rédaction (Vincent Brabant)
Lorsque j'ai vu qu'une 3ième édition de ce livre était sortie, je me suis précipité dessus. En effet, j'avais ouï dire que du bien des éditions précédentes de ce livre.

Malheureusement, je fus quelque peu déçu.

Non pas que le livre en soi soit mauvais. Que du contraire. Il ravira tous les débutants en programmation, pour qui Java est leur premier langage.

Mais, il était indiqué à l'arrière du livre qu'on y découvrirait les dernières nouveautés du J2SE 5.0.

Or, les nouveautés du J2SE 5.0 ne sont abordées que dans les chapitres 9 et 10.

De plus, étant donné que ce livre en est déjà à sa troisième édition, je ne peux m'expliquer la présence de nombreuses coquilles concernant les noms de variables, l'explication d'unicode, ...

Une fois oublié ces quelques défauts, il est à noter que ce livre atteint pleinement le but qu'il s'est fixé: faire découvrir Java en tant que premier langage.

La difficultés des exercices va en progressant tout au long du livre. L'auteur étoffe également son programme "fil rouge" tout au long du livre, pour avoir une application complète à la fin du livre.

Pour résumer: Un bon livre pour ceux qui désirent apprendre Java comme 1er langage. Les exercices qu'il contient sont de très bon niveau, et on se sent progresser tout au long du livre. Mais la présence de nombreuses erreurs et coquilles (n'oublions pas que c'est déjà la troisième édition), ainsi que le peu de matières concernant les nouveautés du J2SE 5.0 m'empêche de donner une bonne note à ce livre.

Sommaire

Le livre de Java 1er Langage

  • Avant-propos - Organisation de l'ouvrage
  • Introduction - Naissance d'un programme
  • Stocker une information
  • Communiquer une information
  • Faire des choix
  • Faire des répétitions
  • De l'algorithme paramétré à l'écriture de fonctions
  • Fonctions, notions avancées
  • Les classes et les objets
  • Les principes du concept "objet"
  • Collectionner un nombre fixe d'objets
  • Collectionner un nombre indéterminé d'objets
  • Dessiner des objets
  • Java et Internet
  • Contenu et exploitation du CD-Rom

463 pages, 3ième édition, Septembre 2005 Editions Eyrolles, ISBN: 2-212-11679-9
Commandez sur www.amazon.fr :
28,41 EUR TTC (prix éditeur 29,90 EUR TTC) - Livraison Gratuite !
couverture du livre 'Refactoring des applications Java/J2EE'

note du livre : 4.5

Refactoring des applications Java/J2EE

de Jean-Philippe Retaillé
Public visé : Confirmé

Résumé de l'éditeur

Améliorer la qualité et l'évolutivité des applications Java/J2EE. Le refactoring consiste à refondre le code source d'une application existante ou en cours de développement pour en améliorer la qualité, avec pour objectif une réduction des coûts de maintenance et une meilleure évolutivité. L'ouvrage passe en revue les différentes techniques de refactoring utilisées en environnement Java/J2EE : extraction de méthodes, généralisation de type, introduction de design patterns, programmation orientée aspect, optimisation de l'accès aux données, etc. Un livre pratique illustré d'une étude de cas détaillée. L'ouvrage décrit dans le détail le processus de refactoring d'une application Java/J2EE : mise en place de l'infrastructure et des outils, analyse de la conception et du code de l'application, mise en oeuvre des techniques de refonte, tests de non régression. Cette démarche est illustrée par une étude de cas complète : refactoring d'une application J2EE Open Source à l'aide d'outils tels que Eclipse, CUS, JUnit et PMD.

Critique du livre par la rédaction (christopheJ)
On finit tous un jour par se retrouver sur un projet avec du code hérité au lourd passif... Le genre de code qui évolue au jour le jour. Le code pour lequel personne ne trouve le temps de prendre du recul pour essayer de l'alléger, réécrire les morceaux peu performant, redondant ou trop contraignant... C'est alors que cet ouvrage est utile.

Il présente une approche progressive du refactoring. On commence avec les choses de bases (renommage de variable, changement de nom de méthode) pour finir sur des choses plus compliquées (applications de pattern, refactoring de la base de données ...). L'approche est très graduelle, on ne se sent pas perdu et les outils (audit de code ou test) sont clairement expliqués.

Ce qui est intéressant, c'est que l'auteur pose toutes les conditions pour que cela se passe bien. Il explique comment déterminer les points sensibles qui seront soumis à refactoring, comment s'assurer que le comportement du logiciel sera le même après refactoring. Il détaille bien les outils de mesures mais aussi leur piège et faux positifs. Pour chaque technique il indique quand l'utiliser et quels sont les risques qui lui sont propres. Par exemple, vous avez sans doute déjà utilisé les fonctions de renommage de votre IDE, mais qu'en est-il en cas de chargement dynamique de la classe ou d'introspection sur la méthode ?
Chaque technique est accompagnée d'un exemple et de capture d'écran pour Eclipse.

Enfin, ce qui ajoute beaucoup de valeur à ce livre, c'est l'étude de cas qui occupe environ un cinquième du volume. On a tous lu des livres avec des exemples (parfois à peine plus complexes qu'un "Hello World"). On pense avoir compris et quand on arrive sur un vrai cas, on se pose encore des questions, on hésite, on ne sait plus ... Ici l'étude de cas se fait sur une vraie application, pas juste trois classes et deux JSP. Cette étude de cas permet de mettre en application les techniques décrites dans la première partie de façon guidée. Et si vous ne voulez pas faire les premières étapes (renommage) mais uniquement la refonte des DAO ou des actions Struts, il existe une version de chacune des étapes sur le CVS.

En conclusion, un livre obligatoire à lire si l'on se retrouve un jour avec du code hérité.

Critique du livre par la rédaction (Vincent Brabant)
Un excellent ouvrage sur le refactoring.

Ce livre est un bijou, une merveille, un joyau.

Je me suis vraiment régalé à la lecture de ce livre. Il commence tout d'abord par vous expliquer la raison d'être du refactoring, ce que c'est et ce que ce n'est pas.

Ensuite, il vous explique les préparations à faire (création de branches, de clichés, s'assurer qu'on a bien les tests unitaires, ...) avant d'effectuer un refactoring de votre application.

Puis, il vous explique la mise en oeuvre du refactoring, à l'aide de l'EDI Eclipse.

Il vient ensuite vous montrer comment combiner les tests unitaires avec le refactoring, et l'utilisation de simulacre d'objets avec EasyMock, mais également l'analyse de couverture avec EMMA.

Toute un chapitre est également consacré aux design patterns, et comment ils peuvent vous venir en aide dans le cas du refactoring.

L'auteur aborde également, avec élégance, la problématique du refactoring avec les bases de données. Et cela est vraiment enrichissant.

La troisième partie du livre est entièrement consacrée à l'étude de cas: un programme de généalogie.

A travers cette étude de cas, l'auteur vous apprendra comment, grâce à une analyse quantitative et une analyse qualitative, trouver les parties de code nécessitant un refactoring.

Une fois ces parties détectées, il va appliquer différents refactoring appris lors de la deuxième partie du livre.

Conclusion : Sans discussion, un excellent achat.

Critique du livre par la rédaction (Stessy)
Quelle personne ne s'est jamais retrouvée en face d'un code qu'elle avait ou n'avait pas produit et qui parfois se révèle être une cochonnerie en terme de maintenance et d'évolutivité.

Eh bien moi je me suis retrouvé dans le cas ou ce code ne m'appartenait pas et, qui plus est, était mal agencé pour me permettre de le faire évoluer sereinement sans devoir tout réécrire de A à Z.

Je me suis donc retroussé les manches et ai commencé à proprement parler le refactoring de l'application.

Je dois bien avouer que je ne m'en serait jamais sorti si je n'avais pas suivi les conseils précieux distillés dans cet ouvrage.

L'auteur commence d'abord par expliquer le pourquoi du refactoring.

Ensuite viennent les pré-processus indispensables pour effectuer un refactoring robuste tels que le versioning des différentes ressources, la mise en oeuvre des tests unitaires,...

Le troisième chapitre est pour moi le plus théorique. Il aborde les méthodes qui permettent d'analyser le code tant de manière quantitative que qualitative.
Je dois bien avouer que j'ai du relire ce chapitre une seconde fois pour bien comprendre à quels moments, et quels endroits du code, le refactoring devenait une nécéssité voire même une obligation.

Chapitre 4. Là, on rentre réellement dans la mise en oeuvre du refactoring. Chaque technique de refactoring abordée dans ce chapitre est basée sur un plan bien précis. Ce plan est décomposé en 4 parties :

  • les objectifs de cette technique ainsi que les risques pouvant survenir
  • les moyens de détection
  • le refactoring proprement dit
  • un exemple concret de mise en oeuvre
Le chapitre suivant traite de l'utilisation de test unitaires en combinaison avec le refactoring. Il explique également comment créer des simulacres d'objets qui permettront, comme le terme l'indique, de simuler des objets.

C'en est terminé avec la première partie de l'ouvrage.

La seconde partie traite des techniques avancées pour effectuer le refactoring d'une application telles que les design patterns, SOA.

Ce qui m'a le plus surpris dans cette partie, c'est le refactoring de la base de données.
Comme quoi on en apprend tous les jours.

La dernière partie reprend une étude de cas complète. Cette partie de l'ouvrage met en pratique la totalité des techniques abordées lors des chapitres précédents, en passant :

  • par l'analyse quantitative et qualitative,
  • par le refactoring de l'application,
  • par la mise en oeuvre des tests unitaires
En conclusion, cet ouvrage est un petite merveille. A recommander chaudement.

Sommaire

  • Remerciements

Avant-propos

  • Objectifs de cet ouvrage
  • Organisation de l'ouvrage
  • A propos des exemples
  • A qui s'adresse l'ouvrage ?

Chapitre 1: L'évolution logicielle et le refactoring

  • La problématique de l'évolution logicielle
  • Le périmètre d'intervention du refactoring
  • Le refactoring au sein des méthodes agiles
  • Conclusion

Chapitre 2: Préparation du refactoring

  • La gestion de configuration
  • Gestion des tests et des anomalies
  • Conclusion

Chapitre 3: L'analyse du logiciel

  • L'analyse quantitative du logiciel
  • L'analyse qualitative du logiciel
  • Sélection des candidats au refactoring
  • Conclusion

Chapitre 4: Mise en oeuvre du refactoring

  • Support du refactoring de code dans Eclipse
  • Les techniques de refactoring du code
  • Conclusion

Chapitre 5: Les tests unitaires pour le refactoring

  • Les tests unitaires avec JUnit
  • Les simulacres d'objets avec EasyMock
  • Analyse de couverture avec EMMA
  • Utilisation des test unitaires pour le refactoring
  • Conclusion

Chapitre 6: Le refactoring avec les design patterns

  • Les design patterns
  • Utilisation des modèles comportementaux
  • Amélioration de la structure des classes
  • Conclusion

Chapitre 7: Refactoring avec la POA (Programmation Orientée Aspect)

  • Principes de la programmation orientée aspect
  • Modularisation des traitements
  • Optimisation des traitements
  • Analyse du logiciel et tests unitaires
  • Conclusion

Chapitre 8: Refactoring de base de données

  • La problématique du refactoring avec les bases de données
  • Refactoring de la structure de la base
  • Refactoring des requêtes SQL
  • Refactoring de l'utilisation de JDBC
  • Conclusion

Chapitre 9: Présentation de l'étude de cas

  • Cahier des charges du logiciel
  • JGenea, une solution Java pour le généalogie
  • Architechture de JGenea Web
  • Récupération de JGenea Web
  • Fonctionnalités d'Éclipse utiles pour l'étude de cas
  • Conclusion

Chapitre 10: Analyse de JGenea Web

  • Analyse quantitative
  • analyse qualitative
  • Conclusion

Chapitre 11: Refactoring de JGenea Web

  • Réorganisation et mise à niveau
  • Application des techniques de base
  • Utilisation des Design Patterns dans la gestion des accès aux données
  • Modularisation avec un aspect
  • Pour aller plus loin

Annexe

  • Installation d'Eclipse
  • Installation de PMD sous Eclipse
  • Installation de Checkstyle sous Eclipse
  • Installation de Metrics sous Eclipse
  • Téléchargement d'EMMA
  • Téléchargement du client CVS pour Windows
  • Téléchargement de StatCVS
  • Téléchargement de Tomcat
  • Installation et configuration du plugin Tomcat de Sysdeo pour Eclipse
  • Installation du plug-in AJDT pour Eclipse
  • Script DDL de JGenea Web
  • Références

376 pages, Septembre 2005 Editions Eyrolles, ISBN: 2-212-11577-6
Commandez sur www.amazon.fr :
39,90 EUR TTC (prix éditeur 42 EUR TTC) - Livraison Gratuite !
couverture du livre 'Hibernate 3.0'

note du livre : 4.5

Hibernate 3.0

Gestion optimale de la persistance dans les applications Java/J2EE

de Anthony Patricio
Public visé : Tout public

Résumé de l'éditeur

Gestion optimale de la persistance dans les applications Java/J2EE : Standard de fait, Hibernate s'est imposé comme la solution idéale pour gérer le délicat problème de la persistance des objets Java/J2EE par mapping vers les bases de données relationnelles. Dans sa version 3, Hibernate fournit déjà une implémentation très avancée du futur standard de la persistance Java/J2EE : EJB 3.0 Persistence API. Un livre pratique illustré d'une étude de cas détaillée : Résolument pratique, cet ouvrage illustre chacune des fonctionnalités d'Hibernate à travers une étude de cas déclinée au fil des chapitres. Il insiste tout particulièrement sur les aspects méthodologiques et sur les questions de performances : maîtrise des fichiers de mapping, gestion optimale des sessions Hibernate, interrogation performante de la base de données, outils de productivité apportés par Hibernate 3.0, configuration des pools de connexions et des caches de second niveau, etc.

Critique du livre par la rédaction (Ricky81)
Cet ouvrage, écrit par l'un des acteurs majeurs de la communauté Hibernate, vous présente la démarche de mapping Objet/Relationnel, et en particulier l'implémentation Hibernate 3.0.
Après quelques rappels historiques et l'évocations des solutions passées et présentes, l'auteur nous fait partager toute sa connaissance d'Hibernate à travers des exemples simples et pertinents.

Suffisamment détaché de la documentation officielle, ce livre vous apprendra Hibernate 3.0 de A à Z en illustrant le propos par de nombreux exemples, dans un style agréable à lire et efficace.

Il y en a pour tous les goûts : que ce soit le débutant qui souhaite s'initier à cette solution de gestion de la persistance, le connaisseur qui est à la recherche de conseils et de bonnes pratiques, ainsi que l'expérimenté toujours à l'affût des nouveautés, améliorations, notions avancées, fonctionnalités à venir.

En conclusion, cet ouvrage complet ne devrait pas vous décevoir, et vous accompagnera dans votre démarche de gestion de la persistance avec l'une des (futures) implémentations de la norme EJB 3.0.

Retrouvez la critique complète ici.

Sommaire

  1. Persistance et mapping objet-relationnel
    1. Historique de la persistance en Java
    2. Principes de la persistance
    3. Les autres solutions de persistance
    4. Conclusion
  2. Classes persistantes et session Hibernate
    1. Installation d'Hibernate
    2. Les classes métier persistantes
    3. La session Hibernate
    4. Conclusion
  3. Métadonnées et mapping des classes métier
    1. Référentiel des métadonnées
    2. Les fichiers de mapping
    3. Conclusion
  4. Héritage, polymorphisme et associations ternaires
    1. Stratégies de mapping d'héritage et polymorphisme
    2. Mise en oeuvre d'une association bidirectionnelle
    3. Les autres types d'associations
    4. Conclusion
  5. Méthodes de récupération d'instances persistantes
    1. Le lazy loading, ou chargement à la demande
    2. Les techniques de récupération d'objets
    3. Conclusion
  6. Création, modification et suppression d'instances persistantes
    1. Persistance d'un réseau d'instances
    2. Les transactions
    3. Conclusion
  7. Gestion de la session Hibernate
    1. La session Hibernate
    2. Les transactions applicatives
    3. Utilisation d'Hibernate avec Struts
    4. Gestion de la session dans un batch
    5. Interpréter les exceptions
    6. Conclusion
  8. Fonctionnalités de mapping avancées
    1. Fonctionnalités de mapping liées aux métadonnées
    2. Fonctionnalités à l'exécution
    3. Les nouveaux types de mapping d'Hibernate 3
    4. Conclusion
  9. L'outillage d'Hibernate
    1. L'outillage relatif aux métadonnées
    2. L'outillage Hibernate Tools
    3. Extensions et intégration
    4. Conclusion

317 pages, 1ère édition, juin 2005 Editions Eyrolles, ISBN: 2212116446 , 19 x 2 x 23 cm
Commandez sur www.amazon.fr :
37,05 EUR TTC (prix éditeur 39 EUR TTC) - Livraison Gratuite !
couverture du livre 'Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0'

note du livre : 3.0

Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0

de Cay S Hortsmann & Gary Cornell

Résumé de l'éditeur

Plus de 250 000 programmeurs ont utilisé Au coeur de Java 2 Volume 1- Notions fondamentales pour consolider leur savoir sur la technologie Java. Ce second volume va plus loin encore et constitue un guide complet pour résoudre les problèmes quotidiens des développeurs. La cinquième édition du volume 2 entre en détail dans des sujets tels que la programmation de l'interface utilisateur et les fonctions professionnelles de la plate-forme java 2, édition standard (JSETM). Totalement mis à jour, cet ouvrage traite les multithreads, qui permettent d'exécuter des tâches en parallèle, l'API JDBC 2.0, CORBA, le glisser-déposer et le modèle de sécurité Java 2. Ce dernier a été revu pour le JDK 5.0, de façon à prendre en compte les algorithmes de cryptage AES et RSA. Les techniques de Swing avancées sont abordées, dont les composants GUI complexes d'arbres et de tables, les indicateurs de progression et l'implémentation Java d'une interface à "plusieurs documents". Un chapitre décrit les techniques de conception des cadres de collections et l'exploitation des données structurelles fondamentales autorisées par la bibliothèque standard Java. Cette édition explique aussi comment internationaliser des applications Java, générer du XML et utiliser les transformations XSL. Le chapitre consacré au XML a été mis à jour pour inclure l'API XPath. Enfin, un nouveau chapitre a été ajouté il traite des annotations et des métadonnées, des fonctionnalités ajoutées au JDK 5.0.

Critique du livre par la rédaction (Vincent Brabant)
Ce second tome complète à merveille le premier (voir critique du 1er tome sur developpez.com)

Le 1er chapitre a été entièrement réécrit, pour aborder la nouvelle API concernant la Concurrence introduite dans la version 5 de Java. Cette nouvelle API met à votre disposition tout un ensemble de classes et interfaces vous permettant de construire plus facilement des applications mutithreads performantes que ce qui était possible jusqu'à présent.

Le second chapitre, couvrant les Collections, a été étendu pour aborde la notion de Queue, la classe PriorityQueue, .... Ce chapitre explique également les tables de hachage, et pourquoi il est important de choisir un bon code de hachage. Il aborde également la notion de Weak Reference, bien que cela soit traité de façon plus superficielle que dans le livre HardCore Java, de chez Oreilly.

J'ai une remarque négative à faire à l'encontre des traducteurs. Pourquoi ont il traduit les noms des classes et/ou interfaces en français dans les figures montrant les anciennes classes, comme Vector, Map et Properties. Mais cela ne concerne qu'une figure sur une page dans tout le livre.

Je n'ai pas eu l'impression qu'il y a beaucoup de modification concernant les chapitre 3 à 10 par rapport à l'ancienne version. Même si le chapitre sur la sécurité couvre maintenant AES et RSA, et que le chapitre XML couvre XPATH. Mais cela est assez concis et rien de tel qu'un ouvrage de référence sur XML et XPATH. Et que les exemples ont été revus. Par exemple, dans le chapitre 9, il expliquent comment appeler une méthode printf depuis Java.

Le chapitre 11 concernant les annotations est quant à lui tout à fait nouveau et vous explique en détails. Il aborde également BCEL, qui vous permet de manipuler directement du ByteCode.

Pour ceux qui possèdent une ancienne édition de ce deuxième tome , l'achat de celui ci vous sera utile si vous voulez connaitre les nouveautés introduites au niveau du Multithreading, des collections, des certificats RSA et AES, et connaitre les annotations. Pour ceux qui ne possedent pas d'ancienne édition de ce deuxième tome, je ne peux que vous conseiller ce livre de référence. En tout cas, si vous avez acheté récemment la dernière édition du Tome 1, n'hésiter pas à acheter son compagnon.

Sommaire

  1. Multithreads
  2. Collections
  3. Programmation des bases de données
  4. Objets distribués
  5. Swing
  6. JavaBeans
  7. La sécurité
  8. Internationalisation
  9. Méthodes natives
  10. XML
  11. Annotations

858 pages, juin 2005 Editions Campus Press Référence, ISBN: 2-7440-1962-3
Commandez sur www.amazon.fr :
42,75 EUR TTC (prix éditeur 45,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Eclipse et JBoss'

note du livre : 3.0

Eclipse et JBoss

de Karim Djaafar, Olivier Salvatori

Résumé de l'éditeur

Développement d'applications J2EE professionnelles, de la conception au déploiement.

Critique du livre par la rédaction (Hugo Etiévant)
C'est un livre sur le développement J2EE avec Eclipse. L'intérêt de l'ouvrage est de présenter les très nombreux outils à interfacer avec Eclipse qui ne se suffit plus à lui-même. Qu'il s'agisse du déploiement avec Ant, des tests unitaires avec JUnit, de l'analyse des performances avec JUnitPerf, de la génération de fichiers de configuration ou de code avec XDoclet, de la gestion collaborative de sources avec CVS, de la génération de code à partir de diagrammes UML avec EclipseUML... nombreux sont les outils qui permettent d'accélerer et de rationnaliser le développement d'applications J2EE. L'auteur nous présente avec simplicité les multiples outils ainsi que les méthodes (design pattern) à disposition des développeurs pour un travail de qualité, réutilisable et maintenable.

Sommaire

  1. Développement et déploiement J2EE avec Eclipse et JBoss
  2. L'étude de cas WebStock
  3. Développement Web avec MyEclipse
  4. Développement EJB avec JBoss, MyEclipse et XDoclet
  5. Aspects avancés de JBoss

629 pages, 1ère édition, mars 2005 Editions Eyrolles, ISBN: 2212114060 , 19 x 4 x 23 cm
Commandez sur www.amazon.fr :
42,75 EUR TTC (prix éditeur 45,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Struts'

note du livre : 3.5

Struts

Les bonnes pratiques pour des développements web réussis

de Vic Cekvenich et Wolfgang Gehner
Public visé : Intermédiaire

Résumé de l'éditeur

Ce livre s'adresse aux développeur et programmeurs d'applications déjà expérimentés en Java et qui ont besoin de maîtriser Struts rapidement et efficacement.
Le framework Jakarta Struts est devenu un standard Open Source confirmé : sa performance, son indépendance par rapport à des systèmes propriétaires et son efficacité des coûts sont des avantages convaincants.
Résolument concret et pratique, cet ouvrage rassemble des conseils, une multitudes d'exercices, des résumés et tout un savoir-faire tiré de l'expérience professionnelle des deux auteurs.
Ils exposent les méthodes les plus efficaces, les interfaces les plus conviviales, les coûts les moins élevés, le chemin le plus court, en un mot ce que les Anglo-saxons appellent les "Best Practices".

- La première partie passe en revue les phases de développement avec Struts 1.2, JSTL 1.1, Servlet 1.4, JSP 2.0, Tomcat 5, Eclipse 3 et PostgreSQL.
- La seconde apprend comment construire une infrastructure applicative solide et performante et comment tirer des avantages de la réutilisation de code.
- La troisième partie explique comment concevoir une interface utilisateur sûre, et comment sécuriser l'application.

Critique du livre par la rédaction (Ricky81)
Cet ouvrage se destine à des développeurs, experts techniques ou architectes, disposant de bases concernant Struts et étant à la recherche de bonnes pratiques.
Les pistes de réflexions suggérées par les auteurs sont nombreuses, dispersées tout au long d'un ouvrage qui manque de cohérence d'ensemble et qui s'éloigne par moment de Struts. Ainsi, le lecteur y trouvera une multitude de conseils pour ses développements Web en Java, mais ne devra pas se reposer sur cet ouvrage pour apprendre à utiliser Struts.

Malgré une certaine désorganisation, les sujets abordés par les auteurs sont intéressants mais par moment assez peu explorés en profondeur. Charge au lecteur d'aller plus loin en partant à la recherche de lectures complémentaires sur les sujets qui auront retenu son attention.
Agrémenté de quelques chapitres plutôt orientés "Gestion de projet", le propos de cet ouvrage repose entièrement sur la suite de développement Jasic (éditée par les sociétés respectives des auteurs) qui rassemble un certain nombre d'outils/framework tels que Struts ou encore iBatis.

On regrettera néanmoins l'absence de certaines thématiques comme les traitements côté serveur, Struts-Layout, les bibliothèques de tags bean et logic, ou encore davantage d'éléments concernant les Tiles. Le lecteur appréciera l'abondance d'illustrations par le code, code dont le style n'est malheureusement pas très agréable à la lecture.

En conclusion, ce livre, véritable mine d'informations et de conseils, malgré une organisation une peu fouillie, vous sera de bon conseil pour approndir l'utilisation de Struts ou de manière générale la construction d'applications Web basées autour de Struts ou un framework équivalent.
Par contre, il ne vous formera pas à Struts, et un minimum de connaissances sur ce framework semble nécessaire pour bien aborder le contenu du livre.

Retrouvez la critique complète ici.

Sommaire

  1. Démarrer le projet
  2. Spécifications des exigences
  3. Créer un accès à la base de données
  4. Travailler avec des actions simples
  5. Travailler avec des JSP et View
  6. Travailler avec des Beans simples
  7. Astuces sur le processus de développement
  8. Créer l'accès aux données
  9. Des Beans réutilisables
  10. Actions et événements réutilisables
  11. Autres actions de traitement des formulaires
  12. Validation
  13. Contenu dynamique de site
  14. Sécurité
  15. Formulaires complexes et notation par points
  16. Eléments déroulants et super-type
  17. Concevoir l'interface utilisateur
  18. Gestion de la performance
  19. Future sécurité de l'application

219 pages, 1ère édition, février 2005 Editions Dunod, ISBN: 2100486357 , 18 x 2 x 25 cm
Commandez sur www.amazon.fr :
28,41 EUR TTC (prix éditeur 29,90 EUR TTC) - Livraison Gratuite !
couverture du livre 'Cahiers du programmeur : Java/XML'

note du livre : 4.0

Cahiers du programmeur : Java/XML

de Renaud Fleury avec la contribution de Caroline de Vasson

Résumé de l'éditeur

Au fil de la refonte d'un système d'information de site e-commerce, ce cahier illustre les meilleures pratiques J2EE à mettre en oeuvre tant pour la modélisation et la présentation de flux XML que pour la conception de services web. Le couple Java/XML est incontournable pour le développeur J2EE professionnel qui doit mettre en place des applications de gestion portables, ouvertes et fiables. On verra dans ce cahier comment stocker et restituer dans un format homogène des données hétérogènes, valider des flux XML, écrire un mapping objet/XML en utilisant des outils open source tels que Xerces, Xalan, Ant, Castor, Eclipse, Axis, eXist...

Critique du livre par la rédaction (Ioan Calapodescu)
Le couple Java/XML est désormais un incontournable pour le développeur J2EE. La découverte des intéractions entre ces deux technologies est le but avoué de cet ouvrage. La tâche est difficile, mais l'auteur, Renaud Fleury, en viens à bout de manière fort élégante.
Ce ouvrage est destiné à toute personne désirant faire du développement web avec J2EE et XML. Que vous soyez un développeur J2EE débutant désirant vous ploger dans le développement web, un développeur J2EE confirmé désirant découvrir (ou redécouvrir) la technologie XML ou encore un chef de projet désirant avoir un apercu clair des possibilités offertes par le couple J2EE/XML, ce livre est fait pour vous.
Le parti pris de cet ouvrage est de faire découvrir les vastes possibilités de Java/XML grâce à la réalisation, tout au long du livre, d'un projet de site web totalement axé sur XML : le projet Octopuss.

Le principal atout de cet ouvrage est justement le projet Octopuss. Il est particulièrement agréable de découvrir de manière pratique ces technologies, parfois complexes. Ainsi, l'auteur commence tout simplement par un cahier des charges : exposition des besoins, spécifications fonctionnelles et techniques, méthodologies de développement, etc. Vous pouvez d'ailleurs découvrir ce premier chapitre sur le site d'Eyrolles : extraits du livre Java / XML.
Après une partie dédiée à l'installation des outils de développement (Eclipse, Tomcat, Log4j, etc.), on passe dans le vif du sujet : le développement de l'application. Chaque chapitre va vous permettre de découvrir une nouvelle facette de XML et son application pratique avec le projet Octopuss. Vous pourrez ainsi faire le tour du monde XML : les notions et API fondamentales (XML, XSL, XML Schema, JAXP, SAX, DOM, etc.), le data-binding (JAXB, Castor, etc.), les frameworks d'application (Struts, Cocoon, Barracuda), les bases de données XML natives et la conception de services Web.
On pourra aussi apprécier la mise en page claire, la présence de nombreux schémas explicatifs et de nombreux cadres présentant des définitions, liens web intéressants, etc.

La seule chose que l'on pourra regretter après la ecture de cette ouvrage est l'absence d'un CD. Celui-ci aurait pu contenir les outils de développement (outils libres et gratuits), ainsi que les codes sources du projet Octopuss. Je pense que cela aurait renforcé le côté pratique de l'ouvrage et aurait permis de se focaliser plus directement sur le côté technique.
Les codes sources de l'application sont téléchargeables : Java/XML Téléchargements.
Une dernière remarque que l'on pourrait faire est le fait que certaines technologies ne sont que survolées. A dire vrai, j'aurais lu avec plaisir quelques chapitres de plus. ;-)

Pour conclure, je dirais que cet ouvrage devrait trouver sa place dans la bibliothèque de tout développeur J2EE : un guide utile, agréable et pratique des technologies Java/XML.

Sommaire

  1. Cahier des charges
  2. Installation de l'environnement de développement
  3. XML, pour configurer et transporter des données
  4. Modélisation et visualisation des objets métier via XML
  5. Struts, partie émergée de l'application ?
  6. Les bases de données XML natives : grand déstockage d'Automne ?
  7. Conception de services web

217 pages, 1ère édition, décembre 2004 Editions Eyrolles, ISBN: 2212113161 , 21 x 2 x 24 cm
Commandez sur www.amazon.fr :
27,55 EUR TTC (prix éditeur 29,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Initiation à JSP'

note du livre : 3.0

Initiation à JSP

Avec 50 exercices corrigés

de Anne Tasso et Sébastien Ermacore
Public visé : Débutant

Résumé de l'éditeur

Apprendre JSP par la pratique. Particulièrement adapté aux étudiants, ce livre décrit de manière concrète et illustrée tous les concepts de JSP (JavaServer Pages), langage de script permettant de développer des sites Web dynamiques associés à des bases de données. Avec une approche très pédagogique, héritée de l'expèrience de formateur des auteurs, cet ouvrage explique à l'aide de termes clairs et d'exemples simples toutes les notions relatives à la programmation JSP : les bases du langage Java, JavaBeans, cookies, sessions, connexion aux bases de données, servlets... Pour permettre au lecteur d'appliquer directement ses connaissances, chaque chapitre se clôt par une série d'exercices, dont les fichiers sources et les corrigés figurent sur le CD-Rom d'accompagnement.

Critique du livre par la rédaction (Ricky81)
Ce livre s'adresse essentiellement à des débutants qui disposent d'un minimum de culture informatique et sont intéressés par le développement Web et la création de pages dynamiques.
Avant d'aborder les JSP, les auteurs s'attachent à poser les fondements du développement Web en insistant sur des points essentiels tels que HTTP, HTML et les bases de données.
Très facile et agréable à lire, il propose également une excellente pédagogie reposant sur un résumé ainsi que des exercices en fin de chapitres. Les termes sont clairs et les exemples nombreux, un précieux CD-ROM accompagne l'ouvrage, et le lecteur apprendra les bases de l'écriture de scriptlets, l'utilisation de JavaBeans, et sera capable de décrire les liens intimes entre JSP et Servlet.

L'ouvrage étant rendu accessible à un public de débutants non initiés aux technologies Web et Java, le propos ne se limite donc pas à JSP et cela a tout naturellement pour conséquence d'en réduire la portée sur ce thème.
Si les choix et orientations des auteurs sont discutables, il n'en reste pas moins que les explications et la progression sont pertinentes. Les débutants y trouveront ainsi tout ce qu'il leur faut pour bien débuter avec JSP et en connaître les caractéristiques de base.
Cependant, le livre atteint ses limites lorsqu'on souhaite aller plus loin et notamment vers un développement plus structuré où les facteurs temps et maintenabilité ont entre autre leur importance. En effet, cet ouvrage ne traite pas des bibliothèques de tags (il se limite à ceux utilisés dans le cadre de JavaBeans) et se cantonne à des pages JSP écrites entièrement en scriptlets. C'est dommage car la notion de bibliothèques de tags reste l'un des fondements de JSP et illustre toute sa puissance, mais il faut bien faire des choix et organiser le livre en fonction du public visé, ce qu'ont bien fait les auteurs.

En conclusion, ce livre, écrit d'une fort belle manière et sans grandes fautes, peut être suggéré aux débutants aussi bien en développement Web que pour les seules JSP. Ceux-ci devront néanmoins réfléchir à leurs attentes : si le désir d'approfondir est présent, ce livre n'y répondra que partiellement.

Retrouvez la critique complète ici.

Sommaire

  1. Avant-propos - Organisation de l'ouvrage
  2. Introduction - Le comment ça marche du Web
    1. Etude d'un premier script JSP
    2. Internet et le modèle client-serveur
    3. Qu'est ce qu'une base de données ?
    4. Exploitation des exemples et exercices du livre
    5. Résumé
  3. Concepts fondamentaux
    1. Radiographie d'un script JSP
    2. Déclarer une variable
    3. L'instruction d'affectation
    4. Les opérateurs arithmètiques
    5. Résumé
    6. Exercices
  4. Communiquer avec l'internaute
    1. Les différentes façons d'afficher une information
    2. Transmettre une information à un site
    3. Résumé
    4. Exercices
  5. Les structures de la programmation Java
    1. Les tests
    2. Les boucles
    3. Les fonctions
    4. Résumé
    5. Exercices
  6. Utiliser un objet Java dans un script
    1. La notion de composants métier
    2. Ecrire un JavaBean
    3. Appeler un bean depuis un JSP
    4. Résumé
    5. Exercices
  7. Interroger une base de donn?es
    1. Mettre en place une base de données
    2. Enrichir une base de données avec JSP
    3. Résumé
    4. Exercices
  8. Connaître l'internaute
    1. Les cookies
    2. La session
    3. Résumé
    4. Exercices
  9. Les servlets ou les dessous cachés de JSP
    1. Du JSP à la servlet
    2. Construire ses propres servlets
    3. Résumé
    4. Exercices
  10. Annexe - Contenu et exploitation du CD-Rom

353 pages, 1ère édition, septembre 2004 Editions Eyrolles, ISBN: 2212115326 , 19 x 2 x 23 cm
Commandez sur www.amazon.fr :
27,55 EUR TTC (prix éditeur 29,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Services Web avec J2EE et .NET'

note du livre : 5.0

Services Web avec J2EE et .NET

Conception et Implémentation

de Libero Maesano, Christian Bernard et Xavier Le Galles
Public visé : Développeurs confirmés

Résumé de l'éditeur

Pour faire interagir de manière fiable, souple, sécurisée et transactionnelle, des applications hétérogènes au sein d'architectures orientées services, il faut intégrer les notions de contrat, de processus et de conversation métier, mais aussi maîtriser les environnements d'exécution en évitant les dérives propriétaires qui réduisent l'interopérabilité.

Cet ouvrage avant tout destiné aux développeurs et aux architectes explique la mise en oeuvre d'architectures réparties sur des plates-formes hétérogènes et mixtes, aussi bien côté serveur (J2EE, .NET) que sur le poste de travail (Internet Explorer, Mozilla, Flash, Microsoft Excel XP...), en mettant l'accent sur la description des processus métier avec BPEL.

Les techniques d'infrastructure ayant trait à la sécurité, à la fiabilité et aux transactions telles que WS-Security, WS-Transaction, WS-Coordination, sont présentées en détail, non sans un rappel approfondi des normes fondatrices (SOAP 1.1 et 1.2, WSDL et UDDI), de leurs dernières implémentations et des recommandations d'interopérabilité WS-I.

Critique du livre par la rédaction (Thomas Lebrun)
Si vous souhaitez tout savoir des Web Services, alors ce livre est pour vous !

Très complet, il vous permettra d'apprendre tout d'abord les bases, puis vous vous tournerez ensuite vers des notions plus complexes.

L'étude de cas est un vrai régal: en effet, dans beaucoup de livres, on vous explique ce que vous devez faire, mais il arrive très souvent que cela manque... d'exemples. Cette étude comble cette lacune et on ne peut que l'apprécier.

Bref, encore un livre que ne je peux que conseiller !

Sommaire

  1. L'architecture orientée services
    1. Le contrat de service
    2. La qualité de service : fiabilité, disponibilité, continuité, performances, sécurité et gestion transactionnelle
    3. Les architectures dynamiques : agrégation et dissémination de services, niveaux de configuration dynamique, négociation
  2. Technologies des services web
    1. # Protocoles Internet (URI, URN, URL, MIME, HTTP/1.1, SMTP, SSL, TLS) - Technologies XML (XML, XML Namespaces, XLink, XML Base, XPath, XML Schema, DOM)
    2. Échanger avec un service en SOAP - SOAP 1.1 et 1.2. Structure du message - Gestion des erreurs - Mécanismes de codage : usage littéral, usage codé. Pièces jointes - Styles d'échange : unidirectionnel, requête/réponse, RPC, document, synchrone, asynchrone
    3. Décrire un service avec WSDL - Liaisons SOAP, HTTP GET/POST, MIME
    4. Découvrir et publier un service avec UDDI 1.0 et 2.0 - Structure d'un annuaire UDDI. API de découverte et de publication - Correspondance WSDL/UDDI - Implémentations : annuaire public répliqué (UBR), annuaires privés - UDDI 3.0
  3. Les plates-formes opérationnelles
    1. WSDL comme pivot. Transformer un composant en service (MS SOAP Toolkit, Cape Clear CapeStudio) - Générer des proxy-services (MS .NET Framework, IBM Web Services Toolkit), squelettes de service (Cape Clear CapeStudio), clients de test (Cape Clear CapeStudio, WebService Browser)
    2. Plates-formes Java - Apache SOAP 4J, Xerces, Tomcat, Axis (implémentation de référence) - IBM WebSphere - Sun ONE - BEA WebLogic, mais aussi Glue, CapeConnect, Systinet WASP, Collaxa...
    3. Plate-forme .NET - WSE - Framework .NET - ASP .NET - Web Forms - Visual Studio .NET
    4. Implémentations sur le poste de travail - Behavior Internet Explorer - Ecmascript avec Mozilla - Office XP en client SOAP - Macromedia Flash
    5. Le défi de l'interopérabilité - Tests SOAP, UDDI et WSDL - Le consortium WS-I
  4. L'infrastructure des services web
    1. Fiabilité des échanges : HTTPR, WS-Reliability...
    2. Gestion de la sécurité : XML Encryption - XML Signature - WS-Security - Exemple avec X.509
    3. Gestion des transactions : WS-Coordination, WS-Transaction, BTP
    4. Gestion des processus métier en BPEL, WSCI...
  5. L'Étude de cas
    1. Agence de voyage - Implémentation client en IE - Architecture statique : Implémentation en Java - Architecture dynamique (UDDI) - Implémentation Java
    2. Implémentation mixte Java/.NET
    3. Architecture en processus métier : orchestration de services en BPEL

1055 pages, septembre 2003 Editions Eyrolles, ISBN: 2212110677 , 6 x 19 x 23
Commandez sur www.amazon.fr :
52,25 EUR TTC (prix éditeur 55 EUR TTC) - Livraison Gratuite !
couverture du livre 'Programmer en Java'

Programmer en Java

de Claude Delannoy
Public visé : intermédiaire - connaissance d'un autre langage (C++) conseillée

Résumé de l'éditeur

De la programmation objet en Java à la programmation événementielle avec Swing

Dans cet ouvrage, Claude Delannoy applique au langage Java la démarche pédagogique qui a fait le succès de ses livres sur le C et le C++.

Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses. L'apprentissage du langage se fait en trois étapes: apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java et initiation à la programmation graphique et événementielle avec la bibliothèque Swing.

Chaque notion nouvelle et chaque fonction du langage est illustrée de programmes complets, tous testés à l'aide de l'outil de développement JBuilder 6 de Borland dont la version Personnel est fournie sur le CD-Rom d'accompagnement.

Cette deuxième édition mise à jour inclut deux nouveaux chapitres sur la gestion des threads et sur les collections et algorithmes.

Critique du livre par Pill_S
Ce livre, très complet et intéressant, est idéal lors des premiers pas dans le langage Java. Bien que la manière d'aborder certains thèmes puisse paraître rude pour certains débutant, les différents chapitres sont très complets et fourmillent d'informations intéressantes, ce qui fait qu'encore aujourd'hui, il m'arrive de m'en servir. De nombreuses comparaisons avec le langage C++ sont effectuées tout au long de l'ouvrage, ce qui pourra inciter les programmeurs C++ voulant se mettre au Java à choisir ce livre.

La première centaine de pages de l'ouvrage est dédiée aux bases du langage : généralités, types primitifs, opérateurs et expressions, instructions de contrôle, etc. En bref, toute la syntaxe de base que l'on doit connaître avant de pouvoir s'attaquer à des choses plus spécifiques au langage.

Ensuite, le rythme s'accélère dès l'arrivée dans les notions propres à l'orienté objet : les notions de classe, d'instance, d'héritage et de polymorphisme sont traitées dans une série de chapitres très intéressant et expliquant bien les différents mécanismes et leurs implications. De nombreux exemples simples, avec leur code, viennent illustrer les sujets traités. Il s'agit sans doute du chapitre réclamant le plus d'efforts de la part du débutant avant d'être assimilé.

Une fois le lourd bagage théorique sur les objets acquis, l'auteur nous fait découvrir les très utiles exceptions de Java, puis nous propose ensuite un chapitre malheureusement trop bref sur les threads.

Les deux centaines de pages suivantes nous entraînent dans les bases de la programmation graphique et événementielle avec Swing. Le lecteur pourra y découvrir des exemples d'utilisation de la plupart des contrôles usuels : boutons, cases à cocher, menu, zones de textes, ... On pourra regretter le fait que AWT ne soit pas traité, mais on regrettera surtout que certains composants relativement complexes comme les JTable ou les JTree ne le sont pas non plus.

La suite du livre traite des entrées/sorties standards de Java, mais de manière succincte, presque bâclée. A aucun moment il ne parle de communication réseau, ni des nouvelles entrées/sorties de java.nio. Seuls les flux de gestion des fichiers sont traités (binaires et textes). Même s'il est vrai que leur utilisation diffère peu d'un flux réseau, je pense qu'il aurait été bon d'avoir un bref exemple d'utilisation.

Les derniers chapitres du livre traitent des collections, ensembles et tables associatives, et sont une nouvelle fois d'une grande qualité, très complets et facile à comprendre.

Globalement, le contenu du livre est très bon, malgré quelques petites lacunes sans gravité. Il remplit parfaitement sa fonction d'initiation au langage Java, et permet d'entrevoir une bonne partie de la puissance du langage. Le programmeur, une fois formé aux bases, devra néanmoins se tourner vers d'autres livres afin de compléter ses connaissances sur des sujets plus spécifiques.

Sommaire

  1. Présentation de Java
  2. Généralités
  3. Les types primitifs de Java
  4. Les opérateurs et les expressions
  5. Les instructions de contrôle de Java
  6. Les classes et les objets
  7. Les tableaux
  8. L'héritage
  9. Les chaînes de caractères
  10. La gestion des exceptions
  11. Les threads
  12. Les bases de la programmation graphique
  13. Les contrôles usuels
  14. Les boîtes de dialogue
  15. Les menus, les actions et les barres d'outils
  16. Les événements de bas niveau
  17. Les gestionnaires de mise en forme
  18. Textes et graphiques
  19. Les applets
  20. Les flux et les fichiers
  21. Les collections et les algorithmes

661 pages, 2ème édition, avril 2003 Editions Eyrolles, ISBN: 2-212-11119-3
Commandez sur www.amazon.fr :
couverture du livre 'Ant précis & concis'

note du livre : 5.0

Ant précis & concis

de Stefan Edlich
Traducteur(s) : James Guérin

Résumé de l'éditeur

Développé par l'Apache Software Foundation sous licence Open Source, Ant est un système de gestion de build comparable à Make. Sa portabilité est garantie par l'usage du langage java et du format XML pour les fichiers de build.
Ant - précis & concis référence les éléments de base (projets, propriétés, cibles et tâches) et décrit par l'exemple un fichier build. Les concepts fondamentaux de cet utilitaire sont expliqués afin de permettre une bonne compréhension du fonctionnement de Ant (jeux de fichiers, de modèles, les Classpath, arguments de la ligne de commande, etc.). Les tâches de base incluses par défaut dans toutes les distributions de Ant sont listées et détaillées. Un aperçu des tâches optionnelles complète ce guide, qui s'appuie sur la version 1.4.1 de Ant.

Les développeurs java qui désirent apprendre rapidement Ant trouveront dans cet ouvrage une introduction à son utilisation et ceux plus expérimentés qui recherchent une commande particulière y verront un précieux aide-mémoire.

Critique du livre par l'équipe Java
Ant est devenu un outil indispensable au développeur Java, quel que soit son domaine de prédilection : J2SE, J2EE, etc. Sa portabilité, sa facilité d'utilisation et son intégration à de nombreux EDI/RAD du marché (grâce à des plugins, voir même par défaut avec NetBeans), en font un outil incontournable. Voici quelques liens grâce auquels vous pourrez en apprendre un peu plus :

Présentation de Ant par Ludovic Fernàndez



Sommaire

  1. Introduction
  2. En trois étapes vers le fichier build
  3. Éléments de base de Ant
  4. Concepts fondamentaux
  5. Paramètres de la ligne de commande
  6. Propriétés prédéfinies
  7. Tâches personnalisées
  8. Perspectives : Ant 2
  9. Tâches prédéfinies
  10. Référence des tâches standard
  11. Tâches optionnelles

110 pages, 30 juin 2002 Editions O'Reilly, ISBN: 2841771598
Commandez sur www.amazon.fr :
8,55 EUR TTC (prix éditeur 9,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Jakarta Struts'

note du livre : 3.0

Jakarta Struts

par la pratique

de James Goodwill
Traducteur(s) : Sylvie Gréco
Public visé : Débutant

Résumé de l'éditeur

Le framework Struts : le standard de fait pour le développement d'applications Web en Java. Parce qu'ils permettent d'assurer l'évolutivité des applications Web, de diminuer les coûts et les délais de développement, et d'accroître la fiabilité des applications, les frameworks se sont imposés comme une alternative très avantageuse aux servies et aux JSP en matière de développement d'applications Web en Java. Standard de fait parmi les frameworks Open Source, Struts gère de façon simple la plupart des tâches inhérentes au développement d'applications Web ; il est entièrement compatible avec les standards en vigueur (JSP, EJB, servlets, etc.). Struts en action Cet ouvrage est conçu comme un tutoriel dont l'objectif est de vous faire acquérir une connaissance concrète et immédiatement exploitable de Struts : design pattern MVC, vues, contrôleur, traitement des erreurs, internationalisation des applications, etc. Le code des nombreux exemples et de l'application complète proposés est directement réutilisable.

Critique du livre par la rédaction (Ricky81)
Cet ouvrage se destine essentiellement aux débutants désirant apprendre à utiliser le framework Struts.
Très facile et agréable à lire, il fait le tour des prérequis nécessaires à la compréhension et l'utilisation de Struts pour se focaliser par la suite sur la version 1.1 du framework.

L'auteur se repose sur l'utilisation de Tomcat 4.1 et de MySQL pour illustrer son propos et construire ses exemples.
Les explications des concepts de base (MVC, ActionForm, Action, fichier de configuration, internationalisation, ...), tout comme leur mise en oeuvre à travers des exemples, sont conformes à ce que propose Struts 1.1, mais l'auteur omet de nombreuses nouveautés introduites à partir de cette version.
Il ne faut donc pas se fier au titre original de cet ouvrage (à savoir Mastering Jakarta Struts) sous peine d'être déçu.

Malgré tout, ce livre reste l'une des rares ressources françaises sur Struts et, même s'il ne permet pas d'être directement opérationnel sur la version courante, permettra à un public de débutants de se familiariser rapidement avec le framework. De plus, ses annexes sur les librairies de tags pourront servir d'aide mémoire.
Si vous recherchez un ouvrage couvrant une version plus récente de Struts pour vous former rapidement ou tout simplement avoir une référence, vous n'aurez malheureusement pas d'autre choix de vous orienter vers des publications en langue anglaise.

Retrouvez la critique complete ici

Sommaire

  1. Présentation du projet Jakarta Struts et de ses composants annexes
    1. Le projet Jakarta Struts
    2. Les applications Web
    3. Le conteneur de servlets/JSP Tomcat
  2. Présentation des servlets et des JavaServer Pages
    1. L'architecture servlet Java
    2. Que sont les JavaServer Pages ?
  3. Présentation de Struts
    1. Télécharger et installer Struts
    2. Créer une première application Struts
  4. Le contrôleur
    1. La classe ActionServlet
    2. La classe Action
    3. Les plug-ins Struts
    4. La classe RequestProcessor
  5. Les vues
  6. L'internationalisation des applications Struts
    1. Les composants i18n d'une application Struts
    2. Internationalisation de l'application eyrollesapp
  7. Le traitement des erreurs
    1. Les composants de traitement d'erreurs Struts
    2. Ajouter le traitement d'erreurs à l'application eyrollesstruts
  8. Création d'ActionMapping personnalisés
    1. Qu'est ce qu'un ActionMapping ?
    2. Création d'un ActionMapping personnalisé
  9. Le pool de connexions JDBC
    1. Qu'est ce qu'une DataSource ?
    2. Utilisation d'une DataSource dans une application Struts
  10. Débogage des applications Struts
    1. Intégrer Tomcat dans une application Java
    2. Débogage d'une application Struts
  11. Développement d'une application Struts
    1. Description de l'application Employes
  12. Le fichier struts-config.xml
    1. Les sous-éléments Struts
    2. Ajouter une DataSource Struts
    3. Ajouter des définitions de FormBean
    4. Ajouter des redirections globales
    5. Ajouter des actions
    6. Ajouter un RequestProcessor
    7. Ajouter des ressources de messages
    8. Ajouter un Plug-in
  13. La bibliothèque de balises Bean
  14. La bibliothèque de balises HTML
  15. La bibliothèque de balises Logic
  16. La bibliothèque de balises Template

331 pages, 1ère édition, janvier 2003 Editions Eyrolles, ISBN: 2212112319
Commandez sur www.amazon.fr :
37,05 EUR TTC (prix éditeur 39 EUR TTC) - Livraison Gratuite !
couverture du livre 'Swing : la synthèse'

note du livre : 3.0

Swing : la synthèse

de Valérie Berthié, Jean-Baptiste Briaud
Introduction : Développement des interfaces graphiques en Java

Résumé de l'éditeur

Swing regroupe les outils Java qui permettent de créer et de gérer une interface graphique avec l'utilisateur.

Le but de cet ouvrage n'est pas de présenter la liste exhaustive des composants Swing, mais d'expliquer les principes de cette bibliothèque de classes et d'offrir une vue d'ensemble de leur architecture.

Les auteurs expliquent les stratégies les plus efficaces pour construire des interfaces graphiques qui répondent aux critères ergonomiques actuels, et qui soient constituées de composants réutilisables, performants et évolutifs.

Les enjeux de cette programmation sont présentés et illustrés à travers des exemples parlants. Au fil des chapitres les aspects majeurs de Swing (layouts, composants, événements) sont expliqués en suivant la même approche : partir d'un exemple, faire comprendre le besoin et la solution, récapituler.

Critique du livre par la rédaction (Hugo Etiévant)
Cet ouvrage présente la bibliothèque Swing en démarrant par des exemples simples.

Les auteurs expliquent avec pertinence les atouts de Swing sur AWT ainsi que les design pattern permettant de développer au mieux des applications graphiques modulaires, maintenables et performantes.

Le lecteur est entraîné immédiatement dans le coeur du sujet avec des exemples concrets immédiatement testables. Les principaux composants graphiques sont expliqués avec le détail nécessaire à une implémentation de base immédiate.

Il aurait été utile de trouver dans ce livre la liste exhaustive des composants sous forme de petites fiches, mais les auteurs ont préféré se concentrer sur l'essentiel. On regrettera également l'absence de CD-ROM contenant les sources du livre.

C'est un ouvrage à conseiller aux développeurs Java désirant s'initier à Swing et apprendre une méthodologie gagnante.

Sommaire

  • Concepts fondamentaux
  • Les layouts
  • Les évènements
  • Les composants plus complexes
  • Les composants textes
  • Le drag and drop
  • Les nouveautés du JDK 1.4

327 pages, juin 2003 Editions Dunod, ISBN: 2100081799
Commandez sur www.amazon.fr :
37.91 EUR TTC seulement (au lieu de 39.90 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Jakarta Struts - précis & concis (O'Reilly)'

note du livre : 4.5

Jakarta Struts - précis & concis (O'Reilly)

de Chuck Cavaness, Brian Keeton
Traducteur(s) : Alexandre Gachet

Résumé de l'éditeur

L'architecture MVC (Modèle - Vue - Contrôleur) a révolutionné le développement d'applications web. Elle permet en effet de modulariser ce développement et d'intégrer des technologies aussi diverses et variées que JSP (JavaServer Pages), Java Servlets, XML, XSLT, EJB, etc. Néanmoins, le coût associé à ce type de réalisation reste généralement élevé. Jakarta Struts constitue la solution idéale pour établir à un coût raisonnable un cadre de développement MVC robuste, évolutif et performant. Il autorise en outre la gestion des erreurs, la validation des saisies et l'internationalisation. Ce petit ouvrage expose les étapes clés de l'installation et de la configuration du cadre de développement Jakarta Struts, et couvre en détail les actions intégrées et les bibliothèques de balises.

Critique du livre par la rédaction (RanDomX Didier)
Critique du livre par RanDomX :

Au premier abord déroutant de part sa traduction littérale n'autorisant aucun anglicisme, cet ouvrage s'avère être un précieux compagnon, voire un compagnon indispensable pour le développeur d'application basées sur le framework Struts.

Après avoir décrit toutes les options des différents fichiers de configuration (web.xml, struts-config.xml,..), l'ouvrage s'attache à rappeler l'utilisation des différents éléments (ActionForm, Action,.. ) du framework et leurs cycles de vie, il passe en revue, sans aucune exception, toutes les librairies de balises. Ce dernier chapitre est sans conteste le plus intéressant pour le développeur aguerri aux applications web et à la couche de présentation JSP. En effet, il décrit de manière très précise tous les tags, mais aussi chacun de leurs attribut, en en décrivant l'utilité et les effets.

Bref, l'ouvrage porte bien son nom car il est à la fois précis et concis. Ce livre est à recommander, quel que soit le niveau du développeur Struts, en tant qu'aide mémoire. Grâce à lui, nous ne nous retrouvons plus dépourvu face à un attribut dont nous ne connaissons pas l'utilité.

Critique du livre par Didier :

La 1ère partie est interessante pour un débutant struts mais trop courte. Le modèle MVC utilisé par Stuts fait l'objet d'une présentation succinte qui je pense, ne suffira pas lorsque l'on découvre pour la 1ère fois ce framework. Les notions d'action sont abordées très rapidement mais reste très accessible. Malgrès tout on entre peu dans le détail. L'explication des fichiers de configuration aurait méritée de plus amples exemples (rien ne vaut un cas concret).

La 2ème partie ressemble plus à un pense bête. Bien détaillé au niveau des paramètres, on accède rapidement aux balises dont on a besoin et à leurs diverses utilisations.

Conclusion :

Ce livre ne me semble pas adapté à un débutant. Sans exemple concret on se retrouve vite noyé sous un flot de fichiers XML en tout genre. Par contre, il rempli à merveille son rôle de pense bête pour les développeurs ayant déjà une vision globale de struts. Le temps perdu dans les inévitables recherches de balise ou de paramètres n'est plus une fatalité.

Sommaire

  1. CONFIGURATION DE STRUTS
    • Fichier de configuration web-xml
    • Les fichiers de configuration de Struts
  2. UTILISATION DES OBJETS ACTIONFORM DE STRUTS
    • Portée des objets ActionForm
    • Le cycle de vie d'un objet ActionForm
    • Création d'un objet ActionForm
    • Déclaration des objets ActionForm dans le fichier de configuration de Struts
    • Utilisation d'un objet ActionForm
    • La classe DynaActionForm
    • Configuration d'objets dynamiques ActionForm
    • DynaActionForm et validation
  3. CLASSES ACTION PREDEFINIES
    • DispatchAction
    • ForwardAction
    • InckudeAction
    • LookupDispatchAction
    • SwitchAction
  4. GUIDE DE REFERENCE DES BALISES
    • Conventions
    • Attributs communs
    • Utilisation des composants JavaBeans avec les balises Struts
    • Balises Bean
    • Balises HTML
    • Balises Logic
    • Balises emboîtées
    • Balises Tiles
  5. DOCUMENTATION
    • chapitress de diffusion de Struts
    • Site consacré à Struts
    • Outils Struts

166 pages, avril 2004 Editions O'Reilly, ISBN: 2-84177-256-X
Commandez sur www.amazon.fr :
8.55 EUR TTC seulement (au lieu de 9.00 EUR TTC : prix éditeur) - Livraison Gratuite ! (voir conditions)
couverture du livre 'Java, conception et déploiement J2EE'

note du livre : 4.0

Java, conception et déploiement J2EE

de Jérôme Molière

Résumé de l'éditeur

Au fil de la création d'un gestionnaire de bookmarks, ce cahier montre comment concevoir et déployer une application J2EE en s'appuyant sur -l'indispensable panoplie des outils Open Source de gestion de versions, de génération d'EJB, d'audit de code : Ant Eclipse, Tomcat, JBoss, Castor, JUnit, XDoclet, Checkstyle, Java Web Start... Riche en retours d'expériences et en design patterns, cet ouvrage fera gagner un temps précieux à ceux qui abordent J2EE ou qui souhaitent en avoir enfin une vue d'ensemble, qu'ils soient développeurs, chefs de projet, responsables qualité, ou encore administrateurs de serveurs Tomcat et JBoss.

Critique du livre par Petrus
Rédigé par un professionnel du développement d'applications J2EE ( certification Sun et JBoss ), cet ouvrage séduira par un style trés facile à lire, et une méthode d'apprentissage assez pragmatique, quoique nécessitant beaucoup de curiosité et d'autodidactie.

L'auteur présente la conception d'une application J2EE simple (au travers le projet "BlueWeb"), ainsi que son déploiement, en présentant tous les artefacts, API et outils utilisables de nos jours. Une petite revue technologique (logiciels libres / GNU essentiellement) forte interessante en soit pour les débutants. Les technologies comme Ant, JUnit, SWT, Regex et autre Log4j sont ainsi étalées et démystifiées de façon assez habile. De nombreuses analogies et exemples satisferont pleinement le lecteur qui ne se sentira par "décroché", et pourra acquérir assez rapidement de bonnes notions sur le monde J2EE et les méthodes de développement préconisées. On notera également que l'auteur s'est attaché à présenter des outils issus du monde libre dans la plupart des cas, plus accessibles pour les apprentis architectes J2EE...

Sont particulièrement appréciables :

  • l'organisation du livre, les larges marges définissant clairement les nouveaux termes abordés, des anecdotes et retours d'expérience
  • le style d'écriture en général
  • la revue panoramique assez complète initiée par l'auteur, la présentation technologique générale
Vous aborderez donc dans cet ouvrage: une étude de cas J2EE, les EJB, Ant, JBoss, les architectures J2EE ( MVC ) et autres patterns, HTTP, JWS, Checkstyle, XDoclet...

Sommaire

  • Introduction au projet BlueWeb
  • Une architecture à 5 couches pour BlueWeb
  • Environnement de développement CVS et ANT
  • Interfaces graphiques pour la couche cliente
  • Couche de présentation des données - servlets HTTP
  • Couche métier avec les EJB
  • Déploiement de l'application et gestion des versions avec ANT et Java Web Start
  • Audit du code et qualité logicielle
  • Implémentation de la logique métier BlueWeb avec XDoclet

179 pages, octobre 2003 Editions Eyrolles, ISBN: 2212111940
Commandez sur www.amazon.fr :
23.75 EUR TTC seulement (au lieu de 25.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Programmation Orienté Aspect pour Java / J2EE'

note du livre : 4.5

Programmation Orienté Aspect pour Java / J2EE

de R.Pawlak, J.Ph.Retaillé et L.Seinturier
Introduction : Un nouveau paradigme

Résumé de l'éditeur

La POA, un nouveau paradigme de programmation étendant l'existant

La programmation orientée aspect (POA) fait partie, comme la programmation orientée objet (POO), de la lignée des techniques de programmation qui ont permis de simplifier l'écriture des programmes informatiques, en les rendant plus modulaires et plus faciles à faire évoluer. Complémentaire et non concurrent de la POO, la POA peut être implémentée sous forme d'extension à n'importe quel langage existant.

Des concepts de la POA aux implémentations avec Java/J2EE

Écrit par trois experts français qui conjuguent une triple expérience du sujet - recherche théorique, conception d'outils logiciels et mise en oeuvre en entreprise -, cet ouvrage est structuré en quatre parties. La première partie présente les principes de la POA et introduit les concepts d'aspect, de coupe, de point de jonction, etc. La deuxième partie décrit les principaux outils de POA du monde Java : AspectJ, JAC (Java Aspect Components), JBoss AOP et AspectWerkz. La troisième partie présente plusieurs exemples d'applications types dans lesquelles s'exprime tout le potentiel de la POA. L'ouvrage s'achève sur une étude de cas détaillée montrant comment implémenter la POA dans une application J2EE existante, aussi bien au niveau de la couche métier que de la couche présentation.

Critique du livre par la rédaction (Lionel Roux (RanDomX))
Dans un style simple et clair, cet ouvrage s'applique à expliquer de manière très didactique les concepts avancés de la POA, avant de passer en revue les principaux outils permettant d'utiliser ce paradigme avec Java. Par ailleurs, il est très pédagogique et au fil des chapitres, l'on se rend compte qu'il distille habilement les bonnes pratiques nécessaires à une bonne appréhension de la POA.

Un soin particulier est apporté à la description des design patterns réécrits en utilisant ce nouveau paradigme, ainsi qu'à l'installation des outils utilisés dans l'ouvrage.

Enfin, l'étude de cas complète permet de fixer les idées afin de maîtriser le concept.

Ce (gros) livre de 446 pages s'avère très complet et permettra au novice de la POA comme à l'expert de trouver ce qu'il cherche. Attention toutefois, une maîtrise parfaite du paradigme objet est nécessaire pour le comprendre aisément.

En conclusion, un ouvrage à recommander aux programmeurs Java / J2EE professionnels désireux d'évoluer.

Sommaire

  1. Les concepts de la POA
  2. Principaux outils de POA du monde Java
  3. Applications de la POA
  4. Étude de cas détaillée

446 pages, avril 2004 Editions Eyrolles, ISBN: 2-212-11408-7
Commandez sur www.amazon.fr :
42.75 EUR TTC seulement (au lieu de 45.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Cahiers du Programmeur Java 1'

note du livre : 4.0

Cahiers du Programmeur Java 1

Premières applications professionnelles en Java

de Emmanuel Puybaret
Public visé : débutant
Introduction : Pour bien débuter en Java

Résumé de l'éditeur

Ce cahier montre à tous les programmeurs combien Java peut être aisé à manier, aussi bien pour créer des applications Web que pour garantir un niveau professionnel de fiabilité et d'évolutivité.

Au fil d'une démarche fluide présentant plus de 50 mini-cas et la réalisation d'un forum de discussion, ce cahier offre le savoir-faire indispensable à tout bon développement Java : après avoir installé le SDK, on apprendra à tirer parti de l'orientation objet pour un code de qualité, à accéder à une base via JDBC, à concevoir des interfaces graphiques et des formulaires Web, avec des pages JSP, des JavaBeans, des servlets et applets...

Critique du livre par la rédaction (Stessy Vedaer)
Stessy :

Même avec mes connaissances du langage, j'ai apprécié la lecture de cet ouvrage. Celui-ci explique très bien, sans nous faire tomber dans l'ennui, les concepts indispensables pour la conception d'applications solides et évolutives.

J'ai également apprécié la mise en page qui est particulièrement soignée et originale.

L'auteur passe même en revue les principales erreurs de compilations, ainsi que les principales exceptions, que les utilisateurs pourraient rencontrer lors de la compilations ou l'exécution de leurs applications.

Ce livre ne comporte que 250 pages mais c'est largement suffisant pour débuter vos applications grâce à la manière dont sont abordés les différents concepts. Bien évidemment, ce n'est pas la bible de java, mais ce n'est pas ce qui était demandé à l'auteur.

Vous n'aurez aucuné difficulté à approfondir vos connaissances par vous même après avoir lu ce livre. Il est clair, bourré d'exemples utiles et de cas d'école.

Bref, c'est un livre que je recommande chaudement pout toute personne souhaitant apprendre le langage java sans devenir ennuyeux par trop de théorie.

Vedaer :

Cet ouvrage, destiné aux débutants en programmation Java, a été une agréable surprise. Il permet de découvrir les principales caractéristiques de la progammation orientée objet et les particularités du langage Java.

L'auteur passe en revue les bases du langage et nous guide de manière efficace vers la programmation d'applications professionnelles : JDBC, servlets, JSP, etc. Une mise en page claire et agréable permet la mise en valeur de différentes astuces et conseils essentiels. On peut ainsi découvrir au fil des chapitres les conventions de nommage, une description de ANT ou encore des rappels sur le langage HTML.

Le principal atout de ce livre est son côté pratique. Il propose en effet plus d'une douzaine d'applications complètes et indépendantes. La plus remarquable d'entre elles est un forum de discussion écrit complétement en Java. Ce dernier est construit tout au long du livre et finis par l'intégration d'une Applet de Chat. L'auteur fais aussi le tour des principales erreurs, que l'on est susceptible de rencontrer, ou de l'installation des outils nécessaires (JDK, MySQL, Tomcat, etc.).

En bref, un livre pratique et efficace, que je conseille à tout débutant désirant découvrir Java et voulant s'orienter vers le développement d'applications Web.

Sommaire

  1. Présentation des études de cas
  2. Principes de base et installation de l'environnement
  3. Création de classes
  4. Opérateurs et instructions de contrôle
  5. Réutilisation des classes
  6. Classes de base
  7. Abstraction et interface
  8. Gestion des erreurs avec les exceptions
  9. Interfaces utilisateur avec Swing
  10. Connexion à une base de données avec JDBC
  11. Serveurs Web avec servlets/JSP/JavaBeans
  12. Interface utilisateur du forum
  13. Programmation multithread

272 pages, Mai 2003 Editions Eyrolles, ISBN: 2-212-11272-6
Commandez sur www.amazon.fr :
21.85 EUR TTC seulement (au lieu de 23.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Java & XSLT'

note du livre : 4.5

Java & XSLT

de Eric M.Burke
Introduction : La puissance de XSLT avec Java

Résumé de l'éditeur

Java vous offre du code portable et XML des données indépendantes de la plate-forme. XSL Transformations (XSLT) permet de transformer les documents XML dans des formats différents. Mais comment transformer ces données, comment les traduire dans un autre langage, comment utiliser XSLT dans un environnement Java ?

Cet ouvrage se concentre sur l'alliance de Java et de XSLT, explicitement conçu pour transformer des documents XML. À travers des cas concrets, le coeur de l'ouvrage aborde les aspects de transformations de documents dans des applications À stand-alone ou des servlets pour des cas aussi variés que les forums de discussion, ou la mise en forme de contenu pour des À appareils sans fil. De nombreux cas pratiques sont abordés dans cet ouvrage : feuilles de style, transformations de À documents, traitement de formulaires.

Citons quelques-uns des thèmes abordés :

- Introduction à XSLT

- Technologies web basées sur Java (détail de l'architecture modèle-vue-contrôleur, utiliser les EJB)

- Traitements XSLT avec Java (XML et SAX, les techniques de cache, interopérer avec DOM et JDOM)

- Feuilles de style et compilation

- XSLT et les Servlets

- Construction d'applications web avec XSLT (modèles XSLT, cookies)

- Internationalisation

- XSLT et les technologies sans fil (WML)

- Optimisation des performances, test

- Référence de l'API JAXP et du langage XSLT.

Java et XSLT aidera le programmeur Java à tirer parti de la puissance de XSLT pour des servlets ou des applications autonomes. Il permettra au développeur de réaliser des applications web complètes. La principale étude de cas est consacrée à une application de forum de discussion, à laquelle deux chapitres sont dévolus.

Critique du livre par la rédaction (LFE)
O'Reilly nous offre ici un livre d'un peu plus de 500 pages, destiné à nous apprendre à utiliser XSLT avec Java.

On pourrait se poser la question suivante : que peut-on raconter sur Java et XSLT en 500 pages ? Et bien, beaucoup de choses très intéréssantes dans ce cas.

Les exemples sont simples, pratiques, sans fioritures inutiles mais permettent de comprendre rapidement les notions exposées. Les textes sont clairs et agréables à lire.

Ce livre n'est pas uniquement centré sur son sujet annoncé mais s'étend un peu sur des sujets annexes, tels que les servlets, la sécurité de ces mêmes servlets par rapport aux threads, aussi bien que par rapport aux utilisateurs. Les notions de bases de XML et des parseurs sont rappelées rapidement mais pas baclées. La génération du XML, par exemple à partir de bases de données est aussi évoquée. Ainsi que bien d'autres sujets périphériques.

En conclusion, un livre complet, assez dense mais très clair et tout à fait abordable, même par des débutants un peu curieux (tels que moi) qui couvre bien son sujet et ses interconnections avec d'autres technologies.

498 pages, mars 2002 Editions O'Reilly, ISBN: 2-84177-205-5
Commandez sur www.amazon.fr :
40.85 EUR TTC seulement (au lieu de 43.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Java & XML 2nd Edition'

note du livre : 4.5

Java & XML 2nd Edition

de Brett McLaughlin
Introduction : Utilisation de XML avec Java

Résumé de l'éditeur

Ce livre s'adresse aux personnes voulant intégrer les technologies liées à XML dans leurs projets Java actuels ou futurs. Grâce notamment à de nombreux exemples concrets, l'auteur parvient à nous faire toucher du doigt la diversité et l'ampleur du phénomène XML. Le langage Java, déjà très sollicité dans tout ce qui touche à la programmation Web, se voit associer un outil de toute première force.

Le livre est composé de 3 grandes parties :

- Tout d'abord un survol rapide de XML.

- Ensuite une large partie consacrée aux parseurs XML : SAX, DOM, JDOM

- Enfin le gros du livre s'attaque aux technologies liant XML avec Java

- WebService

- XML-RPC

- SOAP

A qui s'adresse ce livre ?

Une connaissance minimale des deux technologies est requise pour aborder ce livre. En effet, les bases ne seront que survolées pour XML et totalement absentes pour Java. Il faut donc au minimum connaître les fondements du XML (balisages) et avoir une pratique préalable du langage Java. En outre, une connaissance des technologies liées à J2EE vous permettra de profiter pleinement des derniers chapitres du livre.

Critique du livre par Didier
L'introduction à XML est un peu courte mais suffisante pour entrer rapidement dans le sujet. Si vous êtes déjà un habitué de ce langage passez votre chemin et rendez-vous directement à la 2ème partie. Pour les autres, cette introduction vous donnera les premières notions indispensables à la compréhension des autres chapitres. Mais comme vous le conseille l'auteur, il est préférable d'approfondir l'étude par la lecture de livres spécialisés.

Les chapitres sur les parseurs XML permettent à ceux qui veulent commencer à intégrer le XML dans leurs applications JAVA d'avoir une première approche de ces techniques (lecture, écriture). Ces chapitres peuvent paraître fastidieux à lire mais ils sont indispensables à la bonne compréhension de l'association Java/XML.

Les derniers chapitres sont les plus intéressants. Les technologies présentées sont variées et très prometteuses. L'auteur nous propose de plonger dans les arcanes du développement distribué, et n'hésite pas à illustrer chacun des concepts par des exemples détaillés. Le propos reste toujours très accessible malgré parfois un foisonnement de détails techniques.

En conlusion, un très bon livre, agréable et pertinent sur les technologies émergentes. A réserver aux professionnels et amateurs éclairés.

528 pages, septembre 2001 Editions O'Reilly, ISBN: 0-596-00197-5
Commandez sur www.amazon.fr :
47.50 EUR TTC seulement (au lieu de 50.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Enterprise JavaBeans'

note du livre : 5.0

Enterprise JavaBeans

de Richard Monson-Haefel
Introduction : Pour comprendre les EJB

Résumé de l'éditeur

Les EJB (Enterprise JavaBeans) simplifient beaucoup l'informatique distribuée. Ils proposent un modèle de composants distribués portables facilitant le développement de solutions métier, et ce notamment en gérant les aspects les plus complexes de l'informatique d'entreprise que sont la gestion des transactions, la sécurité, la persistance et la concurrence.

Écrit par l'un des meilleurs spécialistes du domaine, le présent ouvrage explique les fondements de l'architecture des EJB 1.1 et 2.0 en couvrant les dernières avancées de cette technologie. L'auteur s'appuie sur un exemple concret d'application qu'il étoffe au fur et à mesure de ses explications.

Au travers de cet ouvrage les sujets suivants sont tous couverts en détail :

- Les Enterprise JavaBeans 1.1 et 2.0

- Le développement de beans entité (dont le modèle CMP et EJB QL) et de beans session

- Les relations complexes entre les beans

- Les beans orientés message et Java Message Service

- Les descripteurs de déploiement XML

- La gestion des transactions et la sécurité

- Les stratégies de développement

Les relations entre les EJB et J2EE (Java 2, Enterprise Edition) Si vous avez récemment développé du logiciel métier, vous savez à quel point EJB a bouleversé le domaine. Ce livre vous montrera comment utiliser au mieux les derniers développements de ces techniques. Si le développement des solutions métier est nouveau pour vous, cet ouvrage vous permettra d'être performant rapidement.

Critique du livre par cyberzoide
Les EJB permettent de monter très facilement des applications distribuées performantes, sûres, assurant une bonne montée en charge et tolérantes aux pannes. C'est un environnement à base de composants robustes permettant aux développeurs de se concentrer sur l'aspect métier ; les EJB prenant automatiquement en charge la distribution, les transactions, la persistance, la sécurité et la concurrence.

L'auteur commence par présenter le contexte historique, économique et technologique des Entreprise JavaBeans, ce qui a le mérite de plonger le lecteur au coeur du sujet sur un plan industriel et de saisir l'importance des challenges qui ont conduit à la création de cet environnement. Les concepts nombreux qui gravitent autour des EJB (objets distants, compostants serveurs, CTM...) sont très bien expliqués sans pour autant sombrer dans des détails trop complexes.

Le sujet étant assez complexe et dense, l'auteur a le mérite d'avancer pas à pas avec beaucoup de pédagogie. Les avantages mais aussi les limites de cette technologie sont très bien expliqués. De nombreux exemples viennent étayer les propos de l'auteur qui procède par étapes successives. De plus, une étude de cas permet de suivre pas à pas les étapes de la création d'une application de commerce électronique de croisières (typiquement l'application de base pour les EJB).

Cet ouvrage n'est pas à la portée des débutants, une bonne connaissance de Java est indispensable. Et des connaissances générales en applications distribuées et en bases de données sont nécessaires. Il s'adresse aux développeurs qui souhaitent découvrir les EJB pour monter des applications distribuées solides et performantes dans un contexte de production.

Je recommande cet ouvrage que je considère comme un ouvrage de référence pour qui veut se former aux EJB.

610 pages, septembre 2002 Editions O'Reilly, ISBN: 2-841-77218-7
Commandez sur www.amazon.fr :
45.60 EUR TTC seulement (au lieu de 48.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Le Livre de Java premier langage Fr'

note du livre : 4.5

Le Livre de Java premier langage Fr

de Anne Tasso
Introduction : Un des meilleurs livres pour débuter en programmation avec Java

Résumé de l'éditeur

Anne Tasso Maître de conférences à l'université de Marne-la-Vallée, Anne Tasso enseigne le langage de programmation Java, en formation initiale et continue, au sein du département SRC (Services et réseaux de communication) de l'IUT de Marne-la-Vallée. Vous avez décidé de vous initier à la programmation et souhaitez opter pour un langage largement utilisé dans le monde professionnel ? Java se révèle un choix idéal comme vous le découvrirez dans ce livre conçu pour les vrais débutants en programmation. Vous apprendrez d'abord, à travers des exemples simples en Java, à canaliser les notions communes à tous les langages: variables, types de données, boucles et instructions conditionnelles, etc. Vous franchirez un nouveau pas en découvrant par la pratique les concepts de la programmation orientée objet (classes, objets, héritage), puis le monde des interfaces graphiques avec les librairies AWT et Swing (fenêtres, gestion de la souris). Vous découvrirez enfin les applications de lava pour Internet : côté client (applets) et côté serveur (JSP, Javabeans). Chaque chapitre est accompagné de deux types de travaux pratiques : des exercices, dont le corrigé est fourni sur le CD-Rom d'accompagnement, et un projet développé au fil de l'ouvrage, qui vous montrera comment combiner toutes les techniques de programmation étudiées pour construire une véritable application Java. À qui s'adresse ce livre ? Aux étudiants de 1er cycle universitaire (IUT, Deug...) ou d'écoles d'ingénieurs. Aux vrais débutants en programmation : passionnés d'informatique et programmeurs autodidactes, concepteurs de sites Web souhaitant aller au-delà de HTML et JavaScript, etc. Aux enseignants et formateurs à la recherche d'une méthode pédagogique et d'un support de cours structuré pour enseigner Java à des débutants.

Sur le CD-Rom offert avec ce livre : Java 2 SDK 1.4 de Sun, pour Windows 95, 98, 2000, NT et XP : un environnement de programmation complet pour réaliser et exécuter vos programmes Java sous Windows (enanglais) Tomcat 4.0.3 du projet Apache : pour tester vos servlets Java et vos pages JSP (en anglais) Un guide d'installation et d'utilisation du SDK 1.4 et de Tomcat (en français) Le corrigé communté du projet et de tous les exercices du livre Le code source du projet et de tous les exemples et exercices du livre. Plate-forme requise: PC avec processeur Pentium 166 MHz ou plus Windom 95, 98 2000 et supérieur Au moins 48 Mo de RAM pour l'exécution d'applications ou d'applets Java 250 Mo d'espace disque pour l'installation du SDK 1.4 et de sa documentation.

Critique du livre par dav
Que l'on soit développeur avide de découvrir un nouveau language ou novice à la recherche d'une première expèrience dans le domaine de la programmation, ce livre est parfait. Il est écrit dans un language simple, compréhensible par tous (chose de plus en plus rare dans le domaine des nouvelles techno), le livre explique la plus part des notions informatiques par des exemples de la vie courante (notion de boucle, architecture client/serveur ...)En outre le livre propose au fur et mesure de sa lecture le développement d'une application bancaire. Ce livre est donc un vrai support de cours qui peut être lu de façon linéaire. Il y a le cours, puis des exercices corrigés, puis la mise en pratique par l'évolution de l'application bancaire. Seul bémol, la fin du livre est un peu légère, les chapitres traitant des outils graphiques sont un peu trop pauvres en explications et exemples, dés lors la mise en oeuvre des dernières notions devient plus problématique. Enfin il est à noter que les explications d'installation des utilitaires contenus dans le CD ne sont pas à jour (elles concerne les versions antèrieures), dès lors les noms à utiliser doivent être corrigés, de plus il n'y a presque pas d'explications, le novice devra y aller à taton ! Mais c'est ça aussi l'informatique !

Sommaire

  • Qu'est-ce qu'un programme? construire un algorithme Premier exemple de programme en Java, Exécution du programme, Présentation du projet détaillé dans l'ouvrage (application de gestion de compte bancaire). Techniques de base de la programmation. Stocker une information, Types de données, Variables et opérateur d'affection, Expressions et créateurs arithmétiques, La bibliothèque System et les entrées seules, Affichage et saisie des données Instructions if-else et switch Boucles do ... while, while et for. Initiation à lu programmation orientée objet. De l'algorithme paramétré à l'écriture de fonctions Foncions Java prédéfinies, Construire ses propres fonstions variables locales et variables de classe, Passage de paramètres par valeur, Classes et objets Exemple: la classe String et ses méthodes. Construire et utiliser ses propres classes, Les données de type static, Passage de paramètres par référence, La notion d'encapsulation des données, Constructeurs d'objet, Héritage et polymorphisme. Programmation objet avancée et interfaces graphiques. Tableaux à une et deux dimensions, Programmation dynamique : vecteurs et dictionnaires, L'archivage des données : fichiers texte et fichiers d'objets, Gestion des exceptions, Programmation d'interfaces graphiques: la librairie AWT et la librairie Swing, Construire une fenêtre, Dessiner dans une fenêtre, Gérer les événements liés au clavier et à la souris, Créer une applet Java, Créer une servlet, De l'utilité du langage JSP Les JavaBeans. Annexe. Guide d'utilisation du CD-Rom

400 pages, mai 2002 Editions Eyrolles, ISBN: 2212111002
Commandez sur www.amazon.fr :
27.50 EUR TTC seulement (au lieu de 29.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Java en action'

note du livre : 5.0

Java en action

de Ian F. Darwin
Introduction : Un des meilleurs livres intermédiaire pour se perfectionner en Java

Résumé de l'éditeur

Java en action recueille plus d'une centaine de solutions aux problèmes le plus souvent rencontrés par les développeurs Java. À la fois source d'idées et moyen d'apprendre Java par l'exemple, cet ouvrage est construit sur le modèle « un problème, une solution ». Les recettes couvrent un éventail de tâches simples ou complexes et la majorité des chapitres donne le code source d'un utilitaire. Citons quelques-unes des recettes parmi les thèmes abordés : Compiler, exécuter et déboguer : automatiser la compilation avec Ant, ... Interaction avec l'environnement: utiliser le CLASSPATH, des extensions, ... Chaînes de caractères : utiliser StringTokeniser, concaténer des chaînes, formater du texte, tests interactifs avec les expressions régulières, ... Gestion des nombres : comparer, arrondir des nombres à virgule flottante, ... Dates et heures : convertir une chaîne en date, afficher une page de calendrier, ... Programmation des ports série et parallèle : choisir un port, conflits d'accès, ... Graphiques, sons et GUI: dessiner, utiliser l'API 2D et Swing, ... Internationalisation et localisation : ressources I18N, utiliser un locale spécifique, .. Clients réseau : contacter un serveur, erreurs réseau, programme de client Telnet, ... Sockets : gérer les clients multiples, un programme de serveur de discussion, ... Web, applets, servlets et JSP :écrire des applets, combiner JSP et servlets, cookies, ... Courrier électronique: envoyer un message MIME, ... Accès aux bases de données : JDBC, procédures stockées, ... Utilisation de XML : transformer du XML avec XSLT, générer du XML avec DOM, ... Java distribué: serveur RMI, ... Paquetages et empaquetages : exécuter une applet avec JDK, les fichiers JAR, ... Multithread en Java : animer une image, arrêter un thread, ... Introspection : obtenir un descripteur de classe, un programme AppletViewer, ... Java et les autres langages: exécuter un programme, Java et du code en C/C++, ... Java en action couvre la plupart des API ; les solutions présentées sont immédiatement applicables et ne demandent qu'une connaissance minimale de Java. Ian Darwin travaille dans l'industrie informatique depuis 30 ans. Il programme, écrit des articles et enseigne Unix, C et Java à Learning Tree International.

Critique du livre par la rédaction
Les exemples de ce livre sont véritablement très utiles. Ce livre non seulement apporte des réponses à vos recherches, mais il vous permet surtout de découvrir la meilleure façon de faire telle ou telle tache. De plus, l'auteur présente chaque exemple de code avec une explication complète très utile. Son style d'écriture est humble, direct, et plein d'humour. C'est le seul livre de ma collection de livres sur Java que j'ai plaisir à lire, et c'est maintenant celui que je consulte le plus souvent.

836 pages, avril 2002 Editions O'Reilly, ISBN: 2841772039
Commandez sur www.amazon.fr :
55.10 EUR TTC seulement (au lieu de 58.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Java in a Nutshell'

note du livre : 4.0

Java in a Nutshell

de David Flanagan
Traducteur(s) : Alexandre Gachet
Introduction : Manuel de référence

Résumé de l'éditeur

Cet ouvrage fait référence dans la communauté internationale des développeurs Java. Véritable manuel d'enseignement du langage Java, il vous apportera le niveau nécessaire pour utiliser les API (Application Programming Interface). Non seulement la syntaxe est expliquée, mais l'utilisation des classes, leurs exploitations, et leur organisation au sein de l'API est explicité. De plus, le cours sur l'objet est d'une clarté rare.

Java In A Nutshell est accessible éventuellement aux débutants, mais s'adresse surtout aux développeurs confirmés.

La 4e édition de ce best-seller international constitue une référence incontournable pour tous les développeurs Java : si vous ne deviez lire qu'un livre sur Java, choisissez celui-là ! Cet ouvrage exceptionnel est avant tout un guide de référence, mais il servira également de tutoriel pour lés programmeurs avertis qui souhaitent découvrir Java rapidement. La partie « tutoriel » donne aux développeurs tous les éléments pour comprendre ce qui fait la spécificité d'un programme écrit en Java, depuis la syntaxe du langage et les caractéristiques orientées objet jusqu'aux beans Java, en passant par les différents mécanismes de sécurité. Un chapitre entier inventorie les nouveautés introduites dans la version 1.4 du langage et en particulier le traitement de données au format XML, la prise en charge des expressions régulières, ainsi que le renforcement de la gestion des entrées/sorties et de la sécurité. Les notions clés sont présentées sans fioriture, mais illustrées par des exemples concrets et réalistes. La partie « référence » passe en revue toutes les classes des paquetages fondamentaux de Java, pour les versions 1.0, 1.1, 1.2, 1.3 et 1.4 du SDK. Un index des classes, méthodes et champs permet de retrouver en un clin d'oeil le paquetage java auquel ils appartiennent. Ce livre a pour compagnons naturels java Enterprise in a Nutshell, spécifiquement consacré à J2EE, et Exemples en java in a Nutshell, qui offre des exemples plus développés et des exercices qui permettront au développeur d'acquérir rapidement les automatismes de la programmation java. Toujours du même auteur, java Foundation in a Nutshell décrit en détail l'API graphique de java.

Critique du livre par la rédaction (avtonio)
J'ai pas mal de livres sur java dont certains me semblent plutot moyens. Mais celui-là m'est indispensable pour la description approfondie du langage et les packages fondamentaux. Mon avis : je le trouve tres clair (c'est pas si souvent), la recherche d'informations est facile, plein d'exemples très instructifs, mais la description de certaines classes est parfois trop courte (cependant ce qu'il me manque dans le livre, je le trouve bien souvent sur le Web) en bref, je trouve chaque page tres intéressante, pas de blabla inutile. C'est mon livre de reference dans son domaine

1128 pages, 4ème édition, octobre 2002 Editions O'Reilly, ISBN: 2841772160
Commandez sur www.amazon.fr :
51.30 EUR TTC seulement (au lieu de 54.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Au Coeur de Java 2 JDK 5, Vol.1'

note du livre : 5.0

Au Coeur de Java 2 JDK 5, Vol.1

Notions Fondamentales

de Cay S. Hortsmann, Gary Cornell
Traducteur(s) : Christiane Silhol, Nathalie Le Guillou de Penanros
Public visé : Intermédiaire/Avancé
Introduction : Ouvrage de référence pour le J2SE

Résumé de l'éditeur

"Cet ouvrage aborde les bases du J2SE (Java 2 Platform, Standard Edition). Constituant un didacticiel fort pertinent et un outil de référence incontournable, cet ouvrage se base sur des cas concrets qui ont fait leurs preuves dans le monde réel. Les principales caractéristiques et fonctionnalités de la bibliothèque sont présentées dans des programmes qui, malgré leur simplicité, n'en demeurent pas moins parfaitement opérationnels. Enfin, tous les programmes ont été mis au goût du jour du J2SE 5.0 et constituent donc de très bons points de départ pour vos propres créations. Les exemples proposés ne sont jamais dérisoires, ce livre étant destiné aux programmeurs désireux d'écrire du code pour résoudre des problèmes concrets." (les auteurs)

Critique du livre par la rédaction (Nourdine Falola)
Un excellent ouvrage sur le langage Java. Il traite des bases du J2SE et s'adresse au développeur, confirmé dans un autre langage, souhaitant se mettre à Java, comme au développeur Java (intermédiaire ou confirmé) désirant posséder un ouvrage de référence et découvrir les nouveautés du JDK 5.0.

Une mise en page claire et soignée, ainsi qu'une bonne démarche pédagogique appuyée par des exemples simples et pertinents, permettent un apprentissage rapide et efficace du langage.

Des encarts (info, info C++, astuce, attention) informent le lecteur sur des points qu'il est bon de souligner, comme les équivalences/différences avec le C++ ou les pièges à éviter.

Pour chaque nouvel appel à l'API, une brève description de celui-ci est donnée à la fin de la section concernée. Et pour chaque nouveauté du JDK 5.0, son équivalent dans le précédent JDK est proposé, s'il existe. Une annexe regroupe d'ailleurs ces équivalences.

Aucun CD-ROM n'accompagne cette 7ème édition, mais les sources des exemples données dans l'ouvrage sont disponibles au téléchargement sur le site de l'éditeur.

Après avoir acquis les bases du J2SE, nul doute que vous voudrez aborder les fonctionnalités avancées du langage avec "Au Coeur de Java 2, vol.2 - Fonctions Avancées".

Ayant personnellement débuté en Java avec cet ouvrage, et pour avoir été très satisfait de ma rapide progression dans l'utilisation de ce langage, je ne peux que vous le conseiller!

Sommaire

  1. Une introduction à Java
  2. L'environnement de programmation de Java
  3. Structures fondamentales de la programmation Java
  4. Objets et classes
  5. L'héritage
  6. Interfaces et classes internes
  7. Programmation graphique
  8. Gestion des événements
  9. Swing et les composants d'interface utilisateur
  10. Déployer des applets et des applications
  11. Exceptions et mise au point
  12. Les flux et les fichiers
  13. Programmation générique

Annexes

  1. Les mots clés de Java
  2. Adaptation en amont du code du JDK 5.0

855 pages, 7ème édition, Décembre 2004 Editions CampusPress, ISBN: 2-7440-1833-3 , format : 19x23x5 cm, poids : 1575 gr.
Commandez sur www.amazon.fr :
38.00 EUR TTC seulement (au lieu de 40.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Total Java '

note du livre : 3.0

Total Java

de Steven Holzner

Résumé de l'éditeur

Java autrement: Avec plus de 500 exemples, Total Java couvre tous les aspects de la programmation Java, des bases du langage à la programmation Internet avancée: composants Swing, JavaBeans, servlets Java, JDBC, sécurité, etc. Par la pratique, grâce aux Solutions express directement applicables, vous apprendrez à : Créer des étiquettes, des boutons, des listes déroulantes, des boîtes de dialogue, des tableaux Maîtriser la syntaxe Java 2.0 Implémenter les composants d'interface Swing Mettre en oeuvre le multithread Créer des composants JavaBeans Développer des servlets Java Créer des clients et des serveurs TCP Utiliser JDBC Créer des paquetages, des interfaces et des fichiers JAR

A qui s'adresse cet ouvrage : Aux développeurs Java intermédiaires et avancés Aux programmeurs chevronnés (autres langages) souhaitant développer en Java

Critique du livre par Johann Heymes
Extrait : "Il s'agit d'un livre qui mérite belle et bien qu'on y prête attention. Le contenu est riche, utile et efficace. Les quelques critiques énoncées sont certes regrettables mais n'empêchent pas la compréhension et surtout pas l'apprentissage du langage. Le nouveau développeur Java ainsi formé aura tout le temps de prendre connaissance de ces dernières dès ses premiers contacts extérieurs (collègue ou par exemple les fabuleux forums de developpez.net ;-) )"

Lire la critique en détail et en entier : http://johann-heymes.developpez.com/livres/totalJava/

Editions Eyrolles, ISBN: 2212092083
Commandez sur www.amazon.fr :
couverture du livre 'Java Efficace'

note du livre : 5.0

Java Efficace

Guide de Programmation

de Joshua Bloch
Traducteur(s) : Alexis Moussine-Pouchkine
Public visé : Avancé

Résumé de l'éditeur

Ce guide, écrit par un expert de Sun Microsystems, présente cinquante-sept règles de programmation concourant à l'écriture de programmes efficaces pour la plateforme Java. Fruit de l'expérience des créateurs de Java et des défis de programmation relevés au quotidien, chaque règle illustre divers aspects du langage et de ses difficultés au moyen de conseils, recommandations - ce qu'il faut faire ; ce qu'il ne faut pas faire - et d'exemples détaillés : son bon usage idiomatique, ses subtilités et ses pièges, ses patterns et antipatterns.

Excédant la seule programmation Java, ces règles serviront de viatique pour la programmation objet en général et la production de code clair, correct, efficace, robuste et réutilisable.

Les bibliothèques Java (java.lang, java.util et dans une moindre mesure java.io) sont également abordées, ainsi que la sérialisation.

"J'aurais voulu avoir ce livre il y a dix ans. Certains peuvent penser que je n'ai besoin d'aucun livre sur Java, mais celui-ci fait exception." James Gosling, ancien vice-président de Sun Microsystems, co-créateur du langage Java.

Critique du livre par la rédaction (Christophe Jollivet)
Programmez-vous correctement?

Ce livre s'adresse à ceux qui connaissent déjà Java, mais souhaitent produire un code solide. Si vous travaillez en équipe, il vous est sans doute arriver d'écrire des classes ou API qui sont ensuite utilisées par vos collègues. Malheureusement, l'usage que font vos collègues de votre travail entraine soit des erreurs de comportement soit des plantages dans votre code. Il peuvent même vous amener à devoir corriger une grande partie de l'application le jour où vous voulez faire évoluer votre API. Si cela vous est arrivé, ce livre est pour vous.

Il est constitué d'une série de 57 recommandations. Ces recommandations peuvent se lire dans n'importe quel ordre, et présentent souvent des références les unes vers les autres. Elle sont regroupées par thématiques comme le montre la table des matières ci dessous et sont accompagnées d'exemples de code. Vous y trouverez même quelques critiques sur les API du JDK. Certaines se lisent tres vite (une page et demi), d'autres font près d'une dizaine de pages et demandent des efforts de concentration. Le style rédactionnel est très agréable à lire, même si la densité d'informations est élevée.

Ces conseils fournis par l'auteur d'une partie de java.util vous permettront de comprendre toutes les règles nécessaires au développement d'une API solide. Qu'il s'agissent d'immuabilité, de prévoir ou empêcher l'héritage et la surcharge, gérer la visibilité des méthodes et attributs, utiliser correctement les Exceptions et les Thread, vous trouverez une mine d'informations et surtout de bons conseils dans ce livre.

Sommaire

Création et destruction d'objets

  • 1. Privilégier des méthodes de fabrique statiques aux constructeurs
  • 2. Appliquer la propriété du singleton avec un constructeur privé
  • 3. Empêcher l'instanciation avec un constructeur privé
  • 4. Empêcher la duplication d'objets
  • 5. Éliminer les références d'objets obsolètes
  • 6. Éviter les finaliseurs

Méthodes communes à tous les objets

  • 7. Obéir au contrat général lors d'une redéfinition de la méthode equals
  • 8. Toujours redéfinir hashCode lorsque equals est redéfini
  • 9. Toujours redéfinir toString
  • 10. Redéfinir judicieusement clone
  • 11. Envisager l'implémentation de Comparable

Classes et Interfaces

  • 12. Restreindre l'accès des classes et de leurs membres
  • 13. Favoriser l'immuabilité
  • 14. Préférer la composition à l'héritage
  • 15. Prévoir et documenter l'héritage ou bien l'interdire
  • 16. Préférer les interfaces aux classes abstraites
  • 17. N'utiliser les interfaces que pour définir les types
  • 18. Favoriser les classes imbriquées statiques

Équivalents pour constructions du langage C

  • 19. Remplacer les structures par des classes
  • 20. Remplacer une union par une hiérarchie de classes
  • 21. Remplacer les constructions enum par des classes
  • 22. Remplacer les pointeurs de fonctions par des classes et des interfaces

Méthodes

  • 23. Vérifier la validité d'un paramètre
  • 24. Procéder à des recopies défensives en cas de besoin
  • 25. Concevoir avec attention la signature d'une méthode
  • 26. Utiliser la surcharge avec discernement
  • 27. Renvoyer des tableaux vides plutôt que null
  • 28. Écrire des commentaires de documentation pour tous les éléments exposés d'une API

Programmation générale

  • 29. Minimiser la portée des variables locales
  • 30. Connaître et utiliser les bibliothèques
  • 31. Éviter float et double si un résultat exact est requis
  • 32. Éviter les chaînes de caractères là où d'autres types sont plus appropriés
  • 33. Attention à la performance dans la concaténation de chaînes de caractères
  • 34. Faire référence à un objet via son interface
  • 35. Préférer les interfaces à la réflexion
  • 36. Utiliser judicieusement les méthodes natives
  • 37. Optimiser judicieusement
  • 38. Suivre les conventions de nommage généralement acceptées

Exceptions

  • 39. N'utiliser une exception que dans des situations exceptionnelles
  • 40. Utiliser une exception vérifiée pour une situation récupérable et une exception non vérifiée pour une erreur de programmation
  • 41. Ne pas abuser des exceptions vérifiées
  • 42. Préférer l'utilisation d'une exception standard
  • 43. Lever des exceptions en rapport avec l'abstraction
  • 44. Documenter toutes les exceptions levées par une méthode
  • 45. Inclure l'information de contexte dans les messages détaillés
  • 46. Garantir l'atomicité d'une erreur
  • 47. Ne pas ignorer une exception

Threads

  • 48. Synchroniser l'accès à toute donnée partagée et muable
  • 49. Éviter toute synchronisation excessive
  • 50. Ne jamais invoquer wait en dehors d'une boucle
  • 51. Ne pas s'appuyer sur l'ordonnanceur de threads
  • 52. Documenter la sûreté des threads
  • 53. Éviter les groupes de threads

Sérialisation

  • 54. Implémenter judicieusement Serializable
  • 55. Envisager l'utilisation d'une sérialisation sur mesure
  • 56. Rédiger la méthode readObject de manière défensive
  • 57. Fournir une méthode readResolve lorsque cela est nécessaire

Annexes

  • Bibliographie
  • Index des idiomes et patterns
  • Index

272 pages, juin 2002 Editions Vuibert, ISBN: 2-7117-4805-7
Commandez sur www.amazon.fr :
30,40 EUR TTC (prix éditeur 32 EUR TTC) - Livraison Gratuite !

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -