Carview!

Exporters From Japan

HOME
ABOUT
- RESULTS
- differences
- BENEFITS
- HISTORY
- TEAM
- LOCATION
- FACILITIES
- BANKING
- MEMBERSHIPS
- APPROVALS
- LICENCES
- SUPPLIERS
- SPONSORSHIPS
- MEDIA
- PRIVACY
AUCTIONS
SHIPPING
FEES
- TS REWARDS
TOOLS
guides
FAQ
CONTACT
- CONNECT

VEHICLES
BRAND
- JAPANESE CARS
  - DAIHATSU
  - EUNOS
  - FORD
  - HONDA
  - ISUZU
  - LEXUS
  - MAZDA
  - MITSUBISHI
  - MITSUOKA
  - NISSAN
  - SUBARU
  - SUZUKI
  - TOYOTA
- GERMAN CARS
- AMERICAN CARS
- BRITISH CARS
- ITALIAN CARS
- FRENCH CARS
- SWEDISH CARS
- KOREAN CARS
TYPE
- mobility
- VENDING
- instruction
- TAXIS
- AMBULANCES
- FIRE ENGINES
- HEARSES
- LIMOUSINES
- COMMERCIAL
CLASS
FUEL
TRUCKS
minitrucks
- DAIHATSU
- HONDA
- MAZDA
- MITSUBISHI
- NISSAN
- SUBARU
- SUZUKI
- DUMP
- CRANE
- CAMPER
- REFRIGERATED
- 4WD
- NEW
BUSES
MOTORHOMES
- YAHOO!
- RAKUTEN
- DEALER

PARTS
- FREE REPORT
- PARTS CONTAINERS
- PARTS SYSTEMS
- PARTS PROTECTION
- BODY SHELLS
- DISMANTLING
- ONLINE PARTS
- NEW PARTS
- INTERIOR PARTS
- EXTERIOR PARTS
  - BONNETS
  - BUMPERS
  - GRILLES
  - FENDERS
  - DOORS
  - TRUNKS
  - SPOILERS
  - LIGHTS
  - EMBLEMS
  - CAMERAS
- ENGINES
- TRANSMISSIONS
- WHEELS & TYRES
  - WHEELS
  - TYRES
CUTS
PERFORMANCE PARTS
TRUCK PARTS
MOTORBIKE PARTS
- MOTORBIKE ENGINES
- MOTORBIKE ACCESSORIES

MOTORBIKES
MARINE
FORKLIFTS
MACHINERY
AGRICULTURAL
OTHER
COUNTRY
- AUSTRALIA
- CANADA
- KENYA
- MYANMAR
- NEW ZEALAND
- PAKISTAN
- TANZANIA
- UNITED STATES

CARVIEW

MOTORHOMES

Select Language

HTTP/2 200 server: GitHub.com content-type: text/html; charset=utf-8 last-modified: Mon, 28 Jan 2019 14:30:42 GMT access-control-allow-origin: * strict-transport-security: max-age=31556952 etag: W/"5c4f1212-2d59d" expires: Wed, 23 Jul 2025 18:28:19 GMT cache-control: max-age=600 content-encoding: gzip x-proxy-cache: MISS x-github-request-id: 919F:120B4F:F2200:11837A:68812769 accept-ranges: bytes age: 0 date: Wed, 23 Jul 2025 18:18:19 GMT via: 1.1 varnish x-served-by: cache-bom-vanm7210062-BOM x-cache: MISS x-cache-hits: 0 x-timer: S1753294699.924970,VS0,VE223 vary: Accept-Encoding x-fastly-request-id: 7680aa482fd85573a8902c8730db69b41f606baf content-length: 30105 Java Platform, Enterprise Edition The Java EE Tutorial Java Platform, Enterprise Edition, Release 8

Java Platform, Enterprise Edition (Java EE) 8
The Java EE Tutorial

Contents

Title and Copyright Information

Preface

Audience
Documentation Accessibility
Before You Read This Book
Related Documentation
Conventions
Default Paths and File Names

Part I Introduction

1 Overview

Introduction to Java EE
Java EE 8 Platform Highlights
Java EE Application Model
Distributed Multitiered Applications
Java EE Containers
- Container Services
- Container Types
Web Services Support
Java EE Application Assembly and Deployment
Java EE 8 APIs
Java EE 8 APIs in the Java Platform, Standard Edition 8
GlassFish Server Tools

2 Using the Tutorial Examples

Required Software
Starting and Stopping GlassFish Server
Starting the Administration Console
- To Start the Administration Console Using NetBeans IDE
Starting and Stopping Apache Derby
- To Start the Database Server Using NetBeans IDE
Building the Examples
Tutorial Example Directory Structure
Java EE Maven Archetypes in the Tutorial
- Installing the Tutorial Archetypes
  - Installing the Tutorial Archetypes Using NetBeans IDE
  - Installing the Tutorial Archetypes Using Maven
Debugging Java EE Applications
- Using the Server Log
  - To Use the Administration Console Log Viewer
- Using a Debugger
  - To Debug an Application Using a Debugger

Part II Platform Basics

3 Resource Creation

Resources and JNDI Naming
DataSource Objects and Connection Pools
Creating Resources Administratively

4 Injection

Resource Injection
Dependency Injection
The Main Differences between Resource Injection and Dependency Injection

5 Packaging

Packaging Applications
Packaging Enterprise Beans
- Packaging Enterprise Beans in EJB JAR Modules
- Packaging Enterprise Beans in WAR Modules
Packaging Web Archives
Packaging Resource Adapter Archives

Part III The Web Tier

6 Getting Started with Web Applications

Web Applications
Web Application Lifecycle
A Web Module That Uses JavaServer Faces Technology: The hello1 Example
A Web Module That Uses Java Servlet Technology: The hello2 Example
Configuring Web Applications
Further Information about Web Applications

7 JavaServer Faces Technology

Introduction to JavaServer Faces Technology
What Is a JavaServer Faces Application?
JavaServer Faces Technology Benefits
A Simple JavaServer Faces Application
User Interface Component Model
Navigation Model
The Lifecycle of a JavaServer Faces Application
Partial Processing and Partial Rendering
Further Information about JavaServer Faces Technology

8 Introduction to Facelets

What Is Facelets?
The Lifecycle of a Facelets Application
Developing a Simple Facelets Application: The guessnumber-jsf Example Application
Using Facelets Templates
Composite Components
Web Resources
Relocatable Resources
Resource Library Contracts
- The hello1-rlc Example Application
HTML5-Friendly Markup

9 Expression Language

Overview of the EL
Immediate and Deferred Evaluation Syntax
- Immediate Evaluation
- Deferred Evaluation
Value and Method Expressions
Operations on Collection Objects
Operators
Reserved Words
Examples of EL Expressions
Further Information about the Expression Language

10 Using JavaServer Faces Technology in Web Pages

Setting Up a Page
Adding Components to a Page Using HTML Tag Library Tags
Using Core Tags

11 Using Converters, Listeners, and Validators

Using the Standard Converters
Registering Listeners on Components
- Registering a Value-Change Listener on a Component
- Registering an Action Listener on a Component
Using the Standard Validators
- Validating a Component’s Value
- Using Validator Tags
Referencing a Managed Bean Method

12 Developing with JavaServer Faces Technology

Managed Beans in JavaServer Faces Technology
- Creating a Managed Bean
- Using the EL to Reference Managed Beans
Writing Bean Properties
Writing Managed Bean Methods

13 Using Ajax with JavaServer Faces Technology

Overview of Ajax
Using Ajax Functionality with JavaServer Faces Technology
Using Ajax with Facelets
- Using the f:ajax Tag
Sending an Ajax Request
Monitoring Events on the Client
Handling Errors
Receiving an Ajax Response
Ajax Request Lifecycle
Grouping of Components
Loading JavaScript as a Resource
- Using JavaScript API in a Facelets Application
- Using the @ResourceDependency Annotation in a Bean Class
The ajaxguessnumber Example Application
- The ajaxguessnumber Source Files
- Running the ajaxguessnumber Example
Further Information about Ajax in JavaServer Faces Technology

