The JavaT EE 5 Tutorial
- The Java EE 5 Tutorial, Third Edition: For Sun Java System Application Server Platform Edition 9
- 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: hiservice
- 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
- SYMBOL
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
- V
- W
- X