Vos recrutements informatiques

700 000 développeurs, chefs de projets, ingénieurs, informaticiens...

Contactez notre équipe spécialiste en recrutement

Livres pour utilisateurs débutants

29 livres et 42 critiques, dernière mise à jour le 8 février 2017 , note moyenne : 4.4

  1. Architectures réparties en Java - Middleware Java, services web, messagerie instantanée, transfert de données
  2. Programmer en Java - Java 5 à 7
  3. Programmer en Java
  4. Architecture Réparties en JAVA - Internet des objets avec SOAP, RMI, CORBA, JMS, sockets et services web
  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. iReport 3.7
  7. JBoss AS 5 Development
  8. Apache Maven
  9. Spring par l'exemple
  10. Pro Spring Dynamic Modules for OSGi Service Platforms
  11. Beginning Java™ EE 6 Platform with GlassFish™ 3 - From Novice to Professional
  12. JBoss in Action
  13. Maven: The Definitive Guide - Everything You Need to Know from Ideation to Deployment
  14. Harnessing Hibernate
  15. Programmer en Java
  16. Professional Java Development with the Spring Framework
  17. Le guide de Survie - Java: L'essentiel du code et des commandes
  18. Swing la synthèse - Développement des interfaces graphiques en Java
  19. Java Tête la première - Couvre Java 5.0
  20. Les Cahiers du programmeur Swing
  21. Mieux programmer en Java - 68 astuces pour optimiser son code
  22. Exercices en Java - Couvre Java 5.0
  23. Spring par la pratique
  24. Java en concentré - Manuel de référence pour Java
  25. Les cahiers du programmeur - Java 1.4 et 5.0
  26. Aide-Mémoire de Java
  27. Ant précis & concis
  28. Programming in Scala - A Comprehensive Step-by-Step Guide
  29. Java 8 Lambdas - Functional Programming for the Masses
couverture du livre Architectures réparties en Java

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

Architectures réparties en Java

Middleware Java, services web, messagerie instantanée, transfert de données

de
Public visé : Intermédiaire

Résumé de l'éditeur

Cet ouvrage s’adresse aux ingénieurs logiciel, développeurs, architectes et chefs de projet.
Longtemps les applications réparties ont été réservées à de grands systèmes, mais aujourd’hui les besoins se diversifient et les plus petits objets doivent maintenant communiquer. Le langage Java apporte une simplification importante qui met cette technologie à la portée de tous, notamment dans le monde industriel, et fournit de nombreux outils et concepts pour le middleware.
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 donne ensuite une vue d’ensemble des solutions techniques actuellement disponibles ainsi que des indications sur les implémentations alternatives.
La troisième édition de cet ouvrage met à jour les API JMS 2.0 ainsi que les synchronisations de tâches utilisées pour le big data. Elle incorpore un nouveau chapitre sur les messageries instantanées et la gestion des courriels ainsi qu’un exemple d’architecture REST.

Édition : Dunod - 320 pages , 3eédition, 4 novembre 2015

ISBN10 : 2100738704 - ISBN13 : 9782100738700

Commandez sur www.amazon.fr :

32.00 € TTC (prix éditeur 32.00 € TTC)
  • Problématique des applications réparties
  • Rappels sur Java
  • Sockets et Java NIO
  • Interfaces et pliage des arguments
  • RMI
  • CORBA
  • Annuaires-LDAP-JNDI
  • JMS
  • SOAP et services web
  • JMX, test et déploiement
  • Courriels et messagerie
Critique du livre par la rédaction Julien Plu le 1er août 2016
Ce livre est essentiellement destiné aux personnes ayant une expérience en génie logiciel un petit peu plus poussée que celle enseignée à l’université ou en école, notamment pour ce qui est de l’UML où un chapitre de rappel aurait été le bienvenu. Néanmoins, malgré ce petit bémol les paradigmes utilisés pour la réalisation d’applications réparties sont parfaitement bien expliqués et mettent le lecteur directement dans le vif du sujet.

Un autre avantage de ce livre est qu’il n’est pas forcément nécessaire d’avoir un gros niveau en Java, l’auteur a écrit un chapitre d’apprentissage essentiellement consacré aux connaissances nécessaires qui seront utilisées dans les chapitres suivants, de ce fait après une lecture des quatre premiers chapitres, le lecteur a tout ce qu’il lui faut pour entamer le plus gros de l’ouvrage.

J’ai particulièrement aimé ce livre, car l’auteur illustre tout à la fois par des schémas et par des bouts de code, ce qui fait que l’on a une bonne image des problèmes et des solutions associées. J’ai particulièrement aimé le chapitre sur JMS que j’ai tout de suite pu implémenter dans un de mes projets afin de grandement faciliter son utilisation.

Je recommande donc cet ouvrage principalement pour les personnes venant du monde du génie logiciel. Le seul bémol de ce livre est le manque d’un chapitre sur un rappel d’UML. Malgré cela, ce livre est particulièrement bien écrit et surtout compréhensible afin d’avoir un contenu qui peut immédiatement être appliqué sans l’aide d’autres sources particulières sur le sujet.




 Poster une réponse

Avatar de snake264 snake264 - Responsable Web sémantique https://www.developpez.com
le 26/07/2016 à 10:52
Architectures réparties en Java
Middleware Java, services web, messagerie instantanée, transfert de données
Cet ouvrage s’adresse aux ingénieurs logiciel, développeurs, architectes et chefs de projet.
Longtemps les applications réparties ont été réservées à de grands systèmes, mais aujourd’hui les besoins se diversifient et les plus petits objets doivent maintenant communiquer. Le langage Java apporte une simplification importante qui met cette technologie à la portée de tous, notamment dans le monde industriel, et fournit de nombreux outils et concepts pour le middleware.
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 donne ensuite une vue d’ensemble des solutions techniques actuellement disponibles ainsi que des indications sur les implémentations alternatives.
La troisième édition de cet ouvrage met à jour les API JMS 2.0 ainsi que les synchronisations de tâches utilisées pour le big data. Elle incorpore un nouveau chapitre sur les messageries instantanées et la gestion des courriels ainsi qu’un exemple d’architecture REST.

[Lire la suite]




couverture du livre Programmer en Java - Java 5 à 7

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

Programmer en Java - Java 5 à 7

de

Résumé de l'éditeur

Dans cet ouvrage, Claude Delannoy applique au langage Java la démarche pédagogique qui a fait le succès de ses livres sur le C et le C++. Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses.

L'apprentissage du langage se fait en quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction au développement Web avec les servlets Java et les JSP.

L'ouvrage met l'accent sur les apports des versions 5 et 6 de Java Standard Edition : programmation générique, types énumérés, annotations... Un chapitre est dédié aux design patterns en Java et cette 8e édition prend en compte les principaux changements apportés par Java 7 : emploi de chaînes dans l'instruction switch, gestion des catch multiples, gestion automatique des ressources dans un bloc try, nouvelles possibilités de gestion de flux avec NI0.2.

Chaque notion nouvelle et chaque fonction du langage sont illustrées de programmes complets dont le code source est en libre téléchargement sur le site www.editions-eyrolles.com.

Édition : Eyrolles - 868 pages , 8eédition, 27 septembre 2012

ISBN10 : 2212135661 - ISBN13 : 9782212135664

Commandez sur www.amazon.fr :

30.40 € TTC (prix éditeur 32.00 € TTC)
  • Présentation de Java
  • Généralités
  • Les types primitifs de Java
  • Les opérateurs et les expressions
  • Les instructions de contrôle de Java
  • Les classes et les objets
  • Les tableaux
  • L'héritage
  • Les chaînes de caractères et les types énumérés
  • La gestion des exceptions
  • Les threads
  • Les bases de la programmation graphique
  • Les contrôles usuels
  • Les boîtes de dialogue
  • Les menus, les actions et les barres d'outils
  • Les événements de bas niveau
  • Les gestionnaires de mise en forme
  • Textes et graphiques
  • Les applets
  • Les flux et les fichiers
  • La programmation générique
  • Les collections et les algorithmes
  • La programmation Java côté serveur : servlets et JSP
  • Utilisation de bases de données avec JDBC
  • L'introspection et les annotations
  • Introduction aux Design Patterns
  • Annexes