14 Composite Components: Advanced Topics and an Example

Attributes of a Composite Component
Invoking a Managed Bean
Validating Composite Component Values
The compositecomponentexample Example Application

15 Creating Custom UI Components and Other Custom Objects

Introduction to Creating Custom 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
- Creating the Renderer Class
- Identifying the Renderer Type
Implementing an Event Listener
- Implementing Value-Change Listeners
- Implementing Action Listeners
Handling Events for Custom Components
Defining the Custom Component Tag in a Tag Library Descriptor
Using a Custom Component
Creating and Using a Custom Converter
- Creating a Custom Converter
- Using a Custom Converter
Creating and Using a Custom Validator
Binding Component Values and Instances to Managed Bean Properties
Binding Converters, Listeners, and Validators to Managed Bean Properties

16 Configuring JavaServer Faces Applications

Introduction to Configuring JavaServer Faces Applications
Using Annotations to Configure Managed Beans
- Using Managed Bean Scopes
Application Configuration Resource File
- Configuring Eager Application-Scoped Managed Beans
- Ordering of Application Configuration Resource Files
Using Faces Flows
Configuring Managed Beans
Registering Application Messages
- Using FacesMessage to Create a Message
- Referencing Error Messages
Using Default Validators
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

17 Using WebSockets with JavaServer Faces Technology

About WebSockets in JSF
Configuring WebSockets
- WebSocket Usage: Client Side
- WebSocket Usage: Server Side
Using the f:websocket Tag
WebSocket Scopes and Users
Conditionally Connecting WebSockets
- WebSocket Events: Server
- WebSocket Events: Clients
WebSocket Security Considerations
Using Ajax With WebSockets

18 Java Servlet Technology

What Is a Servlet?
Servlet Lifecycle
- Handling Servlet Lifecycle Events
  - Defining the Listener Class
- Handling Servlet Errors
Sharing Information
- Using Scope Objects
- Controlling Concurrent Access to Shared Resources
Creating and Initializing a Servlet
Writing Service Methods
- Getting Information from Requests
- Constructing Responses
Filtering Requests and Responses
Invoking Other Web Resources
- Including Other Resources in the Response
- Transferring Control to Another Web Component
Accessing the Web Context
Maintaining Client State
Finalizing a Servlet
Uploading Files with Java Servlet Technology
- The @MultipartConfig Annotation
- The getParts and getPart Methods
Asynchronous Processing
- Asynchronous Processing in Servlets
- Waiting for a Resource
Nonblocking I/O
- Reading a Large HTTP POST Request Using Nonblocking I/O
Protocol Upgrade Processing
Server Push
HTTP Trailer
The mood Example Application
- Components of the mood Example Application
- Running the mood Example
  - To Run the mood Example Using NetBeans IDE
  - To Run the mood Example Using Maven
The fileupload Example Application
- Architecture of the fileupload Example Application
- Running the fileupload Example
The dukeetf Example Application
- Architecture of the dukeetf Example Application
- Running the dukeetf Example Application
  - To Run the dukeetf Example Application Using NetBeans IDE
  - To Run the dukeetf Example Application Using Maven
Further Information about Java Servlet Technology

19 Java API for WebSocket

Introduction to WebSocket
Creating WebSocket Applications in the Java EE Platform
- Creating and Deploying a WebSocket Endpoint
Programmatic Endpoints
Annotated Endpoints
Sending and Receiving Messages
- Sending Messages
  - Sending Messages to All Peers Connected to an Endpoint
