The Java EE 5 Tutorial Third Edition

By Eric Jendrock, Jennifer Ball, Debbie Carson, Ian Evans, Scott Fordin, Kim Haase
...............................................
Publisher: Addison Wesley Professional
Pub Date: November 03, 2006
Print ISBN-10: 0-321-49029-0
Print ISBN-13: 978-0-321-49029-2
Pages: 1360

The Java EE 5 Tutorial is an introduction to programming server-side Java applications. This book takes a task-oriented, example-driven approach to show you how to build applications for the Java EE 5 platform. This book also describes the features and functionalities available with NetBeans 5.5.

What's new in this edition? The author team have updated the existing chapters to reflect the changes to JSP, EJB, Servlets, and more. Also, the authors have added new chapters on the Sun Java System Application Server 9 as a deployment environment for server-side technologies. The web-tier technology chapters cover the components used in developing the presentation layer of a Java EE 5 or stand-alone web application. The web services technology chapters cover the APIs used in developing standard web services. The Enterprise JavaBeans (EJB) technology chapters cover the components used in developing the business logic of a Java EE 5 application. The Persistence technology chapters cover the Java Persistence API, which is used for accessing databases from Java EE applications. The platform services chapters cover the system services used by all the Java EE 5 component technologies

Table of Contents
Copyright
About This Tutorial
Chapter 1. Overview
Java EE Application Model
Distributed Multitiered Applications
Java EE Containers
Web Services Support
Java EE Application Assembly and Deployment
Packaging Applications
Development Roles
Java EE 5 APIs
Sun Java System Application Server Platform Edition 9
Part One: The Web Tier
Chapter 2. Getting Started with Web Applications
Web Application Life Cycle
Web Modules
Configuring Web Applications
Duke's Bookstore Examples
Accessing Databases from Web Applications
Further Information
Chapter 3. Java Servlet Technology
What Is a Servlet?
The Example Servlets
Servlet Life Cycle
Sharing Information
Initializing a Servlet
Writing Service Methods
Filtering Requests and Responses
Invoking Other Web Resources
Accessing the Web Context
Maintaining Client State
Finalizing a Servlet
Further Information
Chapter 4. JavaServer Pages Technology
What Is a JSP Page?
The Example JSP Pages
The Life Cycle of a JSP Page
Creating Static Content
Creating Dynamic Content
Unified Expression Language
JavaBeans Components
Using Custom Tags
Reusing Content in JSP Pages
Transferring Control to Another Web Component
Including an Applet
Setting Properties for Groups of JSP Pages
Further Information
Chapter 5. JavaServer Pages Documents
The Example JSP Document
Creating a JSP Document
Identifying the JSP Document to the Container
Chapter 6. JavaServer Pages Standard Tag Library
The Example JSP Pages
Using JSTL
Core Tag Library
XML Tag Library
Internationalization Tag Library
SQL Tag Library
Functions
Further Information
Chapter 7. Custom Tags in JSP Pages
What Is a Custom Tag?
The Example JSP Pages
Types of Tags
Encapsulating Reusable Content Using Tag Files
Tag Library Descriptors
Programming Simple Tag Handlers
Chapter 8. Scripting in JSP Pages
The Example JSP Pages
Using Scripting
Disabling Scripting
Declarations
Scriptlets
Expressions
Programming Tags That Accept Scripting Elements
Chapter 9. JavaServer Faces Technology
JavaServer Faces Technology Benefits
What Is a JavaServer Faces Application?
A Simple JavaServer Faces Application
User Interface Component Model
Navigation Model
Backing Beans
The Life Cycle of a JavaServer Faces Page
Further Information
Chapter 10. 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
Using Localized Data
Using the Standard Converters
Registering Listeners on Components
Using the Standard Validators
Binding Component Values and Instances to External Data Sources
Binding Converters, Listeners, and Validators to Backing Bean Properties
Referencing a Backing Bean Method
Using Custom Objects
Chapter 11. Developing with JavaServer Faces Technology
Writing Bean Properties
Performing Localization
Creating a Custom Converter
Implementing an Event Listener
Creating a Custom Validator
Writing Backing Bean Methods
Chapter 12. Creating Custom UI Components
Determining Whether You Need a Custom Component or Renderer
Understanding the Image Map Example
Steps for Creating a Custom Component
Creating Custom Component Classes
Delegating Rendering to a Renderer
Handling Events for Custom Components
Creating the Component Tag Handler
Defining the Custom Component Tag in a Tag Library Descriptor
Chapter 13. Configuring JavaServer Faces Applications
Application Configuration Resource File
Configuring Beans
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
Chapter 14. Internationalizing and Localizing Web Applications
Java Platform Localization Classes
Providing Localized Messages and Labels
Date and Number Formatting
Character Sets and Encodings
Further Information
Part Two: Web Services
Chapter 15. Building Web Services with JAX-WS
Setting the Port
Creating a Simple Web Service and Client with JAX-WS
Types Supported by JAX-WS
Web Services Interoperability and JAX-WS
Further Information
Chapter 16. Binding between XML Schema and Java Classes
JAXB Architecture
Representing XML Content
Binding XML Schemas
Customizing JAXB Bindings
Examples
Basic Examples
Customizing JAXB Bindings
Java-to-Schema Examples
Further Information
Chapter 17. Streaming API for XML
Why StAX?
StAX API
Using StAX
Sun's Streaming XML Parser Implementation
Example Code
Further Information
Chapter 18. SOAP with Attachments API for Java
Overview of SAAJ
Tutorial
Code Examples
Further Information
Chapter 19. Java API for XML Registries
Overview of JAXR
Implementing a JAXR Client
Running the Client Examples
Using JAXR Clients in Java EE Applications
Further Information
Part Three: Enterprise Beans
Chapter 20. Enterprise Beans
What Is an Enterprise Bean?
What Is a Session Bean?
What Is a Message-Driven Bean?
Defining Client Access with Interfaces
The Contents of an Enterprise Bean
Naming Conventions for Enterprise Beans
The Life Cycles of Enterprise Beans
Further Information
Chapter 21. Getting Started with Enterprise Beans
Creating the Enterprise Bean
Creating the Application Client
Creating the Web Client
Deploying the Java EE Application
Running the Application Client
Running the Web Client
Modifying the Java EE Application
Chapter 22. Session Bean Examples
The cart Example
A Web Service Example: helloservice
Using the Timer Service
Handling Exceptions
Chapter 23. A Message-Driven Bean Example
Example Application Overview
The Application Client
The Message-Driven Bean Class
Packaging, Deploying, and Running the SimpleMessage Example
Creating Deployment Descriptors for Message-Driven Beans
Part Four: Persistence
Chapter 24. Introduction to the Java Persistence API
Entities
Managing Entities
Chapter 25. Persistence in the Web Tier
Accessing Databases from Web Applications
Chapter 26. Persistence in the EJB Tier
The order Application
The roster Application
Chapter 27. The Java Persistence Query Language
Terminology
Simplified Syntax
Example Queries
Full Syntax
Part Five: Services
Chapter 28. Introduction to Security in Java EE
Overview
Security Implementation Mechanisms
Securing Containers
Securing the Application Server
Working with Realms, Users, Groups, and Roles
Establishing a Secure Connection Using SSL
Further Information
Chapter 29. Securing Java EE Applications
Securing Enterprise Beans
Enterprise Bean Example Applications
Securing Application Clients
Securing EIS Applications
Example Applications in the Application Server
Further Information
Chapter 30. Securing Web Applications
Overview
Working with Security Roles
Checking Caller Identity Programmatically
Defining Security Requirements for Web Applications
Examples: Securing Web Applications
Further Information
Chapter 31. The Java Message Service API
Overview
Basic JMS API Concepts
The JMS API Programming Model
Writing Simple JMS Client Applications
Creating Robust JMS Applications
Using the JMS API in a Java EE Application
Further Information
Chapter 32. Java EE Examples Using the JMS API
A Java EE Application That Uses the JMS API with a Session Bean
A Java EE Application That Uses the JMS API with an Entity
An Application Example That Consumes Messages from a Remote Server
An Application Example That Deploys a Message-Driven Bean on Two Servers
Chapter 33. Transactions
What Is a Transaction?
Container-Managed Transactions
Bean-Managed Transactions
Transaction Timeouts
Updating Multiple Databases
Transactions in Web Components
Chapter 34. Resource Connections
Resources and JNDI Naming
DataSource Objects and Connection Pools
Resource Injection
The confirmer Example Application
Further Information
Chapter 35. Connector Architecture
About Resource Adapters
Resource Adapter Contracts
Common Client Interface
Further Information
Part Six: Case Studies
Chapter 36. The Coffee Break Application
Common Code
JAX-WS Coffee Supplier Service
SAAJ Coffee Supplier Service
Coffee Break Server
Building, Packaging, Deploying, and Running the Application
Chapter 37. The Duke's Bank Application
Enterprise Beans
Application Client
Web Client
Building, Packaging, Deploying, and Running the Application
Appendix A. Java Encoding Schemes
Further Information
Appendix B. Preparation for Java EE Certification Exams
CX-310-081: Sun Certified Web Component Developer
SL-351: Business Component Development with Enterprise JavaBeans™ Technology
About the Authors
Index

Another J2EE Books
Download