Livres pour les expérimentés

30 livres et 52 critiques, dernière mise à jour le 8 février 2017 , note moyenne : 4.5

  1. GWT (Google Web Toolkit) - Développez des Applications Internet Riches (RIA) en Java
  2. Les Design Patterns en Java : Les 23 modèles de conception fondamentaux
  3. Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3) - Développez pour le web par l'exemple : 3 applications détaillées
  4. Programmation concurrente en Java
  5. JBoss AS 5 Development
  6. Apache Maven
  7. Java SOA Cookbook
  8. Java 6 : Entraînez-vous et maîtrisez Java par la pratique - Collections : Les TP Informatiques
  9. Les Cahiers du programmeur Java EE 5
  10. Filthy Rich Clients
  11. Java Persistence et Hibernate
  12. Programmer en Java
  13. Java Generics - and Collections
  14. Rich Client Programming - Plugging into the Netbeans Platform
  15. SCJP - Sun Certified Programmer for Java 5: (Exam 310-055)
  16. Eclipse et JBoss
  17. Programmation Orienté Aspect pour Java / J2EE
  18. Eclipse - Principes, patterns et plugins
  19. Les Cahiers du programmeur Swing
  20. Mieux programmer en Java - 68 astuces pour optimiser son code
  21. Les expressions régulières par l'exemple
  22. Spring par la pratique
  23. Aide-Mémoire de Java
  24. Refactoring des applications Java/J2EE
  25. Hibernate 3.0 - Gestion optimale de la persistance dans les applications Java/J2EE
  26. Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0
  27. Cahiers du programmeur - Java/XML
  28. Java & XSLT
  29. Au Coeur de Java 2 JDK 5, Vol.1 - Notions Fondamentales
  30. Java Efficace - Guide de Programmation
couverture du livre GWT (Google Web Toolkit)

Note 4 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

GWT (Google Web Toolkit)

Développez des Applications Internet Riches (RIA) en Java

de

Résumé de l'éditeur


Ce livre sur GWT (Google Web Toolkit) s'adresse aux développeurs Java souhaitant créer des applications RIA sans passer par JavaScript ou aux développeurs web confirmés (JavaScript/XHTML/CSS) désireux de disposer d'un framework décuplant leur productivité. Une connaissance de Java et de XHTML/CSS est un pré-requis pour tirer le meilleur parti de ce livre.

Dans le monde du développement des applications internet riches (RIA), Google propose aujourd'hui l'outil GWT (en version 2 au moment de la rédaction du livre) qui offre une passerelle entre les mondes Java et JavaScript en adoptant un fonctionnement surprenant : proposer de compiler du code Java vers une application JavaScript nativement interprétable par les navigateurs web.

Tout au long de ce livre, vous découvrirez comment développer une telle application : la bibliothèque graphique prédéfinie, la gestion des évènements, les communications client-serveur et les optimisations.

Vous serez amené à mettre en ouvre les bonnes pratiques d'architecture : design patterns, Modèle Vue Présentateur et injection de dépendance. Vous découvrirez également les techniques préconisées pour l'internationalisation et le développement de tests unitaires.

L'ensemble de cet ouvrage s'articule autour d'exemples de mise en ouvre entièrement disponibles en téléchargement sur www.editions-eni.fr, vous permettant de tester par vous-même les principes présentés.

Édition : ENI - 400 pages , 1re édition, 11 octobre 2010

ISBN10 : 2746058308 - ISBN13 : 9782746058309

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)
  • Avant-propos
  • Développer avec Google Web Toolkit
  • Créer une interface graphique
  • Gérer des événements
  • Communication client-serveur
  • XML, DOM et JSON
  • Concevoir l'architecture
  • Tests
  • Internationalisation
  • Techniques avancées
Critique du livre par la rédaction benwit le 1er décembre 2011
Ayant lu les deux précédents ouvrages français sur GWT, je n'avais pas d'attente particulière envers celui-ci. Si j'ai décidé de le lire, ce n'est pas pour apprendre sur le sujet mais pour voir comment l'auteur allait le traiter.

Tout d'abord, l'auteur a fait le choix de ne pas parler du positionnement de GWT, de son historique, des généralités. Cela pourra déranger un novice mais j'ai personnellement apprécié : les ouvrages précédents ayant brillamment traité cet aspect, il n'aurait pas été d'un grand intérêt de le refaire, surtout que cela permet d'alléger le livre et d'aborder des points autrement plus intéressants.

L'auteur commence donc son premier chapitre "Développer avec GWT" en allant à l'essentiel. Pas besoin d'installer GWT en ligne de commande, on l'installe vite fait bien fait dans Eclipse. Il faut dire que l'intégration à cet IDE a bien progressé au fil des versions et que la documentation en ligne existante est suffisante. L'espace libéré lui permet d'expliquer chaque partie de la structure d'un projet GWT, tant au niveau développement qu'au niveau déploiement une fois compilé.

Dans le deuxième chapitre "Créer une interface graphique", inutile de décrire chaque widget, les livres précédents et la documentation en ligne y pourvoient amplement. A la place, il préfère se concentrer sur les widgets de positionnement qui posent le plus de problèmes (comme on le voit sur le forum). De plus, il est question principalement des nouveaux widgets de positionnement, ceux de la version 2.0, les XXXLayouts qui sont à utiliser de préférence.

Ensuite, qu'il s'agisse des exemples à la fin du chapitre 2 (FormPanel, Widgets personnalisés) ou de ceux du chapitre 3 relatifs aux événements, ils sont toujours concrets et utiles. Jugez plutôt : composant d'upload de fichier ou composant qui permet d'opacifier une zone de l'écran.

Au chapitre 4 sur la communication client/serveur, il sera question du classique RPC, de son futur remplaçant deRPC mais aussi de l'accès bas niveau (RequestBuilder) nécessaire pour uploader un fichier ou récupérer des flux XML/JSON (traités côté client au chapitre 5).

Le sixième chapitre "Concevoir l'architecture" présente un exemple concret d'application du pattern MVP! Vous comprendrez les différences par rapport à MVC et les bénéfices d'un outil comme GIN.

Bien qu'introduisant les GWTTestCase ou les bancs d'essai GWT, le septième chapitre sur les tests aurait probablement mérité d'être plus développé.

En lisant le chapitre 8 sur l'internationalisation, on voit immédiatement que l'auteur y a été confronté et l'a mis en ouvre personnellement dans des exemples réels, de même qu'au dernier chapitre sur les techniques avancées (JSNI, CLient Bundle).

Je dois avouer que ce livre m'a plu davantage que ce que j'imaginais à priori; principalement pour le contenu inédit qu'il apporte. Je le conseille également aux développeurs qui cherchent un ouvrage pratique qui soit davantage un complément aux documentations officielles qu'un substitut.
Critique du livre par la rédaction Mickael_LT le 18 février 2011
Étant débutant sur cette plateforme GWT, j'ai commencé par de l'autoformation afin d'acquérir les bases, les principes et les notions-clés de cette technologie. Ensuite, j'ai voulu approfondir et surtout cadrer un peu tout ce que j'avais appris pour voir les bonnes pratiques, les bonnes façons de faire ainsi qu'avoir des critiques sur les méthodologies que j'utilisais.

C'est pourquoi j'ai décidé de me procurer ce livre qui avait l'air de survoler l'ensemble des notions à maitriser en GWT. En effet on y retrouve de nombreux points-clés tels que : le récapitulatif de la technologie, la gestion des interfaces graphiques, le modèle d'évènement utilisé par GWT ainsi que la communication client / serveur. Parmi les chapitres du livre, on retrouve des cas pratiques détaillés auxquels chaque développeur pourra être confronté : l'internationalisation de son application, le parsing des fichiers (XML, JSON), etc.

D'autres chapitres m'ont paru un peu plus obscurs (par exemple le chapitre sur les tests) mais c'est surtout parce que je n'ai pas encore eu le temps de les mettre en pratique. Mais, si je me réfère à la qualité des autres, je pense ne pas avoir de surprises le jour où je devrai m'y mettre.

Pour conclure, je dirai que ce livre est maintenant sur mon bureau et me sert de gros pense-bête. Je m'y réfère assez souvent pour voir si je suis toujours dans le vrai et valider mes choix techniques. C'est une ressource intéressante, complète, mais qui fait peut-être l'impasse sur des thématiques plus basiques (installation de l'environnement, utilisation du langage Java, etc.). Les exercices reflètent bien des cas concrets, qu'on retrouve habituellement dans nos métiers de développeur d'applications, mais il permet également d'avoir une bonne approche lors de la phase de conception et de qualification.


couverture du livre Les Design Patterns en Java : Les 23 modèles de conception fondamentaux

Note 3 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Les Design Patterns en Java : Les 23 modèles de conception fondamentaux

de
Public visé : Expert

Résumé de l'éditeur

Tout programmeur Java se doit de connaître les 23 design patterns fondamentaux recensés par les célèbres développeurs du Gang of Four, véritable condensé de l'expérience de plusieurs générations de développeurs, et aujourd'hui incontournable pour écrire un code propre et efficace.
Cet ouvrage, fondé sur de nombreux exemples d'application, vous aidera à comprendre ces modèles et développera votre aptitude à les appliquer dans vos programmes.
Forts de leur expérience en tant qu'instructeurs et programmeurs Java, Steve Metsker et William Wake vous éclaireront sur chaque pattern, au moyen de programmes Java réels, de diagrammes UML, de conseils sur les bonnes pratiques et d'exercices clairs et pertinents. Vous passerez rapidement de la théorie à l'application en apprenant comment écrire un meilleur code ou restructurer du code existant pour le rationaliser, le rendre plus performant et plus facile à maintenir.

Édition : Campus Press - 520 pages , 2eédition, 3 décembre 2009

ISBN10 : 2744023965 - ISBN13 : 9782744023965

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • Introduction
  • Introduction aux interfaces
  • ADAPTER
  • FACADE
  • COMPOSITE
  • BRIDGE
  • Introduction à la responsabilité
  • SINGLETON
  • OBSERVER
  • MEDIATOR
  • PROXY
  • CHAIN OF RESPONSABILITY
  • FLYWEIGHT
  • Introduction à la construction
  • BUILDER
  • FACTORY METHOD
  • ABSTRACT FACTORY
  • PROTOTYPE
  • MEMENTO
  • Introduction aux opérations
  • TEMPLATE METHOD
  • STATE
  • STRATEGY
  • COMMAND
  • INTERPRETER
  • Introduction aux extensions
  • DECORATOR
  • ITERATOR
  • VISITOR
  • A. Recommandations
  • B. Solutions
  • C. Code source d'Oozinoz
  • D. Introduction à UML

Critique du livre par la rédaction Nicolas Vallée le 1er octobre 2010
Cet ouvrage se veut une présentation thématique de design patterns. En effet, les auteurs ont choisi de regrouper par "idée fonctionnelle" les designs patterns afin de présenter les concepts similaires de manière assez proche.
Un autre point intéressant, cet ouvrage est construit comme un cahier d'exercices. Au fur et à mesure de sa lecture, le lecteur est invité à compléter en exercice les exemples présentés, afin de lui faire appliquer immédiatement les concepts présentés, et ainsi faciliter leur assimilation. Bien entendu, les corrigés se trouvent en annexe.
Quelques critiques…
Tout d'abord, l'auteur a choisi d'illustrer son ouvrage à l'aide d'un exemple directeur. Cette idée est intéressante: le lecteur est censé pouvoir se raccrocher à ce fil conducteur, et mieux cerner le schéma global de ce micro-projet. Malheureusement le domaine choisi, à savoir une usine de fabrication de feux d'artifices, n'est pas parlant pour un profane.
Ensuite, cet ouvrage semble être une traduction littéraire. De nombreux points auraient certainement pu mieux respecter les expressions idiomatiques de la langue française.
Enfin, le niveau de cet ouvrage est signalé comme étant avancé, ce qui est loin d'être le cas selon moi. Les concepts ne sont pas poussés dans leur retranchement, un lecteur averti y verrait plutôt une application quasi-immédiate. Par ailleurs, sa notion de polymorphisme est tout simplement incomplète, car restreinte à l'application de LSP. Or depuis Java 1.5, le polymorphisme paramétrique est disponible, et il aurait été intéressant de voir ce qu'il impliquait dans la conception.




 Poster une réponse

Avatar de gorgonite gorgonite - Rédacteur/Modérateur https://www.developpez.com
le 01/10/2010 à 9:55
Bonjour,

J'ai eu l'occasion de lire l'ouvrage Les Design Patterns en Java : Les 23 modèles de conception fondamentaux, publié en 2ème édition chez Pearson
Citation Envoyé par résumé éditeur
Tout programmeur Java se doit de connaître les 23 design patterns fondamentaux recensés par les célèbres développeurs du Gang of Four, véritable condensé de l'expérience de plusieurs générations de développeurs, et aujourd'hui incontournable pour écrire un code propre et efficace.
Cet ouvrage, fondé sur de nombreux exemples d'application, vous aidera à comprendre ces modèles et développera votre aptitude à les appliquer dans vos programmes.
Forts de leur expérience en tant qu'instructeurs et programmeurs Java, Steve Metsker et William Wake vous éclaireront sur chaque pattern, au moyen de programmes Java réels, de diagrammes UML, de conseils sur les bonnes pratiques et d'exercices clairs et pertinents. Vous passerez rapidement de la théorie à l'application en apprenant comment écrire un meilleur code ou restructurer du code existant pour le rationaliser, le rendre plus performant et plus facile à maintenir.


consulter ma critique

n'hésitez pas à partager vos avis sur cet ouvrage à la suite de mon post

à tous
couverture du livre Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

Développez pour le web par l'exemple : 3 applications détaillées

de
Public visé : Débutant

Résumé de l'éditeur

Ce livre sur les EJB 3 s'adresse aux développeurs Java d'applications web travaillant sur les frameworks Struts 2, JSF 2 ou Flex 3. Le débutant comme l'expert trouveront les informations qui leur conviennent sur l'utilisation des EJB (Enterprise JavaBeans) de manière générale et les gains de productivité apportés par la version 3.

L'auteur propose le développement avec les EJB de trois applications web de vente en ligne aux fonctionnalités quasi identiques et qui sont basées sur des couches métier et persistance communes. À l'aide de l'IDE Eclipse et du serveur d'application JBoss 6, il exploite les fonctionnalités d'un container EJB pour :

  • mettre en place une couche de persistance basée sur les Entity beans, le langage JPQL et la Java Persistence API ;
  • créer des objets métiers à l'aide des Session beans et des Message-driven beans ;
  • définir une politique de sécurité avec une gestion des rôles et des permissions définie dans un fichier de propriétés, une base ou un annuaire LDAP ;
  • exposer des EJB 3 en tant que web services ;
  • mettre en place des traitements différés et ponctuels à l'aide des EJB Timers ;
  • faire de la programmation par aspect grâce aux Interceptors.

Tout au long des chapitres, l'auteur :

  • décrit et met en place les nouveautés incluses dans les dernières versions des frameworks Struts 2 et JSF 2 ;
  • détaille l'utilisation du framework GraniteDS pour réaliser la communication entre les objets Java et Flex 3 et créer une interface RIA ;
  • met en avant le framework open-source de reporting JasperReports et montre son utilisation avec les EJB, Struts 2 et JSF 2 pour créer des rapports graphiques.


Enfin, l'auteur décrit les apports de la toute dernière version des EJB, la version 3.1, qui a été finalisée en décembre 2009.

Les sources des applications sont en téléchargement sur le site www.editions-eni.fr et l'auteur continuera de les faire évoluer sur son site.

Édition : ENI - 370 pages , 1re édition, 1er juillet 2010

ISBN10 : 2746055678 - ISBN13 : 9782746055674

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • 1. Introduction
  • 2. L'application VenteEnLigne
  • 3. Les entity beans et l'API de persistance (JPA)
  • 4. Les sessions Beans
  • 5. Traitements des commandes avec les Message-Driven Beans
  • 6. Utilisation des WebServices
  • 7. Les EJBs Timer
  • 8. Les Interceptors
  • 9. Securité
  • 10. Struts 2
  • 11. Développement d'un client avec JSF 2
  • 12. Génération de rapports avec JasperReports
  • 13. Développement d'un client avec Flex 3
  • 14. Mise en place de l'environnement
  • 15. EJB 3.1 : les nouveautés avec Java EE 6
  • 13. Développement d'un client avec Flex 3
Critique du livre par la rédaction Hikage le 1er septembre 2010
Si vous souhaitez découvrir rapidement les EJB 3, ce livre est un excellent moyen de commencer.
À l'aide de capture d'écran et d'extrait de code source, il présente clairements les différents aspect de ceux-ci : la couche métier avec les Session Bean, la persistance avec JPA, la securité, les fonctionnalités transverses avec les interceptors ou encore l'interopérabilité par le biais des WebServices.

Mais le point fort de ce livre est qu'il ne porte pas uniquement sur les EJBs, mais aussi leur utilisation dans des projets avec des outils et frameworks qui ne sont pas forcément liés à ceux-ci au départ.
J'ai fort apprécié la section d'intégration de Flex et des EJBs par exemple, qui est très bien expliquée, ou encore l'intégration avec JasperReport. Ces sujets sont très spécifiques et donc très rarement traités, ce qui en fait une plus-value importante (du moins pour ceux qui s'y intéresse).

Le chapitre concernant la spécification JEE 6 est appréciable également afin de survoler rapidement les nouveautés de celle-ci.

Au niveau de la forme, le livre est bien écrit et assez aisé à suivre. Mon seul regret est de devoir de temps en temps jongler entre les pages, du fait des extraits de code parfois trop verbeux.

Public
Grâce à ses codes source très bien expliqués, ses fonds d'écrans explicites et des explications très facile à comprendre, ce livre est particulièrement bien adapté à des profils neophytes désirant découvrir les EJBs 3.




 Poster une réponse

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 14/09/2010 à 8:59
Bonjour,

J'ai eu l'occasion de lire le livre Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3), de Celinio Fernandes.

C'est un excellent livre francophone pour découvrir les EJBs simplement, et dans des cas pratiques d'interaction avec des fronts Web (JSF et Struts 2) ou RIA (Flex).
couverture du livre Programmation concurrente en Java

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
10 commentaires
 
 

Programmation concurrente en Java

de
Traducteurs : Eric Jacoboni

Résumé de l'éditeur

La programmation concurrente permet l'exécution de programmes en parallèle. A l'heure où les processeurs multicoeurs sont devenus un standard, elle est désormais incontournable, et concerne tous les développeurs Java. Mais l'écriture d'un code qui exploite efficacement la puissance des nouveaux processeurs et supporte les environnements concurrents représente un défi à la fois en termes d'architecture, de programmation et de tests. Le développement, le test et le débogage d'applications multithreads s'avèrent en effet très ardus car, évidemment, les problèmes de concurrence se manifestent de façon imprévisible. Ils apparaissent généralement au pire moment - en production, sous une lourde charge de travail. Le but de ce livre est de répondre à ces défis en offrant des techniques, des patrons et des outils pour analyser les programmes et pour encapsuler la complexité des interactions concurrentes. Il fournit à la fois les bases théoriques et les techniques concrètes pour construire des applications concurrentes fiables et adaptées aux systèmes actuels - et futurs.

Édition : Pearson Education - 370 pages , 1re édition, 1er mai 2009

ISBN10 : 2744023337 - ISBN13 : 9782744023330

18,5 cm x 23 cm, 795g

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)
  • Les bases
    • Thread safety
    • Partage des objets
    • Composition d'objets
    • Briques de base
  • Structuration des applications concurrentes
    • Exécution des tâches
    • Annulation et arrêt
    • Pools de threads
    • Applications graphiques
  • Vivacité, performances et tests
    (list]
  • Éviter les problèmes de vivacité
  • Performances et adaptabilité
  • Tests des programmes concurrents
[*]Sujets avancés
  • Verrous explicites
  • Construction de synchronisateurs personnalisés
  • Variables atomiques et synchronisation non bloquante
  • Le modèle mémoire de Java
[/list]
Critique du livre par la rédaction benwit le 1er août 2010
"Programmation concurrente en Java" est un ouvrage qui peut intimider au premier abord. Avec un titre pareil, s'il ne fait aucun doute que le développeur concerné par le sujet fait partie du lectorat visé, qu'en est-il d'un public plus large ? Peut-il intéressé un développeur Java plutôt habitué à des programmes monothread ?
Si la présence du mot "Java" me laissait penser qu'il était orienté pratique, le sujet me semblait quand même assez spécifique. Quand j'ai décidé de le lire, c'était donc plus par curiosité. Bien m'en a pris et je vais vous expliquer pourquoi.

Sur la forme tout d'abord.
Cet ouvrage fait partie d'une collection "Référence" particulièrement soignée. Je n'ai relevé aucun problème de traduction et je tenais à le souligner car je sais que certains développeurs préfèrent parfois la version originale pour les éviter.
La table des matières est très détaillée et illustre bien via son plan progressif à quel point l'ouvrage est didactique.
J'ai particulièrement apprécié des choses que l'on voit trop rarement :
  • Dans la présentation, l'auteur expose les prérequis et situe son ouvrage, nous dit ce qu'il est, ce qu'il n'est pas et le cas échéant, il nous oriente vers des ouvrages plus indiqués ! Un must.
  • Les nombreux exemples sont tous référencés dans une table des listings et même si le sujet s'y prête bien, ils sont de trois types : les mauvais, les moyens et les bons.


Sur le fond ensuite.
Jusque là, je n'avais qu'effleuré la programmation concurrente. Je l'avais plus ou moins rencontré dans des applications desktop (Swing) ou dans des applications web (Servlet) mais elle nous concerne bien plus que je l'imaginai (Les threads sont partout !).
Avec cet ouvrage, vous comprendrez entre autres :
  • pourquoi les interfaces graphiques sont monothread !
  • pourquoi de nombreux programmes ne sont pas corrects !
  • pourquoi les plantages de la production ne sont pas causés par des ondes alpha !
  • pourquoi tant qu'on a pas compris ce qu'est la thread-safety, on ne sait pas programmer !


Vous verrez également que parfois, la programmation concurrente n'apporte aucune performance supplémentaire et que parfois, elle simplifie l'écriture de programmes !
Dans ce livre, j'ai appris beaucoup de vocabulaire : vivacité, réentrance, confinement, publication, … et j'ai pu mettre des noms sur certaines de mes pratiques comme le "confinement dans la pile". J'ai également découvert la richesse des API Java (AtomicXXX et le framework Executor, …)
En plus de toutes ces explications théoriques, cet ouvrage se veut également un guide pratique pour nous aider dans notre activité de codage et prodigue de nombreux conseils tirés de 20 ans d'expériences.
Bref, vous l'aurez compris, j'ai aimé ce livre et je le conseille à tous les développeurs Java intermédiaire/avancé. Je n'ai qu'un seul regret, ne pas l'avoir lu plus vite !
Critique du livre par la rédaction Eric REBOISSON le 1er décembre 2010
Un livre de moins de 400 pages où beaucoup de choses intéressantes sont dites sur la programmation concurrente en Java, c'est tout l'objectif de "Programmation concurrente en Java".
Le livre est découpé en plusieurs parties : une première aborde les bases de la concurrence, de la "thread safety" et de la composition de classes concurrentes. Une seconde partie montre comment une bonne utilisation de la concurrence peut améliorer la réactivité et la performance des applications (utilisation de pool de threads…). Une troisième partie aborde le test des applications concurrentes pour s'assurer du bon fonctionnement du code. Enfin, une dernière partie couvre des aspects avancés de la programmation concurrente. A noter que la table des matières est très détaillée, permettant de retrouver rapidement un sujet recherché.
On trouvera tout au long du livre des exemples de codes sur ce qu'il est bon de faire et à éviter pour obtenir un code concurrent sécurisé, performant et maintenable. On trouvera ainsi des modèles d'utilisation de la programmation concurrente que l'on pourra réutiliser dans des projets réels comme par exemple la meilleure manière de gérer un cache en utilisant des threads (en principe le code du livre est disponible sur le site de Pearson, mais je n'ai pas encore trouvé l'endroit).
Pas toujours évident, le sujet de la programmation concurrente ne s'adresse pas au débutant en programmation et nécessite une bonne connaissance de Java, ou au moins quelques connaissances pour réussir à suivre. L'auteur de ce livre réussi tout de même à faire passer la pilule sur un sujet qui n'est pas des plus amusants à première vue. En tout cas, je conseille ce livre à tous ceux que la programmation concurrente intéresse, car il me semble que cet ouvrage est une petite bible sur le sujet.




 Poster une réponse

Avatar de benwit benwit - Rédacteur https://www.developpez.com
le 06/08/2010 à 8:08
Je viens de lire "Programmation concurrente en Java" et je vous le recommande vivement.

Une chose m'a particulièrement marqué :
Trop peu de développeurs se soucient de la justesse de leur programme. Un peu comme pour la propreté du code (cf Clean Code), ils sont nombreux à s'arrêter dès que ça fonctionne ! Or en ce qui concerne la concurrence, les conditions limites vont s'exprimer le plus souvent en production et non en développement.

Je ne dis pas qu'il faut faire systématiquement du code multithread (cela à un coût certain) mais au minimum de l'indiquer pour ceux qui viennent après. L'auteur fait d'ailleurs remarqué que même de nombreux frameworks connus ne l'indiquent pas et on est alors obligé de le deviner en se mettant à leur place !!! C'est pourquoi il propose à la fin de son ouvrage des annotations pour l'indiquer explicitement.

Quelle est votre opinion sur le sujet ?
Est-ce que vous y penser en développant ? Est-ce que vous y penser parce que vous avez des comportements étranges en production ?
Etes vous sensibiliser sur le sujet ? Allez vous faire gaffe à l'avenir ?
Que pensez vous de sa proposition des annotations ?
Avatar de divxdede divxdede - Membre éclairé https://www.developpez.com
le 06/08/2010 à 11:16
Bonjour,
La javadoc de l'api standard est bien fichue de ce coté là est indique le plus souvent si une classe est 'thread-safe' ou non.
A mon sens, il s'agit avant tout d'un problème de documentation et l'annotation n'y changera pas grand chose. A savoir lorsqu'elle sera absente, on ne saura pas ce qu'il faut en conclure.
Avatar de Deaf Deaf - Membre éprouvé https://www.developpez.com
le 06/08/2010 à 11:34
Citation Envoyé par benwit  Voir le message
Trop peu de développeurs se soucient de la justesse de leur programme.

Je pense que cela vient du fait que nombre de développeurs ne sont pas à l'aise avec la concurrence. Beaucoup pensent résoudre les problème en métant un 'synchronized' devant LA méthode qui pose problème

Citation Envoyé par benwit  Voir le message
ils sont nombreux à s'arrêter dès que ça fonctionne

Je confirme, la pratique trop souvent répandue est de se poser les questions de concurrence que lorsque des erreurs se produisent. Dès que ça semble rouler, on oublie cette vilaine bête noire...
couverture du livre JBoss AS 5 Development

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

JBoss AS 5 Development

de

Résumé de l'éditeur

Develop, deploy, and secure Java applications on this robust, open source application server

A complete guide for JBoss developers covering everything from basic installation to creating, debugging, and securing Java EE applications on this popular, award-winning JBoss application server
Master the most important areas of Java Enterprise programming including EJB 3.0, web services, the security framework, and more
Starts with the basics of JBoss AS and moves on to cover important advanced topics with the help of easy-to-understand practical examples
Written in a very simple and readable style, this book includes essential tips and tricks that will help you master JBoss AS development

Édition : PackT Publishing - 396 pages , 1re édition, 1er décembre 2009

ISBN10 : 1847196829 - ISBN13 : 9781847196828

Commandez sur www.amazon.fr :

35.16 € TTC (prix éditeur 37.48 € TTC)
  • Chapter 1: Installing Core Components
  • Chapter 2: What's New in JBoss AS 5 ?
  • Chapter 3: Customizing JBoss AS Services
  • Chapter 4: Developing EJB 3 Session Beans
  • Chapter 5: Developing JPA Entities
  • Chapter 6: Creating a Web Application
  • Chapter 7: Developing Applications with JBoss Messaging Service
  • Chapter 8: Developing Applications with JBoss and Hibernate
  • Chapter 9: Managing JBoss AS
  • Chapter 10: Developing Applications with JBoss Web Services
  • Chapter 11: Clustering JBoss AS
  • Chapter 12: Developing a Clustered Application
  • Chapter 13: JBoss AS Security
  • Chapter 14: Securing JBoss AS Applications
Critique du livre par la rédaction longbeach le 1er février 2010
Avant de lire ce livre, je connaissais déjà l'auteur, Francesco Marchioni, grâce à son site - http://www.mastertheboss.com/ - qui est dédié à JBoss. C'est donc avec enthousiasme que j'ai souhaité me procurer ce livre et je n'ai pas été déçu. En effet le livre est à l'image du site : pratique, riche en exemples et en informations utiles.
Concernant la version traitée de JBoss, il s'agit de la version 5. Le livre a été publié en décembre 2009, en même temps que la sortie de la version 6 de JBoss, qui s'aligne petit à petit avec Java EE 6. Mais le livre reste totalement à jour, dans la mesure où il traite principalement de fonctionnalités de JBoss qui sont plus ou moins indépendantes des versions de Java EE.
Le livre est constitué de 14 chapitres. On peut trouver, comme à l'accoutumé dans les livres de la collection Packt Publishing, un résumé à la fin de chaque chapitre qui récapitule les principales notions qui ont été vues.
Les 3ers chapitres décrivent l'installation de JBoss, ses nouveautés et la configuration des services (logs, connexion à la base, les transactions, utilisation de la console JMX, de la console d'administration basée sur Jopr).
Le chapitre 4 met en avant le container EJB de JBoss puisqu'il est consacré au développement des session beans (EJB 3). Il y a du code, des explications théoriques (par exemple sur le cycle de vie des session beans) et pratiques (par exemple configurer la taille du pool de stateless session beans dans JBoss).
Le chapitre 5 aborde la persistance et crée un projet dans Eclipse en utilisant les entity beans et la Java Persistence API (JPA).
Le chapitre 6 utilise JSF 1.2 pour la création d'une application Web. L'auteur décrit le serveur Web contenu dans JBoss et qui utilise Apache Tomcat.
Le chapitre 7 utilise JMS avec les Message-Driven Beans et JBoss Messaging qui remplace JBoss MQ. Là encore on trouve une partie théorique et une partie pratique.
Le chapitre 8 montre l'utilisation d'Hibernate avec JBoss Tools / Hibernate Tools.
Les chapitres 9 à 12 rentrent dans le coeur de JBoss AS avec des explications sur JMX et les MBeans, ainsi que la gestion des ressources depuis la console d'administration. Des Web Services sont développés et déployés avec JBoss WS.
Le clustering de serveurs JBoss AS n'est pas oublié avec des explications sur la configuration nécessaire pour le load balancing et l'utilisation de JBoss Cache pour synchroniser les données dans un cluster.
Enfin j'ai trouvé les chapitres 13 et 14 sur la sécurité très complets. Tout est abordé : JAAS, JBossSX, certificats, sécurisation des EJB, encryption des Web Services.
Ce que j'ai aimé : Les nombreuses illustrations (de la console et de la structure des fichiers dans JBoss, des captures d'écrans d'Eclipse …), les exemples concrets, le côté simple des explications.
Ce que j'ai moins aimé : Certains points ne sont pas abordés en détails mais ce n'est pas quelque chose de négatif dans la mesure où l'auteur fournit les explications de base nécessaires pour aller plus loin dans les détails si nécessaire.

English version :
Before reading this book, I already knew the author, Francesco Marchioni, because of his web site - http://www.mastertheboss.com/ - which is dedicated to JBoss. So it was with enthusiasm that I wished to get a copy of the book and I was not disappointed. Indeed the book is like the web site : practical, rich in samples and useful information.
The book uses JBoss 5. It was published in december 2009, when the first version of JBoss 6 was becoming available and starting to implement Java EE 6. But the book is still up to date since it describes functionalities of JBoss that are more or less independant of the versions of Java EE.
The book is made of 14 chapters. As usual with the books from the Packt Publishing collection, there is a resume at the end of each chapter which recapitulates the main subjects.
The first 3 chapters describe the installation of JBoss, the new features and the configuration of services (logs, database connection, transactions, use of the JMX console and the administration console based on Jopr).
Chapter 4 is dedicated to the EJB container in JBoss since the session beans (EJB 3) are being developed. There is coding, theoretical explanations (for instance the session beans life cycle) and practical explanations (for instance how to configure the size of the pool of stateless session beans in JBoss).
Chapter 5 is about the persistence and a project is developed in Eclipse, using entity beans and the Java Persistence API (JPA).
Chapter 6 uses JSF 1.2 for the creation of a web application. The author describes the Web server inside JBoss and which uses Apache Tomcat.
Chapter 7 uses JMS with Message-Driven Beans and JBoss Messaging which replaces JBoss MQ. Again, there are nice explanations : theoretical and practical.
Chapter 8 shows the use of Hibernate with JBoss Tools / Hibernate Tools.
Chapters 9 to 12 go into the heart of JBoss AS with explanations of JMX, the MBeans and the management of resources from the administration console. Web Services are developed and deployed in JBoss WS.
Clustering of JBoss AS servers is not forgotten : there are explanations on the configuration needed for load balancing and the use of JBoss Cache to synchronise data in a cluster, among many other explanations.
Finally I found chapters 13 and 14 on security very complete. The author writes about everything : JAAS, JBossSX, certificates, securing EJB, Web Services encryption …
What I liked the most : The many illustrations (of the console, the file system structure in JBoss, the screenshots of Eclipse …), the concrete samples, the simple explanations.
What I liked the least : one might have liked to read more details about certains subjects but that is not a negative thing because the author gives the basic explanations needed to investigate further if necessary.




 Poster une réponse

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 13/02/2010 à 11:37
[ame="http://www.amazon.fr/JBoss-AS-Development-Francesco-Marchioni/dp/1847196829/wwwdeveloppec-21"]Jboss As 5 Development: Amazon.fr: Francesco Marchioni: Livres en anglais@@AMEPARAM@@http://ecx.images-amazon.com/images/I/41MEC8SkTlL.@@AMEPARAM@@41MEC8SkTlL[/ame]

Bonjour utilisateurs de JBoss,
je viens de faire une critique du livre JBoss AS 5 Development qui est sorti en décembre 2009.

Elle se trouve ici : http://java.developpez.com/livres/?p...L9781847196828

Si vous avez des questions ou remarques, n'hésitez pas.
couverture du livre Apache Maven

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (3)
29 commentaires
 
 

Apache Maven

de

Résumé de l'éditeur

Maven, l'outil open-source de gestion et d'automatisation de développement Java, a le vent en poupe.

Les raisons : il systématise, rationalise et simplifie le développement collaboratif de projets Java, faisant gagner aux entreprises comme aux développeurs du temps et de l'argent !

Les auteurs, membres de l'équipe de développement Maven, aidés par toute la communauté francophone, ont imaginé de présenter Maven 2 sous un angle original et didactique, à travers un projet fictif, inspiré de leurs expériences sur le terrain, dont ils détaillent toutes les phases successives.
Ce projet évolue au fil des besoins et de la contribution de développeurs aux profils différents, vous familiarisant avec les concepts fondamentaux de Maven et leur mise en oeuvre pratique, mais aussi avec les fonctionnalités plus avancées.
Vous profitez également des recommandations et bonnes pratiques pour optimiser votre utilisation de Maven.
Vous découvrez ainsi de manière ludique et grâce à des exemples concrets le potentiel de Maven, et tous les avantages qu'il peut apporter à vos propres projets.

Édition : Pearson Education - 324 pages , 1re édition, 1er novembre 2009

ISBN10 : 274402337X - ISBN13 : 9782744023378

18,7 x 23 cm

Commandez sur www.amazon.fr :

30.39 € TTC (prix éditeur 32.00 € TTC)
  • Premiers pas avec Maven
    • Introduction
    • Au-delà de java.lang
    • Un peu plus que compiler
    • Mettre en place des tests unitaires
    • Mettre en place des tests d'intégration
  • Maven en entreprise
    • Gestion avancée des dépendances
    • Quand le projet devient trop lourd
    • Maven et JEE
    • Maven et les IDE
    • Le jour J : la livraison
  • Encore plus loin avec Maven
    • Utiliser un outil non supporté
    • L'assurance qualité
    • Respecter un format de distribution
    • Un nouveau projet démarre
    • Avons-nous fait le bon choix ?
    • Nos recommandations
    • Épilogue
    • Lexique
