Que - 2001 - Special Edition Using Enterprise JavaBeans 2.0

• Special Edition Using Enterprise JavaBeans 2.0
• Table of Contents
• 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
    • 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?
    • Troubleshooting
    • 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 Importance 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