By Chuck Cavaness, Brian Keeton
Publisher : Que
Pub Date : September 19, 2001
ISBN : 0-7897-2567-3
Pages : 648
Slots : 1
Special Edition Using Enterprise JavaBeans 2.0 starts with a description of how Enterprise JavaBeans fits into the big picture of J2EE development, then covers such topics as:
Locating EJB's using JNDI
Managing data with EJB Query Language
Building JMS applications using the new Message-driven Bean
Planning EJB applications using design patterns
Later chapters describe advanced development topics including interoperability, horizontal services and clustering. Throughout the book, the authors construct a component-based auction web site using the J2EE architecture as a practical example.
Copyright
About the Authors
Acknowledgments
Tell Us What You Think!
Introduction
This Book Is for You
How This Book Is Organized
Conventions Used in This Book
Part I: Developing Enterprise JavaBeans
Chapter 1. Introduction to Enterprise Applications
The Enterprise JavaBeans Architecture
Component-Based Distributed Computing
N-Tiered Architectures
Why Use EJB?
Chapter 2. Setting the Stage–An Example Auction Site
The Auction Example
Overview of an English Auction
Choosing the Use Cases to Implement
Defining the Object Model
What's Next?
Chapter 3. EJB Concepts
Grasping the Concepts Early
What Is an Enterprise Bean?
EJB Roles and Their Responsibilities
Local Versus Remote EJB Clients
Using RMI to Communicate with Enterprise JavaBeans
Accessing an EJB Through Its Component Interface
Locating Enterprise Beans Using the Home Interface
Deciding Whether to Use a Local or Remote Client
Creation and Removal of EJBs
Passivation and Activation
Object Pooling
Handles
The EJBMetaData Class
EJB Server and Container Implementations
Chapter 4. Java Naming and Directory Interface
Why Applications Need Naming and Directory Services
Overview of the JNDI Architecture
Selecting and Configuring a JNDI Provider
The JNDI Environment Properties
Setting the JNDI Environment Properties
The Context and InitialContext Objects
Getting the Environment for a Context Object
Using the lookup Method to Locate JNDI Resources
Locating EJB Objects
Accessing an EJB's Environment
Establishing Security Through the InitialContext
JNDI and Clustering
Troubleshooting
Chapter 5. Entity Beans
What Is an Entity Bean?
Declaring the Component Interface
Defining the Primary Key Class
Declaring the Home Interface
Implementing an Entity Bean
Inheritance and Entity Beans
Are Entity Beans Worth It?
Chapter 6. Bean-Managed Persistence
Choosing to Manage Persistence Yourself
JDBC Primer
Configuring a Data Source
Creating an Entity Bean
Loading and Storing an Entity
Accessing Other Entity Beans
Implementing Finder Methods
Deleting an Entity
Deploying an Entity Bean Using BMP
Troubleshooting
Chapter 7. Container-Managed Persistence
Building Portable Entity Beans
Declaring a CMP Entity Bean
Implementing the Container Callback Methods
Deploying an Entity Bean Using CMP
Managing Relationships
Using EJB 1.1 CMP
Troubleshooting
Chapter 8. EJB Query Language
What Is the EJB Query Language?
Defining a FROM Clause
Defining a WHERE Clause
Defining a SELECT Clause
Using the Built-In Functions
EJB QL Syntax in BNF Notation
Troubleshooting
Chapter 9. Session Beans
What Is a Session Bean?
Differences Between Stateless and Stateful Session Beans
Declaring the Component Interface
Declaring the Home Interface
Implementing a Session Bean
Deploying a Session Bean
Reentrant Issues
Troubleshooting
Chapter 10. Java Message Service
Introduction to Messaging
Components of the JMS Architecture
The Two JMS Message Models
The JMS Interfaces
The Details of a JMS Message
Message Selection and Filtering
Using the JMS Point-to-Point Model
Using the JMS Publish/Subscribe Model
Synchronous Versus Asynchronous Messaging
Message Persistence
Using Transactions with JMS
Using JMS with Enterprise JavaBeans
Troubleshooting
Chapter 11. Message-Driven Beans
What Are Message-Driven Beans?
The Message-Driven Bean and the Container
Using Message-Driven Beans with EJB
Using JMS Queues or Topics with Message-Driven Beans
Creating a Message-Driven Bean
Deploying a Message-Driven Bean
Sending Messages to a Message-Driven Bean
Acknowledging Messages from Message-Driven Beans
Using Transactions with Message-Driven Beans
Troubleshooting
Chapter 12. Transactions
Understanding Transactions
Passing the ACID Test
Programming with the Java Transaction API
Using Container-Managed Transactions
Using Bean-Managed Transactions
Using Client-Demarcated Transactions
Isolating Access to Resources
Troubleshooting
Chapter 13. Exception Handling
EJB Exception Handling
Application Exceptions
System Exceptions
Exceptions and Transactions
Packaging Exceptions
Troubleshooting
Chapter 14. Security Design and Management
The Imprtance of Application Security
Understanding Your Application's Security Requirements
Basic Security Concepts
Java Security Fundamentals
Using Security with Enterprise JavaBeans and J2EE
Sketching Out the Auction Security
Java Authentication and Authorization Service (JAAS)
Chapter 15. Deployment
Deployment Descriptors and EJB Roles
Bean Provider Responsibilities
Application Assembler Responsibilities
Deployer Responsibilities
Packaging EJBs
Troubleshooting
Part II: Design and Performance
Chapter 16. Patterns and Strategies in EJB Design
What Are Patterns?
Strategies for Enterprise JavaBeans
Designing EJB Classes and Interfaces
Managing Client Access
Implementing a Singleton in EJB
Troubleshooting
Chapter 17. Addressing Performance
The Role of Performance in Design
Minimizing Remote Calls
Optimizing Entity Bean Persistence
Building a Pick List
Managing Transactions
Troubleshooting
Chapter 18. Performance and Stress Testing Your Applications
Why Stress Test Your Applications?
Performance Testing Your Beans
Stress Testing Your Beans
Using ECperf 1.0
Troubleshooting
Part III: Building the Web Tier
Chapter 19. Building a Presentation Tier for EJB
The Different Types of Presentation Tiers
Using a Façade Pattern to Hide EJB
Using Servlets and Java Server Pages with EJB
Using JSP Tag Libraries
Using the Struts Open-Source Framework
Caching on the Web Server or in Stateful Session Beans
Part IV: Advanced Concepts
Chapter 20. Distribution and EJB Interoperability
Interoperability Overview
Portability Versus Interoperability
EJB 2.0 Interoperability Goals
The Relationship Between CORBA and Enterprise JavaBeans
Remote Invocation Interoperability
Transaction Interoperability
Naming Interoperability
Security Interoperability
Chapter 21. Horizontal Services
What Are Horizontal Services?
Horizontal Services Provided by EJB
Traditional Buy Versus Build Analysis
Auction Example Horizontal Services
Building the Auction Logging Service
Java 1.4 Logging API
Building an E-Mail Horizontal Service
Troubleshooting
Chapter 22. EJB Clustering Concepts
Too Much Isn't Always a Good Thing
What Is Clustering?
Clustering in the Web Tier
Clustering in the EJB Tier
Single VM Versus Multiple VM Architectures
Chapter 23. EJB 2.0 Programming Restrictions
The Purpose of the Restrictions
The EJB 2.0 Restrictions
Summary
Part V: Appendixes
Appendix A. The EJB 2.0 API
Interfaces
Exceptions
The javax.ejb.spi Package
Appendix B. Changes from EJB 1.1
Local Clients
Message-Driven Beans
Container-Managed Persistence Changes
EJB Query Language
Home Interface Business Methods
Security Changes
Component Interoperability
Another J2EE Books
Download
No comments:
Post a Comment