The Java EE 5 Tutorial

• The Java EE 5 Tutorial
• Preface
  • Before You Read This Book
  • How This Book Is Organized
  • Application Server Documentation Set
  • Related Documentation
  • Default Paths and File Names
  • Typographic Conventions
  • Symbol Conventions
  • Documentation, Support, and Training
  • Searching Sun Product Documentation
  • Third-Party Web Site References
  • Sun Welcomes Your Comments
• Introduction
  • Overview
    • Java EE Application Model
    • Distributed Multitiered Applications
      • Security
      • Java EE Components
      • Java EE Clients
        • Web Clients
        • Applets
        • Application Clients
        • The JavaBeansTM Component Architecture
        • Java EE Server Communications
      • Web Components
      • Business Components
      • Enterprise Information System Tier
    • Java EE Containers
      • Container Services
      • Container Types
    • Web Services Support
      • XML
      • SOAP Transport Protocol
      • WSDL Standard Format
      • UDDI and ebXML Standard Formats
    • Java EE Application Assembly and Deployment
    • Packaging Applications
    • Development Roles
      • Java EE Product Provider
      • Tool Provider
      • Application Component Provider
        • Enterprise Bean Developer
        • Web Component Developer
        • Application Client Developer
      • Application Assembler
      • Application Deployer and Administrator
    • Java EE 5 APIs
      • Enterprise JavaBeans Technology
      • Java Servlet Technology
      • JavaServer Pages Technology
      • JavaServer Pages Standard Tag Library
      • JavaServer Faces
      • Java Message Service API
      • Java Transaction API
      • JavaMail API
      • JavaBeans Activation Framework
      • Java API for XML Processing
      • Java API for XML Web Services (JAX-WS)
      • Java Architecture for XML Binding (JAXB)
      • SOAP with Attachments API for Java
      • Java API for XML Registries
      • J2EE Connector Architecture
      • Java Database Connectivity API
      • Java Persistence API
      • Java Naming and Directory Interface
      • Java Authentication and Authorization Service
      • Simplified Systems Integration
    • Sun Java System Application Server Platform Edition 9
      • Tools
  • Using the Tutorial Examples
    • Required Software
      • Tutorial Bundle
      • Java Platform, Standard Edition
      • Sun Java System Application Server 9.1
        • Application Server Installation Tips
      • NetBeans IDE
      • Apache Ant
    • Starting and Stopping the Application Server
    • Starting the Admin Console
    • Starting and Stopping the Java DB Database Server
    • Building the Examples
      • Building the Examples Using NetBeans IDE
      • Building the Examples on the Command-Line Using Ant
    • Tutorial Example Directory Structure
    • Debugging Java EE Applications
      • Using the Server Log
      • Using a Debugger
• The Web Tier
  • Getting Started with Web Applications
    • Web Applications
    • Web Application Life Cycle
    • Web Modules
      • Packaging Web Modules
      • Deploying a WAR File
        • Setting the Context Root
        • Deploying a Packaged Web Module
          • Deploying with the Admin Console
          • Deploying with asadmin
          • Deploying with Ant
          • Deploying with NetBeans IDE
      • Testing Deployed Web Modules
      • Listing Deployed Web Modules
      • Updating Web Modules
        • Updating a Packaged Web Module
        • Dynamic Reloading
      • Undeploying Web Modules
    • Configuring Web Applications
      • Mapping URLs to Web Components
        • Setting the Component Alias
      • Declaring Welcome Files
      • Setting Initialization Parameters
      • Mapping Errors to Error Screens
      • Declaring Resource References
        • Declaring a Reference to a Resource
        • Declaring a Reference to a Web Service
    • Dukes Bookstore Examples
    • Accessing Databases from Web Applications
      • Populating the Example Database
      • Creating a Data Source in the Application Server
    • Further Information about Web Applications
  • Java Servlet Technology
    • What Is a Servlet?
    • The Example Servlets
      • Troubleshooting Duke's Bookstore Database Problems
    • Servlet Life Cycle
      • Handling Servlet Life-Cycle Events
        • Defining the Listener Class
        • Specifying Event Listener Classes
      • Handling Servlet Errors
    • Sharing Information
      • Using Scope Objects
      • Controlling Concurrent Access to Shared Resources
      • Accessing Databases
    • Initializing a Servlet
    • Writing Service Methods
      • Getting Information from Requests
      • Constructing Responses
    • Filtering Requests and Responses
      • Programming Filters
      • Programming Customized Requests and Responses
      • Specifying Filter Mappings
    • Invoking Other Web Resources
      • Including Other Resources in the Response
      • Transferring Control to Another Web Component
    • Accessing the Web Context
    • Maintaining Client State
      • Accessing a Session
      • Associating Objects with a Session
        • Notifying Objects That Are Associated with a Session
      • Session Management
      • Session Tracking
    • Finalizing a Servlet
      • Tracking Service Requests
      • Notifying Methods to Shut Down
      • Creating Polite Long-Running Methods
    • Further Information about Java Servlet Technology
  • JavaServer Pages Technology
    • What Is a JSP Page?
      • A Simple JSP Page Example
    • The Example JSP Pages
    • The Life Cycle of a JSP Page
      • Translation and Compilation
      • Execution
        • Buffering
        • Handling JSP Page Errors
    • Creating Static Content
      • Response and Page Encoding
    • Creating Dynamic Content
      • Using Objects within JSP Pages
        • Using Implicit Objects
        • Using Application-Specific Objects
        • Using Shared Objects
    • Unified Expression Language
      • Immediate and Deferred Evaluation Syntax
        • Immediate Evaluation
        • Deferred Evaluation
      • Value and Method Expressions
        • Value Expressions
          • Referencing Objects Using Value Expressions
          • Referring to Object Properties Using Value Expressions
          • Where Value Expressions Can Be Used
        • Method Expressions
      • Defining a Tag Attribute Type
      • Deactivating Expression Evaluation
      • Literal Expressions
      • Resolving Expressions
        • Process of Expression Evaluation
        • EL Resolvers
      • Implicit Objects
      • Operators
      • Reserved Words
      • Examples of EL Expressions
      • Functions
        • Using Functions
        • Defining Functions
    • JavaBeans Components
      • JavaBeans Component Design Conventions
      • Creating and Using a JavaBeans Component
      • Setting JavaBeans Component Properties
      • Retrieving JavaBeans Component Properties
    • Using Custom Tags
      • Declaring Tag Libraries
      • Including the Tag Library Implementation
    • Reusing Content in JSP Pages
    • Transferring Control to Another Web Component
      • jsp:param Element
    • Including an Applet
    • Setting Properties for Groups of JSP Pages
      • Deactivating EL Expression Evaluation
        • Declaring Page Encodings
        • Defining Implicit Includes
        • Eliminating Extra White Space
    • Further Information about JavaServer Pages Technology
  • JavaServer Pages Documents
    • The Example JSP Document
    • Creating a JSP Document
      • Declaring Tag Libraries
      • Including Directives in a JSP Document
      • Creating Static and Dynamic Content
      • Using the jsp:root Element
      • Using the jsp:output Element
        • Generating XML Declarations
        • Generating a Document Type Declaration
    • Identifying the JSP Document to the Container
  • JavaServer Pages Standard Tag Library
    • The Example JSP Pages
    • Using JSTL
      • Tag Collaboration
    • Core Tag Library
      • Variable Support Tags
      • Flow Control Tags
        • Conditional Tags
        • Iterator Tags
      • URL Tags
      • Miscellaneous Tags
    • XML Tag Library
      • Core Tags
      • Flow Control Tags
      • Transformation Tags
    • Internationalization Tag Library
      • Setting the Locale
      • Messaging Tags
        • The setBundle and bundle Tags
        • The message Tag
      • Formatting Tags
    • SQL Tag Library
      • query Tag Result Interface
    • JSTL Functions
    • Further Information about JSTL
  • Custom Tags in JSP Pages
    • What Is a Custom Tag?
    • The Example JSP Pages
    • Types of Tags
      • Tags with Attributes
        • Simple Attributes
        • Fragment Attributes
        • Dynamic Attributes
        • Deferred Value
        • Deferred Method
        • Dynamic Attribute or Deferred Expression
        • jsp:attribute Element
      • Tags with Bodies
        • jsp:body Element
      • Tags That Define Variables
      • Communication between Tags
    • Encapsulating Reusable Content Using Tag Files
      • Tag File Location
      • Tag File Directives
        • Declaring Tags
        • body-content Attribute
        • Declaring Tag Attributes in Tag Files
        • Declaring Tag Variables in Tag Files
          • Variable Synchronization
          • Synchronization Examples
      • Evaluating Fragments Passed to Tag Files
      • Custom Tag Examples
        • Simple Attribute Example
        • Simple and Fragment Attribute and Variable Example
        • Dynamic Attribute Example
    • Tag Library Descriptors
      • Top-Level Tag Library Descriptor Elements
        • validator Element
        • listener Element
      • Declaring Tag Files
        • tag-file TLD Element
        • Unpackaged Tag Files
        • Packaged Tag Files
      • Declaring Tag Handlers
        • body-content Element
      • Declaring Tag Attributes for Tag Handlers
      • Declaring Tag Variables for Tag Handlers
    • Programming Simple Tag Handlers
      • Including Tag Handlers in Web Applications
      • How Is a Simple Tag Handler Invoked?
      • Tag Handlers for Basic Tags
      • Tag Handlers for Tags with Attributes
        • Defining Attributes in a Tag Handler
        • Attribute Validation
        • Setting Dynamic Attributes
        • Setting Deferred Value Attributes and Deferred Method Attributes
      • Tag Handlers for Tags with Bodies
        • Tag Handler Does Not Manipulate the Body
          • Tag Handler Manipulates the Body
      • Tag Handlers for Tags That Define Variables
        • TagExtraInfo Class
      • Cooperating Tags
      • Tag Handler Examples
        • An Iteration Tag
          • JSP Page
          • Tag Handler
        • A Template Tag Library
          • JSP Pages
          • Tag Handlers
  • Scripting in JSP Pages
    • The Example JSP Pages
    • Using Scripting
    • Disabling Scripting
    • JSP Declarations
      • Initializing and Finalizing a JSP Page
    • JSP Scriptlets
    • JSP Expressions
    • Programming Tags That Accept Scripting Elements
      • TLD Elements
      • Tag Handlers
        • How Is a Classic Tag Handler Invoked?
      • Tags with Bodies
        • Tag Handler Does Not Manipulate the Body
        • Tag Handler Manipulates the Body
          • doInitBody Method
          • doAfterBody Method
          • release Method
      • Cooperating Tags
      • Tags That Define Variables
  • JavaServer Faces Technology
    • JavaServer Faces Technology User Interface
    • JavaServer Faces Technology Benefits
    • What Is a JavaServer Faces Application?
    • A Simple JavaServer Faces Application
      • Steps in the Development Process
      • Mapping the FacesServlet Instance
      • Creating the Pages
        • Declaring the Tag Libraries
        • Adding the view and form Tags
        • Adding a Label Component
        • Adding an Image
        • Adding a Text Field
        • Registering a Validator on a Text Field
        • Adding a Custom Message
        • Adding a Button
        • Displaying Error Messages
      • Defining Page Navigation
      • Configuring Error Messages
      • Developing the Beans
      • Adding Managed Bean Declarations
    • User Interface Component Model
      • User Interface Component Classes
      • Component Rendering Model
      • Conversion Model
      • Event and Listener Model
      • Validation Model
    • Navigation Model
    • Backing Beans
      • Creating a Backing Bean Class
        • Configuring a Bean
        • Using the Unified EL to Reference Backing Beans
    • The Life Cycle of a JavaServer Faces Page
      • Restore View Phase
        • Apply Request Values Phase
        • Process Validations Phase
        • Update Model Values Phase
        • Invoke Application Phase
        • Render Response Phase
    • Further Information about JavaServer Faces Technology
  • Using JavaServer Faces Technology in JSP Pages
    • The Example JavaServer Faces Application
    • Setting Up a Page
    • Using the Core Tags
    • Adding UI Components to a Page Using the HTML Component Tags
      • UI Component Tag Attributes
        • The id Attribute
        • The immediate Attribute
        • The rendered Attribute
        • The style and styleClass Attributes
        • The value and binding Attributes
      • Adding a Form Component
      • Using Text Components
        • Rendering a Text Field with the inputText Tag
        • Rendering a Label with the outputLabel Tag
        • Rendering a Hyperlink with the outputLink Tag
        • Displaying a Formatted Message with the outputFormat Tag
        • Rendering a Password Field with the inputSecret Tag
      • Using Command Components for Performing Actions and Navigation
        • Rendering a Button with the commandButton Tag
        • Rendering a Hyperlink with the commandLink Tag
      • Using Data-Bound Table Components
      • Adding Graphics and Images with the graphicImage Tag
      • Laying Out Components with the UIPanel Component
      • Rendering Components for Selecting One Value
        • Displaying a Check Box Using the selectBooleanCheckbox Tag
        • Displaying a Menu Using the selectOneMenu Tag
      • Rendering Components for Selecting Multiple Values
      • The UISelectItem, UISelectItems, and UISelectItemGroup Components
        • Using the selectItems Tag
        • Using the selectItem Tag
      • Displaying Error Messages with the message and messages Tags
    • Using Localized Data
      • Loading a Resource Bundle
      • Referencing Localized Static Data
      • Referencing Error Messages
    • Using the Standard Converters
      • Converting a Components Value
      • Using DateTimeConverter
      • Using NumberConverter
    • Registering Listeners on Components
      • Registering a Value-Change Listener on a Component
      • Registering an Action Listener on a Component
    • Using the Standard Validators
      • Validating a Components Value
      • Using the LongRangeValidator
    • Binding Component Values and Instances to External Data Sources
      • Binding a Component Value to a Property
      • Binding a Component Value to an Implicit Object
      • Binding a Component Instance to a Bean Property
    • Binding Converters, Listeners, and Validators to Backing Bean Properties
    • Referencing a Backing Bean Method
      • Referencing a Method That Performs Navigation
      • Referencing a Method That Handles an Action Event
      • Referencing a Method That Performs Validation
      • Referencing a Method That Handles a Value-change Event
    • Using Custom Objects
      • Using a Custom Converter
      • Using a Custom Validator
      • Using a Custom Component
  • Developing with JavaServer Faces Technology
    • Writing Bean Properties
      • Writing Properties Bound to Component Values
        • UIInput and UIOutput Properties
        • UIData Properties
        • UISelectBoolean Properties
        • UISelectMany Properties
        • UISelectOne Properties
        • UISelectItem Properties
        • UISelectItems Properties
          • Properties for SelectItems Composed of SelectItem Instances
          • Properties for SelectItems Composed of SelectItemGroup Instances
      • Writing Properties Bound to Component Instances
      • Writing Properties Bound to Converters, Listeners, or Validators
    • Performing Localization
      • Creating a Resource Bundle
      • Localizing Dynamic Data
      • Localizing Messages
        • Creating a Message with a Message Factory
        • Using FacesMessage to Create a Message
    • Creating a Custom Converter
    • Implementing an Event Listener
      • Implementing Value-Change Listeners
      • Implementing Action Listeners
    • Creating a Custom Validator
      • Implementing the Validator Interface
      • Creating a Custom Tag
        • Writing the Tag Handler
        • Writing the Tag Library Descriptor
    • Writing Backing Bean Methods
      • Writing a Method to Handle Navigation
      • Writing a Method to Handle an Action Event
      • Writing a Method to Perform Validation
      • Writing a Method to Handle a Value-Change Event
  • Creating Custom UI Components
    • Determining Whether You Need a Custom Component or Renderer
      • When to Use a Custom Component
      • When to Use a Custom Renderer
      • Component, Renderer, and Tag Combinations
    • Understanding the Image Map Example
      • Why Use JavaServer Faces Technology to Implement an Image Map?
      • Understanding the Rendered HTML
      • Understanding the JSP Page
      • Configuring Model Data
      • Summary of the Application Classes
    • Steps for Creating a Custom Component
    • Creating Custom Component Classes
      • Specifying the Component Family
      • Performing Encoding
      • Performing Decoding
      • Enabling Component Properties to Accept Expressions
      • Saving and Restoring State
    • Delegating Rendering to a Renderer
      • Creating the Renderer Class
      • Identifying the Renderer Type
    • Handling Events for Custom Components
    • Creating the Component Tag Handler
      • Retrieving the Component Type
      • Setting Component Property Values
        • Getting the Attribute Values
        • Setting the Component Property Values
          • Setting Value Expressions on Component Properties
          • Setting Method Expressions on Component Properties
      • Providing the Renderer Type
      • Releasing Resources
    • Defining the Custom Component Tag in a Tag Library Descriptor
  • Configuring JavaServer Faces Applications
    • Application Configuration Resource File
    • Configuring Beans
      • Using the managed-bean Element
      • Initializing Properties Using the managed-property Element
        • Referencing a Java Enum Type
        • Referencing an Initialization Parameter
        • Initializing Map Properties
        • Initializing Array and List Properties
        • Initializing Managed Bean Properties
      • Initializing Maps and Lists
    • Registering Custom Error Messages
    • Registering Custom Localized Static Text
    • Registering a Custom Validator
    • Registering a Custom Converter
    • Configuring Navigation Rules
    • Registering a Custom Renderer with a Render Kit
    • Registering a Custom Component
    • Basic Requirements of a JavaServer Faces Application
      • Configuring an Application with a Deployment Descriptor
        • Identifying the Servlet for Life Cycle Processing
        • Specifying a Path to an Application Configuration Resource File
        • Specifying Where State Is Saved
        • Encrypting Client State
        • Restricting Access to JavaServer Faces Components
        • Turning On Validation of XML Files
        • Verifying Custom Objects
      • Including the Required JAR Files
      • Including the Classes, Pages, and Other Resources
  • Internationalizing and Localizing Web Applications
    • Java Platform Localization Classes
    • Providing Localized Messages and Labels
      • Establishing the Locale
      • Setting the Resource Bundle
      • Retrieving Localized Messages
    • Date and Number Formatting
    • Character Sets and Encodings
      • Character Sets
      • Character Encoding
        • Request Encoding
        • Page Encoding
        • Response Encoding
    • Further Information about Internationalizing Web Applications
• Web Services
  • Building Web Services with JAX-WS
    • Setting the Port
    • Creating a Simple Web Service and Client with JAX-WS
      • Requirements of a JAX-WS Endpoint
      • Coding the Service Endpoint Implementation Class
      • Building, Packaging, and Deploying the Service
        • Building, Packaging, and Deploying the Service Using NetBeans IDE
        • Building, Packaging, and Deploying the Service Using Ant
          • Undeploying the Service
          • The all Task
      • Testing the Service without a Client
      • A Simple JAX-WS Client
        • Coding the Client
        • Building and Running the Client
          • Building and Running the Client in NetBeans IDE
          • Building and Running the Client Using Ant
    • Types Supported by JAX-WS
    • Web Services Interoperability and JAX-WS
    • Further Information about JAX-WS
  • Binding between XML Schema and Java Classes
    • JAXB Architecture
      • Architectural Overview
      • The JAXB Binding Process
      • More about Unmarshalling
      • More about Marshalling
      • More about Validation
    • Representing XML Content
      • Java Representation of XML Schema
    • Binding XML Schemas
      • Simple Type Definitions
      • Default Data Type Bindings
        • Schema-to-Java Mapping
        • JAXBElement Object
        • Java-to-Schema Mapping
    • Customizing Generated Classes and Java Program Elements
      • Schema-to-Java
      • Java-to-Schema
    • JAXB Examples
      • JAXB Compiler Options
      • JAXB Schema Generator Option
      • About the Schema-to-Java Bindings
      • Schema-Derived JAXB Classes
        • Comment Class
        • Items Class
        • ObjectFactory Class
        • PurchaseOrder Class
        • PurchaseOrderType Class
        • USAddress Class
    • Basic JAXB Examples
      • Modify Marshal Example
        • Building and Running the Modify Marshal Example Using NetBeans IDE
        • Building and Running the Modify Marshal Example Using Ant
      • Unmarshal Validate Example
        • Building and Running the Unmarshal Validate Example Using NetBeans IDE
        • Building and Running the Unmarshal Validate Example Using Ant
    • Customizing JAXB Bindings
      • Why Customize?
      • Customization Overview
        • Inline and External Customizations
          • Inline Customizations
          • External Binding Customization Files
          • Binding Customization File Format
          • Passing Customization Files to the JAXB Binding Compiler
          • Restrictions for External Binding Customizations
        • Scope, Inheritance, and Precedence
        • Customization Syntax
          • Global Binding Declarations
          • Schema Binding Declarations
          • Class Binding Declarations
          • Property Binding Declarations
          • javaType Binding Declarations
          • Typesafe Enumeration Binding Declarations
          • javadoc Binding Declarations
        • Customization Namespace Prefix
      • Customize Inline Example
        • Building and Running the Customize Inline Example Using NetBeans IDE
        • Building and Running the Customize Inline Example Using Ant
        • Customized Schema
        • Global Binding Declarations
        • Schema Binding Declarations
        • Class Binding Declarations
        • Property Binding Declarations
        • MyDatatypeConverter Class
      • Datatype Converter Example
        • Building and Running the Datatype Converter Example Using NetBeans IDE
        • Building and Running the Datatype Converter Example Using Ant
      • Binding Declaration Files
        • JAXB Version, Namespace, and Schema Attributes
          • JAXB Version Number
          • Namespace Declarations
          • Schema Name and Schema Node
        • Global and Schema Binding Declarations
        • Class Declarations
      • External Customize Example
        • Building and Running the External Customize Example Using NetBeans IDE
        • Building and Running the External Customize Example Using Ant
    • Java-to-Schema Examples
      • Create Marshal Example
        • Building and Running the Create Marshal Example Using NetBeans IDE
        • Building and Running the Create Marshal Example Using Ant
      • XmlAccessorOrder Example
        • Using the @XmlAccessorOrder Annotation to Define Schema Element Ordering
        • Using the @XmlType Annotation to Define Schema Element Ordering
        • Schema Content Ordering in the Example
        • Building and Running the XmlAccessorOrder Example Using NetBeans IDE
        • Building and Running the XmlAccessorOrder Example Using Ant
      • XmlAdapter Field Example
        • Building and Running the XmlAdapter Field Example Using NetBeans IDE
        • Building and Running the XmlAdapter Field Example Using Ant
      • XmlAttribute Field Example
        • Building and Running the XmlAttribute Field Example Using NetBeans IDE
        • Building and Running the XmlAttribute Field Example Using Ant
      • XmlRootElement Example
        • Building and Running the XmlRootElement Example Using NetBeans IDE
        • Building and Running the XmlRootElement Example Using Ant
      • XmlSchemaType Class Example
        • Building and Running the XmlSchemaType Class Example Using NetBeans IDE
        • Building and Running the XmlSchemaType Class Example Using Ant
      • XmlType Example
        • Building and Running the XmlType Example Using NetBeans IDE
        • Building and Running the XmlType Example Using Ant
    • Further Information about JAXB
  • Streaming API for XML
    • Why StAX?
      • Streaming versus DOM
      • Pull Parsing versus Push Parsing
      • StAX Use Cases
      • Comparing StAX to Other JAXP APIs
    • StAX API
      • Cursor API
      • Iterator API
        • Iterator Event Types
        • Example of Event Mapping
      • Choosing between Cursor and Iterator APIs
        • Development Goals
        • Comparing Cursor and Iterator APIs
    • Using StAX
      • StAX Factory Classes
        • XMLInputFactory Class
        • XMLOutputFactory Class
        • XMLEventFactory Class
      • Resources, Namespaces, and Errors
        • Resource Resolution
        • Attributes and Namespaces
        • Error Reporting and Exception Handling
      • Reading XML Streams
        • Using XMLStreamReader
          • Reading Properties, Attributes, and Namespaces
          • XMLStreamReader Methods
          • Instantiating an XMLStreamReader
        • Using XMLEventReader
          • Reading Attributes
          • Reading Namespaces
      • Writing XML Streams
        • Using XMLStreamWriter
        • Using XMLEventWriter
          • Attributes, Escaping Characters, Binding Prefixes
    • Suns Streaming XML Parser Implementation
      • Reporting CDATA Events
      • Streaming XML Parser Factories Implementation
    • Example Code
      • Example Code Organization
      • Example XML Document
      • Cursor Example
        • Stepping through Events
        • Returning String Representations
        • Building and Running the Cursor Example Using NetBeans IDE
        • Building and Running the Cursor Example Using Ant
      • Cursor-to-Event Example
        • Instantiating an XMLEventAllocator
        • Creating an Event Iterator
        • Creating the Allocator Method
        • Building and Running the Cursor-to-Event Example Using NetBeans IDE
        • Building and Running the Cursor-to-Event Example Using Ant
      • Event Example
        • Creating an Input Factory
        • Creating an Event Reader
        • Creating an Event Iterator
        • Getting the Event Stream
        • Returning the Output
        • Building and Running the Event Example Using NetBeans IDE
        • Building and Running the Event Example Using Ant
      • Filter Example
        • Implementing the StreamFilter Class
        • Creating an Input Factory
        • Creating the Filter
        • Capturing the Event Stream
        • Filtering the Stream
        • Returning the Output
        • Building and Running the Filter Example Using NetBeans IDE
        • Building and Running the Filter Example Using Ant
      • Read-and-Write Example
        • Creating an Event Producer/Consumer
        • Creating an Iterator
        • Creating a Writer
        • Returning the Output
        • Building and Running the Read-and-Write Example Using NetBeans IDE
        • Building and Running the Read-and-Write Example Using Ant
      • Writer Example
        • Creating the Output Factory
        • Creating a Stream Writer
        • Writing the Stream
        • Returning the Output
        • Building and Running the Writer Example Using NetBeans IDE
        • Building and Running the Writer Example Using Ant
    • Further Information about StAX
  • SOAP with Attachments API for Java
    • Overview of SAAJ
      • SAAJ Messages
        • The Structure of an XML Document
        • What Is in a Message?
          • Messages with No Attachments
          • Messages with Attachments
        • SAAJ and DOM
      • SAAJ Connections
        • SOAPConnection Objects
    • SAAJ Tutorial
      • Creating and Sending a Simple Message
        • Creating a Message
        • Parts of a Message
        • Accessing Elements of a Message
        • Adding Content to the Body
        • Getting a SOAPConnection Object
        • Sending a Message
        • Getting the Content of a Message
      • Adding Content to the Header
      • Adding Content to the SOAPPart Object
      • Adding a Document to the SOAP Body
      • Manipulating Message Content Using SAAJ or DOM APIs
      • Adding Attachments
        • Creating an AttachmentPart Object and Adding Content
        • Accessing an AttachmentPart Object
      • Adding Attributes
        • Header Attributes
          • The actor Attribute
          • The role Attribute
          • The mustUnderstand Attribute
          • The relay Attribute
      • Using SOAP Faults
        • Overview of SOAP Faults
        • Creating and Populating a SOAPFault Object
        • Retrieving Fault Information
    • Code Examples
      • Request Example
      • Header Example
        • Building and Running the Header Example
      • DOM and DOMSource Examples
        • Examining the DOMExample Class
        • Examining the DOMSrcExample Class
        • Building and Running the DOM and DOMSource Examples
      • Attachments Example
        • Building and Running the Attachments Example
      • SOAP Fault Example
        • Building and Running the SOAP Fault Example
    • Further Information about SAAJ
• Enterprise Beans
  • Enterprise Beans
    • What Is an Enterprise Bean?
      • Benefits of Enterprise Beans
      • When to Use Enterprise Beans
      • Types of Enterprise Beans
    • What Is a Session Bean?
      • State Management Modes
        • Stateful Session Beans
        • Stateless Session Beans
      • When to Use Session Beans
    • What Is a Message-Driven Bean?
      • What Makes Message-Driven Beans Different from Session Beans?
      • When to Use Message-Driven Beans
    • Defining Client Access with Interfaces
      • Remote Clients
      • Local Clients
      • Deciding on Remote or Local Access
      • Web Service Clients
      • Method Parameters and Access
        • Isolation
        • Granularity of Accessed Data
    • The Contents of an Enterprise Bean
    • Naming Conventions for Enterprise Beans
    • The Life Cycles of Enterprise Beans
      • The Life Cycle of a Stateful Session Bean
      • The Life Cycle of a Stateless Session Bean
      • The Life Cycle of a Message-Driven Bean
    • Further Information about Enterprise Beans
  • Getting Started with Enterprise Beans
    • Creating the Enterprise Bean
      • Coding the Enterprise Bean
        • Coding the Business Interface
        • Coding the Enterprise Bean Class
      • Compiling and Packaging the converter Example
        • Compiling and Packaging the converter Example in NetBeans IDE
        • Compiling and Packaging the converter Example Using Ant
    • Creating the converter Application Client
      • Coding the converter Application Client
        • Creating a Reference to an Enterprise Bean Instance
        • Invoking a Business Method
        • ConverterClient Source Code
      • Compiling the converter Application Client
    • Creating the converter Web Client
      • Coding the converter Web Client
      • Compiling the converter Web Client
    • Deploying the converter Java EE Application
      • Deploying the converter Example Using NetBeans IDE
      • Deploying the converter Example Using Ant
    • Running the converter Application Client
      • Running the converter Application Client Using NetBeans IDE
      • Running the converter Application Client Using Ant
    • Running the converter Web Client
    • Modifying the Java EE Application
      • Modifying a Class File
  • Session Bean Examples
    • The cart Example
      • The Business Interface
      • Session Bean Class
        • Life-Cycle Callback Methods
        • Business Methods
      • The Remove Method
      • Helper Classes
      • Building, Packaging, Deploying, and Running the cart Example
        • Building, Packaging, and Deploying the cart Example Using NetBeans IDE
        • Running the cart Application Client Using NetBeans IDE
        • Building, Packaging, and Deploying the cart Example Using Ant
        • Running the cart Application Client Using Ant
        • The all Task
      • Undeploying the cart Example
    • A Web Service Example: helloservice
      • The Web Service Endpoint Implementation Class
      • Stateless Session Bean Implementation Class
      • Building, Packaging, Deploying, and Testing the helloservice Example
        • Building, Packaging, and Deploying the helloservice Example Using NetBeans IDE
        • Building, Packaging, and Deploying the helloservice Example Using Ant
        • Testing the Service without a Client
    • Using the Timer Service
      • The Timeout Method
      • Creating Timers
      • Canceling and Saving Timers
      • Getting Timer Information
      • Transactions and Timers
      • The timersession Example
      • Building, Packaging, Deploying, and Running the timersession Example
        • Building, Packaging, Deploying, and Running the timersession Example Using NetBeans IDE
        • Building, Packaging, and Deploying the timersession Example Using Ant
        • Running the timersession Application Client Using Ant
    • Handling Exceptions
  • A Message-Driven Bean Example
    • simplemessage Example Application Overview
    • The simplemessage Application Client
    • The Message-Driven Bean Class
      • The onMessage Method
    • Packaging, Deploying, and Running the simplemessage Example
      • Creating the Administered Objects for the simplemessage Example
      • Building, Deploying, and Running the simplemessage Application Using NetBeans IDE
      • Building, Deploying, and Running the simplemessage Application Using Ant
      • Removing the Administered Objects for the simplemessage Example
    • Creating Deployment Descriptors for Message-Driven Beans
• Persistence
  • Introduction to the Java Persistence API
    • Entities
      • Requirements for Entity Classes
      • Persistent Fields and Properties in Entity Classes
        • Persistent Fields
        • Persistent Properties
      • Primary Keys in Entities
        • Primary Key Classes
      • Multiplicity in Entity Relationships
      • Direction in Entity Relationships
        • Bidirectional Relationships
        • Unidirectional Relationships
        • Queries and Relationship Direction
        • Cascade Deletes and Relationships
      • Entity Inheritance
        • Abstract Entities
        • Mapped Superclasses
        • Non-Entity Superclasses
        • Entity Inheritance Mapping Strategies
          • The Single Table per Class Hierarchy Strategy
          • The Table per Concrete Class Strategy
          • The Joined Subclass Strategy
    • Managing Entities
      • The Persistence Context
      • The EntityManager Interface
        • Container-Managed Entity Managers
        • Application-Managed Entity Managers
        • Finding Entities Using the EntityManager
        • Managing an Entity Instances Life Cycle
          • Persisting Entity Instances
          • Removing Entity Instances
          • Synchronizing Entity Data to the Database
        • Creating Queries
          • Named Parameters in Queries
          • Positional Parameters in Queries
      • Persistence Units
        • The persistence.xml File
  • Persistence in the Web Tier
    • Accessing Databases from Web Applications
      • Defining the Persistence Unit
      • Creating an Entity Class
      • Obtaining Access to an Entity Manager
      • Accessing Data from the Database
      • Updating Data in the Database
  • Persistence in the EJB Tier
    • The order Application
      • Entity Relationships in the order Application
        • Self-Referential Relationships
        • One-to-One Relationships
        • One-to-Many Relationship Mapped to Overlapping Primary and Foreign Keys
        • Unidirectional Relationships
      • Primary Keys in the order Application
        • Generated Primary Keys
        • Compound Primary Keys
      • Entity Mapped to More Than One Database Table
      • Cascade Operations in the order Application
      • BLOB and CLOB Database Types in the order Application
      • Temporal Types in the order Application
      • Managing the order Applications Entities
        • Creating Entities
        • Finding Entities
        • Setting Entity Relationships
        • Using Queries
        • Removing Entities
      • Building and Running the order Application
        • Creating the Database Tables in NetBeans IDE
          • Creating the Database Connection
          • Creating the Tables
          • Deleting the Tables
        • Creating the Database Tables Using Ant
        • Building, Packaging, Deploying, and Running order In NetBeans IDE
        • Building, Packaging, Deploying, and Running order Using Ant
          • The all Task
          • Undeploying order
    • The roster Application
      • Relationships in the roster Application
        • The Many-To-Many Relationship in roster
      • Entity Inheritance in the roster Application
      • Automatic Table Generation in the roster Application
      • Building and Running the roster Application
        • Building, Packaging, Deploying, and Running roster in NetBeans IDE
        • Building, Packaging, Deploying, and Running roster Using Ant
          • The all Task
          • Undeploying order
  • The Java Persistence Query Language
    • Query Language Terminology
    • Simplified Query Language Syntax
      • Select Statements
      • Update and Delete Statements
    • Example Queries
      • Simple Queries
        • A Basic Select Query
        • Eliminating Duplicate Values
        • Using Named Parameters
      • Queries That Navigate to Related Entities
        • A Simple Query with Relationships
        • Navigating to Single-Valued Relationship Fields
        • Traversing Relationships with an Input Parameter
        • Traversing Multiple Relationships
        • Navigating According to Related Fields
      • Queries with Other Conditional Expressions
        • The LIKE Expression
        • The IS NULL Expression
        • The IS EMPTY Expression
        • The BETWEEN Expression
        • Comparison Operators
      • Bulk Updates and Deletes
        • Update Queries
        • Delete Queries
    • Full Query Language Syntax
      • BNF Symbols
      • BNF Grammar of the Java Persistence Query Language
      • FROM Clause
        • Identifiers
        • Identification Variables
          • Range Variable Declarations
          • Collection Member Declarations
          • Joins
      • Path Expressions
        • Examples of Path Expressions
        • Expression Types
        • Navigation
      • WHERE Clause
        • Literals
          • String Literals
          • Numeric Literals
          • Boolean Literals
          • Enum Literals
        • Input Parameters
        • Conditional Expressions
        • Operators and Their Precedence
        • BETWEEN Expressions
        • IN Expressions
        • LIKE Expressions
        • NULL Comparison Expressions
        • Empty Collection Comparison Expressions
        • Collection Member Expressions
        • Subqueries
          • EXISTS Expressions
          • ALL and ANY Expressions
        • Functional Expressions
        • NULL Values
        • Equality Semantics
      • SELECT Clause
        • Return Types
          • Aggregate Functions in the SELECT Clause
        • The DISTINCT Keyword
        • Constructor Expressions
      • ORDER BY Clause
      • The GROUP BY Clause
        • The HAVING Clause
• Services
  • Introduction to Security in the Java EE Platform
    • Overview of Java EE Security
      • A Simple Security Example
        • Step 1: Initial Request
        • Step 2: Initial Authentication
        • Step 3: URL Authorization
        • Step 4: Fulfilling the Original Request
        • Step 5: Invoking Enterprise Bean Business Methods
      • Security Functions
      • Characteristics of Application Security
    • Security Implementation Mechanisms
      • Java SE Security Implementation Mechanisms
      • Java EE Security Implementation Mechanisms
        • Application-Layer Security
        • Transport-Layer Security
        • Message-Layer Security
    • Securing Containers
      • Using Deployment Descriptors for Declarative Security
      • Using Annotations
      • Using Programmatic Security
    • Securing the Application Server
    • Working with Realms, Users, Groups, and Roles
      • What Are Realms, Users, Groups, and Roles?
        • What Is a Realm?
        • What Is a User?
        • What Is a Group?
        • What Is a Role?
        • Some Other Terminology
      • Managing Users and Groups on the Application Server
        • Adding Users to the Application Server
        • Adding Users to the Certificate Realm
      • Setting Up Security Roles
      • Mapping Roles to Users and Groups
    • Establishing a Secure Connection Using SSL
      • Installing and Configuring SSL Support
      • Specifying a Secure Connection in Your Application Deployment Descriptor
      • Verifying SSL Support
        • Tips on Running SSL
      • Working with Digital Certificates
        • Creating a Server Certificate
        • Signing Digital Certificates
          • Obtaining a Digitally Signed Certificate
        • Using a Different Server Certificate with the Application Server
        • Miscellaneous Commands for Certificates
      • Enabling Mutual Authentication over SSL
        • Creating a Client Certificate for Mutual Authentication
    • Further Information about Security
  • Securing Java EE Applications
    • Securing Enterprise Beans
      • Accessing an Enterprise Bean Callers Security Context
      • Declaring Security Role Names Referenced from Enterprise Bean Code
        • Declaring Security Roles Using Annotations
        • Declaring Security Roles Using Deployment Descriptor Elements
      • Defining a Security View of Enterprise Beans
        • Defining Security Roles
          • Linking Security Role References to Security Roles
        • Specifying an Authentication Mechanism
        • Specifying Method Permissions
          • Specifying Method Permissions Using Annotations
          • Specifying Method Permissions Using Deployment Descriptors
        • Mapping Security Roles to Application Server Groups
        • Propagating Security Identity
          • Configuring a Components Propagated Security Identity
          • Trust between Containers
      • Using Enterprise Bean Security Annotations
      • Using Enterprise Bean Security Deployment Descriptor Elements
      • Configuring IOR Security
      • Deploying Secure Enterprise Beans
        • Accepting Unauthenticated Users
        • Accessing Unprotected Enterprise Beans
    • Enterprise Bean Example Applications
      • Example: Securing an Enterprise Bean
        • Annotating the Bean
        • Setting Runtime Properties
        • Building, Deploying, and Running the Secure Cart Example Using NetBeans IDE
        • Building, Deploying, and Running the Secure Cart Example Using Ant
      • Example: Using the isCallerInRole and getCallerPrincipal Methods
        • Modifying ConverterBean
        • Modifying Runtime Properties for the Secure Converter Example
        • Building, Deploying, and Running the Secure Converter Example Using NetBeans IDE
        • Building, Deploying, and Running the Secure Converter Example Using Ant
        • Troubleshooting the Secure Converter Application
      • Discussion: Securing the Dukes Bank Example
    • Securing Application Clients
      • Using Login Modules
      • Using Programmatic Login
    • Securing EIS Applications
      • Container-Managed Sign-On
      • Component-Managed Sign-On
      • Configuring Resource Adapter Security
      • Mapping an Application Principal to EIS Principals
  • Securing Web Applications
    • Overview of Web Application Security
    • Working with Security Roles
      • Declaring Security Roles
        • Specifying Security Roles Using Annotations
        • Specifying Security Roles Using Deployment Descriptor Elements
      • Mapping Security Roles to Application Server Groups
    • Checking Caller Identity Programmatically
      • Declaring and Linking Role References
        • Declaring Roles Using Annotations
        • Declaring Roles Using Deployment Descriptor Elements
    • Defining Security Requirements for Web Applications
      • Declaring Security Requirements Using Annotations
        • Using the @DeclareRoles Annotation
        • Using the @RunAs Annotation
      • Declaring Security Requirements in a Deployment Descriptor
        • Specifying Security Constraints
          • Specifying Separate Security Constraints for Different Resources
      • Specifying a Secure Connection
      • Specifying an Authentication Mechanism
        • HTTP Basic Authentication
        • Form-Based Authentication
          • Using Login Forms
        • HTTPS Client Authentication
          • Mutual Authentication
        • Digest Authentication
    • Examples: Securing Web Applications
      • Example: Using Form-Based Authentication with a JSP Page
        • Creating a Web Client for Form-Based Authentication
        • Creating the Login Form and the Error Page
        • Specifying a Security Constraint
          • Protecting Passwords with SSL
        • Adding Authorized Roles and Users
        • Mapping Application Roles to Application Server Groups
        • Building, Packaging, and Deploying the Form-Based Authentication Example Using NetBeans IDE
        • Building, Packaging, and Deploying the Form-Based Authentication Example Using Ant
        • Testing the Form-Based Authentication Web Client
      • Example: Basic Authentication with a Servlet
        • Declaring Security Roles
        • Specifying the Security Constraint
          • Protecting Passwords with SSL
        • Adding Authorized Roles and Users
        • Mapping Application Roles to Application Server Groups
        • Building, Packaging, and Deploying the Servlet Basic Authentication Example Using NetBeans IDE
        • Building, Packaging, and Deploying the Servlet Basic Authentication Example Using Ant
        • Running the Basic Authentication Servlet
        • Troubleshooting the Basic Authentication Example
      • Example: Basic Authentication with JAX-WS
        • Annotating the Service
        • Adding Security Elements to the Deployment Descriptor
        • Linking Roles to Groups
        • Building and Deploying helloservice with Basic Authentication Using NetBeans IDE
        • Building and Deploying helloservice with Basic Authentication Using Ant
        • Building and Running the helloservice Client Application with Basic Authentication Using NetBeans IDE
        • Building and Running the helloservice Client Application with Basic Authentication Using Ant
  • The Java Message Service API
    • Overview of the JMS API
      • What Is Messaging?
      • What Is the JMS API?
      • When Can You Use the JMS API?
      • How Does the JMS API Work with the Java EE Platform?
    • Basic JMS API Concepts
      • JMS API Architecture
      • Messaging Domains
        • Point-to-Point Messaging Domain
        • Publish/Subscribe Messaging Domain
        • Programming with the Common Interfaces
      • Message Consumption
    • The JMS API Programming Model
      • JMS Administered Objects
        • JMS Connection Factories
        • JMS Destinations
      • JMS Connections
      • JMS Sessions
      • JMS Message Producers
      • JMS Message Consumers
        • JMS Message Listeners
        • JMS Message Selectors
      • JMS Messages
        • Message Headers
        • Message Properties
        • Message Bodies
      • JMS Queue Browsers
      • JMS Exception Handling
    • Writing Simple JMS Client Applications
      • A Simple Example of Synchronous Message Receives
        • Writing the Client Programs for the Synchronous Receive Example
        • Starting the JMS Provider
        • Creating JMS Administered Objects for the Synchronous Receive Example
        • Compiling and Packaging the Clients for the Synchronous Receive Example
        • Running the Clients for the Synchronous Receive Example
      • A Simple Example of Asynchronous Message Consumption
        • Writing the Client Programs for the Asynchronous Receive Example
        • Compiling and Packaging the AsynchConsumer Client
        • Running the Clients for the Asynchronous Receive Example
      • A Simple Example of Browsing Messages in a Queue
        • Writing the Client Program for the Queue Browser Example
        • Compiling and Packaging the MessageBrowser Client
        • Running the Clients for the Queue Browser Example
      • Running JMS Client Programs on Multiple Systems
        • Creating Administered Objects for Multiple Systems
        • Editing, Recompiling, Repackaging, and Running the Programs
        • Deleting the Connection Factory and Stopping the Server
    • Creating Robust JMS Applications
      • Using Basic Reliability Mechanisms
        • Controlling Message Acknowledgment
          • A Message Acknowledgment Example
        • Specifying Message Persistence
        • Setting Message Priority Levels
        • Allowing Messages to Expire
        • Creating Temporary Destinations
      • Using Advanced Reliability Mechanisms
        • Creating Durable Subscriptions
          • A Durable Subscription Example
        • Using JMS API Local Transactions
          • A Local Transaction Example
    • Using the JMS API in a Java EE Application
      • Using @Resource Annotations in Java EE Components
      • Using Session Beans to Produce and to Synchronously Receive Messages
        • Resource Management
        • Transactions
      • Using Message-Driven Beans to Receive Messages Asynchronously
      • Managing Distributed Transactions
      • Using the JMS API with Application Clients and Web Components
    • Further Information about JMS
  • Java EE Examples Using the JMS API
    • A Java EE Application That Uses the JMS API with a Session Bean
      • Writing the Application Components for the clientsessionmdb Example
        • Coding the Application Client: MyAppClient.java
        • Coding the Publisher Session Bean
        • Coding the Message-Driven Bean: MessageBean.java
      • Creating Resources for the clientsessionmdb Example
      • Building, Deploying, and Running the clientsessionmdb Example Using NetBeans IDE
      • Building, Deploying, and Running the clientsessionmdb Example Using Ant
    • A Java EE Application That Uses the JMS API with an Entity
      • Overview of the clientmdbentity Example Application
      • Writing the Application Components for the clientmdbentity Example
        • Coding the Application Client: HumanResourceClient.java
        • Coding the Message-Driven Beans for the clientmdbentity Example
        • Coding the Entity Class for the clientmdbentity Example
      • Creating Resources for the clientmdbentity Example
      • Building, Deploying, and Running the clientmdbentity Example Using NetBeans IDE
      • Building, Deploying, and Running the clientmdbentity Example Using Ant
    • An Application Example That Consumes Messages from a Remote Server
      • Overview of the consumeremote Example Modules
      • Writing the Module Components for the consumeremote Example
      • Creating Resources for the consumeremote Example
      • Using Two Application Servers for the consumeremote Example
      • Building, Deploying, and Running the consumeremoteModules Using NetBeans IDE
      • Building, Deploying, and Running the consumeremote Modules Using Ant
    • An Application Example That Deploys a Message-Driven Bean on Two Servers
      • Overview of the sendremote Example Modules
      • Writing the Module Components for the sendremote Example
        • Coding the Application Client: MultiAppServerClient.java
        • Coding the Message-Driven Bean: ReplyMsgBean.java
      • Creating Resources for the sendremote Example
      • Using Two Application Servers for the sendremote Example
      • Building, Deploying, and Running the sendremote Modules Using NetBeans IDE
      • Building, Deploying, and Running the sendremote Modules Using Ant
  • Transactions
    • What Is a Transaction?
    • Container-Managed Transactions
      • Transaction Attributes
        • Required Attribute
        • RequiresNew Attribute
        • Mandatory Attribute
        • NotSupported Attribute
        • Supports Attribute
        • Never Attribute
        • Summary of Transaction Attributes
        • Setting Transaction Attributes
      • Rolling Back a Container-Managed Transaction
      • Synchronizing a Session Beans Instance Variables
      • Methods Not Allowed in Container-Managed Transactions
    • Bean-Managed Transactions
      • JTA Transactions
      • Returning without Committing
      • Methods Not Allowed in Bean-Managed Transactions
    • Transaction Timeouts
    • Updating Multiple Databases
    • Transactions in Web Components
  • Resource Connections
    • Resources and JNDI Naming
    • DataSource Objects and Connection Pools
    • Resource Injection
      • Field-Based Injection
      • Method-Based Injection
      • Class-Based Injection
        • Declaring Multiple Resources
    • The confirmer Example Application
      • Running the confirmer Example Application
        • Creating a Mail Session
        • Building, Packaging, and Deploying confirmer in NetBeans IDE
        • Building, Packaging, and Deploying confirmer Using Ant
        • Running the confirmer Client in NetBeans IDE
        • Running the confirmer Client Using Ant
    • Further Information about Resources
  • Connector Architecture
    • About Resource Adapters
    • Resource Adapter Contracts
      • Management Contracts
        • Life-Cycle Management
        • Work Management Contract
      • Outbound Contracts
      • Inbound Contracts
        • Messaging Contracts
        • Transaction Inflow
    • Common Client Interface
    • Further Information about the Connector Architecture
• Case Studies
  • The Coffee Break Application
    • Overview of the Coffee Break Application
    • Common Code
    • JAX-WS Coffee Supplier Service
      • Service Implementation
    • SAAJ Coffee Supplier Service
      • SAAJ Client
        • Sending the Request
          • Extracting the Price List
        • Ordering Coffee
          • Creating the Order
          • Retrieving the Order Confirmation
      • SAAJ Service
        • Returning the Price List
        • Returning the Order Confirmation
    • Coffee Break Server
      • JSP Pages
        • The orderForm Page
        • The checkoutForm Page
        • The checkoutAck Page
      • JavaBeans Components
        • The RetailPriceList JavaBeans Component
        • The ShoppingCart JavaBeans Component
        • The OrderConfirmations JavaBeans Component
        • The CheckoutFormBean JavaBeans Component
        • The CoffeeBreakBean JavaBeans Component
      • The RetailPriceListServlet Servlet
      • Resource Configuration
    • Building, Packaging, Deploying, and Running the Coffee Break Application
      • Setting the Port
      • Building, Packaging, and Deploying the JAX-WS Coffee Supplier Service
      • Building, Packaging, and Deploying the SAAJ Coffee Supplier Service
      • Building, Packaging, and Deploying the Coffee Break Server
      • Running the Coffee Break Client
      • Removing the Coffee Break Application
  • The Dukes Bank Application
    • Overview of the Dukes Bank Application
    • Enterprise Beans
      • Session Beans
        • The AccountControllerBean Session Bean
        • The CustomerControllerBean Session Bean
        • The TxControllerBean Session Bean
      • Java Persistence Entities
      • Helper Classes
      • Database Tables
        • Tables Representing Business Entities
      • Protecting the Enterprise Beans
    • Application Client
      • The Classes and Their Relationships
      • BankAdmin Class
        • The BankAdmin Constructor
        • Class Methods
    • Web Client
      • Design Strategies
      • Client Components
      • Request Processing
      • Protecting the Web Client Resources
    • Building, Packaging, Deploying, and Running the Duke's Bank Application
      • Setting Up the Servers
        • Starting the Application Server
        • Creating the Bank Database in NetBeans IDE
        • Creating the Bank Database Using Ant
        • Adding Users and Groups to the File Realm
      • Building, Packaging, and Deploying Dukes Bank Using NetBeans IDE
      • Building, Packaging, and Deploying Dukes Bank Using Ant
      • Running the Duke's Bank Application Client Using NetBeans IDE
      • Running the Duke's Bank Application Client Using Ant
      • Running the Duke's Bank Web Client
• Appendixes
  • Java Encoding Schemes
    • Further Information about Character Encoding
  • Preparation for Java EE Certification Exams
    • CX-310-081: Sun Certified Web Component Developer
    • SL-351…EE5: Business Component Development with Enterprise JavaBeansTM Technology
  • About the Authors
• Index