Praise for the First Edition
This is the EJB book to read! Don’t miss its practical advice.
—Jeanne Boyarsky, JavaRanch.com
A technical book that is surprisingly entertaining.
—King Y. Wang, Oracle Canada
Great book—covers everything relating to EJB 3.
—Awais Bajwa, Expert Group Member
JSR 243 Java Data Objects
Well-written, easy, and fun.
—Patrick Dennis, Management Dynamics Inc.
Written with a wide audience in mind … not just a recitation of the EJB specification … includes a
lot of practical advice. Has a light, humorous, and accessible style of writing and all the concepts are
illustrated with examples.
—One Minute Review from javalobby.org
Broad coverage of EJB 3 with a very simple and excellently crafted case study. The book starts lightly
on this complex subject and slowly dives into the details of advanced concepts like interceptors, transactions, security, JPA, and performance issues, developing each scenario in the case study. Overall, a
very good book and a very smooth read.
EJB 3 in Action
For online information and ordering of this and other Manning books, please visit
www.manning.com. The publisher offers discounts on this book when ordered in quantity.
For more information, please contact
Special Sales Department
Manning Publications Co.
20 Baldwin Road
PO Box 261
Shelter Island, NY 11964
©2014 by Manning Publications Co. All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in
any form or by means electronic, mechanical, photocopying, or otherwise, without prior written
permission of the publisher.
Many of the designations used by manufacturers and sellers to distinguish their products are
claimed as trademarks. Where those designations appear in the book, and Manning
Publications was aware of a trademark claim, the designations have been printed in initial caps
or all caps.
Recognizing the importance of preserving what has been written, it is Manning’s policy to have
the books we publish printed on acid-free paper, and we exert our best efforts to that end.
Recognizing also our responsibility to conserve the resources of our planet, Manning books
are printed on paper that is at least 15 percent recycled and processed without the use of
Manning Publications Co.
20 Baldwin Road
PO Box 261
Shelter Island, NY 11964
Copyeditor and project editor:
Printed in the United States of America
1 2 3 4 5 6 7 8 9 10 – EBM – 19 18 17 16 15 14
Linda Recktenwald, Melody Dolab
OVERVIEW OF THE EJB LANDSCAPE . ..............................1
What’s what in EJB 3
A first taste of EJB
WORKING WITH EJB COMPONENTS ..............................47
Building business logic with session beans
Messaging and developing MDBs 93
EJB runtime context, dependency injection,
and crosscutting logic 117
Transactions and security
Scheduling and timers 196
Exposing EJBs as web services
USING EJB WITH JPA AND CDI .................................251
Managing entities 294
Using CDI with EJB 3 359
PUTTING EJB INTO ACTION .......................................395
Packaging EJB 3 applications
Using WebSockets with EJB 3
Testing and EJB
about this book xx
about the authors xxiv
about the cover illustration
PART 1 OVERVIEW OF THE EJB LANDSCAPE . ..................1
What’s what in EJB 3 3
EJB as a component model 5 EJB component services 5
Layered architectures and EJB 7 Why choose EJB 3? 9
Understanding EJB types 11
Session beans 11
Entities and the Java Persistence API 12
dependency injection for Java EE 13
Application servers 14 EJB Lite 15 Embeddable
containers 16 Using EJB 3 in Tomcat 16
Brave new innovations
“Hello User” example 17 Annotations versus XML 18
Intelligent defaults versus explicit configuration 19
Dependency injection versus JNDI lookup 19 CDI versus
EJB injection 20 Testable POJO components 20
Changes in EJB 3.2 21
Previous EJB 2 features now optional 21 Enhancements to
message-driven beans 21 Enhancements to stateful
session beans 22 Simplifying local interfaces for
stateless beans 23 Enhancements in TimerService API 23
Enhancements in EJBContainer API 23 EJB API groups 23
A first taste of EJB 25
Introducing the ActionBazaar application
Starting with the architecture
Using CDI with EJB 3
Using stateful beans
Using JPA 2 with EJB 3
Using CDI with EJB 3
Mapping JPA 2 entities to the database 42
Using CDI with JSF 2 and EJB 3 37
and JPA 2 40
An EJB 3–based solution 28
Building business logic with EJB 3
Using stateless session beans 29
Unit testing EJB 3 36
PART 2 WORKING WITH EJB COMPONENTS ..................47
Building business logic with session beans 49
Getting to know session beans
When to use session beans
session bean types 52
Stateless session beans
Component state and
When to use stateless session beans 55 Stateless session
bean pooling 56 BidService example 57 Using the
@Stateless annotation 60 Bean business interfaces 60
Lifecycle callbacks 63 Using stateless session
beans effectively 65
Stateful session beans
When to use stateful session beans 67 Stateful session
bean passivation 68 Stateful session bean clustering 68
Bidder account creator bean example 69 Using the @Stateful
annotation 72 Bean business interfaces 72 Lifecycle
callbacks 73 Using stateful session beans effectively 75
Singleton session beans
When to use singleton session beans 76 ActionBazaar featured
item example 78 Using the @Singleton annotation 79
Singleton bean concurrency control 80 Bean business
interface 83 Lifecycle callbacks 83 @Startup annotation 85
Using stateful singleton session beans effectively 85
Asynchronous session beans
Basics of asynchronous invocation 87 When to use
asynchronous session beans 88 ProcessOrder bean example 88
Using the @Asynchronous annotation 90 Using the Future
interface 91 Using asynchronous session beans effectively 91
Messaging and developing MDBs
Message-oriented middleware 94 Messaging in
ActionBazaar 95 Messaging models 97
JMS Message interface 100
Working with MDBs 102
When to use messaging and MDBs 103 Why use MDBs? 103
Developing a message consumer with MDB 104 Using the
@MessageDriven annotation 106 Implementing the
MessageListener 106 Using ActivationConfigProperty 107
Using bean lifecycle callbacks 110 Sending JMS messages
from MDBs 112 Managing MDB transactions 113
MDB best practices
EJB runtime context, dependency injection,
and crosscutting logic 117
Basics of EJB context 118 EJB context interfaces 119
Accessing the container environment through the EJB context 120
Using EJB DI and JNDI 121
JNDI primer for EJB 122 How EJB names are assigned 125
EJB injection using @EJB 128 When to use EJB injection 129
@EJB annotation in action 129 Resource injection using
@Resource 132 When to use resource injection 133
@Resource annotation in action 133 Looking up resources
and EJBs from JNDI 137 When to use JNDI lookups 138
Application client containers 138 Embedded containers 139
Using EJB injection and lookup effectively 141 EJB versus
CDI injection 141
AOP in the EJB world: interceptors
What is AOP? 143 Interceptor basics 143 When to
use interceptors 144 How interceptors are implemented 144
Specifying interceptors 145 Interceptors in action 148
Using interceptors effectively 154 CDI versus
EJB interceptors 154
Transactions and security 160
Transaction basics 162 Transactions in Java 164
Transactions in EJB 165 When to use transactions 167
How EJB transactions are implemented 167
Two-phase commit 169 JTA performance 170
Snag-it ordering using CMT 171 @TransactionManagement
annotation 172 @TransactionAttribute annotation 172
Marking a CMT for rollback 176 Transaction and
exception handling 177 Session synchronization 179
Using CMT effectively 179
Snag-it ordering using BMT 181 Getting a UserTransaction 181
Using user transactions 182 Using BMT effectively 184
Authentication versus authorization 185 User, groups,
and roles 186 How EJB security is implemented 186
EJB declarative security 190 EJB programmatic security
Using EJB security effectively 194
Scheduling and timers 196
Timer Service features
Timer interface 200
197 Time-outs 199
Types of timers 202
@Schedule annotation 203 @Schedules annotation 203
@Schedule configuration parameters 204 Declarative timer
example 204 Cron syntax rules 206
Using programmatic timers 208
Understanding programmatic timers 208 Programmatic timer
example 210 Using EJB programmatic timers effectively 211
Exposing EJBs as web services 214
What is a web service?
Web service properties 215 Transports 216
Web service types 216 Java EE web service APIs
Web services and JSF 217
Exposing EJBs using SOAP (JAX-WS)
Basics of SOAP 218 When to use SOAP web services 222
When to expose EJBs as SOAP web services 222
SOAP web service for ActionBazaar 223 JAX-WS
annotations 227 Using EJB SOAP web services effectively 231
Exposing EJBs using REST (JAX-RS)
Basics of REST 233 When to use REST/JAX-RS 236
When to expose EJBs as REST web services 237 REST web
service for ActionBazaar 238 JAX-RS annotations 241
Using EJB and REST web services effectively 246
Choosing between SOAP and REST 247
PART 3 USING EJB WITH JPA AND CDI......................251
JPA entities 253
Introducing JPA 254
Impedance mismatch 254
and JPA 255
Relationship between EJB 3
Introducing domain models 256
domain model 256
Implementing domain objects with JPA
@Entity annotation 260 Specifying the table 261
Mapping the columns 265 Temporal types 269
Enumerated types 269 Collections 270
Specifying entity identity 272 Generating primary keys
One-to-one relationships 281 One-to-many and many-to-one
relationships 283 Many-to-many relationships 285
Mapping inheritance 287
Single-table strategy 288 Joined-tables strategy
Table-per-class strategy 290
Managing entities 294
EntityManager interface 295 Lifecycle of an entity 297
Persistence context, scopes, and the EntityManager 300
Using EntityManager in ActionBazaar 302 Injecting the
EntityManager 302 Injecting the EntityManagerFactory 305
Persisting entities 307
Updating entities 313
Dynamic queries 318
Retrieving entities by key
Deleting entities 316
Named queries 318
Statement types 322
SELECT clause 334
Joining entities 338
FROM clause 324
Ordering results 336
Bulk updates and deletes 340
Meta-model API 341 CriteriaBuilder 344
CriteriaQuery 345 Query root 346 FROM clause 349
SELECT clause 349
Native queries 352
Using dynamic queries with native SQL 353 Using a named
native SQL query 353 Using stored procedures 355
Using CDI with EJB 3 359
CDI services 361 Relationship between CDI and EJB 3 364
Relationship between CDI and JSF 2 365
CDI beans 365
How to use CDI beans 366 Component naming
and EL resolution 366 Bean scoping 368
Next generation of dependency injection
Injection with @Inject 370 Producer methods 372
Using qualifiers 374 Disposer methods 375
Specifying alternatives 376
Interceptor and decorators
Component stereotypes 382
Injecting events 383
Using conversations 386
Using CDI effectively with EJB 3
PART 4 PUTTING EJB INTO ACTION ...........................395
Packaging EJB 3 applications
Packaging your applications
Dissecting the Java EE module system
EE module 401
Loading a Java
Exploring class loading 403
Class-loading basics 403 Class loading in Java EE
applications 404 Dependencies between Java EE modules 404
Packaging session and message-driven beans
Packaging EJB-JAR 407 Packaging EJB in WAR 409
XML versus annotations 412 Overriding annotations
with XML 415 Specifying default interceptors 416
Persistence module 417 Describing the persistence module
with persistence.xml 419
CDI modules 421 Using the beans.xml deployment
descriptor 421 Using the bean-discovery-mode annotation
Best practices and common deployment issues
Packaging and deployment best practices
common deployment problems 425
Using WebSockets with EJB 3 427
Limits of request–response 427
Introducing WebSockets 429
WebSockets basics 429
WebSockets versus Comet
WebSockets versus AJAX 432
WebSockets and Java EE
WebSocket endpoints 436 Session interface 437
Decoders and encoders 440
WebSockets in ActionBazaar
Using programmatic endpoints 445
Using annotated endpoints 448
Using WebSockets effectively
Testing and EJB 458
Unit testing EJBs 461
Integration testing using embedded EJBContainer
Integration testing using Arquillian
Deployment descriptor reference 480
Getting started with Java EE 7 SDK 489
EJB 3 developer certification exam 503
In its early days, EJB was inspired by the distributed computing ideas of technologies
such as CORBA and was intended to add scalability to server-side applications. EJB and
J2EE enjoyed some of the greatest buzz in the industry during the dot.com boom.
The initial goal for EJB was to provide a simpler alternative to CORBA through the
benefits of a standard development framework and reusable components. By the time
EJB 2 was released, it became apparent that the EJB framework could become the new
standard for server-side development. The framework provided Enterprise developers
with everything they needed—remoting, transaction management, security, state maintenance, persistence, and web services—but it was heavyweight, requiring developers
to focus more on the framework itself than on the requirements of their business
applications. Because EJB was loaded with more features, its inventors failed to address
its growing complexity.
As the community became disenchanted with the limitations of EJB 2, innovative
open source tools emerged. These tools were signs of the increasing discontent with
the complexities of Java EE. Though well-intentioned, these tools made Enterprise
development even more complex since they deviated from the standards of the application server they were to run in. It was time for the Java Community Process (JCP)
and expert groups to work on the simplification of Java EE development. That was the
sole motivation behind Java EE 5 and the goal of the EJB 3 expert group.
For a technology with a wide deployment base, the changes that came with EJB 3
were nothing short of stunning. EJB 3 successfully melds innovative techniques to
make component development as easy as possible. These techniques include the use
of annotations, metadata programming, dependency injection, AspectJ-like interceptors, and intelligent defaulting. The heavyweight inheritance-based programming
model was abandoned in favor of Plain Old Java Object (POJO) programming, and
the verbose XML descriptor was now out of the developer’s way.
The changes to the persistence model were particularly dramatic. EJB 3 left behind
the flawed EJB 2 Entity Beans model in favor of the lightweight Java Persistence API
(JPA). Unlike Entity Beans, JPA is not container-based. It has more in common with
open source object relational mapping (ORM) tools that emerged in the community
in response to Entity Beans complexity. JPA can be used either inside or outside a Java
Enterprise server and is now the de facto persistence standard for Java. Its Java Persistence Query Language (JPQL) standardizes object relational queries but also supports
native SQL queries if the need arises.
The changes made in EJB 3 have been well received in the Java community. Its simplified specification has led to its wide adoption in new projects. More and more companies are giving the once “ugly” EJB technology another look and they like what they
see. With the release of EJB 3.2, the adoption will continue to grow. EJB 3.2 has made
support for EJB 2 optional so that older technology can finally be sunset and innovations in EJB 3 can continue to grow. EJB 3.2 has also seen major enhancements to
message-driven beans (MDBs), making messaging much easier. EJB 3.2 made improvements to stateful session bean passivation and session bean local interfaces, as well as
dramatic improvements to the timer services. All this and more await you in EJB 3.2.
Since EJB is POJO-based, every Java developer can easily become an EJB developer.
Simple annotations give your business logic safe transaction management, security,
and exposure as web services for easy interoperability in your company. We strive to
keep our book different from other books on EJB by providing practical examples,
best practices, and tips for performance tuning. We highlight what’s new in the EJB 3.2
specification, which gives you more tools for your development. We hope this revised
edition will help you to quickly learn how to use EJB 3 effectively in your next Enterprise application.
Authoring a book requires great effort and it’s difficult to list everyone who helped us
during this project. First and foremost we’d like to thank everyone at Manning for
their encouragement and support, especially publisher Marjan Bace, associate publisher Michael Stephens, and our editor Nermina Miller. We’d also like to thank others at Manning who worked on different stages of the project: review editor Olivia
Booth; project editor Jodie Allen; development manager Maureen Spencer; technical
proofreader Deepak Vohra, who performed a final review of the book shortly before it
went to press; Linda Recktenwald and Melody Dolab, who edited, proofread, and polished our prose; and typesetter Dennis Dalinnik, who converted our Word documents
into a real book! Thanks also to all of those who worked behind the scenes to help get
our book published.
Many reviewers spent their valuable time reading the manuscript at various stages
of its development, and their feedback greatly improved the quality of the book. We’d
like to thank Artur Nowak, Aziz Rahman, Bob Casazza, Christophe Martini, David
Strong, Jeet Marwah, John Griffin, Jonas Bandi, Josef Lehner, Jürgen De Commer,
Karan Malhi, Khalid Muktar, Koray Güclü, Luis Peña, Matthias Agethle, Palak Mathur,
Pavel Rozenblioum, Rick Wagner, Sumit Pal, Victor Aguilar, Wellington Pinheiro, and
Finally, thanks to the readers of Manning’s Early Access Program (MEAP), who
read our chapters as they were being written and posted comments and corrections in
the book’s online forum. Your input has made this a better book.
I’d like to thank my wife, Renuka, for her immense support and continuous encouragement and for her patience with all the late nights, early mornings, and weekends
that I spent on the first edition of the book. I’d also like to thank my kids, Nistha and
Nisheet, who had to share their bapa with the computer during that time.
Many thanks to my coauthors Reza Rahman, Ryan Cuprak, and Michael Remijan,
who worked hard on the second edition of the book.
A journey of a thousand miles begins with a single step.
When I decided to take on writing the first edition of this book, I don’t think any of
the authors were certain how successful the book was going to be or where it might
take us personally. Today I have the luxury of hindsight in saying the book has been a
resounding success and that writing it was the first step of a whirlwind journey over the
past few years that I could have never foreseen. I must confess I continue to enjoy
every minute of it. Since finishing the first edition, I’ve become increasingly more
engaged with the Java community. I’ve contributed to various Java EE expert groups,
including the EJB expert group, had the once-in-a-lifetime opportunity to write an
open source EJB container almost from scratch, and now find myself at the forefront
of the Java EE evangelism team at SunOracle.
One casualty of all of this has been my own personal bandwidth, which was more
abundant when I wrote the first edition. This is a large part of why we had to skip a
Java EE 6 and EJB 3.1 edition of this book. I do think it’s all for the best since Java EE 7 is
an even stronger and more compelling platform, as this edition will demonstrate. I’m
extremely grateful to Michael and Ryan for taking ownership of the book and being
instrumental in producing a worthy second edition. I’m also grateful to the many
folks like you in the Java EE community that I’ve had the privilege to serve and work
with. Lastly, I’m ever thankful to my wife Nicole and daughter Zehra for allowing me
to pursue my passion without reservation. And so the journey continues.
Writing this book would not have been possible without the support of family and
friends. I’d especially like to thank the love of my life, Elsa, who has supported and
encouraged me throughout the long, arduous process and the many long nights I was
hunched over the computer. Finally, I’d like to thank Reza for recruiting me to this
project and encouraging me to take a second look at Java EE many years ago.
My wonderful wife Kelly and my daughter Sophia are the first people I need to thank
when it comes to writing this book. It’s one of many adventures we’ve shared together,
and without their support while I worked early mornings, late nights, and weekends, I
wouldn’t have been able to do the research and writing necessary for a project this
big. Kelly is my best friend, who encourages me in all I do, and is the perfect one for
me—I love her dearly. I’m blessed with a remarkable family.
My coauthors Debu, Ryan, and Reza are next, and many thanks go to them. This
book was a team effort. EJB is a great technology with many, many features; hence the
size of this book. It’d be a monumental task for one person to write it on their own, so
the collaboration among us was essential for delivering this book. It was a great opportunity to work with such talented colleagues.
Finally, thanks to all the people at Manning who did countless reviews and kept the
book on track, especially Maureen Spencer and Jodie Allen. Christina Rudloff originally
recruited me into the project, and without her I wouldn’t have gotten involved.
about this book
EJB 3 is meant to recast Java server-side development into a mold you might not
expect. Therefore, we’ve tried to make this an EJB book you might not anticipate.
Most server-side Java books tend to be serious affairs—heavy on theory, slightly
preachy, and geared toward the advanced developer. While we easily fit the stereotype
of geeks and aren’t the funniest comedians or entertainers, we’ve tried to add some
color to our writing to keep this book as lighthearted and down-to-earth as possible.
The tone is intended to be friendly, conversational, and informal. We made a conscious effort to drive the chapter content with examples that are close to the realworld problems you deal with every day. In most cases, we introduce a problem that
needs to be solved, show you the code to solve it using EJB 3, and explore features of
the technology using the code.
We cover theory when it is necessary. We try to avoid theory for theory’s sake and to
make the discussion as lively as we can. The goal of this book is to help you learn EJB 3
quickly and effectively, not to be a comprehensive reference book. We don’t cover features you’re unlikely to use. Instead, we provide deep coverage of the most useful
EJB 3 features and its related technologies. We discuss various options so you can
make educated choices, warn you about common pitfalls, and tell you about battlehardened best practices.
If you’ve picked up this book, it’s unlikely you’re a complete newcomer to Java. We
assume you’ve done some work in Java, perhaps in the form of web development
using a presentation-tier technology like JSF, Struts, JSP, or Servlets. We assume you’re
familiar with database technologies such as JDBC and have at least a casual familiarity
ABOUT THIS BOOK
with SQL. You don’t need any experience with EJB 2.x to pick up this book; EJB 3 is
completely new. We don’t assume you know any of the Java EE technologies that EJB
is dependent on, such as the Java Naming and Directory Interface (JNDI), Java Remote
Method Invocation (RMI), and Java Messaging Service (JMS). In fact, we assume you’re
not familiar with middleware concepts like remoting, pooling, concurrent programming, security, and distributed transactions. This book is ideally suited for a Java developer with a couple of years’ experience who is curious about EJB 3.
You might find this book different from others in one more important way. EJB is a
server-side middleware technology. This means that it doesn’t live in a vacuum and
must be integrated with other technologies to fulfill its mission. Throughout the
book, we talk about how EJB 3 integrates with technologies like JNDI, JMS, JSF, JSP,
Servlets, AJAX, and even Swing-based Java SE clients.
This book is about EJB 3 as a standard, not a specific application server technology. For this reason, we avoid tying our discussion to any specific application
server implementation. Instead, the code samples in this book are designed to
run with any EJB 3 container or persistence provider. The website accompanying
this book at www.manning.com/EJB3inActionSecondEdition will tell you how you
can get the code up and running in GlassFish and Oracle Application Server 10g.
Maintaining the application server–specific instructions on the publisher’s website instead of in the book will allow us to keep the instructions up to-date with
the newest implementation details.
This book is divided into four parts.
Part 1 provides an overview of EJB. Chapter 1 introduces EJB 3 and EJB types,
makes the case for EJB 3, and provides an overview of changes introduced with EJB 3.2.
Chapter 2 gives you a first taste of EJB, building EJB as you build your first solution
using EJB technology.
Part 2 covers working with EJB components to implement your business logic.
Chapter 3 dives into the details of session beans and outlines best practices. Chapter 4
gives a quick introduction to messaging and JMS and covers MDB in detail. Chapter 5
covers advanced topics such as the EJB context, JNDI, resource and EJB injection, AOP
interceptors, and the application client container. Chapter 6 discusses transaction and
security. Chapter 7 introduces timers and new scheduling options. Chapter 8 exposes
EJB business logic as SOAP and RESTful web services.
Part 3 provides in-depth coverage of EJB 3’s relationship with JPA and CDI. Chapter 9
introduces domain modeling and how to map JPA entities to your domain. Chapter 10
covers managing JPA entities through CRUD operations. Chapter 11 introduces JPQL
and covers retrieval of data in-depth. Chapter 12 is an introduction to CDI and how it
complements EJB development.
Part 4 provides guidelines for putting EJB 3 into action in your enterprise. Chapter 13 discusses packaging EJBs and entities for deployment to a server. Chapter 14
ABOUT THIS BOOK
introduces web sockets, their relationship to EJBs, and asynchronous business logic
execution using the EJB concurrency utilities. Chapter 15 covers unit and integration
testing without the need for deployment to a running server.
The book has three appendixes. Appendix A is a reference on the ejb-jar.xml
deployment descriptor. Appendix B contains step-by-step instructions on downloading
and installing the Java EE 7 SDK, which includes Java SE 7, GlassFish 4, and NetBeans.
Appendix C provides information on Oracle’s EJB certification process and the EJB
Source code downloads
Appendix B provides step-by-step instructions on installation of the Java EE 7 SDK. The
source code for this book is available from http://code.google.com/p/action-bazaar/.
From here you can either clone the Git repository to get a copy of all of the examples
or you can download a prepared ZIP file that has all the code in it. The code was developed primarily in NetBeans, but all the examples are built with Maven, so they should
run in your favorite IDE.
A zip file with the source code is also available for download from the publisher’s
website at www.manning.com/EJB3inActionSecondEdition.
Source code conventions
Because of the example-driven style of this book, the source code was given a great
deal of attention. Larger sections of code in the chapters are presented as their own
listings. All code is formatted using fixed-width Courier font like this for visibility. All inside code, such as XML element names, method names, Java type names,
package names, variable names, and so on, are also formatted using Courier font.
Some code is formatted as Courier Bold to highlight important sections. Code
annotations are also sometimes used to point out important concepts. In some
cases, we’ve abbreviated the code to keep it short and simple. In all cases, the full
version of the abbreviated code is contained in the downloadable zip files. We
encourage you to set up your development environment for each chapter before
you begin reading it.
Purchase of EJB 3 in Action, Second Edition includes free access to a private web forum
run by Manning Publications where you can make comments about the book, ask
technical questions, and receive help from the authors and other users. To access
the forum and subscribe to it, point your web browser to www.manning.com/
EJB3inActionSecondEdition. This Author Online (AO) page provides information
on how to get on the forum once you’re registered, what kind of help is available,
and the rules of conduct on the forum.
Manning’s commitment to our readers is to provide a venue where a meaningful
dialog among individual readers and between readers and the authors can take place.
ABOUT THIS BOOK
It’s not a commitment to any specific amount of participation on the part of the
authors, whose contribution to the AO remains voluntary (and unpaid). We suggest
you try asking the authors some challenging questions, lest their interest stray!
The AO forum and the archives of previous discussions will be accessible from the
publisher’s website as long as the book is in print.
About the title
By combining introductions, overviews, and how-to examples, the In Action books are
designed to help you learn and remember. According to research in cognitive science,
the things people remember are things they discover during self-motivated exploration.
Although no one at Manning is a cognitive scientist, we’re convinced that for
learning to become permanent, it must pass through stages of exploration, play, and,
interestingly, retelling of what’s being learned. People understand and remember new
things—that is, they master them—only after actively exploring them. Humans learn
in action. An essential part of an In Action guide is that it’s example-driven. It encourages the reader to try things out, play with new code, and explore new ideas.
There is another, more mundane, reason for the title of this book: our readers are
busy. They use books to do a job or solve a problem. They need books that allow them
to jump in and jump out easily and learn just what they want just when they want it.
They need books that aid them in action. The books in this series are designed for
about the authors
DEBU PANDA is a seasoned product manager, technologist, and community leader. He
has authored more than 50 articles on Enterprise Java, Cloud, and SOA technologies
and two books on Enterprise middleware. Follow Debu on Twitter @debupanda.
REZA RAHMAN is a former long-time independent consultant and is now officially a
Java EE/GlassFish evangelist at Oracle. Reza is a frequent speaker at Java user groups
and conferences worldwide. He is an avid contributor to industry journals like
JavaLobby/DZone and TheServerSide. Reza has been a member of the Java EE, EJB, and
JMS expert groups. He implemented the EJB container for the Resin open source Java
EE application server.
RYAN CUPRAK is an e-formulation analyst at Dassault Systèmes (DS), author of the NetBeans Certification Guide from McGraw-Hill, and president of the Connecticut Java
Users Group since 2003. He’s also a JavaOne 2011 Rockstar Presenter. At DS he’s
focused on developing data integrations to convert clients’ data, as well as user interface development. Prior to joining DS, he worked for a startup distributed-computing
company, TurboWorx, and Eastman Kodak’s Molecular Imaging Systems group, now
part of Carestream Health. At TurboWorx he was a Java developer and a technical
sales engineer supporting both presales and professional services. Cuprak earned a BS
in computer science and biology from Loyola University Chicago. He is a Sun-certified
NetBeans IDE specialist.