Critique du livre par la rédaction Eric REBOISSON le 1er avril 2010
Maven est aujourd'hui un outil incontournable pour assurer la gestion d'un projet informatique (même s'il n'est pas le seul et loin de faire l'unanimité), notamment pour le monde Java.
Je connais Maven pour l'avoir utilisé sur quelques projets, par le maintien de la FAQ Maven sur le site Developpez.com et également par la lecture de quelques ouvrages sur l'outil.
C'est donc avec grande curiosité que je souhaitais lire "Apache Maven" d'Arnaud Héritier et Nicolas De Loof, un ouvrage en français et atypique selon les dires.
Je dois dire tout de suite que je n'ai pas été déçu car voilà un ouvrage informatique que j'ai dévoré comme un roman, par petits bouts tous les jours, vraiment !

Ce livre raconte donc l'histoire d'un projet, petit et désordonné au départ (sauvegardé sur une disquette), qui deviendra par la suite le produit phare de la multinationale Geegol au travers des bonnes pratiques que le projet distille avec son utilisation de Maven.
On apprendra alors tout au long de l'histoire comment utiliser Maven pour répondre aux incontournables des projets en entreprise, depuis la création du projet jusqu'à sa livraison.
On prendra alors connaissance des nombreuses fonctionnalités de Maven, comme sa gestion des dépendances, la convention plutôt que la configuration, les profils, etc. Mais également sa possibilité d'intégration avec d'autres produits, comme les IDE, les serveurs d'intégration continue, etc.
Très pragmatique, le livre fournit des exemples de configuration directement utilisables dans vos projets.
J'ai aimé également l'ouverture des auteurs sur le produit, on trouvera bien sûr les avantages de Maven mais aussi ses points faibles, les alternatives (ex : Graddle, Ant) ainsi qu'un avant goût du futur, avec Maven 3.
Vous l'aviez peut être deviné : j'ai énormément apprécié ce livre et j'y retrouve l'esprit pédagogique présent également dans la collection "Tête la première" (pour moi une référence en matière de pédagogie informatique).
Les grands intérêts du livre passent par le style employé, très jovial, jamais ennuyant. On y retrouve les grandes lignes principales permettant de mener à bien un projet Java mais également de nombreuses astuces qui pourront parfaire vos réalisations.
Nous avons donc au final un très bon livre en français sur Maven, que je conseille à tous ceux qui auront à travailler avec cet outil formidable.
Critique du livre par la rédaction Hikage le 1er avril 2010
Ce livre est une vraie merveille au niveau de la présentation. Il se démarque clairement de la plupart des livres d'informatique que j'ai pu lire. Contrairement à ceux-ci (qui sont beaucoup plus formels, présentant de manière tout à fait neutre leur sujet) Apache Maven est beaucoup plus vivant et dynamique. Ici, le livre est écrit comme une retranscription de la vie d'une équipe qui a choisi Maven. Nous avons droit à une dose d'humour, mais aussi à des débats où chacun défend son point de vue. Et le résultat est étonnant, car il nous donne l'impression de vivre cette aventure avec eux, nous donnant envie de continuer d'avancer dans le livre sans attendre.
Du point de vue du contenu, Apache Maven couvre les fonctionnalités les plus importantes et/ou les plus intéressantes de Maven, le tout réparti en trois parties :

Premiers pas avec Maven
Dans cette partie, c'est tout d'abord le choix de Maven face à d'autres outils similaires qui est introduit. Sa force principale est les conventions apportées car elles permettent à n'importe quel développeur connaissant Maven de retrouver ses repères rapidement sur n'importe quel projet basé sur Maven. Dans cette partie on découvre également la gestion de dépendances, les premiers plug-ins et comment générer des livrables.

Maven en entreprise
Dans cette seconde partie, l'intégration de Maven dans les trois plus importants IDE (Eclipse, Netbeans et Idea) est présentée, le tout sous la forme d'un débat, dont la conclusion est particulièrement intéressante ! La notion de dépôt d'entreprise est également introduite, permettant de réduire considérablement la bande passante vers Internet, mais également d'avoir une gestion plus fine de ce qui est permis ou non au sein des projets. Et pour finir, les auteurs présentent un plug-in permettant de simplifier considérablement la livraison d'un livrable (deux commandes !)

Encore plus loin avec Maven
Maven, c'est aussi tous ses plug-ins. Mais comment faire quand il n'en existe aucun qui correspond à nos besoins ? Les auteurs nous montrent qu'il n'est pas sorcier de créer nos propres plug-ins Maven. C'est ensuite la notion d'archétype qui est présentée : ceux-ci sont une espèce de template de projet préconfiguré. Exit le copier-coller d'un projet et de renommer à la main les fichiers qui vont bien. Les archétypes proposent une solution beaucoup plus élégante !
Les auteurs terminent finalement par le chapitre certainement le plus intéressant : des best practices basées sur leurs propres expériences

Conclusion
Au final, j'ai réellement dévoré ce livre. Je connaissais et utilisais déjà Maven mais sans avoir pris le temps de regarder toutes ses possibilités. À la fin de ce livre, j'avais qu'une seule envie : tester par moi-même ! Je conseille donc vivement ce livre à toute personne ne connaissant pas (ou mal) Maven. Par contre pour les très bons connaisseurs, je doute que ce livre soit très intéressant, sauf pour convaincre leur management d'utiliser Maven.
Critique du livre par la rédaction Romain Linsolas le 12 janvier 2009
On peut s'en douter en lisant le titre, cet ouvrage va nous faire découvrir Maven, l'outil de construction de projets Java d'Apache.
Il ne faut pas s'attendre ici à trouver LA bible sur Maven, mais plutôt d'apprendre à utiliser cet outil au sein d'une organisation.
Pour ce faire, Nicolas de Loof et Arnaud Héritier nous racontent l'histoire d'une équipe de développeurs, qui va être confrontée à différentes situations - qui ne manqueront pas de nous rappeler nos propres expériences.
Le livre se divise en trois grandes parties.
La première se destine à nous familiariser avec Maven et ses principaux concepts.
La seconde aborde des concepts plus poussés, en particulier concernant l'utilisation de Maven au sein d'une entreprise.
Enfin la dernière partie regroupe différents sujets, par exemple des cas atypiques d'utilisation de Maven.

1e partie : Premiers pas avec Maven
Cette première partie se destine à nous familiariser avec Maven et ses principaux concepts.
Les auteurs en profitent pour poser le décor de leur histoire. Nous suivrons donc l'équipe de développement d'un petit projet nommé noubliepaslalistedescourses !
Autrefois construit par un simple fichier .bat, cette application va rajeunir en étant migré vers Maven.
C'est ici que l'on constate les premiers bénéfices de l'outil d'Apache : gestion simplifiée des dépendances, cycle de vie de construction d'un projet, création des livrables (fichier JAR final par exemple), etc.
Les auteurs s'attaquent à d'autres problématiques, telles que la gestion des versions du JDK, l'intégration d'autres langages (Groovy par exemple).
Un chapitre est également consacré à la politique de tests, en mettant en lumière les différents types de tests (unitaires, fonctionnels, d'intégration, etc.) et même l'intégration continue.
On le voit dès cette première partie : ce livre n'est pas là uniquement pour nous parler de Maven, mais bien de tout ce qui a trait à l'environnement de développement.

2e partie : Maven en entreprise
Cette seconde partie aborde des questions plus poussées, des aspects de Maven qui prennent tout leur sens dans un environnement d'entreprise.
Ainsi, la première problématique abordée est la gestion avancée des dépendances, et en particulier l'introduction des dépôts d'entreprises (les repositories).
Par la suite, on s'attaque aux concepts des projets multi-modules et de l'héritage, très utiles dès que les projets prennent de l'importance !
Il est également question de la construction de livrables plus complexes, en particulier les WAR, les EJB ou les EAR.
Un chapitre est dédié à l'intégration de tout ceci au sein du principal outil du développeur : l'IDE (l'environnement de développement).
Qu'il s'agisse d'Eclipse, de NetBeans ou encore d'IntelliJ, ils sont tous étudiés par les auteurs du livre, qui nous montrent aussi bien la facilité d'utilisation de Maven directement dans l'IDE, que les petits plus qu'ils ont à offrir au développeur pour faciliter son travail quotidien.
Cette seconde partie s'achève sur un point crucial de la vie d'un projet : la livraison !
Cette étape, trop souvent bâclée, peut faire échouer un projet. Les auteurs nous donnent donc les moyens proposés par Maven pour simplifier, automatiser et fiabiliser ce processus.

3e partie : Encore plus loin avec Maven
Cette dernière partie aborde différents sujets qui n'ont pas encore été vus dans les chapitres précédents.
Tout d'abord, les auteurs nous expliquent comment il est possible de lancer des tâches par Maven alors qu'aucun plugin spécifique n'existe pour cela.
Il est ainsi question de développement de plugin Maven, mais aussi de l'intégration d'Ant au sein de Maven.
Un autre sujet connexe est abordé ici : la surveillance de la qualité du code.
Là aussi, Maven peut apporter des solutions - essentiellement grâce à des plugins ou à Sonar - et les auteurs ne manquent pas de nous le montrer.
C'est également le bon moment pour introduire la fonctionnalité de génération de site - et de rapports techniques - offerte par Maven !
Par la suite, un chapitre est entièrement consacré au démarrage d'un nouveau projet.
C'est ici l'occasion de voir les recommandations que l'on peut faire sur de nouveaux projets, et non plus de parler de migration de projets existants vers Maven.
On passe ainsi en revue certaines bonnes pratiques à mettre en place dès le début d'un projet, on apprend également à utiliser les archetypes de Maven, ces plugins qui nous permettent de créer le squelette d'un projet en fonction de son type.
Maintenant que nous avons fait le tour des principales fonctionnalités de Maven, les auteurs se posent une question un peu déroutante, mais tout de même intéressante : "Avons-nous fait le bon choix ?".
C'est ici que l'on fait une sorte de bilan, de savoir si finalement Maven est véritablement l'outil à utiliser au sein de nos projets, d'en définir les limitations et les problèmes.
Les auteurs nous parlent ensuite de l'écosystème autour de Maven : ses concurrents (Ant, Ivy et Gradle en première ligne), les sociétés qui gravitent autour de l'outil (en particulier Sonatype), etc.
Enfin, on termine avec quelques pages nous montrant les nouveautés de Maven 3.
Avant de conclure cet ouvrage, les auteurs décident de nous offrir leurs précieuses recommandations vis-à-vis de l'utilisation de Maven, leurs 10 commandements.

Mon avis
Apache Maven est un livre plutôt atypique.
Il s'apparente plus à un roman qu'à un livre technique traditionnel, et ne doit pas être pris pour une sorte de "bible" sur l'outil d'Apache.
Le fait que Nicolas de Loof et Arnaud Héritier aient abordé le sujet de Maven en racontant la vie et l'évolution d'une équipe de développement est une excellente idée, car cela nous montre un usage très réel et concret de cet outil.
Cela nous permet également de voir tous les à-côtés qui ne sont habituellement pas traités par des ouvrages informatiques sur un outil.
Ici, au-delà de Maven, les auteurs évoquent le TDD (Test Driven Development ou Développement piloté par les tests), les différentes façons de tester son application, le suivi de qualité, l'intégration continue, l'aspect livraison, les bonnes et mauvaises pratiques en général, etc.
C'est forcément un autre bon point pour ce livre !
Alors certes mon niveau en Maven, qui est plutôt bon, ne m'a pas permis de sortir de cette lecture avec beaucoup de nouvelles informations.
Toutefois, cela m'a conforté dans mes idées, m'a rassuré sur mes bonnes pratiques, et m'a appris quelques astuces plutôt sympathiques.
Le fait que ce livre aborde vraiment tous les aspects de la vie d'un projet est un énorme plus, et pourra, à mon avis, intéresser des personnes n'ayant pas un profil de développeur !
Selon moi, ce livre doit être vu comme un indispensable complément à une "bible" Maven, par exemple Maven: The Definitive Guide, d'autant que ce dernier vient tout juste d'être traduit en français.
Vous trouverez une critique complète de cet ouvrage, ainsi que tous les détails relatif à ce livre à cette adresse : http://linsolas.developpez.com/critiques/apache-maven/




 Poster une réponse

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 11/11/2009 à 16:34
Apache Maven: Amazon.fr: Nicolas De loof, Arnaud Héritier: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/515LrFKri0L.@@AMEPARAM@@515LrFKri0L

27/12/2009 :

La critique de romaintaz, membre de la rédaction

Quelques extraits :

Il ne faut pas s'attendre ici à trouver LA bible sur Maven, mais plutôt d'apprendre à utiliser cet outil au sein d'une organisation.

On le voit dès cette première partie : ce livre n'est pas là uniquement pour nous parler de Maven, mais bien de tout ce qui a trait à l'environnement de développement.

Avant de conclure cet ouvrage, les auteurs décident de nous offrir leurs précieuses recommandations vis-à-vis de l'utilisation de Maven, leurs 10 commandements.

Apache Maven est un livre plutôt atypique.
Il s'apparente plus à un roman qu'à un livre technique traditionnel, et ne doit pas être pris pour une sorte de "bible" sur l'outil d'Apache.

Le fait que ce livre aborde vraiment tous les aspects de la vie d'un projet est un énorme plus, et pourra, à mon avis, intéresser des personnes n'ayant pas un profil de développeur !

11/11/2009 :

Bonjour,

Un livre francophone de 324 pages sur Maven devrait sortir dans le mois, à l'initiative de Nicolas De Loof et Arnaud Héritier, tous deux committers Apache.

En voici le sommaire :
  • Introduction
  • Au-delà de java.lang
  • Un peu plus que compiler
  • Mettre en place des tests unitaires
  • Mettre en place des tests d'intégration
  • Gestion avancée des dépendances
  • Quand le projet devient trop lourd
  • Maven et JEE
  • Maven et les IDE
  • Le jour J : la livraison
  • Utiliser un outil non supporté
  • L'assurance qualité
  • Respecter un format de distribution
  • Un nouveau projet démarre
  • Avons-nous fait le bon choix
  • Nos recommandations
  • Épilogue
  • Lexique


En attendant, vous pouvez déjà consulter certains extraits :


De quoi se faire une idée du contenu

Qu'en pensez-vous ? Qui est intéressé ?
Avatar de BerBiX BerBiX - Membre du Club https://www.developpez.com
le 11/11/2009 à 23:48
Débutant sur l'utilisation de Maven et passionné par les possibilités offertes par cet outil, je suis plus qu'intéressé par un livre traitant de Maven en français.
Si les extraits sont représentatifs du reste du bouquin, alors on pourra s'attendre à un ensemble d'anecdotes sur les différentes phases du cycle de vie d'un projet et la façon dont Maven répond aux problématiques rencontrées ; une approche très intéressante et passionnante à lire.
Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 12/11/2009 à 10:43
Idem. Intéressé.
J'en ai entendu parler au JUG, quand Arnaud Heritier en a fait la pub.

En plus la couverture est sympa.
couverture du livre Java SOA Cookbook

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
1 commentaire
 
 

Java SOA Cookbook

de
Public visé : Intermédiaire

Résumé de l'éditeur

Java SOA Cookbook offers practical solutions and advice to programmers charged with implementing a service-oriented architecture (SOA) in their organization. Instead of providing another conceptual, high-level view of SOA, this cookbook shows you how to make SOA work. It's full of Java and XML code you can insert directly into your applications and recipes you can apply right away.

The book focuses primarily on the use of free and open source Java Web Services technologies -- including Java SE 6 and Java EE 5 tools -- but you'll find tips for using commercially available tools as well.

Java SOA Cookbook will help you:

  • Construct XML vocabularies and data models appropriate to SOA applications
  • Build real-world web services using the latest Java standards, including JAX-WS 2.1 and JAX-RS 1.0 for RESTful web services
  • Integrate applications from popular service providers using SOAP, POX, and Atom
  • Create service orchestrations with complete coverage of the WS-BPEL (Business Process Execution Language) 2.0 standard
  • Improve the reliability of SOAP-based services with specifications such as WS-Reliable Messaging
  • Deal with governance, interoperability, and quality-of-service issues

The recipes in Java SOA Cookbook will equip you with the knowledge you need to approach SOA as an integration challenge, not an obstacle.

Édition : O'Reilly - 740 pages , 1re édition, 1er mars 2009

ISBN10 : 0596520727 - ISBN13 : 9780596520724

Commandez sur www.amazon.fr :

36.79 € TTC (prix éditeur 39.82 € TTC) livraison gratuite !
[list][*]Part 1: SOA Fundamentals
  • Chapter 1. Introduction to SOA
  • Chapter 2. XML Schema and the SOA Data Model
  • Chapter 3. Working with XML and Java
[*]Part 2: Web Services
  • Chapter 4. Getting Started
  • Chapter 5. Web Services with SAAJ
  • Chapter 6. Creating Web Service Applications with JAX-WS
  • Chapter 7. Providing SOAP-Based Web Services
  • Chapter 8. RESTful Web Services
[*]Part 3: Business Processes
  • Chapter 9. Service Orchestrations with BPEL
  • Chapter 10. Advanced Orchestrations with BPEL
  • Chapter 11. SOA Governance
[*]Part 4: Interoperability and Quality of Service
  • Chapter 12. Web Service Interoperability
  • Chapter 13. Quality of Service
  • Chapter 14. Enterprise Service Bus

[list]
Critique du livre par la rédaction Eric REBOISSON le 1er janvier 2010


Contributeur pour 97 Things Every Software Architect Should Know, Eben Hewitt nous gratifie là d'un bel ouvrage de plus de 700 pages qui vous aidera à mettre en ?uvre des cas pratiques autour de la SOA.

La structure de la collection Cookbook de chez O'Reilly est la suivante : exposition des problèmes suivis de leurs solutions, des fragments de code ; le tout agrémenté d'explications et de comparaisons entre les différentes opportunités offertes dans le vaste domaine de la gestion des services.

Le contenu de "Java SOA Cookbook" est le suivant :

[list][*]La première partie du livre aborde les fondamentaux de la SOA (définitions, XML, schémas, interaction avec Java).[*]La deuxième partie se focalise sur les Web Services (déploiement, WSDL, SOAP, SAAJ, JAX-WS, REST).[*]La partie suivante est orientée business avec l'orchestration des services via BPEL (Business Process Execution Language, que l'on prononce "bipeul" ) et la gouvernance.[*]La dernière partie discute autour de l'interopérabilité des Web Services, de la qualité de service, et d'ESB.
[list]

D'un point de vue programmatique, le lecteur trouvera beaucoup d'exemples de codes (téléchargeables sur Internet) et des discussions autour de ceux-ci. Une remarque cependant : même si les recettes sont très bien expliquées, il faut être familier avec Java 5 ou 6, J2E et les concepts de développement Web (EARs, WARs...).

Voilà donc un livre que j'ai apprécié, par sa structure efficace, la richesse et la qualité de son contenu. Et comme en cuisine, vous utiliserez ce livre comme un ouvrage de référence quand des problèmes précis seront à résoudre, une lecture linéaire est, je pense, trop ennuyante.
Critique du livre par la rédaction Hikage le 1er août 2009
Français

Pour apprécier à sa juste valeur le livre Java SOA Cookbook, il faut bien comprendre que tous les termes du titre sont importants. Pour ma part, je me suis attaché uniquement à Java SOA, et j'ai été un peu surpris...

Le mot cookbook est plutôt judicieusement choisi, car on peut réellement le comparer à un livre de cuisine : une liste de recettes, sans avoir forcement tout le temps une suite logique entres elles. Par exemple, dans le chapitre concernant les gâteaux, on peut trouver 4 recettes de gâteaux au chocolat, et la 5ème est un gâteau au citron.

Dans le livre Java SOA Cookbook, c'est un peu pareil. Par exemple, dans le chapitre sur BPEL, on utilise d'abord le BPEL Engine de Apache 2-3 recettes, pour ensuite utiliser NetBean et OpenESB, puis encore un autre outil commercial pour la suite.

Et c'est comme cela dans l'ensemble du livre, ce qui est un peu déstabilisant pour "découvrir" la SOA et les sujets du livre.

Mais cela n'empêche pas l'ouvrage d'être un bon livre sur le sujet.
Les Web Services sont bien représentés, tant les services SOAP que les services REST
La partie Business Process Management, malgré mes remarques, est très intéressante elle-aussi. N'ayant personnellement jamais travaillé avec ceux-ci, j'ai appris beaucoup de choses.

Java SOA Cookbook, une fois la surprise passée du format, est un excellent livre qui permettra d'appréhender facilement les Web services, la gestion de processus métier ou, de manière plus générale, la SOA par le biais d'exemples concrets très bien détaillés.

English

To appreciate the book Java SOA Cookbook with its real value, it should be understood that all terms of the title are important. For my part, I have given attention only on Java SOA, and I was a little surprised ..

The term cookbook is carefully chosen, because you can really compare it to a cookbook: a list of recipes, without necessarily having all the time a logical sequence between them. For example, in the chapter on cakes, there are 4 recipes with chocolate, and the 5th is a lemon cake.

In the book "Java SOA Cookbook" is just the same. For example, in the chapter about BPEL, the firsts recipes use the Apache BPEL Engine, the next ones use NetBeans Designer and OpenESB, and the lasts use a commercial product for BPEL.

And it's like this in the entire book, which is a little unsettling for "discovering" the SOA and the subjects of the book.

But this does not prevent the book from being a good book on the subject. The Web Services are well covered, both the services that services SOAP REST.
The Business Process Management part, despite my remarks, is very interesting too. Having personally never worked with BPM/BPEL, I learned many things.

Java SOA Cookbook, once past the surprise of the format, is an excellent book which will easily understand Web services, management of business processes or more generally SOA through examples and very well detailed.




 Poster une réponse

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 08/08/2009 à 15:39
Bonjour,

Le terme SOA est très en vogue ces dernières années, et les concepts se déclinent de manière exhaustive en Java.

Il existe un ouvrage édité par O'Reilly UK intitulé Java SOA Cookbook qui se propose d'illustrer la SOA par l'intermédiaire de petites recettes pratiques.

Voici ce qu'en pense le responsable bénévole Spring :
Pour apprécier à sa juste valeur le livre Java SOA Cookbook, il faut bien comprendre que tous les termes du titre sont importants. Pour ma part, je me suis attaché uniquement à Java SOA, et j'ai été un peu surpris...

(...)

Java SOA Cookbook, une fois la surprise passée du format, est un excellent livre qui permettra d'appréhender facilement les Web services, la gestion de processus métier ou, de manière plus générale, la SOA par le biais d'exemples concrets très bien détaillés.

Retrouvez la critique complète

Certains ont eu l'occasion de feuilleter ce livre ?
Avatar de elitost elitost - Expert éminent https://www.developpez.com
le 08/01/2010 à 23:01
Eh bien, j'ai pu lire ce livre et en rédiger une critique pour Developpez.

C'est un très bon livre sur la SOA, on y trouvera la trousse à outils nécessaire pour résoudre ses problèmes et répondre aux questions sur le sujet.

Il y a énormément de sujets abordés (plusieurs dizaines), le développeurs comme le concepteur SOA y trouvera forcemment son bonheur.

Et vous ? vous en avez pensé quoi ?
couverture du livre Java 6 : Entraînez-vous et maîtrisez Java par la pratique

Note 3.5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java 6 : Entraînez-vous et maîtrisez Java par la pratique

Collections : Les TP Informatiques

de

Résumé de l'éditeur

Ce livre s'adresse aux développeurs, chefs de projet ou responsables techniques désireux de découvrir et maîtriser Java 6 à travers des exercices courts et variés. Avec pour objectif d'aller au-delà de la théorie et de vous inculquer dès le départ les bons réflexes, il vous fera gagner en productivité. Si vous connaissez une version antérieure et souhaitez avoir une vision rapide de la nouvelle plateforme, vous apprécierez cette méthode d'apprentissage par l'exemple dont les solutions sont toujours appuyées par de brefs rappels de cours. Les travaux pratiques proposés couvrent l'essentiel de Java 6 : bases de la syntaxe, programmation objet, connaissances de l'API. Ils reprennent les points indispensables propres à Java (définition d'une classe, héritage, abstraction, polymorphisme, annotations) mais également les nouveautés qui font de Java 6 une source inépuisable de possibilités (web services, scripting…). Au-delà des exercices, ce livre constitue un socle de références (modèles de programmation) que vous pourrez reprendre à loisir dans vos travaux quotidiens. Les éléments nécessaires à la réalisation des exercices sont en téléchargement sur le site de l'éditeur.

119 QCM - 59 travaux pratiques et leurs corrigés - Plus de 23 H de mise en pratique.

Édition : ENI - 300 pages , 1er mai 2007

ISBN10 : 2746036134 - ISBN13 : 9782746036130

Commandez sur www.amazon.fr :

25.65 € TTC (prix éditeur 27.00 € TTC)
  • Chapitre 1 : Le langage
    • Pré-requis
    • Contrôle de flux
    • Exception
    • Type de données
    • Classe
    • Interface
    • Classe anonyme et interne
    • Accessibilité
    • Énumération
    • Ellipse
  • Chapitre 2 : Les collections
    • Pré-requis
    • java.util.List
    • java.util.Map
    • java.util.Set
    • java.util.Queue
  • Chapitre 3 : Les entrées/sorties
    • Pré-requis
    • Les flux binaires
    • Accès aléatoire
    • Les filtres
    • Les flux de caractères
    • Les flux mémoires
    • La sérialization
    • N/IO
  • Chapitre 4 : JDBC - Base de données
    (list]
  • Pré-requis
  • Installation d'une base de données MySQL avec accès ODBC
  • Accès en lecture et écriture par Statement
  • Accès en lecture et écriture par PreparedStatement
  • Les procédures stockées
  • Les DataSources
[*]Chapitre 5 : Threads
  • Pré-requis
  • La classe Thread
  • Synchronisation multithreads
  • java.util.concurrent.ExecutorService
  • java.util.concurrent.ArrayBlockingQueue
  • java.util.concurrent.Exchanger
  • java.lang.management.ThreadInfo
[*]Chapitre 6 : Swing
  • Pré-requis
  • Construction d'un répertoire téléphonique
  • Construction d'un éditeur de texte
  • Mise à jour asynchrone d'une table
  • Installation d'un lookAndFeel
  • Actions
  • Tri et table
  • SystemTray
[*]Chapitre 7 : JAXP - XML
  • Pré-requis
  • SAX
  • DOM
  • XPath
  • Transformation
  • JAXB
  • StAX
[*]Chapitre 8 : Classes utilitaires
  • Pré-requis
  • java.lang.ProcessBuilder
  • java.util.Scanner
  • Expressions régulières
  • Préférences
  • Logs
  • Console
  • Annotations
  • Scripts
[*]Chapitre 9 : Java Web Start
  • Pré-requis
  • Exécution d'une application
  • javax.jnlp.ServiceManager
[*]Chapitre 10 : Services Web
  • Pré-requis
  • Création et usage d'un service Web
  • Usage d'un service Web sur un site marchand
[*]Chapitre 11 : Accès réseaux
  • Pré-requis
  • Socket
  • HTTP
  • Cookie
[/list]
Critique du livre par la rédaction yolepro le 1er mars 2009
Quand j'ai lu ce livre, je cherchais à me mettre à jour sur Java (j'en étais resté à la 1.4) et donc je me suis dit que des cas pratiques étaient souvent plus intéressants que de longs discours théoriques.
Certes, les cas sont très pratiques, mais malheureusement les fonctionnalités de Java 5 / 6 ne sont pas très présentes. Un sous-chapitre très succint sur les Annotations, un Chapitre entier sur JDBC sans parler des nouvelles fonctionnalités de la 6, rien non plus sur les nouveautés liées aux Collections. Il y a tout de même un chapitre sur les web services ainsi qu'un sous-chapitre parlant de Stax et des scripts. On ne peut bien sur pas voir tous les aspects de Java dans un livre de 300 pages, mais dans ce cas, le titre du livre me semble mal adapté.

Je n'ai pas eu l'occasion de lire d'autre livre de cette collection mais la mise en page est très claire. Je n'ai pas eu trop de difficulté à « switcher » des énoncés aux corrections, grâce aux hauts de pages qui sont intuitifs. Le jeu des FAQs pour se tester avant chaque chapitre est très judicieux, c'est un bon moyen de faire un bilan rapide de compétence et de s'informer plus particulièrement par soi même le cas échéant (même si certaines réponses données sont discutables car non exhaustives, c'est d'autant plus gênant lorsque le public visé est débutant).
J'ai été aussi surpris par un vocabulaire approximatif. Pour ma part, il ne me semble pas assez précis, surtout lorsqu'il s'agit de vulgariser un langage (on ne parle pas d'accesseurs, ni d'instance de classe,…). Cela ne gênera toutefois pas les non puristes.

Pour finir, les corrigés sont pédagogiques et bien rédigés, je regrette juste qu'ils se concentrent trop sur la description du corrigé (on décrit ce qu'on fait) et non sur la démarche utilisée (pourquoi utiliser cette Classe plutôt qu'une autre, quel intérêt d'utiliser ce pattern, pourquoi je prends cette API et pas celle là,.). Bref, à la fin du TP on maîtrise le sujet posé, mais on n'a malheureusement pas le recul nécessaire pour l'appliquer dans un projet.
Surtout que certaines petites erreurs viennent entacher la poursuite des TPs (exemple du chapitre 7 où il manque des informations sur les fichiers styles ou une méthode main pour tester une classe).
En l'état, impossible de faire fonctionner le TP complètement. Heureusement que les corrigés sont accessibles en ligne sur le site des éditions ENI.
Encore faudrait-il le savoir !! Cela n'est écrit nulle part dans le livre. J'ai passé 2h à trouver la solution avant de voir une minuscule phrase sur la page arrière du bouquin parlant des corrigés en ligne.
Vous l'aurez compris, je n'ai pas été très tendre avec ce livre, mais c'est tout simplement parce que, comme beaucoup de personnes qui achètent ce genre de livre, je suis exigeant. Malgré cela, j'ai passé un bon moment et j'ai appris certaines choses « concrètes » ce qui au final est ce que l'on attend d'un livre de TP.


couverture du livre Les Cahiers du programmeur Java EE 5

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Les Cahiers du programmeur Java EE 5

de
Public visé : Intermédiaire

Résumé de l'éditeur

Ce cahier détaille la conception d'un site de commerce électronique avec UML et Java EE 5. Inspirée du Java Petstore, l'étude de cas se construit au fil des chapitres en appliquant les spécifications Java EE 5 : EJB 3.0, JPA 1.0, Servlet 2.5, JSP 2.1, JSF 1.2, Web Services 1.2, JAXB 2.0, JAX-WS 2.0, JavaMail 1.4, JMS 1.1. L'application est déployée dans le serveur GlassFish et utilise la base de données Derby.

Cet ouvrage s'adresse aux architectes et développeurs confirmés qui veulent découvrir les nouveautés de Java EE 5 ou migrer leurs applications J2EE 1.4 existantes. Il montre comment s'imbriquent les différentes API de Java EE 5 dans une application internet-intranet.

Édition : Eyrolles - 329 pages , 1re édition, 1er mai 2009

ISBN10 : 2212120389 - ISBN13 : 9782212120387

Commandez sur www.amazon.fr :

34.02 € TTC (prix éditeur 36.00 € TTC) livraison gratuite !
  • Présentation de l'étude de cas
  • L'architecture de l'application
  • Outils et installation
  • Objets persistants
  • Traitements métier
  • Exécution de l'application
  • Interface web
  • Gestion du panier électronique
  • Conserver l'état dans l'application
  • Echanges
  • Traitements asynchrones
  • Annexes
    • Spécifications EE5
    • Tâches ANT
    • Sigles et acronymes
    • EJB2


Critique du livre par la rédaction afrikha le 1er janvier 2008
Ce livre est une réussite dans la mesure où il atteint les objectifs qu'il s'était fixé, à savoir faire découvrir Java EE 5 aux architectes et développeurs confirmés. L'ouvrage s'articule autour de la réalisation d'un site de commerce électronique ce qui a pour avantage d'éclairer à chaque chapitre les concepts théoriques vus précédemment, et permet de mesurer d'une manière précise les apports de Java EE 5 dans la pratique, sans pour autant rentrer dans les détails de chaque spécification abordée. Pour cela l'auteur a pris soin de mettre des références fort pertinentes.

La progression du livre est très pédagogique ce qui est un tour de force compte tenu de l'étendue du sujet : l'auteur parvient à expliquer au fur et à mesure différents concepts et leur imbrication sans sauter les étapes.

Autre point positif, le site de l'auteur est doté d'un forum et permet ainsi de discuter de tel ou tel aspect du livre.

Si je devais relever des points négatifs, je dirais que la présence systèmatique du code des annotations peut paraître inutile compte tenu d'une certaine redondance, mais bon ça reste anécdotique.

Pour conclure, c'est un livre très abouti, à commander donc et à recommander.
Critique du livre par la rédaction Yann D'Isanto le 1er août 2007
Bien que des notions élémentaires de la plateforme Java EE soient suffisantes pour aborder ce livre, il requiert toutefois d'avoir de solides connaissances de la plateforme Java SE ainsi que de bons acquis en UML et XML.

Cet ouvrage tient toutes ses promesses. Il réussit le tour de force d'aborder un nombre impressionant d'APIs de la plateforme Java EE de façon claire et concise. Celles-ci ne sont donc pas abordées dans leur intégralité (un livre ne suffirait pas) mais elles le sont suffisamment pour commencer à savoir s'en servir et nous donner l'envie d'aller plus loin. Ces APIs font toutes partie des spécifications constituant Java EE 5 (EJB3, JPA, JSP, JSF, JSTL, JMS, JAX-WS, JAXB, JavaMail, ...). Pour les personnes voulant approfondir ces notions, l'auteur a eu la très bonne idée de donner, tout au long de son ouvrage, des références sur les sujets qu'il aborde.

Le livre est construit autour du développement d'une application web complète (de type site marchand). C'est cette approche qui permet de couvrir de façon concrète le large panel d'APIs abordées.

Autre point intéressant, la première partie est consacrée à la conception de l'application où l'auteur partage son expérience et son savoir faire en expliquant ses choix (attitude qu'il adopte tout au long du livre).

Agréable à lire et au contenu d'une grande qualité, cet ouvrage m'apparaît être un indispensable pour tout développeur Java EE désireux de connaître la plateforme Java EE 5.

Vous trouverez également sur le site de l'auteur les sources complètes du livre ainsi qu'un espace de discussion autour du livre et du code de l'application.


couverture du livre Filthy Rich Clients

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Filthy Rich Clients

de

Résumé de l'éditeur

Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. They suck the user in from the outset and hang on to them with a death grip of excitement. Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop JavaT Applications shows you how to build better, more effective, cooler desktop applications that intensify the user experience.

The keys to Filthy Rich Clients are graphical and animated effects. These kinds of effects provide ways of enhancing the user experience of the application through more attractive GUIs, dynamic effects that give your application a pulse, and animated transitions that keep your user connected to the logical flow of the application. The book also discusses how to do so effectively, making sure to enrich applications in sensible ways.

Édition : Prentice Hall PTR - 608 pages , 1re édition, 19 août 2007

ISBN10 : 0132413930 - ISBN13 : 9780132413930

Broché

Commandez sur www.amazon.fr :

0.00 € TTC (prix éditeur 0.00 € TTC)
  • Graphics and GUI Fundamentals
    • Desktop Java Graphics APIs: Swing, AWT, and Java 2D
    • Swing Rendering Fundamentals
    • Graphics Fundamentals
    • Images
    • Performance
  • Advanced Graphics Rendering
    • Composites
    • Gradients
    • Image Processing
    • Glass Pane
    • Layered Panes
    • Repaint Manager
  • Animation
    • Animation Fundamentals
    • Smooth Moves
    • Timing Framework: Fundamentals
    • Timing Framework: Advanced Features
  • Effects
    • Static Effects
    • Dynamic Effects
    • Animated Transitions
    • Birth of a Filthy Rich Client
Critique du livre par la rédaction Fabrice Bouyé le 1er mai 2008
Il s'agit là d'un livre que j'ai longtemps attendu ; en fait, je l'attendais même sans le savoir depuis que j'ai commencé à programmer des applications clientes utilisant Swing.
En effet, l'intégration de Java2D lors de la sortie de Java 2 (1.2) dès 1998 a permis d'étendre considérablement les capacités de la plateforme Java en ce qui concerne les effets et traitements d'images et ce de manière totalement portable d'un système à l'autre. De même, Swing, sorti à la même époque, permettait enfin de faire des interfaces graphiques en s'affranchissant des limites de l'AWT, mieux Swing reposait sur Java2D. Cependant, s'il peut-être aisé de trouver des informations, cours ou livres sur Java2D et plus encore sur Swing, il est resté assez difficile de trouver des exemples d'intégration avancée entre ces deux bibliothèques hormis les démos fournies par Sun avec le JDK. Et même celles-ci ne montrent pas comment Java2D peut, littéralement, transformer et transcender Swing.

Tous les programmeurs qui ont eut à créer leur propre composant Swing ou à modifier l'affichage d'un composant existant ont du à un moment ou à un autre écrire un peu de Java2D dans leur code d'affichage ; cependant nous sommes tous généralement restés confinés à des appels des primitives pour tracer des lignes ou encore remplir de simples polygones avec des couleurs unies, personne ne sachant vraiment trop comment combiner les deux bouts ensemble. Ainsi, tandis que les nouvelles versions de Windows et MacOS se succédaient les unes aux autres apportant à chaque fois leur lot de nouveaux effets graphiques cools, les interfaces graphiques Java restaient portables, certes, mais étaient également globalement toujours aussi grises et ennuyantes.
Ne craignez rien ! Romain Guy (Gfx) et Chet Haase, les deux superstars des très populaires présentations orientées Desktop des conférences JavaOne de ces dernières années viennent ENFIN à notre rescousse ! Si vous avez déjà été explorer les tonnes d'exemples et d'astuces que Gfx a proposés sur ce site et notre forum Java ou sur son blog ou ceux que Chet a postés sur le sien, une bonne partie est condensée dans ce livre (en anglais). Avec un langage simple, clair et non dénué d'humour, les deux auteurs nous présentent tour à tour tout ce qui est nécessaire pour faire que votre application Swing sorte du lot et accroche votre utilisateur ; qu'elle puisse s'intégrer aux designs plus riches en couleurs et autres effets graphiques ainsi qu'aux nouveaux standards en matière d'ergonomie ou de présentation des OS d'aujourd'hui.

Dans la première partie de l'ouvrage, nous retrouveront, outre les conseils habituels de "bonne conduite" en ce qui concerne la programmation Swing, des astuces pour bénéficier d'optimisations des performances du rendu. La seconde partie aborde des concepts plus avancés tels que les Composites (ce qui se passe lors de la superposition de 2 rendus), les gradients de couleur, les filtres permettant de faire des traitements sur des images mais également certains concepts Swing nécessaires à l'intégration de ces effets dans une IHM tels que le Glass Pane ou encore le Repaint Manager. La troisième partie touchera quant à elle à l'animation en présentant les concepts de base de ce qui fait une animation puis en abordant le Timing Framework auquel participe Chet Haase. La dernière partie du livre aborde enfin les effets qu'il est possible de créer en combinant tout ce qui a été vu au cours des chapitres précédents ainsi que les différentes étapes de la conception et de la création d'un client "obscènement" riche (traduction libre de Filthy Rich Client).
Attention toutefois, ce livre est uniquement disponible en anglais. Il supposera que vous connaissez déjà les fondamentaux de Swing et que vous avez également quelques connaissances de la manière de dessiner, ce serait-ce qu'une ligne droite ; ce n'est en aucun cas un ouvrage d'introduction à Java2D. De plus, on pourra parfois regretter que certaines images illustrant les chapitres soient un peu petites et que l'impression en niveaux de gris ne permette pas toujours de se rendre compte du résultat final de certains des effets, notamment ceux de surbrillance.

Cependant, ce livre reste une réussite en tout point et est un "must have" pour toute personne qui désire améliorer l'apparence de son application Swing que ce soit à petite dose pour l'épicer juste ce qu'il faut ou au contraire en balançant tout le "bling-bling" d'un seul coup à la face de l'utilisateur. À noter que les exemples accompagnant chacun des chapitres du livre sont directement et gratuitement téléchargeables sur le site http://filthyrichclients.org/


couverture du livre Java Persistence et Hibernate

Note 4 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java Persistence et Hibernate

de
Public visé : Intermédiaire

Résumé de l'éditeur

Gestion optimale de la persistance dans les applications Java/JEE
Avec JPA (Java Persistance API), composante essentielle des spécifications EJB 3, le monde Java/JEE dispose enfin d'un standard fiable et efficace pour la gestion de la persistance et du mapping objet-relationnel. Largement inspiré du pragmatisme d'Hibernate et tirant parti d'une avancée majeure de Java SE 5 (les annotations), Java Persistance privilégie la simplicité de développement en plaçant les métadonnées de persistance au coeur du code Java SE ou EE et en reléguant les descripteurs XML aux cas extrêmes.

Un livre pratique illustré d'une étude de cas détaillée
A la fois pratique et didactique, cet ouvrage décrit les différentes facettes de l'API et de son implémentation Hibernate en montrant comment les mettre en oeuvre à travers une étude de cas déclinée au fil des chapitres. Il insiste tout particulièrement sur la définition des annotations et l'utilisation du gestionnaire d'entités en environnement Java SE ou Java EE, ainsi que sur les aspects méthodologiques et sur les questions de performances : mapping de modèles objet ou de schémas relationnels complexes, récupération efficace des objets persistants, gestion de la concourance et persistance transitive, configuration des pools de connexions et des caches de second niveau, etc.
L'ouvrage montre également comment repousser les limites de Java Persistence API grâce aux possibilités d'optimisation et aux extensions offertes par Hibernate.

Édition : Eyrolles - 365 pages , 1re édition, 18 décembre 2007

ISBN10 : 2212122594 - ISBN13 : 9782212122596

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • Préface
  • Remerciements
  • Table des matières
  • Avant-propos
  • Persistance et mapping objet-relationnel
  • Démarrer avec Java Persistence
  • Métdadonnées et mapping des entités
  • Héritage, polymorphisme et modèles complexes
  • Méthodes de récupération des entités
  • Création, modification et suppression d'entités
  • Obtenir et manipuler le gestionnaire d'entités
  • Fonctionnalités de mapping avancées
  • La suite Hibernate Tools
  • Projets annexes Java Persistence/Hibernate
  • Index
Critique du livre par la rédaction TheLeadingEdge le 1er octobre 2008
Cet ouvrage est certainement le meilleur de ceux qu'il m'ait été donné de lire sur le sujet.
Agréable à lire, illustré de nombreuses captures d'écran qui renforcent les explications données, c'est un livre trés détaillé qui couvre l'ensemble des possibilités d'Hibernate.
Pour autant, même si le public visé est clairement celui des développeurs, il couvre bien plus que le simple aspect programmation.
Tout au long du livre l'auteur s'attache à nous proposer une mise en oeuvre qui va bien au delà du simple mapping mécanique entre une base de données et le modèle métier.
Pour certains cas notamemnt, il étudie plusieurs possibilités de mapping, ou de modélisation, et montre les conséquences sur les autres couches. Les stratégies de chargement les plus adaptées en fonction des différents contextes qu'il est possible de rencontrer sont également abordées dans le détail. Les concepteurs et les architectes devraient apprécier et en tirer sans aucun doute des renseignements utiles.
Mon seul regret concerne la partie technique : l'auteur a choisi de n'utiliser que les annotations. Personnellement je trouve que c'est dommage. J'aurai bien aimé trouver les exemples en XML.
Critique du livre par la rédaction Baptiste Wicht le 1er mars 2008
Comme son titre l'indique, cet ouvrage présente Java Persistence API (JPA) avec Hibernate comme fournisseur de persistance. Ce livre ne va pas se contenter de couvrir la partie JPA, il va également explorer des fonctionnalités spécifiques à Hibernate qui permettront d'aller plus loin que les spécifications JPA.
L'auteur commence par nous présenter la problématique de la persistance et l'évolution des librairies facilitant cette tâche au fil des ans jusqu'à l'avènement de JPA. Il nous montre également les avantages d'un outil de mapping objet-relationnel. Il présente ensuite ce qu'est JPA et c'est qu'est Hibernate.

On continue avec beaucoup de pratique avec les chapitres 3 et 4. Dans ces chapitres, on va apprendre à annoter nos entités pour configurer le mapping objet-relationnel. J'ai trouvé ces chapitres très complets, mais ils vont un peu vite, ce qui est parfois déroutant car on passe d'une notion à une autre très rapidement. Ils présentent également les notions complexes comme l'héritage et le polymorphisme sur les entités.

Les deux chapitres suivants traitent quand à eux des méthodes de récupération des entités ainsi que de la façon de les gérer, c'est-à-dire les modifier, les supprimer et les créer. Ces 2 chapitres sont très complets et plus simples à suivre que les précédents. La partie récupération traite bien de toutes les manières de récupérer des objets (EJB-QL, SQL natif, Criteria). On y parle également des transactions et de la gestion des accès concourants.
Vient ensuite un chapitre sur la gestion de l'EntityManager. C'est-à-dire comment le créer ou récupérer et comment gérer son cycle de vie tout au long de l'exécution de l'application. Il traite des différentes stratégies de gestion de l'EM ainsi que du traitement par lot ou de l'utilisation dans un batch. On y traite également de l'utilisation des EJB3 pour gérer l'EntityManager. Comme je n'ai pas pu installer JBoss intégré, je n'ai pu tester cette partie. Avec le chapitre 8, on entre dans le cour d'Hibernate qui permet de faire plus de choses que la spécification JPA. On verra donc les formules, les procédures stockées, les types personnalisés, les clés composées et encore d'autres notions avancées de mapping avancés. Ces 2 chapitres traitent de notions assez complexes, mais ils les traitent bien, et on s'y retrouve facilement.

L'avant dernier chapitre parle de la suite Hibernate Tools. Il traite surtout du plugin pour Eclipse permettant de faciliter le développement JPA/Hibernate et de SchemaExport, l'utilitaire permettant de générer le schéma de la base de données. Le dernier chapitre, quant à lui, traite des autres projets autour d'Hibernate. On va notamment s'intéresser aux pools de connexion et au gestionnaire de cache de second niveau ainsi qu'à la validation des entités.
En conclusion, j'ai trouvé certaines notions de ce livre complexes à mettre en oeuvre et le plan du livre laisse parfois à désirer. L'auteur va parfois un peu trop vite et le lecteur se retrouve emmêlé entre plusieurs notions parfois très différentes. Néanmoins, ce livre présente très bien les différentes notions de JPA ainsi que les aspects avancés qui nécessitent Hibernate. Mais je ne le conseillerais pas aux débutants.


couverture du livre Programmer en Java

Note 4 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (3)
 
 

Programmer en Java

de

Résumé de l'éditeur

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 quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction au développement Web avec les servlets Java et les JSP. Chaque notion nouvelle et chaque fonction du langage sont illustrées de programmes complets dont le code source est fourni sur le CD-Rom d'accompagnement. L'environnement de développement Eclipse, également fourni sur le CD-Rom, vous permettra de tester ces exemples et de développer vos propres programmes Java. L'accent est mis dans cette 5e édition sur les nouveautés des versions 5 et 6 de Java Standard Edition : programmation générique, types énumérés, annotations (chapitre nouveau), nouvelles possibilités de la classe File, nouveau gestionnaire Grouplayout, nouvelles interfaces et classes de collections (Queue, Deque, ArrayDeque, NavigableSet, NavigableMap), fonctionnalités permettant de professionnaliser une application (classes Desktop et Console, action sur la barre des tâches du système), etc. Lorsque nécessaire, les exemples de code ont été fournis en deux versions : une version exploitant les possibilités nouvelles de Java SE 5 et 6 et une version compatible avec les versions antérieures.

Biographie de l'auteur

Ingénieur informaticien au CNRS, Claude Delannoy possède une grande pratique de la formation continue et de l'enseignement supérieur. Réputés pour la qualité de leur démarche pédagogique, ses ouvrages sur les langages et la programmation totalisent plus de 250 000 exemplaires vendus.

Édition : Eyrolles - 799 pages , 5eédition, 11 octobre 2007

ISBN10 : 2212122322 - ISBN13 : 9782212122329

Commandez sur www.amazon.fr :

33.25 € TTC (prix éditeur 35.00 € TTC)
  • Présentation de Java
  • Généralités
  • Les types primitifs de Java
  • Les opérateurs et les expressions
  • Les instructions de contrôle de Java
  • Les classes et les objets
  • Les tableaux
  • L'héritage
  • Les chaînes de caractères et les types énumérés
  • La gestion des exceptions
  • Les threads
  • Les bases de la programmation graphique
  • Les contrôles usuels
  • Les boîtes de dialogue
  • Les menus, les actions et les barres d'outils
  • Les évènements de bas niveau
  • Les gestionnaires de mise en forme
  • Textes et graphiques
  • Les applets
  • Les flux et les fichiers
  • La programmation générique
  • Les collections et les algorithmes
  • Programmation Java côté serveur : servlets et JSP
  • L'introspection et les annotations
Critique du livre par la rédaction Julien Plu le 1er août 2008
Ce livre est vraiment instructif car il explique vraiment bien ce que peut être le langage Java. Le débutant y trouvera un très bon cours pour le Java, la POO, les graphiques avec SWING, et même pour le développement web avec JSP et d'autres outils / techniques / … .
Ce livre sera aussi une très bonne référence pour les initiés à Java car il contient une annexe très bien fournie et des exemples de code tout faits qui peuvent beaucoup servir.
Une chose très constructive aussi : beaucoup de remarques sur certains points communs avec le langage C++, pour que l'on puisse bien voir les différences ou similitudes avec ce langage. J'ai également beaucoup apprécié le chapitre sur la programmation générique qui est vraiment bien construit. Sinon, mon seul regret est qu'il manque un chapitre sur JDBC qui est très utile et aurait pu introduire une partie BDD.
Conclusion : Ce livre est pour moi LA référence en français du langage Java pour ceux qui voudraient l'apprendre.
C'est également un très bon aide mémoire pour les initiés car il donne tout ce qu'il faut pour être totalement autonome afin de développer ses propres applications et appréhender en toute sérénité la volumineuse documentation Java.
Critique du livre par la rédaction Faith's Fall le 1er juillet 2008
Étant développeur C / C++ de base et désirant migrer vers le langage Java, je me suis intéressé à l'ouvrage « Programmer en Java » de Jean-Claude Delannoy dans sa 5e Édition. La première approche de ce livre est plutôt bonne, il regroupe la plupart des bases du langage comme les class, les threads, les boucles et même l'interface graphique de type Swing sur plusieurs chapitres. On peut noter également la présence d'un chapitre dédié à Java EE qui donne des idées sur la programmation orientée Web avec les pages dynamiques JSP ou les servlets.
Avec plus de détail, ce livre montre une approche très pratique et scolaire sur les divers points du langage Java avec des exemples de code expliqués. J'ai également apprécié les diverses comparaisons entre le Java et le langage C++ qui permette de voir comment le Java est assez proche du C++ et permet également aux développeurs C++ de ne pas être dépaysé par le Java.
Mon avis sur cet ouvrage est très positif, cependant, il est vraiment réservé pour apprendre les bases et ce limite uniquement aux aspects les plus importants du langage Java, ce qui signifie que si vous cherchez des informations sur des techniques de programmation avancés, ce livre ne sera pas fait pour vous. Par contre pour apprendre ou migrer sur le Java, ce livre est un réel plus à avoir à côté de soi.
Critique du livre par la rédaction Eric REBOISSON le 1er février 2008
Un ouvrage très instructif pour tous ceux qui voudraient se lancer dans Java. Ce livre traite de tous les points essentiels du langage : les origines de Java, les types, mots clés, POO, threads, IHM, programmation Web, etc. Claude Delannoy, l'auteur de "Programmer en Java" publie là une 5ème édition de ce qu'on peut appeler maintenant un best-seller. Je vous livre maintenant mes impressions :

Les plus :
  • Un sommaire très détaillé qui pour moi est un bon indicateur sur le contenu
  • La rédaction et le style simple facilitant la bonne compréhension
  • Un contenu de qualité et fiable et les parallèles avec C/C++
  • Plus de 250 000 ouvrages vendus, ce n'est pas un hasard


Les moins :
  • La mise en page trop sobre (mais les goûts et les couleurs, vous connaissez la suite…)
  • Certains chapitres ne sont vraiment que des petites introductions (mais on comprendra que l'ouvrage n'a pas non plus vocation à l'exhaustivité)


Au final, sans être LE livre indispensable au développeur Java qui se respecte, il est je pense un très bon livre en français sur le développement Java pour ceux que l'anglais rebuterait.
Le petit bonus : pour chaque plate-forme (Mac, Windows et Linux/Unix) un CD contenant Eclipse Europa, le JDK en version 6, et les codes sources du livre, ainsi les malheureux de la connexion internet ne seront pas en reste.

Je conseille donc vivement la lecture de "Programmer en Java" de Claude Delannoy, non seulement au débutant Java, mais aussi aux initiés qui chercheraient un référent documentaire.


couverture du livre Java Generics

Note 3.5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java Generics

and Collections

de
Public visé : Intermédiaire

Résumé de l'éditeur

This comprehensive guide shows you how to master the most important changes to Java since it was first released. Generics and the greatly expanded collection libraries have tremendously increased the power of Java 5 and Java 6. But they have also confused many developers who haven't known how to take advantage of these new features. Java Generics and Collections covers everything from the most basic uses of generics to the strangest corner cases. It teaches you everything you need to know about the collections libraries, so you'll always know which collection is appropriate for any given task, and how to use it. Topics covered include:

* Fundamentals of generics: type parameters and generic methods
* Other new features: boxing and unboxing, foreach loops, varargs
* Subtyping and wildcards
* Evolution not revolution: generic libraries with legacy clients and generic clients with legacy libraries
* Generics and reflection
* Design patterns for generics
* Sets, Queues, Lists, Maps, and their implementations
* Concurrent programming and thread safety with collections
* Performance implications of different collections Generics and the new collection libraries they inspired take Java to a new level. If you want to take your software development practice to a new level, this book is essential reading.

Java Generics and Collections covers everything from the most basic uses of generics to the strangest corner cases. It teaches you everything you need to know about the collections libraries, so you'll always know which collection is appropriate for any given task, and how to use it.

Édition : O'Reilly - 273 pages , 1re édition, 1er novembre 2007

ISBN10 : 0596527756 - ISBN13 : 9780596527754

Broché

Commandez sur www.amazon.fr :

21.27 € TTC (prix éditeur 25.01 € TTC)
  • Introduction
  • Subtyping and wildcards
  • Comparison and bounds
  • Declaration
  • Evolution, not Revolution
  • Reification
  • Reflection
  • Effective Generics
  • Design Patterns
  • The main interfaces of the Java Collections Framework
  • Preliminaries
  • The Collection interface
  • Sets
  • Queues
  • Lists
  • Maps
  • The Collections class
Critique du livre par la rédaction Baptiste Wicht le 1er février 2008
Comme son nom l'indique, ce livre couvre les génériques, introduits dans Java 5 et le framework de collection Java. Ces deux thèmes sont distinctement séparés en 2 parties différentes, mais, ces éléments étant intrinsèquement liés, on retrouve bien entendu des notions de génériques dans la partie collection et vice-versa.

Pour commencer, je vais parler des différentes parties de ce livre et de leurs contenus respectifs et je ferai ensuite part de mes impressions concernant le concernant.

Les auteurs débutent, donc, par la partie sur les Generics. Le premier chapitre présente très brièvement les différentes notions utilisées dans ce livre, à savoir, les Generics, la boucle ForEach, l'(Un)Boxing, les types et les méthodes génériques ainsi que les assertions.
Les chapitres suivants nous parlent du sous-typage, des Wildcards de génériques, de l'usage des generics dans les comparaisons et des arguments génériques multiples.

Le chapitre ? lequelest un un peu plus pratique. Il va nous apprendre à utiliser les Generics dans nos déclarations et classes, constructeurs et méthodes. Et donc implicitement à créer nos premières classes.
Le chapitre 5 enchaîne sur la manière dont ont été implémentés les generics de telle sorte à conserver la compatibilité ascendante. Ce chapitre est très utile car il présente les techniques pour utiliser des librairies normales avec une application ou vice-versa et nous met en garde contre les différents problèmes pouvant subvenir.

Le chapitre suivant est à nouveau très technique et explique en détail, le système de "Reification" des types paramétrés. Il présente les différents principes à respecter lors de l'utilisation de classes génériques.
Les chapitres suivants sont plus pratiques. Le premier traite de l'api de "Reflection" pour les generics et des generics pour "Reflection". Ou comment utiliser les generics avec l'api de reflection et l'amélioration de l'api avec les generics. Le chapitre qui suit ("Effective Generics") traite directement des problèmes principaux pouvant subvenir en utilisant les generics, dont la conservation de la compatibilité des binaires.
Enfin, le dernier chapitre sur les generics traite des design pattern pour lesquels il est intéressant de les utiliser.
J'ai trouvé cette première partie très compliqué à assimiler et assez technique. Ceci est peut-être dû à mon niveau d'anglais qui n'est pas parfait, mais c'est le premier livre anglophone que j'ai autant de peine à suivre. Il faut également avouer que le sujet est très complexe quand on s'y plonge. J'ai du parfois m'y reprendre à plusieurs fois pour comprendre une notion. Néanmoins, il se révèle très complet et est une très bonne source d'informations sur les generics.

La partie suivante est consacrée à l'étude du framework de Collections de Java. Les 2 premiers chapitres présentent les principales interfaces du framework et les principaux concepts utilisés dans le framework, comme les iterators, les performances ou encore le multi-threading.
Le chapitre suivant présente en détail l'interface Collection qui est l'interface de référence pour presque toutes les collections du framework. Les principales méthodes et constructeurs sont présentées en détails ainsi que l'implémentation de Collection.

Les quatre chapitres suivants traitent des principales implémentations du framework. A savoir, les Sets, les Queues, les Lists et les Maps. Chaque type de collection est présenté tout d'abord de manière générale et ensuite chacune des implémentations de ce type est présentée en détails et une conclusion à la fin de chaque chapitre nous aide à choisir une implémentation.

Le dernier chapitre traite de la classe Collections qui offre une série de méthodes pour traiter les collections. Les principales méthodes sont présentées et expliquées. Un cas d'utilisation est presque toujours représenté.
J'ai trouvé cette deuxième partie mieux organisée que la première et plus accessible. Néanmoins, elle se révèle toujours assez difficile à comprendre et à suivre bien que le sujet soit plus simple. J'ai beaucoup aimé la présentation des différentes implémentations qui se révèle très complète et très utile dans le choix d'une implémentation.

En conclusion, je dirais que ce livre n'est pas adapté aux débutants qui veulent débuter dans les generics, mais plutôt à un public avancé qui désire aller jusqu'au bout du sujet. Il se révèle en effet très technique et je n'ai jamais réussi à m'y plonger très longtemps. Néanmoins, c'est une excellente source d'informations du fait du nombre de sujets traités. Un bon livre donc, mais pas à mettre entre toutes les mains.


couverture du livre Rich Client Programming

Note 5 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (1)
 
 

Rich Client Programming

Plugging into the Netbeans Platform

de

Résumé de l'éditeur

The NetBeans platform, is the core of the NetBeans integrated development environment (IDE) and an application framework for developing rich desktop applications (ie client applications). Using a NetBeans IDE simplifies the creation and maintenance of software features. NetBeans is free and its code is freely available and what makes NetBeans-based applications special is that they are truly cross-platform which enables developers to focus on the essentials that are specific to their apps and build them more rapidly. This book focuses on using the NetBeans Platform as a framework for creating rich client applications that can be written once and then run on ANY operating system. Much information about the NetBeans Platform is already available, but there is no single up-to-date source that demonstrates how to make use of the whole platform. This book, which is the most frequent request from NetBeans users, pulls together years worth of accumulated wisdom, best practices, and practical information…all in one place.

The open-source NetBeans Platform is an extraordinarily powerful framework for building "write once, run anywhere" rich client applications. Now, for the first time since the release of NetBeans IDE 5.0, there's a comprehensive guide to rich client development on the NetBeans Platform. Written for Java developers and architects who have discovered that basic Swing components are not enough for them, this book will help you get started with NetBeans module development, master NetBeans' key APIs, and learn proven techniques for building reliable desktop software. Each chapter is filled with practical, step-by-step instructions for creating complete rich client applications on top of the NetBeans Platform and plugins for NetBeans IDE.

Rich Client Programming's wide-ranging content covers
  • Why modular development makes sense for small, medium, and large applications
  • Using NetBeans to accelerate development and improve efficiency
  • Leveraging NetBeans productivity features, from the Component Palette to Code Completion
  • Leveraging NetBeans' modular architecture in your own applications
  • Implementing loosely coupled communication to improve code maintainability and robustness
  • Managing user- and system-configuration data
  • Building reloadable components with solid threading models
  • Constructing sophisticated multiwindow applications and presenting rich data structures to users
  • Adding user-configurable options
  • Integrating Web services with NetBeans desktop applications
  • Automating module updates and providing user help

Édition : Prentice Hall PTR - 640 pages , 1re édition, 1er mai 2007

ISBN10 : 0132354802 - ISBN13 : 9780132354806

18 x 3 x 23 cm, broché

Commandez sur www.amazon.fr :

37.42 € TTC (prix éditeur 49.99 € TTC)
  • Foreword by Jonathan Schwartz
  • Foreword by Jan Chalupa
  • Preface
  • About the Authors and Contributors
  • Acknowledgments
  • Chapter 1: Getting Started with the NetBeans Platform
  • Chapter 2: The Benefits of Modular Programming
  • Chapter 3: Modular Architecture
  • Chapter 4: Loosely Coupled Communication
  • Chapter 5: Lookup
  • Chapter 6: Filesystems
  • Chapter 7: Threading, Listener Patterns, and MIME Lookup
  • Chapter 8: The Window System
  • Chapter 9: Nodes, Explorer Views, Actions, and Presenters
  • Chapter 10: DataObjects and DataLoaders
  • Chapter 11: Graphical User Interfaces
  • Chapter 12: Multiview Editors
  • Chapter 13: Syntax Highlighting
  • Chapter 14: Code Completion
  • Chapter 15: Component Palettes
  • Chapter 16: Hyperlinks
  • Chapter 17: Annotations
  • Chapter 18: Options Windows
  • Chapter 19: Web Frameworks
  • Chapter 20: Web Services
  • Chapter 21: JavaHelp Documentation
  • Chapter 22 Update Centers
  • Chapter 23: Use Case 1: NetBeans Module Development
  • Chapter 24: Use Case 2: Rich Unger on Application Development
  • Chapter A: Advanced Module System Techniques
  • Chapter B: Common Idioms and Code Patterns in NetBeans
  • Chapter C: Performance
  • Index
Critique du livre par la rédaction n!co le 1er octobre 2007
Introduction
Poussé par la notoriété grandissante des dernières versions 5.x et de la très attendue version 6, Rich Client Platform : Plugging into the Netbeans Platform est le deuxième livre présentant Netbeans comme plateforme de client riche. Apportant une nouvelle expérience du développement d'application RCP, le site Netbeans.org restait jusqu'à aujourd'hui la principale source d'information pour apprendre à profiter de la plateforme : API très riche, documents techniques, nombreux tutoriaux offerts par la communauté, sans oublier la mailing-list très active. Cependant, il manquait une introduction aux concepts de base de l'architecture et c'est le défi que les auteurs ont su relever avec qualité au travers des 22 chapitres de ce livre.

Les auteurs
Tim Boudreau, aujourd'hui évangéliste pour la plateforme,il fût un des auteurs du premier livre sur Netbeans RCP; Jaroslav Tulach, garant du projet OpenIDE, il fût un des fondateurs de Netbeans dans les années 1997; enfin Geertjan Wielenga, rédacteur technique des branches module et RCP de Netbeans, son blog https://blogs.oracle.com/geertjan/ n'est plus à présenter aux développeurs ayant déjà utilisé la plateforme.

La critique
Le livre commence par 4 chapitres proposant de faire nos premiers pas avec Netbeans et l'architecture modulaire. Vous y découvrirez d'abord comment créer un nouveau module, puis comment il est structuré (layer.xml, bundle.properties, …). Les auteurs décrivent ensuite les intérêts à découper une application en plusieurs modules et les avantages que Netbeans apporte dans ce domaine : les différents types de modules qui coexistent au sein du contrôleur et les différentes façons de les faire communiquer.

Les 7 chapitres suivants détaillent les principales API au coeur de Netbeans. Vous découvrirez la puissance des Lookups, fournissant entre autre un moyen de dialoguer entre modules, les Filesystems offrant un accès unifié aux sources de données (répertoire/ fichier, jar, xml, …) et l'intégration d'une structure d'information grâce aux Nodes. C'est aussi au travers de ces chapitres que vous apprendrez à utiliser les vues de Netbeans, à organiser les fenêtres et à adapter l'interface en fonction des éléments sélectionnés.

Suivent 8 chapitres qui traitent des API plus spécifiques à l'IDE. Tout d'abord vous apprendrez à réaliser un support complet d'un type de fichier dans l'éditeur de code, exemple basé sur les fichier manifest (.mf) : vues multiples et représentation graphique, coloration syntaxique, auto complétion, liens inter document, mise en évidence des erreurs et drag & drop grâce à la palette. Puis vous verrez comment apporter une meilleure expérience utilisateur avec le panneau des options, la mise à disposition d'une documentation et le centre de mise à jour.

Pour finir, les 4 derniers chapitres proposent une approche plus concrète des concepts étudiés tout au long du livre. Vous verrez tout d'abord avec quelle facilité il est possible d'ajouter le support d'un framework au projet Web standard ; Comment faire communiquer un module et un WebService avec moins de 10 lignes de codes ; Pour finir, 2 exemples fonctionnels complets sont détaillés : le support de l'outil Tidy via un plugin Netbeans et une application RCP de manipulation d'une bande sonore. Le livre se clôt enfin par 3 appendices ciblés sur les bonnes pratiques de design et de performances à privilégier lors du développement de module Netbeans.

En conclusion, ce livre est une parfaite introduction à la prise en main de la plateforme Netbeans. On peut regretter l'oubli des Wizards, formulaire à étapes multiples, bien qu'introduits dans plusieurs chapitres (et sur le blog de Geertjan). Néanmoins ce livre couvre les aspects vitaux pour maîtriser la puissance de la plateforme. Il englobe aussi la version 5,5 et chaque point est décrit par un code source clair et illustré (aussi dispo sur le cdrom). Captivant, structuré et d'un anglais largement abordable, ce livre est indispensable à tous les développeurs de plugins et d'applications RCP et je le conseille vivement aux personnes qui souhaitent en connaître davantage sur la plateforme.


couverture du livre SCJP

Note 4 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (1)
 
 

SCJP

Sun Certified Programmer for Java 5: (Exam 310-055)

de
Public visé : Intermédiaire

Résumé de l'éditeur

100% complete coverage of all official objectives for Sun Java exam 310-055.
Exam Objective Highlights in every chapter point out exam objectives to ensure you're focused on passing the examReal-world exercises--Step-by-step instruction modeled after the hands-on exam questions.
Exam Watch sections in every chapter highlight key exam topics covered.
Simulated exam questions match the format, tone, topics, and difficulty of the real exam.

Covers all exam 310-055 topics, including:
  • Declarations and Access Control
  • Object Orientation
  • Assignment and Initialization
  • Operators
  • Flow Control, Exceptions, and Assertions
  • I/O, Formatting, and Parsing
  • Generics
  • Collections
  • Inner Classes
  • Threads
  • Java Development


The best fully integrated study system available.
CD-ROM includes:

Complete MasterExam practice testing engine, featuring:
  • One full practice exam
  • Detailed answers with explanations
  • Score Report performance assessment tool
  • Electronic book for studying on the go
  • Bonus downloadable MasterExam practice test (with free online registration)

Édition : McGraw-Hill/Osborne Media - 825 pages , 1re édition, 1er décembre 2005

ISBN10 : 0072253606 - ISBN13 : 9780072253603

Broché

Commandez sur www.amazon.fr :

38.02 € TTC (prix éditeur 38.02 € TTC) livraison gratuite !
  • Language Fundamentals
  • Declarations and Access Control
  • Operators and Assignments
  • Flow Control, Exceptions, and Assertions
  • Object Orientation, Overloading and Overriding, Constructors, and Return Types
  • Java.lang-The Math Class, Strings, and Wrappers
  • Objects and Collections
  • Inner Classes
  • Threads
  • Development
  • APPENDIX: About the CD
Critique du livre par la rédaction Hikage le 1er août 2007
Avant tout, je me permettre de bien remettre ce livre dans son contexte : C'est un guide pour la certification SCJP !
Donc si c'est un livre pour apprendre le language Java que vous cherchez, passez votre chemin.
Cela étant dit, ce livre très utile et très intéressant, les deux auteurs du livre sont les co-créateurs de l'examen et donc connaissent très bien le sujet traité par le livre

Fréquemment ils mettent en avant ce qui est important de savoir, tout comme ils informent le lecteur lorsqu'un sujet est hors propos pour la certification.
Le livre en lui même est très agréable à lire, malgré des sujets parfois difficiles à appréhender. Personnellement j'ai dévoré ce livre une première fois, pour le relire par après plus en détail.

L'organisation du livre quant à elle est très clair. Un chapitre reprend un sujet important pour le décortiquer en détail.
Et pour chacun chaque section, un lien est fait vers le ou les objectifs de la certification que celle-ci couvrera.
En fin de chapitre est présent un "Two-Minute Drill", un rappel très succint des informations traités par le chapitre, et un mini test de tester vos acquis sur les sujets du chapitre.

En fin de livre, un examen blanc complet est présent, celui-ci contient des questions du même style que celles qui seront posées durant l'examen.
Enfin, un examen supplémentaire est disponible sur le CD-Rom accompagnant le livre, ainsi qu'un autre en téléchargement sur le site du livre.
En conclusion, je dirai que pour ma part ce livre à répondu à son objectif, c'est grâce à lui que j'ai réussi mon examen SCJP 5.


couverture du livre Eclipse et JBoss

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Eclipse et JBoss

de
Public visé : Expert

Résumé de l'éditeur

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

Édition : Eyrolles - 629 pages , 1re édition, 1er mars 2005

ISBN10 : 2212114060 - ISBN13 : 9782212114065

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Développement et déploiement J2EE avec Eclipse et JBoss
  • L'étude de cas WebStock
  • Développement Web avec MyEclipse
  • Développement EJB avec JBoss, MyEclipse et XDoclet
  • Aspects avancés de JBoss
Critique du livre par la rédaction el_toro le 1er juin 2005
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.


couverture du livre Programmation Orienté Aspect pour Java / J2EE

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Programmation Orienté Aspect pour Java / J2EE

de

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.

Édition : Eyrolles - 446 pages , 1er avril 2004

ISBN10 : 2212114087 - ISBN13 : 9782212114089

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC)
Les concepts de la POA

1. Introduction : limites de la programmation objet et apports de la POA
2. Notions d'aspect, de coupe, de code advice, de point de jonction…

Principaux outils de POA du monde Java

1. AspectJ
2. JAC (Java Aspect Components)
3. JBoss AOP
4. AspectWerkz
5. Comparaison des outils de POA

Applications de la POA

1. Implémentation des design patterns
2. Qualité de service des applications : design par contrats, tests, supervision des applications
3. Serveurs d'applications et POA

Étude de cas détaillée

1. Utilisation de la POA dans une application J2EE : couches métier, client et présentation
Critique du livre par la rédaction Eric REBOISSON le 1er août 2007
Le livre "Programmation orientée aspect pour Java / J2EE" définit dans un premier temps ce qu'est la POA (assez succinct, mais précis et suffisant. Pour information, POA c'est AOP en anglais), présente et compare ensuite 4 outils/implémentations de POA (AspectJ, JAC, JBOSS AOP et AspectWerkz) et finit sur une partie concernant les domaines d'application de ce paradigme (Design Patterns, cas concret…)

J'ai apprécié l'approche pragmatique de cet ouvrage, chaque solution est présentée avec une même structure dans ses sous-chapitres. Les solutions sont ensuite utilisées par la suite pour présenter les cas d'utilisation (même si au cours de la lecture j'ai ressenti la préférence des auteurs pour leur bébé JAC). Vous trouverez également dans cet ouvrage des explications sur comment appliquer la POA à votre proche métier ou dans vos techniques habituelles et conventionnelles de programmation. Un bon point pour le style d'écriture des auteurs, l'attention du lecteur est bien entretenue et sa compréhension améliorée. La mise en page est bien conçue dans l'ensemble, les codes sources sont disponibles sur le site de l'éditeur, bref tous les ingrédients sont là.

