• 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