Special Edition Using Enterprise JavaBeans 2.0
Special Edition Using Enterprise JavaBeans 2.0
ISBN: 0789725673
EAN: 2147483647
EAN: 2147483647
Year: 2000
Pages: 223
Pages: 223
Authors: Chuck Cavaness, Brian Keeton
- 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 StageAn 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 PublishSubscribe 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
- 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
- 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 Faade 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
Special Edition Using Enterprise JavaBeans 2.0
ISBN: 0789725673
EAN: 2147483647
EAN: 2147483647
Year: 2000
Pages: 223
Pages: 223
Authors: Chuck Cavaness, Brian Keeton