Ce livre constitue donc, à mon sens une bonne introduction sur le sujet de la POA : assez général pour couvrir un spectre de plusieurs outils, et détaillé pour vous accompagner à comprendre et utiliser les solutions présentées pour une application concrète dans vos projets. Malgré tout (mais je ne pense pas que les auteurs avaient la prétention d'être exhaustif), pour aller plus loin une exploration unitaire des frameworks présentés sera nécessaire. Au final, un livre que je vous conseille pour découvrir la POA.
Critique du livre par la rédaction RanDomX le 1er août 2006
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.


couverture du livre Eclipse

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Eclipse

Principes, patterns et plugins

de
Public visé : Expert

Résumé de l'éditeur

Eclipse est un environnement de programmation Open Source et extensible, centré sur le développement en Java. Que vous ayez besoin de vous familiariser rapidement avec Eclipse ou que vous cherchiez à mieux comprendre les concepts qui régissent cette plate-forme, le CampusPress Référence Eclipse contient toutes les informations que vous devez connaître.
Ce livre aborde non seulement les processus de codage, mais il donne également des conseils et des astuces d'expert pour accélérer votre prise en main. Un exemple complet, qui illustre toutes les phases à parcourir, de la conception globale à la réalisation d'un logiciel qualifié, ainsi que les règles d'or d'Eclipse concernant la création d'extensions, vous aideront à concevoir vos propres contributions.
Vous apprendrez notamment à : Créer un plug-in en moins d'une heure ; Utiliser le plug-in de tests automatisés JUnit ; Concevoir une interface de test ; Employer les patterns comme outils d'investigation ; Gérer les exceptions.

Édition : Campus Press - 450 pages , 1re édition, 20 juillet 2004

ISBN10 : 2744017264 - ISBN13 : 9782744017261

Commandez sur www.amazon.fr :

28.05 € TTC (prix éditeur 30.00 € TTC) livraison gratuite !
  • Configuration préalable d'Eclipse
  • Programme de bienvenue
  • Plan
  • Contribution d'un élément de menu pour les tests
  • Codage du comportement de la commande de test
  • Affichage des résultats
  • Définition d'un point d'extension
  • Notification d'une extension
  • Publication d'une extension
  • Une vue des résultats
  • Contributions de menus
  • Echecs des tests et erreurs de compilation
  • Echecs comme marqueurs
  • Recherche des tests
  • Builders et natures
  • Propriété d'auto-test
  • Gestion des exceptions
  • Résolution d'un marqueur
  • Vue du rapport de test avec JFace
  • Editeur simple pour exclure des tests
  • Retour sur ResultView pour observer les changements
  • Perspectives
  • Système d'aide du plug-in
  • Internationalisation et ergonomie
  • Publication d'un plug-in
  • Core Runtime : l'Adaptable
  • Espace de travail et ressources
  • Noyau Java
  • Le Kit de composants SWT
  • JFace : structure d'interface utilisateur
  • Le plan de travail Workbench
  • Configuration préalable d'Eclipse
  • Programme de bienvenue
  • Plan
  • Contribution d'un élément de menu pour les tests
  • Codage du comportement de la commande de test
  • Affichage des résultats
  • Définition d'un point d'extension
  • Notification d'une extension
  • Publication d'une extension
  • Une vue des résultats
  • Contributions de menus
  • Echecs des tests et erreurs de compilation
  • Echecs comme marqueurs
  • Recherche des tests
  • Builders et natures
  • Propriété d'auto-test
  • Gestion des exceptions
  • Résolution d'un marqueur
  • Vue du rapport de test avec JFace
  • Editeur simple pour exclure des tests
  • Retour sur ResultView pour observer les changements
  • Perspectives
  • Système d'aide du plug-in
  • Internationalisation et ergonomie
  • Publication d'un plug-in
  • Core Runtime : l'Adaptable
  • Espace de travail et ressources
  • Noyau Java
  • Le Kit de composants SWT
  • JFace : structure d'interface utilisateur
  • Le plan de travail Workbench
Critique du livre par la rédaction Michel Blavin le 1er mars 2008


A la vue de la biographie des auteurs on s'attend à un livre d'un très bon niveau, et c'est le cas. Ce livre vous permet d'entrer dans le monde d'Eclipse de manière progressive, logique et pratique. Même si l'entrée en matière est progressive, ce livre s'adresse à un public averti ayant déjà de solides bases en Java et plus généralement en programmation orientée objet.
Je suis assez sensible à la manière dont les sujets sont organisés dans un livre : les chapitres sont souvent courts, ne traitant qu'un sujet à la fois, on ressent ici le talent des auteurs en terme de modélisation. Par conséquent, ce livre est probablement le meilleur moyen pour commencer à développer des plugins Eclipse.

Alors pourquoi seulement la moyenne pour ce livre ? Pour les choix de traduction qui ont été faits :
Les plus :
  • Les copies d'écran utilisent une version française (d'ailleurs ce choix ne tient pas sur la longueur du livre) ;
  • Les noms des Design Pattern, ainsi que le nom des règles qui sont les fondements sur lesquels se base Eclipse, ont été traduits. On se retrouve à aller chercher la traduction anglaise (qui est quand même fournie dans le livre) pour comprendre de quoi ils parlent. Ce choix me paraît une vrai fausse bonne idée.


