47 Introduction to Security in the Java EE Platform
This chapter introduces basic security concepts and security mechanisms. More information on these concepts and mechanisms can be found in the chapter on security in the Java EE 7 specification.
Other chapters in this Part discuss security requirements in web tier and enterprise tier applications.
-
Chapter 48, "Getting Started Securing Web Applications" explains how to add security to web components, such as servlets.
-
Chapter 49, "Getting Started Securing Enterprise Applications" explains how to add security to Java EE components, such as enterprise beans and application clients.
The following topics are addressed here:
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