HARTMANN software group

Fast Track to EJB 3.0 and the JPA Using JBoss Training in Riverside

Enroll in or hire us to teach our Fast Track to EJB 3.0 and the JPA Using JBoss class in Riverside, California by calling us @303.377.6176. Like all HSG classes, Fast Track to EJB 3.0 and the JPA Using JBoss may be offered either onsite or via instructor led virtual training. Consider looking at our public training schedule to see if it is scheduled: Public Training Classes
Provided there are enough attendees, Fast Track to EJB 3.0 and the JPA Using JBoss may be taught at one of our local training facilities.
We offer private customized training for groups of 3 or more attendees.
get pricing information

Course Description

  
The Enterprise JavaBeans 3.0 specification is a deep overhaul of the EJB specification that is intended to improve the EJB architecture by reducing its complexity from the developer's point of view. It leverages annotations (introduced in Java 5) and Object-Relational Mapping (ORM) technologies to eliminate the dependence on complex EJB APIs, allow POJO (Plain Old Java Object) based development, and provide an effective technology for creating distributed, transactional components, and for mapping relational data to an object schema. This course provides thorough coverage of the EJB3 technology including new concepts such as the use of annotations and the use of Dependency Injection to initialize references. This course also includes in-depth coverage of managing persistence using the Java Persistence API (JPA). It uses hands-on labs and a well-paced approach to make this complex technology understandable in an accelerated fashion. You will come away with a comprehensive understanding of EJB and the important issues that need to be considered to use it in real world applications.
Course Length: 4 Days
Course Tuition: $1690 (US)

Prerequisites
One year of Java programming experience (or equivalent) is preferred. Knowledge of relational databases and JDBC is strongly recommended.

Course Outline

  

Overview
What is EJB?
EJB Goals
Types of Enterprise JavaBeans
Java Persistence API
EJB and Java EE (Enterprise Editions)
EJB in Java EE Architecture
SOA and EJB
SOA with Web Services and EJB

EJB 3.0
EJB 3.0 Overview
EJB 2.X Problems
EJB 3.0 Goals
Session Bean Usage
Persistent Entity Usage
MDB Usage

Session Bean Overview
What are Session Beans?
Stateless Session Beans (SLSB)
Stateful Session Beans (SFSB)
Session Bean can be Distributed
Defining a Session Bean
Stateless Session Bean Definition
Calculator Remote Business Interface
Remote and Local Business Interfaces
Calculator Bean Local Business Interface
A Brief Note on Annotations
How Annotations Work
Annotation Definition
Using Annotations
What Else is Needed?

Packaging and Deployment
J2EE Packaging
EJB-JAR File
Deployment Descriptor (DD)
Deployment Descriptors in EJB 3
EJB-JAR File Structure
Enterprise Archive (EAR File)
Application.xml File
Server Deployment
EJB Container
The EJB Container
Server Deployment

JNDI Overview
How do Remote Clients get EJB Access?
JNDI – Java Naming and Directory Interface
EJB Container Binds a Reference into JNDI
Client Looks up Reference in JNDI
JNDI Tree Structure
JNDI API Overview
JNDI API
The Context Interface
The InitialContext Class
Specifying the InitialContext Properties
Using JNDI

EJB Client
Client View of a Session Bean
Client Invocation of a Session EJB
PortableRemoteObject and Casting
Running a Client

Dependency Injection
Dependency Injection
The JavaTunes Online Music Store
An EJB Referencing Another EJB
CatalogMaintenance
Injection of CatalogMaintenance
What is Happening

Deployment Descriptors
More About Deployment Descriptors
The XML Deployment Descriptor

The EJB Environment
Issues with Obtaining Resources
Referencing Resources External to EAR
Reference & Deployment Descriptor Usage
Resolving a JNDI Name
Simple Environment Entries
Declaring Simple Environment Entries
Setter Injection
Resource Manager Connection Factories
More on the Enterprise Bean Environment
The Environment is a Level of Indirection
Looking up Resources in the Environment
Looking up via EJBContext
Looking up via JNDI API
More on the @Stateless Annotation
More on the @EJB Annotation
More on the @Resource Annotation
Deployment Descriptor vs Annotation

Stateless Session Bean Lifecycle & Interceptors
Stateless Session Bean State Diagram
Lifecycle of SSB
Client Call of a Stateless SB Method
Interceptors
Business Method Interceptors
InvocationContext Interface Details
Interceptor Method Details
Interceptor Class
Using Interceptor Classes
Method Level Interceptors
Lifecycle Callback Interceptors
Lifecycle Interceptor in the Bean Class
Lifecycle Interceptor in a Separate Class

Stateful Session Beans
Stateful Session Bean (SFSB) Overview
Coding a Stateful Session Bean
Stateful Session Bean Clients
Stateful Session Bean Removal
Stateful Session Passivation/Activation
When to Use Stateful Session Beans
@PrePassivate and @PostActivate Callbacks
Stateful Session Bean State Diagram

The Timer Service
Bean Requirements
The javax.ejb.Timer Interface
The javax.ejb.TimerService Interface
How the Timer Works
Issues with Using the Timer Service

Overview of Messaging Systems
What is Messaging?
Loose Coupling
When is Messaging Used?
Two Messaging Models
Publish/Subscribe – Illustrated
More on Publish/Subscribe
Point-to-Point – Illustrated
More on Point-to-Point (P2P)
Message Delivery – Push versus Pull

Overview of JMS API
What is Java Message Service?
API Structure
JMS Interfaces
Administered Objects
Administered Objects and JNDI – Illustrated
Client Workflow
Synchronous Queue Consumer Client
Asynchronous Queue Consumer Client
JMS Message Types
Message Header Fields

Message-Driven Beans
J2EE Message Producers and Consumers
Message-Driven Bean (MDB) Overview
Goals of Message-Driven Beans
MDB Consumption of a Message
@MessageDriven Details
Activation Configuration Properties
Specifying a Destination for an MDB
Specifying a Destination Using a DD

Message-Driven Bean Lifecycle
Lifecycle Overview
MDB State Diagram
Interceptor Methods

Transaction Definition
Transaction Overview
Transaction Lifecycle
Transactions Clarify Systems

Transactional System Overview
Overview of a Transactional System
Transactional System Components
Transactional Object
EJB Transaction Support

Transactions in EJB
EJB Declarative Transaction Management
Transactional Scope
EJB Transaction Attributes
Specifying Transaction Attributes
NOTSUPPORTED
SUPPORTS
REQUIRED
REQUIRESNEW
MANDATORY
NEVER
Beans Have a Say in Transactions
Beans can be Notified of Transaction Status
Transaction Attributes – Some Choices
Explicit/Bean-Managed Transactions
Transaction Isolation Levels
Multi-Process TX and Two Phase Commit

Security in EJB
Security Requirements
J2EE Security
Roles
J2EE Security Overview
EJB Security Overview
Authentication
Programmatic Security
Transport Level Security with SSL

Exception Handling
Overview of Exceptions
Exception Hierarchy
Application Exceptions in EJB
Defining Application Exceptions
Container Handling of Application Exception
Bean Throwing of Application Exception
Client Handling of Application Exceptions
System Exceptions Indicate Failure
Container Handling of System Exception
Client Handling of System Exceptions

EJB 3 Best Practices
When to Use EJB
Keep Business Interfaces Coarse Grained
Session Façade Structure
Use Container-Managed Transactions
Transaction Duration
Local and Remote Business Interface
Tuning
Session Bean Tuning
Clustering
Clustering Session Beans

JPA Overview
The Issues with Persistence Layers
Object-Relational Mapping (ORM) Issues
Issues with JDBC Alone
Java Persistence API Overview
JPA Benefits
Java Persistence Environments

Mapping a Simple Class
Entity Classes
Entity Class Requirements
The Entity Declaration
The Event Class
The Id Property
Field Access or Property Access
The EVENTS Table
Generated Id Property
Mapping Properties
Basic Mapping Types
Persisting to the Database

Entity Manager and Persistence Context
The Entity Manager & Persistence Context
The EntityManager
The EntityManager Interface
Persistence Unit
Injecting an EntityManager
Retrieving Persistent Objects
Container-Managed Entity Manager
The Persistence Unit
persistence.xml

Inserting and Updating
Transient, Persistent, Detached Instances
Removed Instances
Persisting a New Entity
Synchronization to the Database
Updating a Persistent Instance
Detached Entities

Querying and Java Persistence Query Language (JPQL)
Java Persistence Query Language
JPQL Basics
Executing a Query
Where Clause
Query Parameters
Using Query Parameters
Named Queries

Versioning/Optimistic Locking
Optimistic Locking
Using a Detached Instance
Versioning
Version Property in Java Class
Locking Objects
Lock Modes

Entity Relationships
Relationships Overview
Object Relationships
Characteristics of Relationships
Directionality
Characteristics of Relationships

Mapping Relationships
Mappings Overview
Unidirectional Many-To-One Relationship
The Table Structure – Many-To-One
The Owning Side
@JoinColumn
Bidirectional One-To-One Relationship
Using the Relationship
More on the Inverse Side
Bidirectional One-To-Many Relationship
Mapping the One-To-Many Relationship
Other Collection Types
Many-To-Many Relationship
Defining Many-To-Many Relationship
Mapping Many-To-Many Relationships
Specifying the Join Table
Lazy and Eager Loading
Cascading Operations
The Cascade Element
Queries Across Relationships
OUTER and FETCH JOIN

Mapping Inheritance
Entity Inheritance
Details of Entity Inheritance
Single-Table Strategy
Entity Definitions for Single-Table
Single Table: Pros and Cons
Joined (Table per Subclass)
Entity Definitions for Joined
Joined: Pros and Cons
Table per Concrete Class

Embedded Objects
Using Embedded Objects
Embeddable Class
Reusing Embeddable Classes
Overriding Embedded Class Attributes
Compound Primary Keys
Compound Key with Embedded Id Class
Using an Embedded Id Class
Compound Key with ID Class

Additional Java Persistence Capabilities
More on Querying
Projection Queries
Aggregate Queries
Bulk Update and Delete
Native SQL Queries

Extended Persistence Contexts
Stateful Session Beans with Entity State
Extended Persistence context
Issues with Extended Persistence Context

XML Mapping Files
XML Mapping Files
A Simple Entity Class
JPA XML Mapping File
JPA XML Mapping File – Mapping Entities
JPA XML Mapping File – Named Queries

Java Persistence with Java SE
Using JPA with Java SE
Java SE APIs

Java Persistence Best Practices
Primary Key Considerations
Use Named Queries
Use Lazy/Eager Loading Appropriately
Be Aware of Transaction Semantics
Encapsulate JPA Code
Use Report Queries Where Applicable
Optimize Read-Only/Mostly Data Access
Paging Data
Consider Going Outside of Java Persistence
Know Your Provider Implementation

Course Directory [training on all levels]

Technical Training Courses
Software engineer/architect, System Admin ... Welcome!
Business Training Courses
Project Managers, Business Analysts, Paralegals ... Welcome!
Upcoming Classes
Gain insight and ideas from students with different perspectives and experiences.

Java Uses & Stats

Java is Used For:
Android & IOS Development Software Products Video Games Desktop GUI's
Difficulty
Popularity
Year Created
1995
Pros

Most Commonly Used: 
According to Oracle, three billion devices run on Java.  And, because of its real-world applications, it consistently ranks at the top of the TIOBE Programming Community Index. 

Great Career Choice: 
Some of the fastest-growing salaries in the U.S. in 2018 are for Java developers.  (Glassdoor)  

Android Apps Development:
Developers predominatly use their Java skills in building apps for Google's Android. The Android platform is the number one mobile paltform in the world

It Can Run On Any Platform:
Java can compile on Windows and run the same compiled file on Linux, Windows and Mac.

Great Supporting IDE's:
Over the years, coding in Java has become simpler with the introduction of open source development tools, i.e. Eclipse and NetBeans that use Java capabilities for debugging.  
 
Cons

Uses a Lot of Memory:
Performance can be significantly slower with Java and more memory-consuming than natively compiled languages such as C or C++.

Difficulty in Learning: 
Learning Java can be a bit challenging if you are a beginner.  However, once you get the hang of Object Oriented Programming and a decent grasp of the syntax, you will be well on your way.

Slow Start Up Times:
There is quite a bit of one-time initialization done by JDK classes before compiling as well as loading classes and verification (making sure code doesn't do evil things, all of which takes longer that some other languages such as C. 

Verbose and Complex Code:
Long, over-complicated sentences make code less readable and scannable. Compare to let's say Python, we can see how clear Python code appears: It doesn’t require semicolons; uses “and,” “or,” and “not” as operators instead of Java’s “&&,” “||,” and “!”; and generally has fewer bells and whistles such as parentheses or curly braces.

Commercial License Cost:
Companies have to prepare for the changes that Oracle will institute in 2019 . Today, the current version of Java is free and available for redistribution for general purpose computing. However, If you are a DEVELOPER, Oracle recommends you review the roadmap information for Java SE 8 and beyond and take appropriate action depending on the type of application you develop and your distribution mode.
Java Job Market
Average Salary
$102,000
Job Count
26,856
Top Job Locations

New York City 
San Jose
Washington D.C, 
Complimentary Skills to have along with Java

- If you are an experienced Java developer, learning a complimentary language to Java should come much more naturally.  As an example JetBrains recently created the Kotlin programming language which is officially supported by Google for mobile development.  Kotlin compiles to Java bytecode and runs on the JVM; it's purported to address many of Java's shortcomings...

Interesting Reads Take a class with us and receive a book of your choosing for 50% off MSRP.