J'ai trouvé ces choix très déstabilisant et cela m'a vraiment gaché la lecture. Ils encouragent à regarder le code existant, or ce code est en anglais ! Il me parait utopique de penser que l'on puisser contribuer à Eclipse sans être capable d'au moins se retrouver dans une documentation dans la langue de Shakespeare.
Il est clair que ce livre ne couvre pas la totalité du sujet, bien trop immense au vue du sujet. Cependant, il permet par la suite de se retrouver plus aisément dans la documentation de Eclipse.

En conclusion, je dirais que la traduction trahit l'esprit du livre, et je recommanderais plutôt sa VO !
Critique du livre par la rédaction Michaël le 1er avril 2007
Voici un livre qui permet une prise en main ultra-rapide mais néanmoins avancée de l'IDE Eclipse, outil de développement multi-plateforme écrit en java en vogue auprès de la communauté. Ce livre, construit sur quatre parties (Cercles 0,1,2,3), vous permettra avant tout de vous familiariser avec le développement et l'intégration de plugins Eclipse.
Bien sûr, cela nécessite une connaissance déjà avancée du langage Java, et des notions de développement GUI avec SWT/JFace seraient un plus pour aborder ce livre, mais on peut apprendre sur le tas.

Parlons un peu des deux auteurs : Erich Gamma et est un des quatre auteurs du livre design patterns, communéments appelés le GoF (pour Gang of Four ).
C'est aussi l'un des initiateurs de l'environnement de tests unitaires en Java JUnit, et de l'IDE Eclipse.
Quant à Kent Beck, c'est LE môssieur de l'eXtreme Programming ! Autant vous dire qu'ils savent ce qu'ils racontent.
D'ailleurs, sachez que le projet autour duquel ce livre s'articule est un plugin, simple, certes, mais pleinement fonctionnel, intégrant une interface graphique claire et implémentant JUnit sous Eclipse.

