Les livres sur les frameworks Web Java MVC

11 livres et 12 critiques, dernière mise à jour le 21 juin 2019 , note moyenne : 4.6

  1. Apache Struts 2 - Web Application Development
  2. Struts 2 - Le framework de développement d'applications Java EE
  3. Spring par l'exemple
  4. Spring par la pratique - Spring 2.5 et 3.0
  5. Struts 2 in Action - Donald Brown, Chad Michael Davis, Scott Stanlick
  6. Spring Recipes: A Problem-Solution Approach
  7. Pro Spring 2.5
  8. Professional Java Development with the Spring Framework
  9. Développement Java sous STRUTS : Version 1.2
  10. Struts - Les bonnes pratiques pour des développements web réussis
  11. Jakarta Struts - par la pratique
couverture du livre Apache Struts 2

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

Apache Struts 2

Web Application Development

de
Public visé : Débutant

Résumé de l'éditeur

Struts 2.1 is a modern, extensible, agile web application framework suitable for both small- and large-scale web applications.

The book begins with a comprehensive look at Struts 2.1 basics, interspersed with detours into more advanced development topics. You'll learn about configuring Struts 2.1 actions, results, and interceptors via both XML and Java annotations. You'll get an introduction to most of the Struts 2.1 custom tags and learn how they can assist in rapid application prototyping and development.

From there you'll make your way into Struts 2.1's strong support for form validation and type conversion, which allows you to treat your form values as domain objects without cluttering your code. A look at Struts 2.1's interceptors is the final piece of the Struts 2.1 puzzle, allowing you to leverage the standard Struts 2 interceptors as well as implement your own custom behavior.

After covering Struts 2.1 you'll journey into the world of JavaScript, a surprisingly capable language, the Document Object Model (DOM), and CSS, and learn how to create clean and concise client-side behavior. You'll leverage that knowledge as you move on to Struts 2 themes and templates, which give you a powerful way to encapsulate site-wide user interface behavior.

The book closes with a look at some tools that make the application development life cycle easier to manage, particularly in a team environment, and more automatic.

Édition : PackT Publishing - 360 pages , 1re édition, 1er juin 2009

ISBN10 : 1847193390 - ISBN13 : 9781847193391

Commandez sur www.amazon.fr :

24.29 € TTC (prix éditeur 25.76 € TTC) livraison gratuite !
[list][*]Chapter 1: Struts and Agile Development[*]Chapter 2: Basic Configuration[*]Chapter 3: Actions and ActionSupport[*]Chapter 4: Results and Result Types[*]Chapter 5: OGNL, the Value Stack, and Custom Tags[*]Chapter 6: Form Tags[*]Chapter 7: Form Validation and Type Conversion[*]Chapter 8: Interceptors[*]Chapter 9: Exceptions and Logging[*]Chapter 10: Getting Started with JavaScript[*]Chapter 11: Advanced JavaScript, the DOM, and CSS[*]Chapter 12: Themes and Templates[*]Chapter 13: Rich Internet Applications[*]Chapter 14: Comprehensive Testing[*]Chapter 15: Documenting our Application
[list]
Critique du livre par la rédaction longbeach le 1er juin 2010
Ce livre est composé de 15 chapitres. On peut considérer que les 9 premiers chapitres (205 pages) présentent les nouveautés de Struts 2 et le reste du livre est un mélange d'apprentissage de JavaScript/Ajax et de bonnes pratiques pour documenter et tester une application web.
Il repose sur la version 2.1.6 de Struts.
Les exemples du livre sont téléchargeables à l'adresse : http://www.packtpub.com/sites/defaul.../3391_Code.zip

Chapitre 1 :
Le chapitre 1 est une première introduction à Struts 2 avec une liste des principales nouveautés. Le lecteur est également introduit aux pratiques agiles .

Chapitre 2 :
Ce chapitre continue sur les nouveautés de Struts 2. L'auteur commence à développer l'application RecipeBox, un site d'échanges de recettes de cuisine, en suivant les pratiques agiles avec des user stories.
Les plug-ins Configuration Browser et Convention sont utilisés.

Chapitre 3 :
Ce chapitre fait le tour de la classe ActionSupport (validation, internationalisation ...). L'auteur fournit également des conseils pour le développement avec l'utilisation de Cygwin et d'Eclipse.

Chapitre 4 :
Ce chapitre se concentre sur les Results qui sont les retours des actions. Différents types de Results sont examinés, notamment FreeMarker. Le plug-in Convention est largement utilisé dans les exemples (annotations @Result, @Action ...).

Chapitre 5 :
Dans ce chapitre, l'auteur examine OGNL, la value stack et plusieurs tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). Ces tags génériques sont richement expliqués, même ceux qui ne sont pas fréquemment utilisés.

Chapitre 6 :
Ce chapitre examine les tags UI qui font partie du formulaire. Chaque tag UI (<s:form>, <s:textfield>, <s:checkbox>, ...) est bien expliqué, avec des exemples. L'auteur apporte une petite introduction aux thèmes et templates (ils sont abordés en détails dans le chapitre 12). Il apporte également des explications pour l'upload de fichiers et le traitement des soumissions en double (tag <s:token>).

Chapitre 7 :
Ce chapitre fait le tour de la validation et de la conversion des données. Les différentes méthodes de validation sont abordées (fichier XML, validation manuelle, annotations), que ce soit côté serveur ou côté client (JavaScript). J'ai trouvé les explications suffisantes et les remarques pertinentes.

Chapitre 8 :
Ce chapitre présente les intercepteurs, examine ceux disponible dans la pile par défaut et décrit comment écrire ses propres intercepteurs à partir d'un exemple (interceptor trim) bien fourni en explications (tant dans le code que dans la configuration).

Chapitre 9 :
Les différentes techniques de gestion des exceptions et la gestion des logs sont examinées dans ce chapitre. L'auteur explique la configuration des logs avec Log4J.

