Enterprise Javabeans: Developing Component-Based Distributed Applications

by Valesky, Thomas C.

• ISBN13: 9780201604467
• ISBN10: 0201604469
• Edition: CD
• Format: Paperback
• Copyright: 1999-05-01
• Publisher: Prentice Hall

Summary

Enterprise JavaBeans powerful extend the advantages of component development to middle-tier and server-side applications. With this targeted, hands-on guide, working developers can get results with Enterprise JavaBeans fast, even if they've never built distributed systems before. Begin with an overview of Enterprise JavaBeans: its architecture, its components, and its compelling advantages. Next, start coding, and walk through each stage of Enterprise JavaBean development. Master stateful and stateless session beans; as well as bean-managed and container-managed entity beans. Discover how to write client programs that use serverside Enterprise JavaBeans; how to package and deploy Enterprise JavaBeans; and much more. You'll find expert tips and rules-of-thumb for constructing distributed systems; a detailed walkthrough of building a networked time management system; a preview of the future of the Enterprise JavaBeans spec; and much more.

Table of Contents

Foreword	xix
Preface	xxiii
The Big Picture	1	(16)
Introduction	1	(1)
Transaction Processors	1	(3)
ACID Properties of Transactions	3	(1)
OLTP Versus OLAP	3	(1)
Two-Tier, Client-Server Architecture	4	(3)
Three-Tier Architecture	7	(5)
Sockets	8	(1)
RPCs	9	(1)
CORBA	9	(1)
RMI	10	(1)
OLE/DCOM	11	(1)
Message Queues	11	(1)
Distributed Transaction Processing	12	(1)
EJB's Role	13	(3)
Conclusion	16	(1)
EJB's Architecture	17	(32)
Logical Architecture	17	(1)
Overview of EJB's Software Architecture	18	(23)
EJB Servers	19	(2)
EJB Containers	21	(5)
Enterprise Beans	26	(15)
A High-Level View of an EJB Conversation	41	(2)
Finding the Bean	42	(1)
Getting Access to a Bean	43	(1)
Calling the Bean's Methods	43	(1)
Getting Rid of the Bean	43	(1)
RMI Clients	43	(1)
CORBA Clients	44	(1)
Building and Deploying EJBs	45	(1)
Writing the EJB	45	(1)
Deploying the EJB	46	(1)
Connecting to the EJB	46	(1)
Roles in EJB	46	(3)
Enterprise Bean Provider	46	(1)
Deployer	47	(1)
Application Assembler	47	(1)
EJB Server Provider	47	(1)
EJB Container Provider	48	(1)
System Administrator	48	(1)
Hello, EJB!	49	(22)
Requirements	49	(1)
Design	50	(1)
Implementation	51	(17)
Create the Remote Interface for the Bean	51	(3)
Create the Bean's Home Interface	54	(2)
Create the Bean's Implementation Class	56	(3)
Compile the Remote Interface, Home Interface, and Implementation Class	59	(1)
Create a Session Descriptor	59	(3)
Create a Manifest	62	(1)
Create an ejb-jar File	63	(1)
Deploy the ejb-jar File	63	(1)
Write a Client	64	(3)
Run the Client	67	(1)
What's Really Going on Here?	68	(2)
Conclusion	70	(1)
Writing EJB Session Beans	71	(32)
When to Use Session Beans	71	(1)
Constraints on Session Beans	71	(2)
Session Bean Life Cycle	73	(5)
Transactions and EJB	78	(2)
Stateful Session Bean Example	80	(11)
Requirements	80	(1)
Design	81	(2)
Implementation	83	(8)
Summing Up the Stateful Session Bean Example	91	(1)
Stateless Session Bean Example	91	(10)
Requirements	91	(1)
Design	92	(1)
Implementation	92	(8)
Deploying the Example	100	(1)
Conclusion	101	(2)
Writing EJB Entity Beans	103	(22)
When to Use Entity Beans	103	(2)
Concurrent Use by Several Clients	104	(1)
Long Lifetime	104	(1)
Survival of Server Crashes	104	(1)
Direct Representation of Data in an Underlying Database	105	(1)
Bean-Managed Versus Container-Managed Persistence	105	(1)
Primary Keys	106	(1)
Entity Bean Life Cycle	106	(3)
Nonexistence	107	(1)
The Pooled State	108	(1)
The Ready State	108	(1)
Reentrant Instances	109	(1)
Example: Container-Managed Persistence	109	(7)
Requirements	109	(1)
Design	109	(1)
Implementation	110	(6)
Example: Bean-Managed Persistence	116	(8)
Requirements	116	(1)
Design	116	(1)
Implementation	117	(7)
Conclusion	124	(1)
EJB Clients	125	(34)
An EJB Bean as a Client to Another Bean	125	(4)
The Home Interface	125	(1)
The Remote Interface	126	(1)
The EJB Client Bean	126	(2)
The Client	128	(1)
Serializing a Handle	129	(5)
The Client	129	(5)
Invoking the Client	134	(1)
Transactions in Clients	134	(3)
Authentication in Clients	137	(2)
Getting Metadata	139	(4)
A Servlet Client	143	(6)
HTML to Make a Call to the Servlet	146	(3)
Setting Up Web Logic Servlets	149	(1)
An Applet Client	149	(4)
The Applet Tag	152	(1)
CORBA Client Example	153	(3)
What to Look for in a CORBA-Compliant EJB Implementation	156	(1)
HTTP Tunneling and SSL	156	(1)
Conclusion	157	(2)
Deployment	159	(24)
The Depolyment Descriptor Class	159	(6)
The Access Control Entry Class	161	(1)
Back to the Deployment Descriptor Class (I)	162	(1)
The Control Descriptor Class	163	(1)
``Run-as'' Modes	164	(1)
Back to the Deployment Descriptor Class (II)	165	(1)
The Session Descriptor Class	165	(2)
The Entity Descriptor Class	167	(1)
Example Program	168	(5)
The Home Interface	168	(1)
The Remote Interface	168	(1)
The Bean Implementation Class	169	(1)
The Client	170	(3)
Using Roles at Runtime	173	(1)
The ReadDD Class	174	(3)
The Deployment Descriptor	177	(2)
Setting Up Access Control Lists	178	(1)
Container-Managed Finder Methods	178	(1)
Other Deployment Issues	179	(3)
Caching Issues	179	(1)
Persistent Storage	180	(1)
Properties	180	(1)
Other Administrative Issues	180	(2)
Conclusion	182	(1)
Tips, Tricks, and Traps for Building Distributed and Other Systems	183	(20)
Expect Your Network Connections to Fail	183	(1)
Test Catastrophic Failure	184	(1)
Avoid Remote Method Invocations Where Possible	184	(1)
Treat Transactions and Database Connections as Precious Resources	184	(1)
Monitor the Granularity of Objects	185	(1)
Monitor the Granularity of Methods	185	(1)
Isolate Vendor-Specific Code	185	(1)
Avoid Making Entity Beans Reentrant	185	(1)
Observe Programming Restrictions on EJB Beans	186	(1)
Don't Implement the Bean's Remote Interface in Its Implementation Class	186	(1)
Use Relatively Small and Well-Defined Queries	187	(1)
Don't Keep Database Cursors Open	187	(1)
Minimize Transactions	187	(1)
Minimize Distributed Transactions	188	(1)
Avoid Indexing Your Tables	188	(1)
Remember That Memory Is Cheap	188	(1)
Build in Upward-Scalability	188	(1)
Wrap Entity Beans with Session Beans	189	(1)
Streamline Your Middleware Methods	189	(1)
Put Your Business Logic in the Middle Tier	189	(1)
Understand the Tradeoffs Between Isolation Level and Concurrency	189	(1)
Avoid Extensive Object Allocation and Deallocation	190	(1)
Prototype, Prototype, Prototype	190	(1)
Do Load Testing	190	(1)
Monitor the Size of Your User Base When Designing an Architecture	190	(1)
Separate Transaction-Processing Tables from Reporting Tables	191	(1)
If a Database Query Runs Slowly, Review Its Query Plan	191	(1)
Keep Joins Simple	191	(1)
Have a Database Administator	192	(1)
Use Prepared Statements	192	(1)
Have Your Development Environment Mirror Your Production Environment	192	(1)
During Load Testing, Use a Sniffer to Monitor Network Traffic	192	(1)
Use the Facade Pattern for Interfacing with Legacy Systems	193	(1)
Use Patterns	193	(1)
Keep Network Topology in Mind	194	(1)
Design Security in from the Start	194	(1)
Work Closely with Network Personnel	194	(1)
Be Aware of Internal Politics	194	(1)
Be Aware of the Organizational Culture	195	(1)
Be Prepared for Requirements Changes	195	(1)
Build One Slice at a Time	196	(1)
Build the Difficult Components First	196	(1)
Talk to Your Users	196	(1)
Keep It Simple	197	(1)
Conduct Walkthroughs	197	(1)
Use Version Control	198	(1)
Use a Code Profiler	198	(1)
Establish Your Interfaces Early	198	(1)
Build Early and Often	199	(1)
Perform Regression Testing	199	(1)
Choose Appropriate Test Cases	200	(1)
Generate Test Cases While Implementing the Application	200	(1)
Automate Everything	200	(1)
Understand the Role of Testing	201	(2)
A Nontrival Example	203	(25)
Requirements	203	(1)
Design	204	(1)
Relationships in EJB	204	(1)
Relationships in General	205	(1)
Detailed Design	205	(8)
Database Design	208	(1)
Detailed Design of the Time Tracker Class	209	(2)
Detailed Design of the Employee Class	211	(1)
Designing the Time SheetHash Class	212	(1)
Designing the Client	213	(1)
Implementation	213	(5)
Building the Database	214	(1)
Setting Up the Access Control Lists	214	(1)
Implementing the Employee Bean	215	(3)
The Final Product	218	(5)
Employee Home Interface	218	(1)
Employee Remote Interface	219	(1)
Employee Implementation	220	(1)
Employee Primary Key Class	220	(1)
Employee Info Class	221	(1)
My Identity Class	221	(1)
Time SheetLine Class	222	(1)
Time SheetHash Class	222	(1)
The Deployment Descriptor	223	(1)
Implementing the Time Tracker Bean	223	(4)
The Home Interface	225	(1)
The Remote Interface	225	(1)
Exceptions	226	(1)
Notes About the Implementation Class	227	(1)
The Deployment Descriptor	227	(1)
Implementing the Real Client	227	(1)
The Client Implementation Class	228	(1)
An Applet to Run the Client	228