Cela doit se ressentir, j'adore ce livre. Je l'ai lu deux fois et il reste mon livre de référence pour le développement de plugins simples.
Ce n'est pas un ouvrage vraiment de référence mais un GROS tutoriel pourrait-on dire, bourré de détails et dont la méthode d'apprentissage ne lasse pas.


couverture du livre Les Cahiers du programmeur Swing

Note 5 drapeau
Détails du livre
Sommaire
Critiques (3)
 
 

Les Cahiers du programmeur Swing

de

Résumé de l'éditeur

Ce cahier montre aux développeurs Java comment exploiter la très riche bibliothèque standard Swing à travers la création d'une application graphique 3D ergonomique et fiable.

Cet ouvrage décrit la création d'un logiciel libre d'aménagement d'intérieur développé avec Java 5 et Swing, de sa conception UML jusqu'à sa ditribution, en passant par l'utilisation d'Eclipse, dont les astuces de productivité sont dévoilées. Le développeur y découvrira comment exploiter efficacement les nombreuses fonctionnalités de Swing : création d'arbres, de tableaux et de boîtes de dialogue, dessin dans un composant graphique, glisser-déposer, gestion d'opérations annulables, intégration d'un composant 3D, …

Édition : Eyrolles - 499 pages , 1re édition, 7 décembre 2006

