Les livres Java Web en Anglais

21 livres et 23 critiques, dernière mise à jour le 21 juin 2019 , note moyenne : 4.7

  1. JSF 2.0 Cookbook
  2. RESTful Java with JAX-RS
  3. Apache Struts 2 - Web Application Development
  4. Modular Java - Creating Flexible Applications With OSGi and Spring
  5. Beginning Java™ EE 6 Platform with GlassFish™ 3 - From Novice to Professional
  6. Java SOA Cookbook
  7. Pro Spring Dynamic Modules for OSGi Service Platforms
  8. Developing with Ext GWT - Enterprise RIA Development
  9. Professional Apache Tomcat 6
  10. JBoss in Action
  11. Struts 2 in Action - Donald Brown, Chad Michael Davis, Scott Stanlick
  12. Seam in action
  13. Spring Recipes: A Problem-Solution Approach
  14. Pro Spring 2.5
  15. Wicket in action
  16. Head First Servlets and JSP
  17. Professional Java Development with the Spring Framework
  18. Google Web Toolkit - GWT Java AJAX Programming
  19. Core JavaServer Faces
  20. Enjoying Web Development with Tapestry - Put the fun back into J2EE application development
  21. Sun Certified Web Component Developer Study Companion - J2EE 1.4 (exams 310-081 and 310-082)
couverture du livre JSF 2.0 Cookbook

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

JSF 2.0 Cookbook

de
Public visé : Débutant

Résumé de l'éditeur

JavaServer Faces is a Java-based Web application framework intended to simplify development of user interfaces for Java EE applications. You may already be aware of the laborious search through reference guides and documentation to develop your JSF applications. With the JSF Cookbook, you can find solutions to the most common JSF problems in a quick and easy way.

This book will cover all the important aspects involved in developing JSF applications. It provides clear instructions for getting the most out of JSF and offers many exercises to build impressive desktop-style interfaces for your web applications. Develop JSF applications starting with simple recipes and gradually moving on to complex recipes.

We discuss all of the fundamental aspects of JSF applications. Once you locate your desired topic, you can try to find a recipe that corresponds to your problem.

We start off with the simple concepts of Converters, validators and file management. We then work our way with various resources such as CSS, JavaScript, and images to improve your web applications. You will learn to build simple and complex custom components to suit your needs. Next, you get to exploit AJAX as well as implement internationalization and localization for your JSF applications. We then look into ensuring security for your applications and perform testing of your applications. You also get to learn all about Facelets and explore the newest JSF 2.0 features. Finally you get learn a few integrations such as JSTL with JSF, Spring with JSF, and Hibernate with JSF. All these concepts are presented in the form of easy-to-follow recipes.

Each chapter discusses separate types of recipes and they are presented with an increasing level of complexity from simple to advanced. All of these recipes can be used with JSF 1.2 as well.

This book helps you to find solutions to the most common aspects regarding JSF development with clear and easy-to-follow recipes

Édition : PackT Publishing - 396 pages , 1re édition, 1er juin 2010

ISBN10 : 1847199526 - ISBN13 : 9781847199522

Commandez sur www.amazon.fr :

34.26 € TTC (prix éditeur 36.06 € TTC) livraison gratuite !
  • Chapter 1: Using Standard and Custom Converters in JSF
  • Chapter 2: Using Standard and Custom Validators in JSF
  • Chapter 3: File Management
  • Chapter 4: Security
  • Chapter 5: Custom Components
  • Chapter 6: AJAX in JSF
  • Chapter 7: Internationalization and Localization
  • Chapter 8: JSF, Images, CSS, and JS
  • Chapter 9: JSF-Managing and Testing
  • Chapter 10: Facelets
  • Chapter 11: JSF 2.0 Features
  • Chapter 12: Mixing JSF with Other Technologies
  • Appendix: Configuring JSF-related Technologies
Critique du livre par la rédaction longbeach le 1er août 2010
Ce livre couvre les nouveautés de JSF 2 à travers environ 100 recetttes. A mon avis ces recettes fournissent un bon aperçu des nouvelles possibilités de la dernière version de JSF.
Les chapitres apportent des solutions immédiates à des problèmes et des pré-requis très courants dans le développement web.
Bien sûr il est nécessaire de lire plus de documentation sur JSF 2 (telle que la référence complète) pour être capable de complètement comprendre et connaître les différentes options.
Le principal IDE et le serveur utilisés dans le livre sont NetBeans 6.8 et GlassFish 3, respectivement. L'IDE Eclipse Ganymede est utilisé dans une recette (utilisation de JSF ID generator).

Les deux premiers chapitres donnent une bonne idée des validators et des converters, personnalisés et standards. Apache MyFaces Trinidad et RichFaces sont utilisés. La validation est également mise en oeuvre à travers l'intégration de la JSR-303 (Bean validation) dans JSF 2.

Le chapitre 3 concerne la gestion des fichiers (envoi, téléchargement, extraction, export) avec l'aide des librairies Mojarra Scales et de composants dans RichFaces et PrimeFaces.

Le chapitre 4 est un autre chapitre intéressant qui explore les différents moyens de protéger un site. Il met en oeuvre l'utilisation des expressions EL qui font partie du projet JSF Security et qui utilisent une portée séparée et appelée securityscope. Les rôles sont basés sur JAAS, stockés dans une base ou ajoutés à la HttpSession. La dernière recette utilise Spring Security pour gérer une page de login.

