• Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Gebraucht: Gut | Details
Verkauft von Warehouse Deals
Zustand: Gebraucht: Gut
Kommentar: Gelesene Ausgabe in gutem, sauberen Zustand. Seiten und Einband sind intakt (ebenfalls der Schutzumschlag, falls vorhanden). Buchrücken darf Gebrauchsspuren aufweisen. Notizen oder Unterstreichungen in begrenztem Ausmaß sowie Bibliotheksstempel sind zumutbar. Amazon-Kundenservice und Rücknahmegarantie (bis zu 30 Tagen) bei jedem Kauf.
Ihren Artikel jetzt
eintauschen und
EUR 0,30 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

Expert One-on-One J2EE Development without EJB (Englisch) Taschenbuch – 2. Juli 2004

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
"Bitte wiederholen"
EUR 27,95
EUR 24,94 EUR 0,79
44 neu ab EUR 24,94 10 gebraucht ab EUR 0,79

Wird oft zusammen gekauft

Expert One-on-One J2EE Development without EJB + Expert One-on-One J2EE Design and Development (Programmer to Programmer)
Preis für beide: EUR 79,46

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.

Geschenk in letzter Sekunde?
Amazon.de Geschenkgutscheine zu Weihnachten: Zum Ausdrucken | Per E-Mail


  • Taschenbuch: 576 Seiten
  • Verlag: John Wiley & Sons; Auflage: 1. Auflage (2. Juli 2004)
  • Sprache: Englisch
  • ISBN-10: 0764558315
  • ISBN-13: 978-0764558313
  • Größe und/oder Gewicht: 18,8 x 3 x 23,4 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (2 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 301.005 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr



"...practical and deep...you have to read if you have any interest in J2EE, with or without EJB..." (VSJ--Visual Systems Journal, December 2004/January 2005) "...a valuable learning experience all round" (Application Development Advisor, 1st September, 2004)


What is this book about? "Expert One-on-One J2EE Development without EJB" shows Java developers and architects how to build robust J2EE applications without having to use Enterprise JavaBeans (EJB). This practical, code-intensive guide provides best practices for using simpler and more effective methods and tools, including JavaServer pages, servlets, and lightweight frameworks. What does this book cover? The book begins by examining the limits of EJB technology - what it does well and not so well.Then the authors guide you through alternatives to EJB that you can use to create higher quality applications faster and at lower cost - both agile methods as well as new classes of tools that have evolved over the past few years. They then dive into the details, showing solutions based on the lightweight framework they pioneered on SourceForge - one of the most innovative open source communities. They demonstrate how to leverage practical techniques and tools, including the popular open source Spring Framework and Hibernate.This book also guides you through productive solutions to core problems, such as transaction management, persistence, remoting, and Web tier design.

You will examine how these alternatives affect testing, performance, and scalability, and discover how lightweight architectures can slash time and effort on many projects. What will you learn from this book? Here are some details on what you'll find in this book such as: how to find the simplest and most maintainable architecture for your application; effective transaction management without EJB; how to solve common problems in enterprise software development using AOP and Inversion of Control; Web tier design and the place of the Web tier in a well-designed J2EE application; effective data access techniques for J2EE applications with JDBC, Hibernate, and JDO; how to leverage open source products to improve productivity and reduce custom coding; and, how to design for optimal performance and scalability.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

In diesem Buch (Mehr dazu)
Like most of my colleagues, I was excited by the promise of EJB when it first appeared. Lesen Sie die erste Seite
Mehr entdecken
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:


5.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne
Beide Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

5 von 5 Kunden fanden die folgende Rezension hilfreich Von Stepan Samarin am 23. August 2004
Format: Taschenbuch
Latest trends in J2EE development found their reflection in this work of Rod Johnson. Being in the field for several years, I've found a lot of information, that would be simply invaluable in my next project. Rod questions the core concepts of middleware usage like transaction management with JTA and provides a clear overview of different ways of dealing with them. EJB gets its' deserved critique, and an explanation of why and when to use it is given to the reader. Dependency injection and AOP get their coverage: what is it, how it can be applied. Persistence techniques are also, of course, covered. Though, I can say, this book can be tough for the beginner in J2EE. But, for the seasoned professional, it's a box of gold. Highly recommended!
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
1 von 2 Kunden fanden die folgende Rezension hilfreich Von Patugo Gmbh am 13. März 2005
Format: Taschenbuch Verifizierter Kauf
J2EE is a complex tool to solve complex software problems. As such, it requires an inconvenient programming model at best. Rod understood very well that the deployment cycle necessary for J2EE applications is way too time-consuming to develop applications in a fast and test-driven way. He came up with Spring, a framework which supports a simplified programming model and enables developers to delay coupling of applications with heavy technology to a later stage.
This book gives a clear introduction to Ron's motivation to develop Spring and quickly jumps into solutions for problems which J2EE developers face regularly.
Although Spring constantly evolves, and there's more recent information on the Web site, I found this bool still a valuable resource.
J2EE development without Spring? Thanks, I've been there.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 31 Rezensionen
70 von 71 Kunden fanden die folgende Rezension hilfreich
A great book that is a must-read for every developer/archite 29. November 2004
Von Vinny Carpenter - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I've read this book several times since the day it shipped and I have to say that this is an excellent book for anyone working as a developer or architect working in the Enterprise Java arena. I absolutely love this book given my bias - I guess I should start by stating my bias. EJB bashing is a favorite past time of a lot of people. I happen to love EJB's, with the exception of entity beans and think EJB's are a great way to create software solutions are remotable, loosely coupled and powerful. I will agree that EJB's are way too complicated with all the stupid artifacts that you need to create to create and deploy an EJB. Having worked with EJB's since 1999, I guess I am so used to all of nuances of EJB's, I can write up deployment descriptors in my sleep. Having said that, I approached this book with a little apprehension as I hate these EJB-sucks book that don't really offer any intelligent discussion about the shortcomings of EJB nor do they offer a viable alternative. Another assumption I brought to the book was that this was just a Spring book with a little EJB bashing thrown in for good measure.

To my pleasant surprise, Rod Johnson and Juergen Hoeller have written an awesome book. This book does not take cheap shots - Instead there is a intelligent, thought provoking discussion about the pros and cons of EJB. In fact, the first 120 pages (Chapter 1-5) are just a great breakdown of application architecture with a through treatment of EJB. I loved this section and re-read it several times and I found myself agreeing with pretty much everything in this section. I would equate this to a great meaningful discussion you would have with someone who really understood application architecture and development and you could debate the pros and cons of the many alternative approaches that exist today.

Chapter 6 starts the discussion of Lightweight Containers and the idea of Inversion of Control (IoC). This is not a chapter on Spring; rather it is an overview of Inversion of Control and strategies like Dependency Injection in the context of Spring and PicoContainer.

The next chapter offers a quick introduction to the Spring Framework. As everyone already knows, the Spring Framework is a very popular open source application framework created by Rod Johnson. The co-author Juergen Hoeller is another lead developer of Spring. The chapter is Spring is fairly light and people hoping for a in-depth Spring tutorial will be disappointed. Instead this chapter offers a rather high-level overview that will get you some basic understanding of the Spring Framework. I guess it's hard to cover Spring in 43 pages.

After the cursory introduction to Spring, the book moves into Aspect-Orientated programming (AOP) concepts. This section starts with a very introduction to AOP before jumping into AOP implementation strategies. After a brief discussion of AspectJ, AspectWerkz, and JBoss AOP, the authors move into SpringAOP. After AOP, the books moves into Transaction Management where current J2EE approaches are discussed and then contrasted with the Spring approach.

Review trimmed to comply with Amazon's review guildlines for length. For more details, check my blog at j2eegeek dot com.
51 von 52 Kunden fanden die folgende Rezension hilfreich
Highly needed myth buster! 17. Juli 2004
Von Edmon Begoli - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
Rod Johnson is doing a great service to the J2EE technical community with his books. This latest book is definitely a myth buster, that I was personally looking for.
I will tell you right away that this is not an anti-EJB book
that tries to prove you a case against EJBs. This is not a
cheap "Spring" framework promotion book either. This is a very mature expert one-on-one advice that is well worth getting.
Rod gives you a nicely rounded manual how to architect solid J2EE application using the latest and greatest practical solutions available both through the open source and JSR community. He propagates two extremly important ideas:
Lightweight containers and (simplified) Aspect Oriented Programming. Moreover, ha makes a very strong case for the application of Inversion of Control principle (IoC) in your applications. If you are not familiar with IoC: I see it pretty much as a savior to a J2EE technology. J2EE grew incredibly big, complex and fluffy in the recent years, and is at risk of being outflanked by more simplistic .NET solutions.
IoC offers "back to basics" approach where you as a good OO architect focus on the solid business domain model without poluting it with the infrastructure code. Through IoC supporting methods (such as Aspects) you then externalize the infrastructural pieces (transactions, pooling, persitence, logging, auditing,...) that make you apps run in the enterprise environement.
Rod's book gave me a very good basis for the creation of my own state-of-the-art J2EE solution and I am grateful for it. It is the best thirty-some dollars that I spent in the long time.
One more thing, this book in NOT a re-write of his previos book "J2EE Design and Development". I have both and they are not the same. I think you have to have both on your bookshelf in order to get the full treatment.
17 von 17 Kunden fanden die folgende Rezension hilfreich
Extremely well done 6. Juli 2004
Von Robert Patton - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This book builds a great case for an EJB-less architecture, the arguments and points are layed out very carefully and very well. A different architecture is presented, with plenty of help on how to get the benefits of an EJB container without the pain. Unlike many other books in which the author seems to hope you will take his or her advice simply because it is in print, Johnson and Hoeller back everything up. The book flows well, and contains very few mistakes that I have noticed (and those were very minor editing slips). I hope to see more from these authors. In the meantime, I guess I can chuck all those EJB patterns books on the shelf and just put this in there...
19 von 21 Kunden fanden die folgende Rezension hilfreich
Practical approach to J2EE 30. Juli 2004
Von Aleksandar Seovic - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This book is a gem. Authors cover extremely well number of subjects that J2EE application architects have to deal with every day. They do not only describe problems associated with 'classic' J2EE architectures and innapropriate use of EJB, but also present very elegant solutions to them.

Chapters 1 and 2 explain why 'EJB does not equal J2EE' and why it is not appropriate for many applications. They also cover developer productivity issues when using EJB and explain why object orientation shouldn't be sacrificed so easily. There is also a section on 'phantom requirements', that architects often introduce into the system in order to boost their own egos, even though there are no real business requirements to support that decision.

Chapter 3 compares various J2EE architectures using several widely available sample applications, while Chapter 4 covers the importance of simplicity in application architecture and design. In addition to technical reasons for unnecessary complexity in many J2EE application, authors cover something that is not addressed very often -- cultural reasons for complexity. Everyone who worked on a large project will be able to relate to at least some of the problems described and get some consolation from the fact that he's not the only one dealing with such political bs.

Chapter 5 looks at EJB in retrospective and describes where it failed, where it succeeded, what we want and what we don't want from it. It also touches on EJB 3.0 and why it will be 'too little, too late'.

Chapter 6 describes concepts of Lightweight Containers and Inversion of Control (IoC). It explains why we need containers, what their advantages over EJB are and how they enable clean separation of interface and implementation. Various IoC (or Dependency Injection) strategies are described, as well as their implications on coding style, testing and development process.

Chapter 7 introduces Spring Framework, that will be used to implement replacements for various EJB features throughout the rest of the book. It covers basic Spring concepts, such as Bean Factory, Application Context and Resources and lays a solid foundation for the rest of the book.

Chapter 8 provides an excellent introduction to Aspect Oriented Programming (AOP), describes various AOP implementation startegies and explains how AOP is implemented and used in Spring.

Chapter 9 builds on previous chapter and shows how declarative transaction management can be handled using Spring's AOP implementation. This chapter is one of the places where Spring's flexibility and configuration really shine, with authors showing how application can be scale to use JTA transactions instead of local transactions by simply modifying configuration file. Extremely cool stuff.

Chapter 10 continues to impress the reader, by showing how several different persistence technologies can be used within Spring and how much Spring simplifies their usage. It also explains why and how data access technology should be chosen at the beginning of the project based on application requirements, and why it is usually not worth the effort to design portable DAO interfaces.

Chapter 11 explains how Spring can be used to both simplify access to remote objects and to expose business interfaces as remote objects. Technologies covered are RMI, EJB, JAX-RPC and Caucho's Hessian and Burlap.

Chapter 12 addresses other EJB services, such as thread management, instance pooling and declarative security and explains why they are not always as good or necessary as people believe them to be.

Chapter 13 takes us through web tier design, explains MVC concept and shows how various popular MVC frameworks (Struts, WebWork2 and Spring web MVC) can be used in conjuction with Spring to build web applications. This chapter is probably the only one I am not completely satisfied with. While it does show how to use different frameworks with Spring, it doesn't have a single example of how data binding between web forms and command objects is defined. On the other hand, book is not about Spring web MVC, but about replacement for various EJB fetures. My opinion is that this chapter could easily be expanded into a book on its own, that would walk reader through the whole process of building a typical Spring web application (hopefully something more realistic than JPetStore sample).

Chapter 14 covers unit testing and TDD. It is one of the best introductions to TDD that I have seen and contains a number of very practical advices for different testing scenarios, including how to make application more testable, when and how to use stubs and mock objects, etc.

Chapter 15 addresses performance and scalability, again from a very practical point of view. It covers architectural choices that can significantly impact performance, application tuning, benchmarking and profiling among other things.

Chapter 16 puts many of the previous topics together and improves iBATIS JPetStore application by implementing Spring middle tier, Struts and Spring web tiers, and exposing remote services using Spring. Overall, not a very exciting application to look at, but it does show how various pieces of the puzzle fit together and how easy it is to integrate various MVC, view, persistence and remoting technologies into Spring applications.

Chapter 17 wraps things up and provides a valuable set of guidelines for architecture in general, programming style, IoC, AOP and testing.

Overall, I was very impressed with the authors' topic coverage and no-nonsense approach. I do not agree with the comment that 50% of the book is rehash of J2EE Development and Design and other 50% is in Spring Reference Guide. While this book does refer to J2EE D&D in many places, it reads more like a sequel to it, with author's updated thoughts on many topics. Things that are repeated are the ones that should probably be repeated in *every* book on J2EE architecture and design.

At the same time, this book is very different from Spring Reference Guide because it does not really focus on Spring features and APIs per se. It does cover much of Spring, but in a very different context, showing how lightweight framework such as Spring can be used to easily replace EJB features that many people think would be hard to replace.

Objection could be made that book is strongly biased towards Spring, but in reality, only Spring offers complete replacement for all the services authors describe in the book. While there are other solutions to individual problems (and authors do mention them and give credit where it's due), only Spring offers all of them as a one-stop-shop. That, and a fact that authors are leads for the Spring Framework, more than justifies use of Spring throughout the book.
17 von 19 Kunden fanden die folgende Rezension hilfreich
Enterprise Java Architects: Buy This Book 1. August 2004
Von cassian78 - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
My love affair with Java has lasted six years now. With enterprise architecture being the way to go, I've been reading about J2EE development using EJB for several months, trying to get my head around why simple things are made so hard using EJB. I was dreading training my developers in Java, and then having to show them EJB and figure out ways to help them be productive.

This book (and the Spring framework) are the light at the end of the tunnel. The concepts are grounded in commonly accepted best practices for application development, the arguments for the implementations chosen are sound, and the implementations themselves are simple and fast. Not to mention, the entire framework has been designed so that you can drop it at any moment and move on to the next big thing when it arrives. Try getting that out of an EJB implementation.

Spring has given me hope for enterprise Java development. If you are at all interested in simplifying your life as a Java developer and have become disillusioned or disappointed with EJB, then this book is a must have.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.