ISBN10 : 2212120192 - ISBN13 : 9782212120196

Broché

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)
  • L'étude de cas : Sweet Home 3D
  • Mise en place de l'environnement de développement
  • Choix technique : Swing ou SWT ?
  • Arbre du catalogue des meubles
  • Tableau des meubles du logement
  • Modification du tableau des meubles avec MVC
  • Gestion des actions annulables
  • Composant graphique du plan
  • Vue 3D du logement
  • Enregistrement et lecture du logement
  • Glisser-déposer et copier-coller
  • Edition des préférences utilisateur
  • Bibliographie
  • Index
Critique du livre par la rédaction Eric REBOISSON le 1er mai 2008
Je viens de terminer la lecture du livre SWING dans la collection "Les cahiers du programmeur", un ouvrage sur l' APISwing qui permet de concevoir des interfaces graphiques avec le langage de programmation Java. Place maintenant à une petite présentation du contenu et à mes impressions sur cette publication dont le fil rouge est une application pour la modélisation 3D d'un logement.
Un bon point pour commencer, le sommaire complet et les titres de chapitres détaillés permettent d' accéder rapidement à l'information. Ensuite pour chaque chapitre, les grands thèmes couverts sont annoncés, on sait donc d'avance ce que l'on va découvrir, c'est structuré et ça suscite l'envie de lire. Pour la matière, toutes les phases de création du projet Sweet Home 3D sont présentées : on débute par l'idée et les phases inhérentes au démarrage d'un projet (cahier des charges, conception…), puis l'installation des outils de développement, la programmation proprement dite et les cycles de tests associés pour finir avec le déploiement de l'applicatif. Le comparatif avec d'autres API graphiques (AWT, SWT, JFace) est le bienvenu pour expliquer les choix qui peuvent conduire à l'utilisation ou non d'un des outils. On pourra lire également sur chaque page des petits encarts pour agrémenter les explications du livre (B.A.-BA, A retenir, Astuces, Pour aller plus loin, Attention…)
Ce livre ne traite donc pas uniquement de Swing et on puisera énormément d'informations sur (entre autres) :
  • Les fondations d'un projet informatique (cahier des charges, référentiel des sources)
  • Les nouveautés de Java 5 (annotations, généricité,)
  • Les designs patterns (MVC, Singleton, Décorateur, Proxy…)
  • Le déploiement avec Java Veb Start
  • ANT


Le livre expose des extraits de code commentés sur l'implémentation de l'application, des scénarios fonctionnels, des diagrammes de classes UML et des copies d'écrans pour illustrer les différentes étapes. J'ai cherché ce qui pouvait manquer dans le contenu mais tout est là.
C'était une découverte de la collection "Les cahiers du programmeur", et je dois dire que j'ai été enchanté tant par la qualité du contenu technique que par la pédagogie adoptée pour tenir le lecteur en haleine, mais aussi par la mise en page très riche et lisible à la fois. Je donne donc la note maximale et je ferai simple pour la conclusion : tous les livres devraient être comme ça, vous pouvez donc l'acheter les yeux fermés !
Critique du livre par la rédaction vbrabant le 1er avril 2007
Tout d'abord, je dois vous signaler, avant que vous n'alliez plus loin dans la critique, que j'ai été relecteur technique de ce livre.
Mon avis aurait donc pu être faussé.
C'est la raison pour laquelle j'ai attendu que quelqu'un d'autre fasse une critique de ce livre, avant de publier la mienne :-).
Ce livre est le seul que j'ai lu jusqu'à ce jour qui explique aussi clairement comment développer une application Swing en utilisant le modèle MVC tout en faisant bien la distinction entre le modèle MVC de votre application et le modèle MVC (ou plutôt M-VC) des composants Swing.
Attention que ce livre n'est pas là pour vous faire découvrir tous les composants Swing qui sont à votre disposition, mais plutôt pour vous faire découvrir comment bien découper/structurer votre application Swing.

Malgré cela, on y apprend l'utilisation des JTable, JTree, …, à afficher le même modèle sous des vues différentes (on visualise la même pièce en 3D, en 2D et sous forme de table), implémenter l'Undo/Redo, le Drag and Drop, l'internationalisation d'une application, …
On y apprend de plus comment découper un projet, comment les personnes ont raisonné pour finalement arriver au design de cette application.
Tout au long de l'ouvrage, l'auteur compare également Swing et AWT avec SWT et JFace, nous fait découvrir des modules Eclipse intéressants.
L'étude de cas que l'auteur a choisi pour ce livre est certainement pour beaucoup dans la qualité de l'ouvrage.
Dès le premier chapitre, on a envie d'en savoir plus, de connaitre comment l'auteur s'y est pris pour réaliser son étude de cas.
Sachez également que l'auteur a aussi mis son étude de cas à la disposition de tous, sous licence open source, et qu'elle est totalement opérationelle.
En conclusion, je ne peux que conseiller ce livre à tous ceux qui programment ou désirent programmer en Swing.
Ce livre me semble assez unique dans sa façon d'aborder Swing.
Pourquoi je ne donne que 4.5/5 à ce livre ? C'est la question que l'auteur m'a posée.
Je lui ai répondu que je mettrais 5/5 au livre qui m'expliquerait Swing à la façon "Head First/Tête première". Et le système des étoiles ne me permet pas de lui donner 4.9/5.
Critique du livre par la rédaction Baptiste Wicht le 1er février 2007
Ce livre est tout simplement génial. C'est la première fois que je lis un livre d'informatique aussi prenant, on a à chaque fois envie d'aller plus loin et d'avancer dans les chapitres.
Ceci est surtout du à la structure qu'a utilisée l'auteur pour écrire ce livre. Il n'en a pas fait un simple catalogue Swing montrant toutes les méthodes et classes de Swing et leur utilisation; il crée plutôt un projet qu'on va faire avancer tout au long du livre en lui ajoutant de nouvelles fonctionnalités. En plus de toutes les informations techniques que l'on obtient durant la lecture des différents chapitres, l'auteur nous fait aussi part de son expérience dans le travail en groupe et le développement de projet. En effet, on va voir comment découper le projet en plusieurs scénarios bien distincts, comment appliquer la méthode XP, comme utiliser CVS pour archiver et partager les fichiers du projet, etc. L'auteur va aussi traiter de la différence SWT/SWING/AWT.

Les domaines techniques abordés par cette application sont très vastes. On va voir comment créer des nouveaux composants Swing en respectant l'architecture MVC et comment faire une application respectant elle aussi le principe MVC. On va aussi voir comment utiliser les composants complexes que sont le JTable et le JTree. On va aussi apprendre à gérer des actions annulables dans l'application et la façon d'utiliser le glisser-déposer dans votre application. On passera aussi sur l'enregistrement de préférences utilisateurs et des données de l'application. En plus, on verra aussi comment visualiser une vue en 2D et en 3D !

En conclusion, je conseille ce livre non seulement à toutes personnes développant une application Swing mais aussi à toute personne développant une application graphique en Java, car ce livre dans ses métiers sait se montrer très général, de sorte que la plupart des informations sont utilisables pour une application graphique non Swing.


couverture du livre Mieux programmer en Java

Note 4 drapeau
Détails du livre
Sommaire
Critiques (2)
0 commentaire
 
 

Mieux programmer en Java

68 astuces pour optimiser son code

de
Public visé : Débutant

Résumé de l'éditeur

Un ouvrage pratique et concret
Tous les programmeurs vous le diront : le temps passé au débogage représente une grande part du développement de programmes et de d'applications. Réduire cette phase de débogage, programmer "juste" du premier coup : tels sont les objectifs atteints par ce livre qui expose en détail les pièges classiques de la programmation Java et la manière de les éviter. En proposant des solutions aux principaux problèmes rencontrés en Java, l'ouvrage va droit au but : pas de discours inutiles mais des recommandations concrètes, répondant aux attentes des programmeurs.

Une structure divisée en ateliers
Les 68 ateliers qui composent cet ouvrage abordent les princpales difficultés de la programmation Java : objets, exceptions, calsses et interfaces, tests d'égalité, multithreadiing, et ce à l'aide d'une multitude d'exemples très détaillés. En toutre, 18 d'entre eux sont consacrés à la manière d'écrire un code plus performant et donc plus rapide.

A qui s'adresse ce livre ?
  • Aux étudiants de 1er cycle universitaire (IUT, Deug, …) et aux élèves d'écoles d'ingénieurs.
  • Aux programmeurs Java débutants, intermédiaires ou avancés.

Édition : Eyrolles - 224 pages , 1re édition, 1er juillet 2000

ISBN10 : 2212091710 - ISBN13 : 9782212091717

Commandez sur www.amazon.fr :

28.05 € TTC (prix éditeur 30.00 € TTC)
  • Techniques générales
  • Objets et tests d'égalité
  • Gestion des exceptions
  • Performances
  • Programmation multithread
  • Classes et interfaces
  • Annexes
Critique du livre par la rédaction Baptiste Wicht le 1er janvier 2007
Ce livre présente 68 méthodes d'optimisation pour du code Java. Néanmoins, il faut bien faire attention au mot optimisation : pour ceux qui s'attendent à n'avoir que des astuces pour avoir un code plus rapide, ce n'est pas le cas. Seules 18 astuces permettent d'optimiser les performances de votre application. Les autres astuces permettent de produire un code plus sûr et plus stable.
Ces astuces sont parfois plus des explications sur comment faire quelque chose qu'une réelle astuce. Mais elles sont néanmoins très intéressantes. Avec ces astuces, vous apprendrez à faire correctement des tests d'égalité, à avoir un code multithread sécurisé ou encore à gérer correctement vos exceptions. Vous apprendrez aussi à implémenter des classes constantes et à redéfinir la méthode equals.
La partie sur les performances se révèle à mon goût un peu faible. Une astuce sur l'optimisation manuelle du code s'avère très intéressante. Les autres étant plus basiques, avec par exemple l'utilisation de StringBuffer à la place de String dans une boucle. Mais cette partie traite aussi de concepts plus avancés tels que l'inlining, l'évaluation différée ou encore l'utilisation de variables de pile plutôt que de variables globales. De plus, les comparaisons entre les différentes techniques sont expliquées directement en bytecode ce qui permet de voir directement ce que ça donne.
Une chose que je trouve dommage est que ce livre n'a pas été mis à jour depuis sa première édition. Il utilise donc Java 1.2, mais la plupart des astuces présentées ici sont toujours valables avec les dernières versions de Java.
En conclusion, ce livre vous montrera différentes manières de mieux coder en Java et d'optimiser les performances de vos programmes. Mais ce livre n'est pas la solution miracle à vos problèmes de performances.
Critique du livre par la rédaction Lucas Girardin le 30 juin 2014
Je suis tombé sur ce livre un peu par hasard, mais cela a été une vraie bonne surprise. La plupart des choses abordées étaient connues. Mais cette fois-ci on revoit les bonnes pratiques avec une vraie explication sur le comportement du code.
Personnellement je n'ai pas pu m’empêcher de tester ce que j'apprenais dans ce livre sur ma machine. C'est aussi très enrichissant d'essayer ces astuces sur un vrai projet (personnel et déjà finalisé de préférence) afin d'encore mieux appréhender ce qui est dit dans ce livre.
Le livre est abordable pour un débutant, qui butera certainement sur quelques chapitres comme les threads ou les exceptions s'il n'a jamais dû s'en servir, mais rien d'insurmontable.
Le dernier chapitre sur les classes et interfaces est un peu à prendre avec des pincettes étant donné l'ancienneté du livre. Mais ça reste une bonne lecture.




 Poster une réponse

Avatar de MarieKisSlaJoue MarieKisSlaJoue - Membre émérite https://www.developpez.com
le 01/07/2014 à 15:00
Vous avez vous aussi dans votre bureau une bibliothèque de livre datant de tellement longtemps que plus personne ne sais qui les a achetés ? Coincé entre deux livre sur java 2 j'ai trouvé dans ma bibliothèque le livre de Petter Haggar, "Mieux programmer en Java - 68 astuces pour optimiser son code" La dernière critique datant de 7 ans je me suis demandé si il était toujours au gout du jour.
Il à pris un coup de vieux mais mérite quand même de l’intérêt pour les débutants. Avec ces 200 pages il est assez rapide à lire.
http://java.developpez.com/livres/in...ts#L2212091710
couverture du livre Les expressions régulières par l'exemple

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Les expressions régulières par l'exemple

de
Public visé : Intermédiaire

Résumé de l'éditeur

Les chaînes de caractères, qui sont si simple en apparence, recèlent des difficultés redoutables dès qu'il faut écrire un programme pour les analyser, par exemple pour extraire des dates. Comme elles ne sont pas structurées, on ne peut rechercher que des régularités : c'est alors qu'interviennent les "expressions régulières".

  • les solutions aux exercices du livre
  • Que faire quand ça ne marche pas ?


Cet ouvrage vous apprendra comment :
  • construire une expression régulière;
  • enrichir votre syntaxe;
  • imbriquer à bon escient des expressions régulières dans vos programmes;
  • écrire des expressions régulières en Perl, Javascript, PHP, Java,C#, Python,C++/Qt, Emacs/Lisp, C/POSIX, Grep et Sed.;


44 exercices corrigés en détail, de très nombreux exemples, des tableaux aide-mémoires et une grille d'aide au débugage vous amèneront à une maîtrise complète de cet outil efficace, ludique et polyvalent.

Édition : Technique & Pratiques - 126 pages , 1re édition, 1er juillet 2005

ISBN10 : 2914010656 - ISBN13 : 9782914010658

Commandez sur www.amazon.fr :

9.31 € TTC (prix éditeur 9.08 € TTC)
  • Avant propos
  • Qu'est ce qu'une expression régulière
  • Débuter avec les expressions régulières
  • Enrichir ses expressions régulières
  • Bien utiliser les expressions régulières
  • Syntaxe dans dix langages
  • Solutions des exercices
  • Que faire quand ça ne marche pas?