Le chapitre 5 fournit des recettes pour la création de divers composants personnalisés (hello world, un visualiseur d'images avec des fonctionnalités Ajax en utilisant le projet Dynamic Faces project, etc) et également des composants composites personnalisés.

Le chapitre 6 concerne Ajax. Il couvre le nouveau tag <f:ajax> et utilise de nouveau plusieurs autres librairies de composants pour ajouter des fonctionnalités Ajax (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).

Le chapitre 7 traite des besoins fréquents en matière de site que sont l'internationalisation et la localisation. Il utilise le tag core f:loadBundle, les fichiers de messages properties, l'encoding ...

Le chapitre 8 montre comment ajouter des styles CSS à des tags JSF, peupler des grids avec des styles CSS, intégrer JavaScript dans JSF avec divers exemples, récupérer des images d'une base et les envoyer de façon dynamique à une page JSF. Il y a même une recette qui montre comment utiliser la librairie de tag rss4jsf pour montrer du contenu RSS dans des pages JSF.

Le chapitre 9 introduit diverses applications :
- l'outil Faces Console pour éditer de façon visuelle les fichiers de configuration JSF
- JSFUnit (un framework JBoss pour tester des applications JSF)
- JMeter pour mesurer la performance
- JSF Chart Creator pour afficher des graphes

Le chapitre 10 est un chapitre important puisqu'il traite des Facelets qui, à partir de la version 2.0 de JSF, font partie de la spécification JSF et sont la technologie de présentation recommandée avec JSF. Le templating et les composants de composition sont les sujets les plus traités dans ce chapitre.

Le chapitre 11 est un ensemble de sept recettes autour des nouveautés de JSF 2.0 qui n'ont pas été abordées dans les précédents chapitres.

Enfin le chapitre 12 est un autre chapitre utile puisqu'il montre l'intégration de JSF avec d'autres technologies telles que Spring et les EJB.

L'appendix contient des listings des fichiers de configuration pour les frameworks basés sur JSF.

Ce que j'ai le plus aimé : les recettes sont basées sur des besoins et des problèmes fréquemment rencontrés lors du développement. Elles sont donc très utiles.

Ce que j'ai moins aimé : je n'ai rien de particulièrement négatif à signaler. Ce livre de recettes correspond à l'idée et aux attentes que j'avais avant de le lire.

English version :

This book covers the new features of JSF 2 in the form of about 1OO hundred recipes. In my opinion these recipes give a good overview of the new capabilities of the latest version of JSF.
The chapters get right to the point with very common problems/requirements in web development and their solutions.
Of course you still need to read more documentation about JSF 2 (such as the complete reference) to be able to completely understand and know the different options.
The main IDE and the server used in the book are NetBeans 6.8 and GlassFish 3, respectively. The IDE Eclipse Ganymede is used in one recipe (Using JSF ID generator).

The first two chapters give a good idea of the custom and standard validators and converters. Apache MyFaces Trinidad and RichFaces are used. Validation is also demonstrated through the built-in integration of JSR-303 (Bean validation) in JSF 2.

Chapter 3 is about file management (uploading, downloading, extraction, export) with the help of Mojarra Scales libraries, RichFaces and PrimeFaces components.

Chapter 4 is another interesting chapter that explores various ways to protect a site. It demonstrates the use of EL expressions part of the JSF Security project which uses a separate scope called securityscope. Roles are based on JAAS, stored in a database or added to the HttpSession. The last recipe makes use of Spring Security to manage a login page.

Chapter 5 provides recipes to demonstrate the creation of various custom components (hello world, image slide viewer with Ajax functionality using the Dynamic Faces project etc) and also composite custom components.

Chapter 6 is about Ajax. It covers the new tag <f:ajax> and again uses several other component libraries to add Ajax features (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).

Chapter 7 is about the frequent site requirements that are internationalization and localization. It uses the core tag f:loadBundle, messages properties files, encoding ...

Chapter 8 shows how to add CSS styles to JSF tags, populate grids with CSS styles, integrate JavaScript to JSF with various examples, retrieve images from a database and provide them dynamically to a JSF page. There is even a recipe that shows how to use the tag libary rss4jsf to show RSS content in JSF pages.

Chapter 9 introduces various applications :
- the Faces Console tool to visually edit JSF configuration files
- JSFUnit (JBoss framework for testing JSF applications)
- JMeter to measure performance
- JSF Chart Creator to diplay charts

Chapter 10 is an important one since it is about Facelets which, starting with JSF 2.0, is a part of the JSF specification and the recommended presentation technology to use in conjunction with JSF. Templating and composition components are the topics most discussed in this chapter.

Chapter 11 is a set of seven recipes about new features in JSF 2.0 that were not seen in the previous chapters.

Finally chapter 12 is another useful chapter since it shows how to integrate JSF with other technologies such as Spring and EJB

The appendix contains listings of the configuration files for JSF-related frameworks.

What i liked most : the recipes are based on frequent requirements and problems encountered when developing. So they are really useful.

What i liked the least : nothing really negative to report. This book of recipes meets the idea and expectations I had of it before reading it.




 Poster une réponse Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 23/08/2010 à 10:52
Bonjour à tous,

les livres sur JSF 2.0 commencent à arriver. En voici un autre : JSF 2.0 Cookbook.

Je l'ai lu et j'ai plutôt été satisfait du contenu. Ma critique est disponible à cette adresse :

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

Bonne lecture.

 
couverture du livre RESTful Java with JAX-RS

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

RESTful Java with JAX-RS

de

Résumé de l'éditeur

Learn how to design and develop distributed web services in Java using RESTful architectural principals and the JAX-RS specification in Java EE 6. With this hands-on reference, you'll focus on implementation rather than theory, and discover why the RESTful method is far better than technologies like CORBA and SOAP.

It's easy to get started with services based on the REST architecture. RESTful Java with JAX-RS includes a technical guide that explains REST and JAX-RS, how they work, and when to use them. With the RESTEasy workbook that follows, you get step-by-step instructions for installing, configuring, and running several working JAX-RS examples using the JBoss RESTEasy implementation of JAX-RS.

Édition : O'Reilly - 320 pages , 1re édition, 1er décembre 2009

ISBN10 : 0596158041 - ISBN13 : 9780596158040

Commandez sur www.amazon.fr :

31.12 € TTC (prix éditeur 34.38 € TTC) livraison gratuite !
[list][*]Introduction to REST[*]Designing RESTful Services[*]Your First JAX-RS Service[*]HTTP Method and URI Matching[*]JAX-RS Injection[*]JAX-RS Content Handlers[*]Response Codes, Complex Responses, and Exception Handling[*]HTTP Content Negotiation[*]HATEOAS[*]Scaling JAX-RS Applications[*]Deployment and Integration[*]Securing JAX-RS[*]RESTful Java Clients[*]JAX-RS Implementations[*]JAX-RS Workbook (examples)
[list]
Critique du livre par la rédaction Petrus le 8 janvier 2010
Efficace, le livre de Bill Burke ! Structuré et de longueur idéale (moins de 200 pages sans le Workbook), l'ouvrage publié par O'Reilly constitue une très bonne introduction aux services RESTful et à leur implémentation en Java. Après de brefs rappels sur l'architecture de l'information Web et sur les principes de REST (Adressability, Uniform interface, Representation-oriented, Statelessly communication, HATEOAS), l'auteur détaille clairement et de façon illustrée la réalisation de services JAX-RS simples (programmation, déploiement) puis introduit les autres composantes de l'architecture (annotations disponibles, injections JAX-RS, traitement du contenu du message et IOs, JAXB, JSon, Marshalling, etc.). Le professionnel ne sera pas en reste, avec des chapitres consacrés aux problématiques d'entreprise, comme la montée en charge, le caching, le déploiement, la sécurité. Une dernière partie particulièrement étoffée "JAX-RS Workbook" accompagne chaque chapitre avec l'intégralité des codes sources et exemples. Un livre sérieux donc, même si le sujet est d'apparence relativement simple, et qui conviendra selon moi à un public technique, débutant ou confirmé. Le seul petit regret est l'absence d'exemples concernant l'écriture de tests unitaires pour des services RESTful et les bonnes pratiques dans ce domaine.




 Poster une réponse Signaler un problème

Avatar de Petrus Petrus - Expert confirmé https://www.developpez.com
le 26/08/2010 à 1:47
Hello,

Je viens de publier une critique concernant le livre "RESTful Java with JAX-RS" de Bill Burke. Un livre à la thématique simple mais assez complet je trouve. Je vous invite donc à le découvrir ;-) :

Lire la(les) critique(s) du livre "RESTful Java with JAX-RS" publié chez O'Reilly.

De manière générale qui utilise JAX-RS ? dans quel contexte métier et architectural ?

 
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 Modular Java

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

Modular Java

Creating Flexible Applications With OSGi and Spring

de
Public visé : Intermédiaire

Résumé de l'éditeur

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

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

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

ISBN10 : 1934356409 - ISBN13 : 9781934356401

Broché

Commandez sur www.amazon.fr :

23.59 € TTC (prix éditeur 24.84 € TTC)
  • Introduction
  • Getting Started
  • Dude, Where's My Jar ?
  • Working with Bundles
  • OSGi Services
  • Spring and OSGi
  • Creating Web Bundles
  • Extending Bundles
  • OSGi in Production
  • Configuring the Application
  • Manifest Headers
  • Spring-DM Configuration
  • The OSGi Blueprint Service
  • Resources
  • Bibliography
  • Index
Critique du livre par la rédaction Baptiste Wicht le 1er novembre 2009
Ce livre est une très bonne introduction à la création d'applications modulaires en Java. Ce livre présente tous les principaux concepts de la technologie OSGi, de Spring Dynamic Modules ainsi que des outils permettant de faciliter le développement d'applications OSGi.
Le premier chapitre présente la problématique de modularité et présente comment OSGi tente de résoudre ce problème. Les concepts principaux de la technologie y sont également décrits.

Le second chapitre présente différents conteneurs OSGi. Dans ce chapitre, on crée un premier programme Hello World en utilisant OSGi. On améliore ensuite ce programme en utilisant la publication et la consommation de services OSGI.
Le troisième chapitre introduit l'application "Dude, Where's my Jar ?" qui nous suivra tout au long du livre. Cette application est une application web permettant d'effectuer des recherches de fichier Jar dans des repository Maven. En plus de cela, le chapitre présente la série d'outils Pax qui permettent de faciliter le développement d'applications OSGi.

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

Le chapitre cinq développe le bundle suivant. Ce chapitre se focalise sur la publication et la consommation de services OSGi. En plus de cela, on apprend également à tester une application et des services OSGi.
Il est maintenant temps de passer à Spring Dynamic Modules avec le chapitre suivant. On y voit comment faciliter la consommation et la déclaration de services sous forme de beans Spring.

Avec le chapitre 7, on commence à développer le bundle web. Pour cela, on va inclure Tomcat ou Jetty sous forme de bundles OSGi. On va ensuite voir les différences qu'il y a entre déclarer un bundle simple (JAR) et un bundle web (WAR).
Le chapitre suivant traite de l'extension de bundle OSGI au moyen de fragment. On va notamment voir comment découpler la partie JSP et design de la partie applicative.

L'avant dernier chapitre permet de voir comment déployer une application OSGi en production. Il présente l'ajout d'une console web à l'application pour administer directement les modules.
Le dernier chapitre présente les services de journalisation et d'administration qui font partie de la norme OSGi.
En conclusion, ce livre vous permettra de commencer à développer des applications utilisant OSGi.
C'est très agréable de suivre le développement d'une application tout au long du livre, tout en découvrant au fur et à mesure ce qu'OSGi permet de faire pour faciliter le développement d'une application.

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




 Poster une réponse Signaler un problème

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

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

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

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

 
couverture du livre 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 Signaler un problème

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/?page=Anglais#L9781430219545

 
couverture du livre Java SOA Cookbook

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

Java SOA Cookbook

de
Public visé : Intermédiaire

Résumé de l'éditeur

Java SOA Cookbook offers practical solutions and advice to programmers charged with implementing a service-oriented architecture (SOA) in their organization. Instead of providing another conceptual, high-level view of SOA, this cookbook shows you how to make SOA work. It's full of Java and XML code you can insert directly into your applications and recipes you can apply right away.

The book focuses primarily on the use of free and open source Java Web Services technologies -- including Java SE 6 and Java EE 5 tools -- but you'll find tips for using commercially available tools as well.

Java SOA Cookbook will help you:

  • Construct XML vocabularies and data models appropriate to SOA applications
  • Build real-world web services using the latest Java standards, including JAX-WS 2.1 and JAX-RS 1.0 for RESTful web services
  • Integrate applications from popular service providers using SOAP, POX, and Atom
  • Create service orchestrations with complete coverage of the WS-BPEL (Business Process Execution Language) 2.0 standard
  • Improve the reliability of SOAP-based services with specifications such as WS-Reliable Messaging
  • Deal with governance, interoperability, and quality-of-service issues

The recipes in Java SOA Cookbook will equip you with the knowledge you need to approach SOA as an integration challenge, not an obstacle.

Édition : O'Reilly - 740 pages , 1re édition, 1er mars 2009

ISBN10 : 0596520727 - ISBN13 : 9780596520724

Commandez sur www.amazon.fr :

36.79 € TTC (prix éditeur 39.82 € TTC) livraison gratuite !
[list][*]Part 1: SOA Fundamentals
  • Chapter 1. Introduction to SOA
  • Chapter 2. XML Schema and the SOA Data Model
  • Chapter 3. Working with XML and Java
[*]Part 2: Web Services
  • Chapter 4. Getting Started
  • Chapter 5. Web Services with SAAJ
  • Chapter 6. Creating Web Service Applications with JAX-WS
  • Chapter 7. Providing SOAP-Based Web Services
  • Chapter 8. RESTful Web Services
[*]Part 3: Business Processes
  • Chapter 9. Service Orchestrations with BPEL
  • Chapter 10. Advanced Orchestrations with BPEL
  • Chapter 11. SOA Governance
[*]Part 4: Interoperability and Quality of Service
  • Chapter 12. Web Service Interoperability
  • Chapter 13. Quality of Service
  • Chapter 14. Enterprise Service Bus

[list]
Critique du livre par la rédaction Eric REBOISSON le 1er janvier 2010


Contributeur pour 97 Things Every Software Architect Should Know, Eben Hewitt nous gratifie là d'un bel ouvrage de plus de 700 pages qui vous aidera à mettre en ?uvre des cas pratiques autour de la SOA.

La structure de la collection Cookbook de chez O'Reilly est la suivante : exposition des problèmes suivis de leurs solutions, des fragments de code ; le tout agrémenté d'explications et de comparaisons entre les différentes opportunités offertes dans le vaste domaine de la gestion des services.

Le contenu de "Java SOA Cookbook" est le suivant :

[list][*]La première partie du livre aborde les fondamentaux de la SOA (définitions, XML, schémas, interaction avec Java).[*]La deuxième partie se focalise sur les Web Services (déploiement, WSDL, SOAP, SAAJ, JAX-WS, REST).[*]La partie suivante est orientée business avec l'orchestration des services via BPEL (Business Process Execution Language, que l'on prononce "bipeul" ) et la gouvernance.[*]La dernière partie discute autour de l'interopérabilité des Web Services, de la qualité de service, et d'ESB.
[list]

D'un point de vue programmatique, le lecteur trouvera beaucoup d'exemples de codes (téléchargeables sur Internet) et des discussions autour de ceux-ci. Une remarque cependant : même si les recettes sont très bien expliquées, il faut être familier avec Java 5 ou 6, J2E et les concepts de développement Web (EARs, WARs...).

Voilà donc un livre que j'ai apprécié, par sa structure efficace, la richesse et la qualité de son contenu. Et comme en cuisine, vous utiliserez ce livre comme un ouvrage de référence quand des problèmes précis seront à résoudre, une lecture linéaire est, je pense, trop ennuyante.
Critique du livre par la rédaction Hikage le 1er août 2009
Français

Pour apprécier à sa juste valeur le livre Java SOA Cookbook, il faut bien comprendre que tous les termes du titre sont importants. Pour ma part, je me suis attaché uniquement à Java SOA, et j'ai été un peu surpris...

Le mot cookbook est plutôt judicieusement choisi, car on peut réellement le comparer à un livre de cuisine : une liste de recettes, sans avoir forcement tout le temps une suite logique entres elles. Par exemple, dans le chapitre concernant les gâteaux, on peut trouver 4 recettes de gâteaux au chocolat, et la 5ème est un gâteau au citron.

Dans le livre Java SOA Cookbook, c'est un peu pareil. Par exemple, dans le chapitre sur BPEL, on utilise d'abord le BPEL Engine de Apache 2-3 recettes, pour ensuite utiliser NetBean et OpenESB, puis encore un autre outil commercial pour la suite.

Et c'est comme cela dans l'ensemble du livre, ce qui est un peu déstabilisant pour "découvrir" la SOA et les sujets du livre.

Mais cela n'empêche pas l'ouvrage d'être un bon livre sur le sujet.
Les Web Services sont bien représentés, tant les services SOAP que les services REST
La partie Business Process Management, malgré mes remarques, est très intéressante elle-aussi. N'ayant personnellement jamais travaillé avec ceux-ci, j'ai appris beaucoup de choses.

Java SOA Cookbook, une fois la surprise passée du format, est un excellent livre qui permettra d'appréhender facilement les Web services, la gestion de processus métier ou, de manière plus générale, la SOA par le biais d'exemples concrets très bien détaillés.

English

To appreciate the book Java SOA Cookbook with its real value, it should be understood that all terms of the title are important. For my part, I have given attention only on Java SOA, and I was a little surprised ..

The term cookbook is carefully chosen, because you can really compare it to a cookbook: a list of recipes, without necessarily having all the time a logical sequence between them. For example, in the chapter on cakes, there are 4 recipes with chocolate, and the 5th is a lemon cake.

In the book "Java SOA Cookbook" is just the same. For example, in the chapter about BPEL, the firsts recipes use the Apache BPEL Engine, the next ones use NetBeans Designer and OpenESB, and the lasts use a commercial product for BPEL.

And it's like this in the entire book, which is a little unsettling for "discovering" the SOA and the subjects of the book.

But this does not prevent the book from being a good book on the subject. The Web Services are well covered, both the services that services SOAP REST.
The Business Process Management part, despite my remarks, is very interesting too. Having personally never worked with BPM/BPEL, I learned many things.

Java SOA Cookbook, once past the surprise of the format, is an excellent book which will easily understand Web services, management of business processes or more generally SOA through examples and very well detailed.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 08/08/2009 à 15:39
Bonjour,

Le terme SOA est très en vogue ces dernières années, et les concepts se déclinent de manière exhaustive en Java.

Il existe un ouvrage édité par O'Reilly UK intitulé Java SOA Cookbook qui se propose d'illustrer la SOA par l'intermédiaire de petites recettes pratiques.

Voici ce qu'en pense le responsable bénévole Spring :

Pour apprécier à sa juste valeur le livre Java SOA Cookbook, il faut bien comprendre que tous les termes du titre sont importants. Pour ma part, je me suis attaché uniquement à Java SOA, et j'ai été un peu surpris...

(...)

Java SOA Cookbook, une fois la surprise passée du format, est un excellent livre qui permettra d'appréhender facilement les Web services, la gestion de processus métier ou, de manière plus générale, la SOA par le biais d'exemples concrets très bien détaillés.
Retrouvez la critique complète

Certains ont eu l'occasion de feuilleter ce livre ?
Avatar de elitost elitost - Expert éminent https://www.developpez.com
le 08/01/2010 à 23:01
Eh bien, j'ai pu lire ce livre et en rédiger une critique pour Developpez.

C'est un très bon livre sur la SOA, on y trouvera la trousse à outils nécessaire pour résoudre ses problèmes et répondre aux questions sur le sujet.

Il y a énormément de sujets abordés (plusieurs dizaines), le développeurs comme le concepteur SOA y trouvera forcemment son bonheur.

Et vous ? vous en avez pensé quoi ?

 
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 Signaler un problème

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 Developing with Ext GWT

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

Developing with Ext GWT

Enterprise RIA Development

de
Public visé : Débutant

Résumé de l'éditeur

Developing in Ext GWT is a fast?paced, practical guide to quickly learning the tasks necessary in building enterprise?class Rich Internet Applications. Based around the exciting new UI library from Ajax leaders Ext JS and the latest GWT release, this book takes the reader through setup, the available widgets, and advanced custom widgets and templates, and concludes with a functional sample client?server application in less than 150 pages. Not your typical beginner's guide to programming, this book provides a rapid approach to becoming effective with leading commercial RIA tools and libraries.

[list][*]A practical approach to enterprise RIA development using industry-proven tools.[*]Full coverage of the new Ext GWT 2.0 widget library based on GWT 1.6[*]Designed for professional developers needing a quick, no-nonsense overview of the initial requirements to get started, ending with an example client-server application
[list]

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

ISBN10 : 1430219408 - ISBN13 : 9781430219408

Commandez sur www.amazon.fr :

0.00 $ TTC (prix éditeur 19.99 $ TTC)
[list][*]Présentation de Ext GWT et GWT[*]Organisez votre environnement[*]Des composants, des composants, partout ![*]Composants avancés[*]Travailler avec des données[*]Un exemple concret
[list]
Critique du livre par la rédaction prenom nom le 1er juin 2009
Ce livre s'adresse aux développeurs Java qui veulent rapidement développer une application Web riche en utilisant la librairie Ext-GWT.

Le point fort des ouvrages de cette collection, c'est de suivre l'évolution technologique au plus près. Celui-ci ne déroge pas à la règle et utilise les librairies GWT et Ext-GWT dans leurs dernières versions. Pour GWT, c'est la 1.6 et pour Ext-GWT, c'est la 2.0 (encore au stade M2). Si vous envisagez de l'acheter, c'est donc le moment !

Ce livre a une approche didactique classique, il commence par une présentation générale, explique comment installer cette librairie, présente les composants simples et avancés et termine avec un exemple concret.

Le premier chapitre présente à la fois les librairies Ext-GWT et GWT. Comme le sujet de ce livre est Ext-GWT, c'est d'abord elle qui est présentée. On sent bien que cette librairie n'est qu'une sur couche de GWT car l'auteur a beaucoup plus de généralités à dire sur GWT. Si cette présentation de GWT ne remplace pas un livre dédié, elle en demeure néanmoins un bon résumé.

