Skip to Content
Sun and Oracle
Channel Sun
How to Buy
Log In
日本語
ホーム
>
Sun GlassFish Enterprise Server v2.1.1
> The Java EE 5 Tutorial
The Java EE 5 Tutorial
この本のみを検索
検索のヘルプ
内に含ま
Sun GlassFish Enterprise Server v2.1.1
Sun GlassFish Communications Server 2.0
Sun GlassFish Communications Server 1.5
Sun Java System Application Server 9.1
Sun GlassFish Enterprise Server 2.1
Sun Java System Application Server 9.1 Update 1-9.1 Update 2
その他のドキュメント
タイトル
製品カテゴリ
サポート リソース
Sun のトレーニングコース
BigAdmin システム管理ポータル
Sun サポートセンター
Sun Solve
PDF 文書ファイルをダウンロードする (9900 KB)
The Java EE 5 Tutorial
Index
Numbers and Symbols
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Book Information
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
1. Overview
Java EE Application Model
Distributed Multitiered Applications
Security
Java EE Components
Java EE Clients
Web Clients
Applets
Application Clients
The JavaBeans 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
2. 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
3. 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
4. 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
5. 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
6. 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
7. 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
8. 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
9. 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
10. 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
11. 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
12. 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
13. 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
14. 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
15. 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
16. 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
17. 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
18. 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
19. 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
20. 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
21. 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
22. 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
23. 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
24. 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
25. 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
26. 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
27. 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
28. 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
29. 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
30. 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
31. 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
32. 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
33. 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
34. 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
35. 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
36. 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
37. 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
A. Java Encoding Schemes
Further Information about Character Encoding
B. Preparation for Java EE Certification Exams
CX-310-083: Sun Certified Web Component Developer
SL-351–EE5: Business Component Development with Enterprise JavaBeans Technology
C. About the Authors
News Center
About Sun
Contact Sun
Terms of Use
Privacy
Copyright
1994-2009
Sun Microsystems, Inc.
PDF 文書ファイルをダウンロードする (9900 KB)