Critique du livre par la rédaction yga le 1er juillet 2006
Ce livre au format poche contient l'essentiel de ce qu'il faut savoir sur les expressions régulières. Au cours des chapitres on trouvera une alternance en explication et mise en application directe par des petits exercices rapides (les corrigés sont disponibles à la fin du livre).
L'approche est progressive. Le premier chapitre introduit par un exemple simple les différentes notions.
Le deuxième chapitre va un peu plus loin en expliquant le fonctionnement des différents opérateurs basiques.
Le chapitre 3 explique de manière plus concrète les expressions régulières via des cas d'utilisations.
Le chapitre 4 donne des conseils de bonnes pratiques avec les expressions régulières.
Le chapitre 5 fait un tour d'horizon des langages proposant des outils pour les expressions régulières.

Deux annexes dans ce livre :
  • les solutions aux exercices du livre
  • que faire quand ça ne marche pas !


couverture du livre Spring par la pratique

Note 4 drapeau
Détails du livre
Sommaire
Critiques (4)
 
 

Spring par la pratique

de

Résumé de l'éditeur

Simplifier le développement des applications Java/J2EE.
Cet ouvrage montre comment développer des applications Java/J2EE professionnelles et performantes grâce à Spring, associé à d'autres frameworks populaires telles que Struts, Hibernate ou Axis. Spring s'appuie sur des concepts modernes, tels que la notion de conteneur léger, l'inversion de contrôle ou la programmation orientée aspect, afin d'améliorer l'architecture des applications Java/J2EE en les rendant plus souples, plus rapides à développer et plus facilement testables.
Un livre pratique illustré d'une étude de cas détaillée.
L'ouvrage présente les concepts sur lesquels reposent Spring avant de détailler les différentes facettes du développement d'applications Web avec Spring : couche présentation (Struts, Spring MVC, Spring Web Flow, portlets, applications Ajax), persistance des données et gestion des transactions, intégration avec d'autres applications et sécurité applicative.
L'accent est mis tout particulièrement sur les bonnes pratiques de conception et de développement, qui sont illustrées à travers une étude de cas détaillée, le projet Open Source Tudu Lists.

Édition : Eyrolles - 518 pages , 1re édition, 1er avril 2006

ISBN10 : 2212117108 - ISBN13 : 9782212117103

Broché, 19 x 23 cm

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
Préface
  • Remerciements
  • Avant-propos
  • Introduction


Les fondations de Spring
  • Les concepts des conteneurs légers
  • Le conteneur léger de Spring
  • Les concepts de la POA
  • Spring AOP


Intégration des frameworks de présentation
  • Intégration de Struts
  • Spring MVC
  • Spring Web Flow
  • Utilisation d'AJAX avec Spring
  • Support des portlets


Gestion des données
  • Persistance des données
  • Gestion des transactions


Technologies d'intégration
  • Technologies d'intégration Java
  • Technologies d'intégration XML
  • La sécurité avec Acegi Security


Les outils connexes
(list][*]Supervision avec JMX[*]Test des applications Spring[*]Annexe[*]Index[/list]
Critique du livre par la rédaction Petrus le 1er février 2008
Un bon ouvrage pour aborder Spring, et les différents concepts fondateurs de son architecture (IoP, AOP). J'ai apprécié les chapitres de démystification de la notion de conteneur léger et de POA, trés accessibles pour les débutants, même si (et c'est normal) ils demeurent incomplets. Sans être rentré dans le détail, j'ai également apprécié la parallèle réalisé avec l'étude de cas "Tudu List", projet OpenSource disponible surSourceForge. Les différentes méthodes d'injection (modificateur, constructeur, propriétés, collaborateurs) , les notions d'aspects (join point, crosscut, code advice, aspect weaver) sont donc abordés, et vous serez capable d'appréhender l'intégration de Spring avec Struts, ou encore avec le propre modèle de pattern MVC de Spring (Spring MVC) et AJAX (DWR, script.aculo.us).
Ce livre conviendra donc aux débutants, qui y trouveront de nombreux exemples sur la manipulation des différents connecteurs de Spring, mais l'expert y trouvera peu d'intérêt, le plan choisi étant volontairement trés général.
Critique du livre par la rédaction Hikage le 1er décembre 2007
Lorsque j'ai acheté ce livre, j'avais une appréhension sur ce que j'allais découvrir. Etant très intéressé par le framework Spring, j'avais eu l'occasion de lire plusieurs livres anglophones sur le sujet.
C'est donc avec sceptiscime que j'ai accueilli le premier livre francophone sur ce framework : Serait-ce une simple traduction/adaptation des versions anglaises? Possèdera-t-il une valeur ajoutée ?
Au final, j'ai été séduit ! Ce livre est très bien écrit, agréable à lire et aborde les sujets les plus fréquents dans le développement J2EE. De plus, il décrit non seulement des fonctionnalités propres à Spring 2.0 mais aussi l'intégration avec un framework Ajax (DWR). C'est le premier livre que j'ai pu lire à avoir traité ces derniers points.
Le livre se base sur une application réelle, Tudu List, qui est proposée sous différents frameworks de présentation : Struts, Spring MVC, Spring WebFlow, Portlet.
Cela permet de voir comment Spring est mis en pratique sur un projet complet. C'est, à mon avis, parfois plus intéressant que d'essayer de comprendre une portion de code dénuée de contexte.
Je conseille donc ce livre à toute personne qui désire découvrir Spring Framework, le livre introduisant la notion de conteneur légers, la programmation orientée aspect pour ensuite présenter de manière plus technique les possibilités de Spring.
Critique du livre par la rédaction joseph_p le 1er août 2007
Ma réaction face à ce livre tient en quelques mots : il aurait dû s'appeler Spring pour la pratique.
En effet, il passe rapidement sur les considérations de modélisation ou de structuration d'une application pour directement aborder les multiples façons d'utiliser Spring, notamment du fait de ses nombreux connecteurs. Il en couvre d'ailleurs la plupart je pense, ce qui est une bonne chose.
Aussi, l'ensemble du livre est très orienté technique, allant même jusqu'à détailler les balises xml. Cela peut s'avérer très utile si vous êtes non anglophone, un peu moins sinon, vu que la doc Spring est très bien foutue.
Au final, je suis resté sur ma faim concernant la modélisation et la façon de travailler. Certes, plein de solutions techniques sont abordées, mais le "comment construire son application" autour de Spring n'est pas assez approfondi je trouve. Ce qui est dommage, je trouve, vu que Spring apporte une vraie révolution en termes de conception (à mes yeux du moins). D'où mon 4.
Critique du livre par la rédaction christopheJ le 1er mars 2007
Vous avez sans doute entendu parler de Spring, mais vous vous demandez ce que c'est, ce que cela peut faire pour vous? Alors ce livre est pour vous.
Ce livre présente un tour d'horizon du framework Spring. Mais il fait plus que de vous donner une idée, il vous montre comment l'utiliser. Si ce livre s'appelle "Spring par la pratique" c'est qu'il s'appuie entièrement sur une application écrite à l'occasion : TUDU List. Vous pouvez voir cette application sur le site : http://app.ess.ch/tudu/welcome.action . Différentes versions de cette application ont aussi été créées correspondant aux différentes technologies présentées dans le livre.
La première partie du livre commence par présenter les problématiques de la programmation Java et Java EE (séparation de préoccupation, test, indépendance de la plateforme et du serveur…). Ensuite il présente brièvement les réponses qu'apporte Spring avec la notion de conteneur léger et de POA. Enfin il présente brièvement l'application TUDU List qui sert de fil rouge au livre.
On trouve ensuite 4 chapitres très denses en informations. Le premier revient en détail sur les conteneurs léger et les notions d'inversion de control et d'injection de dépendance. Le second présente Spring en tant que conteneur léger et son utilisation. Le troisième présente la POA et enfin le quatrième l'intégration de la POA dans Spring.
Ensuite le livre aborde les différentes technologies et frameworks utilisés en Java EE et reprend la même structure tout du long :
  • Présentation sommaire de la technologie
  • Intégration dans Spring
  • Intégration dans TUDU List

Par exemple dans le cas de Struts, les auteurs commencent par présenter le framework en définissant MVC2, les actions et les FormBeans, ensuite ils présentent les trois possibilités d'intégration de Struts dans Spring, enfin ils présentent la solution utilisée dans TUDU List avec des morceaux de code et de fichiers de configuration.
Le livre aborde donc successivement tous les aspects : framework de présentation (Struts, Spring MVC, Spring WebFlow, Ajax et Portlets), gestion des données (persistance, transactions), l'intégration (JMS, JCA, XML, Acegy Security) et enfin les outils connexes (supervision avec JMX et test).
Même si certains points mériteraient d'être plus détaillés, ce livre est indispensable pour qui veut un aperçu complet de ce que peut lui apporter Spring et de ce que va lui coûter sa mise en oeuvre. On peut déplorer que parfois les extraits de code soient trop courts pour permettre de bien comprendre où ils se situent et nécessitent de se reporter aux codes sources de l'application. Cela rend obligatoire le fait d'avoir un ordinateur sous la main, ou de laisser des commentaires si l'on est coincé dans un train.


couverture du livre Aide-Mémoire de Java

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Aide-Mémoire de Java

de

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 !

Édition : Dunod - 246 pages , 1er septembre 2005

ISBN10 : 2100491458 - ISBN13 : 9782100491452

Commandez sur www.amazon.fr :

15.02 € TTC (prix éditeur 16.00 € TTC)
[ist][*]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[/list]
Critique du livre par la rédaction joseph_p le 1er mai 2007
Un livre indispensable pour tout débutant en Java et souvent nécessaire pour développeur confirmé devant aborder des sujets dont il n'a pas l'habitude.
Ce petit livre couvre succinctement l'essentiel de la programmation Java, avec à la fois les explications sur le fonctionnement fondamental de chaque fonctionnalité et des exemples pertinents.
Bien sûr, si vous voulez aborder un aspect bien spécifique, ce livre ne vous sera pas suffisant, mais il offrira sans doute déjà assez d'informations pour bien débuter. De toutes façons, jamais un livre généraliste sur Java ne donnera jamais assez d'éléments sur un point précis des très vastes bibliothèques disponibles.
Au final : un must have.
Critique du livre par la rédaction vbrabant le 1er mai 2006
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


couverture du livre Refactoring des applications Java/J2EE

Note 4.875 drapeau
Détails du livre
Sommaire
Critiques (4)
0 commentaire
 
 

Refactoring des applications Java/J2EE

de
Public visé : Expert

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.

Édition : Eyrolles - 349 pages , 1er septembre 2005

ISBN10 : 2212115776 - ISBN13 : 9782212115772

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • 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
Critique du livre par la rédaction Olivier le 1er février 2010
J'ai trouvé l'ouvrage très intéressant dans ses premiers chapitres, où il expose les différents types de refactoring à considérer, les manières de les mettre en oeuvre.
De plus, les façons d'analyser l'existant sont bien expliquées, et de nombreux outils sont proposés pour arriver à nos fins. Bien qu'il date de 2005, son contenu reste tout à fait d'actualité.
Après, j'ai trouvé que ça s'est gâté. On passe de hors sujet en hors sujet, même si ceux-ci s'avèrent agréables à lire. Une bonne partie du livre nous explique comment utiliser Eclipse pour renommer les méthodes, réorganiser le contenu des classes, présente quelques design patterns et la POA, la façon d'écrire des tests unitaires… Je trouve qu'on s'écarte souvent du sujet principal.

J'espérais trouver un livre dans lequel obtenir plus d'informations sur la manière de refondre le code plus en profondeur. Ceci dit, le livre précise bien qu'un refactoring s'applique à du code dont les fondements sont sains, mais cela ne suffit pas à combler ma déception.
La lecture de ce livre n'aura cependant pas été une perte de temps, car de nombreuses idées traversent l'esprit pendant la lecture de ce dernier par rapport à mon cas personnel, et les techniques/outils présentés le sont très bien.
Critique du livre par la rédaction christopheJ le 1er mars 2007
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 vbrabant le 1er juin 2006
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 Delcroix le 1er janvier 2006
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.




 Poster une réponse

Avatar de if_zen if_zen - Membre averti https://www.developpez.com
le 26/02/2010 à 10:39
Titre de l'ouvrage
Refactoring des applications Java/J2EE
Note sur une échelle de 5
3/5
Votre critique

J'ai trouvé l'ouvrage très intéressant dans ses premiers chapitres, où il expose les différents types de refactoring à considérer, les manières de les mettre en oeuvre.
De plus, les façons d'analyser l'existant sont bien expliquées, et de nombreux outils sont proposés pour arriver à nos fins. Bien qu'il date de 2005, son contenu reste tout à fait d'actualité.
Après, j'ai trouvé que ça s'est gâté. On passe de hors sujet en hors sujet, même si ceux-si s'avèrent agréables à lire. Une bonne partie du livre nous explique comment utiliser Eclipse pour renommer les méthodes, réorganiser le contenu des classes, présente quelques design patterns et la POA, la façon d'écrire des tests unitaires... Je trouve qu'on s'écarte souvent du sujet principal.
J'espérais trouver un livre dans lequel trouver plus d'informations sur la manière de refondre le code plus en profondeur. Ceci dit, le livre précise bien qu'un refactoring s'applique à du code dont les fondements sont sains, mais cela ne suffit pas à combler ma déception.
La lecture de ce livre n'aura cependant pas été une perte de temps, car de nombreuses idées traversent l'esprit pendant la lecture de ce dernier par rapport à mon cas personnel, et les techniques/outils présentés le sont très bien.

La critique en ligne
couverture du livre Hibernate 3.0

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Hibernate 3.0

Gestion optimale de la persistance dans les applications Java/J2EE

de
Public visé : Intermédiaire

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.

Édition : Eyrolles - 317 pages , 1re édition, 1er juin 2005

ISBN10 : 2212116446 - ISBN13 : 9782212116441

19 x 2 x 23 cm

Commandez sur www.amazon.fr :

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

Critique du livre par la rédaction Ricky81 le 14 novembre 2005
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.


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

Note 3 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

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

de
Public visé : Intermédiaire

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.

Édition : Campus Press - 858 pages , 1er juin 2005

ISBN10 : 2744019623 - ISBN13 : 9782744019623

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC)
  • Multithreads
  • Collections
  • Programmation des bases de données
  • Objets distribués
  • Swing
  • JavaBeans
  • La sécurité
  • Internationalisation
  • Méthodes natives
  • XML
  • Annotations
Critique du livre par la rédaction vbrabant le 1er novembre 2005
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.


couverture du livre Cahiers du programmeur

Note 4 drapeau
Détails du livre
Sommaire
Critiques (1)
1 commentaire
 
 

Cahiers du programmeur

Java/XML

de

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...

Édition : Eyrolles - 217 pages , 1re édition, 1er décembre 2004

ISBN10 : 2212113161 - ISBN13 : 9782212113167

21 x 2 x 24 cm

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 29.00 € TTC)
Cahier des charges
Installation de l'environnement de développement
XML, pour configurer et transporter des données
Modélisation et visualisation des objets métier via XML
Struts, partie émergée de l'application ?
Les bases de données XML natives : grand déstockage d'Automne ?
Conception de services web
Critique du livre par la rédaction Ioan le 26 avril 2005
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.




 Poster une réponse

Avatar de freegreg freegreg - Expert éminent https://www.developpez.com
le 13/12/2004 à 16:21
Nouveau livre dédié à la technologie XML : Les Cahiers du Programmeur : Java/XML de Renaud Fleury avec la contribution de Caroline de Vasson aux éditions Eyrolles

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...

N'hésitez pas à nous faire de vos impressions dès que vous l'aurez lu
Avatar de Ioan Ioan - Membre expert https://www.developpez.com
le 26/04/2005 à 10:18
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.

couverture du livre Java & XSLT

Note 4.5 drapeau
Détails du livre
Critiques (1)
0 commentaire
 
 

Java & XSLT

de

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.

Édition : O'Reilly - 498 pages , 1re édition, 1er mars 2002

ISBN10 : 2841772055 - ISBN13 : 9782841772056

Commandez sur www.amazon.fr :

40.85 € TTC (prix éditeur 43.00 € TTC)
Critique du livre par la rédaction LFE le 1er mars 2002
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.




 Poster une réponse

Avatar de khayyam90 khayyam90 - Responsable Portail https://www.developpez.com
le 25/06/2014 à 20:52
Java & XSLT
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.

[Lire la suite]




couverture du livre Au Coeur de Java 2 JDK 5, Vol.1

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Au Coeur de Java 2 JDK 5, Vol.1

Notions Fondamentales

de
Traducteurs : Christiane Silhol, Nathalie Le Guillou de Penanros

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)

Édition : Campus Press - 855 pages , 7eédition, 1er décembre 2004

ISBN10 : 2744018333 - ISBN13 : 9782744018336

format : 19x23x5 cm, poids : 1575 gr.

Commandez sur www.amazon.fr :

38.00 € TTC (prix éditeur 40.00 € TTC)
  • Une introduction à Java
  • L'environnement de programmation de Java
  • Structures fondamentales de la programmation Java
  • Objets et classes
  • L'héritage
  • Interfaces et classes internes
  • Programmation graphique
  • Gestion des événements
  • Swing et les composants d'interface utilisateur
  • Déployer des applets et des applications
  • Exceptions et mise au point
  • Les flux et les fichiers
  • Programmation générique
  • Annexes A : Les mots clés de Java
  • Annexes B : Adaptation en amont du code du JDK 5.0
Critique du livre par la rédaction bigboomshakala le 1er décembre 2005
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!


couverture du livre Java Efficace

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java Efficace

Guide de Programmation

de

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.

Édition : Vuibert - 272 pages , 1er juin 2002

ISBN10 : 2711748057 - ISBN13 : 9782711748051

Commandez sur www.amazon.fr :

30.04 € TTC (prix éditeur 32.00 € TTC)
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
Critique du livre par la rédaction Baptiste Wicht le 1er février 2007
Ce livre est fait non seulement pour toutes les personnes qui doivent écrire des librairies qui vont être réutilisées par d'autres, mais aussi pour les simples développeurs qui produiront un code plus solide. En effet, l'auteur de ce livre (chef de projet chez Sun Microsystems) vous donne en une série de 57 conseils pour développer une librairie plus stable, plus performante, plus propre et plus facilement utilisable.

Il commence par parler de la création et de la destruction d'objets et de la façon de les rendre plus performantes. Il traite ensuite des méthodes communes à tous les objets, c'est-à-dire des méthodes héritées d'Object et de comment correctement les implémenter. Le chapitre suivant traite des interfaces et des bonnes pratiques de la conception orientée objet. Puis, il enchaine sur les équivalents du langage C indiquant, par exemple, comment remplacer les unions en Java. Les chapitres suivants traitent des méthodes et de la programmation en général, indiquant par exemple comment optimiser judicieusement son code. Les 3 derniers chapitres sont chacun très spécifiques, parlant tout d'abord des exceptions, puis des threads, et enfin de la sérialisation.

En conclusion, ce livre est indispensable à toute personne voulant écrire une API correctement maintenable et réutilisable. Le style de l'auteur permet de lire ce livre avec une très grande fluidité malgré la grande dose d'informations.
Critique du livre par la rédaction christopheJ le 1er mars 2006
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 de57 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.


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