Applying Enterprise JavaBeans(TM): Component-Based Development for the J2EE(TM) Platform [Paperback]

Vlada Matena (Author), Beth Stearns (Author)

Book Description

ISBN-10: 0201702673 | ISBN-13: 978-0201702675 | Publication Date: December 27, 2000 | Edition: Enterprise Ed

In this authoritative book, Sun's Enterprise JavaBeans architect demonstrates how to leverage the full power of EJB to deploy component-based enterprise systems faster, and more effectively. Start by understanding EJB's architecture and its interrelationships with the rest of Sun Microsystems' rich Java 2 Enterprise Edition platform for large-scale business development. Compare each architectural option for implementing EJB in your applications, and understand when to use each; review each element of an Enterprise JavaBean; then master container tools and services, EJB roles, session beans, entity beans, transactions, security, and more. The book includes extensive sample code, full-fledged application examples, and a complete API reference. It will be an ideal resource for everyone implementing Enterprise JavaBeans applications: in-house corporate developers, third-party developers creating EJB applications and reusable components; Java developers; architects, managers, and other IT professionals.

Editorial Reviews

Amazon.com Review

As an authoritative resource for using Enterprise JavaBeans (EJB) effectively to build and integrate even the largest systems, Applying Enterprise JavaBeans provides what IT managers and developers need to adopt this powerful component standard successfully in new Java projects.

Most books about EJB are strong on theory, but tend to leave out many details of how to implement components in real projects. That's where this text steps in, providing real code (and real design decisions) for implementing different kinds of JavaBeans, like session and entity Beans. Better yet, it contains a case study of a human resources benefits enrollment system that integrates data from different vendors and uses EJB to hold the data together. (Using fictitious vendor names like "Star Enterprise," "Wombat," and "Providence," the book shows how EJB can lead to successful enterprise integration.)

Subsequent chapters look at different aspects of this system, from session Beans (including stateful Beans used to manage sessions) to detailed examples of entity Beans in action. There are plenty of state transition diagrams (that show the inner workings of EJB in a variety of scenarios) and source code (useful for Java developers). Without actually anchoring this material in an actual application server (which would make the book even more practical), it does a good job of fleshing out the EJB standard for real projects, exposing what really goes on between application server "containers" and the Beans they manage, including activation and passivation states.

Final sections examine transactions and security options for components, including the use of declarative statements in XML descriptors to simplify these aspects of EJB design. Finally, there's a reference for built-in EJB classes and APIs.

Overall, this book can help put EJB within reach for programmers and managers. Its mix of practical expert advice and sample source code will help demystify EJB components and how to use them to create successful, state-of-the-art enterprise systems. --Richard Dragan

Topics covered:

• Two-tiered vs. J2EE application architectures
• Advantages of EJB
• Business rules
• The structure of EJB
• Roles for EJB users (including developers, system administrators, and deployers)
• Session Beans (stateful and stateless session Beans)
• Session Beans and containers (including passivation and activation)
• Entity Bean basics (the Bean life cycle, storing and loading Beans)
• Case study for a health benefits enrollment system (including application integration through EJB)
• Transactions in EJB (including declarative and programmatic transaction management)
• Managing security with Beans (including security roles and declarative security mechanisms)
• EJB API reference

From the Inside Flap

This book provides an in-depth coverage of the Enterprise JavaBeans™ architecture. It describes how to distribute enterprise applications using the EJB component architecture.

Readers of this book should be familiar with the Java™ programming language and have had some exposure to enterprise beans and the EJB architecture. Although we briefly cover the basics of the EJB architecture, this book is not meant to be a tutorial for those just getting started with enterprise beans. Instead, the book provides an in-depth coverage of the EJB architecture for IT personnel implementing applications in-house and for Independent Software Vendors (ISVs) developing generic applications for sale to enterprises.

The EJB architecture defines a component model for enterprise applications. It describes:

How to design an application as a set of components How the components interact with each other How the components interact with their EJB Container

The EJB architecture defines these interactions as contracts, and they enable applications to use components from different sources. Because EJB components must adhere to these contracts, an application can consist of software components from multiple vendors.

The EJB 1.1 specification defines the architecture contracts mainly from the point of view of the container vendor. In contrast, this book tries to present the EJB architecture from the point of view of the application developer, that is, the person who develops EJB applications.

A detailed description of the development of two enterprise applications forms the backbone of the book. While the example applications are relatively simple, they illustrate many of the typical problems encountered in enterprise application development. We use these examples to show how the EJB architecture helps developers solve these problems.

The first example is a benefits enrollment application developed in-house by an IT department. This application works well for explaining how a session bean works and for illustrating how developers use session beans.

The second example takes the benefits application from the first example, which was developed in-house, and turns it into an application developed by an ISV. An ISV has different design goals from that of an in-house IT department. The ISV must design the application such that it can be easily deployed in many different customers' operational environments. Because each customer has a unique operational environment, the ISV must address a number of challenges. In addition, an ISV typically needs to design the application such that the application can be extended by a customer or integrator. We illustrate how the entity bean architecture helps ISVs to overcome these challenges.

These two annotated examples illustrate many of the techniques for applying the EJB architecture to specific problems in enterprise application development. In addition to the two application examples, we describe the individual features of the EJB architecture and discuss when and how they should be used in applications.

Although the typical application developer does not need to know how the EJB Container works, we try to illustrate some of the inner workings of the EJB Container. We do this mainly to give the reader an appreciation of how much work the Container performs on behalf of the application. Other Sources of Information You should refer to other publications related to J2EE. The following books are of particular interest to those developing other application components besides enterprise beans:

Java™ 2 Platform, Enterprise Edition Specification, Version 1.2, Copyright 1999, Sun Microsystems, Inc.Java™ 2 Platform, Enterprise Edition Connector Specification, Copyright 2000, Sun Microsystems, Inc. Java™ 2 Platform, Enterprise Edition, Platform and Component Specification, Shannon, Hapner, Matena, Davidson, Pelegri-Llopart, Cable, Enterprise Team, Copyright 2000, Sun Microsystems, Inc. Enterprise JavaBeans™ 1.1 Specification, Final Release, Copyright 1999, 2000, Sun Microsystems, Inc. Enterprise JavaBeans™ 2.0 Specification, Public Draft, Copyright 2000, Sun Microsystems, Inc. Developing Enterprise Applications with the Java™ 2 Platform, Enterprise Edition, Version 1.0., Kassem, Enterprise Team, Copyright 2000, Sun Microsystems, Inc.

RMI over IIOP 1.0.Note About the Example Applications

It is important to note that the example application in Chapter 4, Working with Session Beans, and the entity bean application in Chapter 7, Entity Bean Application Example, are written without the use of an Interactive Development Environment (IDE). Normally, enterprise developers use a commercial IDE when developing EJB applications. An IDE generates much of the JDBC and other database access code—code that is often tedious to write by hand. However, we wanted our examples to illustrate how the EJB architecture works, and had we used an IDE, the code generated by the IDE would obscure the discussion of the EJB architecture. Therefore, we chose to manually write all the code. Keep this in mind and realize that developing with the EJB architecture is easier than some of our code samples might indicate since in practice a lot of the code would be generated automatically by the IDE.

Because our goal is to illustrate using the EJB architecture, we wanted to keep the code relatively simple. As a result, we don't always show what some developers would consider to be the best coding practices for enterprise applications. By including code to show such practices, we would have obscured the EJB discussion. For the sake of simplicity of the code examples, we sometimes do not handle properly all exceptions thrown by the code. Contents of the Book

The book begins by describing the advantages of the EJB architecture. Chapter 1, Advantages of the Enterprise JavaBeans Architecture, discusses the different enterprise application architectures and how they have evolved, especially with the growth of the Web. It describes the current state-of-the-art EJB and J2EE architectures, and how they are well-suited to meet today's enterprise computing needs.

Chapter 2, Enterprise JavaBeans Architecture Overview, provides a concise overview of the EJB architecture. For someone not so familiar with the EJB architecture, this chapter is a good starting point because it defines the EJB terminology and the structure of enterprise beans. It defines and describes EJB applications, and such basic concepts as business entities and business processes. It provides an overview of the different enterprise bean types, the parts that comprise an enterprise bean, and how to use enterprise beans to model business logic of enterprise applications.

The development of an EJB application can be thought of in terms of the tasks that need to be performed. To that end, Chapter 3, Enterprise JavaBeans Roles, delineates the roles and tasks involved in the application development process.

Once the stage has been set and the introductory material explained, the book focuses on session beans and entity beans. Two chapters focus on session beans and two chapters focus on entity beans. Chapter 4, Working with Session Beans, focuses on typical programming styles for applications using session beans. This chapter is of interest to Bean Developers implementing session beans and to application programmers developing session bean clients. For Bean Developers, the chapter describes how best to implement the methods of a session bean. For application programmers developing session bean clients, it shows how to properly use the session bean home and remote interfaces. An extensive Benefits Enrollment Application example illustrates the key points about session beans.

Chapter 5, Session Bean in its Container, describes the support and services that an EJB Container provides for a session bean. Containers typically provide services to session beans when they are deployed and customized for a particular operational environment, and at runtime, when a client application invokes the session bean. Although the Container services are hidden from the Bean Developer and the client programmer, these services go a long way to simplifying bean and application development. This chapter describes much of what goes on behind the scenes.

After completing its discussion of session beans, the book shifts its focus to entity beans. Entity beans differ significantly from session beans. Chapter 6, Understanding Entity Beans, combines a presentation of the basic concepts regarding programming with entity beans, from both the client and Bean Developer points of view, along with a discussion of the services that the Container provides to entity beans. This chapter is analogous to Chapter 5 for session beans. The chapter also provides a detailed description of strategies for managing entity object state. Chapter 7, Entity Bean Application Example, takes the Benefits example application used for session beans and shows how to write the same application using entity beans. The example illustrates many of the techniques for working with entity beans. It also illustrates how entity beans can be used by ISVs to make their application reusable across many customers' operational environments.

Virtually all applications using enterprise beans rely on transactions. Chapter 8, Understanding Transactions, describes the EJB architecture approach to transaction demarcation. It covers the essential aspects of transactions necessary for application developers.

Security is another area of critical importance to enterprise applications. The EJB architecture provides declarative support for security management. Chapter 9, Managing Security, describes the EJB security environment, particularly from the point of view of the application developer.

Last, the book includes an appendix containing the API reference, a second appendix that contains code samples of supporting classes, and a glossary of terms. The reference section contains all the interfaces defined by the EJB architecture as well as the methods within each interface.

0201702673P04062001

See all Editorial Reviews

Product Details

• Paperback: 436 pages
• Publisher: Pearson Education; Enterprise Ed edition (December 27, 2000)
• Language: English
• ISBN-10: 0201702673
• ISBN-13: 978-0201702675
• Product Dimensions: 9.1 x 7.3 x 1 inches
• Shipping Weight: 1.4 pounds
• Average Customer Review: 3.7 out of 5 stars  See all reviews (15 customer reviews)
• Amazon Best Sellers Rank: #3,892,205 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

69 of 70 people found the following review helpful:

4.0 out of 5 stars Useful but not the best EJB book, January 27, 2001

By 

Eric L. Ma - See all my reviews

This review is from: Applying Enterprise JavaBeans(TM): Component-Based Development for the J2EE(TM) Platform (Paperback)

This book is similar in content to the Monson-Haefel EJB 1.1 book. For EJB beginners, it is somewhat more readable than the latter book, and complete blocks of code are given (for an entire EJB bean class for example) in the book pages. However, as a book that only covers EJB 1.1 spec and is not application server specific, it is rather late to the market and as a result its value is somewhat reduced.

The pluses of the book: the strongest selling point of the book is that it does an excellent job in explaining the EJB API (this may be attributed to the fact that the leading author of the book is a member of the Sun's J2EE architecture team). Things I find very useful include discussions on varies methods defined in the EJBObject and EJBHome and the Bean interfaces, the different life cycle behaviors among various type of EJB's, the container-bean contract, and container services such as transaction management and security control, all in a very clear manner. Although there is no integrated application in the book, unlike the Wrox Press's WebLogic book, the EJB design in this book is more sophisticated. The best practices of using value objects, dependent classes, helper classes, and database connection are all well-demonstrated throughout the code and clearly explained.

The minuses of the book: in addition to the ones I mentioned earlier, this book does not have a companion website to allow one to download the source code. It doesn't provide instructions to set up an EJB server to run the samples, and coverage on how to invoke EJB's from JSP and Java clients is limited.

My suggestion: if you are new to EJB and don't care too much about the upcoming EJB 2.0 CMP service and message-driven beans at this point, this is a good alternative to the Monson-Haefel book. On the other hand, if you already own other EJB books or have hands-on experience, I think you should wait for the 2nd Ed. of the book by Ed Roman et al. to come out in the summer. As a side note, from what I understand the new Roman book promises to cover all the new EJB 2.0 stuff and uses WebLogic 6.0 for its samples.

7 of 7 people found the following review helpful:

5.0 out of 5 stars Excellent, January 28, 2001

By A Customer

This review is from: Applying Enterprise JavaBeans(TM): Component-Based Development for the J2EE(TM) Platform (Paperback)

The first EJB book I've seen with the actual SQL for the tables it uses. The book does not state it's compliance, but I am very familiar with the 1.1 spec and it covers the 1.1 spec with nothing new from my perspective, so I assume it's 1.1 compliant. The book is short and sweet with plenty of examples. The title's keyword of "applying" is exactly correct. It shows application and not theory. If you want theory go for Enterprise Javabean's by O'Reilly. When you are done with that and ready for practical applications, come to this book. I highly recomend it for applying EJB.

6 of 6 people found the following review helpful:

5.0 out of 5 stars Top Notch, Clear Thinking, February 13, 2001

By 

computer/music geek (Arlington, VA USA) - See all my reviews

This review is from: Applying Enterprise JavaBeans(TM): Component-Based Development for the J2EE(TM) Platform (Paperback)

The author expends his time and energy explaining the basics of J2EE platform and the intuition that went into developing the specification. Once you get the basics, you can equip yourself with the advanced stuff either from specialized books or from the manuals. The are some spots where the evangelizing gets a bit much. But hey it's crisp, clear and concise (done in 352 pages). If you want to develop a system you need to get a more "tutorial" type of book such as that of the wrox team, or from ths sun website. Buying a tools book may prove useless as the application/web containers versions change often and you may want to invest in that only closer the job one!