Warning: include(./redir.php): failed to open stream: No such file or directory in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 74

Warning: include(): Failed opening './redir.php' for inclusion (include_path='.:/opt/php56/lib/php') in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 74
Les meilleurs livres Java, Java EE, Spring, Android
Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/developpez-kit-generation.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/code.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/lightbox.2.51.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/public/css/index2.css in /home/developpez/www/developpez-com/template/entete.php on line 405
IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Warning: include(): http:// wrapper is disabled in the server configuration by allow_url_include=0 in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Warning: include(http://java.developpez.com/index/rightColumn): failed to open stream: no suitable wrapper could be found in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Warning: include(): Failed opening 'http://java.developpez.com/index/rightColumn' for inclusion (include_path='.:/opt/php56/lib/php') in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Les livres Java pour les utilisateurs intermédiairesConsultez tous les livres

Dernière mise à jour : 8 février 2013 

precedentsommairesuivant
  1. GWT (Google Web Toolkit) - Développez des Applications Internet Riches (RIA) en Java
  2. 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
  3. Programmation concurrente en Java
  4. iReport 3.7
  5. JBoss AS 5 Development
  6. Apache Maven
  7. Modular Java - Creating Flexible Applications With OSGi and Spring
  8. Spring par l'exemple
  9. Pro Spring Dynamic Modules for OSGi Service Platforms
  10. Spring par la pratique - Spring 2.5 et 3.0
  11. Java SOA Cookbook
  12. JBoss in Action
  13. Java 6 : Entraînez-vous et maîtrisez Java par la pratique - Collections : Les TP Informatiques
  14. Maven: The Definitive Guide - Everything You Need to Know from Ideation to Deployment
  15. Les Cahiers du programmeur Java EE 5
  16. Filthy Rich Clients
  17. Java Persistence et Hibernate
  18. Programmer en Java
  19. Java Generics - and Collections
  20. Checking Java Programs
  21. Professional Java Development with the Spring Framework
  22. Rich Client Programming - Plugging into the Netbeans Platform
  23. Le guide de Survie - Java: L'essentiel du code et des commandes
  24. SCJP - Sun Certified Programmer for Java 5: (Exam 310-055)
couverture du livre GWT (Google Web Toolkit)

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

GWT (Google Web Toolkit)

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

de Damien PICARD
Public visé : Débutants,Intermédiaires,Expérimentés

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.

400 pages, 1 édition,

Édition ENI

ISBN10 : 2746058308

ISBN13 : 9782746058309

Commandez sur www.amazon.fr :

37,05  € TTC (prix éditeur 39  € TTC) livraison gratuite !
  • 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

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 le trocquer

É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 EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

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

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 Celinio Fernandes
Public visé : Débutants,Intermédiaires,Expérimentés

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.

Commentez Donner une note à l´article (4.5)

370 pages, 1ère édition, 1er juillet 2010 

Édition Eni

ISBN10 : 2746055678

ISBN13 : 978-2-7460-5567-4

Commandez sur www.editions-eni.fr : 37,05 ? seulement (au lieu de 39 ? : prix public)

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

Critique du livre par la rédaction Lassiège Hugo

Comme son titre l'indique ce livre traite de l'intégration des EJB avec divers Framework : Struts2, JSF2, JasperReports3 et Flex3 au travers d'une application de vente en ligne développée tout au long des chapitres. L'auteur commence donc par une description des EJB et des apports de la version courante (3.1). Il décrit ensuite l'utilisation des EJB au sein d'une application déployée sur Jboss6 et balaye l'ensemble de la spécification au travers d'exemples variés : JPA, Session Beans, Message Driven Beans, EJB Timers et interceptors. Les exemples vont tour à tour utiliser du WebServices, une couche de présentation réalisée avec Struts2 puis JSF2 et enfin Flex3. Une utilisation des EJB comme source de données pour JasperReports est aussi discutée dans l'un des chapitres.

On pourra reprocher quelques choix discutables sur les implémentations (mélange de Junit3 et 4, confusion entre tests unitaires et tests d'intégration, la gestion des exceptions etc...) ou des raccourcis un peu rapides (non, Struts2 n'est pas juste comme Struts1 avec des extensions différentes sur les URL) qui ternissent un peu le propos.

Mais au final, cet ouvrage se lit comme un tutoriel autour des EJB et non comme un ouvrage de référence. Son gros intérêt c'est son côté didactique qui permet d'explorer les EJB3 sous toutes leurs coutures. La contrepartie en abordant autant de sujets c'est de perdre le débutant, pourtant une des cibles du livre. A vouloir traiter tant de sujets on passe parfois de façon superficielle et on demande donc beaucoup de connaissances préalables au lecteur. Mais on appréciera grandement les exemples fournis et les tutoriels permettant de mettre en place l'environnement ou de manipuler certains outils. D'un point de vue personnel, c'est l'intégration avec Flex3 qui m'a le plus intéressé ne connaissant pas Flex. J'ai ainsi découvert qu'il existait une passerelle entre JAVA avec Flex par l'intermédiaire de BlazeDS et Granite et rien que pour ça, j'ai apprécié la lecture de ce livre.

En conclusion, un bon ouvrage pour découvrir en un seul livre plusieurs technologies d'un seul coup et les EJB en particulier mais qui devra se compléter par des livres plus spécialisés si l'on désire approfondir les frameworks abordés.

 
couverture du livre Programmation concurrente en Java

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

Programmation concurrente en Java

de Brian Goetz
Traducteur(s) : Eric Jacoboni
Public visé : Intermédiaires,Expérimentés

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.

10 commentaires Donner une note à l´article (4)

370 pages, 1ère édition, 05/2009 

Édition Pearson Education

ISBN10 : 2744023337

ISBN13 : 978-2-7440-2333-0

18,5 cm x 23 cm, 795g

Commandez sur www.amazon.fr :

37,05 € TTC (prix éditeur 39 € TTC) livraison gratuite !
  1. Les bases
    • Thread safety
    • Partage des objets
    • Composition d'objets
    • Briques de base
  2. Structuration des applications concurrentes
    • Exécution des tâches
    • Annulation et arrêt
    • Pools de threads
    • Applications graphiques
  3. Vivacité, performances et tests
    • Éviter les problèmes de vivacité
    • Performances et adaptabilité
    • Tests des programmes concurrents
  4. Sujets avancés
    • Verrous explicites
    • Construction de synchronisateurs personnalisés
    • Variables atomiques et synchronisation non bloquante
    • Le modèle mémoire de Java

 
Critique du livre par la rédaction benwit le 08/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.

 
couverture du livre iReport 3.7

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

iReport 3.7

de Shamsuddin Ahammad
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

Although JasperReports is the world's most popular open source Java reporting library, it has always lacked one thing: It doesn't provide a tool to visually design reports. iReport is a visual report designer built on JasperReports that fills that lack. It is an intuitive and easy-to-use visual report builder/designer for JasperReports, written in 100% pure Java.

This beginner's tutorial book is a straightforward introduction to the iReport environment taking an example-oriented approach in developing your skills from scratch. It shows you how to use iReport for creating reports in PDF, RTF, and other formats, which can be delivered over the Web for immediate access.

This book will guide you through using iReport to develop various types of reports from a simple report through to dynamic enterprise-level reports based on realistic examples based on a sample Inventory Management System. It takes you through the main types of report available in iReport, and shows you exactly how to create them. It shows you how to use different report templates, how to use special kinds of data operations to generate more powerful reports, combine data to produce master-detail reports, add images, control the layout and formatting of your report and many more.

It will also show you how to use the NetBeans IDE to create Java projects with reporting facilities. You will learn how to vary report format and layout according to business requirements.

Commentez Donner une note à l´article (0)

222 pages, 1ère édition, 1er mars 2010 

Édition PackT Publishing

ISBN10 : 1847198805

ISBN13 : 978-1-847198-80-8

Commandez sur http://www.packtpub.com : 27,89 euros

Commandez sur www.amazon.fr :

28,91 € TTC (prix éditeur 29,98 € TTC) livraison gratuite !
  • Chapter 1: Introduction to iReport
  • Chapter 2: Building Your First Report
  • Chapter 3: Report Layout and Formatting
  • Chapter 4: Using Variables
  • Chapter 5: Using Parameters
  • Chapter 6: Grouping Data in Reports
  • Chapter 7: Subreports
  • Chapter 8: Crosstab Reports
  • Chapter 9: Charting
  • Chapter 10: Working with Images
  • Chapter 11: Calling Reports from Java Applications
  • Chapter 12: iReport in NetBeans
  • Appendix: A Sample Database

 
Critique du livre par la rédaction Celinio Fernandes le 1er mai 2010 

