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