IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Architectures et serveurs d'application

18 livres et 24 critiques, dernière mise à jour le 22 novembre 2020 , note moyenne : 4.5

  1. EJB 3 - Des concepts à l'écriture du code. Guide du développeur
  2. JSP et Servlets efficaces : Production de sites dynamiques en Java
  3. Architectures réparties en Java - RMI, CORBA, JMS, sockets, SOAP, services web
  4. JBoss AS Performance Tuning
  5. 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
  6. JBoss AS 5 Development
  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. Beginning Java™ EE 6 Platform with GlassFish™ 3 - From Novice to Professional
  12. Les Cahiers du programmeur Java EE 5
  13. Spring Recipes: A Problem-Solution Approach
  14. Pro Spring 2.5
  15. Professional Java Development with the Spring Framework
  16. Eclipse et JBoss
  17. Programmation Orienté Aspect pour Java / J2EE
  18. Refactoring des applications Java/J2EE
couverture du livre EJB 3 - Des concepts à l'écriture du code. Guide du développeur

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

EJB 3 - Des concepts à l'écriture du code. Guide du développeur

de
Public visé : Intermédiaire

Résumé de l'éditeur

Cet ouvrage est fondé sur les cours dispensés par le laboratoire SUPINFO des technologies Sun. Son objectif est de présenter et d'illustrer la nouveauté majeure de la dernière version de la plate-forme Java Entreprise : EJB 3.

Il a été conçu comme un guide de formation et un support de référence répondant aux questions concrètes de développement et de maintenance des services et des objets métiers. Il comporte une étude pratique complète basée sur un cas concret de développement d'une application entreprise ainsi qu'un chapitre dédié à EJB 3.1.

Cet ouvrage conviendra aux développeurs Java désireux de s'initier aux systèmes de persistance des données, aux développeurs EJB 2 souhaitant évoluer vers un système plus modulable et plus rapide à mettre en place ainsi qu'aux développeurs J2EE cherchant à la fois un système performant de persistance de données et un guide pratique proposant de nombreux exemples de code prêt à l'emploi.

Le code source des exemples et des applications est téléchargeable sur www.labo-sun.com et sur www.dunod.com

Édition : Dunod - 350 pages, 2e édition, 9 juillet 2008

ISBN10 : 2100518313 - ISBN13 : 9782100518319

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Concepts architecturaux.
  • Java EE 5 et les EJB 3.
  • Les Sessions Beans.
  • Les Entity Beans.
  • Les Message Driven Beans.
  • L'unité de persistance.
  • Le SQL selon EJB (l'EJB-QL).
  • Le développement côté client.
  • Les transactions.
  • Les outils indispensables (Net Beans, JBoss et Seam).
  • Cas pratique : gestion d'un portefeuille d'actions.
  • EJB 3.1 et Java EE 6.
  • L'avenir d'EJB 3
Critique du livre par la rédaction prenom nom le 2 mai 2011
Au cours de mon expérience de développeur JEE, j'ai été confronté à divers projets dans diverses entreprises. Sans vouloir généraliser, j'ai quand même observé qu'on utilisait des serveurs d'application JEE bien en deçà de leurs capacités. On se servait de WebLogic, de WebSphere comme de simples conteneurs web alors qu'un simple Tomcat aurait pu suffire. Je pense que ces entreprises étaient rassurées par le support d'entreprises de marques reconnues comme BEA ou IBM.

De plus, la technologie EJB dans ses premières versions semblait beaucoup trop lourde à mettre en oeuvre pour s'y investir. Je ne pense pas trop me tromper en disant que la communauté Java partageait cette opinion. C'est d'ailleurs à la recherche de solutions plus légères (comme l'ORM Hibernate) qu'on doit l'évolution vers cette troisième version des EJB.

Ce livre vous montrera qu'en retournant au bon vieil objet Java (POJO), à la configuration par exception et en utilisant la nouvelle API de persistance (JPA), les EJB méritent qu'on s'y intéresse à nouveau.

Ce livre compare la nouvelle version à l'ancienne. Si vous connaissez les EJB 2, vous découvrirez rapidement les apports des EJB 3. Si vous ne les connaissez pas, cela sera également instructif. On pourrait craindre que des exemples de code obsolètes alourdissent la lecture. Bien au contraire, ils explicitent justement ce qui a été masqué par la simplification.

J'ai également apprécié le schéma qui décrit où doit se trouver le fichier de persistance dans les différentes configurations (ear, war, jar).
Ce livre a changé ma vision des EJB. Je vois désormais mieux l'intérêt des Sessions Beans, de JMS et de JTA.

Les auteurs ont eu la bonne idée d'inclure en fin d'ouvrage un exemple concret d'application pour illustrer leurs propos.
En conclusion, ce livre m'a donné envie de réessayer ces technologies, surtout maintenant que je sais qu'il existe des conteneurs EJB légers qu'on peut ajouter dans Tomcat.


couverture du livre JSP et Servlets efficaces : Production de sites dynamiques en Java

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

JSP et Servlets efficaces : Production de sites dynamiques en Java

de

Résumé de l'éditeur

Ce livre s'adresse aux développeurs qui utilisent Java dans la production de sites et à ceux qui souhaitent découvrir l'aspect serveur web. Il permettra aussi un apprentissage concret de ces technologies aux étudiants en informatique en fin de licence et en master.

Vous y trouverez les connaissances nécessaires pour construire un site dynamique riche, attrayant et robuste. L'auteur explique comment mettre en oeuvre simplement des JSP et construire des sites complets au moyen des servlets. Il détaille ensuite les concepts fondamentaux des servlets, ainsi que leurs applications pratiques, et décrit le positionnement des JSP et des servlets par rapport à d'autres architectures. De nombreux exemples pratiques (génération de classeurs Excel, de documents PDF) sont réutilisables. Cette nouvelle édition, complètement réécrite, met davantage l'accent sur les grands principes de développement objet (separation of concerns, inversion de dépendance) et l'architecture MVC. Elle intègre un chapitre sur Ajax, un autre sur le langage Unified EL et une brève présentation de quelques frameworks.

L'auteur a pris le parti systématique des documents JSP (en XML) avec utilisation de EL. La partie sur les scriptlets est toujours disponible dans les compléments en ligne.

Édition : Dunod - 482 pages, 2e édition, 21 juin 2007

ISBN10 : 2100513672 - ISBN13 : 9782100513673

Commandez sur www.amazon.fr :

38.95 € TTC (prix éditeur 41.00 € TTC)
  • Application Web
  • JSP
  • JSTL
  • Beans
  • Traitement des formulaires : servlets
  • Sessions
  • Accès aux bases de données
  • Fichiers Tags
  • Autres formes de Tags
  • Ajax
  • Paramétrage de l'application web et listeners
  • Exceptions
  • Accès concurrent aux ressources
  • Filtres
  • Utilisation avancée de bases de données
  • Sécurité
  • XML et XSL
  • Utilisation d'XML dans une application web
  • SVG
  • Unified EL
  • Frameworks
Critique du livre par la rédaction prenom nom le 8 février 2011
Le titre de cet ouvrage est justifié car après l'avoir lu, il est certain que si vous avez suivi les recommandations de l'auteur, vous obtiendrez un site efficace (comprenez "bien développé et maintenable"). Toutefois, ce titre peut aussi être trompeur et laisser croire qu'il s'adresse uniquement à un public averti or il n'en est rien, bien au contraire ! Je dirai même que cet ouvrage est mieux résumé par son sous-titre "Production de sites dynamiques en Java".
L'auteur parle bien évidemment des JSP et des Servlets mais aussi de tout ce qui tourne autour (bases de données, AJAX, sécurité…). C'est selon moi à la fois une bonne et une mauvaise chose : une bonne chose car en un seul livre, l'auteur réunit tout ce qu'il faut savoir pour faire un site web en Java ; une mauvaise chose car chacun des sujets connexes abordés contribue à alourdir le livre.

Après, tout dépend de votre profil de lecteur : si vous recherchez un ouvrage pour approfondir vos connaissances JEE, celui-ci n'est pas le plus adapté. Quoique les chapitres sur l'écriture de vos propres tags, de vos filtres personnalisés ne sont pas dénués d'intérêt ; si vous êtes étudiant, débutant, si vous n'avez qu'effleuré la création de site dynamique avec PHP et que vous souhaitez essayer un langage plus professionnel comme Java, ce livre est fait pour vous ! L'auteur vous prend par la main, montre comment procéder avec Netbeans, explique les bases de l'Objet. Il vous enseigne les bonnes pratiques (MVC, pool de connexion, problèmes de concurrence et de sécurité…) et vous introduit les principaux frameworks JEE (Struts, Spring, JSF, Hibernate…).

Notez également que chaque chapitre se termine par un résumé, un QCM ou une liste d'exercices, ce qui confirme le caractère didactique de cet ouvrage et dans cette optique, je vous le recommande.


couverture du livre Architectures réparties en Java

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

Architectures réparties en Java

RMI, CORBA, JMS, sockets, SOAP, services web

de
Public visé : Intermédiaire

Résumé de l'éditeur

Ce livre s'adresse aux ingénieurs logiciel, développeurs, architectes et chefs de projet. Il s'adresse aussi aux étudiants en écoles d'ingénieurs et en masters d'informatique.

Une architecture logicielle répartie suppose des données différentes et des tâches différentes traitées sur des machines différentes. Il en découle bien évidemment des problèmes de transmissions de données et de synchronisation entre processus. Très longtemps les applications réparties ont été réservées à des applications d'experts (espace, militaire), mais à présent les besoins se diversifient (communication en pair à pair, multiplication des réseaux). Le langage Java qui est né avec les applications en réseau apporte une simplification importante qui met cette technologie à la portée de tous, notamment dans le monde industriel.

Le but de cet ouvrage est de donner les clés qui permettront de définir la solution la mieux adaptée à chaque situation rencontrée. Il commence par une explication des concepts de base des architectures réparties en Java. Il tente ensuite d'extraire la substantifique moelle sur la meilleure manière de faire communiquer deux machines entre elles. Enfin, il donne une vue d'ensemble des solutions techniques actuellement disponibles.

Disponible en ligne, le code a été volontairement simplifié dans l'ouvrage pour une lecture synthétique - notamment en omettant les packages et les exceptions qui sont proposées automatiquement par les environnements de développement classique.

Édition : Dunod - 201 pages, 1re édition, 3 octobre 2007

ISBN10 : 2100511416 - ISBN13 : 9782100511419

Commandez sur www.amazon.fr :

26.06 € TTC (prix éditeur 28.00 € TTC)
  • Problématique des architectures réparties.
  • Rappels sur Java
  • Sockets et Java NIO
  • Interfaces et pliage des arguments
  • RMI
  • Corba
  • Annuaires LDAP-JNDI
  • JMS
  • SOAP et les services web
  • JMX
Critique du livre par la rédaction prenom nom le 2 août 2011
L'intérêt de ce livre est de présenter ce qui existe en Java pour développer des applications réparties (RMI, CORBA, JMS, sockets, Web Services SOAP) et pour les administrer (JMX).

Avec le développement d'Internet, alors que les Web Services sont de plus en plus utilisés (passage des firewalls), ce livre montre également comment des technologies plus anciennes et éprouvées comme CORBA inspirent les nouvelles par les services qu'elles procurent (gestion de la sécurité, des transactions…)

J'ai particulièrement apprécié les références croisées entre les sujets. Par exemple : les différences entre RMI et CORBA, l'apport de JMS par rapport aux sockets, la comparaison entre les IDL de CORBA et les WSDL de SOAP…

Si le rappel de certaines notions Java est une intention louable, je suis plus réservé sur leur réelle utilité : les exemples sont suffisamment simples.
Mon chapitre préféré est celui sur les Web Services car il présente à la fois la création de Web Service SOAP avec AXIS (génération du code à partir de l'interface) et la création de Web Service SOAP avec Java 6 (génération d'interface à partir du code). Je regrette cependant que les Web Services REST n'aient pas été abordés (peut-être dans une prochaine version ?).

Si vous êtes intéressé par une seule de ces technologies, un ouvrage dédié sera probablement plus adapté mais pour une vue d'ensemble, celui-ci convient très bien.


couverture du livre JBoss AS Performance Tuning

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

JBoss AS Performance Tuning

de
Public visé : Expert

Résumé de l'éditeur

Today's organizations need to deliver faster services to a large set of people and businesses. In order to survive this challenge, enterprises need to optimize the performance of their application server along with its components and hardware. Writing faster applications is no longer just an option for your products; it's an imperative requirement, which you cannot ignore. JBoss AS 5 Performance Tuning will teach you how to deliver fast applications on the JBoss Application Server and Apache Tomcat, giving you a decisive competitive advantage over your competitors. You will learn how to optimize the hardware resources, meeting your application requirements with less expenditure. The performance of Java Enterprise applications is the sum of a set of components including the Java Virtual Machine configuration, the application server configuration (in our case, JBoss AS), the application code itself and ultimately the operating system. This book will show you how to apply the correct tuning methodology and use the tuning tools that will help you to monitor and address any performance issues. By looking more closely at the Java Virtual Machine, you will get a deeper understanding of what the available options are for your applications and how their performance will be affected. You will learn about thread pool tuning, EJB tuning, JMS tuning, Enterprise Java Beans, and the Java Messaging Service. The persistence layer and JBoss Clustering service each have a chapter dedicated to them as they are two of the most crucial elements to configure correctly in order to run a fast application. You will also learn how to tune your web server, enabling you to configure and develop web applications that get the most out of the embedded Tomcat web server. A practical guide to configure and develop lightning fast applications on JBoss AS and its embedded web server, Apache Tomcat

Édition : Packt Publishing - 312 pages, 1er décembre 2010

ISBN10 : 184951402X - ISBN13 : 9781849514026

Commandez sur www.amazon.fr :