- Receiving Messages
Maintaining Client State
Using Encoders and Decoders
- Implementing Encoders to Convert Java Objects into WebSocket Messages
- Implementing Decoders to Convert WebSocket Messages into Java Objects
Path Parameters
Handling Errors
Specifying an Endpoint Configurator Class
The dukeetf2 Example Application
- Architecture of the dukeetf2 Sample Application
- Running the dukeetf2 Example Application
  - To Run the dukeetf2 Example Application Using NetBeans IDE
  - To Run the dukeetf2 Example Application Using Maven
The websocketbot Example Application
- Architecture of the websocketbot Example Application
- Running the websocketbot Example Application
Further Information about WebSocket

20 JSON Processing

Introduction to JSON
JSON Processing in the Java EE Platform
Using the Object Model API
Using the Streaming API
- Reading JSON Data Using a Parser
- Writing JSON Data Using a Generator
JSON in Java EE RESTful Web Services
The jsonpmodel Example Application
- Components of the jsonpmodel Example Application
- Running the jsonpmodel Example Application
  - To Run the jsonpmodel Example Application Using NetBeans IDE
  - To Run the jsonpmodel Example Application Using Maven
The jsonpstreaming Example Application
- Components of the jsonpstreaming Example Application
- Running the jsonpstreaming Example Application
  - To Run the jsonpstreaming Example Application Using NetBeans IDE
  - To Run the jsonpstreaming Example Application Using Maven
Further Information about the Java API for JSON Processing

21 JSON Binding

JSON Binding in the Java EE Platform
Overview of the JSON Binding API
Running the jsonbbasics Example Application
- Components of the jsonbbasics Example Application
- Running the jsonbbasics Example Application
Further Information about the Java API for JSON Binding

22 Internationalizing and Localizing Web Applications

Java Platform Localization Classes
Providing Localized Messages and Labels
Date and Number Formatting
Character Sets and Encodings
- Character Sets
- Character Encoding

Part IV Bean Validation

23 Introduction to Bean Validation

Overview of Bean Validation
Using Bean Validation Constraints
Validating Null and Empty Strings
Validating Constructors and Methods
Further Information about Bean Validation

24 Bean Validation: Advanced Topics

Creating Custom Constraints
- Using the Built-In Constraints to Make a New Constraint
- Removing Ambiguity in Constraint Targets
Customizing Validator Messages
- The ValidationMessages Resource Bundle
  - Localizing Validation Messages
Grouping Constraints
- Customizing Group Validation Order
Using Method Constraints in Type Hierarchies
- Rules for Using Method Constraints in Type Hierarchies

Part V Contexts and Dependency Injection for Java EE

25 Introduction to Contexts and Dependency Injection for Java EE

Getting Started
Overview of CDI
About Beans
About CDI Managed Beans
Beans as Injectable Objects
Using Qualifiers
Injecting Beans
Using Scopes
Giving Beans EL Names
Adding Setter and Getter Methods
Using a Managed Bean in a Facelets Page
Injecting Objects by Using Producer Methods
Configuring a CDI Application
Using the @PostConstruct and @PreDestroy Annotations with CDI Managed Bean Classes
- To Initialize a Managed Bean Using the @PostConstruct Annotation
- To Prepare for the Destruction of a Managed Bean Using the @PreDestroy Annotation
Further Information about CDI

26 Running the Basic Contexts and Dependency Injection Examples

Building and Running the CDI Samples
The simplegreeting CDI Example
The guessnumber-cdi CDI Example

27 Contexts and Dependency Injection for Java EE: Advanced Topics

Packaging CDI Applications
Using Alternatives in CDI Applications
- Using Specialization
Using Producer Methods, Producer Fields, and Disposer Methods in CDI Applications
Using Predefined Beans in CDI Applications
Using Events in CDI Applications
Using Interceptors in CDI Applications
Using Decorators in CDI Applications
Using Stereotypes in CDI Applications
Using the Built-In Annotation Literals
Using the Configurators Interfaces

28 Bootstrapping a CDI Container in Java SE

The Bootstrap API
Configuring the CDI Container

29 Running the Advanced Contexts and Dependency Injection Examples

Building and Running the CDI Advanced Examples
The encoder Example: Using Alternatives
The producermethods Example: Using a Producer Method to Choose a Bean Implementation
- Components of the producermethods Example
- Running the producermethods Example
The producerfields Example: Using Producer Fields to Generate Resources
The billpayment Example: Using Events and Interceptors
The decorators Example: Decorating a Bean

Part VI Web Services

30 Introduction to Web Services

What Are Web Services?
Types of Web Services
- "Big" Web Services
- RESTful Web Services
Deciding Which Type of Web Service to Use

31 Building Web Services with JAX-WS

Overview of Java API for XML Web Services
Creating a Simple Web Service and Clients with JAX-WS
Types Supported by JAX-WS
- Schema-to-Java Mapping
- Java-to-Schema Mapping
Web Services Interoperability and JAX-WS
Further Information about JAX-WS

32 Building RESTful Web Services with JAX-RS

What Are RESTful Web Services?
Creating a RESTful Root Resource Class
Example Applications for JAX-RS
Further Information about JAX-RS

33 Accessing REST Resources with the JAX-RS Client API

Overview of the Client API
Using the Client API in the JAX-RS Example Applications
- The Client API in the rsvp Example Application
- The Client API in the customer Example Application
Advanced Features of the Client API

34 JAX-RS: Advanced Topics and an Example

Annotations for Field and Bean Properties of Resource Classes
Validating Resource Data with Bean Validation
Subresources and Runtime Resource Resolution
- Subresource Methods
- Subresource Locators
Integrating JAX-RS with EJB Technology and CDI
Conditional HTTP Requests
Runtime Content Negotiation
Using JAX-RS with JAXB
The customer Example Application

Part VII Enterprise Beans

35 Enterprise Beans

What Is an Enterprise Bean?
What Is a Session Bean?
- Types of Session Beans
- When to Use Session Beans
What Is a Message-Driven Bean?
- What Makes Message-Driven Beans Different from Session Beans?
- When to Use Message-Driven Beans
Accessing Enterprise Beans
The Contents of an Enterprise Bean
Naming Conventions for Enterprise Beans
The Lifecycles of Enterprise Beans
Further Information about Enterprise Beans

36 Getting Started with Enterprise Beans

Starting With Enterprise Beans
Creating the Enterprise Bean
Modifying the Java EE Application
- To Modify a Class File

37 Running the Enterprise Bean Examples

Overview of the EJB Examples
The cart Example
A Singleton Session Bean Example: counter
A Web Service Example: helloservice
Using the Timer Service
Handling Exceptions

38 Using the Embedded Enterprise Bean Container

Overview of the Embedded Enterprise Bean Container
Developing Embeddable Enterprise Bean Applications
The standalone Example Application

39 Using Asynchronous Method Invocation in Session Beans

Asynchronous Method Invocation
- Creating an Asynchronous Business Method
- Calling Asynchronous Methods from Enterprise Bean Clients
The async Example Application
- Architecture of the async-war Module
- Running the async Example
  - To Run the async Example Application Using NetBeans IDE
  - To Run the async Example Application Using Maven

Part VIII Persistence

40 Introduction to the Java Persistence API

Overview of the Java Persistence API
Entities
Entity Inheritance
Managing Entities
- The EntityManager Interface
- Persistence Units
Querying Entities
Database Schema Creation
- Configuring an Application to Create or Drop Database Tables
- Loading Data Using SQL Scripts
Further Information about Persistence

41 Running the Persistence Examples

Overview of the Persistence Examples
The order Application
The roster Application
The address-book Application

42 The Java Persistence Query Language

Overview of the Java Persistence Query Language
Query Language Terminology
Creating Queries Using the Java Persistence Query Language
- Named Parameters in Queries
- Positional Parameters in Queries
Simplified Query Language Syntax
- Select Statements
- Update and Delete Statements
Example Queries
Full Query Language Syntax

43 Using the Criteria API to Create Queries

Overview of the Criteria and Metamodel APIs
Using the Metamodel API to Model Entity Classes
- Using Metamodel Classes
Using the Criteria API and Metamodel API to Create Basic Typesafe Queries

44 Creating and Using String-Based Criteria Queries

Overview of String-Based Criteria API Queries
Creating String-Based Queries
Executing String-Based Queries

45 Controlling Concurrent Access to Entity Data with Locking

Overview of Entity Locking and Concurrency
- Using Optimistic Locking
Lock Modes
- Setting the Lock Mode
- Using Pessimistic Locking
  - Pessimistic Locking Timeouts

46 Creating Fetch Plans with Entity Graphs

Overview of Using Fetch Plans and Entity Graphs
Entity Graph Basics
- The Default Entity Graph
- Using Entity Graphs in Persistence Operations
  - Fetch Graphs
  - Load Graphs
Using Named Entity Graphs
- Applying Named Entity Graph Annotations to Entity Classes
- Obtaining EntityGraph Instances from Named Entity Graphs
Using Entity Graphs in Query Operations

47 Using a Second-Level Cache with Java Persistence API Applications

Overview of the Second-Level Cache
- Controlling whether Entities May Be Cached
Specifying the Cache Mode Settings to Improve Performance
- Setting the Cache Retrieval and Store Modes
- Controlling the Second-Level Cache Programmatically

Part IX Messaging

48 Java Message Service Concepts

Overview of the JMS API
Basic JMS API Concepts
The JMS API Programming Model
Using Advanced JMS Features
Using the JMS API in Java EE Applications
Further Information about JMS

49 Java Message Service Examples

Building and Running Java Message Service Examples
Overview of the JMS Examples
Writing Simple JMS Applications
Writing More Advanced JMS Applications
- Using Durable Subscriptions
- Using Local Transactions
  - To Create Resources for the transactedexample Example
  - To Run the transactedexample Clients
Writing High Performance and Scalable JMS Applications
- Using Shared Nondurable Subscriptions
  - Writing the Clients for the Shared Consumer Example
  - To Run the SharedConsumer and Producer Clients
- Using Shared Durable Subscriptions
  - To Run the SharedDurableConsumer and Producer Clients
Sending and Receiving Messages Using a Simple Web Application
Receiving Messages Asynchronously Using a Message-Driven Bean
Sending Messages from a Session Bean to an MDB
- Writing the Application Components for the clientsessionmdb Example
- Running the clientsessionmdb Example
  - To Run clientsessionmdb Using NetBeans IDE
  - To Run clientsessionmdb Using Maven
Using an Entity to Join Messages from Two MDBs
Using NetBeans IDE to Create JMS Resources
- To Create JMS Resources Using NetBeans IDE
- To Delete JMS Resources Using NetBeans IDE

Part X Security

50 Introduction to Security in the Java EE Platform

Overview of Java EE Security
Security Mechanisms
- Java SE Security Mechanisms
- Java EE Security Mechanisms
Securing Containers
Using Pluggable Providers
- JSR-196 Java Authentication Service Provider Interface for Containers (JASPIC)
- JSR-375 Java EE Security API
Securing GlassFish Server
Working with Realms, Users, Groups, and Roles
Working with Identity Stores
Establishing a Secure Connection Using SSL
- Verifying and Configuring SSL Support
Further Information about Security

51 Getting Started Securing Web Applications

Overview of Web Application Security
Securing Web Applications
Using Programmatic Security with Web Applications
Examples: Securing Web Applications

52 Getting Started Securing Enterprise Applications

Basic Security Tasks for Enterprise Applications
Securing Enterprise Beans
Examples: Securing Enterprise Beans
- The cart-secure Example: Securing an Enterprise Bean with Declarative Security
- The converter-secure Example: Securing an Enterprise Bean with Programmatic Security

53 Using the Java EE Security API