Chapitre 10 :
Dans ce chapitre entièrement consacré à JavaScript, l'auteur explique la syntaxe de ce langage très utilisé dans la construction d'applications Web.

Chapitre 11 :
Ce chapitre aborde encore JavaScript mais aussi CSS et la librairie jQuery. J'ai bien aimé l'exemple donné à la fin du chapitre pour l'ajout d'une ligne, de façon dynamique, dans un formulaire, ce qui est un besoin courant.

Chapitre 12 :
Lors de mes précédentes recherches, j'avais trouvé peu d'informations sur la création de thèmes. C'est pourquoi je trouve que ce court chapitre, consacré aux thèmes et aux templates, fournit une aide précieuse.

Chapitre 13 :
Ce chapitre présente la librairie JavaScript Dojo et jette un regard sur les tags Dojo dans Struts 2 pour faire de l'AJAX. Le plug-in REST est également présenté, avec ses différents types de réponse (JSON, XML, XHTML).

Chapitre 14 :
Ce chapitre est dédié aux tests et examine le développement dirigé par les tests. Pour cela les frameworks JUnit et TestNG sont utilisés. L'injection de dépendance est également expliquée et utilisée pour les tests. L'auteur en profite alors pour introduire le plug-in Spring pour Struts 2.
Enfin d'autres formes de tests sont présentées : les tests fonctionnels à l'aide de Selenium, les tests de montée en charge avec JMeter.

Chapitre 15 :
Ce chapitre s'écarte un peu du sujet principal du livre (Struts 2) pour aborder la documentation dans un projet. C'est donc l'occasion pour l'auteur de présenter l'AOP, l'outil Javadoc, la modélisation UML, la gestion des sources ...

Ce que j'ai aimé :
Les références données à la fin de chaque chapitre. Ce sont des liens qui permettent d'approfondir des notions.

Ce que j'ai moins aimé :
Je n'ai pas vraiment de critique négative à faire sur le contenu de ce livre, je pense en effet qu'il représente un bel effort pour présenter les nouveautés de Struts 2 et donc faciliter l'apprentissage de la nouvelle version de ce framework auquel on a souvent reproché son manque de documentation.

English version :

This book is made of 15 chapters. One might consider that the first nine chapters (205 pages) explain what's new with Struts 2 and that the rest of the book is a mix of JavaScript/Ajax learning and good practices to document and test a web application.
It is based on the 2.1.6 version of Struts.
The book samples can be downloaded at the following address : http://www.packtpub.com/sites/defaul.../3391_Code.zip

Chapter 1 :
This chapter 1 is a first introduction to Struts 2 with a list of the main new features. The reader is also introduced to the Agile method.

Chapter 2 :
This chapter is still about the new features in Struts 2. The author begins the development of a RecipeBox application, a recipe swapping website, following the Agile method with user stories.
The Configuration Browser and Convention plug-ins are used.

Chapter 3 :
This chapter is about the ActionSupport class (validation, internationalization ...). The author also provides tips for development with the use of Cygwin and Eclipse.

Chapter 4 :
This chapter focuses on Results which are the actions' responses. Different Result types are examined, in particular FreeMarker. The Convention plug-in is widely used in the samples (annotations @Result, @Action ...).

Chapter 5 :
In this chapter, the autheur examines OGNL, the value stach and several tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). These generic tags are richly explained, even those that are not frequently used.

Chapter 6 :
This chapter examines the UI tags that are part of the "form". Each UI tag(<s:form>, <s:textfield>, <s:checkbox>, ...) is well explained, with samples. The author gives a small introduction to themes and templates (they are detailed in chapter 12). He also gives explanations to upload files and to handle double submits (<s:token> tag).

Chapter 7 :
This chapter looks at the validation and the conversion of data. The different methods of validation are explained (XML file, manual validation, annotations), whether it is server-side or client-side (JavaScript). I found the explanations sufficient and the remarks pertinent.

Chapter 8 :
This chapter is about interceptors and examines those that are available in the default stack. It explains how to write your own interceptors with a sample (trim interceptor) that i found well documented with code and configuration explanations.

Chapter 9 :
The different mecanisms to handle exceptions and logs are examined in this chapter. The author explains the logs configuration with Log4J.

Chapter 10 :
In this chapter entirely dedicated to JavaScript, the author explains the syntax of this widely used language for the development of Web applications.

Chapter 11 :
This chapter is still about JavaScript but also CSS and the jQuery library. I liked the example, at the end of the chapter, to add a line, in a dynamic way, in a form and which is a frequent requirement.

Chapter 12 :
During my previous researches, I found very little information for the creation of themes. That is why I think this short chapter, dedicated to themes and templates, provides a precious help.

Chapter 13 :
This chapter describes the Dojo JavaScript library and takes a look at the Dojo tags in Struts 2 to create Ajax applications. The REST plug-in is also introduced, with its different return types (JSON, XML, XHTML).

Chapter 14 :
This chapter is dedicated to tests and examines test-driven development. For this purpose the JUnit and TestNG frameworks are used. Dependency injection is also explained and used in tests. The author takes this opportunity to introduce the Spring plug-in for Struts 2. Finally, other forms of testing are introduced : functional testing with the help of Selenium, load testing with JMeter.

Chapter 15 :
This chapter diverges a bit from the main topic of the book (Struts 2) to look at ways to document a project. It is then an opportunity for the author to introduce AOP, the Javadoc tool, UML modeling, source code control systems ...

What I liked the most :
The references that are given at the end of each chapter. They are links for the reader to check if he wants to take a deeper look into topics of the current chapter.

What I liked the least :
I do not really have any negative critic to make on the content of the book. I think it represents a real nice effort to explain the new features of Struts 2 and that it will help developers who want to learn the framework in this latest version, which has often been criticized for its lack of documentation.




 Poster une réponse Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 28/06/2010 à 8:15
Bonjour à tous,

un livre sympa sur Struts 2 existe, il s'appelle Apache Struts 2 - Web Application Development.

Je l'ai lu et ma critique, plutôt positive, est disponible à cette adresse :

http://javaweb.developpez.com/livres/?page=Anglais#L9781847193391

Bonne lecture.

 
couverture du livre Struts 2

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

Struts 2

Le framework de développement d'applications Java EE

de
Public visé : Débutant

Résumé de l'éditeur

Ce livre sur Struts 2 s'adresse aux développeurs Java qui souhaitent disposer d'un ouvrage de référence, pour mettre en application le framework Java EE le plus répandu. L'ouvrage est décomposé en vingt-trois chapitres qui expliquent le fonctionnement du framewok, sa mise en place, chaque couche du modèle de conception MVC, l'utilisation des formulaires en passant par les plug-ins et le développement de résultats sans oublier la notion d'intercepteurs. Chaque concept est abordé de façon théorique et technique afin de permettre aux concepteurs disposant de connaissances en Java EE d'utiliser une API facilitant les développements d'applications web. Les applications utilisées dans les chapitres sont issus d'exemples concrets et sont téléchargeables sur le site de l'éditeur et sur la plate-forme de l'auteur www.gdawj.com.

Édition : ENI - 450 pages , 1re édition, 7 septembre 2009

ISBN10 : 2746050544 - ISBN13 : 9782746050549

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Présentation
  • Modèle de conception MVC et Java EE
  • Commencer avec Struts 2
  • Gestion des traces et débogage
  • Gestion des actions
  • Bibliothèque de tag Struts
  • Messages et internationalisation
  • Validation des entrées
  • Gestion des types et conversions
  • Couche modèle et accès aux données
  • Gestion de l'upload ou chargement de données
  • Gestion du téléchargement de données
  • Gestion du téléchargement de données
  • Gestion des chargements de pages
  • Développer des intercepteurs
  • Développer des résultats
  • Gérer le double clic ou double envoi
  • Struts et Ajax JQuery
  • Les moteurs de templates
  • XSLT
  • Plug-ins Struts
  • Struts sans configuration
  • Annexe
Critique du livre par la rédaction X-plode le 1er septembre 2009
Comme le nom de l'ouvrage l'indique, Jérôme Lafosse nous livre au travers de plus de 400 pages, toutes les notions à connaître pour développer avec la nouvelle évolution du framework web Java Struts.

Dès les premières pages, nous avons un descriptif succinct des notions essentielles et de l'architecture MVC I et MVC II.
Cette attention particulière pour toute personne novice en la matière, lui permettrait de comprendre les explications données par la suite et pouvoir ainsi dès la fin du livre, développer ses propres applications web.

Les chapitres suivants détaillent chaque partie du framework allant du filtre à l'ajout et l'utilisation de plug-ins complémentaire à/ou déjà intégré dans le framework.

Enfin, Jérôme Lafosse conclut par une annexe recensant les différents intercepteurs.

Un apprentissage par l'exemple continu qui nous permet de voir l'évolution d'un code avec les différents acquis reçus au cours du chapitre, et qui démontre la valeur ajoutée de chaque partie tant sur le code que dans les exemples via les copies d'écran des résultats. Des explications claires et détaillées, qui nous permettent d'avoir deux utilisations du livre. La première serait pour l'apprentissage du langage et la seconde comme livre de référence pour le développement d'applications.
Il est très complet et couvre toutes les notions pour développer une application professionnelle en Struts 2 avec différentes librairies complémentaire comme JQuery pour l'utilisation d'Ajax, Velocity en tant que générateur de template ...

Enfin, la police et la mise en page permettent une lecture aisée et fluide.

Les points négatifs que je pourrais apporter sont : Au niveau de l'édition, nous avons un caractère récurrent (qui est <+>) qui pourrait dérouter les plus novices.
Enfin, on aurait apprécié un surlignage des modifications ou des lignes du code qui étaient rajoutées dans les exemples suivant l'explication.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 01/07/2009 à 23:40
[ame="http://www.amazon.fr/Struts-framework-d%C3%A9veloppement-dapplications-Java/dp/2746050544/wwwdeveloppec-21"]Struts 2 - Le framework de d&eacute;veloppement d&#39;applications Java EE: Amazon.fr: J&eacute;r&ocirc;me LAFOSSE: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/51cygy8ssnL.@@AMEPARAM@@51cygy8ssnL[/ame]

22/09/2009

Sorti il y a quelques semaines, nous vous proposons un premier retour sur l'ouvrage.

21/07/2009

En avant-première, l'auteur vous offre un extrait gratuit de l'ouvrage.
Il s'agit du chapitre introductif du livre, chapitre intitulé "Présentation".

http://jlafosse.developpez.com/livre.../presentation/

L'ouvrage sortira aux éditions ENI en septembre et sera également disponible à la commande en format numérique (lequel sera offert pour l'achat du format papier).
Pour en savoir plus

01/07/2009

Bonsoir,

Ce livre sur Struts 2 s'adresse aux développeurs Java qui souhaitent disposer d'un ouvrage de référence, pour mettre en application le framework Java EE le plus répandu. L'ouvrage est décomposé en vingt-trois chapitres qui expliquent le fonctionnement du framework, sa mise en place, chaque couche du modèle de conception MVC, l'utilisation des formulaires en passant par les plug-ins et le développement de résultats sans oublier la notion d'intercepteurs. Chaque concept est abordé de façon théorique et technique afin de permettre aux concepteurs disposant de connaissances en Java EE d'utiliser une API facilitant les développements d'applications web. Les applications utilisées dans les chapitres sont issus d'exemples concrets et sont téléchargeables sur le site de l'éditeur et sur la plate-forme de l'auteur www.gdawj.com.
Table des matières :

Chapitre 1 : Présentation
Chapitre 2 : Modèle de conception MVC et Java EE
Chapitre 3 : Commencer avec Struts 2
Chapitre 4 : Gestion des traces et débogage
Chapitre 5 : Gestion des actions
Chapitre 6 : Bibliothèques de tags Struts
Chapitre 7 : Messages et internationalisation
Chapitre 8 : Validation des entrées
Chapitre 9 : Gestion des types et conversion
Chapitre 10 : Couche modèle et accès aux données
Chapitre 11 : Gestion de l'upload ou chargement des données
Chapitre 12 : Gestion du download ou téléchargement de données
Chapitre 13 : Gestion des chargements de pages
Chapitre 14 : Développer des intercepteurs
Chapitre 15 : Développer des résultats
Chapitre 16 : Gérer le double-clic ou double envoi
Chapitre 17 : Struts et Ajax JQuery
Chapitre 18 : Les moteurs de templates
Chapitre 19 : XSLT
Chapitre 20 : Plug-ins Struts
Chapitre 21 : Struts sans configuration
Chapitre 22 : Annexes
Qu'en pensez vous ? Certains vont-ils l'acheter ?

Voir aussi :
Mise à disposition gratuite du projet BetaBoutique Struts 2, par Jérôme Lafosse
[Livre] Extraits gratuits de "Java EE - Guide de développement d'applications web en Java" par Jérôme Lafosse !
Commandez chez ENI
Avatar de Bakann Bakann - Nouveau membre du Club https://www.developpez.com
le 02/07/2009 à 11:10
Il n'y a pas de sommaire consultable?
Avatar de ruscov ruscov - Membre confirmé https://www.developpez.com
le 02/07/2009 à 11:25
Pour ma part cela fait +-2 ans que je travaille avec Struts 2 et leur site m'a amplement suffit pour démarrer.
De plus il y a déjà pas mal de bouquin qui traite du sujet.
Le seul avantage que j'y vois c'est pour ceux qui sont nuls en anglais.
Mais c'est mon avis perso.
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 Signaler un problème

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 Spring par la pratique

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

Spring par la pratique

Spring 2.5 et 3.0

de

Résumé de l'éditeur

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

Cette seconde édition présente en détail les nouveautés majeures des versions 2.5 et 3.0 de Spring et de ses modules annexes : modèle de programmation basé sur les annotations, Spring Dynamic Modules for OSGi, Spring Batch, Spring Security, SpringSource dm Server, etc. L'accent est mis tout particulièrement sur les bonnes pratiques de conception et de développement, qui sont illustrées à travers une étude de cas détaillée, le projet Open Source Tudu Lists.

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

ISBN10 : 221212421X - ISBN13 : 9782212124217

Broché

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Avant-propos
  • Introduction à Spring
  • Partie 1 : Les fondations de Spring
    • Le conteneur léger de Spring
    • Concepts avancés du conteneur Spring
    • Les concepts de la POA
    • Spring AOP
    • Test des applications Spring
  • Partie 2 : Les frameworks de présentation
    • Spring MVC
    • Spring WebFlow
    • Utilisation d'Ajax avec Spring
  • Partie 3 : Gestion des données
    • Persistance des données
    • Gestion des transactions
    • Support des technologies JMS et JCA
  • Partie 4 : Technologies d'intégration
    • Spring Web Services
    • Spring Security
    • Spring Batch
  • Partie 5 : Spring en production
    • Spring Dynamic Modules
    • Spring DM Server
    • Supervision avec JMX
Critique du livre par la rédaction Eric REBOISSON le 1er janvier 2010
N'ayant pas eu la chance de critiquer la première édition de "Spring par la pratique", c'est avec joie et grand intérêt que j'ai accueilli le facteur m'apportant cette seconde édition. Pour la petite histoire, j'ai suivi la formation Spring Core en 2008, dispensée par Julien Dubois, co-auteur sur cet ouvrage et j'ai eu comme compère de formation Gildas Cuisinier, relecteur de ce second opus, 4 jours aussi intéressants que ce présent ouvrage.
Le livre commence donc par la pédagogie nécessaire autour des concepts Spring (conteneur léger, inversion de contrôle (IOC), injection de dépendance, AOP (Aspect Oriented Programmation, POA en français pour programmation orientée aspect)) puis la suite est un savant mélange de théorie permettant au lecteur de comprendre correctement les concepts de Spring (et pourquoi ceux-ci existent) et de pratique via la mise en ouvre de cas concrets extraits de l'application fil rouge Tudu List.
On appréciera au fil des chapitres suivants l'exhaustivité de la couverture du portofolio Spring : Spring AOP, Spring Batch, Spring MVC, Spring Web Flow… Il appartient ensuite au lecteur d'utiliser ce qui lui paraîtra nécessaire dans ses applications. A noter qu'il faut un minimum de connaissances sur les frameworks et concepts (où du moins en connaître les principes majeurs) auxquels s'adresse Spring (Hibernate, GWT, JMS, Webservices…) même ci ceux-ci sont très bien introduits dans le livre, ne serait-ce que pour comprendre ce qu'apporte Spring couplé à ces éléments.
Mon avis sur "Spring par la pratique" :

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


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


Nous avons donc là un excellent ouvrage en français sur Spring, clair et détaillé, pédagogique et très complet que je conseille aux curieux désireux de connaître Spring mais aussi aux confirmés qui trouveront dans ce livre les nouveautés du portofolio Spring.
Critique du livre par la rédaction Hikage le 1er juin 2009
Spring par la pratique, première édition, fut un excellent livre sur Spring et son portfolio. A sa sortie, il couvrait directement Spring 2.0, fraichement sorti à l'époque. Mais l'eau a coulé sous les ponts et le livre est devenu un peu désuet de par les nouveautés de Spring 2.5 et 3.0 ou encore l'arrivée de projet tels que Spring Dm ou Spring Batch.. C'est là qu'intervient la nouvelle édition, couvrant justement ceux-ci, alors que Spring 3.0 n'est pas encore officiellement sorti.
Sur la forme, le livre garde le même style que l'ancienne édition, chaque chapitre étant divisé en deux parties. La première étant une présentation théorique d'un sujet, la deuxième étant sa mise en pratique dans un exemple concret ( le même qu'auparavant : Tudu List ). Concernant le contenu par contre, les changements sont majeurs, allant de grosse mises à jour à de nouveaux chapitres complets.

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

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

Une autre nouveauté est le nouveau site (http://www.springparlapratique.org) qui accompagne le livre qui permet de discuter avec les auteurs ou récupérer le code source.
Je conseille donc vivement la lecture de ce livre, aussi bien au débutant voulant apprendre à utiliser Spring en se basant sur la dernière version qu'a des personnes souhaitant simplement se mettre à jour et découvrir les nouveautés du portfolio. Le contenu est des plus complet et très bien expliqué !




 Poster une réponse Signaler un problème

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

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


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

23/06/2009

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

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

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

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

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

Quelques informations :

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

Critique du livre, en avant première

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

Cheers,
IRNBRU
Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 11/08/2009 à 11:18
En même temps, il y a une application complète diposnible sur
http://www.springparlapratique.org
couverture du livre Struts 2 in Action

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

Struts 2 in Action

Donald Brown, Chad Michael Davis, Scott Stanlick

de
Public visé : Débutant

Édition : Manning - 401 pages , 1re édition, 1er janvier 2008

ISBN10 : 193398807x - ISBN13 : 9781933988078

Commandez sur www.amazon.fr :

32.26 € TTC (prix éditeur 44.99 € TTC) livraison gratuite !
Part 1 Struts 2: a brand new framework
  • 1 Struts 2: the modern web application framework
  • 2 Saying hello to Struts 2

Part 2 Core concepts: actions, interceptors, and type conversion
  • 3 Working with Struts 2 actions
  • 4 Adding workflow with interceptors
  • 5 Data transfer: OGNL and type conversion

Part 3 Building the view: tags and results
  • 6 Building a view: tags
  • 7 UI component tags
  • 8 Results in detail

Part 4 Improving your application
  • 9 Integrating with Spring and Hibernate/JPA
  • 10 Exploring the validation framework
  • 11 Understanding internationalization

Part 5 Advanced topics and best practices
  • 12 Extending Struts 2 with plug-ins
  • 13 Best practices
  • 14 Migration from Struts Classic
  • 15 Advanced topics
Critique du livre par la rédaction longbeach le 1er avril 2009
Le livre est divisé en 5 parties.

Dans la 1ère partie les auteurs apportent une présentation sommaire de l'architecture du framework Sruts 2 (MVC pattern, interceptors, ValueStack, OGNL) et abordent un exemple Hello World. Les 2 types de configuration sont détaillés: configuration via des fichiers XML (struts.xml) et configuration par des annotations Java.

Dans la 2ème partie les auteurs couvrent l'action dans Struts 2, de façon relativement bien détaillée et bien expliquée. Ensuite un chapitre traite des interceptors : le principe, la déclaration, les avantages, les interceptors existants et comment créer un interceptor si aucun des interceptors existants ne répond aux besoins. Le langage OGNL, qui permet d'utiliser les objets stockés dans la pile (ValueStack) est abordé pour la première fois dans le livre.

La 3ème partie traite des différents tags. J'ai bien aimé d'abord le découpage rationnel des paragraphes et chapitres suivant les 4 catégories de tags : data tags, control-flow tags, UI tags et autres tags. Ensuite j'ai bien aimé la présentation de chaque tag: d'abord une explication, ensuite un petit tableau décrivant les attributs, types, (...), du tag et enfin un petit extrait de code pour montrer une utilisation concrète. Les auteurs reviennent ensuite sur OGNL et son utilisation pour l'accès aux données provenant de la pile ValueStack (incluse dans ActionContext) mais aussi d'un objet différent d'ActionContext, qui "contient toutes les données qui constituent le contexte d'exécution d'une action". J'ai aussi bien apprécié la présentation rapide d'alternatives aux JSPs telles que Velocity et Freemarker, au niveau des pages de résultats.

La 4ème partie montre comment intégrer les applications Struts 2 avec le plug-in Spring et JPA. Un chapitre entier est consacré au framework bien pratique de validation qui vient avec Struts 2, avec les fichiers XML et les annotations. Le chapitre est lui aussi bien fait, avec abondance de code. Idem pour le chapitre suivant sur l'internationalisation.

Enfin, la 5ème et dernière partie est un peu plus fourre-tout puisqu'elle couvre divers sujets qui, comme le disent les auteurs, nous aident "à travailler plus intelligemment". A savoir l'utilisation de plug-ins (comme le classique Tiles pour la présentation, ou JFreeChart pour la création de graphes), les tests unitaires avec JUnit, comment migrer de Struts 1.X vers Struts 2, comment empêcher le double submit ...

Ce que j'ai aimé dans ce livre : le code source de chaque chapitre est packagé de façon appropriée dans l'archive (fichier war) de l'application finale, sauf les derniers chapitres.

Ce que j'ai moins aimé dans ce livre : J'ai trouvé le livre peut-être un peu trop verbeux à mon goût, dans certains passages. J'aurais préféré que les auteurs aillent d'avantage directement à l'essentiel parfois, surtout quand on dispose de peu de temps pour se former ou que l'on cherche uniquement à acquérir le minimum pour pouvoir développer. L'absence de chapitre au sujet de l'intégration de librairies Javascript et de composants Ajax dans Struts 2.

Le site du livre : http://www.manning.com/Struts2inAction/

Commentez Donner une note à l'article (5)

English version :

The book is divided in 5 parts.

In the first part, the authors give us a quick overview of the Struts 2 framework architecture (MVC pattern, interceptors, ValueStack, OGNL) and start with an Hello World sample. The 2 types of configuration are detailed : configuration through XML-based files (struts.xml) and configuration through Java annotations.

In the second part, the authors cover the action in Struts 2. It is relatively well detailed and well explained. Then a chapter deals with interceptors : their principle, the declaration, the advantages, the existing interceptors and how to create an interceptor if none of the existing ones meets the requirements. The OGNL language, which makes it possible to use the objects stored in the ValueStack, is presented for the first time in the book.

The third part deals with the different tags. I appreciated the rational indentation of paragraphs and chapters based on the 4 categories of tags : data tags, control-flow tags, UI tags and miscellaneous tags. Then I did like the presentation of each tag: first an explanation, then a small array describing the attributes, types, (...), and finally a small snippet of code to illustrate a concrete usage. Then the authors discuss again about OGNL and its utilisation to access data items not only coming from the ValueStack (included in te ActionContext) but also from a different object from the ActionContext, which "contains all the data that makes up the context in which an action occurs". I also liked the quick presentation of JSP alternatives such as Velocity and Freemarker, for the rendering of the result pages.

The fourth part shows how to integrate Struts 2 applications with the Spring plug-in and JPA. An entire chapter is dedicated to the very useful validation framework that comes with Struts 2, with XML files and annotations. The chapter is well written, with abundance of code. Same thing about the next chapter regarding internationalization.

Finally the last and fifth part is a bit more catch-all since it covers various subjects which, as the authors put it, "help us work smarter." Such as the use of plug-ins (like the classic Tiles framework for the presentation, or JFreeChart for the creation of graphs), unit tests with JUnit, how to migrate from Struts 1.X to Struts 2, how to prevent duplicate form submits ...

What I liked about this book : The source code of each chapter is appropriately packaged in the archive (war file) of the final application, except for the last chapters.

What I liked the least in this book :I found the book maybe a bit too verbose for my taste, regarding a few passages. I mean I would have preferred that the authors went directly to the main points, especially when the reader lacks time to go through all the details and learn or when the reader only wants the minimum knowledge in order to develop. The lack of chapter dedicated to the integration of Javascript libraries and Ajax components in Struts 2.

The book's website : http://www.manning.com/Struts2inAction/




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 18/04/2009 à 9:43
Bonjour,

Celinio Fernandes a publié une critique de Struts 2 in Action

Petits extraits :

Ce que j'ai aimé dans ce livre : le code source de chaque chapitre est packagé de façon appropriée dans l'archive (fichier war) de l'application finale, sauf les derniers chapitres.
Ce que j'ai moins aimé dans ce livre : J'ai trouvé le livre peut-être un peu trop verbeux à mon goût, dans certains passages. (...) L'absence de chapitre au sujet de l'intégration de librairies Javascript et de composants Ajax dans Struts 2.
D'autres membres ont une opinion sur ce livre ?

 
couverture du livre Spring Recipes: A Problem-Solution Approach

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

Spring Recipes: A Problem-Solution Approach

de

Résumé de l'éditeur

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

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

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

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

ISBN10 : 1590599799 - ISBN13 : 9781590599792

Commandez sur www.amazon.fr :

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

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

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

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


couverture du livre Pro Spring 2.5

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

Pro Spring 2.5

de
Public visé : Intermédiaire

Résumé de l'éditeur

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

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

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

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

ISBN10 : 1590599217 - ISBN13 : 9781590599211

Commandez sur www.amazon.fr :

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

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


couverture du livre Professional Java Development with the Spring Framework

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

Professional Java Development with the Spring Framework

de

Résumé de l'éditeur

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

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

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


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

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

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

ISBN10 : 0764574833 - ISBN13 : 9780764574832

Broché

Commandez sur www.amazon.fr :

25.13 € TTC (prix éditeur 29.57 € TTC)
  • Introducing the Spring Framework
  • The Bean Factory and Application Context
  • Advanced Container Concepts
  • Spring and AOP
  • DAO Support and JDBC Framework
  • Transaction and Resource Management
  • Object/Relational Mapping
  • Lightweight Remoting
  • Supporting Services
  • Acegi Security System for Spring
  • Spring and EJB
  • Web MVC Framework
  • Web View Technologies
  • Integrating with Other Web Frameworks
  • The Sample Application
  • Conclusion
  • Appendix A : Requirements for the Sample Application
Critique du livre par la rédaction Hikage le 1er octobre 2007
Ce livre est excellent, c'est grâce à lui que j'ai appris les bases de Spring. Bien qu'en anglais, il est très agréable et facile à lire.
Pour les novices, c'est effectivement un support de choix : il va introduire Spring en douceur par l'explication des raisons d'être de celui-ci, pour ensuite expliquer certaines notions sur lesquelles se base Spring (l'injection de dépendance, l'inversion de contrôle, la programmation orientée aspect) sans devenir pénible et difficile à lire.

Il présentera ensuite techniquement les différents services que Spring apporte dans le développement, allant des possibilités de simplification de la couche DAO, à la programmation distribuée ou encore le développement Web grâce à son module MVC.
Ces qualités font de lui un très bon guide pour apprendre Spring, mais aussi un aide mémoire lorsqu'un petit trou de mémoire survient. Il m'arrive encore régulièrement de le relire afin de rafraîchir certains points précis.

De plus, un des auteurs est aussi l'un des créateurs de Spring, Rod Johnson, qui n'en est pas à son premier livre populaire dans le monde Java/J2EE.
Il connait donc bien son sujet, et arrive sans peine à le vendre, et même à nous donner envie d'en savoir plus sur Spring.
Mon seul regret est qu'il n'a pas encore été réédité en prenant en compte les nouveautés de la version 2.0 de Spring, et est donc limité à la version précédente : 1.2


couverture du livre Développement Java sous STRUTS : Version 1.2

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

Développement Java sous STRUTS : Version 1.2

de
Public visé : Débutant

Résumé de l'éditeur

Cet ouvrage s'adresse à toute personne désireuse de perfectionner ses connaissances sur le développement Web avec Java. Il décrit les différents constituants de Struts ainsi que les méthodes pour développer des applications utilisant ce framework.
Le chapitre 1 permet de découvrir le développement Web avec Java.
Le chapitre 2 présente le framework Struts d'un point de vue théorique puis d'un point de vue pratique en développant une première application Struts.
La Vue du modèle MVC 2 Struts est présentée dans le chapitre 3, les ActionForms et les formulaires JSP y sont détaillés.
Le chapitre 4 présente les validations en utilisant des méthodes de la classe ActionForm et/ou les validators. Il présente également différentes méthodes de validation utilisant des formulaires constitués de plusieurs pages JSP.
Le chapitre 5 présente le contrôleur représenté par la classe ActionServlet et les classes Action.
Les balises Struts sont détaillées dans le chapitre 6.
Le chapitre 7 montre comment implémenter le modèle dans une application Struts. Différentes méthodes sont proposées, la première en utilisant des classes Java simples, la deuxième détaille l'utilisation du Design Pattern DAO, la troisième utilise le framework objet/relationnel Hibernate, la dernière les EJB et les services web.
Le chapitre 8 présente des outils open source qu'il est possible d'utiliser avec Struts : ANT, Maven, Log4J, JUnit. Il présente également la future version de Struts 1.3 ainsi que quelques technologies concurrentes présentes ou futures (JSF, Shale, MyFaces).

Édition : ENI - 415 pages , 1re édition, 4 janvier 2006

ISBN10 : 2746031051 - ISBN13 : 9782746031050

Commandez sur www.amazon.fr :

25.78 € TTC (prix éditeur 27.14 € TTC) livraison gratuite !
  • Le développement Web avec Java
  • Struts : MVC 2
  • La Vue
  • Les validations d'entrées
  • Le Contrôleur
  • Les balises Struts
  • Le Modèle
  • Outils open-source et évolution
  • Installation et configuration des outils
  • Utilisation d'Eclipse
  • DTD Struts-config.xml
Critique du livre par la rédaction Edouard Kaiser le 1er juin 2007
En reprenant les bases de la programmation web (HTML, Servlet, JSP) et les infrastructures que cela met en jeu (serveurs Web, serveur d'application et de base de données), l'auteur nous entraîne petit à petit vers la programmation web structurée par le modèle MVC sous le framework Struts. Si vous ne savez pas ce qu'est le modèle MVC, aucun souci car une partie d'un chapitre lui est consacrée afin de bien assimiler ce qu'apporte ce modèle et en quoi Struts réponds à sa mise en place.
Tout les concepts du framework sont ici clairement abordées (ActionForm, taglibs Struts, Validators, etc.) à travers des exemples concis et facilement compréhensibles.
Mais ce livre ne se contente pas simplement de décrire l'utilisation du framework et ce qui le compose, l'auteur élargit le sujet en montrant comment ce framework peut être utilisé, couplé à d'autres technologies telles que les WebServices ou les EJBs. De plus des patterns tels que le pattern DAO sont également décrits (appuyé sur Hibernate). De ce fait, cet ouvrage permet à n'importe quelle personne souhaitant se lancer dans le développement web d'obtenir une vue générale concernant les différentes couches composant une application. On appréciera également une partie d'un chapitre dédiée à des outils tels que Log4j ou ANT par exemple.
Cependant j'aurais une remarque à faire concernant les exemples en eux-mêmes du livre. Même s'il est très pratique d'avoir plusieurs petits exemples pour comprendre différents concepts, je pense qu'il aurait été bon également que le livre s'appuie sur la réalisation d'une et une seule application afin de mieux assimiler en quoi justement ce modèle permet de séparer clairement les différentes couches applicatives afin d'obtenir un résultat modulaire.


couverture du livre Struts

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

Struts

Les bonnes pratiques pour des développements web réussis

de
Public visé : Expert

Résumé de l'éditeur

Ce livre s'adresse aux développeur et programmeurs d'applications déjà expérimentés en Java et qui ont besoin de maîtriser Struts rapidement et efficacement.
Le framework Jakarta Struts est devenu un standard Open Source confirmé : sa performance, son indépendance par rapport à des systèmes propriétaires et son efficacité des coûts sont des avantages convaincants.
Résolument concret et pratique, cet ouvrage rassemble des conseils, une multitudes d'exercices, des résumés et tout un savoir-faire tiré de l'expérience professionnelle des deux auteurs.
Ils exposent les méthodes les plus efficaces, les interfaces les plus conviviales, les coûts les moins élevés, le chemin le plus court, en un mot ce que les Anglo-saxons appellent les "Best Practices".

- La première partie passe en revue les phases de développement avec Struts 1.2, JSTL 1.1, Servlet 1.4, JSP 2.0, Tomcat 5, Eclipse 3 et PostgreSQL.
- La seconde apprend comment construire une infrastructure applicative solide et performante et comment tirer des avantages de la réutilisation de code.
- La troisième partie explique comment concevoir une interface utilisateur sûre, et comment sécuriser l'application.

Édition : Dunod - 219 pages , 1re édition, 1er février 2005

ISBN10 : 2100486357 - ISBN13 : 9782100486359

Commandez sur www.amazon.fr :

28.41 € TTC (prix éditeur 29.00 € TTC) livraison gratuite !
  • Démarrer le projet
  • Spécifications des exigences
  • Créer un accès à la base de données
  • Travailler avec des actions simples
  • Travailler avec des JSP et View
  • Travailler avec des Beans simples
  • Astuces sur le processus de développement
  • Créer l'accès aux données
  • Des Beans réutilisables
  • Actions et événements réutilisables
  • Autres actions de traitement des formulaires
  • Validation
  • Contenu dynamique de site
  • Sécurité
  • Formulaires complexes et notation par points
  • Eléments déroulants et super-type
  • Concevoir l'interface utilisateur
  • Gestion de la performance
  • Future sécurité de l'application
Critique du livre par la rédaction Xoux le 1er septembre 2005
Cet ouvrage se destine à des développeurs, experts techniques ou architectes, disposant de bases concernant Struts et étant à la recherche de bonnes pratiques.
Les pistes de réflexions suggérées par les auteurs sont nombreuses, dispersées tout au long d'un ouvrage qui manque de cohérence d'ensemble et qui s'éloigne par moment de Struts. Ainsi, le lecteur y trouvera une multitude de conseils pour ses développements Web en Java, mais ne devra pas se reposer sur cet ouvrage pour apprendre à utiliser Struts.

Malgré une certaine désorganisation, les sujets abordés par les auteurs sont intéressants mais par moment assez peu explorés en profondeur. Charge au lecteur d'aller plus loin en partant à la recherche de lectures complémentaires sur les sujets qui auront retenu son attention.
Agrémenté de quelques chapitres plutôt orientés "Gestion de projet", le propos de cet ouvrage repose entièrement sur la suite de développement Jasic (éditée par les sociétés respectives des auteurs) qui rassemble un certain nombre d'outils/framework tels que Struts ou encore iBatis.

On regrettera néanmoins l'absence de certaines thématiques comme les traitements côté serveur, Struts-Layout, les bibliothèques de tags bean et logic, ou encore davantage d'éléments concernant les Tiles. Le lecteur appréciera l'abondance d'illustrations par le code, code dont le style n'est malheureusement pas très agréable à la lecture.

En conclusion, ce livre, véritable mine d'informations et de conseils, malgré une organisation une peu fouillie, vous sera de bon conseil pour approndir l'utilisation de Struts ou de manière générale la construction d'applications Web basées autour de Struts ou un framework équivalent.
Par contre, il ne vous formera pas à Struts, et un minimum de connaissances sur ce framework semble nécessaire pour bien aborder le contenu du livre.

Retrouvez la critique complète ici.


couverture du livre Jakarta Struts

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

Jakarta Struts

par la pratique

de
Traducteurs : Sylvie Gréco
Public visé : Débutant

Résumé de l'éditeur

Le framework Struts : le standard de fait pour le développement d'applications Web en Java. Parce qu'ils permettent d'assurer l'évolutivité des applications Web, de diminuer les coûts et les délais de développement, et d'accroître la fiabilité des applications, les frameworks se sont imposés comme une alternative très avantageuse aux servies et aux JSP en matière de développement d'applications Web en Java. Standard de fait parmi les frameworks Open Source, Struts gère de façon simple la plupart des tâches inhérentes au développement d'applications Web ; il est entièrement compatible avec les standards en vigueur (JSP, EJB, servlets, etc.). Struts en action Cet ouvrage est conçu comme un tutoriel dont l'objectif est de vous faire acquérir une connaissance concrète et immédiatement exploitable de Struts : design pattern MVC, vues, contrôleur, traitement des erreurs, internationalisation des applications, etc. Le code des nombreux exemples et de l'application complète proposés est directement réutilisable.

Édition : Eyrolles - 331 pages , 1re édition, 1er janvier 2003

ISBN10 : 2212112319 - ISBN13 : 9782212112313

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Présentation du projet Jakarta Struts et de ses composants annexes
    • Le projet Jakarta Struts
    • Les applications Web
    • Le conteneur de servlets/JSP Tomcat
  • Présentation des servlets et des JavaServer Pages
    • L'architecture servlet Java
    • Que sont les JavaServer Pages ?
  • Présentation de Struts
    • Télécharger et installer Struts
    • Créer une première application Struts
  • Le contrôleur
    • La classe ActionServlet
    • La classe Action
    • Les plug-ins Struts
    • La classe RequestProcessor
  • Les vues
  • L'internationalisation des applications Struts
    • Les composants i18n d'une application Struts
    • Internationalisation de l'application eyrollesapp
  • Le traitement des erreurs
    • Les composants de traitement d'erreurs Struts
    • Ajouter le traitement d'erreurs à l'application eyrollesstruts
  • Création d'ActionMapping personnalisés
    • Qu'est ce qu'un ActionMapping ?
    • Création d'un ActionMapping personnalisé
  • Le pool de connexions JDBC
    • Qu'est ce qu'une DataSource ?
    • Utilisation d'une DataSource dans une application Struts
  • Débogage des applications Struts
    • Intégrer Tomcat dans une application Java
    • Débogage d'une application Struts
  • Développement d'une application Struts
    • Description de l'application Employes
  • Le fichier struts-config.xml
    • Les sous-éléments Struts
    • Ajouter une DataSource Struts
    • Ajouter des définitions de FormBean
    • Ajouter des redirections globales
    • Ajouter des actions
    • Ajouter un RequestProcessor
    • Ajouter des ressources de messages
    • Ajouter un Plug-in
  • La bibliothèque de balises Bean
  • La bibliothèque de balises HTML
  • La bibliothèque de balises Logic
  • La bibliothèque de balises Template
Critique du livre par la rédaction Xoux le 1er décembre 2004
Cet ouvrage se destine essentiellement aux débutants désirant apprendre à utiliser le framework Struts.
Très facile et agréable à lire, il fait le tour des prérequis nécessaires à la compréhension et l'utilisation de Struts pour se focaliser par la suite sur la version 1.1 du framework.

L'auteur se repose sur l'utilisation de Tomcat 4.1 et de MySQL pour illustrer son propos et construire ses exemples.
Les explications des concepts de base (MVC, ActionForm, Action, fichier de configuration, internationalisation, ...), tout comme leur mise en oeuvre à travers des exemples, sont conformes à ce que propose Struts 1.1, mais l'auteur omet de nombreuses nouveautés introduites à partir de cette version.
Il ne faut donc pas se fier au titre original de cet ouvrage (à savoir Mastering Jakarta Struts) sous peine d'être déçu.

Malgré tout, ce livre reste l'une des rares ressources françaises sur Struts et, même s'il ne permet pas d'être directement opérationnel sur la version courante, permettra à un public de débutants de se familiariser rapidement avec le framework. De plus, ses annexes sur les librairies de tags pourront servir d'aide mémoire.
Si vous recherchez un ouvrage couvrant une version plus récente de Struts pour vous former rapidement ou tout simplement avoir une référence, vous n'aurez malheureusement pas d'autre choix de vous orienter vers des publications en langue anglaise.

Retrouvez la critique complète ici.