OReilly.Enterprise.Javabeans 3rd Edition.pdf

EJB 3RD EDITION - Richard Monson-Haefel

Authors’ Note

In the winter of 1997 I was working on a distributed object project using Java

RMI. Not surprisingly, the project failed miserably because Java RMI didn’t

address performance, scalability, fail-over, security, and transactions; qualities of

service that are so vital in a production environment. Although that lesson was

not new for me—I had seen the same thing happen with CORBA—the timing of

the project was especially interesting. It was at that same time Enterprise

JavaBeans was first introduced by Sun Microsystems – had Enterprise

JavaBeans been available earlier, that same project probably would have

succeeded.

At the time I was working on that ill-fated Java RMI project, I was also writing a

column for JavaReport Online called the “The Cutting Edge”. The column

covered what were then, new Java technologies like Java Naming and Directory

Interface (JNDI) and the JavaMail API. I was actually looking for a new topic for

the 3 rd edition of “The Cutting Edge”, when I discovered the first public draft of

Enterprise JavaBeans, version 0.8. I had first heard about this technology in 1996,

but this was the first time anything public has been available. Having worked on

CORBA, Java RMI and other distributed object technologies, I knew a good

thing when I saw it and immediately began writing an article about this new

“Enterprise JavaBeans”. Although the article in question has long since been

lost in the ether of the Internet, it was at that time the first article ever written on

Enterprise JavaBeans.

That seems like eons ago. Since I published that article in March 1998, literally

hundreds of articles have been written on Enterprise JavaBeans and several

books have come and gone on the subject. Over the past three years this book

has kept pace with three versions of the EJB specification and in its 3 rd edition is

considered by many, to my enormous satisfaction, to be the best book on

Enterprise JavaBeans. As the newest version of the specification takes flight

and a slew of new books on the subject daybew I can’t help but remember the

days when the words “Enterprise JavaBeans” drew blank looks from just about

everyone. I’m glad those days are over.

What Is Enterprise JavaBeans?

When Java™ was first introduced in the summer of 1995, most of the IT industry

focused on its graphical user interface characteristics and the competitive

advantage it offered in terms of distribution and platform independence. Those

were interesting times. The Applet was king, and only a few of us were

attempting to use it on the server side. I reality we spent about half our time

coding and the other half trying to convince management that Java was not a

fad.

Today, the focus has broadened considerably: Java has been recognized as an

excellent platform for creating enterprise solutions, specifically for developing

distributed server-side applications. This shift has much to do with Java’s

emerging role as a universal language for producing implementation-independent

abstractions for common enterprise technologies. The JDBC™ API is the first

and most familiar example. JDBC provides a vendor-independent Java interface

for accessing SQL relational databases. This abstraction has been so successful

that it’s difficult to find a relational database vendor that doesn’t support JDBC.

Java abstractions for enterprise technologies have expanded considerably to

include JNDI (Java Naming and Directory Interface™) for abstracting directory

services, JTA (Java Transaction API) for abstracting access to transaction

managers, JMS™ (Java Messaging Service) for abstracting access to different

message-oriented middleware products, and so on.

Enterprise JavaBeans™ was first introduced as a draft specification in late 1997

and has since established itself as one of the most important Java enterprise

technologies provided by Sun Microsystems. Enterprise JavaBeans (EJB)

provides an abstraction for component transaction monitors (CTMs).

Component transaction monitors represent the convergence of two technologies:

traditional transaction processing monitors, such as CICS, TUXEDO, and Encina,

and distributed object services, such as CORBA (Common Object Request

Broker Architecture), DCOM, and native Java RMI. Combining the best of both

technologies, component transaction monitors provide a robust, component-

based environment that simplifies distributed development while automatically

managing the most complex aspects of enterprise computing, such as object

brokering, transaction management, security, persistence, and concurrency.

Enterprise JavaBeans (EJB) defines a server-side component model that allows

business objects to be developed and moved from one brand of EJB container to

another. A component (an enterprise bean) presents a simple programming model

that allows the developer to focus on its business purpose. An EJB server is

responsible for making the component a distributed object and for managing

services such as transactions, persistence, concurrency, and security. In

addition to defining the bean’s business logic, the developer defines the bean’s

runtime attributes in a way that is similar to choosing the display properties of

visual widgets. The transactional, persis tence, and security behaviors of a

component can be defined by choosing from a list of properties. The end result is

that Enterprise JavaBeans makes developing distributed component systems that

are managed in a robust transactional environment much easier. For developers

and corporate IT shops that have struggled with the complexities of delivering

mission-critical, high-performance distributed systems using CORBA, DCOM, or

Java RMI, Enterprise JavaBeans provides a far simpler and more productive

platform on which to base development efforts.

When Enterprise JavaBeans 1.0 was finalized in 1998, it quickly become a de

facto industry standard. Many vendors announced their support even before the

specification was finalized. Since that time Enterprise JavaBeans has been

enhanced twice: The specification was first updated in 1999 to version 1.1, which

was covered by the 2 nd edition. The most recent revision to the specification,

version 2.0, is covered by this, the 3 rd edition of O’Reilly’s EJB book. This 3 rd

edition also covers EJB 1.1, which is for the most part a subset of functionality

offered by EJB 2.0.

Products that conform to the EJB standard have come from every sector of the IT

industry, including the TP monitor, CORBA ORB, application server, relational

database, object database, and web server industries. Some of these products are

based on proprietary models that have been adapted to EJB; many more

wouldn’t even exist without EJB.