31.49 € TTC (prix éditeur 34.04 € TTC) livraison gratuite !
(list][*]Preface[*]Chapter 1: Performance Tuning Concepts[*]Chapter 2: Installing the Tools for Tuning[*]Chapter 3: Tuning the Java Virtual Machine[*]Chapter 4: Tuning the JBoss AS[*]Chapter 5: Tuning the Middleware Services[*]Chapter 6: Tuning the Persistence Layer[*]Chapter 7: JBoss AS Cluster Tuning[*]Chapter 8: Tomcat Web Server Tuning[*]Chapter 9: Tuning Web Applications on JBoss AS[*]Appendix: A Tuned Mind[/list]
Critique du livre par la rédaction Antonio Gomes Rodrigues le 1er décembre 2010
Ce livre de 312 pages a pour but de nous apprendre le tuning de JBoss AS 5. Pour cela l'auteur commence par nous expliquer sa méthodologie et les outils qu'il va utiliser. JBoss étant gratuit et opensource, les outils utilisés (VisualVM, JMeter, Eclipse TPTP) le seront aussi.

Puis commence la partie technique du tuning avec la JVM. Le tout avec des tests chiffrés, des conseils, de la théorie et de la pratique.
On verra comment choisir la taille maximum de la JVM, comment compartimenter la mémoire de la JVM, comment choisir le meilleur comportement du Garbage Collector… Puis chacun des modules (Pool JDBC, thread pool, provider JMS, EJB, Hibernate, Tomcat Web Server…) de JBoss seront traités.

Là encore l'auteur nous explique comment choisir la taille des pools, détecter les fuites de connexions à la base de données, paramétrer les logs…
Un chapitre entier présente le clustering avec JBoss et le cache distribué "JBoss Cache". En derniers chapitres, on a droit à comment programmer une application Web rapide avec une comparaison entre JSP/Servlet et JSF et RichFaces. Le tout en expliquant bien que la productivité du développeur est aussi très importante. Puis les Web services seront traités.

L'auteur ne se contente pas seulement de nous expliquer le tuning de JBoss mais aussi tout ce qui est autour comme le tuning de l'OS, le tuning du réseau, le tuning de Hibernate… Tout ça afin d'avoir l'application la plus performante possible.

En résumé on se retrouve avec un livre facile à lire et à comprendre, très complet et avec un retour d'expérience de l'auteur qui maîtrise le sujet, ce qui permet d'avoir un certain nombre de conseils qui sont parfois difficiles à obtenir.

Un livre que j'aurais bien aimé avoir lorsque j'ai commencé à m'intéresser au tuning de serveur d'application.


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

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

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

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

de
Public visé : Débutant

Résumé de l'éditeur

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

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

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

Tout au long des chapitres, l'auteur :

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


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

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

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

ISBN10 : 2746055678 - ISBN13 : 9782746055674

Commandez sur www.amazon.fr :

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

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

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

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

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




 Commenter Signaler un problème

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

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

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

 
couverture du livre JBoss AS 5 Development

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

JBoss AS 5 Development

de

Résumé de l'éditeur

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

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

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

ISBN10 : 1847196829 - ISBN13 : 9781847196828

Commandez sur www.amazon.fr :

35.16 € TTC (prix éditeur 37.48 € TTC)
  • Chapter 1: Installing Core Components
  • Chapter 2: What's New in JBoss AS 5 ?
  • Chapter 3: Customizing JBoss AS Services
  • Chapter 4: Developing EJB 3 Session Beans
  • Chapter 5: Developing JPA Entities
  • Chapter 6: Creating a Web Application
  • Chapter 7: Developing Applications with JBoss Messaging Service
  • Chapter 8: Developing Applications with JBoss and Hibernate
  • Chapter 9: Managing JBoss AS
  • Chapter 10: Developing Applications with JBoss Web Services
  • Chapter 11: Clustering JBoss AS
  • Chapter 12: Developing a Clustered Application
  • Chapter 13: JBoss AS Security
  • Chapter 14: Securing JBoss AS Applications
Critique du livre par la rédaction Cel Fer 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.




 Commenter Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
l 13/02/2010 à 11:37

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

Elle se trouve ici : http://java.developpez.com/livres/?page=Anglais#L9781847196828

Si vous avez des questions ou remarques, n'hésitez pas.

 
couverture du livre Modular Java

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

Modular Java

Creating Flexible Applications With OSGi and Spring

de
Public visé : Intermédiaire

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.

Édition : O'Reilly - 260 pages, 1re édition, 1er juin 2009

ISBN10 : 1934356409 - ISBN13 : 9781934356401

Broché

Commandez sur www.amazon.fr :

23.59 € TTC (prix éditeur 24.84 € TTC)
  • 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 novembre 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.




 Commenter Signaler un problème

Avatar de Baptiste Wicht Baptiste Wicht - Expert éminent sénior https://www.developpez.com
l 03/11/2009 à 10:24
Bonjour,

Je viens de terminer ma critique du livre Modular Java de Craig Walls.

Comme son titre l'indique, ce livre présente le développement d'applications Java modulaires en utilisant les technologies OSGi et Spring.

Vous pouvez trouver ma critique ici : http://java.developpez.com/livres/?p...L9781934356401

 
couverture du livre Spring par l'exemple

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

Spring par l'exemple

de

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.

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

ISBN10 : 2744023396 - ISBN13 : 9782744023392

Broché

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • 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.




 Commenter Signaler un problème

Avatar de Baptiste Wicht Baptiste Wicht - Expert éminent sénior https://www.developpez.com
l 31/07/2009 à 16:31
Je viens de terminer ma lecture de Spring par l'exemple.

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.

[...]

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.
Vous pouvez lire la critique complète sur notre page livres : http://java.developpez.com/livres/?p...L9782744023392

Voilà
Avatar de kmdkaci kmdkaci - Membre éprouvé https://www.developpez.com
l 03/08/2009 à 10:47
Bonjour,
Merci pour la critique. Juste une suggestion, ça aurait été mieux de mettre l'annonce dans la rubrique Accueil, afin de présenter l'aspect technique du site, autre que celui des news.
Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
l 03/08/2009 à 15:44
Citation Envoyé par kmdkaci Voir le message
Bonjour,
Merci pour la critique. Juste une suggestion, ça aurait été mieux de mettre l'annonce dans la rubrique Accueil, afin de présenter l'aspect technique du site, autre que celui des news.
Salut,

Les critiques de livres n'intéressent pas tout le monde (preuve en est le nombre de lus sur http://java.developpez.com/ ) et encore moins les non Javaïste lisant l'index général http://www.developpez.com/ Ceci explique cela

 
couverture du livre Pro Spring Dynamic Modules for OSGi Service Platforms

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

Pro Spring Dynamic Modules for OSGi Service Platforms

de

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.

Édition : Apress - 392 pages, 1re édition, 1er février 2009

ISBN10 : 1430216123 - ISBN13 : 9781430216124

Broché

Commandez sur www.amazon.fr :

33.74 € TTC (prix éditeur 37.43 € TTC)
  • 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 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.




 Commenter Signaler un problème

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
l 05/07/2009 à 18:06
En début d'année, Apress a publié l'un des tout premiers livres concernant OSGi, et en particulier Spring Dm, le projet du porfolio Spring dédié à rendre OSGi accessible à tout le monde : Pro Spring Dynamic Modules for OSGi Service Platforms

Est-ce que certains d'entre vous l'ont lu ? Si oui, qu'en pensez-vous ?

Pour ma part, je le trouve excellent comme introduction à OSGi, Spring dm et tout ce qui tourne autour.

Cependant, des personnes plus expérimentées seront peut etre déçues. En effet, pour un livre de la collection "Pro", on reste un peu sur sa faim.
Du moins, c'est mon avis.

Et vous ?
Avatar de blacktitanium42 blacktitanium42 - Futur Membre du Club https://www.developpez.com
l 29/08/2009 à 1:39
Oui moi aussi je ai commencé à le lire ,pour le moment je suis un peu déçu par livre.

La lecture du livre n est pas facile , il faut être vraiment concentré pour ne pas décrocher au bout de 30 minutes.

De plus les exemples avec ant ,pas très pratique je trouve .il aurait pu trouver mieux

pour ceux qui ont testé les exemples du livre ,il y a des problèmes lors des chargements des bundles .

je vais continuer qu'en même pour voir ce que ça donne par la suite.
Avatar de ego ego - Rédacteur https://www.developpez.com
l 11/11/2009 à 15:20
j'ai lu ça dernièrement.
Le livre est pas trop mal mais en fait, OSGI ce n'est pas si compliqué que ça alors il n'y a pas trop de truc à dire sur les aspects techniques.
Ce qui est vraiment "chiant" c'est la gestion de dépendances à la fois dans le bundle et côté processus de fabrication (le build).
Le gars explique pas mal le fonctionnement de Ivy mais je pense qu'un chapitre plus théorique sur cet aspect "build" et gestion des numéros de version serait pas mal.
Ouhai, les numéros de version on en a dans plein de fichiers, comment optimiser tout ça !?!

Donc oui le livre vaut le coup d'être lu mais voilà, OSGI c'est pas compliqué alors on n'en ressort pas avec la même impression qu'en ayant lu "Pro Spring" par exemple.

 
couverture du livre Spring par la pratique

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

Spring par la pratique

Spring 2.5 et 3.0

de

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.

Édition : Eyrolles - 658 pages, 2e édition, 1er janvier 2009

ISBN10 : 221212421X - ISBN13 : 9782212124217

Broché

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € 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 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é !




 Commenter Signaler un problème

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
l 23/06/2009 à 21:18
18/08/2009

Suite à la sortie de Spring 3.0 M4, Arnaud Cogoluègnes propose un complément au livre, concernant deux nouveautés de cette version :
  • le namespace jdbc
  • le namespace task


Pour plus d'information, je vous invite à visiter la page des compléments

23/06/2009

Trois ans après la première édition, le tout premier livre francophone sur Spring et son portfolio se voit être mis à jour.

Et comme pour la première fois, ce livre couvre des sujets inédits comme Spring Dm et la technologie OSGi, ou le nouveau serveur Spring Dm Server permettant de tirer parti de cette dernière.

Mais ce n'est pas tout, il est l'un des tout premiers livres à couvrir Spring 3.0 ( toute langues confondues, ce qui n'est pas rien ! ). Pour rappel, cette version n'est pas encore officiellement sortie.

D'autres sujets ont de leur coté été mis à jour, c'est le cas de Spring MVC, se basant maintenant sur le jeu d'annotations ou le nouvellement nommé Spring Security, successeur de Acegi.
Spring Batch fait aussi parti des sujets traités.

Bref, un pur bonheur pour ceux qui ne connaissent pas Spring, mais aussi un excellent livre pour ceux utilisant Spring 2.0 et voulant se remettre à niveau.

Quelques informations :

Sortie eBook : 23 Juin 2009, disponible sur izibook
Sortie papier : le 7 juillet 2009

Critique du livre, en avant première

Bonne lecture
Avatar de irnbru irnbru - Membre confirmé https://www.developpez.com
l 11/08/2009 à 10:08
J'ai pris le livre, il n'est pas mal surtout en termes d'explications. Par contre la présence du code est plutôt légère. Je préfère les explications au code mais un minimum de code complet serait cool. Remarque que je n'ai lu que deux chapitres. Mais plutôt okay comme livre. Je vous tiendrais au courant au fur à mesure de l'avancement de mon exploration.

Cheers,
IRNBRU
Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
l 11/08/2009 à 11:18
En même temps, il y a une application complète diposnible sur
http://www.springparlapratique.org
couverture du livre Beginning Java™ EE 6 Platform with GlassFish™ 3

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

Beginning Java™ EE 6 Platform with GlassFish™ 3

From Novice to Professional

de
Public visé : Débutant

Résumé de l'éditeur

Sun's enterprise Java? platform, Java EE (Enterprise Edition), is getting a facelift! Beginning Java EE 6 Platform with GlassFish 3 is one of the first tutorial books on the forthcoming Java EE 6 Platform.

Step?by?step and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations and shows them in action using practical examples.

This book uses the new version of GlassFish? 3 to deploy and administer the code examples.

Written by an expert member of the Java EE 6 specification request and review board in the Java Community Process (JCP), this book contains the best information possible, from an expert's perspective in enterprise Java technologies and platform.

Édition : Apress - 500 pages, 1re édition, 1er mai 2009

ISBN10 : 1430219548 - ISBN13 : 9781430219545

Commandez sur www.amazon.fr :

31.39 € TTC (prix éditeur 35.83 € TTC) livraison gratuite !
[list][*]Chapter 1 Java EE 6 at a Glance.[*]Chapter 2 Java Persistence.[*]Chapter 3 Object-Relational Mapping.[*]Chapter 4 Managing Persistent Objects.[*]Chapter 5 Callbacks and Listeners.[*]Chapter 6 Enterprise Java Beans.[*]Chapter 7 Session Beans and the Timer Service.[*]Chapter 8 Callbacks and Interceptors.[*]Chapter 9 Transactions and Security.[*]Chapter 10 JavaServer Faces.[*]Chapter 11 Pages and Components.[*]Chapter 12 Processing and Navigation.[*]Chapter 13 Sending Messages.[*]Chapter 14 SOAP Web Services.[*]Chapter 15 RESTful Web Services
[list]
Critique du livre par la rédaction Cel Fer le 1er août 2009
Antonio Goncalves, pour ceux qui ne le savent pas encore, est le co-créateur du Paris JUG et est membre des comités d'experts autour des JSR suivantes: JSR-316 (Java EE 6), JSR-317 (JPA 2.0) et JSR-318 (EJB 3.1). C'est son deuxième livre. Il vient récemment d'avoir le titre de Java champion.
Alexis Moussine-Pouchkine (équipe GlassFish) en a écrit la préface.

Le 1er chapitre dresse une liste des nouveautés introduites dans Java EE 6. Une application d'e-commerce (vente de CDs et livres) est développée au fur et à mesure des chapitres. Et l'installation des outils utilisés est décrite.
Le serveur d'application choisi est GlassFish v3 bien sûr, le premier à supporter Java EE 6 et le seul à l'heure actuelle.

Les chapitres 2 à 5 traitent de la Java Persistence API (JPA), dans sa version 2.0. Pour rappel la version de JPA dans Java EE 5 est la 1.0.

Le 2ème chapitre présente un petit exemple de persistence d'un entity bean, avec l'aide de JUnit pour les tests, Maven pour la compilation et l'exécution, Derby pour la base.

Dans le 3ème chapitre l'auteur explique de nombreuses annotations ORM de la version 1.0 de la JPA mais aussi les nouvelles annotations de la JPA 2.0 (@ElementCollection, @MapKeyColumn, ...). La section sur le mapping des relations entre entités est bien détaillée et elle est certainement très utile pour quiconque aurait un peu oublié ces annotations et souhaiterait s'y remettre rapidement.

Idem pour le 4ème chapitre, très complet dans ses explications de la persistence. Les nouveautés de JPA 2.0 sont évidemment présentées (cache de second niveau, pessimistic locking ...).

Le chapitre 5 offre également des explications complètes sur les méthodes callbacks et les entity listeners.

Les chapitres 6 à 9 se focalisent sur les session beans et les EJB timer service. L'auteur montre l'utilisation du container embarqué, une nouveauté de la version 3.1.

Le chapitre 6 est un très court chapitre qui présente de façon sommaire des nouveautés dans EJB 3.1. Ces nouveautés sont utilisées dans les chapitres suivants.
Un premier petit exemple montre l'utilisation du container embarqué et le lookup JNDI via un nom standard.

Le chapitre 7 fait une description des stateless et stateful session beans, avec des exemples.
Les singletons session beans sont étudiés dans le détail, avec pas mal de code pour illustrer les concepts qui tournent autour (initialisation, chaînage, concurrence). Les autres concepts (JNDI standardisé, injection de dépendance, appels asynchrones avec les session beans, container embarqué, service timer amélioré) sont également riches en exemples de code.

Rien de particulier à signaler sur le chapitre 8. L'auteur fait une description classique des cycles de vie des session beans et des singletons, des méthodes callbacks et des interceptors (chaînage, exclusion).

Chapitre 9 : Encore une fois, une description classique et bien complète des 2 modes de transactions (container ou bean) des EJBs est faite. Et également des explications claires sur les annotations relatives à la sécurité.

Chapitre 10 : présentation de JSF 2.0. Un exemple montre le développement d'une application web JSF 2.0 en utilisant un business tiers basé sur les EJB 3.1 et une couche de persistance reposant sur JPA 2.0.

Dans le chapitre 11, l'auteur fait de nombreux rappels autour d'HTML, des CSS, des JSP, EL et JSTL.
Les facelets sont préférées aux JSP en tant que PDL (Presentation Declaration Language) pour JSF. L'auteur fait également une revue des composants JSF HTML et montre la création et l'utilisation de composants / widgets avec JSF 2.0.

Chapitre 12 : beaucoup d'explications accompagnent la présentation des capacités de JSF 2.0 tant dans le traitement des requêtes (cycle de vie) que dans la navigation, la conversion et la validation de données, ainsi que le support AJAX.

Chapitre 13 : La JMS API est abordée en détails avant de voir l'utilisation des EJB MDB avec OpenMQ, le fournisseur de messages par défaut de GlassFish, et leur compilation et déploiement avec Maven.

Chapitre 14 : Les généralités sur les Web Services (WSDL, SOAP ...) sont passées en revue. L'auteur montre l'utilisation des annotations du modèle JAX-WS, suivant la spécification JSR-181, pour la création et l'appel de web services par un consommateur.

Chapitre 15 : ce dernier chapitre ne manque pas d'intérêt puisqu'il introduit le nouveau type de Web Service, RESTful.
Il est décrit en faisant usage des annotations de l'API JAX-RS qui fait partie de Java EE 6.

Conclusion : Le code est téléchargeable sur le site des éditions Apress.
J'ai bien aimé l'aspect pédagogique du livre : dans certains chapitres, il y a une section "Putting it all together" qui met en pratique les notions vues précédemment.

English version :

Antonio Goncalves, if you do not know him yet, is the co-founder of the Paris JUG and is a member of the experts committees regarding the following JSRs : JSR-316 (Java EE 6), JSR-317 (JPA 2.0) et JSR-318 (EJB 3.1). This is his second book. He has been recently awarded the title of Java champion.
Alexis Moussine-Pouchkine (GlassFish team) wrote the foreword.

The 1st chapter enumerates a list of new features introduced in Java EE 6. An e-commerce application (CDs and books sales) is developed in the chapters. And the installation of the used softwares is described.
The chosen application server is GlassFish v3 of course, the first one to support Java EE 6 and also the only one at the moment.

Chapters 2 to 5 deal with the Java Persistence API (JPA), in its version 2.0. As a reminder, the JPA version in Java EE 5 is 1.0 .

The 2nd chapter offers a small sample of persistance of an entity bean, with the help of JUnit for the tests, Maven for the compilation and the execution, Derby for the database.

In the 3rd chapter the author explains numerous ORM annotations of the version 1.0 of the JPA but also the new annotations of the JPA 2.0 (@ElementCollection, @MapKeyColumn, ...). The section on the mapping of relations between entities is well detailed and is certainly very useful for anyone who has forgotten these annotations and wishes to quickly learn them again. rapidement.

Same thing for the 4th chapter, it is very exhaustive in its explications of the persistance. The new features of JPA 2.0 are of course introduced (second-level caching, pessimistic locking ...).

The 5th chapter also gives exhaustive explanations on callback methods and entity listeners.

Chapters 6 to 9 focus on session beans and EJB timer services. The author shows the use of an embedded container, a new feature in the 3.1 version.

Chapter 6 is a very short chapter which explains briefly the new features in EJB 3.1. These new features are used in the next chapters.
A first small example shows the user of the embedded container and the JNDI lookup JNDI through a standard name.

Chapter 7 does a description of stateless and stateful session beans, with examples.
Session beans singletons are explained in details, with a lot of code to illustrate the features around them (initialisation, chaining, concurrence). The other features (standardized JNDI, dependency injection, asynchrones calls with session beans, embedded container, improved timer service) are also rich in examples of code.

Nothing particular to mention about chapter 8. The author does a classical description of the lifecycles of session beans and singletons, callback methods and interceptors (chaining, exclusion).

Chapitre 9 : Once again, a classical and exhaustive description of the 2 transaction modes (container or bean) in EJBs is done. And it also provides good explanations about security-related annotations.

Chapitre 10 : presentation of JSF 2.0. An example shows the development of a JSF 2.0 web application using a business tier based on EJB 3.1 and a persistence layer based on JPA 2.0.

In chapter 11, the author writes some reminders about HTML, CSS, JSP, EL and JSTL.
Facelets are favored against JSP as PDL (Presentation Declaration Language) for JSF. The author also tells us about the JSF HTML components and shows the creation and use of components / widgets with JSF 2.0.

Chapter 12 : a lot of explanations support the presentation of the capabilities in JSF 2.0 regarding the treatment of requests (lifecycle), the navigation, conversion and validation of data, as well as AJAX support.

Chapter 13 : The JMS API is explained in details before the use of MDB EJBs with OpenMQ, the default messaging provider for GlassFish, and their compilation and deployment with Maven.

Chapter 14 : Main features of Web Services (WSDL, SOAP ...) are explained. The author shows the use of annotations of the JAX-WS model, according to the JSR-181 specification, for the creation and the call of web services by a consumer.

Chapter 15 : this last chapter does not lack any interest since it introduces the new type of Web Service, RESTful.
It is detailed using the annotations of the JAX-RS API which is part of Java EE 6.

Conclusion : The code is available on the Apress editions website.
I liked the educational approach of the book : in certain chapters, there is a "Putting it all together" section which makes use of the notions explained previously.




 Commenter Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
l 16/08/2009 à 16:40
Bonjour,
le deuxième livre d'Antonio Goncalves, co-fondateur du JUG de Paris et récemment élu Java Champion, est sorti il y a environ
3 mois.
Le titre est Beginning Java EE 6 Platform with GlassFish 3, From novice to professional, aux editions Apress.

Comme le titre l'indique, le livre est consacré à Java EE 6 en général et aux EJB 3.1, JSF 2.0 et Web Services (SOAP et Restful) en particulier, avec
GlassFish 3 comme serveur d'application.
Vous pouvez lire ma critique ici :

http://java.developpez.com/livres/?page=Anglais#L9781430219545

 
couverture du livre Les Cahiers du programmeur Java EE 5

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

Les Cahiers du programmeur Java EE 5

de
Public visé : Intermédiaire

Résumé de l'éditeur

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

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

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

ISBN10 : 2212120389 - ISBN13 : 9782212120387

Commandez sur www.amazon.fr :

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


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

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

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

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

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

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

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

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

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

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


couverture du livre Spring Recipes: A Problem-Solution Approach

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

Spring Recipes: A Problem-Solution Approach

de

Résumé de l'éditeur

Spring addresses most aspects of Java/Java EE application development and offers simple solutions to them. By using Spring, you will be lead to use industry best practices to design and implement your applications. The releases of Spring 2.x have added many improvements and new features to the 1.x versions. Spring Recipes: A Problem-Solution Approach focuses on the latest Spring 2.5 features for building enterprise Java applications.

Spring Recipes covers Spring 2.5 from basic to advanced, including Spring IoC container, Spring AOP and AspectJ, Spring data access support, Spring transaction management, Spring Web and Portlet MVC, Spring testing support, Spring support for remoting, EJB, JMS, JMX, E-mail, scheduling, and scripting languages. This book also introduces several common Spring Portfolio projects that will bring significant value to your application development, including Spring Security, Spring Web Flow, and Spring Web Services.

The topics in this book are introduced by complete and real-world code examples that you can follow step by step. Instead of abstract descriptions on complex concepts, you will find live examples in this book. When you start a new project, you can consider copying the code and configuration files from this book, and then modifying them for your needs. This can save you a great deal of work over creating a project from scratch.

Édition : Apress - 752 pages, 1re édition, 1er juin 2008

ISBN10 : 1590599799 - ISBN13 : 9781590599792

Commandez sur www.amazon.fr :

31.49 € TTC (prix éditeur 49.09 € TTC)
  • Part 1: Core
    • Chapter 1 Inversion of Control and Containers
    • Chapter 2 Introduction to Spring
    • Chapter 3 Bean Configuration in Spring
    • Chapter 4 Advanced Spring IoC Container
    • Chapter 5 Dynamic Proxy and Classic Spring AOP
    • Chapter 6 Spring 2.x AOP and AspectJ Support
  • Part 2: Fundamentals
    • Chapter 7 Spring JDBC Support
    • Chapter 8 Transaction Management in Spring
    • Chapter 9 Spring ORM Support
    • Chapter 10 Spring MVC Framework
    • Chapter 11 Integrating Spring with Other Web Frameworks
    • Chapter 12 Spring Testing Support
  • Part 3: Advanced
    • Chapter 13 Spring Security
    • Chapter 14 Spring Portlet MVC Framework
    • Chapter 15 Spring Web Flow
    • Chapter 16 Spring Remoting and Web Services
    • Chapter 17 Spring Support for EJB and JMS
    • Chapter 18 Spring Support for JMX, E-mail, and Scheduling
    • Chapter 19 Scripting in Spring
Critique du livre par la rédaction Hikage le 1er novembre 2008
«Spring Recipes: A Problem-Solution Approach», ou un livre de plus couvrant le Framework Spring ? Oui, mais un excellent livre !
En tant que Springer, j'ai eu l'occasion de lire un certain nombre de livres sur Spring. Bien que tous couvrent très bien Spring, la manière de le présenter est souvent fort semblable. Selon se critère, ce livre est une exception.

En effet, «Spring Recipes: A Problem-Solution Approach» se base sur une approche Problème-Solution-Explication. Ainsi le problème (ce que l'on désire faire) est dans un premier temps exposé pour ensuite être résolu par une solution, qui sera expliquée en détail et critiquée.

Et le terme 'une solution' est important car le livre ne va pas proposer la solution optimale directement, mais plutôt proposer une solution simple mais qui résous le problème (et ce parfois sans Spring dans un premier temps). De cette solution, le livre va ensuite mettre en avant les lacunes et faiblesses de cette solution pour l'améliorer. Et dans le souci de cette amélioration, l'utilité de Spring apparait clairement
Et c'est ce cheminement qui est selon moi la valeur ajoutée de ce livre, car il va non seulement vous apprendre à utiliser, mais surtout vous permettre de comprendre en quoi il est utile ou intéressant de l'utiliser.

Concernant le contenu du livre, celui-ci est fort complet. Il couvre Spring Framework (Accès aux données, transactions, AOP, Testing, Scripting …) mais aussi le portfolio Spring (Spring WebFlow, Spring Security, ..).
Mon seul gros regret est le chapitre sur Spring MVC, qui détaille plus l'ancienne manière de faire que le nouveau Framework basé sur les annotations.


couverture du livre Pro Spring 2.5

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

Pro Spring 2.5

de
Public visé : Intermédiaire

Résumé de l'éditeur

The move from so-called heavyweight architectures, such as Enterprise JavaBeans, toward lightweight frameworks, like Spring, has not stopped since Pro Spring was published by Rob Harrop and Jan Machacek in 2005; in fact, it's picked up pace. The Spring Framework remains the leader in this move and provides a platform on which you can build your own applications and services.

Pro Spring 2.5 covers the new features of Spring 2.5, but moreover, it is focused on the best practices and core standards of contemporary Spring development. As members of the Spring development team at Cake Solutions, the author team brings extensive practical experience gained from working with Spring since version 1.0 and delivering successful systems on top of it.

Learn the approaches that really matter in a professional, enterprise-level environment, so you can apply them to your projects today, safe in the knowledge that they just work.

Édition : APress - 890 pages, 1re édition, 1er août 2008

ISBN10 : 1590599217 - ISBN13 : 9781590599211

Commandez sur www.amazon.fr :

42.27 € TTC (prix éditeur 49.99 € TTC)
  • Part 1: Getting started with Spring
    • Chapter 1 Introducing Spring
    • Chapter 2 Getting started
    • Chapter 3 Introducing inversion of control
    • Chapter 4 Beyond the basics
    • Chapter 5 Introducing Spring AOP
    • Chapter 6 Advanced AOP
    • Chapter 7 Spring Schemas and Namespaces
    • Chapter 8 Spring Patterns
  • Part 2: Data Access
    • Chapter 9 JDBC Support
    • Chapter 10 iBATIS Integration
    • Chapter 11 Hibernate Support
  • Part 3: Enterprise Applications Components
    • Chapter 12 Job Scheduling with Spring
    • Chapter 13 Mail Support in Spring
    • Chapter 14 Dynamic Languages
  • Part 4: Java EE 5
    • Chapter 15 Using Spring Remoting
    • Chapter 16 Transaction Management
    • Chapter 17 Web Applications with Spring MVC
    • Chapter 18 Spring Web Flow
    • Chapter 19 Spring and Ajax
    • Chapter 20 JMX with Spring
    • Chapter 21 Testing with Spring
    • Chapter 22 Spring Performance Tuning

Critique du livre par la rédaction Cel Fer le 1er décembre 2008
Ce livre, publié en août 2008 aux éditions Apress, est parfait pour le développeur Spring, qu'il soit débutant ou expérimenté. Il intimide par son épaisseur (890 pages) qui s'explique par les nombreux domaines pris en charge par Spring mais aussi par le nombre d'auteurs puisqu'il y en a quatre.
Il couvre bien sûr les nouveautés de la version 2.5 du framework léger Spring.
J'ai apprécié les nombreux exemples de code et de configuration qui accompagnent les 22 chapitres, ainsi que la diversité des sujets abordés : AOP, MVC, JDBC, Hibernate, Quartz, remoting, design patterns, gestion des transactions, JMX, les tests, tuning …
On y trouve même un exemple de configuration de JasperReports pour la génération de fichiers PDF !
Le livre est logiquement découpé en 4 parties composée chacune de plusieurs chapitres.
Le 1er chapitre fait un tour rapide des différents sujets abordés dans le livre.
Le 2ème chapitre présente avec le traditionnel exemple "Hello World" une première esquisse de l'implémentation du pattern "Injection de dépendance" (DI) via Spring.
Le 3ème chapitre aborde le pattern au coeur de Spring : Inversion of Control.
Les différentes types d'IoC sont décrit en détails :
- DI (avec 2 sous-types : constructor DI et setter DI)
- Dependency lookup (avec 2 sous-types : dependency pull et contextualized dependency lookup)
L'interface BeanFactory est introduite et expliquée avec de nombreux exemples.
Le chapitre sur les langages dynamiques décrit la création de beans managés par Spring avec BeanShell, JRuby et Groovy.
Le plus gros chapitre du livre consacre presque 100 pages à l'implémentation du pattern MVC dans Spring, en détaillant l'utilisation d'autres technologies Web telles que Velocity, Freemaker …
Et l'on trouve ensuite de façon logique une explication détaillée de Spring Web Flow..
On peut cependant regretter l'absence de chapitres consacrés aux web services, à la sécurité, aux EJBs ou encore JMS.
Le code source des exemples est disponible en ligne sur le site des éditions Apress.


couverture du livre Professional Java Development with the Spring Framework

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

Professional Java Development with the Spring Framework

de

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.

Édition : Wrox, Wiley Publishing - 643 pages, 1re édition, 1er juillet 2005

ISBN10 : 0764574833 - ISBN13 : 9780764574832

Broché

Commandez sur www.amazon.fr :

25.13 € TTC (prix éditeur 29.57 € TTC)
  • 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 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 Eclipse et JBoss

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

Eclipse et JBoss

de
Public visé : Expert

Résumé de l'éditeur

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

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

ISBN10 : 2212114060 - ISBN13 : 9782212114065

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Développement et déploiement J2EE avec Eclipse et JBoss
  • L'étude de cas WebStock
  • Développement Web avec MyEclipse
  • Développement EJB avec JBoss, MyEclipse et XDoclet
  • Aspects avancés de JBoss
Critique du livre par la rédaction el_toro le 1er juin 2005
C'est un livre sur le développement J2EE avec Eclipse. L'intérêt de l'ouvrage est de présenter les très nombreux outils à interfacer avec Eclipse qui ne se suffit plus à lui-même. Qu'il s'agisse du déploiement avec Ant, des tests unitaires avec JUnit, de l'analyse des performances avec JUnitPerf, de la génération de fichiers de configuration ou de code avec XDoclet, de la gestion collaborative de sources avec CVS, de la génération de code à partir de diagrammes UML avec EclipseUML... nombreux sont les outils qui permettent d'accélerer et de rationnaliser le développement d'applications J2EE. L'auteur nous présente avec simplicité les multiples outils ainsi que les méthodes (design pattern) à disposition des développeurs pour un travail de qualité, réutilisable et maintenable.


couverture du livre Programmation Orienté Aspect pour Java / J2EE

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

Programmation Orienté Aspect pour Java / J2EE

de

Résumé de l'éditeur

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

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

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

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

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

ISBN10 : 2212114087 - ISBN13 : 9782212114089

Commandez sur www.amazon.fr :

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

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

Principaux outils de POA du monde Java

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

Applications de la POA

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

Étude de cas détaillée

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

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

Ce livre constitue donc, à mon sens une bonne introduction sur le sujet de la POA : assez général pour couvrir un spectre de plusieurs outils, et détaillé pour vous accompagner à comprendre et utiliser les solutions présentées pour une application concrète dans vos projets. Malgré tout (mais je ne pense pas que les auteurs avaient la prétention d'être exhaustif), pour aller plus loin une exploration unitaire des frameworks présentés sera nécessaire. Au final, un livre que je vous conseille pour découvrir la POA.
Critique du livre par la rédaction doe john le 1er août 2006
Dans un style simple et clair, cet ouvrage s'applique à expliquer de manière très didactique les concepts avancés de la POA, avant de passer en revue les principaux outils permettant d'utiliser ce paradigme avec Java. Par ailleurs, il est très pédagogique et au fil des chapitres, l'on se rend compte qu'il distille habilement les bonnes pratiques nécessaires à une bonne appréhension de la POA.

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

Enfin, l'étude de cas complète permet de fixer les idées afin de maîtriser le concept.
Ce (gros) livre de 446 pages s'avère très complet et permettra au novice de la POA comme à l'expert de trouver ce qu'il cherche. Attention toutefois, une maîtrise parfaite du paradigme objet est nécessaire pour le comprendre aisément.
En conclusion, un ouvrage à recommander aux programmeurs Java / J2EE professionnels désireux d'évoluer.


couverture du livre Refactoring des applications Java/J2EE

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

Refactoring des applications Java/J2EE

de
Public visé : Expert

Résumé de l'éditeur

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

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

ISBN10 : 2212115776 - ISBN13 : 9782212115772

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • Remerciements


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


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


Chapitre 2: Préparation du refactoring
  • La gestion de configuration
  • Gestion des tests et des anomalies
  • Conclusion


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


Chapitre 4: Mise en oeuvre du refactoring
  • Support du refactoring de code dans Eclipse
  • Les techniques de refactoring du code
  • Conclusion


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


Chapitre 6: Le refactoring avec les design patterns
  • Les design patterns
  • Utilisation des modèles comportementaux
  • Amélioration de la structure des classes
  • Conclusion


Chapitre 7: Refactoring avec la POA (Programmation Orientée Aspect)
  • Principes de la programmation orientée aspect
  • Modularisation des traitements
  • Optimisation des traitements
  • Analyse du logiciel et tests unitaires
  • Conclusion


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


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


Chapitre 10: Analyse de JGenea Web
  • Analyse quantitative
  • analyse qualitative
  • Conclusion


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


Annexe
  • Installation d'Eclipse
  • Installation de PMD sous Eclipse
  • Installation de Checkstyle sous Eclipse
  • Installation de Metrics sous Eclipse
  • Téléchargement d'EMMA
  • Téléchargement du client CVS pour Windows
  • Téléchargement de StatCVS
  • Téléchargement de Tomcat
  • Installation et configuration du plugin Tomcat de Sysdeo pour Eclipse
  • Installation du plug-in AJDT pour Eclipse
  • Script DDL de JGenea Web
  • Références
Critique du livre par la rédaction Olivier le 1er février 2010
J'ai trouvé l'ouvrage très intéressant dans ses premiers chapitres, où il expose les différents types de refactoring à considérer, les manières de les mettre en oeuvre.
De plus, les façons d'analyser l'existant sont bien expliquées, et de nombreux outils sont proposés pour arriver à nos fins. Bien qu'il date de 2005, son contenu reste tout à fait d'actualité.
Après, j'ai trouvé que ça s'est gâté. On passe de hors sujet en hors sujet, même si ceux-ci s'avèrent agréables à lire. Une bonne partie du livre nous explique comment utiliser Eclipse pour renommer les méthodes, réorganiser le contenu des classes, présente quelques design patterns et la POA, la façon d'écrire des tests unitaires… Je trouve qu'on s'écarte souvent du sujet principal.

J'espérais trouver un livre dans lequel obtenir plus d'informations sur la manière de refondre le code plus en profondeur. Ceci dit, le livre précise bien qu'un refactoring s'applique à du code dont les fondements sont sains, mais cela ne suffit pas à combler ma déception.
La lecture de ce livre n'aura cependant pas été une perte de temps, car de nombreuses idées traversent l'esprit pendant la lecture de ce dernier par rapport à mon cas personnel, et les techniques/outils présentés le sont très bien.
Critique du livre par la rédaction christopheJ le 1er mars 2007
On finit tous un jour par se retrouver sur un projet avec du code hérité au lourd passif… Le genre de code qui évolue au jour le jour. Le code pour lequel personne ne trouve le temps de prendre du recul pour essayer de l'alléger, réécrire les morceaux peu performant, redondant ou trop contraignant… C'est alors que cet ouvrage est utile.

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

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

Chaque technique est accompagnée d'un exemple et de capture d'écran pour Eclipse.
Enfin, ce qui ajoute beaucoup de valeur à ce livre, c'est l'étude de cas qui occupe environ un cinquième du volume. On a tous lu des livres avec des exemples (parfois à peine plus complexes qu'un "Hello World"). On pense avoir compris et quand on arrive sur un vrai cas, on se pose encore des questions, on hésite, on ne sait plus … Ici l'étude de cas se fait sur une vraie application, pas juste trois classes et deux JSP. Cette étude de cas permet de mettre en application les techniques décrites dans la première partie de façon guidée. Et si vous ne voulez pas faire les premières étapes (renommage) mais uniquement la refonte des DAO ou des actions Struts, il existe une version de chacune des étapes sur le CVS.
En conclusion, un livre obligatoire à lire si l'on se retrouve un jour avec du code hérité.
Critique du livre par la rédaction vbrabant le 1er juin 2006
Un excellent ouvrage sur le refactoring.

Ce livre est un bijou, une merveille, un joyau.
Je me suis vraiment régalé à la lecture de ce livre. Il commence tout d'abord par vous expliquer la raison d'être du refactoring, ce que c'est et ce que ce n'est pas.
Ensuite, il vous explique les préparations à faire (création de branches, de clichés, s'assurer qu'on a bien les tests unitaires, …) avant d'effectuer un refactoring de votre application.
Puis, il vous explique la mise en oeuvre du refactoring, à l'aide de l'EDI Eclipse.
Il vient ensuite vous montrer comment combiner les tests unitaires avec le refactoring, et l'utilisation de simulacre d'objets avec EasyMock, mais également l'analyse de couverture avec EMMA.
Toute un chapitre est également consacré aux design patterns, et comment ils peuvent vous venir en aide dans le cas du refactoring.
L'auteur aborde également, avec élégance, la problématique du refactoring avec les bases de données. Et cela est vraiment enrichissant.

La troisième partie du livre est entièrement consacrée à l'étude de cas: un programme de généalogie.
A travers cette étude de cas, l'auteur vous apprendra comment, grâce à une analyse quantitative et une analyse qualitative, trouver les parties de code nécessitant un refactoring.
Une fois ces parties détectées, il va appliquer différents refactoring appris lors de la deuxième partie du livre.
Conclusion :Sans discussion, un excellent achat.
Critique du livre par la rédaction Stessy Delcroix le 1er janvier 2006
Quelle personne ne s'est jamais retrouvée en face d'un code qu'elle avait ou n'avait pas produit et qui parfois se révèle être une cochonnerie en terme de maintenance et d'évolutivité.
Eh bien moi je me suis retrouvé dans le cas ou ce code ne m'appartenait pas et, qui plus est, était mal agencé pour me permettre de le faire évoluer sereinement sans devoir tout réécrire de A à Z.
Je me suis donc retroussé les manches et ai commencé à proprement parler le refactoring de l'application.
Je dois bien avouer que je ne m'en serait jamais sorti si je n'avais pas suivi les conseils précieux distillés dans cet ouvrage.
L'auteur commence d'abord par expliquer le pourquoi du refactoring.
Ensuite viennent les pré-processus indispensables pour effectuer un refactoring robuste tels que le versioning des différentes ressources, la mise en oeuvre des tests unitaires,…
Le troisième chapitre est pour moi le plus théorique. Il aborde les méthodes qui permettent d'analyser le code tant de manière quantitative que qualitative.
Je dois bien avouer que j'ai du relire ce chapitre une seconde fois pour bien comprendre à quels moments, et quels endroits du code, le refactoring devenait une nécéssité voire même une obligation.
Chapitre 4. Là, on rentre réellement dans la mise en oeuvre du refactoring. Chaque technique de refactoring abordée dans ce chapitre est basée sur un plan bien précis. Ce plan est décomposé en 4 parties :
  • les objectifs de cette technique ainsi que les risques pouvant survenir
  • les moyens de détection
  • le refactoring proprement dit
  • un exemple concret de mise en oeuvre


Le chapitre suivant traite de l'utilisation de test unitaires en combinaison avec le refactoring. Il explique également comment créer des simulacres d'objets qui permettront, comme le terme l'indique, de simuler des objets.
C'en est terminé avec la première partie de l'ouvrage.
La seconde partie traite des techniques avancées pour effectuer le refactoring d'une application telles que les design patterns, SOA.
Ce qui m'a le plus surpris dans cette partie, c'est le refactoring de la base de données.
Comme quoi on en apprend tous les jours.
La dernière partie reprend une étude de cas complète. Cette partie de l'ouvrage met en pratique la totalité des techniques abordées lors des chapitres précédents, en passant :
  • par l'analyse quantitative et qualitative,
  • par le refactoring de l'application,
  • par la mise en oeuvre des tests unitaires


En conclusion, cet ouvrage est un petite merveille. A recommander chaudement.




 Commenter Signaler un problème

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

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

La critique en ligne