Recommended books about EJB

Persistence-the ability of data to outlive an instance of a program-is central to modern applications. Hibernate, the most popular Java persistence tool, provides automatic and transparent object/relational mapping making it a snap to work with SQL databases in Java applications. Hibernate applications are cheaper, more portable, and more resilient to change. Because it conforms to the new EJB 3.0 and Java Persistence 1.0 standard, Hibernate allows the developer to seamlessly create efficient, scalable Java EE applications.

Java Persistence with Hibernate explores Hibernate by developing an application that ties together hundreds of individual examples. You'll immediately dig into the rich programming model of Hibernate 3.2 and Java Persistence, working through queries, fetching strategies, caching, transactions, conversations, and more. You'll also appreciate the well-illustrated discussion of best practices in database design, object/relational mapping, and optimization techniques.

In this revised edition of the bestselling Hibernate in Action, authors Christian Bauer and Gavin King-the founder of the Hibernate project-cover Hibernate 3.2 in detail along with the EJB 3.0 and Java Persistence standard.

This book is not a cookbook, but it does provide a deeper-than-usual perspective on the concepts guiding Hibernate and ORM in general. As a result, you have to read it differently from the run-of-the-mill software book: say a chapter at a time, rather than simply copying the code samples. In my experience, that special effort really pays off. Thanks to the authors!

First off, if you want a great example of a very well written technical book on Java EE, check out Seam in Action. Allen covers ORM as well. This book goes back and forth between the Hibernate xml mappings and the JPA annotations very often. The Hibernate Session API and JPA EntityManager API is thrown around willy nilly in the text. It's very difficult to concentrate and digest the information. But there is some good stuff in there including second level cache and Seam (which seams inappropriate for a ORM book). Also there is way too much detail at times (most of the book honestly) so you don't get the high-level picture of the ORM concepts. What about Kodo and JPOX and other persistence providers for JPA? Not written by a native English speaker apparently so another minus. JPA and Hibernate are obviously related but they belong in separate books for clarity. For JPA, I recommend Java Persistence book by Mike Keith (Apress). Or the spec (JSR 220). This book is not worth the price, find something better. For Hibernate, you can learn a lot from the Caveat Emptor download as well. The authors have yet to finish the Seam version of Caveat Emptor! Get with the program!

I had a very difficult time reading this book. Manning should have released a new edition of Hibernate in Action and a Java Persistence in Action. The book is way too long and heavy. Very confusing to read as the authors keep going back and forth on code/xml for Hibernate and then JPA.

not enough coverage on views and how when you reverse engineer a view a separate @Embeddable class is create by hbm2java and the primary key always consists of all the columns in the table which the view is based on.

needs a chapter on best practices and design patterns (OSIV, for example). Performance tuning as well. When and why to use stored procs and whether or not JPA supports stored procs.

the seam chapter in the end is random and not necessary (is this a JBoss stack book?)

needs more coverage on Toplink Essentials (the RI for JPA), OpenJPA and other alternatives to Hibernate.

needs coverage on what is planned for JPA 2.0 (like Criteria API).

stay away from this book, it's very difficult to read and follow. stick with the specs, forums and online user docs.

so...i'm a novice hibernater (ie never used it before--learning it for the first time). after 8 months, i'm at page 634 of 840+ pages (but the last 80 pages don't count cause its about jboss seams). and i finally decided to share my opinion of this book. first, let me explain why its taken me as long as it has. when i read a technology book, i try most/all of the examples and understand it. those who read this book without coding are just wasting there time. (i'll probably read it a second time, but hopefully at a far faster rate, but i have to take some golfing lessons or something else in between, thank god)

wow--what a read. comprehensive it is. anything and everything you want to know about hibernate. every example i tried worked, some i didn't try cause i'm not going to use it (jpa). having said that, except for the first example which is fully documented, everything is presented as bits of code; you have to fill in the rest, which means you better know what you're doing, or willing to dig around, or do what i did, start at page 1 and work your way through the book.

the early chapters are well written. people who criticize this book for being boring just don't get it. if you want exciting, got buy a work of fiction. if you want to learn hibernate, BUY THIS BOOK.

the later chapters about concepts and advanced hibernate features aren't as well written. the flow is not as contiguous, and some of the topics seem to be thrown together into a chapter with no tie in, except for the common chapter title.

but worth its cost, if you take your time, and you will definitely learn some hibernate if you buy this book. how much will depend on you.


things they could improve on
-introduce the basics of HQL & criteria/query api earlier in the book
-introduce transactions earlier
-object scope identity not well defined, still little hazy about it
-ch 12 and onwards just seem not was well edited as the earlier chapters, seems like they were thrown together to make a deadline
-later chapters start to get really big, for people who read/study in chunks, makes these chapters seem more daunting
-leave out the last chapter, seams does not belong in hibernate/jpa book


things very well done
-rationalizing why hibernate is the way it is, especially things like how it is implemented to allow separation of concerns
-explaining most of the concepts
-optimizing hibernate
-and many others

1) the book is way too long, it should have been released as two separate books: an update to Hibernate in Action and a new Java Persistence in Action (see Mike Keith's Apress book on JPA!)

2) why is there a random Seam chapter at the end? obviously it ties in with the implementing conversations (chapter 11) and the purpose of Seam is essentially to improve and simplify Java EE while tying together JSF and EJB 3, but does it really need to be in this already way too long book? And if you're interested in learning about Seam, read Seam in Action by Dan Allen, that's the best book out thus far on Seam.

3) there is no chapter on when and why you would use the Hibernate API (e.g. Criteria) which is not available in the current JPA 1.0 spec. When and in what scenarios is it worthwhile and/or necessary to deviate from JPA? And if you do, what are the possible consequences (e.g. if you subsequently use a different persistence provider, then you must refactor the Hibernate AIP out). What is currently deficient about JPA 1.0, etc.?