Critique du livre par la rédaction Julien Plu le 26 octobre 2013
Ce livre est pour tous les développeurs Java aussi bien les débutants que pour ceux qui maîtrisent le langage. Il aborde parfaitement toute la panoplie des principales fonctionnalités de Java, y compris de la dernière version, Java 7 (NIO.2 et la gestion automatique des ressources).
J'ai particulièrement aimé le chapitre sur l'utilisation des principaux design patterns, celui sur les composants graphiques Swing et celui sur JEE (servlet, JSP et JavaBeans) qui sont particulièrement bien écrits.

Le chapitre sur la généricité est assez compliqué à comprendre, mais c'est normal sachant que ce concept n'est à la base pas facile à maîtriser.
Il y a malgré tout quelques petites déceptions comme la maigreur de la partie sur les sockets (l'étude des sockets en SSL aurait été la bienvenue), l'absence d'explications pour ce qui concerne les applications distribuées (RMI) et les applications à base d'EJB. Mais il n'y a pas de doute que cela fera partie des futures éditions.

Pour conclure on peut dire que les débutants, une fois ce livre en main pourront sans hésiter commencer à développer des applications complexes sans grande difficultés. Pour ce qui est des développeurs qui maîtrisent le Java, cet ouvrage leur fera sans nul doute un excellent aide-mémoire.


couverture du livre Programmer en Java

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

Programmer en Java

de
Public visé : Débutant

Résumé de l'éditeur

Dans cet ouvrage, Claude Delannoy applique au langage Java la démarche pédagogique qui a fait le succès de ses livres sur le C et le C++. Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses.
L'apprentissage du langage se fait en quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction au développement Web avec les servlets Java, les JSP et JDBC.
L'ouvrage met l'accent sur les apports des versions 5 à 8 de Java Standard Edition : programmation générique, types énumérés, annotations... Un chapitre est dédié aux design patterns en Java et cette 9e édition comporte deux chapitres supplémentaires sur des nouveautés majeures de Java 8 : les streams et les expressions lambda ; la gestion du temps, des dates et des heures.
Chaque notion nouvelle et chaque fonction du langage sont illustrées de programmes complets dont le code source est en libre téléchargement sur le site www.editions-eyrolles.com.

À qui s'adresse ce livre ?
Aux étudiants de licence et de master, ainsi qu'aux élèves d'écoles d'ingénieurs.
À tout programmeur ayant déjà une expérience de la programmation (Python, PHP, C/C++, C#...) et souhaitant s'initier au langage Java.

Édition : Eyrolles - 940 pages , 9eédition, 12 juin 2014

ISBN10 : 221214007X - ISBN13 : 9782212140071

Commandez sur www.amazon.fr :

36.00 € TTC (prix éditeur 36.00 € TTC)
Présentation de Java
Généralités
Les types primitifs de Java
Les opérateurs et les expressions
Les instructions de contrôle de Java
Les classes et les objets
Les tableaux
L'héritage
Les chaînes de caractères et les types énumérés
La gestion des exceptions
Les threads
Les bases de la programmation graphique
Les contrôles usuels
Les boîtes de dialogue
Les menus, les actions et les barres d'outils
Les événements de bas niveau
Les gestionnaires de mise en forme
Textes et graphiques
Les applets
Les flux et les fichiers
La programmation générique
Les collections et les algorithmes
Expressions lambda et streams
L'introspection et les annotations
La gestion du temps et les heures (Java 8)
La programmation Java côté serveur : servlets et JSP
Utilisation de bases de données avec JDBC
Introduction aux Design Patterns
Annexes
Critique du livre par la rédaction Julien Plu le 29 octobre 2014
Je n'ai pas grand-chose à dire sur cette nouvelle édition mis à part que dans la lignée des précédentes elle reste la meilleure référence du langage. Je n'ai pas de point négatif sur cette édition, elle enseigne les nouveautés de Java 8 de façon très innovante, comme le reste d'ailleurs. Je la conseille à tout le monde : du plus débutant, pour apprendre, au plus expert, comme référence.
Critique du livre par la rédaction Hinault Romaric le 29 août 2015
Java 8 est une évolution majeure qui a entraîné une modification importante de la machine virtuelle Java (JVM). La sortie de cette version m’a donné une envie de me remettre à niveau en ce qui concerne Java.

Ayant des connaissances un peu limitées en Java et étant plus expérimenté en programmation C#, j’ai estimé que c’était l’occasion pour revoir en profondeur ce que Java offre. Après quelques recherches en ligne, mon choix s’est porté sur ce livre de Claude Delannoy, dont j’apprécie le style rédactionnel et l’approche pédagogique de ses œuvres.

Ce livre est une véritable « bible du langage Java ». Il permet de découvrir progressivement les principes de la programmation orientée objet et les caractéristiques du langage Java.

Je voulais essentiellement en apprendre plus sur les expressions Lambda et Streams. Avec ce livre, je n’ai pas été déçu. Par des exemples concrets et commentés, l’auteur « décortique » ces apports de Java 8 qui à première vue peuvent sembler déroutants.

En supplément, une partie sur les design patterns a été introduite dans le livre. De quoi se familiariser avec ces concepts qui sont d’un grand apport dans la conception d’une application.

Je conseille ce livre à toute personne qui souhaite avoir une bonne maîtrise du langage Java. Le débutant y trouvera un excellent guide à la programmation orientée objet et à Java. L’expert pourra mettre à jour ses connaissances et découvrir d’autres subtilités du langage.


couverture du livre Architecture Réparties en JAVA

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

Architecture Réparties en JAVA

Internet des objets avec SOAP, RMI, CORBA, JMS, sockets et services web

de

Résumé de l'éditeur

Une architecture logicielle répartie permet de faire communiquer des machines en réseau par programme. Longtemps les applications reparties ont été réservées à de grands systèmes (espace, militaire), à présent les besoins se diversifient (communication en pair à pair, multiplication des réseaux, internet des objets) et même les plus petits objets sont en communication. Le langage Java 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.

La deuxième édition de cet ouvrage met à jour le chapitre sur les services web, complète certains aspects de RMI et introduit de nouvelles notions sur IPV6, les interfaces réseau et la programmation multicœurs.

Cet ouvrage s'adresse aux ingénieurs logiciels, développeurs, architectes et chefs de projet. Il s'adresse également aux étudiants en écoles d'ingénieurs et en master d'informatique.

Édition : Dunod - 241 pages , 2eédition, 10 septembre 2012

ISBN10 : 2100582178 - ISBN13 : 9782100582174

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 27.55 € TTC)
  • Problématique des applications réparties
  • Rappels sur Java
  • Sockets et Java NIO
  • Interfaces et pliage des arguments
  • RMI
  • CORBA
  • Annuaires LDAP-JNDI
  • JMS
  • SOAP et services web
  • JMX, test et déploiement
Critique du livre par la rédaction Kuntz Demazy MBELLA le 13 avril 2013
De prime abord, on peut dire de ce livre qu'il n'est pas fait pour les débutants en JAVA et encore moins en architecture logicielle. Il s'agit d'un livre assez bien structuré et indiqué pour ceux qui ont une certaine expérience pratique de ce domaine.
Cependant, il est agréable à lire et à comprendre : l'auteur a effectué une entrée en matière réussit en posant le problème de façon générale, et plus spécifiquement en s'appuyant autour de l'approche JAVA de la chose. Ainsi après une introduction autour des concepts importants et nécessaires à la compréhension de la suite de l'ouvrage une vue panoramique du langage JAVA est exposée afin de remettre le lecteur en condition. Les aspects généraux sont exposés et expliqués notamment pour ce qui concerne la sérialisation, les threads, les design patterns, etc. La suite est une entrée directe dans le vif du sujet ou les concepts tels SOAP, RMI, CORBA, JMS, les services Web sont exposés tout d'abord théoriquement et par la suite pratiquement avec des extraits de code illustratifs. D'ailleurs l'ensemble des codes sources de l'ouvrage est disponible sur le site de l'ouvrage.
Le seul bémol que je lui trouve à ce livre, c'est l'aspect conception des architectures réparties qui lui manque un peu : il aurait été intéressant d'avoir un cas pratique de conception et de mise en œuvre d'une application répartie utilisant les concepts exposés dans l'ouvrage.
C'est donc un livre qui pour ma part est opérationnel, on ne s'encombre pas de trop de théorie qu'on estime déjà acquise et on va directement à la mise en œuvre du concept. Je le conseille vivement à ceux qui veulent aller droit au but dans tout ce qui est de la mise en œuvre des architectures réparties en se basant sur Java ou pour s'en faire une idée pratique.




 Poster une réponse

Avatar de kdmbella kdmbella - Expert éminent https://www.developpez.com
le 24/04/2013 à 16:40
Bonjour.

La rédaction de Developpez a lu pour vous l'ouvrage suivant :

Architecture Réparties en Java de Annick Fron

RÉSUMÉ DE L'ÉDITEUR

Une architecture logicielle répartie permet de faire communiquer des machines en réseau par programme. Longtemps les applications reparties ont été réservées à de grands systèmes (espace, militaire), à présent les besoins se diversifient (communication en pair à pair, multiplication des réseaux, internet des objets) et même les plus petits objets sont en communication. Le langage Java 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.

La deuxième édition de cet ouvrage met à jour le chapitre sur les services web, complète certains aspects de RMI et introduit de nouvelles notions sur IPV6, les interfaces réseau et la programmation multicœurs.

Cet ouvrage s'adresse aux ingénieurs logiciels, développeurs, architectes et chefs de projet. Il s'adresse également aux étudiants en écoles d'ingénieurs et en master d'informatique.

L'avez-vous lu ? Comptez-vous le lire bientôt ?

Quel est votre avis ?
couverture du livre Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

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

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

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

de
Public visé : Débutant

Résumé de l'éditeur

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

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

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

Tout au long des chapitres, l'auteur :

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


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

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

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

ISBN10 : 2746055678 - ISBN13 : 9782746055674

Commandez sur www.amazon.fr :

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

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

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

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

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




 Poster une réponse

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

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

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

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

iReport 3.7

de

Résumé de l'éditeur

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

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

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

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

Édition : PackT Publishing - 222 pages , 1re édition, 1er mars 2010

ISBN10 : 1847198805 - ISBN13 : 9781847198808

Commandez sur www.amazon.fr :

28.91 € TTC (prix éditeur 29.98 € TTC)
Chapter 1: Introduction to iReport
Chapter 2: Building Your First Report
Chapter 3: Report Layout and Formatting
Chapter 4: Using Variables
Chapter 5: Using Parameters
Chapter 6: Grouping Data in Reports
Chapter 7: Subreports
Chapter 8: Crosstab Reports
Chapter 9: Charting
Chapter 10: Working with Images
Chapter 11: Calling Reports from Java Applications
Chapter 12: iReport in NetBeans
Appendix: A Sample Database
Critique du livre par la rédaction longbeach le 1er mai 2010
Dans ce livre constitué de 12 chapitres, l'auteur Shamsuddin Ahammad présente iReport, l'outil indispensable pour concevoir des rapports basés sur la librairie JasperReports, écrite en Java.
Une base MySQL est créée et son modèle décrit dans l'annexe.

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

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




 Poster une réponse

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 09/05/2010 à 7:40
Bonjour,
un livre sur l'outil de reporting iReport est sorti récemment. Son titre est iReport 3.7 et il est publié aux éditions Packt Publishing.

[ame="http://www.amazon.fr/exec/obidos/ASIN/1847198805/wwwdeveloppec-21"]Ireport 3.7: Amazon.fr: S. Ahammad: Livres en anglais@@AMEPARAM@@http://ecx.images-amazon.com/images/I/519kB4MjZOL.@@AMEPARAM@@519kB4MjZOL[/ame]

Ma critique est disponible à l'adresse URL suivante :


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


Bonne lecture.
couverture du livre JBoss AS 5 Development

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

JBoss AS 5 Development

de

Résumé de l'éditeur

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

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

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

ISBN10 : 1847196829 - ISBN13 : 9781847196828

Commandez sur www.amazon.fr :

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

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




 Poster une réponse

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

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

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

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

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

Apache Maven

de

Résumé de l'éditeur

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

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

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

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

ISBN10 : 274402337X - ISBN13 : 9782744023378

18,7 x 23 cm

Commandez sur www.amazon.fr :

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

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

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

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

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

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

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

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

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

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




 Poster une réponse

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

27/12/2009 :

La critique de romaintaz, membre de la rédaction

Quelques extraits :

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

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

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

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

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

11/11/2009 :

Bonjour,

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

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


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


De quoi se faire une idée du contenu

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

En plus la couverture est sympa.
couverture du livre 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.




 Poster une réponse

Avatar de Baptiste Wicht Baptiste Wicht - Expert éminent sénior https://www.developpez.com
le 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
le 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
le 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.




 Poster une réponse

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 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
le 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
le 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 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 longbeach 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.




 Poster une réponse

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 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/?p...L9781430219545
couverture du livre JBoss in Action

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

JBoss in Action

de
Public visé : Débutant

Résumé de l'éditeur

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

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

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

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

Édition : Manning - 464 pages , 1re édition, 1er janvier 2009

ISBN10 : 1933988029 - ISBN13 : 9781933988023

Commandez sur www.amazon.fr :

31.49 € TTC (prix éditeur 39.82 € TTC) livraison gratuite !
PART 1 THE JBOSS APPLICATION SERVER
  • 1 Vote for JBoss
  • 2 Managing the JBoss Application Server
  • 3 Deploying applications
  • 4 Securing applications

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

Part 3 JBOSS PORTAL
  • 10 The JBoss Portal and portlets
  • 11 Configuring the JBoss Portal

Part 4 GOING TO PRODUCTION
  • 12 Understanding clustering
  • 13 Clustering JBoss AS services
  • 14 Tuning the JBoss Application Server
  • 15 Going to production

Critique du livre par la rédaction longbeach le 1er juin 2009
Le livre est divisé en 4 parties.

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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




 Poster une réponse

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 02/06/2009 à 8:51
Bonjour,

Manning a publié en janvier un ouvrage intitulé JBoss in Action: Configuring the JBoss Application Server écrit par Javid Jamae et Peter Johnson.

Etant donné la rareté d'ouvrages récents sur JBoss (mis à part le récent JBoss - Développement, déploiement et sécurisation d'applications JEE) certains d'entre vous ont sans doute envisagé de se retourner vers les livres anglais ?

