Home Page Icon
Home Page
Table of Contents for
Cover Page
Close
Cover Page
by William Markito, Kim Haase, Ian Evans, Ricardo Cervera-Navarro, Eric Jendrock
The Java EE 7 Tutorial, Volume 2, Fifth Edition
About This eBook
Title Page
Copyright Page
Contents
Preface
Audience
Before You Read This Book
Related Documentation
The Oracle Accessibility Program
Conventions
Default Paths and File Names
Acknowledgments
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 Development Roles
1.8 Java EE 7 APIs
1.9 Java EE 7 APIs in the Java Platform, Standard Edition 7
1.10 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
Part II: Enterprise Beans
3. Enterprise Beans
3.1 What Is an Enterprise Bean?
3.2 What Is a Session Bean?
3.3 What Is a Message-Driven Bean?
3.4 Accessing Enterprise Beans
3.5 The Contents of an Enterprise Bean
3.6 Naming Conventions for Enterprise Beans
3.7 The Lifecycles of Enterprise Beans
3.8 Further Information about Enterprise Beans
4. Getting Started with Enterprise Beans
4.1 Creating the Enterprise Bean
4.2 Modifying the Java EE Application
5. Running the Enterprise Bean Examples
5.1 The cart Example
5.2 A Singleton Session Bean Example: counter
5.3 A Web Service Example: helloservice
5.4 Using the Timer Service
5.5 Handling Exceptions
6. Using the Embedded Enterprise Bean Container
6.1 Overview of the Embedded Enterprise Bean Container
6.2 Developing Embeddable Enterprise Bean Applications
6.3 The standalone Example Application
7. Using Asynchronous Method Invocation in Session Beans
7.1 Asynchronous Method Invocation
7.2 The async Example Application
Part III: Persistence
8. Introduction to the Java Persistence API
8.1 Entities
8.2 Entity Inheritance
8.3 Managing Entities
8.4 Querying Entities
8.5 Database Schema Creation
8.6 Further Information about Persistence
9. Running the Persistence Examples
9.1 The order Application
9.2 The roster Application
9.3 The address-book Application
10. The Java Persistence Query Language
10.1 Query Language Terminology
10.2 Creating Queries Using the Java Persistence Query Language
10.3 Simplified Query Language Syntax
10.4 Example Queries
10.5 Full Query Language Syntax
11. Using the Criteria API to Create Queries
11.1 Overview of the Criteria and Metamodel APIs
11.2 Using the Metamodel API to Model Entity Classes
11.3 Using the Criteria API and Metamodel API to Create Basic Typesafe Queries
12. Creating and Using String-Based Criteria Queries
12.1 Overview of String-Based Criteria API Queries
12.2 Creating String-Based Queries
12.3 Executing String-Based Queries
13. Controlling Concurrent Access to Entity Data with Locking
13.1 Overview of Entity Locking and Concurrency
13.2 Lock Modes
14. Creating Fetch Plans with Entity Graphs
14.1 Entity Graph Basics
14.2 Using Named Entity Graphs
14.3 Using Entity Graphs in Query Operations
15. Using a Second-Level Cache with Java Persistence API Applications
15.1 Overview of the Second-Level Cache
15.2 Specifying the Cache Mode Settings to Improve Performance
Part IV: Messaging
16. Java Message Service Concepts
16.1 Overview of the JMS API
16.2 Basic JMS API Concepts
16.3 The JMS API Programming Model
16.4 Using Advanced JMS Features
16.5 Using the JMS API in Java EE Applications
16.6 Further Information about JMS
17. Java Message Service Examples
17.1 Overview of the JMS Examples
17.2 Writing Simple JMS Applications
17.3 Writing More Advanced JMS Applications
17.4 Writing High Performance and Scalable JMS Applications
17.5 Sending and Receiving Messages Using a Simple Web Application
17.6 Receiving Messages Asynchronously Using a Message-Driven Bean
17.7 Sending Messages from a Session Bean to an MDB
17.8 Using an Entity to Join Messages from Two MDBs
17.9 Using NetBeans IDE to Create JMS Resources
Part V: Security
18. Introduction to Security in the Java EE Platform
18.1 Overview of Java EE Security
18.2 Security Mechanisms
18.3 Securing Containers
18.4 Securing GlassFish Server
18.5 Working with Realms, Users, Groups, and Roles
18.6 Establishing a Secure Connection Using SSL
18.7 Further Information about Security
19. Getting Started Securing Web Applications
19.1 Overview of Web Application Security
19.2 Securing Web Applications
19.3 Using Programmatic Security with Web Applications
19.4 Examples: Securing Web Applications
20. Getting Started Securing Enterprise Applications
20.1 Basic Security Tasks for Enterprise Applications
20.2 Securing Enterprise Beans
20.3 Examples: Securing Enterprise Beans
21. Java EE Security: Advanced Topics
21.1 Working with Digital Certificates
21.2 Authentication Mechanisms
21.3 Using the JDBC Realm for User Authentication
21.4 Securing HTTP Resources
21.5 Securing Application Clients
21.6 Securing Enterprise Information Systems Applications
21.7 Configuring Security Using Deployment Descriptors
21.8 Further Information about Advanced Security Topics
Part VI: Java EE Supporting Technologies
22. Transactions
22.1 Transactions in Java EE Applications
22.2 What Is a Transaction?
22.3 Container-Managed Transactions
22.4 Bean-Managed Transactions
22.5 Transaction Timeouts
22.6 Updating Multiple Databases
22.7 Transactions in Web Components
22.8 Further Information about Transactions
23. Resource Adapters and Contracts
23.1 What Is a Resource Adapter?
23.2 Metadata Annotations
23.3 Common Client Interface
23.4 Using Resource Adapters with Contexts and Dependency Injection for Java EE (CDI)
23.5 Further Information about Resource Adapters
24. The Resource Adapter Examples
24.1 The trading Example
24.2 The traffic Example
25. Using Java EE Interceptors
25.1 Overview of Interceptors
25.2 Using Interceptors
25.3 The interceptor Example Application
26. Batch Processing
26.1 Introduction to Batch Processing
26.2 Batch Processing in Java EE
26.3 Simple Use Case
26.4 Using the Job Specification Language
26.5 Creating Batch Artifacts
26.6 Submitting Jobs to the Batch Runtime
26.7 Packaging Batch Applications
26.8 The webserverlog Example Application
26.9 The phonebilling Example Application
26.10 Further Information about Batch Processing
27. Concurrency Utilities for Java EE
27.1 Concurrency Basics
27.2 Main Components of the Concurrency Utilities
27.3 Concurrency and Transactions
27.4 Concurrency and Security
27.5 The jobs Concurrency Example
27.6 The taskcreator Concurrency Example
27.7 Further Information about the Concurrency Utilities
Part VII: Case Studies
28. Duke’s Bookstore Case Study Example
28.1 Design and Architecture of Duke’s Bookstore
28.2 The Duke’s Bookstore Interface
28.3 Running the Duke’s Bookstore Case Study Application
29. Duke’s Tutoring Case Study Example
29.1 Design and Architecture of Duke’s Tutoring
29.2 Main Interface
29.3 Administration Interface
29.4 Running the Duke’s Tutoring Case Study Application
30. Duke’s Forest Case Study Example
30.1 Design and Architecture of Duke’s Forest
30.2 Building and Deploying the Duke’s Forest Case Study Application
30.3 Running the Duke’s Forest Application
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
About This eBook
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset