Documentation Home
> The Java EE 6 Tutorial
The Java EE 6 Tutorial
Book Information
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
Preface
Part I Introduction
Chapter 1 Overview
Java EE 6 Platform Highlights
Java EE Application Model
Distributed Multitiered Applications
Security
Java EE Components
Java EE Clients
Web Clients
Application Clients
Applets
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
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 6 APIs
Enterprise JavaBeans Technology
Java Servlet Technology
JavaServer Faces Technology
JavaServer Pages Technology
JavaServer Pages Standard Tag Library
Java Persistence API
Java Transaction API
Java API for RESTful Web Services
Managed Beans
Contexts and Dependency Injection for the Java EE Platform (JSR 299)
Dependency Injection for Java (JSR 330)
Bean Validation
Java Message Service API
Java EE Connector Architecture
JavaMail API
Java Authorization Contract for Containers
Java Authentication Service Provider Interface for Containers
Java EE 6 APIs in the Java Platform, Standard Edition 6.0
Java Database Connectivity API
Java Naming and Directory Interface API
JavaBeans Activation Framework
Java API for XML Processing
Java Architecture for XML Binding
SOAP with Attachments API for Java
Java API for XML Web Services
Java Authentication and Authorization Service
GlassFish Server Tools
Chapter 2 Using the Tutorial Examples
Required Software
Java Platform, Standard Edition
Java EE 6 Software Development Kit
SDK Installation Tips
Java EE 6 Tutorial Component
To Obtain the Tutorial Component Using the Update Tool
To Obtain the Tutorial Component from the java.net Web Site
NetBeans IDE
To Install NetBeans IDE without GlassFish Server
To Add GlassFish Server as a Server in NetBeans IDE
Apache Ant
To Obtain Apache Ant
Starting and Stopping the GlassFish Server
Starting the Administration Console
To Start the Administration Console in NetBeans IDE
Starting and Stopping the Java DB Server
To Start the Database Server Using NetBeans IDE
Building the Examples
Tutorial Example Directory Structure
Getting the Latest Updates to the Tutorial
To Update the Tutorial Through the Update Center
Debugging Java EE Applications
Using the Server Log
To Use the Log Viewer
Using a Debugger
To Debug an Application Using a Debugger
Part II The Web Tier
Chapter 3 Getting Started with Web Applications
Web Applications
Web Application Lifecycle
Web Modules: The hello1 Example
Examining the hello1 Web Module
To View the hello1 Web Module Using NetBeans IDE
Packaging a Web Module
To Set the Context Root
To Build and Package the hello1 Web Module Using NetBeans IDE
To Build and Package the hello1 Web Module Using Ant
Deploying a Web Module
To Deploy the hello1 Web Module Using NetBeans IDE
To Deploy the hello1 Web Module Using Ant
Running a Deployed Web Module
To Run a Deployed Web Module
Listing Deployed Web Modules
To List Deployed Web Modules Using the Administration Console
To List Deployed Web Modules Using the asadmin Command
Updating a Web Module
To Update a Deployed Web Module
Dynamic Reloading
To Disable or Modify Dynamic Reloading
Undeploying Web Modules
To Undeploy the hello1 Web Module Using NetBeans IDE
To Undeploy the hello1 Web Module Using Ant
Configuring Web Applications: The hello2 Example
Mapping URLs to Web Components
Examining the hello2 Web Module
To View the hello2 Web Module Using NetBeans IDE
Building, Packaging, Deploying, and Running the hello2 Example
To Build, Package, Deploy, and Run the hello2 Example Using NetBeans IDE
To Build, Package, Deploy, and Run the hello2 Example Using Ant
Declaring Welcome Files
Setting Context and Initialization Parameters
To Add a Context Parameter Using NetBeans IDE
To Add an Initialization Parameter Using NetBeans IDE
Mapping Errors to Error Screens
To Set Up Error Mapping Using NetBeans IDE
Declaring Resource References
Declaring a Reference to a Resource
Declaring a Reference to a Web Service
Further Information about Web Applications
Chapter 4 JavaServer Faces Technology
What Is a JavaServer Faces Application?
JavaServer Faces Technology Benefits
Creating a Simple JavaServer Faces Application
Developing the Backing Bean
Creating the Web Page
Mapping the FacesServlet Instance
The Lifecycle of the hello Application
To Build, Package, Deploy, and Run the Application in NetBeans IDE
Further Information about JavaServer Faces Technology
Chapter 5 Introduction to Facelets
What Is Facelets?
Developing a Simple Facelets Application
Creating a Facelets Application
Developing a Backing Bean
Creating Facelets Views
Configuring the Application
Building, Packaging, Deploying, and Running the guessnumber Facelets Example
To Build, Package, and Deploy the guessnumber Example Using NetBeans IDE
To Build, Package, and Deploy the guessnumber Example Using Ant
To Run the guessnumber Example
Templating
Composite Components
Resources
Chapter 6 Expression Language
Overview of the EL
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
Parameterized Method Calls
Defining a Tag Attribute Type
Literal Expressions
Operators
Reserved Words
Examples of EL Expressions
Chapter 7 Using JavaServer Faces Technology in Web Pages
Setting Up a Page
Adding Components to a Page Using HTML Tags
Common Component Tag Attributes
The id Attribute
The immediate Attribute
The rendered Attribute
The style and styleClass Attributes
The value and binding Attributes
Adding HTML Head and Body Tags
Adding a Form Component
Using Text Components
Rendering a Text Field with the h:inputText Tag
Rendering a Password Field with the h:inputSecret Tag
Rendering a Label with the h:outputLabel Tag
Rendering a Hyperlink with the h:outputLink Tag
Displaying a Formatted Message with the h:outputFormat Tag
Using Command Component Tags for Performing Actions and Navigation
Rendering a Button with the h:commandButton Tag
Rendering a Hyperlink with the h:commandLink Tag
Adding Graphics and Images with the h:graphicImage Tag
Laying Out Components with the h:panelGrid and h:panelGroup Tags
Displaying Components for Selecting One Value
Displaying a Check Box Using the h:selectBooleanCheckbox Tag
Displaying a Menu Using the h:selectOneMenu Tag
Displaying Components for Selecting Multiple Values
Using the f:selectItem and f:selectItems Tags
Using the f:selectItems Tag
Using the f:selectItem Tag
Using Data-Bound Table Components
Displaying Error Messages with the h:message and h:messages Tags
Creating Bookmarkable URLs with the h:button and h:link Tags
Using View Parameters to Configure Bookmarkable URLs
Resource Relocation Using h:output Tags
Using Core Tags
Chapter 8 Using Converters, Listeners, and Validators
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 LongRangeValidator
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
Chapter 9 Developing with JavaServer Faces Technology
Backing Beans
Creating a Backing Bean
Using the EL to Reference Backing Beans
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
Writing Properties Bound to Component Instances
Writing Properties Bound to Converters, Listeners, or Validators
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
Using Bean Validation
Validating Null and Empty Strings
Chapter 10 Java Servlet Technology
What Is a Servlet?
Servlet Lifecycle
Handling Servlet Lifecycle Events
Defining the Listener Class
Handling Servlet Errors
Sharing Information
Using Scope Objects
Controlling Concurrent Access to Shared Resources
Creating and 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
To Specify Filter Mappings Using NetBeans IDE
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
Session Management
To Set the Timeout Period Using NetBeans IDE
Session Tracking
Finalizing a Servlet
Tracking Service Requests
Notifying Methods to Shut Down
Creating Polite Long-Running Methods
The mood Example Application
Components of the mood Example Application
Building, Packaging, Deploying, and Running the mood Example
To Build, Package, Deploy, and Run the mood Example Using NetBeans IDE
To Build, Package, Deploy, and Run the mood Example Using Ant
Further Information about Java Servlet Technology
Part III Web Services
Chapter 11 Introduction to Web Services
What Are Web Services?
Types of Web Services
“Big” Web Services
RESTful Web Services
Deciding Which Type of Web Service to Use
Chapter 12 Building Web Services with JAX-WS
Creating a Simple Web Service and Clients with JAX-WS
Requirements of a JAX-WS Endpoint
Coding the Service Endpoint Implementation Class
Building, Packaging, and Deploying the Service
To Build, Package, and Deploy the Service Using NetBeans IDE
To Build, Package, and Deploy the Service Using Ant
Testing the Methods of a Web Service Endpoint
To Test the Service without a Client
A Simple JAX-WS Application Client
Coding the Application Client
Building, Packaging, Deploying, and Running the Application Client
To Build, Package, Deploy, and Run the Application Client Using NetBeans IDE
To Build, Package, Deploy, and Run the Application Client Using Ant
A Simple JAX-WS Web Client
Coding the Servlet
Building, Packaging, Deploying, and Running the Web Client
To Build, Package, Deploy, and Run the Web Client Using NetBeans IDE
To Build, Package, Deploy, and Run the Web Client Using Ant
Types Supported by JAX-WS
Web Services Interoperability and JAX-WS
Further Information about JAX-WS
Chapter 13 Building RESTful Web Services with JAX-RS
What Are RESTful Web Services?
Creating a RESTful Root Resource Class
Developing RESTful Web Services with JAX-RS
Overview of a JAX-RS Application
The @Path Annotation and URI Path Templates
Responding to HTTP Resources
The Request Method Designator Annotations
Using Entity Providers to Map HTTP Response and Request Entity Bodies
Using @Consumes and @Produces to Customize Requests and Responses
The @Produces Annotation
The @Consumes Annotation
Extracting Request Parameters
Example Applications for JAX-RS
A RESTful Web Service
To Create a RESTful Web Service Using NetBeans IDE
The rsvp Example Application
Components of the rsvp Example Application
Running the rsvp Example Application
To Run the rsvp Example Application in NetBeans IDE
To Run the rsvp Example Application Using Ant
Real-World Examples
Further Information about JAX-RS
Part IV Enterprise Beans
Chapter 14 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?
Types of Session Beans
Stateful Session Beans
Stateless Session Beans
Singleton 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
Accessing Enterprise Beans
Using Enterprise Beans in Clients
Portable JNDI Syntax
Deciding on Remote or Local Access
Local Clients
Accessing Local Enterprise Beans Using the No-Interface View
Accessing Local Enterprise Beans That Implement Business Interfaces
Remote Clients
Web Service Clients
Method Parameters and Access
Isolation
Granularity of Accessed Data
The Contents of an Enterprise Bean
Packaging Enterprise Beans in EJB JAR Modules
Packaging Enterprise Beans in WAR Modules
Naming Conventions for Enterprise Beans
The Lifecycles of Enterprise Beans
The Lifecycle of a Stateful Session Bean
The Lifecycle of a Stateless Session Bean
The Lifecycle of a Singleton Session Bean
The Lifecycle of a Message-Driven Bean
Further Information about Enterprise Beans
Chapter 15 Getting Started with Enterprise Beans
Creating the Enterprise Bean
Coding the Enterprise Bean Class
Creating the converter Web Client
Building, Packaging, Deploying, and Running the converter Example
To Build, Package, and Deploy the converter Example in NetBeans IDE
To Build, Package, and Deploy the converter Example Using Ant
To Run the converter Example
Modifying the Java EE Application
To Modify a Class File
Chapter 16 Running the Enterprise Bean Examples
The cart Example
The Business Interface
Session Bean Class
Lifecycle Callback Methods
Business Methods
The @Remove Method
Helper Classes
Building, Packaging, Deploying, and Running the cart Example
To Build, Package, Deploy, and Run the cart Example Using NetBeans IDE
To Build, Package, Deploy, and Run the cart Example Using Ant
The all Task
A Singleton Session Bean Example: counter
Creating a Singleton Session Bean
Initializing Singleton Session Beans
Managing Concurrent Access in a Singleton Session Bean
Container-Managed Concurrency
Bean-Managed Concurrency
Handling Errors in a Singleton Session Bean
The Architecture of the counter Example
Building, Packaging, Deploying, and Running the counter Example
To Build, Package, Deploy, and Run the counter Example Using NetBeans IDE
To Build, Package, Deploy, and Run the counter Example Using Ant
A Web Service Example: helloservice
The Web Service Endpoint Implementation Class
Stateless Session Bean Implementation Class
Building, Packaging, Deploying, and Testing the helloservice Example
To Build, Package, and Deploy the helloservice Example Using NetBeans IDE
To Build, Package, and Deploy the helloservice Example Using Ant
To Test the Service without a Client
Using the Timer Service
Creating Calendar-Based Timer Expressions
Specifying Multiple Values in Calendar Expressions
Using Wildcards in Calendar Expressions
Specifying a List of Values
Specifying a Range of Values
Specifying Intervals
Programmatic Timers
The @Timeout Method
Creating Programmatic Timers
Automatic Timers
Canceling and Saving Timers
Getting Timer Information
Transactions and Timers
The timersession Example
Building, Packaging, Deploying, and Running the timersession Example
To Build, Package, Deploy, and Run the timersession Example Using NetBeans IDE
To Build, Package, and Deploy the timersession Example Using Ant
To Run the Web Client
Handling Exceptions
Chapter 17 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
To Build, Deploy, and Run the simplemessage Application Using NetBeans IDE
To Build, Deploy, and Run the simplemessage Application Using Ant
Removing the Administered Objects for the simplemessage Example
Part V Contexts and Dependency Injection for the Java EE Platform
Chapter 18 Introduction to Contexts and Dependency Injection for the Java EE Platform
Overview of CDI
About Beans
About Managed Beans
Beans as Injectable Objects
Using Qualifiers
Injecting Beans
Using Scopes
Giving Beans EL Names
Adding Setter and Getter Methods
Using a Managed Bean in a Facelets Page
Injecting Objects by Using Producer Methods
Configuring a CDI Application
Further Information about CDI
Chapter 19 Running the Basic Contexts and Dependency Injection Examples
The simplegreeting CDI Example
The simplegreeting Source Files
The Facelets Template and Page
Configuration Files
Building, Packaging, Deploying, and Running the simplegreeting CDI Example
To Build, Package, and Deploy the simplegreeting Example Using NetBeans IDE
To Build, Package, and Deploy the simplegreeting Example Using Ant
To Run the simplegreeting Example
The guessnumber CDI Example
The guessnumber Source Files
The @MaxNumber and @Random Qualifier Interfaces
The Generator Managed Bean
The UserNumberBean Managed Bean
The Facelets Page
Building, Packaging, Deploying, and Running the guessnumber CDI Example
To Build, Package, and Deploy the guessnumber Example Using NetBeans IDE
To Build, Package, and Deploy the guessnumber Example Using Ant
To Run the guessnumber Example
Part VI Persistence
Chapter 20 Introduction to the Java Persistence API
Entities
Requirements for Entity Classes
Persistent Fields and Properties in Entity Classes
Persistent Fields
Persistent Properties
Using Collections in Entity Fields and Properties
Validating Persistent Fields and Properties
Primary Keys in Entities
Multiplicity in Entity Relationships
Direction in Entity Relationships
Bidirectional Relationships
Unidirectional Relationships
Queries and Relationship Direction
Cascade Operations and Relationships
Orphan Removal in Relationships
Embeddable Classes in Entities
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 EntityManager Interface
Container-Managed Entity Managers
Application-Managed Entity Managers
Finding Entities Using the EntityManager
Managing an Entity Instance’s Lifecycle
Persisting Entity Instances
Removing Entity Instances
Synchronizing Entity Data to the Database
Persistence Units
Querying Entities
Further Information about Persistence
Chapter 21 Running the Persistence Examples
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, Packaging, Deploying, and Running the order Application
To Build, Package, Deploy, and Run order UsingNetBeans IDE
To Build, Package, Deploy, and Run order Using Ant
The all Task
The roster Application
Relationships in the roster Application
The Many-To-Many Relationship in roster
Entity Inheritance in the roster Application
Criteria Queries in the roster Application
Metamodel Classes in the roster Application
Obtaining a CriteriaBuilder Instance in RequestBean
Creating Criteria Queries in RequestBean's Business Methods
Automatic Table Generation in the roster Application
Building, Packaging, Deploying, and Running the roster Application
To Build, Package, Deploy, and Run roster Using NetBeans IDE
To Build, Package, Deploy, and Run roster Using Ant
The all Task
The address-book Application
Bean Validation Constraints in address-book
Specifying Error Messages for Constraints in address-book
Validating Contact Input from a JavaServer Faces Application
Building, Packaging, Deploying, and Running the address-book Application
Building, Packaging, Deploying, and Running the address-book Application in NetBeans IDE
Building, Packaging, Deploying, and Running the address-book Application Using Ant
Chapter 22 The Java Persistence Query Language
Query Language Terminology
Creating Queries Using the Java Persistence Query Language
Named Parameters in Queries
Positional Parameters in Queries
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
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
Functional Expressions
Case Expressions
NULL Values
Equality Semantics
SELECT Clause
Return Types
The DISTINCT Keyword
Constructor Expressions
ORDER BY Clause
GROUP BY and HAVING Clauses
Chapter 23 Using the Criteria API to Create Queries
Overview of the Criteria and Metamodel APIs
Using the Metamodel API to Model Entity Classes
Using Metamodel Classes
Using the Criteria API and Metamodel API to Create Basic Typesafe Queries
Creating a Criteria Query
Query Roots
Querying Relationships Using Joins
Path Navigation in Criteria Queries
Restricting Criteria Query Results
The Expression Interface Methods
Expression Methods in the CriteriaBuilder Interface
Managing Criteria Query Results
Ordering Results
Grouping Results
Executing Queries
Single-Valued Query Results
Collection-Valued Query Results
Part VII Security
Chapter 24 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
Features of a Security Mechanism
Characteristics of Application Security
Security Mechanisms
Java SE Security Mechanisms
Java EE Security Mechanisms
Application-Layer Security
Transport-Layer Security
Message-Layer Security
Securing Containers
Using Annotations to Specify Security Information
Using Deployment Descriptors for Declarative Security
Using Programmatic Security
Securing the GlassFish 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 GlassFish Server
To Add Users to the GlassFish Server
Adding Users to the Certificate Realm
Setting Up Security Roles
Mapping Roles to Users and Groups
Establishing a Secure Connection Using SSL
Verifying and Configuring SSL Support
Working with Digital Certificates
Creating a Server Certificate
To Use keytool to Create a Server Certificate
Further Information about Security
Chapter 25 Getting Started Securing Web Applications
Overview of Web Application Security
Securing Web Applications
Specifying Security Constraints
Specifying a Web Resource Collection
Specifying an Authorization Constraint
Specifying a Secure Connection
Specifying Separate Security Constraints for Various Resources
Specifying Authentication Mechanisms
HTTP Basic Authentication
Form-Based Authentication
Digest Authentication
Client Authentication
Mutual Authentication
Specifying an Authentication Mechanism in the Deployment Descriptor
Declaring Security Roles
Using Programmatic Security with Web Applications
Authenticating Users Programmatically
Checking Caller Identity Programmatically
Example Code for Programmatic Security
Declaring and Linking Role References
Examples: Securing Web Applications
To Set Up Your System for Running the Security Examples
Example: Basic Authentication with a Servlet
Specifying Security for Basic Authentication Using Annotations
To Build, Package, and Deploy the Servlet Basic Authentication Example Using NetBeans IDE
To Build, Package, and Deploy the Servlet Basic Authentication Example Using Ant
To Run the Basic Authentication Servlet
Example: Form-Based Authentication with a JavaServer Faces Application
Creating the Login Form and the Error Page
Specifying Security for the Form-Based Authentication Example
To Build, Package, and Deploy the Form-Based Authentication Example Using NetBeans IDE
To Build, Package, and Deploy the Form-Based Authentication Example Using Ant
To Run the Form-Based Authentication Example
Chapter 26 Getting Started Securing Enterprise Applications
Securing Enterprise Beans
Securing an Enterprise Bean Using Declarative Security
Specifying Authorized Users by Declaring Security Roles
Specifying an Authentication Mechanism and Secure Connection
Securing an Enterprise Bean Programmatically
Accessing an Enterprise Bean Caller’s Security Context
Propagating a Security Identity (Run-As)
Configuring a Component’s Propagated Security Identity
Trust between Containers
Deploying Secure Enterprise Beans
Examples: Securing Enterprise Beans
Example: Securing an Enterprise Bean with Declarative Security
Annotating the Bean
To Build, Package, Deploy, and Run the Secure Cart Example Using NetBeans IDE
To Build, Package, Deploy, and Run the Secure Cart Example Using Ant
Example: Securing an Enterprise Bean with Programmatic Security
Modifying ConverterBean
Modifying ConverterServlet
To Build, Package, and Deploy the Secure Converter Example Using NetBeans IDE
To Build, Package, and Deploy the Secure Converter Example Using Ant
To Run the Secure Converter Example
Securing Application Clients
Using Login Modules
Using Programmatic Login
Securing Enterprise Information Systems Applications
Container-Managed Sign-On
Component-Managed Sign-On
Configuring Resource Adapter Security
To Map an Application Principal to EIS Principals
Part VIII Java EE Supporting Technologies
Chapter 27 Introduction to Java EE Supporting Technologies
Transactions
Resources
The Java EE Connector Architecture and Resource Adapters
Java Database Connectivity Software
Java Message Service
Chapter 28 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
To Set a Transaction Timeout
Updating Multiple Databases
Transactions in Web Components
Further Information about Transactions
Chapter 29 Resource Connections
Resources and JNDI Naming
DataSource Objects and Connection Pools
Resource Injection
Field-Based Injection
Method-Based Injection
Class-Based Injection
Resource Adapters and Contracts
Management Contracts
Lifecycle Management
Work Management Contract
Generic Work Context Contract
Outbound and Inbound Contracts
Metadata Annotations
Common Client Interface
Further Information about Resources
Chapter 30 Java Message Service Concepts
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
Creating Robust JMS Applications
Using Basic Reliability Mechanisms
Controlling Message Acknowledgment
Specifying Message Persistence
Setting Message Priority Levels
Allowing Messages to Expire
Creating Temporary Destinations
Using Advanced Reliability Mechanisms
Creating Durable Subscriptions
Using JMS API Local Transactions
Using the JMS API in Java EE Applications
Using @Resource Annotations in Enterprise Bean or Web 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
Chapter 31 Java Message Service Examples
Writing Simple JMS Applications
A Simple Example of Synchronous Message Receives
Writing the Clients for the Synchronous Receive Example
Starting the JMS Provider
To Create JMS Administered Objects for the Synchronous Receive Example
Building, Packaging, Deploying, and Running the Clients for the Synchronous Receive Example
To Build and Package the Clients for the Synchronous Receive Example Using NetBeans IDE
To Deploy and Run the Clients for the Synchronous Receive Example Using NetBeans IDE
To Build and Package the Clients for the Synchronous Receive Example Using Ant
To Deploy and Run the Clients for the Synchronous Receive Example Using Ant and the appclient Command
A Simple Example of Asynchronous Message Consumption
Writing the Clients for the Asynchronous Receive Example
To Build and Package the AsynchConsumer Client Using NetBeans IDE
To Deploy and Run the Clients for the Asynchronous Receive Example Using NetBeans IDE
To Build and Package the AsynchConsumer Client Using Ant
To Deploy and Run the Clients for the Asynchronous Receive Example Using Ant and the appclient Command
A Simple Example of Browsing Messages in a Queue
Writing the Client for the Queue Browser Example
To Build, Package, Deploy, and Run the MessageBrowser Client Using NetBeans IDE
To Build, Package, Deploy, and Run the MessageBrowser Client Using Ant and the appclient Command
Running JMS Clients on Multiple Systems
To Create Administered Objects for Multiple Systems
Changing the Default Host Name
To Change the Default Host Name Using the Administration Console
To Change the Default Host Name Using the asadmin Command
To Edit, Build, Package, Deploy, and Run the Clients Using NetBeans IDE
To Edit, Build, Package, Deploy, and Run the Clients Using Ant and the appclient Command
Undeploying and Cleaning the Simple JMS Examples
Writing Robust JMS Applications
A Message Acknowledgment Example
To Build, Package, Deploy, and Run the ackequivexample Using NetBeans IDE
To Build, Package, Deploy, and Run ackequivexample Using Ant
A Durable Subscription Example
To Build, Package, Deploy, and Run durablesubscriberexample Using NetBeans IDE
To Build, Package, Deploy, and Run durablesubscriberexample Using Ant
A Local Transaction Example
To Build, Package, Deploy, and Run transactedexample Using NetBeans IDE
To Build, Package, Deploy, and Run transactedexample Using Ant and the appclient Command
An 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
To Build, Package, Deploy, and Run the clientsessionmdb Example Using NetBeans IDE
To Build, Package, Deploy, and Run the clientsessionmdb Example Using Ant
An 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
To Build, Package, Deploy, and Run the clientmdbentity Example Using NetBeans IDE
To Build, Package, Deploy, and Run 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
To Build, Package, Deploy, and Run the consumeremoteModules Using NetBeans IDE
To Build, Package, Deploy, and Run 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
To Use Two Application Servers for the sendremote Example
To Build, Package, Deploy, and Run the sendremote Modules Using NetBeans IDE
To Build, Package, Deploy, and Run the sendremote Modules Using Ant
Chapter 32 Advanced Bean Validation Concepts and Examples
Creating Custom Constraints
Using the Built-In Constraints To Make a New Constraint
Customizing Validator Messages
The ValidationMessages Resource Bundle
Localizing Validation Messages
Grouping Constraints
Customizing Group Validation Order
© 2010, Oracle Corporation and/or its affiliates