4) there is no chapter on comparing and contrasting the various JPA persistence provider options like OpenJPA, Kodo, Hibernate, Toplink Essentials. Why should one use Hibernate if Toplink is the reference implementation for the JPA spec?

5) there is no chapter on using Hibernate/JPA in a clustered environment (although there is some coverage on JBossCache, JGroups and second level cache).

6) Caveat Emptor Seam version is still not available (and there is no release date)!

7) there is no ORM design patterns chapter which would describe material like DAO and Open Session in View pattern, for example.

8) it would be nice if there were some more pictures (Seam in Action does very well in this regard!)

9) last but not least, and this is the main reason I'm rating this book so poorly, is that there is a ton of information in this book but it is EXTREMELY difficult to read, follow, and digest. The authors go back and forth between JPA code and Hibernate code (and XML configs) constantly and it is very, very confusing.

So. If you want to be more confused about JPA and Hibernate (ORM is definitely not the easiest subject to digest and learn), then waste your money and buy and attempt to read this book.

Otherwise, just stick to the specs, reference docs and forums. Or wait for the potential Hibernate in Practice (there is a Spring in Practice book coming soon!)

If you're up on the latest Java technologies, then you know that Enterprise JavaBeans (EJB) 3.0 is the hottest news in Java this year. In fact, EJB 3.0 is being hailed as the new standard of server-side business logic programming. And O'Reilly's award-winning book on EJB has been refreshed just in time to capitalize on the technology's latest rise in popularity.

This fifth edition, written by Bill Burke and Richard Monson-Haefel, has been updated to capture the very latest need-to-know Java technologies in the same award-winning fashion that drove the success of the previous four strong-selling editions. Bill Burke, Chief Architect at JBoss, Inc., represents the company on the EJB 3.0 and Java EE 5 specification committees. Richard Monson-Haefel is one of the world's leading experts on Enterprise Java.

"Enterprise JavaBeans 3.0," 5th Edition is organized into two parts: the technical manuscript followed by the JBoss workbook. The technical manuscript explains what EJB is, how it works, and when to use it. The JBoss workbook provides step-by-step instructions for installing, configuring, and running the examples from the manuscript on the JBoss 4.0 Application Server.

Although EJB makes application development much simpler, it's still a complex and ambitious technology that requires a great deal of time to study and master. But now, thanks to "Enterprise JavaBeans 3.0," 5th Edition, you can overcome the complexities of EJBs and learn from hundreds of practical examples that are large enough to test key concepts but small enough to be taken apart and explained in the detail that you need. Now you can harness the complexity of EJB with just a single resource by your side.

As many Java developers and IS managers already know, Sun's powerful Enterprise JavaBean (EJB) technology offers an attractive option for developing server-side components. A suitable read for both managers and Java programmers, Enterprise JavaBeans provides a surprisingly clear and engaging introduction to designing and programming with EJBs.

The tour of the EJB component model presented here centers on several beans created and tested for a travel reservation system in a fictitious cruise ship company. The samples are just right in scale, large enough to test out key concepts in design and deployment, but small enough to be comprehensible, even to those who are not Java experts. The author pays close attention to the real-world issues of deployment with EJBs (as well as the differences among the vendor application servers that run them).

While there are enough details in Java syntax for designing both entity and session beans for the developer, sections on design here will please those who manage projects without delving much into code. Later, the author shows various ways to design entity and session beans. (For instance, entity beans can allow their bean containers to handle the details of connecting to a database, or they can do it themselves. This book demonstrates both approaches.) When it comes to session beans (which "wire" together entity beans to do real work), the author's introduction to managing state and transactions is also a standout. Tips for performance and reusability close out the book.

In all, Enterprise JavaBeans provides an engaging tour of one of the most promising component technologies. It's technically astute, but thoroughly approachable too, and can serve the needs of any manager or Java developer considering EJBs for future projects. --Richard Dragan

Topics covered: Enterprise JavaBeans (EJBs) basics, distributed architectures, Component Transaction Monitors (CTMs), bean-containers, home and remote bean interfaces, resource management, configuring EJB servers, entity beans, JNDI, container-managed and bean-managed persistence, session beans, stateless and stateful beans, transactions, design and performance hints.

I started reading this book with a basic understanding of EJB 3.0. But the book does not keep you interested in the topic. I found the reference manual more interesting. I use this as a reference book.

This book covers almost everything related to EJBs in their new reincarnation. Its author have rightfully chosen to scrap any information concerning EJB 2.1. This is the right path to take as the new 3.X standard is so radically different (read much more useful) from the earlier versions.

The book starts out with a fairly detailed introduction to JPA 1.0 persistence mappings, entity relations and inheritance. It then moves on to covering session beans, interceptors, JAX-WS/RPC, the JNDI ENC and JTA.

This is a massive amount of stuff and still the author manages to convey its primary use, pitfalls and corner cases in an engaging technical style. So from a topical point of view you get what you pay for (and then some). The book is however not without some problems. First of all it contains some annoying errors, like:

1) In the interceptor chapter, the author fails to inform you that EJB interceptors are only used on direct invocations. That is if you put a interceptor on EJB A and inject it into EJB B, then delegated method invocations on EJB A from B are not intercepted. This is annoying at best, and at worst it could be considered an enormous flaw in the EJB spec.

2) Some JPA information is just plain wrong (like the use of named parameters in native queries). Most of these errors can be traced back to the fact that the author uses Hibernate which indeed supports this non-standard functionality. While understandable, it does confuse you some when confronted with strange errors in other containers

Many other errors exists and this book badly needs a review from some of the other EJB/JPA spec members, preferably someone not involved with the JBoss container. Another and more grave problem is the fact that the book presents most technologies as separate entities, and thereby you fail to see the complete picture. I really miss a complete real life EJB applications including:

1) Security (propagation of client role to the server (i.e. getCallerPrincipal)).
2) Interceptors (for logging and security).
3) Use of EJBs from a web application.
4) Testing of EJBs (best practices for easy unit testing).
5) Packaging and compiling (these days you cannot write a JEE book without a complete Maven sample)

This might sound like allot of grief, but I still choose to give the book four stars from the simple fact that it is complete, contains allot of useful samples (like the .NET SOAP application client) and manages to make many hard topics easy to understand.

In general a well written and useful book with a heap of information, written in a pragmatic style without to much fluff.

This is a great introduction to EJBs in general, and now EJB3. (the JSR 220 standard) Just like EJBs are now easier to develop with version 3, so is it easy to read and study this book. I hold O'Reilly in a high regard, (doesn't mean I'm a fan boy though, they do have their share of bad apples) and their high standards show in the quality of writing in this book. You will be happy with your purchase.

To be brief, this is a great book, but you will almost certainly want the newest edition of it.

I recommend this book. The book cover almost topics in EJB 3.0 and you can depend it for preparing the SCBCD 5. The author explain and describe the topics in easy way.

The problem of this book have more error in code I escalation it for author. cause the book have his name not auditor name.

I will give this book three stars for losing the quality.

EJB 3 in Action tackles EJB 3 and the Java Persistence API head-on, providing practical code samples, real-life scenarios, best practices, design patterns, and performance tuning tips. This book builds on the contributions and strengths of seminal technologies like Spring, Hibernate, and TopLink.

EJB 3 is the most important innovation introduced in Java EE 5.0. EJB 3 simplifies enterprise development, abandoning the complex EJB 2.x model in favor of a lightweight POJO framework. The new API represents a fresh perspective on EJB without sacrificing the mission of enabling business application developers to create robust, scalable, standards-based solutions.

EJB 3 in Action is a fast-paced tutorial, geared toward helping you learn EJB 3 and the Java Persistence API quickly and easily. For newcomers to EJB, this book provides a solid foundation in EJB. For the developer moving to EJB 3 from EJB 2, this book addresses the changes both in the EJB API and in the way the developer should approach EJB and persistence.

One might say that "EJB3 In Action" is actually two books in one. Both EJB3's core functionality (Session beans, message driven beans, interceptors, transactions, exceptions...) and Java Persistence API (JPA) are covered. Learning Enterprise Java Beans is not an easy task, no matter how cleaner EJB3 are compared to EJB2. "EJB3 In Action" achieves to make a lot of advanced topics look easy. Not only does it provide the necessary information to understand EJB3 in an enjoyable style, it also introduces some best practices, performance issues, and illustrates important concepts with relevant code snippets. There is enough examples to keep you busy trying it yourself on your favorite container, as well as the downloadable application which is used throughout the book. There are also chapters about interoperability with EJB2, about using EJB3 with the Spring framework, well enough to satisfy the most curious and avid developers. All in all, the authors have made a fantastic job keeping the reader focused and entertained.

I used this book to study Sun's SCBCD certification. Although the book does not go as deep into the EJB specification as the exam does, I'm confident enough to say that, armed with this book and an exam simulator to fill the gaps, any serious developer can successfully pass.

EJB 3 in Action is an excellent introduction and reference book for EJB3. The Manning books are usually a cut above the competition and this one is no different. The also covers the new web services APIs in JEE 5 as well as JPA and ties them all together which greatly enhances the utility of this book. This is the best JEE book I have read to date - explanations and examples are clear an applicable to my work. The book also delves into patterns and good practices and how EJB development has taken a radical leap forward since version 2.

EJB is not an easy topic to learn and read about. But this book starts with explaining basic concept and goes deeper with a very good speed that it doesn't make you feel you are being sunk at the same time it doesn't put you to sleep.
it covers most if not all of the materials of the SCBCD exam, of course you still need to check the spec's but this book gives a great kick start and great level of understanding that makes reading the spec's easier also it makes reading books that act like a reference (such as OReilly's EJB 3.0) easier and trust me everything starts making sense after reading EJB3 in action.
I think book would be perfect if it covers DD with more examples.
Nice work authors.

One of my big complaints when I get a technical book is that I often feel like I'm in the Goldilocks and the Three Bears story - technical books are either way out there covering things you don't care about and are too complicated or they don't cover enough to even be relevant for when you actually want to start coding (you know books that just talk about theory and history, bla bla blah.) I found this book to be the "perfect porridge" (to keep with the Three Bears analogy.)


The book doesn't bore you with things you don't care about and covers all the things you "do" need to know and need to care about. It's extremely well written and well organized.

I really appreciate the clear and concise code snippets illustrating PRACTICAL implementations. I emphasize 'practical' because too often technical books provide some weird code snippet that you wouldn't use 'in real life.' This is not the case with the examples in this book. The examples in this book fit perfectly with the text and they don't just waste space pasting in code to fill up pages.

Who would this book be good for? I've had a lot of experience with Java web applications, but NOT EJBs and I found the book VERY easy to follow. Previous knowledge of EJB2 is not necessary at all for comprehending the material. Having some relational database knowledge would certainly come in handy to help understand some of the entity relationships, but even that's not absolutely necessary.

This book is also nice because I found it easy to read while just lying in bed to get a complete feel for the whole gamut of the EJB3 realm.

I highly recommend this book for anyone brand new to EJBs or those coming from the EJB2 world.

You know i have been in IT not since long, before i started this book many of my concept's were not clear about EJB3.

after reading this book, you will get to know the status of current technolgie's are.

it almost cover's all concept's related to ejb3 and side by side, it also introduces you to other competing technolgies.

well it's language is too easy, all the chapter's do have a easy language.
well i do enjoy to read this book.

i am learning EJB 3 and the Java Persistence API in an easy manner and without difficulty. For novices to EJB, this book provides a rock-solid foundation to EJB. For developers moving to EJB 3 from EJB 2, this book addresses the changes both in the EJB 3 API and JPA. This book is ideally suited for Java developers with a couple of years' experience who are interested in EJB 3.

What do Ford Financial, IBM, and Victoria's Secret have in common? Enterprise JavaBeans (EJB). As the industry standard for platform-independent reusable business components, EJB has just become Sun Microsystem's latest developer certification. Whether you want to be certifiable or just want to learn the technology inside and out, Head First EJB will get you there in the least painful way. And with the greatest understanding. You'll learn not just what the technology *is*, but more importantly, *why* it is, and what it is and isn't good for. You'll learn tricks and tips for EJB development, along with tricks and tips for passing this latest, very challenging Sun Certified Business Component Developer (SCBCD) exam. You'll learn how to think like a server. You'll learn how to think like a bean. And because this is a Head First book, you'll learn how to think about thinking. Co-author Kathy Sierra was one of Sun's first employees to teach brave, early adopter customers how to use EJB. She has the scars. But besides dragging you deep into EJB technology, Kathy and Bert will see you through your certification exam, if you decide to go for it. And nobody knows the certification like they do - they're co-developers of Sun's actual exam! As the second book in the Head First series, Head First EJB follows up the number one best-selling Java book in the US, Head First Java. Find out why reviewers are calling it a revolution in learning tough technical topics, and why Sun Chairman and CEO Scott McNealy says, "Java technology is everywhere...if you develop software and haven't learned Java, it's definitely time to dive in "Head First." And with Head First book, you don't even have to feel guilty about having fun while you're learning; it's all part of the learning theory. If the latest research in cognitive science, education, and neurobiology suggested that boring, dry, and excruciatingly painful was the best way to learn, we'd have done it. Thankfully, it's been shown that your brain has a sense of style, a sense of humour, and a darn good sense of what it likes and dislikes. In Head First EJB, you'll learn all about:

• Component-based and role-based development
• The architecture of EJB, distributed programming with RMI
• Developing and Deploying an EJB application
• The Client View of a Session and Entity bean
• The Session Bean Lifecycle and Component Contract
• The Entity bean Lifecycle and Component Contract
• Container-managed Persistence (CMP)
• Container-managed Relationships (CMR)
• EJB-QL
• Transactions
• Security
• EJB Exceptions
• The Deployment Descriptor
• The Enterprise Bean Environment in JNDI
• Programming Restrictions and Portability

The book includes over 200 mock exam questions that match the tone, style, difficulty, and topics on the real SCBCD exam. See why Kathy and Bert are responsible for thousands of successful exam-passers-- "The Sun certification exam was certainly no walk in the park, but Kathy's material allowed me to not only pass the exam, but Ace it!" --Mary Whetsel, Sr. Technology Specialist, Application Strategy and Integration, The St. Paul Companies "Kathy Sierra and Bert Bates are two of the few people in the world who can make complicated things seem damn simple, and as if that isn't enough, they can make boring things seem interesting." --Paul Wheaton, The Trail Boss, javaranch.com "Who better to write a Java study guide than Kathy Sierra, reigning queen of Java instruction? Kathy Sierra has done it again. Here is a study guide that almost guarantees you a certification!" --James Cubetta, Systems Engineer, SGI

Had high hopes for the book, with cartoons and all. But they got into lots of agonizingly boring technical detail without putting it into a clear context. The explanations could have been much clearer by providing that context.

This book helped me to understand what is enterprise how they fit together how to create EJB 2.0 actually it let you have a strong understanding of J2EE concepst.the authors are very experienced and their books are really the best and should be best ev er selling

This was a great book for me, ( had to use wrath of EJB 2.1 in several projects =( ). So when EJB 3 came out and i went through EJB 3 ( via Oreilly's book ) i was amazed, pleased and overjoyed.

The new Exam covers EJB3. However if you are still planning to give EJB 2.X exam, this is BEST book you'll buy. It guides you step by step towards steep learning curve that EJB comes with and makes it real easy to remember things.

I am usually critical of Head First "Kids" like format, but this book justifies that because of the subject being such. EJB 2.x deserved this kind of book, where one go one step at a time to understand things.

Book Covers :

1. ) Transaction Management
2. ) All kinds of Beans ( what you do, what container does etc etc. )

What it does not Cover :
1.) EJB 3
2.) Deployment to JBOSS container ( these days with EJB 3 more and more people are adopting JBOSS AS ), neither does it cover deployment specifics of Websphere. ( And in reality Why should it ever do that? this book is only for certification etc. )

If you want to earn SCBCD ( old one ) or if you are working for EJB 2.X project, do yourself the favor of buying this book

Regards
Vyas, Anirudh

This book is out-of date. It does not cover EJB 3 which is the current paradigm. For EJB 1 & 2 it is a good book, but these are not used. If you are preparing for SCBCD this is not the book to use

This is a absolutely easy going book. You can read it for hours and not feel any stress. The methods they have used are so good that you will never forget the concepts.

There are dozens of Java frameworks out there, but most of them require you to learn special coding techniques and new, often rigid, patterns of development. Wicket is different. As a component-based Web application framework, Wicket lets you build maintainable enterprise-grade web applications using the power of plain old Java objects (POJOs), HTML, Ajax, Spring, Hibernate and Maven. Wicket automatically manages state at the component level, which means no more awkward HTTPSession objects. Its elegant programming model enables you to write rich web applications quickly.

Wicket in Action is an authoritative, comprehensive guide for Java developers building Wicket-based Web applications. This book starts with an introduction to Wicket's structure and components, and moves quickly into examples of Wicket at work. Written by two of the project's earliest and most authoritative experts, this book shows you both the "how-to" and the "why" of Wicket. As you move through the book, you'll learn to use and customize Wicket components, how to interact with other technologies like Spring and Hibernate, and how to build rich, Ajax-driven features into your applications.

There is already a lot of appreciation of the book, don't have much to say here

I have been developing with Wicket for a year or so. When I started working with Wicket I didn't have a good book as a reference. The community is very helpful in this case. In the mailing list you can sometimes see the two writers of this book. Their responses are very helpful. And so is the book.
The book covers a lot of theoretical Wicket stuff, which I think is very useful if one wants to understand it better.
The book is great for a newcomer as well. Just follow the examples and you'll understand Wicket.
I found the book very useful to me, an intermediate / expert Wicket developer.
Each time I read a few pages or a chapter, I learn something new.
I recommend this book to anyone that uses Wicket or plan to use it.

As the Manning publications book Wicket in Action is soon to hit the shelf of your local book store, I was granted the opportunity of a sneak preview. Now, I'm not a person with a lot of spare time on my hands these days but I felt an obligation to give this book a serious read because A) Wicket is an excellent framework for building web applications B) The people who wrote this book are extremely helpful on the mailing list and irc channel and I wanted to know if their talents translated well to book writing. I'm happy to report it has, in spades....
[...]

I already bought this book before it was released. I love wicket and this book sure makes it easier to work with Wicket. It gives you a great in depth view on how wicket works. Adding more and more complexity in all the different chapters.

A needed read for anyone who wants to get the most out of Wicket.

I don't normally review books on Amazon but this is one of the best technical books that I've read in a while. The authors do a great job of organizing and presenting the material. The book is easy to read and I was able to get through it in about two evenings. I'm now using it as a reference while I work on my first major Wicket application. It might help that Wicket itself is well structured which makes the concepts that much easier to understand.

That being said, there are a few short-comings:
1) The cheese and lasagna examples get really old really quickly. The authors could have used different concepts or something a little more relevant or interesting to most developers.

2) The book is somewhat short. While they covered the core topics well, I felt that a few things we missing. I was surprised to see that the publisher trimmed the book and put an extra chapter online but not in print.

3) Some fundamentals like what DTD to include in an HTML page or what the Wicket web.xml should look like would be nice. You can find these answers online with a quick search but this book should really cover it.

But these faults don't hurt the overall usefulness of the book. It would be nice if most/all of this documentation was available in the Wicket project itself, but no such luck which makes this book even more valuable. I don't know if it will be in all copies, but my copy had a coupon for a free version of the digital book (PDF I suppose)... nice touch.

I recommend buying this book and learning about a very reasonable alternative to JSF.

JavaServer Pages (JSP) has built a huge following since the release of JSP 1.0 in 1999, providing Enterprise Java developers with a flexible tool for the development of dynamic web sites and web applications. While new point releases over the years, along with the introduction of the JSP Standard Tag Library (JSTL), have incrementally improved the rough areas of the first version of the JSP specification, JSP 2.0 takes this technology to new heights.

"JavaServer Pages," Third Edition, is completely revised and updated to cover the JSP 2.0 and JSTL 1.1 specifications. It includes detailed coverage of the Expression Language (EL) incorporated into JSP 2.0, the JSTL 1.1 tag libraries and the new function library, the new tag file format that enables custom tag library development without Java code, the simplified Java tag library API, improvements in the JSP XML syntax, and more. Further, it details setup of the Apache Tomcat server, JSP and JSTL syntax and features, error handling and debugging, authentication and personalization, database access, XML processing, and internationalization.

This book recognizes the different needs of the two groups of professionals who want to learn JSP: page authors interested in using JSP elements in web pages, and programmers concerned with learning the JSP API and using JSP effectively as a part of an enterprise application. If you're in the first group, you'll learn from the practical web application examples in the second part of the book. If you're in the latter group, you'll appreciate the detailed coverage of advanced topics in the third part, such as how to integrate servlets and JavaBeans components with JSP using the popular ApacheStruts MVC framework, and how to develop custom tag libraries using the JSP API, with realistic examples that you can use as a springboard for your own libraries.

"Hans Bergsten, a JSP expert group veteran and one of our most active contributors, has thoroughly and accurately captured the new features of JSP 2.0 and JSTL 1.1 in a way that is well-organized and easy to understand. With excellent, to-the-point examples, this book is a 'must have' for any serious JSP 2.0 developer."

--Mark Roth, JSP 2.0 Specification Lead, Sun Microsystems, Inc.

Hans Bergsten is the founder of Gefion Software, a company focused on Java services and products based on J2EE technologies. Hans has been an active participant in the working groups for both the servlet and JSP specifications since their inception and contributes to other related JCP specifications, such as JSP Standard Tag Library (JSTL) and JavaServer Faces (JSF), and, as one of the initial members of the Apache Jakarta Project Management Committee, helped develop the Apache Tomcat reference implementation for the servlet and JSP specifications.

This is an extremely well written and informative book. I have
lots of experience with servlets, so I don't know how the book
will appeal to page designers, but I had no problem reading and
enjoying the chapters oriented more toward them. I used to look
at JSP and see the same kind of maintenance nightmare that comes
with something like PHP when your project gets large. I have
been using WebMacro/Velocity but am now a convert to JSP since
it has matured. I love the author's philosophy of no scriptlets
in your JSPs. I own many programing books, but I believe this
is the best written I've seen.

If you are looking for a quick cookbook this should not be your choice. If you want to learn JSP in depth, buy it right now. Hans guides you from the basics to comprehensive details of JSP technology in a very structured way.

In any case, (from my point of view) JSP is not the whole jigsaw for building web applications, it's just a piece of it. So don't expect to be able to build real web applications if you just have read this book. At least, consider reading also Java, Struts/MVC and SQL.

Perhaps this is as good a user guide as is possible for JSP, which is a good, but not great techology.

JSP integrates between web markup user interfaces (usually HTML) and back-end java technology (usually servlets), and best practices have most of the interesting work done in these technologies, not in JSP. JSP's flaws come from too many spurious features that lead the unsuspecting user far away from best practices.

JSP's strengths as a template technology for web view markup come in its 2.0 version with its addition of programmatic logic to markup (JSTL for logical branches and loops, and tags for subroutines) which allow for development of markup without repeated code. This is a great benefit of JSP, and this book does a fairly good job of explaining it for JSTL/logic, but talks around it with confusing examples for tags/subroutines. To this book's credit, it is the only decent reference I have found for JSP 2.0 tag library development.

Best practices with JSP as an integration technology involve what is called "Model 2 MVC" where the JSP page is strictly used only as a template for markup (the "view" which is the "V" from "MVC"), a JavaBean is used for the M-"model" and a single servlet is used for the C-"controller". This concept is mentioned in this book, but its up to you to figure out how to implement it, and the book is full of examples that show off unrealistic uses of JSP's spurious features and are anything but best practices. At some point in using JSP's and servlets, you are going to have to go head-to-head (actually, head-to-confusing-XML) with a real deployment descriptor, and this book will give you little help as to why it doesn't work.

Until someone writes a truly useful reference for JSP and servlets, you will have to follow the time-honored tradition of finding an example that works and cut-and-pasting it into your web application. Poring over this book will help some, as will poring over Craig McClanahan's online doc that comes with Tomcat. The best book I've found so far for explaining best practice design with JSP is Rod Johnson's "expert one-on-one J2EE Design and Development" (read the chapters on web-tier MVC design and views in the web tier) though it's description of JSP is somewhat dated, and it won't help you out with implementation details.

O'Reilly falls down on its usual excellent editorial job and delivers an undisciplined unstructured mess that is useless as a reference. The JSTL examples are so incomplete as to be virtually worthless. As an experienced developer, I spent my 45 bucks expecting a useful reference and practical guide, instead getting a beginner's tour and some appendices of jstl syntax spec.

There is some really good information in this book. The problem is, you have to wade through a mess to find it. The author is constantly referencing chapters later in the book, suggesting that the reader look ahead for information on the subject currently being talked about. Much of the information in later chapters should have been included earlier on. Besides the annoyance of having to read ahead to keep up with the current subject, the author goes back on himself constantly. Examples are shown as a functional way to do things, and then later on, I found myself being told not to follow the methods explained previously because they arent an efficient way to work. On top of this, the language of the book seems overcomplicated. Simple concepts are explained in a long drawn out fashion left me wondering where I had lost my way.

I am picking things up that I wouldn't have figured out without the book, but I'm quite convinced that another book would have had me writing applications already.

Nothing is as constant as change, and this is as true in enterprise computing as anywhere else. With the recent release of Java 2 Enterprise Edition 1.4, developers are being called on to add even greater, more complex levels of interconnectivity to their applications.

To do this, Java developers today need a clear understanding of how to apply the new APIs, use the latest open source Java tools, and learn the capabilities and pitfalls in Java 2 Enterprise Edition 1.4 -- so they can plan a technology and implementation strategy for new enterprise projects.

Fortunately, this is exactly what they get with the new Java Enterprise in a Nutshell, 3rd Edition. Because most integrated development environments (IDE) today include API lookup, we took out the main API sections from our previous edition to make room for new chapters, among others, on Ant, Cactus, Hibernate, Jakarta Struts, JUnit, security, XDoclet, and XML/JAXP.

Revised and updated for the new 1.4 version of Sun Microsystems Java Enterprise Edition software, Java Enterprise in a Nutshell, 3rd Edition is a practical guide for enterprise Java developers.

For the intermediate to advanced Java developer, Java Enterprise in a Nutshell shows how to work with all of today's relevant Java APIs. Plus, it's a topnotch reference for all enterprise classes. Part tutorial and part reference work that you can use everyday at your desk, this title is a worthwhile resource for any Java developer building Web or enterprise software.

The practical, succinct focus here on actual Java enterprise APIs helps distinguish this text from the pack. Early sections provide short, clear examples along with just enough background to help you use APIs like JDBC, servlets and JSPs, EJBs, and others. Coverage of Java's ability to interface with legacy CORBA systems is just excellent, with a full tour of Java IDL, CORBA services, and Remote Method Invocation (RMI). Typically, readers will be familiar with some J2EE APIs and not others. This book can help fill in the gaps.

Updated with the latest standards from Sun, including JDBC 3.0, Servlet 2.3, and EJB 2.0, this is an essential primer for today's high-end (and high-paying) Java. The basic presentation of servlets/JSP and EJBs (among the most important APIs for current Java Web development) is concise and nicely digestible. We also liked the chapter on JMS for messaging (also a hotbed of Java job activity).

The second half of this text lists every J2EE class, along with methods and properties, in a very valuable reference section that makes good use of two-toned shading for easy access. Entries are organized by package name. (One small oversight here is that an index of cross-listed packages, classes, and methods omits page numbers.)

Overall, this book is truly indispensable for any working Java programmer. The second edition of Java Enterprise in a Nutshell is a fully up-to-date tutorial and reference that lives up to the standards of O'Reilly�fs Nutshell series. Both thorough and concise, it's a handy resource for anyone who works with the hundreds and thousands of Java enterprise APIs on a regular basis. --Richard Dragan

Topics covered: Introduction to enterprise computing with the Java 2 Enterprise Edition (J2EE), survey of Java enterprise APIs, JDBC 3.0 (including database connections, ResultSets, prepared statements, BLOB fields, transaction support, stored procedures), the JDBC Optional Package (and connection pooling), Remote Method Invocation (RMI) described (building stubs and skeletons, dynamically loaded classes and remote object activation, RMI over IIOP), in-depth tutorial for Java IDL (with CORBA) and designing remote objects, Java Servlet 2.3 APIs (basic servlet processing and the servlet lifecycle, chaining and filters, thread safety, managing state, cookies, servlets used with JDBC), JavaServer Pages (JSP): including custom tags, JNDI and directory tutorial (contexts, looking up objects, accessing and modifying directory entries), Enterprise Java Beans (EJB) 2.0 (conventions for entity, session and message beans, using transactions), Java XML APIs (DOM, SAX and XSLT), Java Message Service (JMS), point-to-point and publish-subscribe messaging models, message selectors, JavaMail, reference to SQL and relational databases, RMI tools, reference to all IDL keywords, data types and declarations; CORBA services, Java IDL tool reference, Enterprise JavaBeans Query Language (EJB QL) 2.0 query language, and an alphabetical listing of all APIs for Java enterprise programming (listing of classes, methods, and properties).