Le deuxième chapitre est un tutoriel très pratique qui vous explique comment configurer un environnement de développement Ext-GWT sous eclipse et comment commencer une première application. L'auteur a semble t'il préféré le côté didactique des batchs de GWT à la simplicité du plugin Eclipse-GWT.

Les troisième et quatrième chapitres présentent les composants de la librairie, des plus simples ou plus avancés. La présentation est progressive et la lecture facile. Quelques captures d'écran et exemples de code viennent compléter les explications.

Le cinquième chapitre présente les composants Ext-GWT qui font le lien entre les widgets graphiques et le serveur. Comme la librairie, l'auteur fait le choix du "full gwt" et ne traite donc que du mode RPC de GWT. Ne cherchez donc pas dans ce livre d'exemple d'échanges de données avec XML ou JSON, vous n'en trouverez pas !

Le sixième et dernier chapitre se veut être un exemple concret qui reprend un peu tout ce qui a été présenté dans les chapitres précédents. Bien que synthétique, il apporte également les quelques informations complémentaires nécessaires à la construction d'une application réelle.

Avant de lire ce livre, j'avais réalisé des applications Ext-GWT en utilisant tous les composants qu'elle propose. L'avantage pour vous, c'est que j'ai pu écrire une meilleure critique vis à vis de ce que dit ou ne dit pas l'auteur ! L'inconvénient pour moi, c'est que du coup, ce livre m'a un peu laissé sur ma faim ... Il faut croire que je ne suis pas la cible !

Ceci dit, ce qui est super dans ce livre, c'est toutes les remarques, trucs et astuces qu'il recèle. J'ai été agréablement surpris de voir qu'il dresse tous les pièges dans lesquels je suis tombé moi-même. Je le recommande donc principalement à ceux qui veulent écrire leur première application avec Ext-GWT.

English version :

This book is intended for Java developers who want to quickly develop a rich web application using GWT-Ext library.

The particularity of this collection is to follow technological developments as closely as possible. This book is not an exception to the rule and uses GWT and GWT-Ext in their latest versions (GWT is 1.6 and GWT-Ext is 2.0). If you plan to buy, so this is the moment !

This book has a didactic style, it begins with an overview, how to install this library, introduces the simple and advanced components and ends with a concrete example.

The first chapter describes both GWT-Ext and GWT. Since the topic of this book is Ext-GWT, author begins with it. We can see that this library is a layer of GWT because the author has much more to say about general GWT. If this presentation of GWT does not replace a book dedicated, it remains a good summary.

The second chapter is a useful tutorial that explains how to configure a development environment GWT-Ext in Eclipse and how to start a first application. The author seems to prefer the didactic GWT batches to the simplicity of the GWT Eclipse-plugin.

The third and fourth chapters gradually introduces the components of the library, from the simplest to the more advanced one. The presentation is progressive and easy reading. Some screenshots and code examples complement the explanations.

The fifth chapter describes the GWT-Ext components which link the graphical widgets to the server components. As the library does, the author decided to follow a "full GWT" way and therefore does only cover the GWT RPC mode. Do not try to find in this book an example of data exchange with XML or JSON, you won't find any !

The sixth and final section provides a concrete example which aims to sumamarize all the things presented in previous chapters. Although synthetic, it also provides some additional information needed to build a real application.

Before reading this book, I had built GWT-Ext applications, using all the Ext components. The benefit to you is that I could write a better review with respect to what is said or not by the author! The downside for me is that suddenly, I'm left wanting more ... Must believe that I am not the target !

What is great in this book is all the comments, tips and tricks it contains. I was pleasantly surprised to see that it gives all the traps in which I fall myself. I therefore recommend mainly to those who want to write their first application with GWT-Ext.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 21/06/2009 à 11:03
Bonjour,

Avez vous des retours d'expériences sur les livres GWT disponibles en librairies ?

Un petit inventaire (non nécessairement exhaustif) :


Ais-je bien cherché ? Pas encore de livre francophone sur le sujet ?
Avatar de benwit benwit - Rédacteur https://www.developpez.com
le 22/06/2009 à 7:44
Il faudrait distinguer les livres spécifiques à GWT (tous ceux cités sauf un) de ceux spécifiques à une surcouche de GWT (Le livre sur Ext-GWT).

Il pourrait être également intéressant de les trier par ordre de parution / version de GWT car GWT évoluant très vite, certains expliquent des trucs qui n'ont plus lieu d'être.

Eh non, rien en français pour l'instant ... Des éditeurs seraient partant ?
Avatar de Louhike Louhike - Membre habitué https://www.developpez.com
le 22/06/2009 à 21:47
J'ai acheté "GWT in action" sur Amazon et je suis très satisfait. Le livre n'est pas super récent donc c'est une ancienne version de GWT mais ça ne m'a pas gêné pour l'instant.
Par contre, le premier chapitre du livre est un peu confus pour un débutant et j'ai eu un peu de mal à tout suivre, mais dès le chapitre 2 ça allait mieux.
Donc j'aurais tendance à le recommander, d'autant que j'ai vu plusieurs critiques qui le considéraient comme un des plus intéressants parmi les livres sur GWT.
Il faut par contre avoir déjà des notions légères de Java évidemment, le but étant d'apprendre GWT, pas le langage qu'il utilise.

 
couverture du livre Professional Apache Tomcat 6

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

Professional Apache Tomcat 6

de
Public visé : Débutant

Résumé de l'éditeur

Tomcat is the official reference implementation of Sun's servlet and JSP specifications, and Java developers must test all Web applications on Tomcat to ensure they work as designed

Boasting more than 40 percent new and updated material, this book covers all the major new features affecting server administration and management

Explores the additional built-in tools of Tomcat, which help Java developers program more efficiently, and looks at how Apache's other open source servlet/JSP technologies are designed to work with Tomcat

Features full coverage of Release 6, which supports the latest JSP and servlet specifications: JSP 2.1 and Servlets 2.5

Addresses solving real-world problems encountered during all phases of server administration, including managing class loaders and connectors, security, shared hosting and clustering, and system testing

Édition : WRox Professional - 629 pages , 1re édition, 1er août 2007

ISBN10 : 0471753610 - ISBN13 : 9780471753612

Commandez sur www.amazon.fr :

30.48 € TTC (prix éditeur 31.46 € TTC) livraison gratuite !
[list][*]Apache Tomcat[*]Web Applications: Servelets, JSPs, and More.[*]Tomcat installation[*]Tomcat Architecture.[*]Basic Tomcat Configuration.[*]Advanced Tomcat Features (2)[*]Web Application Configuration.[*]Web Application Administration.[*]Class Loaders.[*]HTTP Connectors[*]Tomcat and Apache HTTP Server.[*]Tomcat and IIS.[*]JDBC Connectivity.[*]Tomcat Security.[*]Shared Tomcat Housing .[*]Monitoring and Managing Tomcat with JMX.[*]Clustering.[*]Embedded Tomcat.[*]Logging.[*]Performance Testing.[*]Performance Tuning.[*]Appendix A. Tomcat and IDEs.[*]Appendix B. Apache Ant.
[list]
Critique du livre par la rédaction Hikage le 1er juin 2009
Si vous cherchez un très bon livre sur Tomcat, Professional Apache Tomcat 6 est clairement un très bon choix.

Présenté par ses auteurs comme une réponse au manque cruel d'une documentation de qualité sur ce serveur de Servlet, ce livre couvre effectivement tout les points intéressants.
L'audience cible est aussi très vaste : le non initié trouvera ses marques dans les premiers chapitres où les origines de Tomcat, les bases de Servlet/JSP ou encore l'installation sont présentées.

Les chapitres suivants intéresseront un public beaucoup plus vaste : l'architecture de Tomcat, sa configuration et ses principales fonctionnalités sont détaillées et expliquées.
Dans ces chapitres, les fichiers server.xml et context.xml ou encore web.xml sont décryptés, balises par balises, attributs par attributs, le tout avec des explications complètes et claires.
Des fonctionnalités moins communes mais tout aussi intéressantes, telles que la gestion de Single Sign On ou la persistance des sessions, sont aussi au sommaire.

Mais le livre ne s'arrête pas à une vue développeur de Tomcat, des sujets plus orientés administrateurs complètent la portée de ce livre : présentation des différents connecteurs, intégration de Tomcat avec Apache Http Server ou Microsoft IIS, Monitoring avec JMX, mise en clusters et optimisation.

Bref, ce livre est un très bon investissement si vous vous intéressez à Tomcat : très bon support pour le découvrir, et excellente bible Tomcat par la suite.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 16/06/2009 à 21:01
Bonsoir,

La dernière version stable de Tomcat est la 6.0 (actuellement 6.0.20).

Il existe plusieurs livres sur le sujet, donc un en français :


En avez vous lus certains et si oui, qu'en avez vous pensé ?
Avatar de sal.gass sal.gass - Membre régulier https://www.developpez.com
le 17/06/2009 à 0:33
Bonsoir,
quand on veux savoir une nouvelle chose ou un nouveau sujet on cherche souvent un livre, on trouve plusieurs, et après on reste inquiet quel est le bon livre qui répond à nos besoin

Personnellement, je n'ai aucun livre de ce que vous avez cité.
J'ai le suivant : Pro Apache Tomcat 6
J'ai pas encore lu malgré qu'il était chez moi plus qu'un ans.

Je travail avec tomcat 6 depuis longtemps, quand je veux savoir un truc ou quand je rencontre un soucis je cherche dans les forums.

Je ne sait pas si lire un livre apporte le plus,
c'est par la pratique on maitrise les chose.

c'est mon propre avis .
Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 17/06/2009 à 6:59
Citation Envoyé par logarsalem Voir le message

Personnellement, je n'ai aucun livre de ce que vous avez cité.
J'ai le suivant : Pro Apache Tomcat 6
J'ai pas encore lu malgré qu'il était chez moi plus qu'un ans.
Ajouté

C'est un peu dommage de lui faire prendre la poussière : je pense que passé un certain niveau le livre n'est plus vu comme une bible de secours, mais comme un outil d'approfondissement. Or sur l'instant présent, on ressent rarement ce besoin d'approfondissement car on a tendance à attendre la rencontre d'une problématique qui nous est inconnue plutôt que d'exploiter le livre pour aller en profondeur dans des sujets qui pourraient nous intéresser.

 
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 Signaler un problème

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/?page=Anglais#L9781933988023

 
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 Seam in action

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

Seam in action

de
Public visé : Expert

Édition : Manning - 590 pages , 1re édition, 1er septembre 2009

ISBN10 : 1933988401 - ISBN13 : 9781933988405

Commandez sur www.amazon.fr :

34.82 € TTC (prix éditeur 44.99 € TTC) livraison gratuite !
Part 1 Teeing off with Seam
  • 1 Seam unifies Java EE
  • 2 Putting seam-gen to work

Part 2 Seam fundamentals
  • 3 The Seam life cycle
  • 4 Components and contexts
  • 5 The Seam component descriptor
  • 6 Absolute inversion of control

Part 3 Seam's state management
  • 7 The conversation: Seam's unit of work
  • 8 Understanding Java persistence
  • 9 Seam-managed persistence and transactions
  • 10 Rapid Seam development

Part 4 Sinking the business requirements
  • 11 Securing Seam applications
  • 12 Ajax and JavaScript remoting
  • 13 File, rich rendering, and email support
Critique du livre par la rédaction longbeach le 1er janvier 2009
Seam veut dire suture en anglais. Mais depuis 3 ans, ce mot revêt une autre signification pour les développeurs puisqu'il désigne aussi un framework. C'est un framework assez récent, la version 1.0.0 Beta 1 date de septembre 2005, dont le project leader est Gavin King (l'un des créateurs d'Hibernate), qui intègre JSF et les EJB 3, et c'est donc avec beaucoup d'intérêt et de curiosité que j'ai lu ce livre. L'auteur, Dan Allen, sait de quoi il parle puisqu'il est un committer sur le projet. On apprend qu'à l'origine le terme Seam a été choisi pour désigner l'effort d'intégration entre JSF et les EJB 3. Les applications JBoss Seam peuvent tourner sur Websphere, Weblogic, Tomcat. Le livre se veut pratique puisqu'il propose de développer une application de golf (Open 18) pour illustrer les fonctionnalités de Seam. Le livre est divisé en 4 parties.

Dans la 1ère partie (chapitres 1, 2), l'outil seam-gen est détaillé et utilisé dès le départ pour la mise en place de l'environnement de développement, à partir d'une base de données Hypersonic H2.

Dans la 2ème partie (chapitres 3, 4, 5, 6), l'auteur explique ce que Seam apporte à JSF, en corrigeant certaines « lourdeurs », tel qu'un fichier XML trop verbeux (faces-config.xml), en supprimant les tags <managed-bean> du fichier. On peut grâce à Seam se passer de définir les backed beans dans un fichier XML. Le cycle de vie JSF avec Seam est décrit également pour expliquer les avantages de Seam. Le chapitre 4 traite des components, les annotations concernées (@Name, @Scope ...), le cycle de vie des components, etc. Dans le chapitre 5 les tags du fichier de configuration components.xml (une alternative aux annotations) sont largement détaillés. Le chapitre 6 traite des interceptors et de la notion de bijection (= injection + outjection, avec les annotations @In, @Out) en introduisant le nouveau terme outjection qui désigne la possibilité de mettre une propriété de component dans une variable de contexte pour être ensuite utilisée dans un autre component, une vue JSF ... Avec la bijection, les valeurs sont injectées depuis les variables de contexte quand le component est invoqué et réinjectées vers les variables de contexte. Une distinction nette est faite entre injection statique (assignation d'une variable quand le component est instancié) et injection dynamique (chaque fois qu'une méthode d'un component est invoquée).

Dans la 3ème partie (chapitres 7, 8, 9, 10), un chapitre entier (chapitre 7) est dédié à l'état Conversation, un des 2 états/contextes introduits par Seam (l'autre état étant business process, qui est plus long que la session), en plus des 4 états classiques que sont Request, Page, Session, Application. Cet état permet de lier des requêtes individuelles. Les 6 états classés par portée croissante sont donc : Request (event), Page, Conversation, Session, Business Process, Application. La notion de conversation, les page flows et les annotations concernées (@Begin, @Conversational, @End etc) sont systématiquement et largement expliquées avec des extraits de code s'articulant autour de l'application Open 18. Le chapitre 8 est un rappel nécessaire sur JPA et Hibernate. J'ai particulièrement apprécié le rappel sur l'extended persistence context et les différences entre ces 2 APIs car c'est bien expliqué. Le chapitre suivant aborde la gestion de la persistence et les transactions avec Seam, notamment dans la conversation, et est largement illustré par des extraits de code. Le chapitre 10 présente le Seam Application Framework au travers d'un exercice.

Dans la 4ème partie (chapitres 11, 12, 13), on apprend que Seam s'appuie sur JAAS pour l'authentication (chapitre 11). Un exemple avec une page de login JSF est utilisé. Une distinction est faite entre les authorisations basées sur des rôles et les authorisations basées sur des règles. Le moteur de règles Drools (qui tire son nom du terme "Dynamic rules") est présenté et utilisé pour créer des règles. Un exemple rapide d'utilisation du component org.jboss.seam.captcha pour l'affichage d'un CAPTCHA dans une page web est expliqué. Le chapitre 12 met l'accent sur AJAX et les solutions existantes qui tournent autour (Ajax4jsf, ICEfaces, GWT ...) Enfin, le chapitre 13 présente divers components Seam tel que <s:fileUpload> pour uploader des fichiers à partir d'un form JSF, <s:graphicImage> pour le rendu dynamique d'images , des UI components pour la génération de PDF à travers des templates de Facelets, mais aussi le module Seam de génération de graphique basé sur JFreeChart, l'envoi de mail avec un component mail Seam etc

Ce que j'ai aimé dans ce livre : Le ton de l'auteur. On a l'impression d'assister à une présentation en live de Seam, l'auteur passe beaucoup de temps à introduire les choses, à peser le pour et le contre des solutions existantes et ensuite à expliquer comment Seam peut être une solution possible. Le thème du golf, omniprésent et instructif ;-)

Ce que j'ai moins aimé dans ce livre : La prise en compte d'une version antérieure de JBoss AS : 4.2 au lieu de 5 (Java EE 5)

Le code source du livre est bien entendu disponible sur le site du livre, ainsi que deux chapitres "bonus" format PDF concernant l'intégration avec Spring d'une part et la gestion du business process (jBPM) d'autre part : http://www.manning.com/dallen/

Le site de l'auteur : http://www.mojavelinux.com/ Un errata est disponible à l'adresse http://www.manning.com/dallen/excerpt_errata.html

Enfin, le code source du livre est aussi disponible sur : http://code.google.com/p/seaminaction/

English version :

A seam is a joining of 2 things, like 2 fabrics for example. But for 3 years now, it has had another meaning for developers since it also refers to a framework. It is a rather new framework, the 1.0.0 Beta version was released in September 2005, the project leader was Gavin King (one of the creators of Hibernate), it uses JSF and EJB 3, and so it is with some big interest and curiosity that i read this book. The author, Dan Allen, knows what he is talking about since he is a committer on the project. We learn that the term Seam was chosen to refer to the work put on to facilitate the collaboration between JSF and EJB 3. JBoss Seam applications may run on Websphere, Weblogic, Tomcat. The book has a practical approach since it is based on an application centered on the game of golf (Open 18), to illustrate the features of Seam. The book is divided into 4 parts.

In the 1st part (chapters 1, 2), the seam-gen tool is explained and used from the beginning to set up the development environment, using a Hypersonic H2 database.

In the 2nd part (chapters 3, 4, 5, 6), the author explains what Seam brings to JSF, correcting some defects, such as a verbose XML file (faces-config.xml), by removing the <managed-bean> tags from the file. With Seam it is possible to define the backed beans in an XML file. The life cycle of JSF with Seam is also detailed to explain the advantages of Seam. Chapter 4 introduces the components, its related annotations (@Name, @Scope ...), the life cycle of components, etc. In chapter 5, the tags of the configuration file components.xml (the alternative to annotations) are explained in details. Chapter 6 is about interceptors and the concept of bijection (= injection + outjection, with annotations @In, @Out) by introducing the new term outjection which refers to the possibility of injecting the property of a component into a context variable, which can be re-used inside another component, a JSF view ... With bijection, the values are injected from context variables when the component is called and injected again into the context variables. A clear distinction is made between static injection (the value is injected when the component instance is created) and dynamic injection (the value is injected when a method on the component is executed).

In the 3rd part (chapters 7, 8, 9, 10), an entire chapter (chapter 7) is dedicated to the Conversation scope, one of the 2 scopes/contexts introduced by Seam (the other scope being business process, which is longer than the session), as an addition to the 4 classic scopes which are Request, Page, Session, Application. This scope ties together individual requests. So the 6 scopes ordered by ascending scope are : Request (event), Page, Conversation, Session, Business Process, Application. The term of conversation, page flows and related annotations (@Begin, @Conversational, @End, etc) are systematically and largely explained with code snippets around the Open 18 application. Chapter 8 is a necessary reminder of JPA and Hibernate. I have particularly liked the quick presentation on extended persistence context and the differences between these 2 APIs because it is well explained. The next chapter is about the persistence and the transactions with Seam, in particular within the conversation, and is largely illustrated with code snippets. Chapter 10 explains the Seam Application Framework with an exercise.

In the 4th part (chapters 11, 12, 13), we learn that Seam relies on JAAS for authentication (chapter 11). A sample with a JSF login page form is used. A clear distinction is made between role-based authorizations and rule-based authorisations. The rules engine Drools (the name Drools is derived from the term "dynamic rules") is explained and used to create the rules. A quick sample of use of the org.jboss.seam.captcha component to display CAPTCHA inside a web page is explained. AJAX and existing solutions (Ajax4jsf, ICEfaces, GWT ...) are empasized in chapter 12. Finally, chapter 13 introduces a few Seam components such as <s:fileUpload> to upload files from a JSF form, <s:graphicImage> for the dynamic rendering of images, UI components to generate PDF files using facelets templates, but also the Seam module for graphic generation based on JFreeChart, composing email with a Seam component mail etc

What I liked about this book : The author's tone. It makes you feel like you are attending a live presentation on Seam, the author spends a lot of time introducing things, weighs the pros and the cons of existing solutions and then explains how Seam can be a possible solution. I also liked the golf theme, omnipresent, and instructive ;-)

What I liked the least in this book : The referring to an older version of JBoss AS : 4.2 instead of 5 (Java EE 5)

The source code of the book is of course available on the book's website, along with 2 extra chapters in PDF format regarding the integration with Spring and the use of business process (jBPM) : http://www.manning.com/dallen/

The author's website : http://www.mojavelinux.com/ An errata is also available at http://www.manning.com/dallen/excerpt_errata.html

Finally, the code source of the book is also available at : http://code.google.com/p/seaminaction/


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 Wicket in action

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

Wicket in action

de
Public visé : Débutant

Résumé de l'éditeur

Wicket bridges the mismatch between the web's stateless protocol and Java's OO model. The component-based Wicket framework shields you from the HTTP under a web app so you can concentrate on business problems instead of the plumbing code. In Wicket, you use logic-free HTML templates for layout and standard Java for an application's behavior. The result? Coding a web app with Wicket feels more like regular Java programming.

Wicket in Action is a comprehensive guide for Java developers building Wicket-based web applications. It introduces Wicket's structure and components, and moves quickly into examples of Wicket at work. Written by core committers, this book shows you the "how-to" and the "why" of Wicket. You'll learn to use and customize Wicket components, to interact with Spring and Hibernate, and to implement rich Ajax-driven features.

Édition : Manning - 392 pages , 1re édition, 1er août 2008

ISBN10 : 1932394982 - ISBN13 : 9781932394986

Commandez sur www.amazon.fr :

35.89 € TTC (prix éditeur 44.99 € TTC) livraison gratuite !
Part 1 Getting started with Wicket
  • 1 What is Wicket?
  • 2 The architecture of Wicket
  • 3 Building a cheesy Wicket application

Part 2 Ingredients for your Wicket applications
  • 4 Understanding models
  • 5 Working with components: labels, links, and repeaters
  • 6 Processing user input using forms
  • 7 Composing your pages

Part 3 Going beyond Wicket basics
  • 8 Developing reusable components
  • 9 Images, CSS, and scripts: working with resources
  • 10 Rich components and Ajax

Part 4 Preparing for the real world
  • 11 Securing your application
  • 12 Conquer the world with l10n and i18n
  • 13 Multitiered architectures
  • 14 Putting your application into production

Critique du livre par la rédaction 1cado le 1er décembre 2008
Le livre en lui-même est bien présenté et agréable à lire. Les chapitres sont courts et bien découpés, ce qui facilite son usage comme référence pour plus tard.

Il a été écrit par deux des principaux Core Developers de Wicket depuis qu'il est OpenSource. On peut donc leur faire confiance quand ils donnent des conseils ;-) . Les parties de code sont assez claires même si j'ai eu un peu de mal à comprendre où rattacher quoi à certains moments.

Les auteurs détaillent le framework progressivement même si l'application est déjà bien lancée au chapitre 3. Chaque partie est expliquée en détail mais pas trop. Je ne me lancerai quand-même pas dans la publication d'un composant sans y regarder à deux fois mais les principes et les bases sont évoqués.

Le chapitre sur Spring est bien présenté, on voit différentes façons de l'intégrer, y compris par les annotations. La partie sur « Aller en production » est vraiment intéressante car on y apprend que Wicket peut exposer des Mbeans pour se reconfigurer à chaud. Il est aussi expliqué comment tester ses composants et ses pages.

J'aurais aimé un chapitre sur les projets annexes que l'on retrouve côté Wicket Stuff.

Par exemple, dans le chapitre sur la sécurité, Acegi n'est pas évoqué. Certes c'est un livre sur Wicket, mais quelques paragraphes pour montrer les extensions annexes auraient été les bienvenus.

De plus, le livre ne revient pas sur les changements qui ont eu lieu au fil des versions. Pourquoi ne pas parler de Wicket 2 qui est mort-né ? Et Wicket 1.4, quelles seront les nouveautés ? Allez, je demandais juste un bout d'introduction. Cette version est à peine évoquée au fil des pages.

Le livre a répondu à beaucoup des questions que je me posais. Son spectre n'est pas très large (pas de Wicket Stuff) mais largement suffisant pour démarrer rapidement. Je le recommande à ceux qui veulent tester Wicket et se lancer dans leur premier projet.
Mais d'ailleurs, vous devriez déjà être sur Amazon pour commander votre exemplaire.

Retrouvez la critique originale (et complète) ici
Critique du livre par la rédaction fmorin le 1er novembre 2008
« Wicket In Action » ou comment mélanger la théorie et la pratique de façon agréable. Si vous souhaitez aborder le développement Web sous un nouvel angle, Wicket est la solution. Ce framework permet une réelle séparation de la partie HTML et de la partie JAVA. Cependant, l'approche étant fondamentalement différente, sur quel livre se baser pour réaliser l'apprentissage de ce framework ?

« Wicket in Action » livre publié chez Manning, sorti récemment, présente le framework avec beaucoup de pertinence, en ne sautant aucune étape, et en laissant encore un peu de travail au lecteur pour l'acquisition de certains composants.

Après une brève présentation du pourquoi, du comment, le livre s'attache à nous faire comprendre le fonctionnement intrinsèque du framework via une petite application Web (« Boutique de vente de Fromage ») mettant en ?uvre les concepts fondamentaux. Cette approche très pragmatique du sujet permet au lecteur de comprendre en douceur le raisonnement qu'il devra acquérir pour réaliser lui-même des services. La présentation pas à pas des différents composant de l'application, de la méthode de mise en ?uvre, et de la manière de séparer visualisation pour un graphiste et intégration pour un développeur, donne indéniablement envie d'en savoir plus.

Les chapitres suivant permettront d'approfondir les sujets, parfois abordés rapidement au cours de l'exemple (comme la notion de modèles), via une judicieuse montée en puissance, pour finir par l'intégration de composants Ajax dans les pages. Tous les composants de Wicket ne sont pas détaillés laissant au lecteur le plaisir de chercher pour voir plus loin.

Ce livre est écrit en autre par Martjin Dashorst, un collègue de Jonathan Locke (créateur de Wicket), qui connait très bien le sujet pour avoir travaillé sur les toutes premières versions du framework, et qui participé aux orientations sur les concepts et développements.


couverture du livre Head First Servlets and JSP

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

Head First Servlets and JSP

de
Public visé : Débutant

Résumé de l'éditeur

Looking to study up for the new J2EE 1.5 Sun Certified Web Component Developer (SCWCD) exam?

This book will get you way up to speed on the technology you'll know it so well, in fact, that you can pass the brand new J2EE 1.5 exam. If that's what you want to do, that is. Maybe you don't care about the exam, but need to use servlets and JSPs in your next project. You're working on a deadline. You're over the legal limit for caffeine. You can't waste your time with a book that makes sense only AFTER you're an expert (or worse, one that puts you to sleep).

Learn how to write servlets and JSPs, what makes a web container tick (and what ticks it off), how to use JSP's Expression Language (EL for short), and how to write deployment descriptors for your web applications. Master the c:out tag, and get a handle on exactly what's changed since the older J2EE 1.4 exam. You don't just pass the new J2EE 1.5 SCWCD exam, you'll understand this stuff and put it to work immediately.

Head First Servlets and JSP doesn't just give you a bunch of facts to memorize; it drives knowledge straight into your brain. You'll interact with servlets and JSPs in ways that help you learn quickly and deeply. And when you're through with the book, you can take a brand-new mock exam, created specifically to simulate the real test-taking experience.

Édition : O'Reilly - 911 pages , 2eédition, 25 mars 2008

ISBN10 : 0596516681 - ISBN13 : 9780596516680

Commandez sur www.amazon.fr :

35.15 € TTC (prix éditeur 37.99 € TTC) livraison gratuite !
  • Chapter 1. intro and overview
  • Chapter 2. high-level overview
  • Chapter 3. hands-on MVC
  • Chapter 4. request AND response
  • Chapter 5. attributes and listeners
  • Chapter 6. session management
  • Chapter 7. using JSP
  • Chapter 8. scriptless JSP
  • Chapter 9. using JSTL
  • Chapter 10. custom tag development
  • Chapter 11. web app deployment
  • Chapter 12. Web app security
  • Chapter 13. filters and wrappers
  • Chapter 14. patterns and struts
  • Appendix A. Final Mock Exam
Critique du livre par la rédaction Eric REBOISSON le 1er septembre 2008
Comme l'explique la description du livre, sans Java côté serveur, eBay n'existerait pas...et donc pas possible d'acheter le poster de Farrah Fawcett qui vous plait tant. Voilà l'ambiance dans laquelle vous baignerez à la lecture de "Head First Servlets and JSP" : un contenu décalé (des images et dialogues amusants, etc.) par rapport aux ouvrages informatiques traditionnels, mais qui cache une pédagogie bien étudiée et qui fonctionne (je pense que tous les lecteurs de cette collection confirmeront).

Le but de ce livre est non seulement d'expliquer les techniques de développement orienté web avec Java (Servlets, JSP, taglibs...) mais surtout une préparation à la certification Sun Certified Web Component Developer Exam (SCWCD) dans sa version pour J2EE 1.5 : chaque chapitre est ainsi ponctué d'un mini examen, et à la fin du livre un dernier pour vous tester véritablement.

Les trois auteurs sont très qualifiés sur le sujet puisque Bryan Basham a participé à la conception de la SCWCD, Bert Bates quant à lui, a oeuvré pour la Sun Certified Business Component Developer et enfin Kathy Sierra est fondatrice de javaranch.com et a participé également à la conception de la SCJP. Que du beau monde donc !

Et les trois auteurs se focalisent uniquement sur les sujets de la certification, vous garantissant la réussite de la certification avec tous les conseils prodigués dans l'ouvrage.

Je ne vais pas trop m'étendre et juste résumer la qualité de l'ouvrage en donnant la note maximale pour un livre qui vous apprendra tous les rudiments du développement web en Java, ou vous aidera à réviser pour passer la SCWCD. Un livre à acheter les yeux fermés !


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 Google Web Toolkit

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

Google Web Toolkit

GWT Java AJAX Programming

de
Public visé : Expert

Résumé de l'éditeur

This book is for Java developers who want to create Ajax interfaces using the Google Web Toolkit (GWT). It focuses on useful, practical tasks from the first chapter. The book is aimed at programmers who want to use GWT to create interfaces for their professional web applications. It concentrates on the serious side of Ajax: creating powerful, productive applications for browser platforms. GWT Ajax Programming shows you how to create reliable user interfaces that enhance the user experience.

GWT is an open source Java software development framework that makes writing AJAX applications like Google Maps and Gmail easy for developers who don't speak browser quirks as a second language. Writing dynamic web applications today is a tedious and error-prone process; you spend 90% of your time working around subtle incompatibilities between web browsers and platforms, and JavaScript's lack of modularity makes sharing, testing, and reusing AJAX components difficult and fragile. GWT lets you avoid many of these headaches while offering your users the same dynamic, standards-compliant experience. You write your front end in the Java programming language, and the GWT compiler converts your Java classes to browser-compliant JavaScript and HTML.

Plan your ECM installation, implement it, and customize it. Among the many topics covered are:

Set up an elegant GWT development environment in Eclipse
Create, test, debug and deploy GWT applications
Develop custom widgets - examples include a calendar and weather forecast widget
Internationalize your GWT applications
Create complex interfaces using grids, moveable elements, and more
Integrate GWT with Rico, Moo.fx and Script.aculo.us to create even more attractive UIs using JSNI

Each chapter covers a series of practical tasks, showing how to achieve a particular useful result - and then learn how it works so that you can apply your knowledge to your own unique situation. Readers will need experience writing non-trivial applications using Java. Experience with developing web interfaces is useful, but knowledge of JavaScript and DHTML is not required... GWT takes care of that!

Édition : Packt Publishing - 238 pages , 1re édition, 1er février 2007

ISBN10 : 1847191002 - ISBN13 : 9781847191007

Commandez sur www.amazon.fr :

35.54 € TTC (prix éditeur 35.99 € TTC) livraison gratuite !
  • Preface
  • Chapter 1: Getting Started
  • Chapter 2: Creating a New GWT Application
  • Chapter 3: Creating Services
  • Chapter 4: Interactive Forms
  • Chapter 5: Responsive Complex Interfaces
  • Chapter 6: Browser Effects with JSNI and JavaScript Libraries
  • Chapter 7: Custom Widgets
  • Chapter 8: Unit Tests
  • Chapter 9: I18N and XML
  • Chapter 10: Deployment
  • Appendix A: Running the Samples
  • Index
Critique du livre par la rédaction moritan le 1er mai 2007
Il s'agit d'un très bon livre d'introduction à GWT.
Il est bien écrit et didactique.
Je dois avouer que la structure des chapitres m'a d'abord déconcerté, chacun de ces chapitres est scindé en quatre parties:

  • Présentation
  • "Time for action"
  • "What's just happened"
  • "There's more / summary"


Le fait de commencer par réaliser le code puis ensuite de donner l'explication du code réalisé, peut surprendre mais finalement cela permet de ne pas réserver ce livre à un public restreint. Pour le débutant, le fait que le code soit clairement séparé des explications permet de se concentrer sur les faits importants et de ne pas se disperser entre le code et les explications.
Pour un lecteur expérimenté, cela permet de retrouver rapidement l'information recherchée ou de passer rapidement sur les notions qu'il maitrise.
La section "There's more /summary" est très intéressante, elle permet de voir les petits plus existants, et de recentrer les notions déjà vu.

La qualité du code donné, ainsi que les méthodes de réalisation fournies sont de très bon niveau.

Pourquoi ne pas mettre 5 étoiles ?
C'est un très bon livre d'introduction et d'aide mémoire, mais il n'est pas totalement complet.
Il manque pour moi trois notions pour qu'il soit complet.
D'abord un peu d'information sur les conventions de nommage, nottament pour les styles CSS.
Ensuite, l'utilisation du protocole JSON n'est pas abordé, ce protocole peut-être utile pour permettre de mélanger un application GWT avec un autre langage PHP par exemple.
Enfin, un exemple d'utilisation du framework GWT, avec un autre framework de type Struts, pour l'intégration avec des applications existantes.


couverture du livre Core JavaServer Faces

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

Core JavaServer Faces

de
Public visé : Débutant

Résumé de l'éditeur

JavaServer Faces is a Web application framework -- similar to Jakarta Struts -- that gives application developers access to custom components that facilitate the creation of rich user interfaces. JSF also provides Integrated Development Environment (IDE) vendors with a standard upon which to base their IDEs. In the Core tradition, this new book aims to be THE tutorial and reference for experienced programmers who need to learn this exciting new technology. Although J2EE is still the most popular platform for developing Web applications, Microsoft's .NET has gained market share over the past two years. J2EE is arguably more powerful, but .NET, is generally regarded as easier to use. J2EE currently lacks- a rich component model that makes it easy to develop custom components and an IDE (like Visual Studio) that facilitates Web application development. That's where JSF enters the equation, and this book aims to be the most authoritative treatment of the topic -- a must-have for any serious J2EE programmer.

Édition : Prentice Hall - 656 pages , 1re édition, 1er juin 2004

ISBN10 : 0131463055 - ISBN13 : 9780131463059

Commandez sur www.amazon.fr :

42.62 € TTC (prix éditeur 42.62 € TTC) livraison gratuite !
  • Preface
  • Getting Started
  • Managed Beans
  • Navigation (on the Prentice Hall site)
  • Basic Standard Components
  • Data Tables
  • Conversion and Validation
  • Event Handlers
  • Subviews and Tiles
  • Custom Components
  • Accessing External Services
  • Wireless Clients
  • How Do I...
Critique du livre par la rédaction Michel Blavin le 1er mai 2007
Ce livre est une merveille, il est à la fois précis et concis, détaillant chaque élément du framework sans se perdre dans de longues explications, tous les textes sont très courts et entrecoupés de code fonctionnel et réutilisable. Les codes et les erratas pourront être téléchargés sur le site du livre.

JSF est un framework qui a la réputation d'être complexe à appréhender au premier contact pour le novice. Vous pourrez grâce à ce livre prendre la main sereinement et developper rapidement des applications en profitant de la puissance et de la souplesse des JSF. Il est important de noter que l'on peut aborder ce livre sans avoir de connaissance particulière sur les JSP/Servlet, seule une connaissance de la programmation Java est nécessaire.

Tous les exemples de code sont complets, ce qui permet d'être opérationnel très rapidement. Et surtout ce livre sera une formidable référence à conserver sous le bras tout au long du développement. Je conseille la lecture de ce livre à toute personne aillant l'intention de développer des applications utilisant les JSF.


