Table of Contents

	Table of Contents
	Examples

Special Edition Using Enterprise JavaBeans 2.0
By Chuck  Cavaness, Brian  Keeton
Publisher	: Que
Pub Date	: September 19, 2001
ISBN	: 0-7897-2567-3
Pages	: 648
Slots	: 1			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 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