![]() ![]() ![]() ![]() |
About This Tutorial
Chapter 1: Introduction to Web Services
The Role of XML and the Java Platform
Overview of the Java APIs for XML
Chapter 2: Introduction to Interactive Web Application Technologies
Interactive Web Application Architectures
JavaServer Pages Standard Tag Library
Chapter 3: Getting Started With Tomcat
Modifying the Build Properties File
Creating a Simple Web Application
Creating the JavaBeans Component
Creating the Build Properties File
Creating the Deployment Descriptor
Building the Example Application
Running the Getting Started Application
Modifying a JavaBeans Component
Common Problems and Their Solutions
Chapter 4: Getting Started with Web Applications
Mapping URLs to Web Components
Setting Initialization Parameters
Declaring References to Environment Entries, Resource Environment Entries, or Resources
Listing Installed and Deployed Web Applications
Accessing Databases from Web Applications
Installing and Starting the PointBase Database Server
Populating the Example Database
Defining a Data Source in Tomcat
Configuring the Web Application to Reference a Data Source with JNDI
Mapping the Web Application JNDI Name to a Data Source
Chapter 5: Understanding XML
XML and Related Specs: Digesting the Alphabet Soup
Linking and Presentation Standards
Writing Processing Instructions
Substituting and Inserting Text
Creating a Document Type Definition (DTD)
Defining Attributes and Entities in the DTD
Defining Parameter Entities and Conditional Sections
Designing an XML Data Structure
Chapter 6: Java API for XML Processing
The Simple API for XML (SAX) APIs
The Document Object Model (DOM) APIs
The XML Stylesheet Language for Transformation (XSLT) APIs
Compiling and Running the Programs
Chapter 7: Simple API for XML
Echoing an XML File with the SAX Parser
Implementing the ContentHandler Interface
Compiling and Running the Program
Adding Additional Event Handlers
Identifying the Document's Location
Handling Processing Instructions
Handling Errors with the Nonvalidating Parser
Displaying Special Characters and CDATA
Handling Text with XML-Style Syntax
Handling CDATA and Other Characters
DTD's Effect on the Nonvalidating Parser
Choosing your Parser Implementation
Experimenting with Validation Errors
Error Handling in the Validating Parser
Using the DTDHandler and EntityResolver
Chapter 8: Document Object Model
Create Adapters to Display the DOM in a JTree
Examining the Structure of a DOM
Displaying a More Complex Tree
Constructing a User-Friendly JTree from a DOM
Creating and Manipulating a DOM
Obtaining a DOM from the Factory
Overview of the Validation Process
Configuring the DocumentBuilder Factory
Validating with Multiple Namespaces
Chapter 9: XML Stylesheet Language for Transformations
The JAXP Transformation Packages
XPath Data Types and Operators
Writing Out a DOM as an XML File
Writing Out a Subtree of the DOM
Generating XML from an Arbitrary Data Structure
Modifying the Parser to Generate SAX Events
Using the Parser as a SAXSource
Transforming XML Data with XSLT
Defining a Simple <article> Document Type
Processing the Basic Structure Elements
Processing the Remaining Structure Elements
Process Inline (Content) Elements
Transforming from the Command Line with Xalan
Concatenating Transformations with a Filter Chain
Understanding How the Filter Chain Works
Chapter 10: Binding XML Schema to Java Classes with JAXB
Binding XML Names to Java Identifiers
Java Representation of XML Schema
Chapter 11: Using JAXB
Configuring and Running the Examples Manually
Configuring and Running the Samples With Ant
About the Schema-to-Java Bindings
Chapter 12: Building Web Services With JAX-RPC
Creating a Web Service with JAX-RPC
Coding the Service Endpoint Interface and Implementation Class
Creating Web Service Clients with JAX-RPC
Dynamic Invocation Interface (DII) Client Example
Web Services Interoperability (WS-I) and JAX-RPC
Advanced Dynamic Proxy Example
Chapter 13: SOAP with Attachments API for Java
Creating and Sending a Simple Message
Adding Content to the SOAP Body
Adding Content to the SOAPPart Object
Adding a Document to the SOAP Body
Manipulating Message Content Using SAAJ or DOM APIs
DOMExample.java and DomSrcExample.java
Chapter 14: Java API for XML Registries
Using Taxonomies in JAXR Clients
Before You Compile the Examples
Chapter 15: Java Servlet Technology
Handling Servlet Life Cycle Events
Controlling Concurrent Access to Shared Resources
Getting Information from Requests
Filtering Requests and Responses
Programming Customized Requests and Responses
Including Other Resources in the Response
Transferring Control to Another Web Component
Associating Attributes with a Session
Notifying Methods to Shut Down
Creating Polite Long-Running Methods
Chapter 16: JavaServer Pages Technology
Using Objects within JSP Pages
Deactivating Expression Evaluation
JavaBeans Component Design Conventions
Creating and Using a JavaBeans Component
Setting JavaBeans Component Properties
Retrieving JavaBeans Component Properties
Including the Tag Library Implementation
Transferring Control to Another Web Component
Setting Properties for Groups of JSP Pages
Chapter 17: JavaServer Pages Standard Tag Library
Chapter 18: Custom Tags in JSP Pages
Encapsulating Reusable Content using Tag Files
Evaluating Fragments Passed to Tag Files
Declaring Tag Attributes for Tag Handlers
Declaring Tag Variables for Tag Handlers
Programming Simple Tag Handlers
Chapter 19: Scripting in JSP Pages
Initializing and Finalizing a JSP Page
Programming Tags That Accept Scripting Elements
Chapter 20: JavaServer Faces Technology
JavaServer Faces Technology Benefits
What is a JavaServer Faces Application?
A Simple JavaServer Faces Application
Steps in the Development Process
Adding Managed Bean Declarations
The Lifecycle of a JavaServer Faces Page
Request Processing Lifecycle Scenarios
Standard Request Processing Lifecycle
User Interface Component Model
The User-Interface Component Classes
Chapter 21: Using JavaServer Faces Technology
Running the Examples Using the Pre-Installed XML Files
Building and Running the Sample Applications Manually
Basic Requirements of a JavaServer Faces Application
Including the Required JAR Files
Including the Classes, Pages, and Other Resources
Setting Up The Application Configuration File
Using the managed-bean Element
Initializing Properties using the managed-property Element
Binding a Component to a Data Source
How Binding a Component to Data Works
Binding a Component to a Bean Property
Binding a Component to an Initial Default
Combining Component Data and Action Objects
Using the JavaServer Faces Tag Libraries
Declaring the JavaServer Faces Tag Libraries
Writing Model Object Properties
Displaying Validation Error Messages
Creating and Using a Custom Converter
Implementing an Event Listener
Registering Listeners on Components
Configuring Navigation Rules in faces-config.xml
Referencing An Action From a Component
Using an Action Object With a Navigation Rule
Chapter 22: Creating Custom UI Components
Determining if You Need a Custom Component or Renderer
When to Use a Custom Component
Component, Renderer, and Tag Combinations
Understanding the Image Map Example
Why Use JavaServer Faces Technology to Implement an Image Map?
Understanding the Rendered HTML
Summary of the Application Classes
Steps for Creating a Custom Component
Creating the Component Tag Handler
Defining the Custom Component Tag in a Tag Library Descriptor
Creating Custom Component Classes
Extending From a Standard Component
Delegating Rendering to a Renderer
Register the Renderer with a Render Kit
Handling Events for Custom Components
Using the Custom Component in the Page
Chapter 23: Internationalizing and Localizing Web Applications
Java Platform Localization Classes
Providing Localized Messages and Labels
Chapter 24: Security
Realms, Users, Groups, and Roles
Specifying Security Constraints
Specifying a Secure Connection
Configuring Login Authentication
Using Programmatic Security in the Web Tier
Declaring and Linking Role References
Installing and Configuring SSL Support
What is Secure Socket Layer Technology?
Setting Up Digital Certificates
Basic Authentication with JAX-RPC
Client-Certificate Authentication over HTTP/SSL with JAX-RPC
Chapter 25: The Coffee Break Application
Publishing the Service in the Registry
Deleting the Service From the Registry
Building, Installing, and Running the Application
Building and Installing the JAX-RPC Service
Building and Installing the SAAJ Service
Building and Installing the Coffee Break Server
Running the Coffee Break Client
Removing the Coffee Break Application
Appendix A: Tomcat Administration Tool
Configuring Connector Elements
Configuring Environment Entries
Administering Roles, Groups, and Users
Appendix B: Tomcat Web Application Manager
Running the Web Application Manager
Running Manager Commands Using Ant Tasks
Appendix C: The Java WSDP Registry Server
Using JAXR to Access the Registry Server
Adding a New User to the Registry
Deleting a User from the Registry
Appendix D: Registry Browser
Adding Services to an Organization
Adding Service Bindings to a Service
Adding and Removing Classifications
Appendix E: HTTP Overview
Appendix F: Java Encoding Schemes
Glossary
About the Authors
Index
![]() ![]() ![]() ![]() |