L'avez vous lu, et si oui qu'en pensez vous ?

Eric
Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 04/06/2009 à 7:22
Je vous invite à lire ma critique du livre JBoss in Action à cette adresse :
http://java.developpez.com/livres/?p...L9781933988023
couverture du livre Maven: The Definitive Guide

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

Maven: The Definitive Guide

Everything You Need to Know from Ideation to Deployment

de

Résumé de l'éditeur

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

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

Édition : O'Reilly - 468 pages , 1re édition, 1er octobre 2008

ISBN10 : 0596517335 - ISBN13 : 9780596517335

Commandez sur www.amazon.fr :

23.06 € TTC (prix éditeur 24.28 € TTC)
  • Introduction
    • Introducing Apache Maven
    • Installing and Running Maven
  • Maven by Example
    • A simple Maven Project
    • Customizing a Maven Project
    • A Simple Web Application
    • A Multimodule Project
    • Multimodule Enterprise Project
  • Maven Reference
    • Optimizing and Refactoring POMs
    • The Project Object Model
    • The Build Lifecycle
    • Build Profiles
    • Maven Assemblies
    • Properties and Resource Filtering
    • Maven and Eclipse: m2eclipse
    • Site Generation
    • Repository Manager
    • Writing Plugins
    • Writing Plugins in Alternative Languages
  • Appendixes
    • Settings Details
    • Sun Specification Alternatives