Warning to all buyers, the 3rd edition of this book does not include the J2EE library reference. While I realize this information is available online, having a printed form of library references is the primary reason I buy the "in a nutshell" series. Included in this book is a very general overview of various enterprise technologies, which unlike the very useful language reference include in other "in a nutshell" books, seems too broad and shallow to be useful. Any developer serious about working in JSP, for example, would be better served buying a book on JSP. Admittedly I just received this book so I can provide a cursory commentary on the usefulness of the material, but the lack of library details alone would have made me not purchase it if I was browsing in a store.

I'm very happy, i have got "java in a nutshell" too and I was very satisfied of my purchase, the book is simple and written very well, a "must" for a Java programmer.

Do you have all of the tools you need to build enterprise-class applications? If you don't, then this book is for you! Authors Jim Farley, William Crawford, Prakash Malani, Justin Gehtland and John G Norman, have done an outstanding job of writing the third edition of a book that provides a pragmatic introduction to the latest release of Java 2 Enterprise Edition (J2EE).

Farley, Crawford, Malani, Gehtland and Norman, begin by presenting the general model that J2EE supports for assembling components and resources into full services or applications and how they are deployed to their runtime environments. Then, the authors demonstrate the basic techniques that are used to write servlets using the Sevlet API, including some common web development tasks such as cookie manipulation and session tracking. Next, they look at JSP from a Java programmer's perspective as opposed to that of a web site designer. The authors then provide a whirlwind introduction to programming with JavaServer Faces. They continue by providing a basic introduction to Enterprise JavaBeans. Then, the authors take a quick look at Sun's Java API for XML Processing (JAXP) Version 1.2, which provides a standardized approach to processing XML files in Java. Next, they focus on the JDBC 3.0 API, which includes a modest yet variable set of new features. The authors then provide an overview of transport and application security as well as defining the important concepts of authentication and authorization. They continue by focusing on developing, deploying, and using web services in your enterprise applications. They also examine the Java Remote Method Invocation (RMI) API--Java's native scheme for creating and using remote objects. Then, the authors look at an overview of the CORBA architecture and how it allows you to create, export, access, and manage remote objects. Finally, they give a brief overview of transaction terminology, including ACID properties and transaction isolation levels as well as the concepts of local and distributed transactions.

This most excellent book provides concise, fast paced tutorials on a broad range of enterprise Java tools and APIs. More importantly, this book is both a practical guide and quick reference for Java programmers who are writing enterprise applications.

Jim Farley and William Crawford's Java Enterprise In A Nutshell: A Practical Guide packs in tutorials on a number of enterprise Java tools, offering new material covering Xdoclet and Java 5.0 Annotations, JavaServer Faces, and the Hibernate API. Also included are open source testing and build tools, tips on writing SOAP-based web services, J2EE security issues and operations, and much more. Serious Java developers will want this as an essential desk reference.

Java Enterprise in a Nutshell tries to do the impossible - fit Enterprise Java into a nutshell. I don't think it matters how big of a nutshell you have, it would be a truly impossible task. Farley and Crawford, though, do a nice job shoe-horning as much Enterprise Java as they can into an 800+ page book. They go over many topics including all the J2EE standards like EJBs and JSPs to open source tools like JUnit, Cactus, and Hibernate. The book goes into enough detail to get more than just the gist of the subjects, but not so much detail to overwhelm someone looking for information on a particular topic. The book also has relevant code sections for the various topics outlining how that technology might be used. Overall, a compact, clear, well written reference.

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:

• 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
• How to design for optimal performance and scalability

By now a classic, this book eloquently expressed how the Corba component design committees came up with an EJB specification that was not an ideal cornerstone for all J(2)EE applications. Although very fit for selected purposes the early EJB specs had to evolve to EJB 3 to really leverage the power of Java. Fundamentals of component based flexibility often lost on OO design are explained well, regardless of whether one decides to use Spring the alleviate the risks around it.

bought this book long back,
kind of boarting book, nothing is writen very clearly,
AOP part is horrible, its so boaring whenever i try reading it
after reading one or two page i just fall to sleep,

This book introduces the Spring framework strategy as an alternative to J2EE which is GREAT. I noticed this book is far behind while comparing to the latest updates to Spring framework. Now, I am looking for updated code example and how-tos.

It does not fit for Software Engineer or Developer at all. EJB has bad performance though, it is a well-known fact, no need to say lots on the point. This book is like an advertisement for Spring Framework, but no directly and clear outline of Spring. From beginning to end, the book wrote lots verbose concepts about java, no real touch of authentic content. Although Rod is famous and experience on Java, this book might be an artitechure knowledge book, not good for level below intermedia java developers and SEs.

This is a fine book. I appreciate the practical insight and opinions expressed by the author. Sometimes it seems that he justifies his points by using the same rational he attacks in other technologies like EJB. Not that I am a fan of EJB, having used it in projects and found it wanting.

EJB 3.0 sets a new precedent. It has made huge advances in ease of development, and its drastically simplified programming model has been widely acclaimed.

Mike Keith, EJB 3.0 co-specification lead, and Merrick Schinariol, reviewer of EJB 3.0, offer unparalleled insight and expertise on the new EJB 3.0 persistence specification, in this definitive guide to EJB 3.0 persistence technology. Expect full coverage and examination of the EJB 3.0 spec from these expert authors, including:

• The new EntityManager API
• The new features of EJB Query Language (EJB QL)
• Basic and advanced object-relational mapping
• Advanced topics like concurrency, locking, inheritance, and polymorphism

Assuming a basic knowledge of Java, SQL, JDBC, and some J2EE experience, Mike Keith and Merrick Schinariol will teach you EJB 3 persistence from the ground up. After reading it, you will have an in-depth understanding of the EJB 3.0 Persistence API and how to use it in your applications.

This books seems to achieve the goal it has in mind, that of providing the user with the information necessary to use the Java Persistence API. Unfortunately there are real problems in the execution of this book.

A book like this should not only be full of examples, but it should be structured in such a way that it is easy for someone using the book to duplicate the examples on their own system. This book fails to do so.

In chapter two we are promised a complete application using the new API by the end of the chapter. The source code is provided for the application discussed and it is a pretty good example of the API discussed up to that point. Unfortunately there isn't enough information for the reader to build and run the application on their own computer. There is no reason for this kind of omission this early in the book.

The problems with the book continue as one moves on. I recognize that the target audience for this book includes only professional programmers of reasonable skill. I consider myself a very good Java programmer. That doesn't mean that I want to waste my time filling in gaps that should have been covered by a book I already spent my money on. It isn't any excuse for the omissions in this book.

This book is a joy to read. Object relational mapping is explained in a very simple manner. What I like about this book is that it explains a certain concept and then immediately talk about the specific use-cases when that concept/design may not be the best choice. The authors then give excellent suggestions and alternatives.

Very good reading material, simple examples used to explain complicated concepts. Writing style of the authors is also very engaging.

A very good buy.

This is the best book out there that explains in detail how JPA works with some good examples. I found the book to be well structured and easy to read.

I would recommend this book for anybody who is looking to work with JPA.

Pro EJB3 is a great book. Having been using it for over last 6 month on my recent project, I can definitely say that this book is invaluable.

Have been worked on EJB 2.x for many years and on several projects with different application servers (Weblogic, JBoss, WebSphere), I understand the basics of EJB. So I want not only understand the basic how-to in EJB3 and JPA, but also want to understand the in depth explanations on transaction, persistence context and different behavior in the new system.

The book explain all these topics very well. I had brought other book (hibernate in action with JPA pdf version), but found that book was too focused on hibernate (even I was a fan of the previous edition of hibernate in action book). This book is well focused on JPA,and I really likes JPA APIs.

The book author is really nice and accessible. I have emailed Mike questions and he consistently replied promptly.

This book worth the money !!!

Chester

Anything that requires getting a bunch of jars on the server classpath was deemed unsuitable for automated deployments. I wonder how people manage automated deployments and configurations, especially in a multi-server clustered environment.

There's nothing ordinary about JBoss. What began as an open source EJB container project six years ago has become a fully certified J2EE 1.4 application server with the largest market share, competitive with proprietary Java application servers in features and quality. And with its dynamic architecture, JBoss isn't just a J2EE server. You can alter the services to make J2EE work the way you want, or even throw J2EE away completely.

After more than a million downloads, many JBoss users are no longer trying it out on internal test boxes, but rolling it out on production machines. JBoss: A Developer's Notebook takes you on a complete tour of JBoss in a very unique way: rather than long discussions, you will find code--lots of code. In fact, the book is a collection of hands-on labs that take you through the critical JBoss features step-by-step. You don't just read about JBoss, you learn it through direct practical application. That includes exploring the server's many configurations: from bare features for simple applications, to the lightweight J2EE configuration, to everything JBoss has in store-including Hibernate and Tomcat.

JBoss: A Developer's Notebook also introduces the management console, the web services messaging features, enhanced monitoring capabilities, and shows you how to improve performance. At the end of each lab, you'll find a section called "What about..." that anticipates and answers likely follow-up questions, along with a section that points you to articles and other resources if you need more information.

JBoss is truly an extraordinary application server. And we have an extraordinary way for you to learn it.

I never have the time to read all the technical books required in today's high tech world, so it's nice to see a book that cuts to the chase and give you the critical information to build with JBOSS.

"JBoss: A Developer's Notebook" is a great introduction to getting up and running on JBoss. Instead of just dumping code and mounds of text at you, it quickly walks through setting up a "ToDo" application, including connecting to a mySQL database, logging, monitoring and security. None of it is in-depth but it's enough to point you in the right direction.

Be warned that the chapter on persistence uses XDoclet whereas things are moving towards EJB3 now so that chapter is not quite as useful as the rest of the book.

Overall, I would recommend this book if you are looking to set up a JBoss development server. Using it, I was able to tweak my installation of JBoss quite a bit.

This book is an example for all modern book writers to follow.

Most writers seem to want to write books weighing a few pounds, try to cover every conceivable topic and eventually do not do sufficient justice to anything.

On the other hand, this book is the book when you know "what" you want to do, and then "how" to do that with JBoss.

JBoss: A Developer's Notebook continues with the pragmatic appproach followed by the other books in the series. A series of clear, succinct examples on getting up and running with JBoss are the primary method used to present the content of the book. Most examples build on a previous example so it is best to cover them in a linear fashion. After execution of the examples, the user should have a good understanding of how JBoss operates, what it takes to deploy an application on JBoss and how to use the built-in features such as the Web Console.

If you are trying to dive into the details of JBoss in order to solve a complex setup issue or trying to fully understand one aspect of the application, then this is probably not the book for you. The depth of the information in the book is appropriate for it's scope as a developers notebook but it is not a reference manual.

Overall, if you want to learn the basics of JBoss quickly or stand up an instance with minimal research, you have come to the right place.

Excellent book on JBoss, the book is a easy read covering the ins and outs of JBoss from writing your app to, securing and managing the container. Very well presented with the cool notes on the sidebar which are worth reading all by themselves. The chapters are concise and to the point in presenting the ideas, this has become valuable resource on my desk.