In short, Enterprise JavaBeans 2.0 and 1.1 provides a standard distributed

component model that greatly simplifies the development process and allows

beans that are developed and deployed on one vendor’s EJB server to be easily

deployed on a different vendor’s EJB server. This book will provide you with the

foundation you need to develop vendor-independent EJB solutions.

Who Should Read This Book?

This book explains and demonstrates the fundamentals of the Enterprise

JavaBeans 2.0 and 1.1 architecture. Although EJB makes distributed computing

much simpler, it is still a complex technology that requires a great deal of time to

master. This book provides a straightforward, no-nonsense explanation of the

underlying technology, Java classes and interfaces, component model, and

runtime behavior of Enterprise JavaBeans. It includes material that is backward

compatible with EJB 1.1 and provides special notes and chapters when there are

significant differences between 1.1 and 2.0.

Although this book focuses on the fundamentals, it’s no “dummies” book.

Enterprise JavaBeans embodies an extremely complex and ambitious enterprise

technology. While using EJB may be fairly simple, the amount of work required

to truly understand and master EJB is significant. Before reading this book, you

should be fluent with the Java language and have some practical experience

developing business solutions. Experience with distributed object systems is not

a must, but you will need some experience with JDBC (or at least an

understanding of the basics) to follow the examples in this book. If you are

unfamiliar with the Java language, I recommend that you pick up a copy of

Learning Java™ by Patrick Neimeyer and Jonathan Knudsen, formerly

Exploring Java™ , (O’Reilly). If you are unfamiliar with JDBC, I recommend

Database Programming with JDBC™ and Java™, 2 nd Edition by George Reese

(O’Reilly). If you need a stronger background in distributed computing, I

recommend Java™ Distributed Computing by Jim Farley (O’Reilly).

Organization

Here’s how the book is structured. The first three chapters are largely

background material, placing Enterprise JavaBeans 2.0 and 1.1 in the context of

related technologies, and explaining at the most abstract level how the EJB

technology works and what makes up an enterprise bean. Chapters 4 through 13

go into detail about developing enterprise beans of various types. Chapters 14

and 15 could be considered “advanced topics,” except that transactions

(Chapter 14) are essential to everything that happens in enterprise computing,

and design strategies (Chapter 15) help you deal with a number of real-world

issues that influence bean design. Chapter 16 describes in detail the XML

deployment descriptors used in EJB 2.0 and 1.1. Finally, Chapter 17 is an

overview of the Java™ 2, Enterprise Edition (J2EE) includes Servlets, JSP and

EJB.

Chapter 1, Introduction

This chapter defines component transaction monitors and explains how they

form the underlying technology of the Enterprise JavaBeans component

model.

Chapter 2, Architectural Overview

This chapter defines the architecture of the Enterprise JavaBeans

component model and examines the difference between the three basic types

of enterprise beans: entity beans, session beans, and message-driven beans.

Chapter 3, Resource Management and the Primary Services

This chapter explains how the EJB-compliant server manages an enterprise

bean at runtime.

Chapter 4, Developing Your First Enterprise Beans

This chapter walks the reader through the development of some simple

enterprise beans.

Chapter 5, The Client View

This chapter explains in detail how enterprise beans are accessed and used

by a remote client application.

Chapter 6, EJB 2.0 CMP: Basic Persistence

This chapter provides an explanation of how to develop basic container-

managed entity beans in EJB 2.0

Chapter 7, EJB 2.0 CMP: Entity Relationships

This chapter picks up where Chapter 6 left off, expanding your

understanding of container-managed persistence to complex bean-to-bean

relationships

Chapter 8, EJB 2.0 CMP: EJB QL

This chapter addresses the Enterprise JavaBeans Query Language (EJB QL),

which is used to query EJBs and locate specific entity beans in EJB 2.0

container-managed persistence.

Chapter 9, EJB 1.1: Container-Managed Persistence

This chapter covers EJB 1.1 container-managed persistence, which is

supported in EJB 2.0 for backward compatibility. Read this chapter only if

you need to support legacy EJB applications.

Chapter 10, Bean-Managed Persistence

This chapter covers the development of bean-managed persistence beans

including when to store, load, and remove data from the database.

Chapter 11, Entity-Container Contract

This chapter covers the general protocol between an entity bean and its

container at runtime and applies to container-managed persistence in EJB 2.0

and 1.1, as well as bean-managed persistence.

Chapter 12, Session Beans

This chapter shows how to develop stateless and stateful session beans.

Chapter 13, Message-Driven Beans

This chapter shows how to develop message-driven beans in EJB 2.0.

Chapter 14, Transactions

This chapter provides an in-depth explanation of transactions and describes

the transactional model defined by Enterprise JavaBeans.

Chapter 15, Design Strategies

This chapter provides some basic design strategies that can simplify your

EJB development efforts and make your EJB system more efficient.

Chapter 16, XML Deployment Descriptors

This chapter provides an in-depth explanation of the XML deployment

descriptors used in EJB 1.1 and 2.0.

Chapter 17, Java 2, Enterprise Edition

This chapter provides an overview of the Java 2, Enterprise Edition 1.3 and

explains how 2.0 fits into this new platform.

Appendix A, The Enterprise JavaBeans API

This appendix provides a quick reference to the classes and interfaces

defined in the EJB packages.

Appendix B, State and Sequence Diagrams

This appendix provides diagrams that clarify the life cycle of enterprise

beans at runtime.

Appendix C, EJB Vendors

This appendix provides information about the vendors of EJB servers.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: