Customer Reviews

J2EE Applications and BEA WebLogic Server (2nd Edition)

5 star:		(12)
4 star:		(8)
3 star:		(13)
2 star:		(6)
1 star:		(5)

 

 

The title of the book is the immediate draw. I purchased the book online and read thru it this weekend. Upfront, I'd like to say that this book covers J2EE in a survey format. They touch on all of the major topics but they don't drill down. So if you need in-depth coverage on each J2EE technology then you will be better buying a different book. However, the book does show some nice feature of using the Weblogic security API and connection pooling.

One thing that I immediately noticed were the large amount of blatant typos. Some of the source code examples are totally incorrect. For example, in the JSP chapter, they have a discussion on handling exceptions with an error page. The JSP code example uses: <%= exception.printStackTrace(); %>. This code will not compile since the authors incorrectly used a JSP expression.

The authors of the book did a very good job at explaining EJB. They devoted three chapters to it w/ explanations of Session and Entity beans. The coverage of Message Driven beans was okay...however, they didn't mention the use of selectors w/ Message Driven Beans.

It seems that the authors strength is EJB and not servlets/JSP. The servlets and JSP chapters were extremely weak. If you need to learn servlets or JSP then you will be better off buying a book that focuses on servlets and JSP. The information contained in the book could easily be picked up in an on-line tutorial or magazine article.

I was a bit surprised that they didn't use the MVC architecture for the Auction application. Instead, they made use of JSPs and custom tags. Since they presented a large number of best practices in the book, they didn't follow one of the leading best practices for web app development...and that's the MVC pattern.

I expected to see portions of the WebAuction application developed in each chapter along w/ design and source code. However, each chapter ended w/ a paltry 1-2 paragraph description of the WebAuction component(s). This description didn't contain any source code or UML diagrams. In fact, the full source for the WebAuction application was never completely presented in the book. The authors simply referred you to the CD.

The contains a large number of best practices. Most of them were useful. However, a couple of them were either simple-minded or totally unsupported. Here's an example of a best-practice that was listed in the JMS chapter:

"Use selectors that only examine message header fields. A selector that examines message properties will be slower, and examining the message body produces the slowest message selectors".

The authors do not provide an supporting data for the selector performance. How about some numbers? Also, the piece about examing the message body...well you can't create a selector that examines a message body. The JMS specification states the selectors only work on the JMS headers and properties.

Those are some of my big comments. I made note of a lot of others but I'm running out of breath now.

I'd recommend that you skim thru the book at a bookstore before you buy it.

There are a lot of really good books out there dealing with J2EE technologies such as EJB, Servlets/JSP, JMS, etc.. (Like the O'Reilly books). But we didn't have a good book that put it all together in context of the WebLogic Application server, until now.

I wasn't sure what to expect when I started reading this book. Michael Girdley and Rob Woollen are very smart people and people that spend any times in the WebLogic newsgroups know how smart these guys really are. I wasn't sure if that would translate to their writings -- It does. This is a very nicely written book that goes through Servlets, JSP, JDBC/JTA, JMS, RMI, EJB's including Message Beans and WebLogic specific configuration options including clustering and failover.

I think this is a great book for beginners as well as advanced users as it is a reference and `step-by-step' tutorial rolled in one. One of my favorite things about the book is that each chapter is embedded with 'best practices' that contain a lot of useful gems, especially for more advanced users that just skim through the book.

The final chapter of the book puts everything that you've learned from the previous chapters together into a complete J2EE application. The sample application, which is included on the CD is a Web-based auction system. A must-read for anyone that wants to learn everything they need about J2EE.

"J2EE Applications and BEA WebLogic Server" by Girdley, Woollen, and Emerson, is a book that I had been waiting for. "Professional J2EE Programming with BEA WebLogic Server" by Gomez and Zadrosky kept me hungry for the `beef', and I knew that Woollen is one of the good answerers on the BEA newsgroups. It's a fat book of 15 chapters in over 600 pages plus CD, covering all the J2EE technologies. It begins with an overview of J2EE technologies, and then goes thru each of them: servlets, JSPs, JDBC, RMI, JNDI, JMS, EJB 2.0, JavaMail, and security, followed by two chapters on production deployment and capacity planning, and one outlining an example application, a web auction. Each of the J2EE technology chapters presents some small programs illustrating the technology, followed by some advice for design decisions. There are some WebLogic-specific topics like clustering, entity locking, and the WebLogic security service, but in the main the material is not specific to a J2EE product.

The strategy of using small disconnected "Hello World" programs to illustrate each of the technologies is good. Other books reject that strategy because such programs are not realistic. Those books are not readable selectively. In addition to the small examples, this book also has a larger, more realistic example. A separate chapter is devoted to it and it's on the CD.
Practical examples illustrate common tasks such as login verification. Throughout the book, the authors highlight tricks and unobvious traps.
I am happy to see the two chapters on deployment and about capacity planning. These are important topics that are frequently ignored or neglected. This information cannot be learnt from reading the J2EE specs and mustn't be left to guesswork.
The best area of the book are the chapters about EJBs. They explain the standard EJB behaviour, and the extra WebLogic functionalities like clustering and the use of WebLogic CMP. I appreciate practical advice that goes beyond what the spec says, for example how to write primary key classes, and how to use read-mostly entities.

Unfortunately, one wishes some content and its presentation were better. The presented technologies are not motivated enough. Before I read how to program a servlet, I want to know why I want to program a servlet.
The book does not compare and criticise the technologies enough. It should compare and criticise choices like basic athentication, form-based authentication, or certificate authentication for web access. It is not enough to say how to program them.
The book uses very few diagrams, and no UML at all! Concepts like the relations between the three or more interfaces and classes that make up an EJB can be presented so much clearer by just a few small pictures. It's obviously not a question of space: we see many superfluous pictures of DOS consoles executing deployment scripts.
The few diagrams in the book have several errors. For example in the deployment chapter, they contradict the text and therefore confuse. The diagram on page 568 gives "code" as the first stage in J2EE application development. Sigh.
The quality of the technical writing in this book is variable.
Don't read the JSP Chapter. If I didn't know how JSPs work already, I'm not sure I would have understood it from this chapter. There's grammar without definitions, like "import= " { package . class | package .* } , ... "". I could not guess what that is supposed to mean. The deployment descriptors are partly wrong. Class names are badly formatted. There are sentences like "out is a subclass of ..." --- it's not a subclass, it's an object of course. While it may seem fussy of me to criticise the wording at this level, this level is exactly where the reader spends unnecessary effort. An inexperienced reader may misunderstand the sentence completely. The chapter does not explain clearly what a JSP is and how it is executed. The chapter has become superfluous: Those readers who are able to understand it already know its contents.
There is a lot of badly formatted and incorrect code in this book. I won't go into details, except to mention the ridiculous pages 454/455 where we are surprised with:
abstract "C:\WINNT\Profiles\michaelg\javax\mail\Address.html" [] "C:\WINNT\Profiles\michaelg\javax\mail\Message.html" \l "getFrom()" () Returns the From Attribute.
It was supposed to be a repetition of the JavaDoc of javax.mail.Message, so it is superfluous anyway. In any programming book, the code has to be correct and it has to be beautiful, even more so than the narrative text.

Who should buy this book?

If this is your first book on J2EE, you'll be partly confused by it. As a beginner's intro to J2EE it is not detailed enough, and not pedagogical enough. If you read this after a J2EE tutorial and together with the specs and the WebLogic online doc, you'll gain quite a bit from it. If you're looking for critical assessment of J2EE helping you to decide on technical questions like which transaction isolation level to set, whether to use stateful session beans or HttpSession attributes, you'll find some help in this book. Maybe not as much as I had hoped for. If you want specific hints and tricks about using WebLogic: the book has little more than BEA's generally good online documentation.

Verdict

Many weaknesses can easily be fixed in a corrected edition. The next edition must eliminate the typos and add diagrams. The book has good parts, but it could have been a lot better. Of course many WebLogic developers will buy it regardless!

I've been developing with Weblogic since back in the Tengah 3.1 days, and I wasn't sure how much I would get out of another J2EE book. However, I definitely learned a lot from this book.

The best part about this book are the best practices sections in every chapter. I really found these to be valuable. I've been porting my application to Weblogic 6.1, and these really helped me out.

I also liked the sections on performance tuning and capacity planning.

I agree with most of the reviewers who gave this book a 4-start rating. In spite of the obvious weakness in covering servlets and JSP's, it nevertheless does an excellent job discussing various aspects of developing and deploying EJB's with WebLogic Server 6.0, which for most part is what WebLogic Server is meant for (for pure servlets and JSP work, I'd rather save some money by using JRun, Tomcat, or Resin, don't you agree?). For intermediate and advanced EJB programmers, you should be quite happy to see some of the intricate points in designing and fine-tuning entity EJB's are covered here. As with some of the earlier reviewers, I would also like to draw your attention the "Best Practices" sections in many of the chapters. These are real-world experience given by BEA insiders that you typically don't get in general EJB texts.

The WebAuction sample app also adds value to the book by nicely tying all concepts (JSP, custom tags, all flavors of EJB's, JMS, and JavaMail) together. Even though it doesn't demo how to use a MVC framework in the web-tier and does not use the local interface features in the EJB-tier, and the Java classes' package hierarchy is a bit simplistic, the application is quite well architected, In fact, I was able to modify it easily by incorporating the Apache Struts framework and changing to local interface for all EJB's.

To sum up, the book is definitely valuable to people who moved to WebLogic from another app server, and to those who are moving from EJB 1.x to 2.0, in addition to serving J2EE/EJB "newbies".

I am working through this book currently. and have the following observations:

Generally I am spending the bulk of my time with this book sorting out problems with setting up the examples. Generalized troubleshooting in other words. Once I sort out the problems, understanding the examples is relatively simple.

This is both good and bad. I am certainly learning the details of how Weblogic 6.0 works very well, at the cost of a lot of additional effort on my part. At the same time that effort is going to make it difficult for everyone buying this book to get full use out of it.

The books authors intend to put up a book-specific website with an FAQ. I highly recommend they do this soonest, as this could well save readers a lot of time. The solutions to the problems are simple once you work them out, but the working out is taking a lot of time.

The EJB sections are excellent and largely bug-free.

The book needs a more complete explanation about licensing and getting the Weblogic Server running correctly. This was a major hangup to a newbie.

The JSP example in Chapter 4 was flawed and required troubleshooting to make it work. This is problematical for an entry-level text.

The example in the JSP chapter (chapter 7) also lacked complete setup instructions for setting up a JMS Server. This required

This book is very well done. In reading through, I'm most impressed by the co-mingling of J2EE with WebLogic. As a WebLogic developer, it is a must because of the Best Practices. Any one of these can save hours of trials and tribulations. While I have learned many of these through direct work with WebLogic, it would have been amazing to have them all in a single book when I first started, as is provided here. Invaluable.

This book covers topics for beginner J2EE developers which are covered better in books on those topics. JSP and servlets for example are well represented in depth by other books. So why cover these and other topics that are not really specific to the WebLogic server? Sure there are some differences in how WebLogic implements some of these features but it's easily learned through the documentation. What's really needed is a detailed analysis of WebLogic server with reasonably complex examples that are thoroughly explained.

The workbook style of the book with step by step instructions to complete the examples, DOS Windows showing the results of running simple DOS batch file or directories again illustrates the beginner level of the book. I mean why do we need large graphics of login screens, or pictures of the console. This is just filler.

I'm also not a fan of Prentice Hall's publishing style with large margins, big font, thick pages, poor graphics and source code that is word wrapped instead of using smaller fonts. This book could have easily been reduced by at least half.

Overall I cannot recommend this book for anyone who has some working knowledge of WebLogic server. Beginners depending on your skill set will find it useful to some degree.

This is a very light overview of Weblogic and J2EE. This book is a step-by-step follow-the-numbers outline of how to get a particular example program to work. You will not find any indepth information on why things are done the way they are.

A lot of space is wasted on screen shots of DOS shells that show how to run a .bat file.

Even though it is advertised as supporting WLS 6.0, I am disappointed that the webauction example source code / build scripts do not work with WLS 6.1. Considering that this book was just published and that its copyright is dated as 2002 (sic), the example code should run on the current version of Weblogic.

To add insult to injury, the "questions / comments" email address on their web site bounces.

This book might be a good book for beginner/intermediate programmers but it does little for intermediate/advance programmers who want to learn about weblogic. Advanced users will easily get bored with its simplicity and lack of detail on critical topics such as command line depoyment or even console for that matter (not practical). Their are a lot of things that are assumed in this book and really just scratches the surface of weblogic. Just when topics get interesting, the authors refer the reader to weblogic's online edocs.

If you have understanding of j2ee and need to get upto date with weblogic , this is not the book for you. The examples in this book are very simple, with probably a hello world example for each chapter. You can see this as either good or bad. warning: Some beginners to j2ee will find some difficulty understanding deployment without previous knowledge in j2ee, The book is not very PRACTICAL. It would have been prefaired if the examples in each chapter continued on to the following chapter, this way the reader could learn how the different components in j2ee work together and more prefairably in a weblogic environment.

Overall I didnt enjoy reading this book very much, some chapters are really well done while others are not, I give this book a 3 only because this book would serve well for a beginner in j2ee and not weblogic.