Dans ce livre constitué de 12 chapitres, l'auteur Shamsuddin Ahammad présente iReport, l'outil indispensable pour concevoir des rapports basés sur la librairie JasperReports, écrite en Java.
Une base MySQL est créée et son modèle décrit dans l'annexe.

Les trois premiers chapitres font un tour rapide de l'outil avec :
- une présentation des fonctionnalités de iReport,
- l'utilisation du générateur de rapports pour la création d'un premier rapport depuis une connexion à une base MySQL,
- le formatage du rapport et de ses éléments

A partir du quatrième chapitre, l'auteur aborde le traitement des données dans iReport avec les créations de variables (pour des calculs de sommes par exemple) et de paramètres (pour créer des requêtes ou des titres dynamiques par exemple).
Ensuite les groupes et les variables de groupes sont expliqués.

Un chapitre entier est dédié aux rapports contenant des sous-rapports, avec les relations maitre-enfant.
Un autre chapitre détaille la création de tableaux croisés, très utilisés dans les rapports.
Trois types de rapports graphiques sont créés : diagramme en camembert, diagramme en camembert 3D et diagramme en bâtons.
L'auteur montre également comment afficher des images qui sont stockées sur le disque ou bien en base de données.

Un exemple montre l'utilisation de l'API JasperReports pour créer un projet qui affiche un rapport dans une application Swing. L'affichage d'un rapport dans une application Web n'est pas détaillé mais l'auteur mentionne néanmoins les méthodes à utiliser.
NetBeans est l'IDE choisi par l'auteur pour développer, avec l'intégration du plugin Report Designer.

Ce que j'ai aimé : Les nombreuses copies d'écrans qui facilitent la compréhension, notamment pour la mise en place de sous-rapports.

Ce que j'ai moins aimé : j'aurais souhaité voir l'utilisation d'autres sources de données telles que des requêtes EJB-QL (EJB avec JPA) ou MDX pour des cubes de données.

Le site de l'auteur est : http://ireport-tutorial.blogspot.com/

English version :

In this book made of 12 chapters, the author Shamsuddin Ahammad shows how to use iReport, the indispensable tool to conceive reports based on the JasperReports library, written with Java.
A MySQL database is created and its model is described in the appendix.

The first three chapters give us a quick overview of the tool :
- a presentation of the functionalities of iReport,
- the use of the Report Wizard to create a first report with a connexion to a MySQL database,
- formatting the report and its elements.

Starting from the fourth chapter, the author explains the processing of data in iReport with the creation of variables (to calculate sums for instance) and parameters (to create dynamic queries or titles for instance).
Then groups and group variables are explained.

An entire chapter is dedicated to reports and their sub-reports, with master-child relations.
Another chapter details the creation of crosstabs, which are very used in reports.
Three types of graphic charts are created : a pie chart, a 3D pie chart and a bar chart.
The author also shows how to display pictures which are stored in a disk or in a database .

An example shows the use of the JasperReports API to create a project which displays a report in a Swing application.
The display of a report in a web application is not detailed but the author still mentions the methods to use.
NetBeans is the IDE chosen by the author to develop, with the integration of the Report Designer plugin.

What I liked the most : the numerous screen shots to facilitate the comprehension, especially the use of sub-reports.

What I liked the least : I would have wanted to read about the use of other types of datasource such as EJB-QL queries (EJB with JPA) or MDX for cubes of data.

The site of the author is http://ireport-tutorial.blogspot.com/

 
couverture du livre JBoss AS 5 Development

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

JBoss AS 5 Development

de Francesco Marchioni
Public visé : Débutants,Intermédiaires,Expérimentés

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

Commentez Donner une note à l´article (4)

396 pages, 1ère édition, 1er décembre 2009 

Édition PackT Publishing

ISBN10 : 1847196829

ISBN13 : 978-1-847196-82-8

Commandez sur http://www.packtpub.com : 27.89 £

Commandez sur www.amazon.fr :

35.16 € TTC seulement (au lieu de 37.48  € TTC : prix éditeur) livraison gratuite !
  • 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 Celinio Fernandes 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.

 
couverture du livre Apache Maven

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

Apache Maven

de Nicolas de Loof, Arnaud Héritier
Public visé : Débutants,Intermédiaires,Expérimentés

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.

29 commentaires Donner une note à l´article (4.5)

324 pages, 1ère édition, 1er novembre 2009 

Édition Pearson

ISBN10 : 274402337X

ISBN13 : 978-2744023378

18,7 x 23 cm

Commandez sur www.amazon.fr :

30.39 € TTC seulement (au lieu de 32  € TTC : prix éditeur) livraison gratuite !
  • 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 Cuisinier Gildas 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 romaintaz le 1er décembre 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/

 
couverture du livre Modular Java

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

Modular Java

Creating Flexible Applications With OSGi and Spring

de Craig Walls
Public visé : Intermédiaires,Avancés

Résumé de l'éditeur

Modular Java is a pragmatic guide to developing modular applications using OSGi, the framework for dynamic modularity in Java, and Spring Dynamic Modules, an OSGi extension to the Spring Framework. You'll start with the basics but quickly ramp up, creating loosely coupled modules that publish and consume services, and you'll see how to compose them into larger applications. Along the way, you'll apply what you learn as you build a complete web application that is made up of several OSGi modules, using Spring-DM to wire those modules together.

Modular Java is filled with tips and tricks that will make you a more proficient OSGi and Spring-DM developer. Equipped with the know-how gained from this book, you'll be able to develop applications that are more robust and agile.

Commentez Donner une note à l´article (4)

260 pages, 1ère édition, 1er juin 2009 

Édition O'Reilly

ISBN10 : 1934356409

ISBN13 : 978-1934356401

Broché

Commandez sur http://oreilly.com : 34.95 $ - livraison gratuite !

Commandez sur www.amazon.fr :

23.59 € TTC seulement (au lieu de 24.84  € TTC : prix éditeur) livraison gratuite !
  • Introduction
  • Getting Started
  • Dude, Where's My Jar ?
  • Working with Bundles
  • OSGi Services
  • Spring and OSGi
  • Creating Web Bundles
  • Extending Bundles
  • OSGi in Production
  • Configuring the Application
  • Manifest Headers
  • Spring-DM Configuration
  • The OSGi Blueprint Service
  • Resources
  • Bibliography
  • Index

 
Critique du livre par la rédaction Baptiste Wicht le 1er octobre 2009 

Ce livre est une très bonne introduction à la création d'applications modulaires en Java. Ce livre présente tous les principaux concepts de la technologie OSGi, de Spring Dynamic Modules ainsi que des outils permettant de faciliter le développement d'applications OSGi.

Le premier chapitre présente la problématique de modularité et présente comment OSGi tente de résoudre ce problème. Les concepts principaux de la technologie y sont également décrits.

Le second chapitre présente différents conteneurs OSGi. Dans ce chapitre, on crée un premier programme Hello World en utilisant OSGi. On améliore ensuite ce programme en utilisant la publication et la consommation de services OSGI.

Le troisième chapitre introduit l'application "Dude, Where's my Jar ?" qui nous suivra tout au long du livre. Cette application est une application web permettant d'effectuer des recherches de fichier Jar dans des repository Maven. En plus de cela, le chapitre présente la série d'outils Pax qui permettent de faciliter le développement d'applications OSGi.

Le chapitre suivant voit la création du premier bundle de notre application grâce auquel on adresse les premières problématiques du développement OSGi, à savoir l'utilisation de dépendances non-OSGi.

Le chapitre cinq développe le bundle suivant. Ce chapitre se focalise sur la publication et la consommation de services OSGi. En plus de cela, on apprend également à tester une application et des services OSGi.

Il est maintenant temps de passer à Spring Dynamic Modules avec le chapitre suivant. On y voit comment faciliter la consommation et la déclaration de services sous forme de beans Spring.

Avec le chapitre 7, on commence à développer le bundle web. Pour cela, on va inclure Tomcat ou Jetty sous forme de bundles OSGi. On va ensuite voir les différences qu'il y a entre déclarer un bundle simple (JAR) et un bundle web (WAR).

Le chapitre suivant traite de l'extension de bundle OSGI au moyen de fragment. On va notamment voir comment découpler la partie JSP et design de la partie applicative.

L'avant dernier chapitre permet de voir comment déployer une application OSGi en production. Il présente l'ajout d'une console web à l'application pour administer directement les modules.

Le dernier chapitre présente les services de journalisation et d'administration qui font partie de la norme OSGi.

En conclusion, ce livre vous permettra de commencer à développer des applications utilisant OSGi.
C'est très agréable de suivre le développement d'une application tout au long du livre, tout en découvrant au fur et à mesure ce qu'OSGi permet de faire pour faciliter le développement d'une application.
Néanmoins, je trouve qu'on aurait pu éviter de se baser tant que ça sur les outils Pax. On perd presque de vue OSGi à partir de l'utilisation de Pax. Il se peut qu'on ne puisse utiliser Pax dans une application et dans ce cas, on pourrait ne pas savoir tout faire.
Certes, il est utile de voir le déroulement Maven les premières fois, mais ce n'est pas utile de les afficher systématiquement. Certaines pages ne contiennent presque que des traces Maven qui ne correspondent ni à des erreurs, ni à des informations intéressantes. Mais malgré cela, la lecture du livre reste très fluide et intéressante.

 
couverture du livre Spring par l'exemple

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

Spring par l'exemple

de Gary Mak
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

Spring représente le framework applicatif Java EE le plus simple et le plus puissant que j'aie jamais utilisé. Depuis l'inversion de contrôle et la programmation orientée aspect à la persistance, les transactions, le design pattern MVC, les tests et autres, ce livre explique comment tirer profit de Spring au travers d'exemples de code détaillés. Ces exemples vont du scan de composants dans le chemin d'accès aux classes au test unitaire des contrôleurs Spring MVC. Spring propose des solutions simples à des problèmes difficiles. Cette simplicité a été également mon premier objectif dans la conception de cet ouvrage. J'ai souhaité trouver un équilibre entre l'étendue des sujets traités, le niveau de détail, la rapidité d'apprentissage et les connaissances requises. Chaque chapitre explore un sujet important au travers d'un exemple réel complet. Lors de la première lecture d'un chapitre, je vous recommande de suivre l'exemple de manière séquentielle. Ensuite, vous pouvez vous en servir comme référence en examinant la liste des problèmes-solutions. Si vous cherchez à résoudre un problème précis, vous pouvez aller directement aux solutions dont vous avez besoin en consultant la table des matières ou l'index.

5 commentaires Donner une note à l´article (5)

510 pages, 1ère édition, 1er mai 2009 

Édition Pearson Education

ISBN10 : 2744023396

ISBN13 : 978-2744023392

Broché

Commandez sur www.amazon.fr :

39.90 € TTC seulement (au lieu de 42  € TTC : prix éditeur) livraison gratuite !
  • A propos de l'auteur
  • Introduction
  • Inversion de contrôle et conteneur
  • Introduction au framework Spring
  • Configuration des beans
  • Fonction élaborées du conteneur Spring IoC
  • Proxy dynamique et Spring AOP classique
  • Spring 2.x AOP et prise en charge d'AspectJ
  • Prise en charge de JDBC
  • Gestion des transactions
  • Prise en charge de l'ORM
  • Framework Spring MVC
  • Intégration avec d'autres frameworks web
  • Prise en charge des tests unitaires
  • Index

 
Critique du livre par la rédaction Baptiste Wicht le 1er juillet 2009 

Ce livre est une excellente introduction à Spring. En effet, il va explorer les différents concepts de Spring en allant chaque fois un peu plus loin. Après avoir lu ce livre, on maitrise les principales fonctionalités du framewok Spring. Chaque chapitre du livre traite d'un concept spécifique de Spring. Chacun des chapitres est découpé en sous-chapitres se basant sur une série de problèmes/solutions, ce qui se révèle très pratique pour retrouver des informations par la suite.

Le premier chapitre traite de l'inversion de contrôle en général. Les différents types d'IoC y sont décrits et mis en oeuvre à l'aide de la création d'un petit exemple de container IoC développé au long du chapitre.

Le deuxième chapitre présente le framework Spring et son impressionnant portfolio. Vous y apprendrez à installer le framework et ses dépendances ainsi que Spring IDE.

Avec les deux chapitres suivants, on explore les fonctionnalités d'inversion de contrôle de Spring. Après ce chapitre, vous saurez tout ce qu'il faut savoir sur l'utilisation de Spring pour injecter vos dépendances dans vos objets. L'injection de beans, de collections ou de constantes n'auront plus de secret pour vous. Des fonctionnalités plus élaborées, telles que les beans et méthodes de fabrique, les postprocesseurs, l'internationalisation ou les éditeurs de propriété, sont également explorées.

Avec les deux prochains chapitres, vous apprendrez à modulariser les préoccupations transversales en utilisation la programmation orientée aspect. Ces chapitres commencent en utilisant les proxies dynamiques de Java pour coder ces préoccupations transversales, ensuite de quoi, il nous apprend à utiliser Spring AOP classique (Spring 1.x) et enfin, on apprend à utiliser Spring AOP (Spring 2.x). Le support d'AspectJ est également traité en profondeur, du tissage au chargement en passant par la configuration d'aspects AspectJ en tant que beans Spring.

Le chapitre 7 explore la prise en charge de JDBC (appelée Spring JDBC). On y apprendra à utiliser des templates JDBC pour faciliter le développement d'applications basées sur JDBC. On y verra également comment profiter des generics et des varargs de Java 5.0 pour JDBC.

On passe ensuite à la gestion des transactions avec Spring. Les différentes méthodes pour implémenter les transactions avec Spring, API du gestionnaire de transactions, template de transaction, Spring AOP, greffons transactionnels ou encore annotation @Transactional, y sont traités en détail. On verra également comment configurer finement les différentes transactions, via leurs attributs de propagation, isolation, temporisation ou encore annulation.

Le chapitre suivant traite de la prise en charge de l'ORM dans Spring. On y voit comment configurer un framework ORM dans Spring et on développe également un exemple complet avec JPA et Hibernate.

L'antépénultième chapitre traite du framework Spring MVC qui permet de développer facilement des applications web sur la base du design pattern MVC. Les différents concepts de Spring MVC y sont traitées et bien que ce ne soit pas exhaustif, après la lecture de ce chapitre, vous serez capable de développer une première application web basique avec Spring MVC. On enchaîne directement avec le chapitre suivant qui traite de l'intégration avec d'autres frameworks Web tels que Struts, JSF ou DWR.

Le dernier chapitre traite de l'intégration des tests unitaires. Ce chapitre explique comment simplifier le test d'une application basé sur le Spring Framework avec JUnit ou TestNG. On y apprendra à créer des tests unitaires ainsi que des tests d'intégration.

En conclusion, ce livre vous permettra de commencer à développer des applications basées sur Spring et de découvrir la puissance de ce framework. La seule critique que je peux faire par rapport à ce livre est la longueur des chapitres Spring MVC et frameworks web. Pour moi qui suis plutôt orientés applications Desktop, j'aurais préféré aller plus loin dans certains chapitres ou explorer d'autres fonctionnalités de Spring telles que la validation, le scheduling/pooling de threads ou le support de langages dynamiques dans la configuration des beans.

 
couverture du livre Pro Spring Dynamic Modules for OSGi Service Platforms

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

Pro Spring Dynamic Modules for OSGi Service Platforms

de Daniel Rubio
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

Spring and OSGi's features are a natural fit; they are orthogonal to each other: OSGi is about packaging, deployment, and versioning issues, while Spring is about providing the necessary foundation to wire up Java classes in their most basic form using dependency injection and aspect orientation to fulfill an application's purpose.

Pro Spring Dynamic Modules for OSGiT Service Platforms by Daniel Rubio is the first book to cover OSGi as practically implemented by the world's most popular, agile, and open source enterprise Java framework, Spring.

  • Author Daniel Rubio covers the ease at which OSGi is used with the Spring Framework in development, packaging, versioning, and deployment.
  • Enterprises are trusting Spring more and more, and this book leverages OSGi in a way that can "complete" the use of Spring in the enterprise, as OSGi is already being trusted and adopted by IBM, BEA, and others.
  • The text discusses how Spring OSGi makes your Spring applications trusted SOA applications.

What you'll learn?

  • Understand the fundamentals of OSGi and Spring, and combine the two.
  • Take your Spring applications and bundles, and incorporate OSGi for production-ready packaging, versioning practices, and deployment.
  • Create production-ready Spring Beans by packaging and versioning, and then deploy them.
  • Develop data access methods and means for your Spring OSGi projects.
  • Build and use GUIs for Spring OSGi.
  • Test, scale, and optimize your Spring OSGi applications for deployment and performance.

4 commentaires Donner une note à l´article (4)

392 pages, 1ere édition, 1er février 2009 

Édition Apress

ISBN10 : 1430216123

ISBN13 : 9781430216124

Broché

Commandez sur www.apress.com : 46.99 $

Commandez sur www.amazon.fr :

33,74 € TTC (prix éditeur 37,43 € TTC) livraison gratuite !
  • Introducing OSGi
  • Introducing Spring
  • Integrating Spring and OSGi
  • Spring Dynamic Modules for OSGi
  • SpringSource dm Server
  • Versioning with OSGi and Spring
  • Data Access and Bundle Management Without SpringSource dm Server
  • Web Applications Using Spring and OSGi
  • Testing with Spring and OSGi

 
Critique du livre par la rédaction Gildas CUISINIER (hikage) le 1er juillet 2009 

Critique en français

Vous avez entendu parler d'OSGi mais vous ne savez pas ce que c'est ? Ou vous pensez que cela est trop compliqué ? Alors le livre de Daniel Rubio est surement un moyen d'appréhender OSGi de manière simple grâce à Spring Dm.

Ce livre est bien écrit et permet d'avoir une première approche sur le sujet. Dès les premiers chapitres, OSGi est expliqué très simplement et vous apprendrez quels sont les avantages de cette technologie face à JEE.
Ensuite, Spring Dm sera présenté. Celui-ci apporte la simplicité POJOs dans le monde OSGi, à la manière des projets Spring.

Vous ne connaissez pas du tout Spring ? Pas de soucis ! Une introduction succincte mais suffisante du Framework sera faite, ce qui vous permettra de suivre correctement le reste du livre sans problème.

D'autres sujets, toujours gravitant autour de OSGi et Spring seront abordés. C'est le cas du serveur de SpringSource par exemple. C'est ainsi que vous apprendrez les extensions d'OSGi qu'il apporte pour faciliter le développement, en particulier avec JPA. L'utilitaire bnd sera lui aussi au sommaire, afin de vous expliquer comment rendre un JAR compatible OSGi sans trop d'effort.

Bref, c'est un excellent livre pour débuter avec OSGi et Spring Dm, mais pour moi il ne va pas assez en profondeur pour un livre de la collection "Pro".

English review

You've heard about OSGi but do not know what it is? Or do you think this is too complicated? Then the Daniel Rubio's book is probably a simple way to learn OSGi thanks to Spring Dm.
This book is well written and gives a first approach on the subject. In the first chapters, OSGi is explained very simply and you will learn what are the benefits of this technology face to JEE.

Then Dm Spring will be presented. This brings the simplicity of POJOs in the OSGi world, like all the Spring projects.
You do not know anything of Spring? No worries! A brief but sufficient introduction of the Framework will be made, allowing you to follow the book without difficulty.

Other subjects, always revolving around OSGi and Spring, will be covered. This is the case SpringSource server for example. Thus you will learn the extensions it provides to OSGi to facilitate development, especially for JPA.
The tool 'bnd' is also introduced in summary, to explain you how to make a OSGi-compatible JARs without too much effort.

In short, it is an excellent book to start with OSGi and Spring Dm, but for me it does not go deep enough for a book of the "Pro" collection.

 
couverture du livre Spring par la pratique

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

Spring par la pratique

Spring 2.5 et 3.0

de Arnaud Cogoluègnes, Thierry Templier, Julien Dubois, et Jean-Philippe Retaillé
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

Cet ouvrage montre comment développer des applications Java EE professionnelles performantes à l'aide du framework Spring. L'ouvrage présente les concepts sur lesquels reposent Spring (conteneur léger, injection de dépendances, programmation orienté aspect) avant de détailler les différentes facettes du développement d'applications d'entreprise avec Spring : couche présentation, persistance des données et gestion des transactions, intégration avec d'autres applications et sécurité applicative.

Cette seconde édition présente en détail les nouveautés majeures des versions 2.5 et 3.0 de Spring et de ses modules annexes : modèle de programmation basé sur les annotations, Spring Dynamic Modules for OSGi, Spring Batch, Spring Security, SpringSource dm Server, etc. 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.

11 commentaires Donner une note à l´article (5)

658 pages, 2ème édition, 1er janvier 2009 

Édition Eyrolles

ISBN10 : 221212421X

Broché

Commandez sur http://izibook.eyrolles.com : 39 ?
Au format PDF

Commandez sur www.amazon.fr :

42,75 € TTC (prix éditeur 45 € TTC) livraison gratuite !
  • Avant-propos
  • Introduction à Spring
  • Partie 1 : Les fondations de Spring
    • Le conteneur léger de Spring
    • Concepts avancés du conteneur Spring
    • Les concepts de la POA
    • Spring AOP
    • Test des applications Spring
  • Partie 2 : Les frameworks de présentation
    • Spring MVC
    • Spring WebFlow
    • Utilisation d'Ajax avec Spring
  • Partie 3 : Gestion des données
    • Persistance des données
    • Gestion des transactions
    • Support des technologies JMS et JCA
  • Partie 4 : Technologies d'intégration
    • Spring Web Services
    • Spring Security
    • Spring Batch
  • Partie 5 : Spring en production
    • Spring Dynamic Modules
    • Spring DM Server
    • Supervision avec JMX

 
Critique du livre par la rédaction Eric Reboisson le 1er janvier 2010 

N'ayant pas eu la chance de critiquer la première édition de "Spring par la pratique", c'est avec joie et grand intérêt que j'ai accueilli le facteur m'apportant cette seconde édition. Pour la petite histoire, j'ai suivi la formation Spring Core en 2008, dispensée par Julien Dubois, co-auteur sur cet ouvrage et j'ai eu comme compère de formation Gildas Cuisinier, relecteur de ce second opus, 4 jours aussi intéressants que ce présent ouvrage.

Le livre commence donc par la pédagogie nécessaire autour des concepts Spring (conteneur léger, inversion de contrôle (IOC), injection de dépendance, AOP (Aspect Oriented Programmation, POA en français pour programmation orientée aspect)) puis la suite est un savant mélange de théorie permettant au lecteur de comprendre correctement les concepts de Spring (et pourquoi ceux-ci existent) et de pratique via la mise en ouvre de cas concrets extraits de l'application fil rouge Tudu List.

On appréciera au fil des chapitres suivants l'exhaustivité de la couverture du portofolio Spring : Spring AOP, Spring Batch, Spring MVC, Spring Web Flow... Il appartient ensuite au lecteur d'utiliser ce qui lui paraîtra nécessaire dans ses applications. A noter qu'il faut un minimum de connaissances sur les frameworks et concepts (où du moins en connaître les principes majeurs) auxquels s'adresse Spring (Hibernate, GWT, JMS, Webservices...) même ci ceux-ci sont très bien introduits dans le livre, ne serait-ce que pour comprendre ce qu'apporte Spring couplé à ces éléments.

Mon avis sur "Spring par la pratique" :

J'ai aimé

  • Un très bon livre sur Spring en français
  • La pédagogie idéale pour la découverte des débutants au travers d'une lecture assez facile
  • L'introduction TRES intéressante montre en quoi Spring peut aider à une bonne conception projet, par la séparation des couches et les abstractions proposées par les modules de Spring
  • Le cas d'étude réel avec l'application Tudu List, une application complète (qui évolue au fil des améliorations de Spring) illustrant les nombreuses caractéristiques de Spring (téléchargeable sur http://www.springparlapratique.org)

Et un peu moins

  • Les termes traduits en français, car je pense que vous utilisez, comme moi, au quotidien la terminologie anglaise (aspect, AOP...), mais comme c'est un livre en français...
  • Les mises en ouvre sont assez génériques donc pour les détails il faudra creuser les ressources du Web par soi-même (mais sinon, nous n'aurions plus de travail...)
  • Les exemples sont un peu parachutés par moment et il n'est pas toujours évident de les comprendre dans le tout d'une application

Nous avons donc là un excellent ouvrage en français sur Spring, clair et détaillé, pédagogique et très complet que je conseille aux curieux désireux de connaître Spring mais aussi aux confirmés qui trouveront dans ce livre les nouveautés du portofolio Spring.

Critique du livre par la rédaction Gildas CUISINIER (hikage) le 1er juin 2009 

Spring par la pratique, première édition, fut un excellent livre sur Spring et son portfolio. A sa sortie, il couvrait directement Spring 2.0, fraichement sorti à l'époque. Mais l'eau a coulé sous les ponts et le livre est devenu un peu désuet de par les nouveautés de Spring 2.5 et 3.0 ou encore l'arrivée de projet tels que Spring Dm ou Spring Batch.. C'est là qu'intervient la nouvelle édition, couvrant justement ceux-ci, alors que Spring 3.0 n'est pas encore officiellement sorti.

Sur la forme, le livre garde le même style que l'ancienne édition, chaque chapitre étant divisé en deux parties. La première étant une présentation théorique d'un sujet, la deuxième étant sa mise en pratique dans un exemple concret ( le même qu'auparavant : Tudu List ). Concernant le contenu par contre, les changements sont majeurs, allant de grosse mises à jour à de nouveaux chapitres complets.

Ce qui change ?
Les chapitre concernant les bases de Spring ( Inversion du controle, injection de dépendances, AOP ) ont été complètement revus afin de prendre en compte les nouvelles possiblités de configuration apportées par Spring 2.5 et Spring 3.0 : annotations, expression language, nouveaux schéma XML.
La chapitre sur la partie Web à aussi ré-écrit afin de présenter le nouveau framework @MVC et ses annotations ainsi que le support de REST. C'est aussi le cas du chapitre Spring WebFlow, qui se base sur la version 2.0, ou sur la sécurité basé sur Spring Security et non plus sur Acegi.

Quoi de neuf ?
Parmi les nouveautés, plusieurs chapitres sont dédiés à OSGi et les solutions apportées par SpringSource : Spring Dynamic Modules qui rend le développement OSGi des plus simples, et Spring Dm Server qui propose une alternative à JEE en permettant le déploiement d'application OSGi.
Spring Batch, une solution de traitements de lots de fichiers en Java, se voit aussi consacrer un chapitre.

Une autre nouveauté est le nouveau site (http://www.springparlapratique.org) qui accompagne le livre qui permet de discuter avec les auteurs ou récupérer le code source.

Je conseille donc vivement la lecture de ce livre, aussi bien au débutant voulant apprendre à utiliser Spring en se basant sur la dernière version qu'a des personnes souhaitant simplement se mettre à jour et découvrir les nouveautés du portfolio. Le contenu est des plus complet et très bien expliqué !

 
couverture du livre Java SOA Cookbook

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

Java SOA Cookbook

de Eben Hewitt
Public visé : Intermédiaires,Expérimentés

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.

1 commentaire Donner une note à l´article (4)

740 pages, 1ère édition,

Édition O'Reilly UK

ISBN10 : 0596520727

ISBN13 : 9780596520724

Commandez sur www.amazon.fr :

36,79 € TTC (prix éditeur 39,82 € TTC) livraison gratuite !
  • 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

 
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 ouvre 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 :

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

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 Cuisinier Gildas le 08/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 ..

 
couverture du livre JBoss in Action

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

JBoss in Action

de Javid Jamae, Peter Johnson
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

JBoss in Action teaches readers how to use the JBoss application server, digging into the things that separate JBoss from other Java EE servers. This book goes deeply into the advanced features and configuration of the server. In particular, it focuses on enterprise-class topics, such as high availability, security, and performance.

The book walks you through the JBoss 5 Application Server, from installation and configuration to production deployment. It guides you through configuring the server's component containers, such as the JBoss Web Server, the EJB3 server, and JBoss Messaging. It also gives you detailed insight into configuring the services, such as security, performance, and clustering. Beyond coverage of the core application server, the book also teaches you how to use some of the "hot" technologies that run on top of the application server, such as JBoss Seam and JBoss Portal.

The authors, both seasoned professional experts at developing and administering JBoss, provide meaningful explanations and background on many topics, all tied together with practical, real-world advice from their collective experience. The uniquely comprehensive explanations and the overall wide coverage provided in this book surpass any other content currently available.

This book is perfect for developers writing Java EE applications, as well as administrators responsible for maintaining the JBoss Application Server.

1 commentaire Donner une note à l´article (5)

464 pages, 1ère édition, 1er janvier 2009 

Édition Manning

ISBN10 : 1933988029

ISBN13 : 978-1933988023

Commandez sur www.manning.com : 44.99 $

Commandez sur www.amazon.fr :

31.49 € TTC seulement (au lieu de 39.82  € TTC : prix éditeur) livraison gratuite !

PART 1 THE JBOSS APPLICATION SERVER

  • 1 Vote for JBoss
  • 2 Managing the JBoss Application Server
  • 3 Deploying applications
  • 4 Securing applications

Part 2 APPLICATION SERVICES

  • 5 Configuring JBoss Web Server
  • 6 Securing web applications
  • 7 Configuring enterprise applications
  • 8 JBoss Messaging
  • 9 Configuring Web Services

Part 3 JBOSS PORTAL

  • 10 The JBoss Portal and portlets
  • 11 Configuring the JBoss Portal

Part 4 GOING TO PRODUCTION

  • 12 Understanding clustering
  • 13 Clustering JBoss AS services
  • 14 Tuning the JBoss Application Server
  • 15 Going to production

 
Critique du livre par la rédaction Celinio Fernandes le 1er juin 2009 

Le livre est divisé en 4 parties.

D'abord j'aimerais dire que j'ai bien aimé la table des matières. Elle montre bien que JBoss est plus qu'un serveur d'application puisqu'une partie entière est consacrée à JBoss Portal.

Dans la première partie les auteurs racontent les origines du serveur JBoss (saviez-vous que JBoss s'appelait EJBoss à l'origine et que cela signifiait Enterprise Java Beans Open Source Software ?) et décrivent l'installation de la version 5, le déploiement d'applications et la configuration.
La structure du serveur est abordée en détails avec des explications sur les MBeans (managed beans, issus de la JSR 3) et la console JMX, illustrée par des captures d'écran.
Ensuite vient le tour du déploiement d'une application, la déclaration d'une source de données, la création d'une archive HIbernate (.har) ... Les auteurs en profitent pour montrer les avantages d'un serveur d'application.
Le chapitre sur la sécurité est très intéressant. Les modules de login du framework JBoss SX, qui repose sur JAAS, sont décrits et illustrés par des exemples de configuration XML, suivant la source de données (base, LDAP, certificat ...).

La deuxième partie traite des éléments de configuration du serveur Web dans JBoss. Tout est bien passé en revue : fichiers, de configuration, archive WAR, structure d'une URL et même la configuration de JSF.
Les applications d'entreprise ne sont pas oubliées. Bien au contraire, puisque les auteurs vont même jusqu'à présenter les EJB 3 et à packager et déployer des session beans.
La sécurité des applications, aux niveaux entreprise (EJB) et web, de façon programmatique et de façon déclarative, est bien détaillée.
JBoss Messaging et les Web Services sont vus aussi. Les auteurs prennent le temps d'expliquer les technologies avant d'en parler par rapport à JBoss. C'est une approche très sympa.

La troisième partie est entièrement dédiée à JBoss Portal et c'est assez sympa puisque là encore les technologies sont présentées (Portlets, JSR-169, CMS ...).

La quatrième partie comporte un chapitre sur le clustering, avec une description d'un exemple à faire sur un serveur unique (clustering vertical). Très intéressant, tant sur la partie théorique du clustering que sur la partie configuration JBoss. Plein de petites notes sur le tuning dans JBoss, pour améliorer les performances.
Et enfin un chapitre sur des choses à faire avant de passer en production.

Ce que j'ai aimé dans ce livre : les auteurs sont sincères pour évoquer les avantages mais aussi les faiblesses de ce serveur d'application, par rapport à d'autres. Par exemple, ils admettent qu'il n'y a pas de console d'administration aussi puissante que dans Weblogic ou Websphere, mais on y vient avec Jopr.
Chaque chapitre se termine par un résumé et des liens sur les sujets qui ont été vus.

Ce que j'ai moins aimé dans ce livre : l'absence de chapitre dédié à la nouvelle console d'administration, Jopr. Mais cela est dû au fait qu'elle n'était pas encore disponible au moment de l'écriture du livre.

English version :

I would like to begin by saying that I like the table of contents. It shows that JBoss is more than an application server since a full part is about JBoss Portal.

In the first part the authors tell us about the origins of the server (did you know that JBoss was originally called EJBoss and that it meant Enterprise Java Beans Open Source Software ?) and describe the installation of version 5, the deployment of applications and the configuration.
The structure of the server is described in detail with explanations on MBeans (managed beans, from the JSR 3) and the JMX console, illustrated with screenshots.
Then comes the deployment of an application, the declaration of a data source, the creation of an Hibernate archive (.har) ... All along, the authors explain the advantages of an application server.
The chapter on security is very interesting. The login modules of the JBoss SX framework, which uses JAAS, are described and illustrated with examples of XML configuration for each type of data source (database, LDAP, certificate ...).

The second part is about the configuration of JBoss Web server. Everything is explained : configuration files, WAR archive, the structure of an URL and even the JSF configuration.
The enterprise applications are not forgotten. On the contrary, since the authors go as far as giving us a nice overview of EJB 3 and packaging and deploying session beans.
The security of applications, at the enterprise (EJB) and web levels, programmatically and declaratively, is very detailed.
JBoss Messaging and Web Services are also detailed. The authors take the time to explain the technologies before explaining them with JBoss. That is a very nice approach.

The third part is entirely dedicated to JBoss Portal and it is nice again to see that the technologies are first introduced (Portlets, JSR-169, CMS ...).

The fourth part has a chapter about clustering, with the description of an example to do on a single server (vertical clustering). Very interesting, as much in the theorical part of clustering as in the JBoss configuration part. Plenty of notes on the tuning of JBoss, to improve the performances, are also provided.
And a chapter on things to do before going into production concludes this part.

What I liked in this book : the authors are sincere when they discuss the advantages but also the weaknesses of the application server, in comparison with others. For instance, they admit that there is no administration console as powerful as in Weblogic or Websphere, but Jopr is going in the right direction.
Each chapter ends with a summary and links about the reviewed topics.

What I liked the least in this book : the lack of chapter about the new administration console, Jopr. But that is due to the fact that it was not yet available when the book was being written.

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

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

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

Collections : Les TP Informatiques

de Alexandre Brillant
Public visé : Intermédiaires, Expérimentés

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.
300 pages, 05/2007 

Édition ENI

ISBN10 : 2746036134

ISBN13 : 978-2746036130

Commandez sur www.editions-eni.fr : 25,65 ? seulement (au lieu de 27 ? : prix public)

Commandez sur www.amazon.fr :

25,65 € TTC (prix éditeur 27 € TTC) livraison gratuite !
  • 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
    • 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

 
Critique du livre par la rédaction Y. Charpiot 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 Maven: The Definitive Guide

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

Maven: The Definitive Guide

Everything You Need to Know from Ideation to Deployment

de Sonatype Company
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

For too long, developers have worked on disorganized application projects, where every part seemed to have its own build system, and no common repository existed for information about the state of the project. Now there's help. The long-awaited official documentation to Maven is here. Written by Maven creator Jason Van Zyl and his team at Sonatype, Maven: The Definitive Guide clearly explains how this tool can bring order to your software development projects. Maven is largely replacing Ant as the build tool of choice for large open source Java projects because, unlike Ant, Maven is also a project management tool that can run reports, generate a project website, and facilitate communication among members of a working team. To use Maven, everything you need to know is in this guide. The first part demonstrates the tool's capabilities through the development, from ideation to deployment, of several sample applications -- a simple software development project, a simple web application, a multi-module project, and a multi-module enterprise project. The second part offers a complete reference guide that includes: The POM and Project Relationships The Build Lifecycle Plugins Project website generation Advanced site generation Reporting Properties Build Profiles The Maven Repository Team Collaboration Writing Plugins IDEs such as Eclipse, IntelliJ, ands NetBeans Using and creating assemblies Developing with Maven Archetypes

Several sources for Maven have appeared online for some time, but nothing served as an introduction and comprehensive reference guide to this tool -- until now. Maven: The Definitive Guide is the ideal book to help you manage development projects for software, webapplications, and enterprise applications. And it comes straight from the source.

468 pages, 1ère édition, 1er octobre 2008 

Édition O'Reilly

ISBN10 : 0596517335

ISBN13 : 978-0596517335

Commandez sur www.amazon.fr :

23,06 € TTC (prix éditeur 24,28 € TTC) livraison gratuite !
  • Introduction
    • Introducing Apache Maven
    • Installing and Running Maven
  • Maven by Example
    • A simple Maven Project
    • Customizing a Maven Project
    • A Simple Web Application
    • A Multimodule Project
    • Multimodule Enterprise Project
  • Maven Reference
    • Optimizing and Refactoring POMs
    • The Project Object Model
    • The Build Lifecycle
    • Build Profiles
    • Maven Assemblies
    • Properties and Resource Filtering
    • Maven and Eclipse: m2eclipse
    • Site Generation
    • Repository Manager
    • Writing Plugins
    • Writing Plugins in Alternative Languages
  • Appendixes
    • Settings Details
    • Sun Specification Alternatives

 
Critique du livre par la rédaction Eric Reboisson le 1er février 2009 

"Maven : the definitive guide" est un livre adoptant une pédagogie très progressive sur l'outil Maven. Commençant par une présentation en surface de l'outil (son orientation déclarative, quelques commandes de base, les plugins connexes) pour continuer sur un descriptif de ses possibilités plus étendues (extension par l'écriture de plugin, intégration dans Eclipse, etc.).

Les plus

  • Un guide très complet
  • Deux échantillons de projet Maven utilisables immédiatement : une première structure simple et une autre découpée en modules comme dans le monde réel de l'entreprise (web, modèle, services, etc.)
  • La découverte de nombreux outils en dehors de Maven (Spring, Hibernate, Geronimo...)
  • Le plaisir de la découverte de l'outil, l'écriture agréable et jamais ennuyante (voire même amusante)
  • On trouvera aussi de nombreuses astuces et des conseils qui trouveront je suis sûr une place dans vos projets existants

Les moins

  • Comme Eric le soulignait précédemment, il est parfois étrange de se voir référer un schéma qui se trouve 2 ou 3 pages plus loin, mais ça c'est du détail sur la mise en page
  • Je ne trouve pas d'autres points négatifs...juste peut être que j'aurais voulu en avoir plus encore (par exemple une ouverture à d'autres systèmes de gestion de repositories d'entreprise, mais seul Nexus est retenu, compréhensible car développé par Sonatype)

A qui s'adresse ce livre ?

  • A tous ceux qui ne connaissent pas Maven, car cet ouvrage est une très bonne introduction pour ce fabuleux outil, mais aussi aux intéressés qui chercheraient à aller plus loin encore (pour ce qui concerne l'optimisation par exemple)
  • Mais également aux autres qui chercheraient à convaincre des équipes de développement réfractaires (beaucoup pensent encore que seul l'outil Ant existe) ou à trouver l'argumentaire pour convaincre des décideurs hésitants sur cette option technologique pouvant apporter bien des indicateurs au niveau d'un projet.

Voilà donc un ouvrage que j'ai vraiment apprécié et dont je conseille vivement la lecture ! A noter au final aussi la sympathique (ou pas) métaphore du fourmilier en couverture...

Critique du livre par la rédaction Eric Siber le 1er janvier 2009 

Ce livre porte bien son nom. Non seulement il est destiné à tout public, mais en plus il constitue vraiment un guide complet sur Maven 2.
En effet, il aborde tous les aspects de Maven 2 (cycle de vie, gestion de dépendances, outils, extensions, etc.) en fournissant au lecteur suffisamment d'éléments pour que celui-ci puisse approfondir s'il le souhaite.

Le découpage de l'ouvrage est bien fait et permettra à ceux qui ont déjà un peu d'expérience avec Maven de se focaliser sur l'un ou l'autre chapitre de la partie Maven by Example avant d'aller parcourir la partie Maven Reference qui se propose d'approfondir les connaissances de base.
Les premiers chapitres sont vraiment écrits dans une approche progressive et illustrent les possibilités de Maven 2 via des applications exemples représentatives.

J'ai été impressionné par le nombre d'astuces et de conseils prodigués, permettant d'utiliser Maven 2 de manière intelligente et non en suivant une simple mécanique de déclaration pure et dure de dépendances.
Si j'ai trouvé le chapitre sur les assemblies un peu plus indigeste que les autres, celui sur m2eclipse devrait ravir ceux qui sont lassés par l'édition de fichier XML et ne se sentent pas assez productifs dans leur utilisation de Maven 2 (on regrettera juste que les illustrations soient parfois à 1 ou 2 pages de la description, la faute au nombre important de visuels nécessaires à ce chapitre).
Les chapitres plus avancés sur Nexus et la création de plugins sont également intéressants, même si sans doute moins utiles à la majorité des lecteurs. On a notamment droit à un éventail complet de l'utilisation et configuration de Nexus, excellent point de départ pour vous aider à initier un proxy/repository d'entreprise.

Enfin, on appréciera la présence des 2 annexes permettant respectivement d'avoir un aperçu des éléments de configuration pouvant être déclarés dans le fichier de configuration global (settings.xml), ainsi que les artefacts du serveur Geronimo qui vous permettrons de pallier à l'indisponibilité (via les repositories) de ceux correspondants à la spécification Java EE (vous évitant de devoir installer ces derniers à la main).

En conclusion, Maven: The Definitive Guide est un livre bien écrit, assez complet, et dans lequel tout lecteur devrait s'y retrouver.
Ce qui est vraiment appréciable, c'est que les auteurs ne masquent en aucun cas les défauts et problématiques courantes survenant avec Maven 2, mais surtout qu'ils fournissent au lecteur les outils et pratiques pour traiter ces derniers.
Un livre à recommander.

 
couverture du livre Les Cahiers du programmeur Java EE 5

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

Les Cahiers du programmeur Java EE 5

de Antonio Goncalves
Public visé : Intermédiaires, Expérimentés

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.

329 pages, 1ère édition, 1er mai 2007 

Édition Eyrolles

ISBN10 : 2212120389

Broché

Commandez sur http://www.eyrolles.com : 34,20 € TTC seulement (au lieu de 36,00 € TTC : prix public)

Commandez sur www.amazon.fr :

34,20 € 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
    1. Spécifications EE5
    2. Tâches ANT
    3. Sigles et acronymes
    4. EJB2

 
Critique du livre par la rédaction Anis Frikha 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.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Filthy Rich Clients

de Chet Haase, Romain Guy
Public visé : Intermédiaires,Expérimentés

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.

608 pages, 1ère édition, 19 août 2007 

Édition Prentice Hall PTR

ISBN10 : 0132413930

ISBN13 : 9780132413930

Broché

Commandez sur www.amazon.fr :

32.01 € TTC seulement (au lieu de 33.70  € TTC : prix éditeur) livraison gratuite !
  1. Graphics and GUI Fundamentals
    1. Desktop Java Graphics APIs: Swing, AWT, and Java 2D
    2. Swing Rendering Fundamentals
    3. Graphics Fundamentals
    4. Images
    5. Performance
  2. Advanced Graphics Rendering
    1. Composites
    2. Gradients
    3. Image Processing
    4. Glass Pane
    5. Layered Panes
    6. Repaint Manager
  3. Animation
    1. Animation Fundamentals
    2. Smooth Moves
    3. Timing Framework: Fundamentals
    4. Timing Framework: Advanced Features
  4. Effects
    1. Static Effects
    2. Dynamic Effects
    3. Animated Transitions
    4. 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.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java Persistence et Hibernate

de Anthony Patricio
Public visé : Intermédiaires,Expérimentés

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.

365 pages, 1ère édition, 18 décembre 2007 

Édition Eyrolles

ISBN10 : 2212122594

ISBN13 : 9782212122596

Commandez sur eyrolles.com : 39,90 € TTC seulement (au lieu de 42,00 € TTC : prix public)

Commandez sur www.amazon.fr :

39.90 € TTC seulement (au lieu de 42.00  € TTC : prix éditeur) livraison gratuite !
  1. Préface
  2. Remerciements
  3. Table des matières
  4. Avant-propos
  5. Persistance et mapping objet-relationnel
  6. Démarrer avec Java Persistence
  7. Métdadonnées et mapping des entités
  8. Héritage, polymorphisme et modèles complexes
  9. Méthodes de récupération des entités
  10. Création, modification et suppression d'entités
  11. Obtenir et manipuler le gestionnaire d'entités
  12. Fonctionnalités de mapping avancées
  13. La suite Hibernate Tools
  14. Projets annexes Java Persistence/Hibernate
  15. 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.0drapeaucdrom
Détails du livre
Sommaire
Critiques (3)
 
 

Programmer en Java

de Claude Delannoy
Public visé : Débutants,Intermédiaires,Expérimentés
Introduction : 5ème édition Java 5 et 6

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.

799 pages, 5ème édition, 11 octobre 2007 

Édition Eyrolles

ISBN10 : 2212122322

Commandez sur eyrolles.com : 33,25 € TTC seulement (au lieu de 35,00 € TTC : prix public)

Commandez sur www.amazon.fr :

33.25 € TTC seulement (au lieu de 35.00  € TTC : prix éditeur) livraison gratuite !
  1. Présentation de Java
  2. Généralités
  3. Les types primitifs de Java
  4. Les opérateurs et les expressions
  5. Les instructions de contrôle de Java
  6. Les classes et les objets
  7. Les tableaux
  8. L'héritage
  9. Les chaînes de caractères et les types énumérés
  10. La gestion des exceptions
  11. Les threads
  12. Les bases de la programmation graphique
  13. Les contrôles usuels
  14. Les boîtes de dialogue
  15. Les menus, les actions et les barres d'outils
  16. Les évènements de bas niveau
  17. Les gestionnaires de mise en forme
  18. Textes et graphiques
  19. Les applets
  20. Les flux et les fichiers
  21. La programmation générique
  22. Les collections et les algorithmes
  23. Programmation Java côté serveur : servlets et JSP
  24. 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 BWP-Necromance 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.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java Generics

and Collections

de Maurice Naftalin, Philip Wadler
Public visé : Expérimentés, Intermédiaires

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.

273 pages, 1ère édition, 1er novembre 2007 

Édition O'Reilly

ISBN10 : 0-59652775-6

ISBN13 : 978-0-596-52775-4

Broché

Commandez sur www.amazon.fr :

21,27 € TTC (prix éditeur 25,01 € TTC) livraison gratuite !
  • 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 janvier 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 Checking Java Programs

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

Checking Java Programs

de Ian F. Darwin
Public visé : Débutants, Intermédiaires

Résumé de l'éditeur

This Short Cut tells you about tools that will improve the quality of your Java code, using checking above and beyond what the standard tools do, including:

  • Using javac options, JUnit and assertions
  • Making your IDE work harder
  • Checking your source code with PMD
  • Checking your compiled code (.class files) with FindBugs
  • Checking your program's run-time behavior with Java PathFinder
54 pages, 1ere édition, 1er mars 2007 

Édition O'Reilly

ISBN10 : 0596510233

Format PDF

Commandez sur www.amazon.fr :

  • What It's Not About
  • It Usually Begins with javac
  • Making Your IDE Work Harder
  • Source Code Checking with PMD
  • Static (Class File) Checking with FindBugs
  • Dynamic Checking with NASA's Java PathFinder
  • What's Next ?

 
Critique du livre par la rédaction Baptiste Wicht le 1er décembre 2007 

Tout d'abord, ce livre ne se veut pas un livre complet sur les programmes cités ici. C'est une introduction à l'analyse de programmes. Ce livre est donc destiné aux programmeurs qui n'ont pas encore testés leurs propres outils d'analyse et qui aimeraient en savoir plus sur les possibilités existantes dans ce domaine.

L'auteur va tout d'abord nous parler des warnings du compilateur Java (javac) et de la manière dont on peut les configurer pour n'avoir que ceux qu'on désire vraiment traiter. Il va ensuite nous montrer comment les configurer dans Eclipse. L'auteur utilisera Eclipse pour tous les exemples concernant l'intégration avec un IDE.

Après avoir vu les possibilités du compilateur Java, on va passer dans le vif du sujet avec la présentation de trois outils pour trois besoins différents. Tout d'abord, on va découvrir un outil d'analyse de code source, PMD. L'auteur va nous montrer comment faire marcher PMD de manière standalone, ensuite dans Ant, puis dans Eclipse et enfin, il va nous montrer comment étendre PMD avec de nouvelles règles. On va également découvrir CPD qui est un utilitaire de PMD permettant de détecter des portions de code copiées-collées.

L'auteur va suivre cette structure pour les 3 programmes présentés dans l'article, ce qui permet de s'y retrouver facilement. A la fin de chaque chapitre sur un outil, on va retrouver un résumé avec les points importants de chaque partie de la présentation. Ce résumé permet très succinctement de placer l'outil dans son contexte et de découvrir les principaux avantages du produit. Ce qui peut se révéler très intéressant si on revient sur le livre un moment après l'avoir lu.

Ensuite, l'auteur va nous présenter un outil d'analyse statique, FindBugs. Il va nous montrer l'utilisation en ligne de commande ou avec l'interface graphique de cet outil et nous montrer ce qu'on peut faire avec. Une courte partie est consacrée à une partie peu connue de FindBugs, le datamining. Cela permet de faire des comparaisons entre plusieurs analyses FindBugs pour vérifier l'avancement des erreurs, le nombre d'erreurs résolues et le nombre d'erreurs supplémentaires. On peut également suivre l'avancement du projet avec cet utilitaire étant donné qu'il nous donne par exemple le nombre de classes du projet.

Enfin, l'auteur nous présente le dernier outil, un outil d'analyse dynamique, Java PathFinder développé par la NASA. Cet outil permet de tester tous les chemins d'exécution possible de votre programme et permet de détecter certains problèmes comme des DeadLocks ou des exceptions non gérées. Il se révèle très utile dans un programme multi-threadé pour trouver des problèmes de concurrence.

En conclusion, ce livre est une très bonne introduction à l'analyse de programmes Java et vous permettra de découvrir trois excellents programmes d'analyse. Les programmes présentés ne sont qu'une sélection, il en existe d'autres, mais ils sont choisis parmi les meilleurs et dans un tel article, il n'aurait servi à rien de présenter plusieurs programmes de même catégorie. L'article se lit bien, mais certains passages sont plus difficiles à suivre. Il m'a fallu revenir plusieurs fois sur le même paragraphe pour bien le comprendre, mais en général, la lecture se révèle fluide et agréable. Je le conseille donc à tous les programmeurs Java qui aimeraient se lancer dans l'analyse de leurs programmes mais ne savent pas par où commencer.

 
couverture du livre Professional Java Development with the Spring Framework

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

Professional Java Development with the Spring Framework

de Rod Johnson, Juergen Hoeller, Alef Arendsen, Thomas Risberg and Collin Sampaleanu
Public visé : Débutants, Intermédiaires

Résumé de l'éditeur

The Spring Framework is a major open source application development framework that makes Java/J2EE(TM) development easier and more productive. This book shows you not only what Spring can do but why, explaining its functionality and motivation to help you use all parts of the framework to develop successful applications.

You will be guided through all the Spring features and see how they form a coherent whole. In turn, this will help you understand the rationale for Spring's approach, when to use Spring, and how to follow best practices. All this is illustrated with a complete sample application. When you finish the book, you will be well equipped to use Spring effectively in everything from simple Web applications to complex enterprise applications.

What you will learn from this book

  • The core Inversion of Control container and the concept of Dependency Injection
  • Spring's Aspect Oriented Programming (AOP) framework and why AOP is important in J2EE development
  • How to use Spring's programmatic and declarative transaction management services effectively
  • Ways to access data using Spring's JDBC functionality, iBATIS SQL Maps, Hibernate, and other O/R mapping frameworks
  • Spring services for accessing and implementing EJBs
  • Spring's remoting framework

Who this book is for

This book is for Java/J2EE architects and developers who want to gain a deeper knowledge of the Spring Framework and use it effectively.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

643 pages, 1ere édition, 1er juillet 2005 

Édition Wrox, Wiley Publishing

ISBN10 : 0764574833

Broché

Commandez sur www.amazon.fr :

25,13 € TTC (prix éditeur 29,57 € TTC) livraison gratuite !
  • Introducing the Spring Framework
  • The Bean Factory and Application Context
  • Advanced Container Concepts
  • Spring and AOP
  • DAO Support and JDBC Framework
  • Transaction and Resource Management
  • Object/Relational Mapping
  • Lightweight Remoting
  • Supporting Services
  • Acegi Security System for Spring
  • Spring and EJB
  • Web MVC Framework
  • Web View Technologies
  • Integrating with Other Web Frameworks
  • The Sample Application
  • Conclusion
  • Appendix A : Requirements for the Sample Application

 
Critique du livre par la rédaction Gildas CUISINIER (hikage) le 1er octobre 2007 

Ce livre est excellent, c'est grâce à lui que j'ai appris les bases de Spring. Bien qu'en anglais, il est très agréable et facile à lire.

Pour les novices, c'est effectivement un support de choix : il va introduire Spring en douceur par l'explication des raisons d'être de celui-ci, pour ensuite expliquer certaines notions sur lesquelles se base Spring (l'injection de dépendance, l'inversion de contrôle, la programmation orientée aspect) sans devenir pénible et difficile à lire.
Il présentera ensuite techniquement les différents services que Spring apporte dans le développement, allant des possibilités de simplification de la couche DAO, à la programmation distribuée ou encore le développement Web grâce à son module MVC.

Ces qualités font de lui un très bon guide pour apprendre Spring, mais aussi un aide mémoire lorsqu'un petit trou de mémoire survient. Il m'arrive encore régulièrement de le relire afin de rafraîchir certains points précis.

De plus, un des auteurs est aussi l'un des créateurs de Spring, Rod Johnson, qui n'en est pas à son premier livre populaire dans le monde Java/J2EE.
Il connait donc bien son sujet, et arrive sans peine à le vendre, et même à nous donner envie d'en savoir plus sur Spring.

Mon seul regret est qu'il n'a pas encore été réédité en prenant en compte les nouveautés de la version 2.0 de Spring, et est donc limité à la version précédente : 1.2

 
couverture du livre Rich Client Programming

Note 5.0drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

Rich Client Programming

Plugging into the Netbeans Platform

de Tim Boudreau, Jaroslav Tulach et Geertjan Wielenga
Public visé : Intermédiaires, Expérimentés

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
640 pages, 1ère édition, 1er mai 2007 

Édition Prentice Hall PTR

ISBN10 : 0132354802

ISBN13 : 978-0132354806

18 x 3 x 23 cm, broché

Commandez sur www.amazon.fr :

37.42 € TTC seulement (au lieu de 49.99  € TTC : prix éditeur) livraison gratuite !
  • 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 Nicolas Coquelet (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 http://blogs.sun.con/geertjan/ Geertjan's blog 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 Le guide de Survie

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

Le guide de Survie

Java: L'essentiel du code et des commandes

de Timothy Fisher
Public visé : Débutants, Intermédiaires

Résumé de l'éditeur

Ce Guide de survie vous livre tout le code dont vous avez besoin pour réaliser rapidement et efficacement vos projets de développement en Java. Facile à transporter, facile à utiliser - finis les livres encombrants ! Plus de 100 fragments de code personnalisables pour programmer du Java fonctionnel dans toutes les situations.

232 pages, 1er mars 2007 

Édition CampusPress

ISBN10 : 2744021628

Commandez sur www.amazon.fr :

15,20 € TTC (prix éditeur 16 € TTC) livraison gratuite !

Java: Le guide de Survie

  • Introduction
  • Les bases
  • Interagir avec l'environnement
  • Manipuler des chaines
  • Travailler avec des structures de données
  • Dates et Heures
  • Retrouvez des motifs avec des expressions régulières
  • Nombres
  • Entrées/Sorties
  • Travailler avec des répertoires et des fichiers
  • Clients Réseau
  • Serveurs Réseau
  • Envoyer et recevoir des emails
  • Accès aux bases de données
  • XML
  • Utiliser des Threads
  • Programmation dynamique par réflexion
  • Empaquetage et documentation des classes
  • Index

 
Critique du livre par la rédaction Vincent Brabant le 1er septembre 2007 

Une excellente FAQ de poche

Ce livre de poche, complément idéal de l'Aide-Mémoire Java publié chez Dunod, se présente comme un guide de survie. C'est en fait une bonne petite FAQ couvrant les API de bases de Java. Que ce soit les entrées/sortie, la manipulation des chaines de caractères, des dates, des nombres. Mais cela couvre également d'autres domaines comme l'écriture/lecture de fichiers ZIP, l'envoi/réception de mails via JAVAMail, la transformation XML par XSLT, ....

Je vous laisse découvrir par vous-même la table des matières pour que vous sachiez exactement ce qu'il couvre.

La façon dont le livre est découpé, et dont les exemples de code sont présentés, permet de trouver rapidement ce que l'on cherche.
En effet, quasi chaque sous-chapitre d'un chapitre commence par un bout de code, en blanc sous fond noir. Ce qui fait que lorsqu'on feuillete ou parcourt rapidement le livre ou un chapitre à la recherche d'une solution à notre problème, notre regard est directement attiré sur le code, ce qui en facilite grandement sa recherche.

Chaque code est accompagné d'un texte explicatif, lorsque c'est nécessaire, mais surtout d'autres détails et/ou astuces supplémentaires y sont donnés.

Les bouts de code sont toujours très courts mais toujours utilisables.

J'ai noté quelques exemples pour lesquels je ne suis personellement pas toujours d'accord. Ainsi, pour voir si une chaîne de caractères contient un nombre, il utilise le parseInt() de la classe Integer enrobé dans un try-catch avec NumberFormatException. Sachant qu'une exception coute cher, je préfère utiliser d'autres techniques que cela pour vérifier que c'est bien un nombre.
Aussi, lorsqu'il s'agit d'additionner et de soustraire des dates, ou de calculer la différence entre deux dates, son auteur propose à chaque fois d'additionner/soustraire des millisecondes ou de convertir en millisecondes.
J'aurais préféré qu'il propose des exemples de code où il utilise JodaTime, tout comme il propose des exemples de code avec JavaMail pour la gestion des mails.
JodaTime est vraiment l'API qu'il vous faut si vous devez manipuler des dates et des intervalles de dates. D'ailleurs, une JSR a été créée récemment pour introduire JodaTime dans une prochaine version du JDK

A part cela, je n'ai trop rien à dire. Une vraie petite FAQ de poche.

 
couverture du livre SCJP

Note 4.0drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

SCJP

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

de Kathy Sierra et Bert Bates
Public visé : Intermédiaires, Expérimentés

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)
825 pages, 1ère édition, 1er décembre 2005 

Édition McGraw-Hill/Osborne Media

ISBN10 : 0072253606

Broché

Commandez sur www.amazon.fr :

38,20 € TTC (prix éditeur 38,20 € 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 Gildas CUISINIER (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.

 
precedentsommairesuivant

  

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