- Tapa blanda: 432 páginas
- Editor: Lulu.com (5 de septiembre de 2012)
- Idioma: Inglés
- ISBN-10: 1300149310
- ISBN-13: 978-1300149316
- Valoración media de los clientes: Sé el primero en opinar sobre este producto
- Clasificación en los más vendidos de Amazon: nº298.405 en Libros en idiomas extranjeros (Ver el Top 100 en Libros en idiomas extranjeros)
Compara Precios en Amazon
+ Envío GRATIS
Real World Java EE Patterns-Rethinking Best Practices (Inglés) Tapa blanda – 5 sep 2012
Los clientes que compraron este producto también compraron
Descripción del producto
Reseña del editor
Real World Java EE Patterns - Rethinking Best Practices (http://realworldpatterns.com) discusses patterns and best practices in a structured way, with code from real world projects. The rewritten and re-edited version of this book covers: an introduction into the core principles and APIs of Java EE 6, principles of transactions, isolation levels, CAP and BASE, remoting, pragmatic modularization and structure of Java EE applications, discussion of superfluous patterns and outdated best practices, patterns for domain driven and service oriented components, custom scopes, asynchronous processing and parallelization, real time HTTP events, schedulers, REST optimizations, plugins and monitoring tools, and fully functional JCA 1.6 implementation. Real World Java EE Patterns--Rethinking Best Practices will not only help experienced developers and architects to write concise code, but especially help you to shrink the codebase to unbelievably small sizes :-).
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
- if are junior or less experienced developer, make it 4 starts (because you won't get like 50% of the book)
- if you are senior developer or architect, make it 5 stars (if you worked with previous J2EE versions and now working with Java EE, it's just must read)
- if you buy kndle version, make it 3 stars LESS (because it's rubbish, see bottom of this review)
Now, about the book. This book is set of various Java EE patterns and it rethinks fundamental ways how Java EE applications are developed. Book explains why some older patterns are discouraged now, or at least why there is no such need to use them anymore. Then book introduces plenty of new patterns, some are pretty cool - for example those that use interceptors in situations I would've never thinked of. And last, but not least, book describes plenty of migration strategies, like for example how to migrate EJB2 to EJB3 or how to migrate Guice/Spring DI components to EJB3.
It's quite hard though. I don't remember all the patterns now and I think I didn't even get them all. But at least if I ever hear something similar, I know where to look.
Warning: don't buy kindle version. I believe Adam Bien put effort in formatting code, but in Kindle version it is completely unformatted. It's just complete unreadable rubbish :( Amazon should never sell kindle versions like this!
I don't agree with everything the author says. For example, when he talks about SOA implementations, he only mentions REST services, but I've found that SOAP services are a better option for many applications. But the book has encouraged me to question many of my assumptions about Java enterprise applications, and I'm learning a tremendous amount.
It was amusing to see Spring and Guice referred to as legacy technologies now that Java EE 6 has arrived. I think this was mentioned only twice. This book is still very useful to Spring (and maybe Guice) developers since the programming model is practically the same as Java EE 6, and it is a book on design patterns.
This book is self published, and you can tell. There are some spelling mistakes, awkward grammar (the author is German), formatting issues, etc. The book was edited, but probably not by a technical person, so they left some things as-is because they didn't understand it. Since I found this book so helpful, these issues didn't really bother me. I just wish I would have highlighted each issue while reading so that I could mail it back to the author and have him send me a second edition for free.
On the negative side, I would mention rather frivolous use of technical words and English language in general, which complicates understanding. For example, the word "entity" is used in various meanings, sometimes for database row, sometimes for Java object. Or what could that mean: "Hence it is often used as a separation strategy to build independent design and developer teams" (p 71)? Such an inacurate language is acceptable in architectural meetings, where everybody is sleeping, but not in a textbook. The author should be more careful about his language.
The patterns are really practical. I have applied many of the patterns from this book in my applications, I also found I intuitively used a very similar approach on my own so some of them are very natural to me.
I'd give it 5 stars for the content alone.
The editiorial side of the kindle edition of the book is rather poor: there's a lot of linguistic errors, the code formatting makes its comprehension harder. Therefore 4 in overall.
I recommend it to JEE developers and junior architects.