couverture du livre Enjoying Web Development with Tapestry

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

Enjoying Web Development with Tapestry

Put the fun back into J2EE application development

de
Public visé : Débutant

Résumé de l'éditeur

If you'd like to create web-based applications easily, then this book is for you. More importantly, it shows you how to do that with joy and feel good about your own work! You don't need to know servlet or JSP while your productivity will be much higher than using servlet or JSP directly. This is possible because we're going to use a library called "Tapestry" that makes complicated stuff simple and elegant.

How does it do that? First, it allows the web designer to work on the static contents and design of a page while allowing the developer to work on the dynamic contents of that page without stepping on each other's toes; Second, it allows developers to work with high level concepts such as objects and properties instead of HTTP URLs, query parameters or HTML string values; Third, it comes with powerful components such as calendar, tree and data grid and it allows you to create your own components for reuse in your own project.

How this book can help you learn Tapestry? 1. It has a tutorial style that walks you through in a step-by-step manner. 2. It is concise. There is no lengthy, abstract description. 3. Many diagrams are used to show the flow of processing and high level concepts so that you get a whole picture of what's happening. 4. Free sample chapters are available (online). You can judge it yourself.

It includes the following chapters: Getting Started with Tapestry, Using Forms, Validating Inputs, Creating an e-Shop, Creating Custom Components, Supporting Other Languages, Using the Table Component, Handling File Downloads and Uploads, Providing a Common Layout, Using Javascript, Building Dynamic Forms, Test Driven Development with HtmlUnit, Database and Concurrency Issues, Using Hibernate, Integrating with Struts.

Édition : Lulu Press - 495 pages , 1re édition, 1er avril 2006

ISBN10 : 1411649133 - ISBN13 : 9781411649132

Commandez sur www.amazon.fr :

31.06 € TTC (prix éditeur 31.06 € TTC) livraison gratuite !
  • Getting Started with Tapestry
  • Using Forms
  • Validating Input
  • Creating an e-Shop
  • Creating Custom Components
  • Supporting Other Languages
  • Using the Table Component
  • Handling File Downloads and Uploads
  • Providing a Common Layout
  • Using Javascript
  • Building Interactive Forms with AJAX
  • Test Driven Development with HtmlUnit
  • Database and Concurrency Issues
  • Using Hibernate
  • Integrating with Struts
Critique du livre par la rédaction joseph_p le 1er mai 2007
Kent Tong a une façon très didactique de présenter le framework Tapestry. Il explique les grands principes, montre leurs applications de façon générale puis donne des exemples précis et pertinents.

Dans son livre, il présente d'abord le fonctionnement intrinsèque de ce framework, puis montre des explications pertinentes d'intégration avec des framework tiers, tels Hibernate ou HtmlUnit. Cela permet donc vraiment d'aborder la conception de site web de façon globale. La pertinence est telle que j'ai réutilisé ces exemples d'intégration dans d'autres contextes. En effet, Kent Tong explique tant les détails de réalisation que la portée de ceux-ci avec clarté et précision.

A noter également que Kent Tong a régulièrement fait parvenir des corrections ou mises à jour de son pdf. Par exemple, la version que j'avais acquise l'année passée couvrait uniquement Tapestry 4.0. Puis Tapestry 4.1 est apparu, et peu de temps après Kent Tong a communiqué une version à jour de son livre couvrant Tapestry 4.1 (qui introduit des changements notables).

Au final, personnellement, c'est le meilleur livre d'introduction à un framework que j'ai vu jusqu'à présent.

NB : Je tiens toutefois à préciser que je n'ai pas retenu ce framework.

Kent Tong has a very didactic way of explaining the Tapestry framework. He explains the fundamental aspects behind the framework from a general point of view, and then provides very consistent and precise examples.

In his book, Kent Tong shows first the Tapestry framework and its way of doing things. Then he explains how to integrate the framework with others, like Hibernate or HtmlUnit. Thus, with this book, one can approach web design in all its aspects, which is fairly important. The interest of Kent Tong examples are such that I've used them in different contexts than Tapestry. Indeed, he explains both the details of the implementation as well as the impacts, all being done with clarity and precision.

Important to notice as well, Kent Tong has regularly provided updates or corrections of his book. For example, when I bought the book, only Tapestry 4.0 was covered. Then Tapestry 4.1 appeared. Short after, Kent Tong provided an updated version of his book covering Tapestry 4.1 (which introduces some fairly important changes).

Finally, personally, it's the best framework introduction book I've read until now.

NB : Just a last notice : eventually, I didn't retain Tapestry.


couverture du livre Sun Certified Web Component Developer Study Companion

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

Sun Certified Web Component Developer Study Companion

J2EE 1.4 (exams 310-081 and 310-082)

de
Public visé : Expert

Résumé de l'éditeur

This book is a study guide for any candidate preparing for the new J2EE 1.4 version of the Sun Certified Web Component Developer exam (310-081 and upgrade 310-082). It contains the theory behind why the Web container operates as it does, and important notes, hints and tips on the types of ?trick' questions to look for in the exam. By combining logical and easy-to-follow discussions with clear visual aids and diagrams, you will learn how the container works, and, by the end of the book, you'll be wondering why servlets, JSPs and tag libraries seemed so complicated before. By combining the theory taught in this book with practical experience, you will not only succeed in passing the exam, but will do so confident that you are able to solve problems and draw-up solutions ?on the job'.

Reference Material

Have you ever found that you couldn't quite remember the names of the XML elements or attributes in the Deployment Descriptor or Tag Library Descriptor, or perhaps you've had problems recalling custom tag life cycles? Not a problem! Helpful visual diagrams show ?at a glance' the important schemas, without having to resort to knowing the XML Schema or DTD languages, as used in the specifications.

Who is this book suitable for?

This guide is not intended as a beginner's book. It assumes prior, although basic, knowledge of J2EE, the Web container and the Extensible Mark-up Language (XML) core syntax. However, the thorough explanations presented in this book give excellent grounding in the subject, and a well-versed beginner or a quick-learner might be able to pick up sufficient knowledge of the Web container to actually pass the exam (no guarantees)! In addition, particular attention is devoted to the subjects of the Expression Language and custom tag libraries, both of which are new or have been significantly updated in the 1.4 version of the J2EE platform. No knowledge of either of these more difficult topics is assumed.

Additional Chapters

The two additional chapters present a summary of all the new features available in Java EE 5.0, including the platform's change of name! These are suitable for anyone already working confidently with J2EE 1.4.

Édition : Garner Press - 640 pages , 1re édition, 1er juillet 2006

ISBN10 : 0955160316 - ISBN13 : 9780955160318

Commandez sur www.amazon.fr :

29.99 € TTC (prix éditeur 31.06 € TTC) livraison gratuite !
J2EE Environment
  • Networks and HTTP
  • J2EE Architecture

Servlets
  • Servlet Basics
  • Servlet Contexts
  • Requests and Responses
  • Wrappers and Request Dispatching
  • Filters
  • Session Management
  • Application Deployment

JavaServer Pages
  • JSP Basics
  • JSP Documents
  • Expression Language
  • Standard Actions and JavaBeans
  • Tag Libraries and the JSTL
  • Custom Tags
  • Tag Files
  • Tag Deployment

Further Topics
  • Security
  • J2EE Patterns

Java EE 5
  • Servlet 2.5 and JSP 2.1 Changes
  • Unified Expression Language (EL 2.1)

APPENDICES
  • Exam Objectives
  • Mock Exam Subscription

Critique du livre par la rédaction vbrabant le 1er mai 2007
J'ai eu un coup de coeur pour ce livre concernant la certification SCWCD J2EE 1.4 (310-081).
Je pense que Charles Lyons a réussi quelque chose de magnifique avec ce livre.

J'ai beaucoup aimé son approche, très équilibrée, pour vous expliquer les choses. Il ne va pas vous expliquer le protocole HTTP dans tous les détails comme si vous deviez être un expert réseau, ni vous l'expliquer comme si vous aviez vécu dans le désert jusqu'à présent. Mais il va vous l'expliquer simplement, mettant l'accent sur les choses à retenir pour l'examen.
Les questions que l'on retrouve dans le livre (il y en a plus de 300) vous donnent une bonne idée de ce qui vous attends à l'examen.

Mais il y a également des bonus :

Ainsi, en plus du livre, vous avez également un "mock exam" en ligne, vous permettant de vous entraîner encore un peu plus.
Les deux derniers chapitre du livre vous expliquent également les modifications introduites avec Java EE 5 dans ce qui est Servlet 2.5, JSP 2.1, et EL 2.1.

Attention que ce n'est qu'un "Study Companion" pour ce qui est de la certification. Il n'est pas là pour remplacer les livres qui vous apprennent tout de A à Z. Il est là pour réviser quelque peu la matière et vous rafraîchir la mémoire sur les points importants pour l'examen.

Bien que ce livre tranche tout à fait, si on le compare avec l'approche choisie pas les auteurs de la série Head First de chez Oreilly, il a tout de même un style propre à lui qui le rend différent des autres livres que l'ont lit généralement sur les certifications.

Il m'a vraiment beaucoup plus.

Je lui donne 5 étoiles, car je pense qu'il le mérite vraiment. Et j'espère que vous partagerez également cet avis.


Responsables bénévoles de la rubrique Java Web : Mickael Baron - Robin56 -

Partenaire : Hébergement Web