Critique du livre par la rédaction Eric REBOISSON le 1er février 2009
"Maven : the definitive guide" est un livre adoptant une pédagogie très progressive sur l'outil Maven. Commençant par une présentation en surface de l'outil (son orientation déclarative, quelques commandes de base, les plugins connexes) pour continuer sur un descriptif de ses possibilités plus étendues (extension par l'écriture de plugin, intégration dans Eclipse, etc.).

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


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


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


Voilà donc un ouvrage que j'ai vraiment apprécié et dont je conseille vivement la lecture ! A noter au final aussi la sympathique (ou pas) métaphore du fourmilier en couverture…
Critique du livre par la rédaction Ricky81 le 1er janvier 2009
Ce livre porte bien son nom. Non seulement il est destiné à tout public, mais en plus il constitue vraiment un guide complet sur Maven 2.
En effet, il aborde tous les aspects de Maven 2 (cycle de vie, gestion de dépendances, outils, extensions, etc.) en fournissant au lecteur suffisamment d'éléments pour que celui-ci puisse approfondir s'il le souhaite.

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

J'ai été impressionné par le nombre d'astuces et de conseils prodigués, permettant d'utiliser Maven 2 de manière intelligente et non en suivant une simple mécanique de déclaration pure et dure de dépendances.

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

Enfin, on appréciera la présence des 2 annexes permettant respectivement d'avoir un aperçu des éléments de configuration pouvant être déclarés dans le fichier de configuration global (settings.xml), ainsi que les artefacts du serveur Geronimo qui vous permettrons de pallier à l'indisponibilité (via les repositories) de ceux correspondants à la spécification Java EE (vous évitant de devoir installer ces derniers à la main).
En conclusion, Maven: The Definitive Guide est un livre bien écrit, assez complet, et dans lequel tout lecteur devrait s'y retrouver.
Ce qui est vraiment appréciable, c'est que les auteurs ne masquent en aucun cas les défauts et problématiques courantes survenant avec Maven 2, mais surtout qu'ils fournissent au lecteur les outils et pratiques pour traiter ces derniers.
Un livre à recommander.


couverture du livre Harnessing Hibernate

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

Harnessing Hibernate

de
Public visé : Débutant

Résumé de l'éditeur

This guide is an ideal introduction to Hibernate, the framework that lets Java developers work with information from a relational database easily and efficiently. Databases are a very different world than Java objects, and with Hibernate, bridging them is significantly easier. This new edition lets you explore the system, from download and configuration through a series of projects that demonstrate how to accomplish a variety of practical goals.

Édition : O'Reilly - 380 pages , 1re édition, 1er mai 2008

ISBN10 : 0596517726 - ISBN13 : 9780596517724

Commandez sur www.amazon.fr :

28.12 € TTC (prix éditeur 29.91 € TTC)
Chapitre 1. Installation and setup
Chapitre 2. Introduction to mapping
Chapitre 3. Harnessing Hibernate
Chapitre 4. Collections and Associations
Chapitre 5. Richer Associations
Chapitre 6. Custom Value Types
Chapitre 7. The Annotation Alternative
Chapitre 8. Criteria Queries
Chapitre 9. A Look at HQL
Chapitre 10. Connecting Hibernate to MySQL
Chapitre 11. Hibernate and Eclipse: Really Using
Chapitre 12. Maven in More Depth
Chapitre 13. Put a Spring in your Step: Hibernate with Spring
Chapitre 14. The finishing Touch: Stripes with Spring and Hibernate
Critique du livre par la rédaction Petrus le 24 février 2009
Habitué à d'autres formes de persistence et ORM avec le langage Java, Harnessing Hibernate est ma première lecture sur Hibernate. Les chapitres de ce livre gravitent autour d'un projet central (le traditionnel outil de gestion de collection de musique), enrichi au fur et à mesure par les fonctionnalités d'Hibernate. Installation des outils (Maven, Ant), mappings et requêtes simples, requêtes Criteria, annotations, intégration avec d'autres bases de données (HSQLDB, MySQL) et outils (Spring, Stripes, IDE Eclipse) : une vision assez globale est donnée et vous serez en mesure de construire vos premiers projets avec une couche de persistence reposant sur Hibernate, et en exploitant les primitives simples.

Néanmoins je trouve que l'auteur consacre beaucoup trop de temps aux outils annexes comme Maven (le chapitre 12!), qui nécessite à lui seul un livre, et j'aurais préféré qu'il passe davantage de temps sur des mappings plus complexes, ou encore à la gestion de cache, la gestion des sessions Hibernate. Il demeure bien construit pour un lecteur débutant, mais aura du mal à satisfaire celui-ci dés l'apparition des premiers besoins atypiques et plus complexes. Utile, mais loin d'être indispensable.


couverture du livre Programmer en Java

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

Programmer en Java

de

Résumé de l'éditeur

Dans cet ouvrage, Claude Delannoy applique au langage Java la démarche pédagogique qui a fait le succès de ses livres sur le C et le C++. Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses. L'apprentissage du langage se fait en quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction au développement Web avec les servlets Java et les JSP. Chaque notion nouvelle et chaque fonction du langage sont illustrées de programmes complets dont le code source est fourni sur le CD-Rom d'accompagnement. L'environnement de développement Eclipse, également fourni sur le CD-Rom, vous permettra de tester ces exemples et de développer vos propres programmes Java. L'accent est mis dans cette 5e édition sur les nouveautés des versions 5 et 6 de Java Standard Edition : programmation générique, types énumérés, annotations (chapitre nouveau), nouvelles possibilités de la classe File, nouveau gestionnaire Grouplayout, nouvelles interfaces et classes de collections (Queue, Deque, ArrayDeque, NavigableSet, NavigableMap), fonctionnalités permettant de professionnaliser une application (classes Desktop et Console, action sur la barre des tâches du système), etc. Lorsque nécessaire, les exemples de code ont été fournis en deux versions : une version exploitant les possibilités nouvelles de Java SE 5 et 6 et une version compatible avec les versions antérieures.

Biographie de l'auteur

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

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

ISBN10 : 2212122322 - ISBN13 : 9782212122329

Commandez sur www.amazon.fr :

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

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


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


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

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


couverture du livre 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 Le guide de Survie

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

Le guide de Survie

Java: L'essentiel du code et des commandes

de
Public visé : Intermédiaire

Résumé de l'éditeur

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

Édition : Campus Press - 232 pages , 1er mars 2007

ISBN10 : 2744021628 - ISBN13 : 9782744021626

Commandez sur www.amazon.fr :

15.02 € TTC (prix éditeur 16.00 € TTC)
Java: Le guide de Survie

  • Introduction
  • Les bases
  • Interagir avec l'environnement
  • Manipuler des chaines
  • Travailler avec des structures de données
  • Dates et Heures
  • Retrouvez des motifs avec des expressions régulières
  • Nombres
  • Entrées/Sorties
  • Travailler avec des répertoires et des fichiers
  • Clients Réseau
  • Serveurs Réseau
  • Envoyer et recevoir des emails
  • Accès aux bases de données
  • XML
  • Utiliser des Threads
  • Programmation dynamique par réflexion
  • Empaquetage et documentation des classes
  • Index
Critique du livre par la rédaction vbrabant le 1er septembre 2007
Une excellente FAQ de poche

Ce livre de poche, complément idéal de l'Aide-Mémoire Java publié chez Dunod, se présente comme un guide de survie. C'est en fait une bonne petite FAQ couvrant les API de bases de Java. Que ce soit les entrées/sortie, la manipulation des chaines de caractères, des dates, des nombres. Mais cela couvre également d'autres domaines comme l'écriture/lecture de fichiers ZIP, l'envoi/réception de mails via JAVAMail, la transformation XML par XSLT, ….
Je vous laisse découvrir par vous-même la table des matières pour que vous sachiez exactement ce qu'il couvre.
La façon dont le livre est découpé, et dont les exemples de code sont présentés, permet de trouver rapidement ce que l'on cherche.
En effet, quasi chaque sous-chapitre d'un chapitre commence par un bout de code, en blanc sous fond noir. Ce qui fait que lorsqu'on feuillete ou parcourt rapidement le livre ou un chapitre à la recherche d'une solution à notre problème, notre regard est directement attiré sur le code, ce qui en facilite grandement sa recherche.

Chaque code est accompagné d'un texte explicatif, lorsque c'est nécessaire, mais surtout d'autres détails et/ou astuces supplémentaires y sont donnés.
Les bouts de code sont toujours très courts mais toujours utilisables.
J'ai noté quelques exemples pour lesquels je ne suis personellement pas toujours d'accord. Ainsi, pour voir si une chaîne de caractères contient un nombre, il utilise le parseInt() de la classe Integer enrobé dans un try-catch avec NumberFormatException. Sachant qu'une exception coute cher, je préfère utiliser d'autres techniques que cela pour vérifier que c'est bien un nombre.

Aussi, lorsqu'il s'agit d'additionner et de soustraire des dates, ou de calculer la différence entre deux dates, son auteur propose à chaque fois d'additionner/soustraire des millisecondes ou de convertir en millisecondes.
J'aurais préféré qu'il propose des exemples de code où il utilise JodaTime, tout comme il propose des exemples de code avec JavaMail pour la gestion des mails.

JodaTime est vraiment l'API qu'il vous faut si vous devez manipuler des dates et des intervalles de dates. D'ailleurs, une JSR a été créée récemment pour introduire JodaTime dans une prochaine version du JDK
A part cela, je n'ai trop rien à dire. Une vraie petite FAQ de poche.


couverture du livre Swing la synthèse

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

Swing la synthèse

Développement des interfaces graphiques en Java

de
Public visé : Débutant

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.

Édition : Dunod - 348 pages , 2eédition, 1er novembre 2005

ISBN10 : 2100492195 - ISBN13 : 9782100492190

Broché

Commandez sur www.amazon.fr :

35.15 € TTC (prix éditeur 37.00 € TTC)
  • Concepts fondamentaux, premiers pas avec Swing
  • Les layouts
  • Les événements
  • Les composants plus complexes
  • Les composants texte
  • Le drag and drop
  • Concepts avancés
  • Les apports des dernières versions de Java
  • Le formalisme UML
Critique du livre par la rédaction Baptiste Wicht le 1er août 2007
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.


couverture du livre Java Tête la première

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

Java Tête la première

Couvre Java 5.0

de
Traducteurs : Marie-Cécile Baland
Public visé : Débutant

Résumé de l'éditeur

On sait bien ce que vous pensez. ; mais que vient faire un canard dans le chapitre sur la gestion de la mémoire ? Est-ce qu'une fille dans son bain peut vraiment illustrer la subtilité d'un sujet comme le polymorphisme ? Préparez-vous à tester votre ouverture d'esprit. " Java - Tête la première " mélange jeux, images, interviews et vous amène à être actif de différentes manières. Rapide, réel, concret et amusant. Ce livre est tout cela.
Il existe mille et une façons d'apprendre. Ce livre en a choisi une bien spécifique. Sous des dehors amusants et ludiques, cet ouvrage n'en demeure pas moins parfaitement, rigoureux. Mais la différence réside dans les jeux, les énigmes à résoudre, toutes ces images, bref, la façon dont vous allez apprendre.
Cette seconde édition de " Java - Tête la première " est une introduction à la programmation orientée objet et à java. Elle se concentre sur java 5.0, la dernière version du langage java. Celle-ci représentant une mise à jour importante de la plate-forme, nous vous proposons une nouvelle édition de " Java - Tête la première ", avec beaucoup plus de code, de jeux, etc. Les sujets suivants seront abordés : les bases du langage ; le développement orienté objet ; la manière d'écrire, de tester et de déployer des applications ; l'utilisation de la bibliothèque d'API java ; le formatage des dates et des nombre ; la gestion des exception ; le multithreading ; la programmation avec Swing ; le réseau avec RMI et les sockets.
L'approche des auteurs est concentrée sur la pédagogie. Les concepts s'appuient sur des images et sur des exercices ludiques. Les différents points n'en sont alors que mieux mémorisés. Vous allez réellement penser comme un développeur orienté objet.
Si vous voulez apprendre Java mais qu'en même temps vous aimez sortir et vous amuser, alors feuilletez ce livre. Il est fait pour vous !

Édition : O'Reilly - 687 pages , 2eédition, 1er novembre 2006

ISBN10 : 2841774112 - ISBN13 : 9782841774111

Commandez sur www.amazon.fr :

46.55 € TTC (prix éditeur 49.00 € TTC)
  • Intro
  • Jetons nous à l'eau : on pique une tête
  • Voyage à Objectville : oui, il y aura des objets
  • Maîtrisez vos variables : types primitifs et références
  • Le comportement des objets : l'état des objets affecte le comportement des méthodes
  • Méthodes extra-fortes : contrôle de flots, opérations et autres
  • Utiliser la bibliothèque Java : pour éviter de tout écrire vous-même
  • Mieux vivre à Objectville : planifier l'avenir
  • Le polymorphisme dans tous ses états : interfaces et classes abstraites
  • Vie et mort d'un objet : constructeurs et gestion de la mémoire
  • Affaires de nombres : math, formatage, classes, enveloppes et static
  • Comportements à risque : gestion des exceptions
  • Une histoire très graphique : IHM, gestion des événements et classes internes
  • Travaillez votre Swing : gestionnaires d'agencement et composants
  • Sauvegarder les objets : sérialisation et E/S
  • Établir une connexion : sockets et threads
  • Structures de données : collections et génériques
  • Déployez votre code : packages et déploiement
  • Informatique distribuée : RMI plus une touche de servlets, d'EJB et de Jini
  • Annexe A : Recettes de code
  • Annexe B : Dix notions importantes qui ne rentraient pas dans le reste du livre
  • Index
Critique du livre par la rédaction afrikha le 1er juin 2007
J'ai trouvé ce livre tout simplement excellent. Les auteurs de ce livre abordent Java d'une manière très originale qui consiste à combiner images, textes et jeux, ce qui permet de démystifier bon nombre de sujets délicats, ainsi on peut y trouver, par exemple, un dialogue entre une variable locale et une variable d'instance !

Chaque chapitre est clôturé par une série d'exercices très bien faits et ordonnés par difficulté croissante. Vous pouvez donc vous retrouver à jouer le rôle du compilateur ou bien de la JVM ce qui peut être très instructif.

J'ajouterais que pour tirer pleinement parti de ce livre, il vaut mieux connaître déjà un langage de programmation et qu'il soit de préférence orienté objet (mais ce n'est pas obligatoire). Si vous faites partie de cette catégorie de gens alors ce livre constitue un très bon investissement. Dans le cas contraire, passez votre chemin.


couverture du livre Les Cahiers du programmeur Swing

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

Les Cahiers du programmeur Swing

de

Résumé de l'éditeur

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

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

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

ISBN10 : 2212120192 - ISBN13 : 9782212120196

Broché

Commandez sur www.amazon.fr :

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


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

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

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

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


couverture du livre Mieux programmer en Java

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

Mieux programmer en Java

68 astuces pour optimiser son code

de
Public visé : Débutant

Résumé de l'éditeur

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

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

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

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

ISBN10 : 2212091710 - ISBN13 : 9782212091717

Commandez sur www.amazon.fr :

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




 Poster une réponse

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

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

Exercices en Java

Couvre Java 5.0

de
Public visé : Débutant

Résumé de l'éditeur

Conçu pour les étudiants en informatique, ce recueil d'exercices corrigés est le complément idéal de Programmer en Java du même auteur ou de tout autre ouvrage d'initiation au langage Java. Cette nouvelle édition a été mise à jour pour tenir compte des nouveautés de Java 5.0. Elle comporte deux nouveaux chapitres (les types énumérés et les génériques), soit 17 exercices supplémentaires. Les 160 exercices sont classés par thèmes en 16 chapitres. Chaque chapitre débute par la liste des nations nécessaire la résolution des exercices (section Prérequis). Certains exercices portent sur une notion précise indiquée dans l'énoncé. D'autres, appelés Exercices de synthèse, font appel à la mise en rouvre de plusieurs notions étudiées dans les exercices chapitres précédents, et nécessitent donc un effort de réflexion plus fourni. Chaque énoncé d'exercice est suivi d'une ou plusieurs solutions détaillées.

Édition : Eyrolles - 313 pages , 2eédition, 1er août 2006

ISBN10 : 2212119895 - ISBN13 : 9782212119893

Commandez sur www.amazon.fr :

18.91 € TTC (prix éditeur 19.09 € TTC)
  • Les opérateurs et les expressions
  • Les instructions de contrôle
  • Les classes et les objets
  • Les tableaux
  • L'héritage et le polymorphisme
  • La classe String et les chaînes de caractères
  • Les exceptions
  • Les bases de la programmation événementielle
  • Les principaux contrôles de Swing
  • Les boîtes de dialogue
  • Les menus
  • Les événements de bas niveau
  • Les applets
  • Les flux et les fichiers
  • La programmation générique
Critique du livre par la rédaction vbrabant le 1er janvier 2007
Tout d'abord, je dois vous dire que c'est la première fois que j'ai un livre de Claude Delannoy dans mes mains. Et je suis parti du principe que ce livre doit m'offrir des exercices pour programmer en Java (mais aussi en Java 5, vu que c'est le pourquoi de la 2ième édition).

Les moins :
  • Rien trouvé sur les collections
  • Rien trouvé sur la nouvelle boucle for each (for : )
  • Explications quelques fois trop succinctes, voire même complètement absentes


Les plus :
  • Bien structuré
  • Respect des conventions (une classe commence par un Majuscule, une méthode par une minuscule, CamelAnnotation, …)
  • La généricité y est bien abordée
  • Les énumérations y sont bien expliquées
  • Les exercices permettent de vous entraîner pour la certification (mais attention, ce livre ne suffit pas à vous préparer à la certification !!!)


Mon évaluation de l'ouvrage a été guidée par les points suivants :
  • Les nouveautés contenues dans Java 5 sont vraiment traitées de façon inégale.
  • Il n'y a pas vraiment d'exercices concernant les collections, et leur gestion, et je n'en ai pas vu non plus concernant les Threads.
  • Les solutions des exercices sont quelques peu légères voire même absentes, et il n'y a aucun exercice sur l'api JDBC et la manipulation des fichiers XML.


Conclusion : un bon livre d'exercices, mais décevant un peu pour ce qui est des exercices concernant Java 5. En fait, ce livre fait très bien la paire avec le livre Java 6 : Entraînez-vous et maîtrisez Java par la pratique, couvrant Java 5. Mais le fait de devoir acheter les 2 livres fait que cela revient assez cher l'exercice. Je conseillerais alors, pour la somme des 2 livres, d'acheter un autre livre (mais en anglais, malheureusement, Comment Programmez en Java, de chez Deitel et Deitel).


couverture du livre Spring par la pratique

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

Spring par la pratique

de

Résumé de l'éditeur

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

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

ISBN10 : 2212117108 - ISBN13 : 9782212117103

Broché, 19 x 23 cm

Commandez sur www.amazon.fr :

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


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


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


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


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


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

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


couverture du livre Java en concentré

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

Java en concentré

Manuel de référence pour Java

de
Public visé : Débutant

Résumé de l'éditeur

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

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

Édition : O'Reilly - 1418 pages , 5eédition, 1er février 2006

ISBN10 : 284177371X - ISBN13 : 9782841773718

18 x 6 x 24 cm

Commandez sur www.amazon.fr :

51.03 € TTC (prix éditeur 54.00 € TTC)
  • Introduction
    • Qu'est ce que Java ?
    • Les avantages clés de Java ?
    • Un exemple de programme
  • La syntaxe Java
    • Programmes Java dans leur ensemble
    • Types de données primitifs
    • Expressions et opérateurs
    • Instructions
    • Méthodes
    • Introduction aux classes et objets
    • Tableaux
    • Types références
    • Paquetages et espace de désignation en Java
    • Structure des fichiers Java
    • Définir et exécuter des programmes Java
    • Différences entre C et Java
  • La programmation orientée objet en Java
    (list]
  • Syntaxe de la définition des classes
  • Champs et méthodes
  • Création et initialisation d'objets
  • Destruction et finalisation d'objets
  • Sous-classes et héritage
  • Masquage des données et encapsulation
  • Classes et méthodes abstraites
  • Méthodes importantes de java.lang.Object
  • Interfaces
  • Types emboîtés
  • Résumé des modificateurs
  • Caractéristiques de C++ absentes en Java
[*]Nouveautés du langage Java 5.0
  • Types génériques
  • Types énumérés
  • Annotations
[*]La plate-forme Java
  • Vue d'ensemble de la plate-forme Java
  • Texte
  • Nombre de Maths
  • Dates et heures
  • Tableaux
  • Collections
  • Threads et programmation concurrente
  • Fichiers et répertoires
  • Flux d'entrée et de sortie avec java.io
  • Interconnexion de réseaux avec java.net
  • Entrées/sorties et interconnexion de réseaux avec java.nio
  • XML
  • Types, réflexion et chargement dynamique
  • Persistence des objets
  • Sécurité
  • Cryptographie
  • Fonctionnalités diverses
[*]La sécurité en Java
  • Risques liés à la sécurité
  • Sécurité de la machine virtuelle Java et vérification des fichiers de classe
  • Authentification et cryptographie
  • Contrôle d'accès
  • Sécurité pour tout le monde
  • Classes de permissions
[*]Conventions de programmation et de documentation en Java
  • Conventions liées à l'attribution des noms et à la capitalisation
  • Conventions de portabilité
  • Commentaires de documentation en Java
  • Conventions propres aux JavaBeans
[*]Outils de développement Java[*]Guide de référence[/list]
Critique du livre par la rédaction Ricky81 le 1er août 2006
Voila le livre idéal pour découvrir ou redécouvrir la plate-forme Java.
Clair et concis (malgré la taille), il vous servira également de guide de référence lorsque vous aurez le malheur de ne pas pouvoir accéder facilement à des ressources en ligne ou à la Javadoc.
Cette nouvelle édition introduit les nouveautés de Java 5 en se concentrant sur l'essentiel (logique, puisque l'ouvrage anciennement "Java in a Nutshell" s'appelle désormais "Java enconcentré").
Bien entendu, vous ne trouverez pas tous le détail d'une API comme les Generics, mais suffisamment pour ensuite vous débrouiller et fouiller la partie "Guide de référence".
Ce livre en impose, tant par le nombre de pages (dont les 400 premières constituent la matière grise) que par la densité des informations.
Certains passages auraient certes pu être adaptés à Java 5, mais le travail serait considérable et certains passages risqueraient de devenir trop complexes et risqueraient de mettre en arrière plan les concepts illustrés.
Mention spéciale aux traducteurs Anne et Alexandre Gachet qui ont réalisé un travail de grande qualité. On ne leur reprochera pas les quelques coquilles relevées compte tenu du nombre impressionnant de pages.
Bref, vous l'aurez compris, cet ouvrage est plus qu'un livre de chevet, une vraie bible comme on aimerait en voir plus souvent.


couverture du livre Les cahiers du programmeur

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

Les cahiers du programmeur

Java 1.4 et 5.0

de
Public visé : Débutant

Résumé de l'éditeur

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

Édition : Eyrolles - 367 pages , 3eédition, 1er mars 2006

ISBN10 : 221211916X - ISBN13 : 9782212119169

21 x 2 x 24 cm

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 29.00 € TTC)
  • Présentation des études de cas
  • Principes du langage et installation de l'environnement
  • Création de classes
  • Contrôle des traitements avec les opérateurs, boucles et branchements
  • Réutilisation des classes
  • Les classes de base de la bibliothèque Java
  • Abstraction et interface
  • Gestion des erreurs avec les exceptions
  • Lecture et écriture des fichiers
  • Interfaces utilisateur avec Swing
  • Connexion à la base de données avec JDBC
  • Programmation Web avec les servlets, JSP et JavaBeans
  • Interface utilisateur du forum
  • Echanger des informations avec XML
  • Messagerie instantanée avec la programmation multitâche
Critique du livre par la rédaction vbrabant le 1er juin 2006
Cette 3ème édition du cahier des programmeurs Java d'Emmanuel Puybaret est un remaniement total comparé à la 1ère édition :
  • une centaine de pages en plus
  • 1 CD-ROM est maintenant joint avec
  • 2 nouveaux chapitres, couvrant java.io et XML
  • dernier chapitre fortement enrichi d'une partie dédiée à la synchronisation et au multi-threading, superbement bien expliqué
  • rajout d'appartés (notes marginales) à l'intention des développeurs C, C++ et C#
  • rajout d'appartés concernant les principales nouveautés du JDK 5.0


J'avais déjà lu la 1ère édition de ce livre, et la façon dont Emmanuel Puybaret explique les choses ma plue énormément. Les illustrations apportent beaucoup à la compréhension. Le code vous est expliqué, décortiqué. Vous n'avez presque plus l'impression de lire, mais de l'entendre vous parler. Ce livre est captivant. J'ai eu des difficultés à m'en détacher contrairement à d'autres livres, pour lesquels il m'a fallu me faire violence pour les lire jusqu'au bout (Le livre d'Anne Tassot en est un exemple).
Ce livre est AMHA le meilleur de la collection "Cahiers du programmeur", du point de vue approche pédagogique, illustration des propos, … Emmanuel Puybaret a une approche pédagogique qui fait merveille.

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

A conseiller à tous les débutants Java.


couverture du livre Aide-Mémoire de Java

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

Aide-Mémoire de Java

de

Résumé de l'éditeur

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

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

ISBN10 : 2100491458 - ISBN13 : 9782100491452

Commandez sur www.amazon.fr :

15.02 € TTC (prix éditeur 16.00 € TTC)
[ist][*]Avant-propos[*]Java, les bases[*]Les Objets de base[*]Le modèle Objet de Java[*]Les mécanisme de programmation par objets[*]La généricité[*]Le contrôle de l'exécution[*]Les entrées-sorties[*]L'API[*]L'environnement Java[*]Bibliographie[*]Annexe[*]Index[/list]
Critique du livre par la rédaction joseph_p le 1er mai 2007
Un livre indispensable pour tout débutant en Java et souvent nécessaire pour développeur confirmé devant aborder des sujets dont il n'a pas l'habitude.
Ce petit livre couvre succinctement l'essentiel de la programmation Java, avec à la fois les explications sur le fonctionnement fondamental de chaque fonctionnalité et des exemples pertinents.
Bien sûr, si vous voulez aborder un aspect bien spécifique, ce livre ne vous sera pas suffisant, mais il offrira sans doute déjà assez d'informations pour bien débuter. De toutes façons, jamais un livre généraliste sur Java ne donnera jamais assez d'éléments sur un point précis des très vastes bibliothèques disponibles.
Au final : un must have.
Critique du livre par la rédaction vbrabant le 1er mai 2006
Un livre à avoir dans votre poche

Cet aide-mémoire, de petit format, devrait être tout le temps dans votre poche.
Dès les premières pages de cet aide-mémoire, je fus surpris par sa qualité tant du point de vue du texte, que du point de vue des bouts de code Java donnés.
Ainsi, d'entrée de jeu (chapitre 1 et 2), on vous apprend comment afficher la date du jour dans un format donné, la nouvelle boucle ForEach, la classe StringBuilder, la classe Collator (Est-ce que Éléonor précède Fabian ou pas ?), les énumérations (enum).
J'aime également beaucoup la façon dont les auteurs vous expliquent les mécanismes de la programmation par objet, la généricité (nouveauté du JDK 5.0) et le contrôle d'exécution.
Le chapitre 8, dédié aux API Java, aborde les collections, les tables, les URL et Sockets, AWT, Swing et les applets. Cela ne couvre évidemment pas tout ce qu'un livré dédié à Swing pourrait couvrir, bien évidemment, mais vous y avez vraiment l'essentiel (composants, événements, conteneurs et systèmes d'agencement (layout))
Dans le dernier chapitre (le 9), ils y ont même consacré une petite partie sur la sécurité, et l'utilitaire policytool.
J'oubliais également la partie consacrée aux entrées-sorties, ainsi que celle consacrée aux threads.
Quand je vous dis que malgré sa petite taille, il couvre une multitude de choses, je n'exagère pas. Ce n'est pas un ouvrage de référence, qui passe en revue toutes les API du JDK. Mais un excellent aide-mémoire, illustré abondamment d'extraits de code, très bien pensés.

Un excellent rapport qualité/prix


couverture du livre Ant précis & concis

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

Ant précis & concis

de
Public visé : Débutant

Résumé de l'éditeur

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

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

Édition : O'Reilly - 110 pages , 30 juin 2002

ISBN10 : 2841771598 - ISBN13 : 9782841771592

Commandez sur www.amazon.fr :

0.00 € TTC (prix éditeur 0.00 € TTC)
  • Introduction
  • En trois étapes vers le fichier build
  • Éléments de base de Ant
  • Concepts fondamentaux
  • Paramètres de la ligne de commande
  • Propriétés prédéfinies
  • Tâches personnalisées
  • Perspectives : Ant 2
  • Tâches prédéfinies
  • Référence des tâches standard
  • Tâches optionnelles
Critique du livre par l'équipe Java le 30 novembre 2002
Ant est devenu un outil indispensable au développeur Java, quel que soit son domaine de prédilection : J2SE, J2EE, etc. Sa portabilité, sa facilité d'utilisation et son intégration à de nombreux EDI/RAD du marché (grâce à des plugins, voir même par défaut avec NetBeans), en font un outil incontournable. Voici quelques liens grâce auquels vous pourrez en apprendre un peu plus :
Une courte introduction à Ant par l'équipe Java
Forum d'entraide Ant
Autres outils pour le développeur Java
Texte de votre critique
Date de la critique JJ/MM/AAAA
Qui a réalisé cette critique ?

Son pseudo :

Son nom :
Note


couverture du livre Programming in Scala

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

Programming in Scala

A Comprehensive Step-by-Step Guide

de
Public visé : Débutant

Résumé de l'éditeur

Scala is an object-oriented programming language for the Java Virtual Machine. In addition to being object-oriented, Scala is also a functional language, and combines the best approaches to OO and functional programming.

In Italian, Scala means a stairway, or steps—indeed, Scala lets you step up to a programming environment that incorporates some of the best recent thinking in programming language design while also letting you use all your existing Java code.

Artima is very pleased to publish a new edition of the best-selling book on Scala, written by the designer of the language, Martin Odersky. Co-authored by Lex Spoon and Bill Venners, this book takes a step-by-step tutorial approach to teaching you Scala. Starting with the fundamental elements of the language, Programming in Scala introduces functional programming from the practitioner\'s perspective, and describes advanced language features that can make you a better, more productive developer.

Édition : Artima Inc - 852 pages , 2eédition, 13 décembre 2010

ISBN10 : 0981531644 - ISBN13 : 9780981531649

Dimensions : 18,4 x 23,5 cm

Commandez sur www.amazon.fr :

50.87 € TTC (prix éditeur 39.98 € TTC)
  • What Readers are Saying
  • Contents
  • List of Figures
  • List of Tables
  • List of Listings
  • Foreword
  • Foreword to the First Edition
  • Acknowledgments
  • Introduction
  • 1. A Scalable Language
  • 2. First Steps in Scala
  • 3. Next Steps in Scala
  • 4. Classes and Objects
  • 5. Basic Types and Operations
  • 6. Functional Objects
  • 7. Built-in Control Structures
  • 8. Functions and Closures
  • 9. Control Abstraction
  • 10. Composition and Inheritance
  • 11. Scala's Hierarchy
  • 12. Traits
  • 13. Packages and Imports
  • 14. Assertions and Unit Testing
  • 15. Case Classes and Pattern Matching
  • 16. Working with Lists
  • 17. Collections
  • 18. Stateful Objects
  • 19. Type Parameterization
  • 20. Abstract Members
  • 21. Implicit Conversions and Parameters
  • 22. Implementing Lists
  • 23. For Expressions Revisited
  • 24. The Scala Collections API
  • 25. The Architecture of Scala Collections
  • 26. Extractors
  • 27. Annotations
  • 28. Working with XML
  • 29. Modular Programming Using Objects
  • 30. Object Equality
  • 31. Combining Scala and Java
  • 32. Actors and Concurrency
  • 33. Combinator Parsing
  • 34. GUI Programming
  • 35. The SCells Spreadsheet
  • A. Scala scripts on Unix and Windows
  • Glossary
  • Bibliography
  • About the Authors
  • Index
Critique du livre par la rédaction Philippe BASTIANI le 24 août 2013
Scala est un langage qui associe les principes de la programmation fonctionnelle à la programmation orientée objet.

Le langage Scala est conçu pour s'intégrer facilement à une machine virtuelle telle que la machine virtuelle Java. Scala peut ainsi être utilisé conjointement avec le langage Java dans le développement applicatif.

Il y a quelques mois, j'ai voulu m'initier en douceur à la programmation fonctionnelle… Je me suis donc tout naturellement arrêté sur le livre Programming in Scala qui a l'avantage d'être coécrit par le créateur du langage.

Dans ce livre les auteurs ont pour objectif de nous guider pas à pas dans la découverte du langage Scala ! Voyons ce qu'il en est réellement…

Le livre s'articule autour de 35 chapitres répartis sur 850 pages pour sa version papier et 880 pages pour sa version électronique !

La version électronique est parfaitement adaptée à la lecture sur écran. Seul bémol : de nombreuses illustrations ne sont pas en phase avec le texte !

Notez aussi que cette réédition s'appuie sur la version 2.8 du compilateur Scala.

Tout au long du livre, les auteurs nous distillent les bonnes pratiques de programmation : le livre n'est ni catalogue de l'API Scala, ni un catalogue de design patterns ! Bien au contraire, la lecture reste fluide; et, l'apprentissage du langage se fait en douceur.

L'ensemble des spécificités de Scala relatives à la programmation fonctionnelle y est décrit : l'immutabilité, les monades, les fonctions d'ordre supérieur, les closures, les fonctions partielles sont bien sûr abordées en détail… Aussi académiques que puissent être ces notions, elles sont présentées, ici, sans démonstration mathématique.

La programmation orientée objet n'est pas oubliée : les classes, les objets, l'héritage, etc. ! Pour ces notions, les auteurs nous montrent les spécificités du langage Scala en les comparant à l'implémentation Java.

Une grande partie du livre est consacrée aux collections : trop peut-être ! Mais cela a l'avantage de ramener le lecteur vers des notions plus concrètes.

Chaque chapitre peut être vu comme un tutoriel à part entière :

  • les auteurs introduisent les notions qui vont être abordées ;
  • le corps du tutoriel est accompagné d'un ou plusieurs exemples ;
  • tous les exemples sont expliqués instruction par instruction ;
  • la conclusion reprend les points essentiels à assimiler.


Bref, une architecture efficace. Et, pour ne rien gâcher, le style est agréable.

L'écriture d'un tableur graphique en 200 lignes est ce que propose Martin Odersky en guise de conclusion : le code proposé est concis tout en restant lisible ; et, nous invite à continuer l'aventure Scala. Dommage que Martin Odersky n'ait pas pris le soin de mettre à jour son code avec la version 2.8.x de Scala… La classe SimpleGUIApplication est en effet dépréciée !

Concrètement, de bout à bout, il m'a fallu deux mois de lecture :

  • les exemples proposés sont nombreux, mais souvent trop académiques,
  • l'organisation des chapitres est parfois déroutante : à mi-chemin, les tests unitaires sont abordés… mais pourquoi diantre, avoir positionné ce chapitre ici, alors que le lecteur n'a pas encore assimilé les bases du développement en Scala ?


Bref, il m'a manqué un fil d'Ariane entre les exemples et les chapitres. Et, à la sortie de cette lecture, certes enrichissante, je n'ai pas eu l'impression d'être très opérationnel !

Nous en sommes à la version 2.10 du langage Scala, pour autant, Programming in Scala reste une référence pour qui veut s'initier à Scala. Suite à sa lecture, le lecteur pourra trouver des ressources en ligne concernant :

  • les nouvelles fonctionnalités du langage telles que les collections parallèles, les Futures/Promises ;
  • l'intégration des composants tels que Akka (futur standard pour les acteurs) de TypeSafe.


Dans l'ensemble, j'ai trouvé le livre intéressant et agréable à lire, mais je ne vous conseillerais pas celui-ci si vous avez besoin d'apprendre Scala rapidement.

Préférez-lui, en première lecture, « Scala in action » ou « Scala for the Impatient » pour une acquisition rapide du b.a.-ba du langage Scala.

Notez bien : Martin Odersky dispense également la formation Functional Programming Principles in Scala ! Une formation en ligne qui est de l'avis de tous très enrichissante.




 Poster une réponse

Avatar de Philippe Bastiani Philippe Bastiani - Membre éprouvé https://www.developpez.com
le 25/08/2013 à 18:10
Bonjour,

La rédaction de Développez me permet de partager avec vous mes notes de lecture concernant l'ouvrage Programming in Scala: A Comprehensive Step-by-Step Guide.

Cet ouvrage s'adresse aux ingénieurs logiciels, développeurs, architectes et chefs de projet qui souhaitent découvrir la programmation en Scala !
Une expérience en programmation fonctionnelle n'est pas requise pour aborder la lecture de ce livre.

Cette 2ème édition de Programming in Scala s'appuie sur la version 2.8 du langage (i.e. datant de Juillet 2010); mais, reste une référence pour qui veut s'initier à Scala.

Pensez-vous que cet ouvrage est l'outil idéal pour aborder la programmation en Scala ?
Avatar de BHericher BHericher - Membre à l'essai https://www.developpez.com
le 26/08/2013 à 11:01
A mon avis, c'est un des meilleurs livres pour aborder Scala. Il laisse le lecteur entièrement libre de pratiquer une programmation purement fonctionnelle ou orientée objet ou de pratiquer un mixte des deux. De plus, c'est un vrai manuel de référence très complet.
La version de Scala utilisée (2.8) est effectivement un peu ancienne, mais le livre reste quand même d'actualité. Des rumeurs récurrentes évoquent une troisième édition, mais, à ma connaissance, les auteurs n'ont rien annoncé.

Benoît
Avatar de Yoteco Yoteco - Rédacteur https://www.developpez.com
le 29/08/2013 à 16:13
Pour moi ce livre est de loin le meilleur livre de programmation que j'ai lu !

Ce qui m'a le plus plu, c'est qu'on comprend vraiment tous les choix que Martin Odersky a fait lorsqu'il a développé Scala. Plus on avance dans le livre et plus on comprend la façon dont Scala a été construit.

De plus on peut lire le livre comme un roman, car toutes les exécutions sont développées.

Bref un super livre !
couverture du livre Java 8 Lambdas

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

Java 8 Lambdas

Functional Programming for the Masses

de
Public visé : Débutant

Résumé de l'éditeur



If you’re a developer with core Java SE skills, this hands-on book takes you through the language changes in Java 8 triggered by the addition of lambda expressions. You’ll learn through code examples, exercises, and fluid explanations how these anonymous functions will help you write simple, clean, library-level code that solves business problems.

Lambda expressions are a fairly simple change to Java, and the first part of the book shows you how to use them properly. Later chapters show you how lambda functions help you improve performance with parallelism, write simpler concurrent code, and model your domain more accurately, including building better DSLs.

Use exercises in each chapter to help you master lambda expressions in Java 8 quickly
Explore streams, advanced collections, and other Java 8 library improvements
Leverage multicore CPUs and improve performance with data parallelism
Use techniques to “lambdify” your existing codebase or library code
Learn practical solutions for lambda expression unit testing and debugging
Implement SOLID principles of object-oriented programming with lambdas
Write concurrent applications that efficiently perform message passing and non-blocking I/O

Édition : O'Reilly Media - 182 pages , 1re édition, 28 mars 2014

ISBN10 : 1449370772 - ISBN13 : 9781449370770

Commandez sur www.amazon.fr :

22.84 $ TTC (prix éditeur 29.99 $ TTC) livraison gratuite !
1. Introduction
2. Lambda Expressions
3. Streams
4. Libraries
5. Advanced Collections and Collectors
6. Data Parallelism
7. Testing, Debugging, and Refactoring
8. Design and Architectural Principles
9. Lambda-Enabled Concurrency
10. Moving Forward

Critique du livre par la rédaction plawyx le 12 avril 2014
JDK 8 est sorti depuis moins d'un mois avec son lot d'innovations et d'améliorations. Parmi l'une des plus attendues, le support des lambdas par Java.

Le but de ce livre est d'être une introduction pratique aux lambdas et interfaces fonctionnelles. Les trois chapitres suivants montrent progressivement l'impact des lambdas sur l'utilisation du framework Collection via l'API Stream. Un vrai chamboulement dans l'écriture des traitements de données.

Le livre se termine par une présentation des effets des lambdas sur la conception des programmes (pattern...) et de l'utilisation des lambdas dans la concurrence.

Un bon livre pour découvrir simplement et rapidement les lambdas sous Java et leurs conséquences sur la programmation, en particulier, sur le traitement des collections.

Un petit regret. A mon sens, il manque une présentation exhaustive des méthodes de création d'un Stream. Idem pour la présentation des opérations sur les Stream qui se contente des traitements de base et qui aurait mérité d'être un peu plus étoffée. Cela invite à d'autres lectures...




 Poster une réponse

Avatar de christ_mallet christ_mallet - Futur Membre du Club https://www.developpez.com
le 16/05/2002 à 16:41
Quelle est la différence réelle entre un "bidouilleur" et son contraire, c'est à dire un pro.
J'entends souvent traiter négativement les développeurs de bidouilleurs alors que le travail réalisé est souvent remarquable.
Avatar de Karuto Karuto - Membre du Club https://www.developpez.com
le 16/05/2002 à 16:56
lol pour moi un bidouilleur c un mek ki se rue sur son pc pour coder les truks ki lui passent par la tête alors qu'un pro c'est un mek ki developpe apres avoir fait une etude de besoins, une etude fonctionnelle et qui ne passe au codage qu'une fois l'architecture de son travail bien etablie.

bon serieusement du haut de ma toute petite experience d'etudiant et de stagiaire j'ai du dévellopper une bonne vingtaine de projet et meme en entreprise je suis jamais tombé dans un projet ou vraiment tout etait carré et tout défini a l'avance. bien sur en entreprise c plus strict et plus protocolaire mais l'esprit reste un peu celui de la bidouille

(sauf si tu te retrouves dans un dévelloppement long et deja bien entamé ou la tache est deja définie et ou il ne erste plus k'a finaliser
Avatar de Geronimo Geronimo - Membre chevronné https://www.developpez.com
le 16/05/2002 à 17:12
D'après moi,

La bidouille c'est aussi : tu tapes 3 lignes, tu compiles, tu regardes si ça marche, tu regardes ce qui manque, tu le rajoutes après...

Un pro écrit une bonne partie de son code bien proprement, le commente au fur et à mesure et enfin compile.
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -