Expert One-On-One J2EE Development Without EJB

by Rod Johnson, Jürgen Höller, Jürgen Höller, et al.

What is this book about?

Expert One-on-One J2EE Development without EJB shows Javadevelopers and architects how to build robust J2EE applicationswithout having to use Enterprise JavaBeans (EJB). This practical, code-intensive guide provides best practices for using simpler andmore effective methods and tools, including JavaServer pages, servlets, and lightweight frameworks.

What does this book cover?

The book begins...

• Format: Paperback
• Language: English
• ISBN: 0764558315
• ISBN13: 9780764558313
• Release Date: June 2004
• Publisher: Wrox Press
• Length: 552 Pages
• Weight: 1.95 lbs.
• Dimensions: 1.2" x 7.4" x 9.2"

Customer Reviews

Enterprise Java Architects: Buy This Book

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.

Practical approach to J2EE

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 technolo

Highly needed myth buster!

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 bookthat 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.

Extremely well done

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...