Le site
Tutoriels
Syndication
Projets
Critiques de livre par Baptiste Wicht - Les livres Java
Dernière mise à jour : 01/12/2009
- Modular Java - Creating Flexible Applications With OSGi and Spring
- Spring par l'exemple
- Hardcore Java
- Java Persistence et Hibernate
- Java Generics - and Collections
- Checking Java Programs
- Swing la synthèse - Développement des interfaces graphiques en Java
- Programmer en Java
- Mieux programmer en Java - 68 astuces pour optimiser son code
- Java Efficace - Guide de Programmation
- Les Cahiers du programmeur Swing
- Les Design Patterns en Java : Les 23 modèles de conception fondamentaux
  |
Public visé : Intermédiaires,Avancés Résumé de l'éditeur
Modular Java is a pragmatic guide to developing modular applications using OSGi, the framework for dynamic modularity in
Java, and Spring Dynamic Modules, an OSGi extension to the Spring Framework. You'll start with the basics but quickly ramp
up, creating loosely coupled modules that publish and consume services, and you'll see how to compose them into larger
applications. Along the way, you'll apply what you learn as you build a complete web application that is made up of several
OSGi modules, using Spring-DM to wire those modules together.
Modular Java is filled with tips and tricks that will make you a more proficient OSGi and Spring-DM developer. Equipped with
the know-how gained from this book, you'll be able to develop applications that are more robust and agile.
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. Sommaire
260 pages,
1ère édition,
juin 2009
Editions O'Reilly,
ISBN10 : 1934356409,
ISBN13 : 978-1934356401,
Broché Commandez sur www.amazon.fr : 23.59 EUR TTC seulement (au lieu de 24.84 EUR TTC : prix éditeur) - Livraison Gratuite ! |
  |
