You are previewing Java Enterprise in a Nutshell, Third Edition.
O'Reilly logo
Java Enterprise in a Nutshell, Third Edition

Book Description

Nothing is as constant as change, and this is as true in enterprise computing as anywhere else. With the recent release of Java 2 Enterprise Edition 1.4, developers are being called on to add even greater, more complex levels of interconnectivity to their applications.

To do this, Java developers today need a clear understanding of how to apply the new APIs, use the latest open source Java tools, and learn the capabilities and pitfalls in Java 2 Enterprise Edition 1.4 -- so they can plan a technology and implementation strategy for new enterprise projects.

Fortunately, this is exactly what they get with the new Java Enterprise in a Nutshell, 3rd Edition. Because most integrated development environments (IDE) today include API lookup, we took out the main API sections from our previous edition to make room for new chapters, among others, on Ant, Cactus, Hibernate, Jakarta Struts, JUnit, security, XDoclet, and XML/JAXP.

Revised and updated for the new 1.4 version of Sun Microsystems Java Enterprise Edition software, Java Enterprise in a Nutshell, 3rd Edition is a practical guide for enterprise Java developers.

Table of Contents

  1. Java Enterprise in a Nutshell, 3rd Edition
    1. Preface
      1. What’s New in This Edition
      2. Contents of This Book
      3. Java Programming Resources
      4. Examples Online
      5. Conventions Used in This Book
        1. Typographic Conventions
        2. XML Schema/DTD Diagrams
      6. Using Code Examples
      7. Safari® Enabled
      8. Comments and Questions
      9. Acknowledgments
        1. Jim Farley
        2. William Crawford
        3. Prakash Malani
        4. John G. Norman
        5. Justin Gehtland
    2. I. The Java Enterprise APIs
      1. 1. Introduction
        1. Enterprise Computing Defined
        2. Enterprise Computing Demystified
        3. Standard Java Enterprise APIs
          1. Basic Tools
            1. Java API for XML Processing (JAXP)
            2. J2EE security
          2. Web UIs and Components
            1. Java servlets: Basic web-enabled components
            2. JavaServer Pages (JSPs): Dynamic web pages
            3. JavaServer Faces (JSF): Web UI components
          3. Accessing Information Systems
            1. JDBC: Working with relational databases
            2. Java Naming and Directory Interface (JNDI): Working with directory services
            3. Java Transaction API (JTA): Accessing transactional resources
          4. Distributed Computing
            1. JAX-RPC and SAAJ: Using and writing web services
            2. Java RMI: Java-to-Java remote objects
            3. Java IDL: Using and writing CORBA remote objects
            4. Enterprise JavaBeans: Distributed business components
          5. Messaging
            1. Java Message Service (JMS): General enterprise messaging
            2. JavaMail: Email-based messaging
        4. De Facto Standard Enterprise Development Tools
          1. Ant: Building and Deploying Applications
          2. JUnit and Cactus: Testing Your Objects, Components, and Applications
          3. Struts: Implementing Model-View-Controller Systems
          4. Hibernate: Object Relational Mappings
          5. XDoclet and Java Annotations: Simplifying Development with Metadata
        5. An Enterprise Computing Scenario
          1. Enabling E-Commerce for a Mail-Order Enterprise
          2. Updating CornCo with Enterprise JavaBeans
          3. Other Potential Directions
        6. Other Enterprise APIs
      2. 2. Application Assembly and Deployment
        1. J2EE Application Assembly Model
          1. Assembling Applications
          2. JNDI Configuration Services
            1. Naming conventions
            2. Two-level name resolution
          3. Deploying Applications
            1. Resolving resource and component references
            2. Runtime classloading models
            3. Physical deployment
        2. Component Modules
          1. Module Jar Files
          2. Deployment Descriptors
          3. Component Module Assembly Example
            1. EJB module descriptor
            2. Web module descriptor
        3. Application Assemblies
          1. Application Assembly Example
        4. Deploying J2EE Applications
          1. Adjust Deployment Descriptors
          2. Perform Server-Specific Configuration
          3. Generate Container-Specific Classes
      3. 3. Java Servlets
        1. Getting a Servlet Environment
        2. Servlet Basics
          1. The Servlet Lifecycle
          2. Writing Servlets
          3. HTTP Servlets
        3. Web Applications
          1. Structure of Web Applications
          2. Mapping Requests with a Context
          3. Context Methods
        4. Servlet Requests
          1. Forms and Interaction
          2. POST, HEAD and Other Requests
        5. Servlet Responses
          1. Request Dispatching
          2. Error Handling
            1. Status codes
            2. Servlet exceptions
            3. A file-serving servlet
        6. Custom Servlet Initialization
          1. Servlet Context Initialization
        7. Security
        8. Servlet Filters
          1. Filters and Request Dispatchers
        9. Thread Safety
        10. Cookies
        11. Session Tracking
          1. HttpSessionBindingListener
        12. Databases and Non-HTML Content
      4. 4. JavaServer Pages
        1. JSP Basics
          1. Directives and Declarations
          2. Built-in Objects
          3. Sharing Data Between JSPs, Other JSPs, and Servlets
        2. JSP Actions
          1. JSP Tags and JavaBeans
          2. Scoping Beans
        3. The JSP Expression Language
          1. Using the EL with Tags
        4. JSP Standard Tag Library
          1. Variables and Flow Control
            1. Flow control
            2. URL management
          2. Internationalization
        5. Custom Tags
          1. Implementing Custom Tags
          2. More About the Tag Lifecycle
          3. Body Tags
          4. Intertag Communication
        6. Wrapping Up
      5. 5. JavaServer Faces
        1. The Sample Application
        2. Structure of a JSF Application
          1. JSF Lifecycle
          2. The JSF Configuration File
        3. Managed Beans
        4. The JSF Expression Language
        5. JSF Actions and Views
          1. Navigation
            1. Dynamic actions and navigation
          2. Sophisticated Views
          3. User Interface Events
        6. Building Tables
          1. Panel Grids
          2. Data Grids
            1. Editing data tables
            2. Data model objects
        7. Validation
          1. Adding Validators to Forms
          2. Displaying Validation Messages
          3. Custom Validators
        8. Moving on with JSF
      6. 6. Enterprise JavaBeans
        1. What Version Is Covered Here?
        2. EJB Component Model Overview
          1. The Enterprise JavaBeans Object
            1. Types of EJBs
            2. EJB code artifacts
          2. The EJB Client
          3. The EJB Container
        3. EJB Tutorial
          1. Client Interfaces
            1. Remote client interfaces
            2. Local client interfaces
          2. Home Interfaces
          3. The Bean Implementation
        4. Deploying EJBs
          1. EJB Deployment Descriptors
          2. Security-Related Deployment Attributes
            1. Client security roles
            2. Method permissions
            3. Propagating identities
          3. Packaging EJBs
            1. Generating the container classes
            2. Delivering the package
        5. Using Enterprise JavaBeans
          1. Local Versus Remote Clients
          2. Finding Home Interfaces Through JNDI
          3. Creating and Finding Beans
          4. EJB Handles and Home Handles
        6. Session Bean Specifics
          1. Session Bean Implementation Classes
          2. Stateless Versus Stateful Session Beans
          3. Container Management of Session Beans
          4. Optional Transaction Support
        7. Entity Beans
          1. Finder Methods
          2. Select Methods
          3. Entity Bean Implementations
            1. Primary keys
            2. Entity bean container callbacks
          4. Deployment Options for Entity Beans
          5. The Entity Context
          6. Lifecycle of an Entity Bean
          7. Bean-Managed Persistence
          8. Container-Managed Persistence
            1. Mapping container-managed fields: Abstract persistence schema
            2. Handling complex data structures
            3. Finder and select methods
            4. EJB relationships
        8. Message-Driven Beans
          1. Deploying Message-Driven EJBs
          2. Message-Driven Clients
        9. Transaction Management
          1. Transaction Management: Bean-Managed Versus Container-Managed
          2. Transaction Support Attributes
            1. Message-driven beans
            2. CMP entity beans
            3. Stateful session beans
            4. Stateless session beans
        10. EJB 3.0
      7. 7. Java and XML
        1. Using XML Documents
          1. XML Schema
        2. Java API for XML Processing
          1. Getting a Parser or Processor
        3. SAX
          1. SAX Handlers
            1. ContentHandler
            2. ErrorHandler
            3. DefaultHandler
          2. Using a SAX Parser
            1. A SAX example: Processing orders
        4. DOM
          1. Getting a DOM Parser
          2. Navigating the DOM Tree
            1. Element attributes
          3. Manipulating DOM Trees
          4. Extending DOM Trees
        5. XSLT
          1. JAXP Data Sources
            1. Determining data source support
            2. Custom URI resolution
      8. 8. JDBC
        1. JDBC Architecture
          1. JDBC Basics
          2. JDBC Drivers
          3. JDBC URLs
          4. The JDBC-ODBC Bridge
        2. Connecting to the Database
          1. DataSource Objects
          2. Connection Pooling
        3. Statements
          1. Multiple Result Sets
        4. Results
          1. Handling Nulls
          2. Large Data Types
          3. Dates and Times
          4. Advanced Results Handling
          5. Java-Aware Databases
        5. Handling Errors
          1. SQL Warnings
        6. Prepared Statements
          1. Batch Updates
          2. Auto-Generated Keys
        7. BLOBs and CLOBs
        8. Metadata
          1. DatabaseMetaData
          2. ResultSetMetaData
        9. Transactions
          1. Distributed Transactions
          2. Savepoints
        10. Stored Procedures
        11. Escape Sequences
        12. RowSets
      9. 9. JNDI
        1. JNDI Architecture
        2. A Simple Example
        3. Introducing the Context
          1. Using the InitialContext Class
          2. Other Naming Systems
        4. Looking Up Objects in a Context
        5. The NamingShell Application
          1. The Command Interface
          2. A Command for Loading an Initial Context
          3. Running the Shell
        6. Listing the Children of a Context
          1. How Names Work
          2. Browsing a Naming System
          3. Listing the Bindings of a Context
        7. Creating and Destroying Contexts
        8. Binding Objects
        9. Accessing Directory Services
          1. The DirContext Interface
          2. The Attributes Interface
          3. The Attribute Interface
        10. Modifying Directory Entries
        11. Creating Directory Entries
        12. Searching a Directory
          1. Search Criteria
          2. Search Results
          3. Search Controls
          4. A Search Command
        13. Event Notification
          1. Event Sources
          2. Writing Event Listeners
          3. Registering Event Listeners
            1. A listen command
      10. 10. J2EE Security
        1. Basic Security Concepts
          1. Public-Key Cryptography
          2. Transport Layer Security: Integrity and Confidentiality
          3. Application Layer Security: Authentication and Authorization
        2. A Look at Java and J2EE Security Standards
          1. Authentication and Authorization in Java Security
          2. Encryption in Java Security
        3. Declarative Security Versus Programmatic Security
        4. Web Component Security
          1. Web-Tier Transport-Level Security
          2. Web-Tier Authentication
            1. BASIC authentication
            2. DIGEST authentication
            3. FORM authentication
            4. CLIENT authentication
            5. Custom authentication
          3. Web-Tier Authorization
            1. Declarative authorization
            2. Programmatic authorization
          4. Identity Propagation from the Web Tier to the EJB Tier
          5. Web Tier Best Practices
        5. EJB Component Security
          1. EJB-Tier Transport-Level Security
          2. EJB-Tier Authentication
          3. EJB-Tier Authorization
            1. EJB-tier declarative authorization
            2. EJB-tier programmatic authorization
          4. EJB Tier Best Practices
        6. Other J2EE Security Topics
          1. Accessing Enterprise Resource Managers
          2. Web Services Security
          3. Single Sign-On (SSO)
            1. SSO products
            2. Security stores
        7. Limitations of J2EE Security
      11. 11. Java Message Service
        1. JMS in the J2EE Environment
        2. Elements of Messaging with JMS
          1. Messaging Styles: Point-to-Point and Publish-Subscribe
          2. Key JMS Interfaces
          3. A Generic JMS Client
            1. General setup
            2. Client identifiers
            3. Authenticated connections
            4. Sessions
            5. Sending messages
            6. Receiving messages
            7. Temporary destinations
            8. Cleaning up
        3. The Anatomy of Messages
          1. Message Header Fields and Properties
          2. JMS Message Types
          3. Accessing Message Content
          4. Filtering Messages
        4. Point-to-Point Messaging
          1. Sample Client
          2. Browsing Queues
        5. Publish-Subscribe Messaging
          1. Sample Client
          2. Durable Subscriptions
        6. Unified Messaging
        7. Transactional Messaging
      12. 12. Web Services with JAX-RPC and SAAJ
        1. What’s Covered Here?
        2. Brief Introduction to Web Services
          1. Simple Object Access Protocol (SOAP)
          2. Web Service Description Language (WSDL)
          3. Web Service Styles and Encoding
        3. Java Web Services
          1. Mapping SOAP and WSDL to Java
          2. Web Service Deployment
        4. Writing Web Service Clients
          1. Static Proxy Approach
          2. Dynamic Proxy Approach
          3. Dynamic Invocation Interface (DII) Approach
        5. Writing Web Services
          1. Simple Java Web Services
          2. EJB Web Services
          3. Nonstandard Implementation Schemes
            1. Axis JWS approach
        6. Deploying Web Services
          1. J2EE Standard Model
            1. Simple Java web services
            2. EJB web services
          2. Axis Deployment Model
      13. 13. Remote Method Invocation
        1. What’s Covered Here?
        2. Introduction to RMI
          1. RMI in Action
          2. RMI Architecture
          3. RMI Object Services
            1. Naming/registry service
            2. Object activation service
            3. Distributed garbage collection
        3. Defining Remote Objects
          1. Key RMI Classes for Remote Object Implementations
        4. Creating the Stubs and Skeletons
        5. Accessing Remote Objects as a Client
          1. The Registry and Naming Services
          2. Remote Method Arguments and Return Values
          3. Factory Classes
        6. Dynamic Classloading
          1. Configuring Clients and Servers for Remote Classloading
          2. Loading Classes from Applets
        7. Remote Object Activation
          1. Persistent Remote References
          2. Defining an Activatable Remote Object
            1. The Activatable class
            2. Implementing an activatable object
          3. Registering Activatable Objects
            1. Registering an activatable object without instantiating
            2. Passing data with the MarshalledObject
          4. Activation Groups
            1. Registering activation groups
            2. Assigning activatable objects to groups
          5. The Activation Daemon
            1. The daemon’s dual personality
        8. RMI and Native Method Calls
          1. RMI with JNI Versus CORBA
        9. RMI Over IIOP
          1. Accessing RMI Objects from CORBA
      14. 14. Java IDL (CORBA)
        1. A Note on Evolving Standards
        2. The CORBA Architecture
          1. Interface Definition Language
          2. The Object Request Broker and the Object Adaptor
          3. The Naming Service
          4. Inter-ORB Communication
        3. Creating CORBA Objects
          1. An IDL Primer
            1. Modules
            2. Interfaces
            3. Data members and methods
            4. A complete IDL example
          2. Turning IDL into Java
            1. The delegation server-side model
            2. A simple server class
            3. The helper class and narrowing references
            4. The holder class
            5. The client stub
            6. Server skeletons
          3. Writing the Implementation
        4. Putting It in the Public Eye
          1. Initializing the ORB
          2. Registering with a Naming Service
          3. Adding Objects to a Naming Context
            1. A slightly simpler approach: The Interoperable Naming Service
        5. Finding and Using Remote Objects
          1. Remote Object References and Narrowing
          2. Accessing Remote Objects
          3. ORB Initial Object References
          4. Getting Objects from Other Remote Objects
            1. Naming Service lookups
          5. Object URLs
        6. What If I Don’t Have the Interface?
          1. Dynamic Invocation Interface
      15. 15. JavaMail
        1. Email and JavaMail
          1. JavaMail Layers
          2. Installing and Configuring JavaMail
            1. Provider registries
          3. The Mail Session
            1. Authenticators
            2. Providers
            3. URL names
        2. Creating and Sending Messages
          1. Sending Messages
        3. Retrieving Messages
          1. Message Stores
          2. Handling Incoming Messages
          3. Searches and Message Management
        4. Multipart Messages
          1. Displaying Multipart Messages
          2. Sending Multipart Messages
      16. 16. Transactions
        1. Transaction Overview
          1. Transaction Properties
          2. Transaction Isolation Problems and Levels
            1. Transaction isolation violations
            2. Transaction isolation levels
          3. Transaction Models
          4. Distributed Transactions and the JTA
          5. Distributed Transaction Scenarios
            1. Database and message queue
            2. Multiple databases
            3. Multiple application servers
            4. Client demarcation
          6. Two-Phase Commit
            1. Emulating two-phase commit
        2. Programmatic Transactions Versus Declarative Transactions
          1. Programmatic Transactions
          2. Declarative Transactions
        3. Optimistic Concurrency
        4. EJB Transaction Management
          1. BMTD with JTA
            1. Stateless session beans and message-driven beans
            2. Stateful session beans
          2. Container-Managed Transaction Demarcation (CMTD)
            1. Inducing rollbacks in CMTD
        5. Some Common Programming Scenarios
          1. Using a Session Façade
          2. Using Transaction Attributes with CMTD
          3. Distributed Transactions Involving a JMS Destination and Database
        6. Transaction Best Practices
    3. II. Open Source Enterprise Tools
      1. 17. Ant
        1. What Version Is Covered Here?
        2. Ant Overview
        3. Ant Fundamentals
          1. Buildfiles
          2. Defining Targets, Their Tasks, and Their Relationships
          3. Properties
            1. Setting properties
            2. Referencing properties
        4. Core Tasks
          1. File and Directory Tasks
            1. Basic entities
            2. Creating, moving, copying, and deleting
            3. Making archives
          2. Basic Java Tasks
            1. Paths and classpaths
            2. Compiling Java code
            3. Running Java programs
          3. Miscellaneous Utilities
            1. Ant’s echo task: System.out.println()
            2. Calling external programs
            3. Importing custom Ant tasks
            4. Invoking targets
        5. Enterprise Tasks
          1. Assembling Components
            1. Web components
            2. EJB components
          2. Assembling Applications
          3. Deploying Components and Applications
        6. Creating Portable Build Processes
          1. Hierarchical Property Files
          2. Modular Target Definitions
            1. Importing targets in older Ant versions
          3. Putting It All Together
      2. 18. JUnit and Cactus
        1. What’s Covered Here?
          1. Other Tools to Consider
        2. Unit Testing Concepts
          1. Units and Dependencies
          2. Unit Testing Versus Integration Testing
          3. White Box Versus Black Box Testing
          4. Keep the Tests Simple
          5. Test Coverage
        3. JUnit Overview
          1. Defining Tests by Writing TestCases
          2. Making Assertions in Test Methods
          3. Failing Tests
          4. Managing Test Fixtures
          5. Organizing Tests Using TestSuites
        4. Using JUnit with Ant
          1. Controlling the Build with Unit Tests
          2. Running Batches of Tests
          3. Formatting Test Results
        5. Testing Enterprise Components with Cactus
          1. The Cactus Model and Architecture
            1. The Cactus test process
            2. Cactus test proxies
          2. Writing Cactus Tests
            1. Introduction to Cactus tests: Testing servlets
            2. Testing JSPs
            3. Testing JSP custom tags
            4. Testing servlet filters
            5. Testing EJBs and component types
            6. Testing asynchronous code
          3. Running Cactus Tests
            1. Running Cactus tests with Ant
            2. Running Cactus tests using ServletTestRunner
      3. 19. Struts
        1. The Scope of Struts
        2. The Sample Application
        3. The Development Process with Struts
        4. The Struts Controller
          1. The ActionServlet
          2. The RequestProcessor
        5. The Action Class
          1. RequestProcessor and Actions
          2. The Struts Configuration File
        6. Views in Struts
          1. The ActionForm Class
            1. Validation
            2. Scope
            3. The ActionForm and the JSP
        7. Struts Tags
          1. Form Handling and Form Tags
            1. <html:form>
            2. <html:text>, <html:password>, and <html:submit>
            3. <html:select>, <html:options>, and <html:checkbox>
            4. <html:multibox>
          2. Additional Tags
            1. <html:link>
            2. <html:errors>
            3. <logic:forward>
          3. Using the JSTL Expression Language in Struts Tags
        8. Struts Plug-ins
        9. DynaActionForms and the Struts Validator
      4. 20. Hibernate
        1. The Sample Application
        2. Principles of Hibernate
          1. Transparency
          2. Reflection
          3. Java, JDBC, and RDBMS
          4. Pluggability
          5. Performance
        3. Configuration and Mapping
          1. Global Configuration
            1. Debugging
            2. Other JDBC properties
            3. Transaction management
            4. Optimization
            5. JNDI
            6. SQL
          2. The Hibernate Type System
          3. Class Mappings
            1. Unique IDs
            2. Properties
          4. Collection Types
          5. Relationship Mappings
            1. One-to-one
            2. One-to-many and many-to-one
            3. Many-to-many
            4. Proxies
            5. Lazy loading
            6. Special note about lazy initialization
          6. Polymorphic Mappings
            1. One table per class hierarchy
            2. One table per class
            3. One table per concrete class
          7. Mapping Tools
        4. The Hibernate API
          1. Configuration and Hibernate
          2. SessionFactory
          3. Session
            1. Loading objects
            2. Saving new objects
            3. Updating existing objects
            4. Retrieving multiple objects
            5. Connection management
            6. Disconnected objects
          4. Query
          5. Interceptors
          6. Events
        5. HQL (Hibernate Query Language)
          1. FROM
          2. SELECT
          3. WHERE
        6. Hibernate Services
          1. Transactions
          2. Caching
            1. The second-level cache
            2. The Query cache
          3. Security
        7. Conclusion
      5. 21. Annotations with XDoclet and J2SE Metadata
        1. What’s Covered Here?
        2. What Are Code Annotations?
        3. Annotation Tools
        4. XDoclet Tutorial
          1. Annotating Your Code
          2. Processing XDoclet Annotations
          3. Generating Deployment Descriptors
            1. “Pure” annotation-driven deployment descriptors
            2. Mixed models: Deployment using annotations and external data
          4. Generating Source Code
            1. Web services
            2. EJBs
          5. Other Annotations
          6. Custom XDoclet Annotations
          7. A Word of Caution
        5. J2SE Annotations Tutorial
          1. General Programming Model
          2. Core Annotations
            1. @Override
            2. @SuppressWarnings
            3. @Deprecated
          3. Creating and Using Custom Annotations
          4. Processing Annotations at Runtime
          5. The Future of J2SE Annotations
    4. III. Appendixes
      1. A. J2EE Deployment Descriptor Reference
        1. Web Components (web.xml)
          1. General Cross-Component Settings
          2. Web Component Declarations
          3. Web Handler Declarations
          4. Security Configuration
          5. Component References
          6. Resources and Environment Entries
        2. Enterprise JavaBeans (ejb-jar.xml)
          1. Session EJB Declarations
          2. Message-Driven EJB Declarations
          3. Entity EJB Declarations
          4. Entity EJB Relationship Declarations
          5. Cross-Component Runtime Settings
        3. Application Archives (application .xml)
        4. Web Services (webservices.xml)
        5. Web Service Java/WSDL Mappings
      2. B. JavaServer Faces Tag Libraries
        1. JSF Core Tags
          1. <f:actionListener>
          2. <f:attribute>
          3. <f:convertDateTime>
          4. <f:convertNumber>
          5. <f:converter>
          6. <f:facet>
          7. <f:loadBundle>
          8. <f:param>
          9. <f:selectItem>
          10. <f:selectItems>
          11. <f:subview>
          12. <f:validator>
          13. <f:validateDoubleRange>
          14. <f:validateLength>
          15. <f:validateLongRange>
          16. <f:valueChangeListener>
          17. <f:view>
          18. <f:verbatim>
        2. JSF HTML Tags
          1. Pass-Through Attributes
          2. <h:column>
          3. <h:commandButton>
          4. <h:commandLink>
          5. <h:dataTable>
          6. <h:form>
          7. <h:graphicImage>
          8. <h:inputHidden>
          9. <h:inputSecret>
          10. <h:inputText>
          11. <h:inputTextarea>
          12. <h:message>
          13. <h:messages>
          14. <h:outputFormat>
          15. <h:outputLabel>
          16. <h:outputLink>
          17. <h:outputText>
          18. <h:panelGrid>
          19. <h:panelGroup>
          20. <h:selectBooleanCheckbox>
          21. <h:selectManyCheckbox>
          22. <h:selectManyListbox>
          23. <h:selectManyMenu>
          24. <h:selectOneListbox>
          25. <h:selectOneMenu>
          26. <h:selectOneRadio>
      3. C. Enterprise JavaBeans Query Language Syntax
        1. Basic Structure of EJB QL Queries
        2. FROM Clause
          1. Range Variables
          2. Collection Member Variables
        3. SELECT Clause
          1. Aggregation expressions
          2. DISTINCT Queries
        4. WHERE Clause
          1. Literals
          2. Variables
            1. Simple query variables
            2. Input parameter variables
            3. Path expression variables
          3. Functions
          4. Conditional Expressions
            1. Logical operators
            2. Arithmetic operators
            3. Comparison operators
        5. ORDER BY Clause
      4. D. SQL Reference
        1. Relational Databases
        2. Data Types
        3. Schema Manipulation Commands
          1. CREATE TABLE
          2. ALTER TABLE
          3. DROP
        4. Data Manipulation Commands
          1. SELECT
            1. String comparisons
            2. Subqueries and joins
            3. Groups
          2. INSERT
          3. UPDATE
          4. DELETE
        5. Functions
          1. Aggregate Functions
          2. Value Functions
            1. Date/time functions
            2. String manipulation functions
        6. Return Codes
      5. E. JMS Message Selector Syntax
        1. Structure of a Selector
        2. Identifiers
        3. Literals
        4. Operators
          1. Logical Operators
          2. Arithmetic Operators
          3. Comparison Operators
        5. Expressions
      6. F. FRMI Tools
        1. rmic: The Java RMI Compiler
        2. rmid : The RMI Activation Daemon
        3. rmiregistry : The Java RMI Object Registry
        4. serialver: The RMI Serial Version Utility
      7. G. IDL Reference
        1. IDL Keywords
        2. Identifiers
          1. Mapping Identifiers to Java
        3. Comments
          1. Mapping Comments to Java
        4. Basic Data Types
          1. Strings and Characters
            1. Mapping strings and characters to Java
        5. Constants and Literals
          1. Mapping Constants to Java
          2. Boolean Literals
          3. Numeric Literals
            1. Integer literals
            2. Floating-point literals
            3. Fixed-point literals
            4. Mapping numeric literals to Java
          4. Character Literals
          5. String Literals
        6. Naming Scopes
        7. User-Defined Data Types
          1. Typedefs
            1. Mapping typedefs to Java
          2. Arrays
            1. Mapping arrays to Java
          3. Sequences
            1. Mapping sequences to Java
          4. Structs
            1. Mapping structs to Java
          5. Enumerations
            1. Mapping enumerations to Java
          6. Unions
            1. Mapping unions to Java
        8. Exceptions
          1. Standard Exceptions
          2. Mapping Exceptions to Java
        9. Module Declarations
          1. Mapping Modules to Java
        10. Interface Declarations
          1. Attributes
          2. Methods
            1. Arguments
            2. Exceptions
            3. Context values
            4. Call semantics
          3. Interface Inheritance
            1. Method and attribute inheritance
            2. Constant, type, and exception inheritance
            3. IDL early binding
          4. Mapping Interfaces to Java
            1. Helper and holder classes
            2. Attributes
            3. Methods
        11. Value Type Declarations
          1. Mapping Valuetypes to Java
      8. H. HJava IDL Tools
        1. idlj : The Java IDL Compiler
        2. orbd : Naming Service Daemon
        3. servertool
        4. tnameserv: Transient Naming Service Daemon
    5. About the Authors
    6. Index
    7. Colophon