- Tapa blanda: 436 páginas
- Editor: Packt Publishing (8 de junio de 2011)
- Idioma: Inglés
- ISBN-10: 1849682380
- ISBN-13: 978-1849682381
- Valoración media de los clientes: Sé el primero en opinar sobre este producto
- Clasificación en los más vendidos de Amazon: nº1.060.091 en Libros en idiomas extranjeros (Ver el Top 100 en Libros en idiomas extranjeros)
Compara Precios en Amazon
+ Envío GRATIS
Ejb 3.1 Cookbook (Inglés) Tapa blanda – 8 jun 2011
|Nuevo desde||Usado desde|
Los clientes que compraron este producto también compraron
Descripción del producto
Reseña del editor
Each recipe comprises step-by-step instructions followed by an analysis of what was done in each task and other useful information. The book is designed so that you can read it chapter by chapter, or look at the list of recipes and refer to them in no particular order. It is packed with useful screenshots to make your learning even easier. The book is aimed at Java EE and EJB developers and programmers. Readers should be familiar with the use of servlets in the construction of a web application. A working knowledge of XML is also desirable.
Biografía del autor
Richard M. Reese holds a Ph.D. in Computer Science from Texas A & M University and is currently an Associate Professor in the Department of Engineering and Physics at Tarleton State University in Stephenville Texas. In addition to his experience in academia, Richard has over 16 years of experience in industry including operating system development at GTE Automatic Electric Labs and at Lockheed Martin in Fort Worth, Texas where he supervised a tool development group and oversaw various research and development projects. Prior to his industrial experience he served 4 years in the United States Air Force. Richard first worked with EJBs as a consultant/instructor of software languages in private and public classes providing him with a variety of insight into industry applications. He has published numerous papers and has developed courseware for a variety of topics including advanced Java technologies.
No es necesario ningún dispositivo Kindle. Descárgate una de las apps de Kindle gratuitas para comenzar a leer libros Kindle en tu smartphone, tablet u ordenador.
Obtén la app gratuita:
Detalles del producto
Si eres el vendedor de este producto, ¿te gustaría sugerir ciertos cambios a través del servicio de atención al vendedor?
Opiniones de clientes
|5 estrellas (0%)|
|4 estrellas (0%)|
|3 estrellas (0%)|
|2 estrellas (0%)|
|1 estrella (0%)|
Opiniones de clientes más útiles en Amazon.com
organized around so called recipes - short (no more than three pages long) micro-chapters focused on one specific issue. This is the most advantageous feature of this publication: all recipes all self-contained most of the time, so one can jump between them and apply the most suitable in given scenario. This makes the book suitable for both the beginners, which should read it from cover to cover and slightly more experienced developers. However the latter ones will probably prefer more comprehensive sources and skip significant parts of the book.
Although I found the book structure very convenient, contents (both granularity and volume) are highly subjective and controversial. On the one hand the author devotes five recipes to describe separately each JMS message type (string, byte, stream, map and object) - each one is almost identical. Whilst he could only list different types, he fills half of the JMS chapter this way (sic!) On the other hand, there is only one recipe explaining new JPA 2.0 Criteria API - to make matters worse, only using weakly typed queries. Probably one of the most important new features in EJB 3.1 stack has been covered on two pages. And this API is not particularly easy to grasp. To depict you the scale - the art of adding Bean Validation annotations (@NotNull etc.) on fields required ten pages and eight recipes... Where a half-page bullet-list would suffice.
The last chapter - EJB Techniques - is very intriguing. Lots of valuable and accurate tips have been given, like the difference between Date and Calendar, logging and dealing with exceptions, effective String manipulations. Despite appearances, this is not the basic Java knowledge and many experienced programmers still don't know that SimpleDateFormat is not thread-safe and that Date class does not store time zone. I am really happy that this kind of knowledge found its way in the book. Unfortunately - in the wrong one. That being said, there are more appropriate books, not focused on EJB or even Java EE. Here it just looks like putting anything useful to reach dozen chapters in total.
There are however bright sides as well. I particularly enjoyed Transaction Processing and Interceptors chapters. In the former one the author briefly but succinctly explains different transaction propagation and error handling behaviours, very important topics. Table on page 210 captures the essence of transaction demarcation in few simple rules, brilliant in its simplicity. In the interceptors chapter the recipes are focused on typical cross-cutting concerns, forming handy starting point. Also pretty informative.
When in comes to code examples and use-cases, they were generally interesting and well thought. Nevertheless, I am still awfully confused after reading a recipe on @Singleton: "We will assume that our game will never have more than one player so a singleton is an appropriate choice " - says the author to justify the usage of singleton to store user attributes. Yes, I think we are all using Enterprise Java Beans and Application Servers to develop systems that would never have more than one user at a time... (Hint: statefull session bean) The same thing with the usage of Facade pattern throughout the book. First the author quotes the exact definition of this design pattern and then names a class wrapping EntityManager and providing convenient, strongly typed create(), remove(), findAll(), etc. - PatientFacade. No, this class is not hiding the complexity of Patient entity, and all programmers all over the world would call this abstraction a Repository or DAO. Not here.
By the way in the same recipe one-to-many relationship is introduced between a patient and medication, where clearly many-to-many is required. Curiously enough, in the next recipe DISTINCT SQL statement is used to filter out duplications that have appeared due to denormalization. Well, if the database was designed properly, there wouldn't be any duplicates on the first place... After all these misleading and sometimes harmful advices, typos and errors in source codes (ClassNoDefException? - never heard of it...) are not that irritating.
In conclusion, despite all the deficiencies and inconsistencies, I mostly enjoyed reading this book. Once again I will highlight the very elegant chapter-recipe structure and the fixed layout inside each recipe. I believe it is suitable for people that suddenly inherited an EJB application and need an immediate help and suggestions. However on the long run, they should invest in more comprehensive publication. Few years back I managed to pass SCBCD exam (EJB 3.0 by that time) after reading Enterprise JavaBeans 3.0. With the book in question it would be virtually impossible. If you need a quick and dirty, yet entertaining source of ready solutions, go ahead. Otherwise, definitely look for something broader and less verbose.
The book is a compilation of, what the author called, recipes. All the receipts meant to create a cookbook, and while they were "simple", they weren't "incredibly effective", quoting from the book's front cover.
I assume cookbooks are meant like this - they provide recipes, and while you may find out how to achieve a goal, you won't find out whether it's the most effective or appropriate in a given scenario. You find no answers on why it's done that way or why it was possible at all.
According to "Who this book is written for" (see the book's website or the closing cover) "the book is aimed at Java EE and EJB developers and programmers." I could hardly disagree with that general and vague description - it says nothing about their experience that I believe is crucial for this book to shape expectations before giving the book a go.
I don't think it aims at people who are just starting their journey into EJB 3.1 and/or Java EE 6 as there's too much loosely placed explanations of different approaches and one has to be very careful not to follow the recipes in their entirety.
On the other hand, I doubt that it aims at developers who have already spent some time with EJB 3.1 (where I belong to), either - it's too basic and clattered with servlets as the way to showcase the EJB 3.1. There's, however, no recipe with EJB beans bundled in a WAR. That would greatly have eased a few recipes and, moreover, ditch a couple of pages. I'd rather avoid using servlets for every sample, especially where there's more servlet/HTML code than EJB one. It's not uncommon.
I'm thus troubled to clearly point out who the book is really aimed at. Many pages cover basic Java programming material (it's clearly visible in chapter 12 "EJB Techniques" where java.util.Date/Calendar, java.util.logging and String manipulation are presented, or when @Override on page 10 is explained), whereas there are pages with more advanced EJB 3.1 concepts - timers, transaction, security or interceptors. Glancing at the table of contents it's easy to get deceived into thinking the book will cover a lot of advanced stuff, but it doesn't take long to realize that the table of contents looks promising, while the material covered is not as intensive as it may have been considered.
The book uses NetBeans 6.9.1 and GlassFish 3.0.1, but they're almost invisible as the topics don't touch too many container- or IDE-specific aspects. Just a few pages should not spoil the book for readers who use other tools (provided the other shortcomings did not already).
Unfortunately, it's easy to find a typo in the text or the code snippets. The editing process leaves much to complain about.
Sentences like "Mozilla Firefox or Google Chrome can be used to display the output of servlets" (page 3), "Message sent successfully", "Message sent successfully2" (page 21), or explanation of how the jar tool works (in chapter 11, pp. 345-351) are, say, how the book is written - there are 400 pages yet 100 would make it a better reading.