Public visé : Débutants,Intermédiaires Résumé de l'éditeurSpring 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.
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.
Sommaire
510 pages,
1ère édition,
mai 2009
Editions Pearson Education,
ISBN10 : 2744023396,
ISBN13 : 978-2744023392,
Broché Commandez sur www.amazon.fr : 39.90 EUR TTC seulement (au lieu de 42 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Intermédiaire / Avancé Résumé de l'éditeur
Java has quickly become one of the most important languages in programming, particularly for professional and enterprise-level
projects. From its infancy as a language primarily used for web applets to its maturity through servlets, Enterprise JavaBeans,
and database access, Java has become a complex and robust tool for today's developer. Hardcore Java takes this language and breaks
it apart, piece by piece, revealing the important secrets and tricks that will take you from a junior-level programmer to a
seasoned and expert developer. You'll fly through the fundamentals and quickly find yourself learning about advanced memory
management techniques, optimization and bytecode-level enhancements, and the techniques required to build lightning-fast GUIs.
Throughout the book, you'll also master the art of writing and maintaining bulletproof and error-proof code, all while grasping
the intricacies of the Java language. Hardcore Java covers:
Hardcore Java is an invaluable addition to every programmer's library, and even the most advanced developers will find themselves
moving beyond their own conceptions into truly advanced applications of the language. Thousands of lines of code, heavily
commented and easily runnable, illustrate each concept in the book.
Ce livre présente plusieurs particularités du langage Java ainsi que beaucoup de trucs et astuces permettant d'utiliser au mieux
ce language.
Le premier chapitre passe en revue les particularités du langage Java. Il met en avant quelques spécialités du langage et démontre
quelques erreurs qui sont communes aux programmeurs
Java. Le chapitre suivant est complètement dedié au mot clé final. Il parle de l'utilité du mot clé final pour les champs, les
méthodes et les classes. Ce chapitre traite aussi
de la compilation conditionelle. Le chapitre suivant est dediée aux objets immuables, de leur conception à leur utilité.
Le quatrième chapitre est entièrement dedié aux collections du langage Java. Il présente les différents types de Collection que
propose l'API standard et les différents concepts qu'il est
utile de connaître pour choisir une collection. Ce chapitre ne se contente pas de lister les différentes collections, il va
décrire en détails les mécanismes de chacune de ces dernières.
Il va également traiter de la performance des collections et des arguments pouvant conduire au choix de l'une ou de l'autre
collection.
Le chapitre 5 décrit le mécanisme des exceptions dans Java. Il présente également les bonnes manières de gérer les exceptions dans
un programme Java. Le chapitre suivant décrit
en profondeur le système des classes internes. Il va décrire tous les types de classes internes, leur utilité et leur utilisation.
Il donne aussi un résumé de ce que peut faire et ne
peut pas faire chaque type de classe interne.
Le chapitre 7 traite des constantes. Il parle des constantes de substition, des objets constants et des options constantes. Il
traite également des "bit fields" qui sont des variables
combinant plusieurs états vrais-faux. Avec le chapitre suivant, on passe dans la modélisation des données. Ce chapitre indique
tous les points auxquels il faut faire attention quand
on modélise un modèle de données. Il traite des contraintes sur le modèle, du langage de modélisation naturel et du choix entre
une base de données orientée objet ou relationnelle.
Le chapitre suivant traite de la réflection et son utilité dans un programme Java. Un premier exemple utilise la reflection pour
faciliter le logging des classes et un autre pour les
tests unitaires. Le chapitre 10 décrit les proxies. Il va décrire le proxy statique et le proxy dynamique généré directement par
Java. L'avant-dernier chapitre décrit les références
et présente les différentes utilités de chacun des types de référence présente dans le langage Java. Enfin le dernier chapitre
repasse sur les nouveautés de Tiger. Ce chapitre n'est
utile qu'aux personnes ne connaissant pas encore ces nouveautés.
En conclusion, ce livre est très bon pour compléter ses connaissances sur le Java. En effet, ce livre traite de sujets qui ne sont
habituellement pas traités dans les autres livres
que j'ai pu lire sur Java. Néanmoins, j'ai trouvé que certains chapitres n'allaient pas assez en profondeur dans leur sujet.
Cependant, ce livre m'a permis d'appréhender des sujets
encore quasi-inconnus et d'en approfondir d'autres. Je conseille ce livre à tous les utilisateurs du langage Java qui n'ont pas
forcément encore poussé à fond dans le langage.
Sommaire
400 pages,
1ère édition,
janvier 2004
Editions O'Reilly,
ISBN10 : 0596005687,
ISBN13 : 978-0596005689 |
  |
Public visé : Intermédiaires,Expérimentés Résumé de l'éditeur
Gestion optimale de la persistance dans les applications Java/JEE
Avec JPA (Java Persistance API), composante essentielle des spécifications EJB 3, le monde Java/JEE dispose enfin d'un standard fiable et efficace pour la gestion de la persistance et du mapping objet-relationnel. Largement inspiré du pragmatisme d'Hibernate et tirant parti d'une avancée majeure de Java SE 5 (les annotations), Java Persistance privilégie la simplicité de développement en plaçant les métadonnées de persistance au coeur du code Java SE ou EE et en reléguant les descripteurs XML aux cas extrêmes.
Un livre pratique illustré d'une étude de cas détaillée
A la fois pratique et didactique, cet ouvrage décrit les différentes facettes de l'API et de son implémentation Hibernate en
montrant comment les mettre en oeuvre à travers une étude de cas déclinée au fil des chapitres. Il insiste tout particulièrement
sur la définition des annotations et l'utilisation du gestionnaire d'entités en environnement Java SE ou Java EE, ainsi que sur
les aspects méthodologiques et sur les questions de performances : mapping de modèles objet ou de schémas relationnels complexes,
récupération efficace des objets persistants, gestion de la concourance et persistance transitive, configuration des pools de
connexions et des caches de second niveau, etc.
L'ouvrage montre également comment repousser les limites de Java Persistence API grâce aux possibilités d'optimisation et aux extensions offertes par Hibernate.
Comme son titre l'indique, cet ouvrage présente Java Persistence API (JPA) avec Hibernate comme fournisseur de persistance. Ce
livre ne va pas se contenter de couvrir la partie JPA, il va également explorer des fonctionnalités spécifiques à Hibernate qui
permettront d'aller plus loin que les spécifications JPA.
L'auteur commence par nous présenter la problématique de la persistance et l'évolution des librairies facilitant cette tâche au
fil des ans jusqu'à l'avènement de JPA. Il nous montre également les avantages d'un outil de mapping objet-relationnel. Il
présente ensuite ce qu'est JPA et c'est qu'est Hibernate.
On continue avec beaucoup de pratique avec les chapitres 3 et 4. Dans ces chapitres, on va apprendre à annoter nos entités pour
configurer le mapping objet-relationnel. J'ai trouvé ces chapitres très complets, mais ils vont un peu vite, ce qui est parfois
déroutant car on passe d'une notion à une autre très rapidement. Ils présentent également les notions complexes comme l'héritage
et le polymorphisme sur les entités.
Les deux chapitres suivants traitent quand à eux des méthodes de récupération des entités ainsi que de la façon de les gérer,
c'est-à-dire les modifier, les supprimer et les créer. Ces 2 chapitres sont très complets et plus simples à suivre que les
précédents. La partie récupération traite bien de toutes les manières de récupérer des objets (EJB-QL, SQL natif, Criteria). On y
parle également des transactions et de la gestion des accès concourants.
Vient ensuite un chapitre sur la gestion de l'EntityManager. C'est-à-dire comment le créer ou récupérer et comment gérer son cycle
de vie tout au long de l'exécution de l'application. Il traite des différentes stratégies de gestion de l'EM ainsi que du
traitement par lot ou de l'utilisation dans un batch. On y traite également de l'utilisation des EJB3 pour gérer l'EntityManager.
Comme je n'ai pas pu installer JBoss intégré, je n'ai pu tester cette partie. Avec le chapitre 8, on entre dans le cœur
d'Hibernate qui permet de faire plus de choses que la spécification JPA. On verra donc les formules, les procédures stockées, les
types personnalisés, les clés composées et encore d'autres notions avancées de mapping avancés. Ces 2 chapitres traitent de
notions assez complexes, mais ils les traitent bien, et on s'y retrouve facilement.
L'avant dernier chapitre parle de la suite Hibernate Tools. Il traite surtout du plugin pour Eclipse permettant de faciliter le
développement JPA/Hibernate et de SchemaExport, l'utilitaire permettant de générer le schéma de la base de données. Le dernier
chapitre, quant à lui, traite des autres projets autour d'Hibernate. On va notamment s'intéresser aux pools de connexion et au
gestionnaire de cache de second niveau ainsi qu'à la validation des entités.
En conclusion, j'ai trouvé certaines notions de ce livre complexes à mettre en oeuvre et le plan du livre laisse parfois à
désirer. L'auteur va parfois un peu trop vite et le lecteur se retrouve emmêlé entre plusieurs notions parfois très différentes.
Néanmoins, ce livre présente très bien les différentes notions de JPA ainsi que les aspects avancés qui nécessitent Hibernate.
Mais je ne le conseillerais pas aux débutants.
Sommaire
365 pages,
1ère édition,
18 décembre 2007
Editions Eyrolles,
ISBN10 : 2212122594,
ISBN13 : 9782212122596 Commandez sur www.amazon.fr : 39.90 EUR TTC seulement (au lieu de 42.00 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Expérimentés, Intermédiaires Résumé de l'éditeurThis comprehensive guide shows you how to master the most important changes to Java since it was first released. Generics
and the greatly expanded collection libraries have tremendously increased the power of Java 5 and Java 6. But they have also
confused many developers who haven't known how to take advantage of these new features. Java Generics and Collections covers
everything from the most basic uses of generics to the strangest corner cases. It teaches you everything you need to know about
the collections libraries, so you'll always know which collection is appropriate for any given task, and how to use it. Topics
covered include:
* Fundamentals of generics: type parameters and generic methods * Other new features: boxing and unboxing, foreach loops, varargs * Subtyping and wildcards * Evolution not revolution: generic libraries with legacy clients and generic clients with legacy libraries * Generics and reflection * Design patterns for generics * Sets, Queues, Lists, Maps, and their implementations * Concurrent programming and thread safety with collections * Performance implications of different collections Generics and the new collection libraries they inspired take Java to a new level. If you want to take your software development practice to a new level, this book is essential reading. Java Generics and Collections covers everything from the most basic uses of generics to the strangest corner cases. It
teaches you everything you need to know about the collections libraries, so you'll always know which collection is appropriate for
any given task, and how to use it.
Comme son nom l'indique, ce livre couvre les génériques, introduits dans Java 5 et le framework de collection Java. Ces
deux thèmes sont distinctement séparés en 2 parties différentes, mais, ces éléments étant intrinsèquement liés, on retrouve bien
entendu des notions de génériques dans la partie collection et vice-versa.
Pour commencer, je vais parler des différentes parties de ce livre et de leurs contenus respectifs et je ferai ensuite part
de mes impressions concernant le concernant.
Les auteurs débutent, donc, par la partie sur les Generics. Le premier chapitre présente très brièvement les différentes
notions utilisées dans ce livre, à savoir, les Generics, la boucle ForEach, l'(Un)Boxing, les types et les méthodes génériques
ainsi que les assertions.
Les chapitres suivants nous parlent du sous-typage, des Wildcards de génériques, de l'usage des generics dans les
comparaisons et des arguments génériques multiples.
Le chapitre ? lequelest un un peu plus pratique. Il va nous apprendre à utiliser les Generics dans nos déclarations et
classes, constructeurs et méthodes. Et donc implicitement à créer nos premières classes.
Le chapitre 5 enchaîne sur la manière dont ont été implémentés les generics de telle sorte à conserver la compatibilité
ascendante. Ce chapitre est très utile car il présente les techniques pour utiliser des librairies normales avec une application
ou vice-versa et nous met en garde contre les différents problèmes pouvant subvenir.
Le chapitre suivant est à nouveau très technique et explique en détail, le système de "Reification" des types paramétrés.
Il présente les différents principes à respecter lors de l'utilisation de classes génériques.
Les chapitres suivants sont plus pratiques. Le premier traite de l'api de "Reflection" pour les generics et des generics
pour "Reflection". Ou comment utiliser les generics avec l'api de reflection et l'amélioration de l'api avec les generics. Le
chapitre qui suit ("Effective Generics") traite directement des problèmes principaux pouvant subvenir en utilisant les generics,
dont la conservation de la compatibilité des binaires.
Enfin, le dernier chapitre sur les generics traite des design pattern pour lesquels il est intéressant de les utiliser.
J'ai trouvé cette première partie très compliqué à assimiler et assez technique. Ceci est peut-être dû à mon niveau
d'anglais qui n'est pas parfait, mais c'est le premier livre anglophone que j'ai autant de peine à suivre. Il faut également
avouer que le sujet est très complexe quand on s'y plonge. J'ai du parfois m'y reprendre à plusieurs fois pour comprendre une
notion. Néanmoins, il se révèle très complet et est une très bonne source d'informations sur les generics.
La partie suivante est consacrée à l'étude du framework de Collections de Java. Les 2 premiers chapitres présentent les
principales interfaces du framework et les principaux concepts utilisés dans le framework, comme les iterators, les performances
ou encore le multi-threading.
Le chapitre suivant présente en détail l'interface Collection qui est l'interface de référence pour presque toutes les
collections du framework. Les principales méthodes et constructeurs sont présentées en détails ainsi que l'implémentation de
Collection.
Les quatre chapitres suivants traitent des principales implémentations du framework. A savoir, les Sets, les Queues, les
Lists et les Maps. Chaque type de collection est présenté tout d'abord de manière générale et ensuite chacune des implémentations
de ce type est présentée en détails et une conclusion à la fin de chaque chapitre nous aide à choisir une implémentation.
Le dernier chapitre traite de la classe Collections qui offre une série de méthodes pour traiter les collections. Les
principales méthodes sont présentées et expliquées. Un cas d'utilisation est presque toujours représenté.
J'ai trouvé cette deuxième partie mieux organisée que la première et plus accessible. Néanmoins, elle se révèle toujours
assez difficile à comprendre et à suivre bien que le sujet soit plus simple. J'ai beaucoup aimé la présentation des différentes
implémentations qui se révèle très complète et très utile dans le choix d'une implémentation.
En conclusion, je dirais que ce livre n'est pas adapté aux débutants qui veulent débuter dans les generics, mais plutôt à
un public avancé qui désire aller jusqu'au bout du sujet. Il se révèle en effet très technique et je n'ai jamais réussi à m'y
plonger très longtemps. Néanmoins, c'est une excellente source d'informations du fait du nombre de sujets traités. Un bon livre
donc, mais pas à mettre entre toutes les mains.
Sommaire
273 pages,
1ère édition,
Novembre 2007
Editions O'Reilly,
ISBN10 : 0-59652775-6,
ISBN13 : 978-0-596-52775-4,
Broché |
 |
Public visé : Débutants, Intermédiaires Résumé de l'éditeur
This Short Cut tells you about tools that will improve the quality of your Java code, using checking above and beyond what the
standard tools do, including:
Tout d'abord, ce livre ne se veut pas un livre complet sur les programmes cités ici. C'est une introduction à l'analyse de
programmes. Ce livre est donc destiné aux programmeurs qui n'ont pas encore testés leurs propres outils d'analyse et qui
aimeraient en savoir plus sur les possibilités existantes dans ce domaine.
L'auteur va tout d'abord nous parler des warnings du compilateur Java (javac) et de la manière dont on peut les configurer pour
n'avoir que ceux qu'on désire vraiment traiter. Il va ensuite nous montrer comment les configurer dans Eclipse. L'auteur utilisera
Eclipse pour tous les exemples concernant l'intégration avec un IDE.
Après avoir vu les possibilités du compilateur Java, on va passer dans le vif du sujet avec la présentation de trois outils pour
trois besoins différents. Tout d'abord, on va découvrir un outil d'analyse de code source, PMD. L'auteur va nous montrer comment
faire marcher PMD de manière standalone, ensuite dans Ant, puis dans Eclipse et enfin, il va nous montrer comment étendre PMD avec
de nouvelles règles. On va également découvrir CPD qui est un utilitaire de PMD permettant de détecter des portions de code
copiées-collées.
L'auteur va suivre cette structure pour les 3 programmes présentés dans l'article, ce qui permet de s'y retrouver facilement. A la
fin de chaque chapitre sur un outil, on va retrouver un résumé avec les points importants de chaque partie de la présentation. Ce
résumé permet très succinctement de placer l'outil dans son contexte et de découvrir les principaux avantages du produit. Ce qui
peut se révéler très intéressant si on revient sur le livre un moment après l'avoir lu.
Ensuite, l'auteur va nous présenter un outil d'analyse statique, FindBugs. Il va nous montrer l'utilisation en ligne de commande
ou avec l'interface graphique de cet outil et nous montrer ce qu'on peut faire avec. Une courte partie est consacrée à une partie
peu connue de FindBugs, le datamining. Cela permet de faire des comparaisons entre plusieurs analyses FindBugs pour vérifier
l'avancement des erreurs, le nombre d'erreurs résolues et le nombre d'erreurs supplémentaires. On peut également suivre
l'avancement du projet avec cet utilitaire étant donné qu'il nous donne par exemple le nombre de classes du projet.
Enfin, l'auteur nous présente le dernier outil, un outil d'analyse dynamique, Java PathFinder développé par la NASA. Cet outil
permet de tester tous les chemins d'exécution possible de votre programme et permet de détecter certains problèmes comme des
DeadLocks ou des exceptions non gérées. Il se révèle très utile dans un programme multi-threadé pour trouver des problèmes de
concurrence.
En conclusion, ce livre est une très bonne introduction à l'analyse de programmes Java et vous permettra de découvrir trois
excellents programmes d'analyse. Les programmes présentés ne sont qu'une sélection, il en existe d'autres, mais ils sont choisis
parmi les meilleurs et dans un tel article, il n'aurait servi à rien de présenter plusieurs programmes de même catégorie.
L'article se lit bien, mais certains passages sont plus difficiles à suivre. Il m'a fallu revenir plusieurs fois sur le même
paragraphe pour bien le comprendre, mais en général, la lecture se révèle fluide et agréable. Je le conseille donc à tous les
programmeurs Java qui aimeraient se lancer dans l'analyse de leurs programmes mais ne savent pas par où commencer.
Sommaire
54 pages,
1ere édition,
Mars 2007
Editions O'Reilly,
ISBN10 : 0596510233,
Format PDF Commandez sur www.amazon.fr : |
 |
Public visé : Débutants Résumé de l'éditeur
Swing est une librarie Java qui permet de créer et de gérer des interfaces graphiques évoluées.
Le but de cet ouvrage n'est pas de présenter la liste exhaustive des composants Swing,
mais d'expliquer les principes de cette bibliothèque de classes et d'en offrir une vue d'ensemble.
Les composants les plus courants sont analysés en détail, amenant l'explication des concepts de layout,
d'événement, de drag and drop et d'architecture MVC, ainsi que l'étude des composants plus complexes.
Enfin, des problématiques plus avancées sont abordées, telles que le parralélisme, le multifenêtrage,
les tests ainsi qu'une ébauche de framework.
La démarche s'appuie sur de nombreux exemples correspondant à des cas d'utilisation dans le monde professionnnel.
L'un d'eux est enrichi tout au long de l'ouvrage, au fur et à mesure de la présentation de ces concepts.
Cet ouvrage s'addresse donc à des développeurs devant programmer une interface graphique avec Swing,
à des architectes devant concevoir un système où Swing intervient ou encore à des chefs de projet
ou des décideurs ayant à comprendre les principes globaux de Swing.
Tous pourront acquérir le recul nécessaire aussi bien lors du développement que lors de choix techniques
ou architecturaux.
Ce livre est destiné à toutes les personnes utilisant Swing.
Il va vous expliquer les principaux concepts de Swing.
Vous allez les apprendre via une série d'exemples ludiques.
A la fin de chaque chapitre, vous allez pouvoir appliquer les différentes notions à une petite application.
On va commencer par voir les concepts fondamentaux de Swing.
C'est-à-dire la notion de composants, de container, les fenêtres ainsi que les looks and feels.
On va continuer ensuite avec la gestion des événements.
Puis on va partir sur les composants plus complexes comme la JList, la JTable et le JTree.
On va ainsi voir la notion de modèles, de renderers ainsi que d'editors.
Sans oublier l'architecture MVC de Swing. Après avoir découvert toutes ces notions,
un chapitre entier sera consacré aux composants texte avec notamment la gestion des Document,
des Action ainsi que de l'undo-redo. Puis un autre chapitre pour le drag and drop.
Vous y découvrirez 2 manières de faire du drag-and-drop, la deuxième étant seulement disponible depuis le JDK 4.
Après nous avoir parlé de tous les concepts de "base" de Swing, l'auteur va nous expliquer le concept de threading avec Swing.
Un concept très important mais souvent mal compris par les débutants et même par les utilisateurs plus expérimentés.
Ce concept sera expliqué avec une série de tests pour montrer la différence de performances de Swing avec
ou sans respect de l'Event Dispatching Thread.
On va également apprendre quels sont les nouveautés qui ont vu le jour dans les dernières versions de Java
(1.4 et 5.0 pour ce livre). Puis vient le dernier chapitre sur le formalisme UML,
mais je ne trouve pas que ce chapitre apporte grand-chose au livre vu la faible complexité des diagrammes UML utilisés.
En conclusion, ce livre va vous apprendre les principaux concepts de Swing et d'une très bonne manière.
Après la lecture de ce livre, vous devriez parfaitement maîtriser les bases de Swing
et vous devriez pouvoir vous lancer dans le développement d'interfaces graphiques en Swing.
Néanmoins, ce livre n'est pas un catalogue Swing montrant tous les composants et leurs fonctions,
la Javadoc et les tutoriaux de Sun étant nettement suffisants à ce niveau-là.
On peut néanmoins regretter le manque de clarté de certains chapitres,
comme celui sur les Javabeans ou encore la brièveté du chapitre sur l'undo-redo
ou celui sur la deuxième manière de faire du drag-and-drop. Mais mis à part ces petits défauts,
ce livre reste une excellente introduction au framework Swing et je ne peux que vous le conseiller.
Sommaire
348 pages,
2ème édition,
1 novembre 2005
Editions Dunod,
ISBN10 : 2100492195,
Broché |
 |
Public visé : Tous niveaux Introduction : 4ème édition Java 5.0 Résumé de l'éditeurDans cet ouvrage, Claude Delannoy applique ou langage Java la marche pédagogique qui a fait le succès de ses livres sur le C et le C++. Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses. L'apprentissage du langage se fait en quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction nu développement Web avec les servlets Java et les JSP. Chaque notion nouvelle et chaque fonction du langage est illustrée de programmes complets dont le code source est fourni sur le CD-Rom d'accompagnement. L'environnement de développement Eclipse 3.1, également fourni sur le CD-Rom, vous permettra de tester ces exemples et de développer vos propres programmes Java. L'accent est mis dans cette 4e édition sur les nouveautés de la version 5 de Java 2 Standard Edition : programmation générique (chapitre nouveau), types énumérés, types enveloppes, possibilités de " boxing/unboxing " automatique, arguments variables en nombre, boucle for... each, etc. Lorsque nécessaire, les exemples de code ont été fournis en deux versions : une version exploitant les possibilités nouvelles de J2SE 5.0 et une version compatible avec les versions antérieures. Critique du livre par la rédaction (Baptiste Wicht) Ce livre passe en revue et explique tout ce qu'il faut savoir sur Java. Les différents chapitres sont tous très complets et permettent de bien saisir les divers concepts de Java. De plus l'auteur a choisi d'ajouter de nombreux exemples en C++ pour montrer les similarités des deux langages, ce qui fera peut-être choisir ce livre à un programmeur C++ désirant passer à Java. Il ne faut pas oublier de dire que ce livre traite aussi de toutes les nouveautés qu'offre Java 5, c'est-à-dire la généricité, la boucle foreach, l'autoboxing. Les premiers chapitres du livre sont consacrés aux généralités du langage Java : un historique du langage, les règles générales d'écriture, une explication très complète des types primitifs en Java, les opérateurs et les expressions et les instructions de contrôles. Cette partie va permettre de se familiariser avec Java et permettre de nous lancer dans l'étude des chapitres suivants. Ensuite, le livre va consacrer plus de 170 de ses pages aux notions de programmation orienté objet. Toutes les notions y sont clairement expliquées et illustrées par des exemples. On passe des classes, des objets et des tableaux à l'héritage, à la redéfinition et à la sur définition et au polymorphisme puis on finit avec les types énumérés et les chaînes de caractères. Ces chapitres seront sans doute les plus compliqués pour le débutant en POO, mais certainement aussi les plus indispensables. L'auteur passe ensuite à un chapitre sur les exceptions, traitant des exceptions en général et aussi de la création de nos propres exceptions. S'ensuit un chapitre, malheureusement trop court sur les threads. Ensuite, l'auteur nous fera entrer dans le monde de la programmation graphique et événementielle avec Swing. Cette partie est très complète et comprend la gestion des événements, les contrôles usuels, les boîtes de dialogue, les menus, les gestionnaires de positionnement (layouts) et le dessin. On pourra néanmoins critiquer l'absence d'AWT et surtout que l'auteur ne traite pas des composants complexes tels que JTable ou JTree. Une partie sur les applets vient ensuite, suivie d'une partie sur les flux d'entrée/sortie. Cette partie traite de la lecture et de l'écriture dans un fichier binaire, de la gestion de fichiers et des flux en général. Néanmoins, cette partie aurait mérité plus de matière tant il y a dire, car elle ne parle aucunement de communications réseau ni d'ailleurs des nouveaux fluxs réseaux de Java (nio). Le dernier chapitre du livre est consacré à la programmation Java coté serveur. C'est-à-dire les servlets et les JSP. Ce chapitre est une bonne introduction à la compréhension et au développement de servlets et de JSP. Mais il ne va pas non plus assez loin pour permettre de créer des applications compliquées, ceci sortirait du contexte du livre. Pour conclure, ce livre permet de bien saisir tous les concepts de Java et, malgré quelques lacunes, fournit à toute personne l'ensemble des bases nécessaires pour aller plus loin dans le développement d'applications Java. Le programmeur devra quand même passer par d'autres ouvrages plus ciblés pour aller plus loin dans certains concepts tels que la programmation côté serveur. Sommaire
750 pages,
4ème édition,
Mars 2006
Editions Eyrolles - Collection Blanche,
ISBN10 : 2212117485,
Broché, 21 x 5 x 23cm |
 |
Public visé : Connaissances de base en Java Résumé de l'éditeur
Un ouvrage pratique et concret Tous les programmeurs vous le diront : le temps passé au débogage représente une grande part du développement de programmes et de d'applications. Réduire cette phase de débogage, programmer "juste" du premier coup : tels sont les objectifs atteints par ce livre qui expose en détail les pièges classiques de la programmation Java et la manière de les éviter. En proposant des solutions aux principaux problèmes rencontrés en Java, l'ouvrage va droit au but : pas de discours inutiles mais des recommandations concrètes, répondant aux attentes des programmeurs.
Une structure divisée en ateliers Les 68 atelierws qui composent cet ouvrage abordent les princpales difficultés de la programmation Java : objets, exceptions, calsses et interfaces, tests d'égalité, multithreadiing, et ce à l'aide d'une multitude d'exemples très détaillés. En toutre, 18 d'entre eux sont consacrés à la manière d'écrire un code plus performant et donc plus rapide.
A qui s'adresse ce livre ?
Critique du livre par la rédaction (Baptiste Wicht)
Ce livre présente 68 méthodes d'optimisation pour du code Java. Néanmoins, il faut bien faire attention au mot optimisation : pour ceux qui s'attendent à n'avoir que des astuces pour avoir un code plus rapide, ce n'est pas le cas. Seules 18 astuces permettent d'optimiser les performances de votre application. Les autres astuces permettent de produire un code plus sûr et plus stable.
Ces astuces sont parfois plus des explications sur comment faire quelque chose qu'une réelle astuce. Mais elles sont néanmoins très intéressantes. Avec ces astuces, vous apprendrez à faire correctement des tests d'égalité, à avoir un code multithread sécurisé ou encore à gérer correctement vos exceptions. Vous apprendrez aussi à implémenter des classes constantes et à redéfinir la méthode equals.
La partie sur les performances se révèle à mon goût un peu faible. Une astuce sur l'optimisation manuelle du code s'avère très intéressante. Les autres étant plus basiques, avec par exemple l'utilisation de StringBuffer à la place de String dans une boucle. Mais cette partie traite aussi de concepts plus avancés tels que l'inlining, l'évaluation différée ou encore l'utilisation de variables de pile plutôt que de variables globales. De plus, les comparaisons entre les différentes techniques sont expliquées directement en bytecode ce qui permet de voir directement ce que ça donne.
Une chose que je trouve dommage est que ce livre n'a pas été mis à jour depuis sa première édition. Il utilise donc Java 1.2, mais la plupart des astuces présentées ici sont toujours valables avec les dernières versions de Java.
En conclusion, ce livre vous montrera différentes manières de mieux coder en Java et d'optimiser les performances de vos programmes. Mais ce livre n'est pas la solution miracle à vos problèmes de performances.
Sommaire
224 pages,
1ère édition,
Juillet 2000
Editions Eyrolles,
ISBN10 : 2212091710,
Broché |
  |
Traducteur(s) : Alexis Moussine-Pouchkine Public visé : Expérimentés Résumé de l'éditeur
Ce guide, écrit par un expert de Sun Microsystems, présente cinquante-sept règles de programmation concourant à l'écriture de programmes efficaces pour la plateforme Java.
Fruit de l'expérience des créateurs de Java et des défis de programmation relevés au quotidien, chaque règle illustre divers aspects du langage et de ses difficultés au moyen de conseils, recommandations - ce qu'il faut faire ; ce qu'il ne faut pas faire - et d'exemples détaillés : son bon usage idiomatique, ses subtilités et ses pièges, ses patterns et antipatterns.
Excédant la seule programmation Java, ces règles serviront de viatique pour la programmation objet en général et la production de code clair, correct, efficace, robuste et réutilisable.
Les bibliothèques Java (java.lang, java.util et dans une moindre mesure java.io) sont également abordées, ainsi que la sérialisation.
"J'aurais voulu avoir ce livre il y a dix ans. Certains peuvent penser que je n'ai besoin d'aucun livre sur Java, mais celui-ci fait exception."
James Gosling, ancien vice-président de Sun Microsystems, co-créateur du langage Java.
Critique du livre par la rédaction (Baptiste Wicht)
Ce livre est fait non seulement pour toutes les personnes qui doivent écrire des libraires qui vont être réutilisées par d'autres, mais aussi pour les simples développeurs qui produiront un code plus solide. En effet, l'auteur de ce livre (chef de projet chez Sun Microsystems) vous donne en effet une série de 57 conseils pour développer une librairie plus stable, plus performante, plus propre et plus facilement utilisable.
Il commence par parler de la création et de la destruction d'objets et à la façon de les rendre plus performantes. Il traite ensuite des méthodes communes à tous les objets, c'est-à-dire des méthodes héritées d'Object et de comment correctement les implémenter. Le chapitre suivant traite des interfaces et des bonnes pratiques de la conception orientée objet. Puis, il enchaine sur les équivalents du langage C, indiquant par exemple, comment remplacer les unions en Java. Les chapitres suivants traitent des méthodes et de la programmation en générale, indiquant par exemple comment optimiser judicieusement son code. Les 3 derniers chapitres sont chacun très spécifiques, parlant tout d'abord des exceptions, puis des threads et enfin de la sérialisation.
En conclusion, ce livre est indispensable à toute personne voulant écrire une api correctement maintenable et réutilisable. Le style de l'auteur permet de lire ce livre avec une très grande fluidité malgré la grande dose d'informations.
SommaireCréation et destruction d'objets
Méthodes communes à tous les objets
Classes et Interfaces
Équivalents pour constructions du langage C
Méthodes
Programmation générale
Exceptions
Threads
Sérialisation
Annexes
272 pages,
juin 2002
Editions Vuibert,
ISBN10 : 2-7117-4805-7 |
 |
Public visé : Connaissances de base en Java Résumé de l'éditeur
Ce cahier montre aux développeurs Java comment exploiter la très riche bibliothèque standard Swing à travers la création d'une application graphique 3D ergonomique et fiable.
Cet ouvrage décrit la création d'un logiciel libre d'aménagement d'intérieur développé avec Java 5 et Swing, de sa conception UML jusqu'à sa ditribution, en passant par l'utilisation d'Eclipse, dont les astuces de productivité sont dévoilées. Le développeur y découvrira comment exploiter efficacement les nombreuses fonctionnalités de Swing : création d'arbres, de tableaux et de boîtes de dialogue, dessin dans un composant graphique, glisser-déposer, gestion d'opérations annulables, intégration d'un composant 3D, ...
Critique du livre par la rédaction (Baptiste Wicht)
Ce livre est tout simplement génial. C'est la première fois que je lis un livre d'informatique aussi prenant, on a à chaque fois envie d'aller plus loin et d'avancer dans les chapitres.
Ceci est surtout du à structure qu'a utilisée l'auteur pour écrire ce livre. Il n'en a pas fait un simple catalogue Swing montrant toutes les méthodes et classes de Swing et leur utilisation; il crée plutôt un projet qu'on va faire avancer tout au long du livre en lui ajoutant de nouvelles fonctionnalités. En plus de toutes les informations techniques que l'on obtient durant la lecture des différents chapitres, l'auteur nous fait aussi part de son expérience dans le travail en groupe et le développement de projet. En effet, on va voir comment découper le projet en plusieurs scénarios bien distincts, comment appliquer la méthode XP, comme utiliser CVS pour archiver et partager les fichiers du projet, etc. … L'auteur va aussi traiter de la différence SWT/SWING/AWT.
Les domaines techniques abordés par cette application sont très vastes. On va voir comment créer des nouveaux composants Swing en respectant l'architecture MVC et comment faire une application respectant elle aussi le principe MVC. On va aussi voir comment utiliser les composants complexes que sont le JTable et le JTree. On va aussi apprendre à gérer des actions annulables dans l'application et la façon d'utiliser le glisser-déposer dans votre application. On passera aussi sur l'enregistrement de préférences utilisateurs et des données de l'application. En plus, on verra aussi comment visualiser une vue en 2D et en 3D !
En conclusion, je conseille ce livre non seulement à toutes personnes développant une application Swing mais aussi à toute personne développant une application graphique en Java, car ce livre dans ses métiers sait se montrer très général, de sorte que la plupart des informations sont utilisables pour une application graphique non Swing.
Sommaire
499 pages,
1ère édition,
7 Décembre 2006
Editions Eyrolles,
ISBN10 : 2212120192,
Broché |
 |
Public visé : Expérimentés Résumé de l'éditeur
Par son approche pratique fondée sur de nombreux exemples d'application, Design Patterns en Java™ vous amène à une compréhension approfondie des patterns de conception, condition sine qua non pour tirer le meilleur parti de leur puissance dans le développement d'applications en Java. Ce document révolutionnaire introduit les fonctionnalités les plus récentes de Java et les meilleures pratiques aux 23 patterns.
Forts de leur grande expérience en tant qu'instructeurs et programmeurs Java, Steve Metsker et William Wake vous éclaireront sur chaque pattern, au moyen de programmes Java réels, de diagrammes UML et d'exercices clairs et pertinents. Vous passerez rapidement de la théorie à l'application en apprenant comment écrire un meilleur code ou restructurer du code existant pour le rationaliser, le rendre plus performant et plus facile à maintenir.
Si vous êtes un programmeur Java désireux de gagner du temps grâce à l'écriture d'un code plus efficace, les explications lumineuses de cet ouvrage, étayées de nombreux exemples, conseils et techniques vous aideront à y parvenir. Vous maîtriserez la puissance des patterns et améliorerez vos programmes, tant en matière de conception que d'écriture et de maintenance du code.
Critique du livre par la rédaction (Baptiste Wicht)
Il est presque indispensable de connaître les design patterns pour bien concevoir et développer une application. En effet, il participent grandement à l'évolutivité et à la maintenabilité du code.
Ce livre présente les 23 design patterns principaux et il le fait très bien. Tous les patterns sont présentées de la même manière, on commence par voir quelle problèmatique peut régler le pattern en question et et quel est son objectif. Ensuite, on part sur un cas pratique (toujours basé sur la même application), dans lequel on montre la problèmatique et on la résoud grâce au pattern. Si c'est possible, on nous montre aussi d'autres exemples ou l'utilisation du pattern dans la librairie standard de Java, ce qui aide parfois a mieux comprendre quand utiliser le pattern.
Les patterns sont triés en plusieurs catégories différentes : les patterns d'interface, les patterns de responsabilité, les patterns de construction, les patterns de construction et les patterns d'extension. Comme tout les patterns et les catégories sont bien divisés, on peut facilement le lire comme un catalogue et rechercher un pattern spécifique, mais ce livre n'est pas seulement un catalogue de pattern, en effet, il vous propose des exercices pour vérifier vos connaissances et utilise une application concrète tout au long du livre, application dont on peut d'ailleurs télécharger les sources.
On peut néanmoins reprocher plusieurs choses à ce livre. Tout d'abord, l'application choisie n'est peut-être pas la meilleure... On se retrouve souvent avec des termes techniques relatifs aux feux d'artifices ce qui nous embrouille souvent... De plus, on a parfois de la peine à bien comprendre ce que fait vraiment la partie de l'application. Ensuite, le style n'est pas toujours des plus agréables et je n'ai jamais réussi à passer longtemps sur ce livre, alors qu'il m'est arrivé de ne pas décrocher d'autres livres pendant plusieurs heures. Et enfin, du fait parfois du style et parfois des exemples, j'ai eu de la peine à bien comprendre le pattern, notamment VISITOR (mais ce n'est pas le plus simple).
En conclusion, ce livre est une très bonne introduction aux designs patterns et vous permettra de produire un code plus maintenable et évolutif. Mais ne vous attendez pas non plus à un livre que vous lirez des heures durant.
Sommaire
435 pages,
1ère édition,
25 août 2006
Editions CampusPress,
ISBN10 : 2744020990 |