About the Java EE Security API
Overview of the HTTP Authentication Mechanism Interface
Overview of the Identity Store Interfaces
Running the Built-In Database Identity Store Example
- Overview of the Built-In Database Identity Store Example
- Running the built-in-db-identity-store Example
Running the Custom Identity Store Example
- Overview of the Custom Identity Store Example
- Running the custom-identity-store Example

54 Java EE Security: Advanced Topics

Working with Digital Certificates
Authentication Mechanisms
- Client Authentication
- Mutual Authentication
  - Enabling Mutual Authentication over SSL
  - Creating a Client Certificate for Mutual Authentication
Using the JDBC Realm for User Authentication
- To Configure a JDBC Authentication Realm
Securing HTTP Resources
Securing Application Clients
- Using Login Modules
- Using Programmatic Login
Securing Enterprise Information Systems Applications
Configuring Security Using Deployment Descriptors
- Specifying Security for Basic Authentication in the Deployment Descriptor
- Specifying Non-Default Principal-to-Role Mapping in the Deployment Descriptor
Further Information about Advanced Security Topics

Part XI Java EE Supporting Technologies

55 Transactions

Overview of Transactions
Transactions in Java EE Applications
What Is a Transaction?
Container-Managed Transactions
Bean-Managed Transactions
Transaction Timeouts
- To Set a Transaction Timeout
Updating Multiple Databases
Transactions in Web Components
Further Information about Transactions

56 Resource Adapters and Contracts

What Is a Resource Adapter?
Metadata Annotations
Common Client Interface
Using Resource Adapters with Contexts and Dependency Injection for Java EE (CDI)
Further Information about Resource Adapters

57 The Resource Adapter Examples

Overview of the Resource Adapter Examples
The trading Example
The traffic Example

58 Using Java EE Interceptors

Overview of Interceptors
Using Interceptors
The interceptor Example Application
- Running the interceptor Example
  - To Run the interceptor Example Using NetBeans IDE
  - To Run the interceptor Example Using Maven

59 Batch Processing

Introduction to Batch Processing
Batch Processing in Java EE
Simple Use Case
- Chunk Step
- Task Step
Using the Job Specification Language
Creating Batch Artifacts
Submitting Jobs to the Batch Runtime
Packaging Batch Applications
The webserverlog Example Application
- Architecture of the webserverlog Example Application
- Running the webserverlog Example Application
  - To Run the webserverlog Example Application Using NetBeans IDE
  - To Run the webserverlog Example Application Using Maven
The phonebilling Example Application
- Architecture of the phonebilling Example Application
- Running the phonebilling Example Application
  - To Run the phonebilling Example Application Using NetBeans IDE
  - To Run the phonebilling Example Application Using Maven
Further Information about Batch Processing

60 Concurrency Utilities for Java EE

Concurrency Basics
- Threads and Processes
Main Components of the Concurrency Utilities
Concurrency and Transactions
Concurrency and Security
The jobs Concurrency Example
- Running the jobs Example
The taskcreator Concurrency Example
- Running the taskcreator Example
Further Information about the Concurrency Utilities

Part XII Case Studies

61 Duke’s Bookstore Case Study Example

Design and Architecture of Duke’s Bookstore
The Duke’s Bookstore Interface
Running the Duke’s Bookstore Case Study Application

62 Duke’s Tutoring Case Study Example

Design and Architecture of Duke’s Tutoring
Main Interface
Administration Interface
Running the Duke’s Tutoring Case Study Application
- Running Duke’s Tutoring

63 Duke’s Forest Case Study Example

Overview of the Duke’s Forest Case Study Example
Design and Architecture of Duke’s Forest
Building and Deploying the Duke’s Forest Case Study Application
- To Build and Deploy the Duke’s Forest Application Using NetBeans IDE
- To Build and Deploy the Duke’s Forest Application Using Maven
Running the Duke’s Forest Application

Copyright © 2017, Oracle and/or its affiliates. All rights reserved.

HOME
ABOUT
AUCTIONS
SHIPPING
FEES
TOOLS
HOW
FAQ
CONTACT

Original Source | Taken Source