Home    |    Instructor-led Training    |    Online Training     
         
 
Courses
ADA
Adobe
Agile
AJAX
Android
Apache
AutoCAD
Big Data
BlockChain
Business Analysis
Business Intelligence
Business Objects
Business Skills
C/C++/Go programming
Cisco
Citrix
Cloud Computing
COBOL
Cognos
ColdFusion
COM/COM+
CompTIA
CORBA
CRM
Crystal Reports
Data Science
Datawarehousing
DB2
Desktop Application Software
DevOps
DNS
Embedded Systems
Google Web Toolkit (GWT)
IPhone
ITIL
Java
JBoss
LDAP
Leadership Development
Lotus
Machine learning/AI
Macintosh
Mainframe programming
Mobile
MultiMedia and design
.NET
NetApp
Networking
New Manager Development
Object oriented analysis and design
OpenVMS
Oracle
Oracle VM
Perl
PHP
PostgreSQL
PowerBuilder
Professional Soft Skills Workshops
Project Management
Rational
Ruby
Sales Performance
SAP
SAS
Security
SharePoint
SOA
Software quality and tools
SQL Server
Sybase
Symantec
Telecommunications
Teradata
Tivoli
Tomcat
Unix/Linux/Solaris/AIX/
HP-UX
Unisys Mainframe
Visual Basic
Visual Foxpro
VMware
Web Development
WebLogic
WebSphere
Websphere MQ (MQSeries)
Windows programming
XML
XML Web Services
Other
Enterprise JavaBeans Version 3.0.2
(Click here for Version 2.1.2)
Java Training Overview

This course gives the experienced Java developer a thorough grounding in Enterprise JavaBeans -- the Java EE standard for scalable, secure, and transactional business components. EJB 3.0 has reinvigorated this area of Java enterprise development, with dramatic improvements in ease of use and smooth integration with servlet-based or JSF web applications. This course treats the 3.0 specification, with a few notes on 2.1 compatibility but an emphasis on doing things the 3.0 way.

Students get an overview of the EJB rationale and architecture, and then dive right into creating session beans and entities. The new dependency-injection features of EJB3 cause perhaps the most confusion, so we work through a chapter devoted explicitly to DI and JNDI, and basically how components find each other to make an application. We study entities and the Java Persistence API in depth, and get a look at message-driven beans as well. The latter phase of the course covers advanced topics including transactions, security, and interceptors.

This version of the course is designed to work with the Java EE 5 SDK, Update 7, which includes the GlassFish application server, version 2.1, and TopLink as the JPA provider. Variants of the course are also available with specific support for recent versions of JBoss and WebLogic.

Java Training Learning Objectives

  • Understand the role of EJB in the broader Java EE platform.
  • Describe the features that are implemented by an EJB container on behalf of application components.
  • Build stateless session beans as part of a service layer or SOA.
  • Build JPA entities to represent persistent data records within the Java application.
  • Develop systems of entities to manage complex data models including 1:1, 1:N, and N:N associations.
  • Manage transactional behavior of the application through declarative and programmatic techniques.
  • Invoke EJB sessions from Java web applications.
  • Use dependency injection and JNDI names to assemble complex web/EJB systems with minimal fuss and maximal flexibility.
  • Implement message-driven beans to process queued messages asynchronously.
  • Declare and/or program transaction boundaries, persistence contexts, and exception handling to properly control persistence logic.
  • Apply role-based authorization policies to EJBs.
  • Build interceptors to perform generic processing before, after, or around EJB business-method invocations.
  • Use EJB timers to defer processing or establish regularly scheduled tasks.
Java Training Prerequisites

  • Solid Java programming skills and understanding of OO Java and Java-5 language features is essential. Course "Java Programming" is excellent preparation for this course.
  • Experience with developing Java web applications is very helpful for this course, but not strictly required.
  • Some knowledge of XML will be useful for writing the occasional deployment descriptor, but is not required. Course "Introduction to XML" is recommended for those who would like to get more familiar with XML before pursuing this course.
Java Training Course duration

5 days.

Java Training Course outline

Chapter 1. Overview

  • Enterprise Applications
  • Containers and Objects
  • Three Containers
  • Remote Connectivity
  • Scalability and Availability
  • Security
  • Transaction Control
Chapter 2. Architecture
  • What is an EJB?
  • Types of Beans
  • Inversion of Control
  • The Bean-Type Annotations
  • Dependency Injection
  • The @EJB Annotation
  • The GlassFish Application Server
  • The Administration Console
  • Deploying EJB Applications
  • Configuring Data Sources
  • Development Cycle and Roles
Chapter 3. Session Beans
  • Interface/Implementation Split
  • Stateful vs. Stateless
  • The @Stateless Annotation
  • Lifecycle and State Transitions
  • Session Context
  • The @Stateful Annotation
  • State Transitions
  • Singletons and Pools
Chapter 4. Entities
  • The Java Persistence API
  • Persistence Annotations
  • Configuration by Exception
  • ORM Annotations
  • The EntityManager
  • Acquiring and Using the EntityManager
  • persistence.xml
  • @Enumerated and @Temporal Types
Chapter 5. Associations
  • Associations, Cardinality, and Ownership
  • Annotations
  • Unidirectional vs. Bidirectional
  • The @Embedded Annotation
Chapter 6. Java Persistence Query Language
  • OO Query Languages
  • The FROM Clause and Directionality
  • The WHERE Clause
  • The SELECT Clause
  • Joins
  • Aggregates and Grouping
  • Ordering
Chapter 7. Dependency Injection
  • Interdependent Systems
  • The Factory Pattern
  • The Service Locator Pattern
  • Dependency Injection
  • Injection by Magic?
  • Injection by Type
  • Injection by Name
  • The Component Environment
  • Deployment Descriptors
  • Impact on Stateful Session Beans
  • JNDI
  • Connecting to a Remote Bean
  • Using mappedName
  • Who Can Declare Dependencies
Chapter 8. Message-Driven Beans
  • Asynchronous Messaging
  • The Java Message Service
  • Message-Driven Beans
  • Message Types
  • Injecting JMS Queues
  • JMS Configuration in GlassFish
Chapter 9. Transactions
  • ACID Transactions
  • The EntityTransaction Interface
  • EJB Transaction Attributes
  • Persistence Contexts
  • Extended Persistence Contexts
  • Isolation Levels
  • Application-Managed Persistence
  • The SessionSynchronization Interface
  • Impact on JMS and MDBs
Chapter 10. Exception Handling
  • Java Exceptions
  • Remote Exceptions
  • EJB Exception Handling
  • System Exceptions
  • Application Exceptions
  • Transaction Control
Chapter 11. Security
  • Authentication and Authorization
  • Declarative Authorization
  • Abstract Roles
  • Concrete Realms
  • Configuring User Realms in GlassFish
  • Programmatic Authorization
  • Run-As Identity
Chapter 12. Interceptors
  • EJB and AOP
  • The Intercepting Filter Pattern
  • EJB Interceptors
  • Annotating Interceptor Classes
  • The InvocationContext Interface
  • Binding Interceptors to Targets
  • Shared Lifecycle and Context
  • Interceptors and MDBs
Chapter 13. Timers
  • The EJB Timer Service
  • The TimerService Interface
  • The Timer Interface
  • Timeout Methods
  • Timer Handles
  • Transactions and Timers
Appendix A. Learning Resources

Appendix B. Quick Reference: Java EE Annotations



Hardware/Software Requirements

Hardware – minimal

1 GHz, 512 meg RAM, 1 gig disk space.

Hardware – recommended

2 GHz, 1 gig RAM, 1 gig disk space

Operating system

Tested on Windows XP Professional. Course software should be viable on all systems which support the Java EE 5.0 SDK.

Network and Security

Limited privileges required

Software

All free downloadable tools.


Please contact your training representative for more details on having this course delivered onsite or online

Training Outlines - the one stop shopping center for IT training.
© Training Outlines All rights reserved