32.6 Naming Conventions for Enterprise Beans
Because enterprise beans are composed of multiple parts, it's useful to follow a naming convention for your applications. Table 32-2 summarizes the conventions for the example beans in this tutorial.
Java Platform, Enterprise Edition: The Java EE Tutorial
Table of Contents
Java Platform, Enterprise Edition: The Java EE Tutorial
Expand | Collapse- Title and Copyright Information
- Preface
- Part I Introduction
- 1 Overview
- 1.1 Java EE 7 Platform Highlights
- 1.2 Java EE Application Model
- 1.3 Distributed Multitiered Applications
- 1.4 Java EE Containers
- 1.5 Web Services Support
- 1.6 Java EE Application Assembly and Deployment
- 1.7 Java EE 7 APIs
- 1.7.1 Enterprise JavaBeans Technology
- 1.7.2 Java Servlet Technology
- 1.7.3 JavaServer Faces Technology
- 1.7.4 JavaServer Pages Technology
- 1.7.5 JavaServer Pages Standard Tag Library
- 1.7.6 Java Persistence API
- 1.7.7 Java Transaction API
- 1.7.8 Java API for RESTful Web Services
- 1.7.9 Managed Beans
- 1.7.10 Contexts and Dependency Injection for Java EE
- 1.7.11 Dependency Injection for Java
- 1.7.12 Bean Validation
- 1.7.13 Java Message Service API
- 1.7.14 Java EE Connector Architecture
- 1.7.15 JavaMail API
- 1.7.16 Java Authorization Contract for Containers
- 1.7.17 Java Authentication Service Provider Interface for Containers
- 1.7.18 Java API for WebSocket
- 1.7.19 Java API for JSON Processing
- 1.7.20 Concurrency Utilities for Java EE
- 1.7.21 Batch Applications for the Java Platform
- 1.8 Java EE 7 APIs in the Java Platform, Standard Edition 7
- 1.8.1 Java Database Connectivity API
- 1.8.2 Java Naming and Directory Interface API
- 1.8.3 JavaBeans Activation Framework
- 1.8.4 Java API for XML Processing
- 1.8.5 Java Architecture for XML Binding
- 1.8.6 Java API for XML Web Services
- 1.8.7 SOAP with Attachments API for Java
- 1.8.8 Java Authentication and Authorization Service
- 1.8.9 Common Annotations for the Java Platform
- 1.9 GlassFish Server Tools
- 2 Using the Tutorial Examples
- 2.1 Required Software
- 2.2 Starting and Stopping GlassFish Server
- 2.3 Starting the Administration Console
- 2.4 Starting and Stopping the Java DB Server
- 2.5 Building the Examples
- 2.6 Tutorial Example Directory Structure
- 2.7 Java EE 7 Maven Archetypes in the Tutorial
- 2.8 Getting the Latest Updates to the Tutorial
- 2.9 Debugging Java EE Applications
- 1 Overview
- Part II Platform Basics
- Part III The Web Tier
- 6 Getting Started with Web Applications
- 6.1 Web Applications
- 6.2 Web Application Lifecycle
- 6.3 A Web Module That Uses JavaServer Faces Technology: The hello1 Example
- 6.4 A Web Module That Uses Java Servlet Technology: The hello2 Example
- 6.5 Configuring Web Applications
- 6.6 Further Information about Web Applications
- 7 JavaServer Faces Technology
- 7.1 What Is a JavaServer Faces Application?
- 7.2 JavaServer Faces Technology Benefits
- 7.3 A Simple JavaServer Faces Application
- 7.4 User Interface Component Model
- 7.5 Navigation Model
- 7.6 The Lifecycle of a JavaServer Faces Application
- 7.7 Partial Processing and Partial Rendering
- 7.8 Further Information about JavaServer Faces Technology
- 8 Introduction to Facelets
- 8.1 What Is Facelets?
- 8.2 The Lifecycle of a Facelets Application
- 8.3 Developing a Simple Facelets Application: The guessnumber-jsf Example Application
- 8.4 Using Facelets Templates
- 8.5 Composite Components
- 8.6 Web Resources
- 8.7 Relocatable Resources
- 8.8 Resource Library Contracts
- 8.9 HTML5-Friendly Markup
- 8.9.1 Using Pass-Through Elements
- 8.9.2 Using Pass-Through Attributes
- 8.9.3 The reservation Example Application
- 8.9.3.1 The Facelets Pages for the reservation Application
- 8.9.3.2 The Managed Bean for the reservation Application
- 8.9.3.3 To Build, Package, and Deploy the reservation Example Using NetBeans IDE
- 8.9.3.4 To Build, Package, and Deploy the reservation Example Using Maven
- 8.9.3.5 To Run the reservation Example
- 9 Expression Language
- 10 Using JavaServer Faces Technology in Web Pages
- 10.1 Setting Up a Page
- 10.2 Adding Components to a Page Using HTML Tag Library Tags
- 10.2.1 Common Component Tag Attributes
- 10.2.2 Adding HTML Head and Body Tags
- 10.2.3 Adding a Form Component
- 10.2.4 Using Text Components
- 10.2.5 Using Command Component Tags for Performing Actions and Navigation
- 10.2.6 Adding Graphics and Images with the h:graphicImage Tag
- 10.2.7 Laying Out Components with the h:panelGrid and h:panelGroup Tags
- 10.2.8 Displaying Components for Selecting One Value
- 10.2.9 Displaying Components for Selecting Multiple Values
- 10.2.10 Using the f:selectItem and f:selectItems Tags
- 10.2.11 Displaying the Results from Selection Components
- 10.2.12 Using Data-Bound Table Components
- 10.2.13 Displaying Error Messages with the h:message and h:messages Tags
- 10.2.14 Creating Bookmarkable URLs with the h:button and h:link Tags
- 10.2.15 Using View Parameters to Configure Bookmarkable URLs
- 10.2.16 The bookmarks Example Application
- 10.2.17 Resource Relocation Using h:outputScript and h:outputStylesheet Tags
- 10.3 Using Core Tags
- 11 Using Converters, Listeners, and Validators
- 12 Developing with JavaServer Faces Technology
- 13 Using Ajax with JavaServer Faces Technology
- 13.1 Overview of Ajax
- 13.2 Using Ajax Functionality with JavaServer Faces Technology
- 13.3 Using Ajax with Facelets
- 13.4 Sending an Ajax Request
- 13.5 Monitoring Events on the Client
- 13.6 Handling Errors
- 13.7 Receiving an Ajax Response
- 13.8 Ajax Request Lifecycle
- 13.9 Grouping of Components
- 13.10 Loading JavaScript as a Resource
- 13.11 The ajaxguessnumber Example Application
- 13.12 Further Information about Ajax in JavaServer Faces Technology
- 14 Composite Components: Advanced Topics and an Example
- 14.1 Attributes of a Composite Component
- 14.2 Invoking a Managed Bean
- 14.3 Validating Composite Component Values
- 14.4 The compositecomponentexample Example Application
- 15 Creating Custom UI Components and Other Custom Objects
- 15.1 Determining Whether You Need a Custom Component or Renderer
- 15.2 Understanding the Image Map Example
- 15.3 Steps for Creating a Custom Component
- 15.4 Creating Custom Component Classes
- 15.5 Delegating Rendering to a Renderer
- 15.6 Implementing an Event Listener
- 15.7 Handling Events for Custom Components
- 15.8 Defining the Custom Component Tag in a Tag Library Descriptor
- 15.9 Using a Custom Component
- 15.10 Creating and Using a Custom Converter
- 15.11 Creating and Using a Custom Validator
- 15.12 Binding Component Values and Instances to Managed Bean Properties
- 15.13 Binding Converters, Listeners, and Validators to Managed Bean Properties
- 16 Configuring JavaServer Faces Applications
- 16.1 Using Annotations to Configure Managed Beans
- 16.2 Application Configuration Resource File
- 16.3 Using Faces Flows
- 16.3.1 Packaging Flows in an Application
- 16.3.2 The Simplest Possible Flow: The simple-flow Example Application
- 16.3.3 The checkout-module Example Application
- 16.3.3.1 The Facelets Pages for the checkout-module Example
- 16.3.3.2 Using a Configuration File to Configure a Flow
- 16.3.3.3 Using a Java Class to Configure a Flow
- 16.3.3.4 The Flow-Scoped Managed Beans
- 16.3.3.5 To Build, Package, and Deploy the checkout-module Example Using NetBeans IDE
- 16.3.3.6 To Build, Package, and Deploy the checkout-module Example Using Maven
- 16.3.3.7 To Run the checkout-module Example
- 16.4 Configuring Managed Beans
- 16.5 Registering Application Messages
- 16.6 Using Default Validators
- 16.7 Registering a Custom Validator
- 16.8 Registering a Custom Converter
- 16.9 Configuring Navigation Rules
- 16.10 Registering a Custom Renderer with a Render Kit
- 16.11 Registering a Custom Component
- 16.12 Basic Requirements of a JavaServer Faces Application
- 17 Java Servlet Technology
- 17.1 What Is a Servlet?
- 17.2 Servlet Lifecycle
- 17.3 Sharing Information
- 17.4 Creating and Initializing a Servlet
- 17.5 Writing Service Methods
- 17.6 Filtering Requests and Responses
- 17.7 Invoking Other Web Resources
- 17.8 Accessing the Web Context
- 17.9 Maintaining Client State
- 17.10 Finalizing a Servlet
- 17.11 Uploading Files with Java Servlet Technology
- 17.12 Asynchronous Processing
- 17.13 Nonblocking I/O
- 17.14 Protocol Upgrade Processing
- 17.15 The mood Example Application
- 17.16 The fileupload Example Application
- 17.17 The dukeetf Example Application
- 17.18 Further Information about Java Servlet Technology
- 18 Java API for WebSocket
- 18.1 Introduction to WebSocket
- 18.2 Creating WebSocket Applications in the Java EE Platform
- 18.3 Programmatic Endpoints
- 18.4 Annotated Endpoints
- 18.5 Sending and Receiving Messages
- 18.6 Maintaining Client State
- 18.7 Using Encoders and Decoders
- 18.8 Path Parameters
- 18.9 Handling Errors
- 18.10 Specifying an Endpoint Configurator Class
- 18.11 The dukeetf2 Example Application
- 18.12 The websocketbot Example Application
- 18.13 Further Information about WebSocket
- 19 JSON Processing
- 19.1 Introduction to JSON
- 19.2 JSON Processing in the Java EE Platform
- 19.3 Using the Object Model API
- 19.4 Using the Streaming API
- 19.5 JSON in Java EE RESTful Web Services
- 19.6 The jsonpmodel Example Application
- 19.7 The jsonpstreaming Example Application
- 19.8 Further Information about the Java API for JSON Processing
- 20 Internationalizing and Localizing Web Applications
- 6 Getting Started with Web Applications
- Part IV Bean Validation
- 21 Introduction to Bean Validation
- 22 Bean Validation: Advanced Topics
- Part V Contexts and Dependency Injection for Java EE
- 23 Introduction to Contexts and Dependency Injection for Java EE
- 23.1 Getting Started
- 23.2 Overview of CDI
- 23.3 About Beans
- 23.4 About CDI Managed Beans
- 23.5 Beans as Injectable Objects
- 23.6 Using Qualifiers
- 23.7 Injecting Beans
- 23.8 Using Scopes
- 23.9 Giving Beans EL Names
- 23.10 Adding Setter and Getter Methods
- 23.11 Using a Managed Bean in a Facelets Page
- 23.12 Injecting Objects by Using Producer Methods
- 23.13 Configuring a CDI Application
- 23.14 Using the @PostConstruct and @PreDestroy Annotations with CDI Managed Bean Classes
- 23.15 Further Information about CDI
- 24 Running the Basic Contexts and Dependency Injection Examples
- 25 Contexts and Dependency Injection for Java EE: Advanced Topics
- 25.1 Packaging CDI Applications
- 25.2 Using Alternatives in CDI Applications
- 25.3 Using Producer Methods, Producer Fields, and Disposer Methods in CDI Applications
- 25.4 Using Predefined Beans in CDI Applications
- 25.5 Using Events in CDI Applications
- 25.6 Using Interceptors in CDI Applications
- 25.7 Using Decorators in CDI Applications
- 25.8 Using Stereotypes in CDI Applications
- 26 Running the Advanced Contexts and Dependency Injection Examples
- 26.1 The encoder Example: Using Alternatives
- 26.2 The producermethods Example: Using a Producer Method to Choose a Bean Implementation
- 26.3 The producerfields Example: Using Producer Fields to Generate Resources
- 26.4 The billpayment Example: Using Events and Interceptors
- 26.5 The decorators Example: Decorating a Bean
- 23 Introduction to Contexts and Dependency Injection for Java EE
- Part VI Web Services
- 27 Introduction to Web Services
- 28 Building Web Services with JAX-WS
- 28.1 Creating a Simple Web Service and Clients with JAX-WS
- 28.2 Types Supported by JAX-WS
- 28.3 Web Services Interoperability and JAX-WS
- 28.4 Further Information about JAX-WS
- 29 Building RESTful Web Services with JAX-RS
- 29.1 What Are RESTful Web Services?
- 29.2 Creating a RESTful Root Resource Class
- 29.2.1 Developing RESTful Web Services with JAX-RS
- 29.2.2 Overview of a JAX-RS Application
- 29.2.3 The @Path Annotation and URI Path Templates
- 29.2.4 Responding to HTTP Methods and Requests
- 29.2.5 Using @Consumes and @Produces to Customize Requests and Responses
- 29.2.6 Extracting Request Parameters
- 29.2.7 Configuring JAX-RS Applications
- 29.3 Example Applications for JAX-RS
- 29.4 Further Information about JAX-RS
- 30 Accessing REST Resources with the JAX-RS Client API
- 31 JAX-RS: Advanced Topics and an Example
- 31.1 Annotations for Field and Bean Properties of Resource Classes
- 31.2 Validating Resource Data with Bean Validation
- 31.3 Subresources and Runtime Resource Resolution
- 31.4 Integrating JAX-RS with EJB Technology and CDI
- 31.5 Conditional HTTP Requests
- 31.6 Runtime Content Negotiation
- 31.7 Using JAX-RS with JAXB
- 31.8 The customer Example Application
- Part VII Enterprise Beans
- 32 Enterprise Beans
- 32.1 What Is an Enterprise Bean?
- 32.2 What Is a Session Bean?
- 32.3 What Is a Message-Driven Bean?
- 32.4 Accessing Enterprise Beans
- 32.5 The Contents of an Enterprise Bean
- 32.6 Naming Conventions for Enterprise Beans
- 32.7 The Lifecycles of Enterprise Beans
- 32.8 Further Information about Enterprise Beans
- 33 Getting Started with Enterprise Beans
- 34 Running the Enterprise Bean Examples
- 34.1 The cart Example
- 34.2 A Singleton Session Bean Example: counter
- 34.3 A Web Service Example: helloservice
- 34.4 Using the Timer Service
- 34.5 Handling Exceptions
- 35 Using the Embedded Enterprise Bean Container
- 36 Using Asynchronous Method Invocation in Session Beans
- 32 Enterprise Beans
- Part VIII Persistence
- 37 Introduction to the Java Persistence API
- 37.1 Entities
- 37.2 Entity Inheritance
- 37.3 Managing Entities
- 37.3.1 The EntityManager Interface
- 37.3.1.1 Container-Managed Entity Managers
- 37.3.1.2 Application-Managed Entity Managers
- 37.3.1.3 Finding Entities Using the EntityManager
- 37.3.1.4 Managing an Entity Instance's Lifecycle
- 37.3.1.5 Persisting Entity Instances
- 37.3.1.6 Removing Entity Instances
- 37.3.1.7 Synchronizing Entity Data to the Database
- 37.3.2 Persistence Units
- 37.3.1 The EntityManager Interface
- 37.4 Querying Entities
- 37.5 Database Schema Creation
- 37.6 Further Information about Persistence
- 38 Running the Persistence Examples
- 38.1 The order Application
- 38.1.1 Entity Relationships in the order Application
- 38.1.2 Primary Keys in the order Application
- 38.1.3 Entity Mapped to More Than One Database Table
- 38.1.4 Cascade Operations in the order Application
- 38.1.5 BLOB and CLOB Database Types in the order Application
- 38.1.6 Temporal Types in the order Application
- 38.1.7 Managing the order Application's Entities
- 38.1.8 Running the order Example
- 38.2 The roster Application
- 38.3 The address-book Application
- 38.1 The order Application
- 39 The Java Persistence Query Language
- 39.1 Query Language Terminology
- 39.2 Creating Queries Using the Java Persistence Query Language
- 39.3 Simplified Query Language Syntax
- 39.4 Example Queries
- 39.5 Full Query Language Syntax
- 39.5.1 BNF Symbols
- 39.5.2 BNF Grammar of the Java Persistence Query Language
- 39.5.3 FROM Clause
- 39.5.4 Path Expressions
- 39.5.5 WHERE Clause
- 39.5.5.1 Literals
- 39.5.5.2 Input Parameters
- 39.5.5.3 Conditional Expressions
- 39.5.5.4 Operators and Their Precedence
- 39.5.5.5 BETWEEN Expressions
- 39.5.5.6 IN Expressions
- 39.5.5.7 LIKE Expressions
- 39.5.5.8 NULL Comparison Expressions
- 39.5.5.9 Empty Collection Comparison Expressions
- 39.5.5.10 Collection Member Expressions
- 39.5.5.11 Subqueries
- 39.5.5.12 Functional Expressions
- 39.5.5.13 Case Expressions
- 39.5.5.14 NULL Values
- 39.5.5.15 Equality Semantics
- 39.5.6 SELECT Clause
- 39.5.7 ORDER BY Clause
- 39.5.8 GROUP BY and HAVING Clauses
- 40 Using the Criteria API to Create Queries
- 40.1 Overview of the Criteria and Metamodel APIs
- 40.2 Using the Metamodel API to Model Entity Classes
- 40.3 Using the Criteria API and Metamodel API to Create Basic Typesafe Queries
- 41 Creating and Using String-Based Criteria Queries
- 42 Controlling Concurrent Access to Entity Data with Locking
- 43 Creating Fetch Plans with Entity Graphs
- 44 Using a Second-Level Cache with Java Persistence API Applications
- 37 Introduction to the Java Persistence API
- Part IX Messaging
- 45 Java Message Service Concepts
- 45.1 Overview of the JMS API
- 45.2 Basic JMS API Concepts
- 45.3 The JMS API Programming Model
- 45.4 Using Advanced JMS Features
- 45.5 Using the JMS API in Java EE Applications
- 45.5.1 Creating Resources for Java EE Applications
- 45.5.2 Using Resource Injection in Enterprise Bean or Web Components
- 45.5.3 Using Java EE Components to Produce and to Synchronously Receive Messages
- 45.5.4 Using Message-Driven Beans to Receive Messages Asynchronously
- 45.5.5 Managing JTA Transactions
- 45.6 Further Information about JMS
- 46 Java Message Service Examples
- 46.1 Overview of the JMS Examples
- 46.2 Writing Simple JMS Applications
- 46.2.1 Starting the JMS Provider
- 46.2.2 Creating JMS Administered Objects
- 46.2.3 Building All the Simple Examples
- 46.2.4 Sending Messages
- 46.2.5 Receiving Messages Synchronously
- 46.2.6 Using a Message Listener for Asynchronous Message Delivery
- 46.2.7 Browsing Messages on a Queue
- 46.2.8 Running Multiple Consumers on the Same Destination
- 46.2.9 Acknowledging Messages
- 46.3 Writing More Advanced JMS Applications
- 46.4 Writing High Performance and Scalable JMS Applications
- 46.5 Sending and Receiving Messages Using a Simple Web Application
- 46.6 Receiving Messages Asynchronously Using a Message-Driven Bean
- 46.7 Sending Messages from a Session Bean to an MDB
- 46.8 Using an Entity to Join Messages from Two MDBs
- 46.9 Using NetBeans IDE to Create JMS Resources
- 45 Java Message Service Concepts
- Part X Security
- 47 Introduction to Security in the Java EE Platform
- 47.1 Overview of Java EE Security
- 47.2 Security Mechanisms
- 47.3 Securing Containers
- 47.4 Securing GlassFish Server
- 47.5 Working with Realms, Users, Groups, and Roles
- 47.6 Establishing a Secure Connection Using SSL
- 47.7 Further Information about Security
- 48 Getting Started Securing Web Applications
- 48.1 Overview of Web Application Security
- 48.2 Securing Web Applications
- 48.3 Using Programmatic Security with Web Applications
- 48.4 Examples: Securing Web Applications
- 48.4.1 To Set Up Your System for Running the Security Examples
- 48.4.2 The hello2-basicauth Example: Basic Authentication with a Servlet
- 48.4.3 The hello1-formauth Example: Form-Based Authentication with a JavaServer Faces Application
- 48.4.3.1 Creating the Login Form and the Error Page
- 48.4.3.2 Specifying Security for the Form-Based Authentication Example
- 48.4.3.3 To Build, Package, and Deploy the hello1-formauth Example Using NetBeans IDE
- 48.4.3.4 To Build, Package, and Deploy the hello1-formauth Example Using Maven and the asadmin Command
- 48.4.3.5 To Run the hello1-formauth Example
- 49 Getting Started Securing Enterprise Applications
- 49.1 Basic Security Tasks for Enterprise Applications
- 49.2 Securing Enterprise Beans
- 49.3 Examples: Securing Enterprise Beans
- 50 Java EE Security: Advanced Topics
- 50.1 Working with Digital Certificates
- 50.2 Authentication Mechanisms
- 50.3 Using the JDBC Realm for User Authentication
- 50.4 Securing HTTP Resources
- 50.5 Securing Application Clients
- 50.6 Securing Enterprise Information Systems Applications
- 50.7 Configuring Security Using Deployment Descriptors
- 50.8 Further Information about Advanced Security Topics
- 47 Introduction to Security in the Java EE Platform
- Part XI Java EE Supporting Technologies
- 51 Transactions
- 51.1 Transactions in Java EE Applications
- 51.2 What Is a Transaction?
- 51.3 Container-Managed Transactions
- 51.4 Bean-Managed Transactions
- 51.5 Transaction Timeouts
- 51.6 Updating Multiple Databases
- 51.7 Transactions in Web Components
- 51.8 Further Information about Transactions
- 52 Resource Adapters and Contracts
- 53 The Resource Adapter Examples
- 54 Using Java EE Interceptors
- 55 Batch Processing
- 55.1 Introduction to Batch Processing
- 55.2 Batch Processing in Java EE
- 55.3 Simple Use Case
- 55.4 Using the Job Specification Language
- 55.5 Creating Batch Artifacts
- 55.6 Submitting Jobs to the Batch Runtime
- 55.7 Packaging Batch Applications
- 55.8 The webserverlog Example Application
- 55.9 The phonebilling Example Application
- 55.10 Further Information about Batch Processing
- 56 Concurrency Utilities for Java EE
- 56.1 Concurrency Basics
- 56.2 Main Components of the Concurrency Utilities
- 56.3 Concurrency and Transactions
- 56.4 Concurrency and Security
- 56.5 The jobs Concurrency Example
- 56.5.1 Running the jobs Example
- 56.5.1.1 To Configure GlassFish Server for the Basic Concurrency Example
- 56.5.1.2 To Build, Package, and Deploy the jobs Example Using NetBeans IDE
- 56.5.1.3 To Build, Package, and Deploy the jobs Example Using Maven
- 56.5.1.4 To Run the jobs Example and Submit Jobs with Low Priority
- 56.5.1.5 To Run the jobs Example and Submit Jobs with High Priority
- 56.5.1 Running the jobs Example
- 56.6 The taskcreator Concurrency Example
- 56.7 Further Information about the Concurrency Utilities
- 51 Transactions
- Part XII Case Studies
- 57 Duke's Bookstore Case Study Example
- 57.1 Design and Architecture of Duke's Bookstore
- 57.2 The Duke's Bookstore Interface
- 57.2.1 The Book Java Persistence API Entity
- 57.2.2 Enterprise Beans Used in Duke's Bookstore
- 57.2.3 Facelets Pages and Managed Beans Used in Duke's Bookstore
- 57.2.4 Custom Components and Other Custom Objects Used in Duke's Bookstore
- 57.2.5 Properties Files Used in Duke's Bookstore
- 57.2.6 Deployment Descriptors Used in Duke's Bookstore
- 57.3 Running the Duke's Bookstore Case Study Application
- 58 Duke's Tutoring Case Study Example
- 58.1 Design and Architecture of Duke's Tutoring
- 58.2 Main Interface
- 58.2.1 Java Persistence API Entities Used in the Main Interface
- 58.2.2 Enterprise Beans Used in the Main Interface
- 58.2.3 WebSocket Endpoint Used in the Main Interface
- 58.2.4 Facelets Files Used in the Main Interface
- 58.2.5 Helper Classes Used in the Main Interface
- 58.2.6 Properties Files
- 58.2.7 Deployment Descriptors Used in Duke's Tutoring
- 58.3 Administration Interface
- 58.4 Running the Duke's Tutoring Case Study Application
- 59 Duke's Forest Case Study Example
- 59.1 Design and Architecture of Duke's Forest
- 59.1.1 The events Project
- 59.1.2 The entities Project
- 59.1.3 The dukes-payment Project
- 59.1.4 The dukes-resources Project
- 59.1.5 The Duke's Store Project
- 59.1.5.1 Enterprise Beans Used in Duke's Store
- 59.1.5.2 Facelets Files Used in the Main Interface of Duke's Store
- 59.1.5.3 Facelets Files Used in the Administration Interface of Duke's Store
- 59.1.5.4 Managed Beans Used in Duke's Store
- 59.1.5.5 Helper Classes Used in Duke's Store
- 59.1.5.6 Qualifiers Used in Duke's Store
- 59.1.5.7 Event Handlers Used in Duke's Store
- 59.1.5.8 Deployment Descriptors Used in Duke's Store
- 59.1.6 The Duke's Shipment Project
- 59.2 Building and Deploying the Duke's Forest Case Study Application
- 59.3 Running the Duke's Forest Application
- 59.1 Design and Architecture of Duke's Forest
- 57 Duke's Bookstore Case Study Example