You are previewing Professional Java® JDK®, 6th Edition.
O'Reilly logo
Professional Java® JDK®, 6th Edition

Book Description

Working as an effective professional Java developer requires you to know Java APIs, tools, and techniques to solve a wide variety of Java problems. Building upon Ivor Horton's Beginning Java 2, this resource shows you how to use the core features of the latest JDK as well as powerful open source tools such as Ant, JUnit, and Hibernate. It will arm you with a well-rounded understanding of the professional Java development landscape.

The expert author team begins by uncovering the sophisticated Java language features, the methodology for developing solutions, and steps for exploiting patterns. They then provide you with a collection of real-world examples that will become an essential part of your developer's toolkit. With this approach, you'll gain the skills to build advanced solutions by utilizing the more complex and nuanced parts of Java JDK 6.

What you will learn from this book

  • How to use tools to make your work easier and more productive

  • Methods to develop effective user interfaces with Java Foundation Classes (JFC)

  • Steps to build web applications using the Model 1 and Model 2 architectures

  • Ways to interact with the databases and XML using JDBC and JAXB

  • Techniques for developing enterprise applications using EJB 3.0 and web services

  • How to package and deploy Java applications

Who this book is for

This book is for Java developers who are looking for an all-purpose resource, are ready for more advanced Java solutions and language features, and need assistance when tackling new Java problems that may be outside their technological experience.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Table of Contents

  1. Copyright
  2. About the Authors
  3. Credits
  4. Acknowledgments
  5. Introduction
    1. Who This Book Is For
    2. What This Book Covers
    3. How This Book Is Structured
      1. Part I: Thinking Like a Java Developer
        1. Chapter 1: Key Java Language Features and Libraries
        2. Chapter 2: Tools and Techniques for Developing Java Solutions
        3. Chapter 3: Exploiting Patterns in Java
      2. Part II: A Broad Understanding of Java APIs, Tools, and Techniques
        1. Chapter 4: Developing Effective User Interfaces with JFC
        2. Chapter 5: Persisting Your Application Using Files
        3. Chapter 6: Persisting Your Application Using Databases
        4. Chapter 7: Developing Web Applications Using the Model 1 Architecture
        5. Chapter 8: Developing Web Applications Using the Model 2 Architecture
        6. Chapter 9: Interacting with C/C++ Using Java Native Interface
        7. Chapter 10: EJB 3 and the Java Persistence API
        8. Chapter 11: Communicating between Java Components and Components of Other Platforms
        9. Chapter 12: Service Oriented Integration
        10. Chapter 13: Java Security
        11. Chapter 14: Packaging and Deploying Your Java Applications
    4. What You Need to Use This Book
    5. Conventions
    6. Source Code
    7. Errata
    8. p2p.wrox.com
  6. I. Thinking Like a Java Developer
    1. 1. Key Java Language Features and Libraries
      1. 1.1. Introducing Derby
      2. 1.2. Using Derby
      3. 1.3. Language Features Added in Java 5
        1. 1.3.1. Generics
          1. 1.3.1.1. Type Erasure
          2. 1.3.1.2. Wildcards and Bounded Type Variables
          3. 1.3.1.3. Using Generics
            1. 1.3.1.3.1. Class Instances
            2. 1.3.1.3.2. Arrays
            3. 1.3.1.3.3. Generic Methods
            4. 1.3.1.3.4. Generics and Exceptions
        2. 1.3.2. Enhanced for Loop
        3. 1.3.3. Additions to the Java Class Library
        4. 1.3.4. Variable Arguments
        5. 1.3.5. Boxing and Unboxing Conversions
          1. 1.3.5.1. Boxing Conversions
          2. 1.3.5.2. Unboxing Conversions
          3. 1.3.5.3. Valid Contexts for Boxing and Unboxing Conversions
            1. 1.3.5.3.1. Assignments
            2. 1.3.5.3.2. Method Invocations
        6. 1.3.6. Static Imports
        7. 1.3.7. Enumerations
        8. 1.3.8. Metadata
          1. 1.3.8.1. AnnotationDesc
          2. 1.3.8.2. AnnotationDesc.ElementValuePair
          3. 1.3.8.3. AnnotationTypeDoc
          4. 1.3.8.4. AnnotationTypeElementDoc
          5. 1.3.8.5. AnnotationValue
      4. 1.4. Important Java Utility Libraries
        1. 1.4.1. Java Logging
          1. 1.4.1.1. The Log Manager
            1. 1.4.1.1.1. The LogManager Class
            2. 1.4.1.1.2. The Logger Class
            3. 1.4.1.1.3. Logger Methods
          2. 1.4.1.2. The LogRecord Class
          3. 1.4.1.3. LogRecord Methods
            1. 1.4.1.3.1. Setting Information about Message Origination
            2. 1.4.1.3.2. Resource Bundle Methods
            3. 1.4.1.3.3. Setting Information about the Message
          4. 1.4.1.4. The Level Class
            1. 1.4.1.4.1. Logging Levels
            2. 1.4.1.4.2. Level Methods
          5. 1.4.1.5. The Handler Class
            1. 1.4.1.5.1. Handler Methods
            2. 1.4.1.5.2. Stock Handlers
          6. 1.4.1.6. The Formatter Class
          7. 1.4.1.7. Stock Formatters
            1. 1.4.1.7.1. SimpleFormatter
            2. 1.4.1.7.2. XMLFormatter
          8. 1.4.1.8. Creating Your Own Formatter
          9. 1.4.1.9. The Filter Interface
          10. 1.4.1.10. Creating Your Own Filter
          11. 1.4.1.11. The ErrorManager
          12. 1.4.1.12. Logging Examples
          13. 1.4.1.13. Regular Expressions
          14. 1.4.1.14. The Pattern Class
          15. 1.4.1.15. The Matcher Class
          16. 1.4.1.16. The MatchResult Interface
          17. 1.4.1.17. Regular Expression Example
        2. 1.4.2. Java Preferences
          1. 1.4.2.1. The Preferences Class
            1. 1.4.2.1.1. Operations on the Preferences Tree
            2. 1.4.2.1.2. Retrieving Information about the Node
            3. 1.4.2.1.3. Retrieving Preference Values from the Node
            4. 1.4.2.1.4. Setting Preference Values on the Node
            5. 1.4.2.1.5. Events
            6. 1.4.2.1.6. Other Operations
          2. 1.4.2.2. Exporting to XML
          3. 1.4.2.3. Using Preferences
      5. 1.5. Summary
    2. 2. Tools and Techniques for Developing Java Solutions
      1. 2.1. Principles of Quality Software Development
      2. 2.2. Habits of Effective Software Development
        1. 2.2.1. Communicate
        2. 2.2.2. Model
        3. 2.2.3. Be Agile
        4. 2.2.4. Be Disciplined
        5. 2.2.5. Trace Your Actions to Need
        6. 2.2.6. Don't Be Afraid to Write Code
        7. 2.2.7. Think of Code as a Design, not a Product
        8. 2.2.8. Read a Lot
        9. 2.2.9. Build Your Process from the Ground Up
        10. 2.2.10. Manage Your Configuration
        11. 2.2.11. Unit Test Your Code
        12. 2.2.12. Continuously Integrate
        13. 2.2.13. Maintaining Short Iterations
        14. 2.2.14. Measure What You Accomplished—Indirectly
        15. 2.2.15. Track Your Issues
      3. 2.3. Development Methodology
        1. 2.3.1. Waterfall Methodology
        2. 2.3.2. Unified Process
        3. 2.3.3. Extreme Programming
        4. 2.3.4. Observations on Methodology
      4. 2.4. Practical Development Scenarios
        1. 2.4.1. Ant
          1. 2.4.1.1. Scenario 1
          2. 2.4.1.2. Scenario 2
          3. 2.4.1.3. Scenario 3
        2. 2.4.2. Maven 2
          1. 2.4.2.1. Archetypes
          2. 2.4.2.2. Transitive Dependencies
        3. 2.4.3. TestNG
        4. 2.4.4. XDoclet
        5. 2.4.5. JMeter
      5. 2.5. Summary
    3. 3. Exploiting Patterns in Java
      1. 3.1. Why Patterns Are Important
        1. 3.1.1. Keys to Understanding the Java Programming Language
        2. 3.1.2. Keys to Understanding Tools Used in Java Development
          1. 3.1.2.1. Ant
          2. 3.1.2.2. TestNG
          3. 3.1.2.3. XDoclet
        3. 3.1.3. Keys to Developing Effective Java Solutions
          1. 3.1.3.1. Develop Common Design Vocabulary
          2. 3.1.3.2. Understand the Fundamentals of Design
      2. 3.2. Building Patterns with Design Principles
        1. 3.2.1. Designing a Single Class
        2. 3.2.2. Creating an Association between Classes
        3. 3.2.3. Creating an Interface
        4. 3.2.4. Creating an Inheritance Loop
      3. 3.3. Important Java Patterns
        1. 3.3.1. Adapter
          1. 3.3.1.1. Target
          2. 3.3.1.2. Client
          3. 3.3.1.3. Adaptee
          4. 3.3.1.4. Adapter
        2. 3.3.2. Model-View-Controller
          1. 3.3.2.1. Scenario 1: Changing the Model
          2. 3.3.2.2. Scenario 2: Refreshing When the Model Changes
          3. 3.3.2.3. Scenario 3: Initializing the Application
          4. 3.3.2.4. Model
          5. 3.3.2.5. View
          6. 3.3.2.6. Controller
        3. 3.3.3. Command
          1. 3.3.3.1. Command
          2. 3.3.3.2. CommandManager
          3. 3.3.3.3. Invoker
        4. 3.3.4. Strategy
          1. 3.3.4.1. Strategy
          2. 3.3.4.2. Context
        5. 3.3.5. Composite
          1. 3.3.5.1. Component
          2. 3.3.5.2. Leaf
          3. 3.3.5.3. Composite
      4. 3.4. Summary
  7. II. A Broad Understanding of Java APIs, Tools, and Techniques
    1. 4. Developing Effective User Interfaces with JFC
      1. 4.1. Layout Managers
        1. 4.1.1. BorderLayout
        2. 4.1.2. BoxLayout
        3. 4.1.3. FlowLayout
        4. 4.1.4. GridLayout
        5. 4.1.5. GridBagLayout
        6. 4.1.6. SpringLayout
        7. 4.1.7. CardLayout
        8. 4.1.8. GroupLayout
      2. 4.2. Mustang Release Desktop Enhancements
      3. 4.3. Managing Navigation Flows in Swing Applications
      4. 4.4. Summary
    2. 5. Persisting Your Application Using Files
      1. 5.1. Application Data
        1. 5.1.1. Saving Application Data
        2. 5.1.2. Sample Configuration Data Model for an Application
      2. 5.2. Java Serialization: Persisting Object Graphs
        1. 5.2.1. Key Classes
        2. 5.2.2. Serializing Your Objects
          1. 5.2.2.1. Configuration Example: Saving Your App's Configuration to Disk
            1. 5.2.2.1.1. Writing the Configuration to Disk
            2. 5.2.2.1.2. Reading the Configuration from Disk
            3. 5.2.2.1.3. Wrapping Your Serialization and Deserialization Code Inside Swing Actions
          2. 5.2.2.2. Giving Your Application a Time-Based License Using Serialization
            1. 5.2.2.2.1. Implementing the License
            2. 5.2.2.2.2. Implementing the Timeserver
          3. 5.2.2.3. Tying Your Serialization Components into the Application
        3. 5.2.3. Extending and Customizing Serialization
          1. 5.2.3.1. The Transient Keyword
          2. 5.2.3.2. Customizing the Serialization Format
            1. 5.2.3.2.1. Verification and Validation for Configuration
            2. 5.2.3.2.2. The Externalizable Interface
          3. 5.2.3.3. Versioning
        4. 5.2.4. When to Use Java Serialization
      3. 5.3. JavaBeans Long-Term Serialization: XMLEncoder/Decoder
        1. 5.3.1. Design Differences
          1. 5.3.1.1. XML: The Serialization Format
          2. 5.3.1.2. Key Classes
        2. 5.3.2. Serializing Your JavaBeans
          1. 5.3.2.1. Robustness Demonstrated: Changing a Configuration's Internal Data
          2. 5.3.2.2. Possible Customization
          3. 5.3.2.3. Persistence Delegates
        3. 5.3.3. When to Use XMLEncoder/Decoder
      4. 5.4. Flexible XML Serialization: Java API for XML Binding (JAXB)
        1. 5.4.1. Sample XML Document for the Configuration Object
        2. 5.4.2. Defining Your XML Format with an XML Schema
          1. 5.4.2.1. Defining Your Data: Configuration.xsd
          2. 5.4.2.2. Generating JAXB Java Classes from Your Schema
          3. 5.4.2.3. Generated JAXB Object Graphs
        3. 5.4.3. JAXB API Key Classes
        4. 5.4.4. Marshalling and Unmarshalling XML Data
        5. 5.4.5. Creating New XML Content with JAXB-Generated Classes
        6. 5.4.6. Using JAXB-Generated Classes in Your Application
          1. 5.4.6.1. Implementing the Save Action
          2. 5.4.6.2. Implementing the Load Action
        7. 5.4.7. Annotating Existing Java Classes for Use with JAXB
          1. 5.4.7.1. A Simple Case
          2. 5.4.7.2. JAXB API Key Annotations
          3. 5.4.7.3. Annotating the Data Model
            1. 5.4.7.3.1. The Class Declaration: XmlRootElement, XmlType, and XmlAccessorType
            2. 5.4.7.3.2. XmlElement and XmlAttribute
            3. 5.4.7.3.3. XmlElementWrapper
            4. 5.4.7.3.4. XmlJavaTypeAdapter
            5. 5.4.7.3.5. XmlTransient
          4. 5.4.7.4. Generating an XML Schema from JAXB Annotated Classes
          5. 5.4.7.5. JAXB Pitfalls
            1. 5.4.7.5.1. JAXB Serializes by Value
            2. 5.4.7.5.2. XmlJavaTypeAdapter as the Root of Serialization
        8. 5.4.8. When to Use JAXB
        9. 5.4.9. Where JAXB Fits in the JDK
      5. 5.5. Summary
    3. 6. Persisting Your Application Using Databases
      1. 6.1. JDBC API Overview
      2. 6.2. Setting Up Your Environment
      3. 6.3. JDBC API Usage in the Real World
        1. 6.3.1. Understanding the Two-Tier Model
        2. 6.3.2. Understanding the Three-Tier Model
      4. 6.4. Effectively Using JDBC 4.0
        1. 6.4.1. Overview
        2. 6.4.2. Managing Connections
          1. 6.4.2.1. DriverManager
          2. 6.4.2.2. DataSource
        3. 6.4.3. Understanding Statements
          1. 6.4.3.1. Investigating the Statement Interface
          2. 6.4.3.2. Exploring the PreparedStatement Interface
            1. 6.4.3.2.1. Setting IN Parameters
            2. 6.4.3.2.2. IN Parameter Pitfalls
            3. 6.4.3.2.3. Specifying JDBC Types with setObject
          3. 6.4.3.3. Exploring the CallableStatement Interface
          4. 6.4.3.4. Utilizing Batch Updates
            1. 6.4.3.4.1. Creating Batch Updates Using a Statement Object
            2. 6.4.3.4.2. Creating Batch Updates Using a PreparedStatement Object
        4. 6.4.4. Utilizing Result Sets
          1. 6.4.4.1. Investigating Types of Result Sets
          2. 6.4.4.2. Setting Concurrency of Result Sets
          3. 6.4.4.3. Setting Holdability of Result Sets
          4. 6.4.4.4. Using Result Sets
            1. 6.4.4.4.1. Navigating Result Sets
            2. 6.4.4.4.2. Manipulating Result Sets
            3. 6.4.4.4.3. Closing Result Sets
        5. 6.4.5. Advanced Concepts
          1. 6.4.5.1. Annotations
          2. 6.4.5.2. Managing Transactions
            1. 6.4.5.2.1. What Is a Transaction?
            2. 6.4.5.2.2. Standard Transactions
      5. 6.5. Hibernate
        1. 6.5.1. Hibernate Components
          1. 6.5.1.1. Persistent Java Object
          2. 6.5.1.2. Hibernate Mapping File
          3. 6.5.1.3. Hibernate Configuration File
          4. 6.5.1.4. Hibernate API
        2. 6.5.2. Hibernate Example
          1. 6.5.2.1. Setup
          2. 6.5.2.2. HibernateUtil
          3. 6.5.2.3. Book Manager
          4. 6.5.2.4. Hibernate Example
            1. 6.5.2.4.1. Many-to-One
            2. 6.5.2.4.2. Mapping Components
            3. 6.5.2.4.3. Mapping Collections
          5. 6.5.2.5. Criteria Interface
          6. 6.5.2.6. Query Interface
      6. 6.6. Summary
    4. 7. Developing Web Applications Using the Model 1 Architecture
      1. 7.1. What Is Model 1? Why Use It?
        1. 7.1.1. JSP 2.0 Overview
          1. 7.1.1.1. Servlet 2.4 Support
          2. 7.1.1.2. Expression Language Support
          3. 7.1.1.3. Code Reuse with .tag and .tagx Files
          4. 7.1.1.4. JSP Page Extensions (.jspx)
          5. 7.1.1.5. Simple Invocation Protocol
        2. 7.1.2. Integrated Expression Language (EL)
        3. 7.1.3. JSTL 1.1 Overview
          1. 7.1.3.1. Function Tag Library
          2. 7.1.3.2. SQL Actions
        4. 7.1.4. Developing Your Web Application Visualizations with JSTL 1.1
        5. 7.1.5. Developing Your Web Application Visualizations with JSP 2.0
        6. 7.1.6. AJAX
          1. 7.1.6.1. What Is AJAXTags? Why Use It?
          2. 7.1.6.2. What Is DWR? Why Use It?
      2. 7.2. Summary
    5. 8. Developing Web Applications Using the Model 2 Architecture
      1. 8.1. The Problem
      2. 8.2. What Is Model 2?
      3. 8.3. Why Use Model 2?
      4. 8.4. Developing an Application with WebWork
        1. 8.4.1. What Is Inversion of Control and Why Is it Useful?
        2. 8.4.2. Architecture
          1. 8.4.2.1. Interceptors
          2. 8.4.2.2. ValueStack
          3. 8.4.2.3. OGNL
          4. 8.4.2.4. Components
        3. 8.4.3. Extending the Framework to Support Hibernate
        4. 8.4.4. Preventing the Hanging Session
        5. 8.4.5. Defining Your Domain Model
        6. 8.4.6. Implementing Your Use Cases with Actions
        7. 8.4.7. Developing Your Views
          1. 8.4.7.1. Adding Contacts to the System
          2. 8.4.7.2. Browsing Contacts
        8. 8.4.8. Configuring Your Application
        9. 8.4.9. Adapting to Changes
      5. 8.5. Summary
    6. 9. Interacting with C/C++ Using Java Native Interface
      1. 9.1. A First Look at Java Native Interface
        1. 9.1.1. Creating the Java Code
        2. 9.1.2. Creating the Native Code and Library
        3. 9.1.3. Executing the Code
      2. 9.2. Java Native Interface
        1. 9.2.1. Data Types
        2. 9.2.2. Strings in JNI
        3. 9.2.3. Arrays in JNI
          1. 9.2.3.1. How Arrays Can and Cannot Be Used
          2. 9.2.3.2. Array Functions
            1. 9.2.3.2.1. Functions for Arrays of Objects
            2. 9.2.3.2.2. Functions for Arrays of Primitive Types
        4. 9.2.4. Working with Java Objects in C/C++
          1. 9.2.4.1. Accessing Fields in JNI
          2. 9.2.4.2. Invoking Java Methods Using JNI
        5. 9.2.5. Handling Java Exceptions in Native Code
        6. 9.2.6. Working with Object References in Native Code
          1. 9.2.6.1. Local References
          2. 9.2.6.2. Global and Weak Global References
          3. 9.2.6.3. Comparing References
        7. 9.2.7. Advanced Programming Using JNI
          1. 9.2.7.1. Java Threading
          2. 9.2.7.2. Native NIO Support
          3. 9.2.7.3. Manually Registering Native Methods
          4. 9.2.7.4. Reflection
      3. 9.3. Developing an Email Client
        1. 9.3.1. System Design
        2. 9.3.2. User Interface
      4. 9.4. Summary
    7. 10. EJB 3 and the Java Persistence API
      1. 10.1. New Features
      2. 10.2. Java Persistence API (JPA)
        1. 10.2.1. Entities
        2. 10.2.2. Query Language
        3. 10.2.3. EntityManager
        4. 10.2.4. What Are Session Beans? The Demise of Entity Beans?
        5. 10.2.5. Interceptors
        6. 10.2.6. EJB 3 and Java Persistence API Web Component Examples
          1. 10.2.6.1. Scenario 1
          2. 10.2.6.2. Scenario 2
          3. 10.2.6.3. Scenario 3
      3. 10.3. Summary
    8. 11. Communicating between Java Components and Components of Other Platforms
      1. 11.1. Component Communication Scenarios
        1. 11.1.1. News Reader: Automated Web Browsing
        2. 11.1.2. A Bank Application: An EJB/Java EE Client
        3. 11.1.3. A Portal: Integrating Heterogeneous Data Sources and Services
      2. 11.2. Overview of Interprocess Communication and Basic Network Architecture
      3. 11.3. Sockets
        1. 11.3.1. The Java Socket API
          1. 11.3.1.1. Key Classes
          2. 11.3.1.2. Client Programming
          3. 11.3.1.3. Server Programming
          4. 11.3.1.4. Putting it All Together: An Echo Server
            1. 11.3.1.4.1. SocketEcho
            2. 11.3.1.4.2. Running the Echo Server
        2. 11.3.2. Implementing a Protocol
          1. 11.3.2.1. Protocol Specification
            1. 11.3.2.1.1. Basic Elements of HTTP
            2. 11.3.2.1.2. A Simple Implementation of HTTP GET
            3. 11.3.2.1.3. TCP Monitoring: Testing with Apache TCPMon
          2. 11.3.2.2. Proprietary Protocols and Reverse Engineering
          3. 11.3.2.3. Utilizing Existing Protocols and Implementations
      4. 11.4. Remote Method Invocation
        1. 11.4.1. Core RPC/RMI Principles
          1. 11.4.1.1. Marshalling and Unmarshalling
          2. 11.4.1.2. Protocols
          3. 11.4.1.3. RMI Registry
          4. 11.4.1.4. Distributed Objects
          5. 11.4.1.5. Middleware and Java EE
      5. 11.5. Common Object Request Broker Architecture
        1. 11.5.1. CORBA Basics
          1. 11.5.1.1. IDL: Interface Definition Language
          2. 11.5.1.2. ORB: Object Request Broker
          3. 11.5.1.3. Common Object Service (COS) Naming
          4. 11.5.1.4. IIOP: Internet InterORB Protocol
        2. 11.5.2. RMI-IIOP: Making RMI Compatible with CORBA
        3. 11.5.3. How to Turn an RMI Object into an RMI-IIOP Object
        4. 11.5.4. When to Use CORBA
        5. 11.5.5. Distributed File System Notifications: An Example CORBA System
          1. 11.5.5.1. The Implementation
          2. 11.5.5.2. Running the Example
      6. 11.6. Web Services
        1. 11.6.1. Random-Weather.org
        2. 11.6.2. Platform-Independent RPC
          1. 11.6.2.1. WS-I Basic Profile
          2. 11.6.2.2. Web Services Description Language (WSDL)
          3. 11.6.2.3. Simple Object Access Protocol (SOAP)
          4. 11.6.2.4. Underlying Transport Protocols
          5. 11.6.2.5. Weather Web Site Example
          6. 11.6.2.6. Creating a Web Service from a Java Method
            1. 11.6.2.6.1. Using JAX-WS Annotations
            2. 11.6.2.6.2. Running wsgen
            3. 11.6.2.6.3. Deploying Your Web Service with JDK 6
            4. 11.6.2.6.4. Deploying Your Web Service with Tomcat
            5. 11.6.2.6.5. Configuring web.xml and sun-jaxws.xml
          7. 11.6.2.7. Writing a Web Service Client
            1. 11.6.2.7.1. Running wsimport
            2. 11.6.2.7.2. Generating Stubs Supporting Asynchronous Invocation
            3. 11.6.2.7.3. Calling a Web Service
            4. 11.6.2.7.4. Web Service Security with Basic HTTP Authentication
          8. 11.6.2.8. Putting It All Together: Weather System Tray App
            1. 11.6.2.8.1. Weather Watcher Application
            2. 11.6.2.8.2. Using TCPMon to Simulate a Slow Connection
            3. 11.6.2.8.3. Other Client-Side Possibilities
          9. 11.6.2.9. Web Services Interoperability Technologies Project (WSIT)
      7. 11.7. Summary
    9. 12. Service Oriented Integration
      1. 12.1. Service Oriented Architecture
      2. 12.2. Enabling Technology
      3. 12.3. Java Management Extensions
        1. 12.3.1. Why Is JMX Important?
        2. 12.3.2. The JMX Architecture
        3. 12.3.3. Creating and Managing a Standard MBean
        4. 12.3.4. JMX Management
          1. 12.3.4.1. RemoteAgent
          2. 12.3.4.2. RemoteClient
          3. 12.3.4.3. WorkMonitor
      4. 12.4. Java Messaging Service
        1. 12.4.1. Why Is JMS Important?
        2. 12.4.2. Endpoints: Queues and Topics
        3. 12.4.3. Sending and Receiving Messages
          1. 12.4.3.1. Configuring the JMS Server
          2. 12.4.3.2. MessageClient
          3. 12.4.3.3. JMSWorkerMBean
          4. 12.4.3.4. JMSWorker
          5. 12.4.3.5. JMSAgent
      5. 12.5. System Integration Patterns
        1. 12.5.1. Processing Chain
        2. 12.5.2. Request-Reply
        3. 12.5.3. Split-Aggregate
      6. 12.6. Summary
    10. 13. Java Security
      1. 13.1. Java Cryptography Architecture and Java Cryptography Extension (JCA/JCE)
        1. 13.1.1. JCA Design and Architecture
          1. 13.1.1.1. Engine Classes
          2. 13.1.1.2. Calculating and Verifying Message Digests
          3. 13.1.1.3. Digital Signing and Verification of Data
          4. 13.1.1.4. Digital Key Creation and Management
          5. 13.1.1.5. Storing and Managing Keys
          6. 13.1.1.6. Algorithm Management
          7. 13.1.1.7. Random Number Generation
          8. 13.1.1.8. XML Digital Signatures
            1. 13.1.1.8.1. Signing Documents
            2. 13.1.1.8.2. Validating a Signature
          9. 13.1.1.9. Certificate Management
            1. 13.1.1.9.1. CertificateFactory
            2. 13.1.1.9.2. CertPathBuilder
            3. 13.1.1.9.3. CertPathValidator
            4. 13.1.1.9.4. CertStore
        2. 13.1.2. Java Cryptography Extension
          1. 13.1.2.1. The Cipher Engine Class
            1. 13.1.2.1.1. Encrypting/Decrypting Data
            2. 13.1.2.1.2. Wrapping and Unwrapping Keys
          2. 13.1.2.2. KeyGenerator
          3. 13.1.2.3. SecretKeyFactory
          4. 13.1.2.4. Protecting Objects through Sealing
          5. 13.1.2.5. Computing Message Authentication Codes
      2. 13.2. Program Security Using JAAS
        1. 13.2.1. User Identification
        2. 13.2.2. Executing Code with Security Checks
          1. 13.2.2.1. Principals
          2. 13.2.2.2. Credentials
          3. 13.2.2.3. Authenticating a Subject
          4. 13.2.2.4. Configuration
          5. 13.2.2.5. LoginContext
        3. 13.2.3. Authorization
      3. 13.3. Summary
    11. 14. Packaging and Deploying Your Java Applications
      1. 14.1. Examining Java Classpaths
      2. 14.2. Investigating the Endorsed Directory
      3. 14.3. Exploring Java Archives
      4. 14.4. Manipulating JAR Files
        1. 14.4.1. Examining the Basic Manifest File
        2. 14.4.2. Examining Applets and JARs
        3. 14.4.3. Signing JAR Files
        4. 14.4.4. Examining the JAR Index Option
        5. 14.4.5. Creating an Executable JAR
      5. 14.5. Analyzing Applets
        1. 14.5.1. Basic Anatomy of an Applet
        2. 14.5.2. Packaging an Applet for Execution
        3. 14.5.3. Examining Applet Security
      6. 14.6. Exploring Web Applications
        1. 14.6.1. Examining the WAR Directory Structure
        2. 14.6.2. Understanding the WAR Deployment Descriptor
      7. 14.7. Packaging Enterprise JavaBeans
      8. 14.8. Inspecting Enterprise Archives
        1. 14.8.1. The EAR Descriptor File
        2. 14.8.2. Deployment Scenario
      9. 14.9. Jumping into Java Web Start
        1. 14.9.1. Examining the TicTacToe Example
          1. 14.9.1.1. TicTacToe.JNLP
          2. 14.9.1.2. TTTMain.java
          3. 14.9.1.3. TTTLogic.java
          4. 14.9.1.4. TTTGui.java
        2. 14.9.2. Summarizing Java Web Start
      10. 14.10. Using Ant with Web Archives
        1. 14.10.1. Installing Ant
        2. 14.10.2. Building Projects with Ant
      11. 14.11. Summary