This is an example of a simple banner
  • Trainings
  • Certifications

Training: Developing with EJB3 in Java EE

Ref. EJB

Download PDF

Duration:
4
 days
Exam:
Optional
Level:
Intermediate
Funding:
Eligible

Description

The new EJB3 architecture is designed to greatly simplify the EJB development, which today represents the most advanced in terms of a distributed architecture. They enable the development of business components, both addressable by a Web service as the “classic” of a company.

Participant Profiles

  • Application developers
  • IT managers
  • Architects
  • Project managers
  • Engineers

Objectives

  • Manage the development of EJB 3 and its integration into an enterprise application

Prerequisites

  • Knowledge of Java language
  • knowledge of servlets and JSP is a plus
  • Knowledge of EJB 2.x is a plus

Course Content

Module 1: Fundamental Architectural Concepts
  • Lesson 1: What is Architecture?
  • Lesson 2: Architecture vs. Design
  • Lesson 3: Qualities of Service (QoS)
  • Lesson 4: Common Mechanisms
  • Lesson 5: Architectural Description
  • Lesson 6: What Architecture is Not
  • Lesson 7: The Need for Architecture
  • Lesson 8: The Architect
  • Lesson 9: Roles of the Architect
  • Lesson 10: Skills of the Architect
Module 2 : System Architecture Development Guidelines
  • Lesson 1: Security Risks
  • Lesson 2: Performance & Scalability Risks
  • Lesson 3: Availability & Complexity Risks
  • Lesson 4: Compatibility & Control Risks
  • Lesson 5: Network Considerations
  • Lesson 6: Latency and Bandwidth
  • Lesson 7: Minimize Number of Network Calls
  • Lesson 8: Minimize Network Call Size
  • Lesson 9: Firewall Navigation
  • Lesson 10: Secure Communication
  • Lesson 11: Distributed Object Technologies
  • Lesson 12: What is a Transaction?
  • Lesson 13: Bank Example
  • Lesson 14: Multiple Users Sharing Data
  • Lesson 15: ACID Properties of Transactions
  • Lesson 16: Architecture
  • Lesson 17: Reference Architecture
  • Lesson 18: Patterns
  • Lesson 19: Development Methodologies
  • Lesson 20: Open Standards
  • Lesson 21: Frameworks
Module 3 : Quality of Service Requirements
  • Lesson 1: What are Quality of Service Requirements?
  • Lesson 2: Qualities of Service and Design
  • Lesson 3: Quality of Service Inventory
  • Lesson 4: Performance
  • Lesson 5: Scalability
  • Lesson 6: Reliability
  • Lesson 7: Availability
  • Lesson 8: Extensibility
  • Lesson 9: Maintainability
  • Lesson 10: Manageability
  • Lesson 11: Security
  • Lesson 12: Cultural Adaptability
  • Lesson 13: Portability
  • Lesson 14: Testability
  • Lesson 15: Usability
  • Lesson 16: Upgradeability
  • Lesson 17: Recoverability
  • Lesson 18: Prioritizing Quality of Service Requirements
  • Lesson 19: Inspecting QoS Requirements for Trade-off Opportunities
  • Lesson 20: Quality of Service Reviews
Module 4 : Software Architecture Tiers
  • Lesson 1: System Architecture
  • Lesson 2: Good Architecture
  • Lesson 3:Cave Drawings to Modern Day
  • Lesson 4: Information Systems Evolution
  • Lesson 5: Present Day
  • Lesson 6: Client-Server Computing
  • Lesson 7: Client-Server Pros/Cons
  • Lesson 8: Tiered Architectures
  • Lesson 9: Single-tier Architecture
  • Lesson 10: Single-tier Pros/Cons
  • Lesson 11: Two-tier Architecture
  • Lesson 12: Two-tier Pros/Cons
  • Lesson 13: Three-tier Architecture
  • Lesson 14: three-tier Pros/Cons
  • Lesson 15: N-Tier Architecture
  • Lesson 16: N-Tier Pros/Cons
Module 5 : Managing Client Tier Considerations
  • Lesson 1: Understand client-tier concerns
  • Lesson 2: Types of Clients
  • Lesson 3: JEE Client Responsibilities
  • Lesson 4: Presenting the user interface
  • Lesson 5: Validating user inputs
  • Lesson 6: Communicating with the server
  • Lesson 7: Managing conversational state
  • Lesson 8: Understand Client-Tier security
  • Lesson 9: Compare/contrast user interface devices
  • Lesson 10: Application of reuse to the client tier
  • Lesson 11: Strategies for deploying Java desktop applications
Module 6 : Java EE Technology Servers
  • Lesson 1: Server Types in Java EE
  • Lesson 2: Java EE Servers
  • Lesson 3: Java EE Containers
  • Lesson 4: Enterprise Information Systems
  • Lesson 5: ERP Systems
  • Lesson 6: Mainframe Transaction Processing Systems
  • Lesson 7: Relational and Legacy Databases
  • Lesson 8: Legacy Integration
  • Lesson 9: Selecting a Java EE Server
  • Lesson 10: Roles and Responsibilities
  • Lesson 11: EJB Modules
  • Lesson 12: EJB Module Packaging
  • Lesson 13: EJB Module Recommendations
  • Lesson 14: Web Modules
  • Lesson 15: Web Module Recommendations
  • Lesson 16: Deployment Descriptors
Module 7 : Java EE Technologies
  • Lesson 1: Servlets
  • Lesson 2: The Web Container
  • Lesson 3: Servlet API
  • Lesson 4: Session Management
  • Lesson 5: Servlet Thread Issues
  • Lesson 6: JSP (Java Server Pages)
  • Lesson 7: How JSPs Work
  • Lesson 8: JSP Elements
  • Lesson 9: Using JavaBeans in JSP
  • Lesson 10: Custom Tags
  • Lesson 11: Filters
  • Lesson 12: Filters and the Processing Pipeline
  • Lesson 13: Filter API
  • Lesson 14: Uses for Filters
  • Lesson 15: Event Listeners
  • Lesson 16: What are EJBs?
  • Lesson 17: Main Characteristics of EJBs
  • Lesson 18: EJB Architecture Components
  • Lesson 19: EJB Container
  • Lesson 20: EJB Container – Persistence
  • Lesson 21: EJB Container – Transactions
  • Lesson 22: Enterprise Java Beans
  • Lesson 23: Session Beans
  • Lesson 24: Entity Beans
  • Lesson 25: Message-Driven Beans
  • Lesson 26: EJB Classes and Interfaces
  • Lesson 27 EJB Container – Relationships
  • Lesson 28: How Remote EJBs Work
  • Lesson 29: Remote vs. Local EJBs
  • Lesson 30: Web Services
  • Lesson 31: Web Service Implementation in Java EE
  • Lesson 32: Web Service Deployment in J2EE
  • Lesson 33: JCA (Java EE Connector Architecture)
  • Lesson 34: Application Level Contract
  • Lesson 35: System Level Contracts
Module 8 : Java EE Technology Choices
  • Lesson 1: Client Session State
  • Lesson 2: Client Managed State
  • Lesson 3: Web Tier Managed State
  • Lesson 4: EJB Tier Managed State
  • Lesson 5: Business Objects
  • Lesson 6: When to Use EJB
  • Lesson 7: When to Use Entity Beans
  • Lesson 8: CMP vs. BMP
  • Lesson 9: Client Types
  • Lesson 10: Web Browser Clients
  • Lesson 11: Java Clients
  • Lesson 12: Model View Controller
  • Lesson 13: Model View Controller in the Web-Tier
  • Lesson 14: Web Application Frameworks
  • Lesson 15: Web Presentation Layout
  • Lesson 16: Java Presentation Layout
  • Lesson 17: Message-Oriented Middleware and JMS
  • Lesson 18: Messaging Domains
  • Lesson 19: Characteristics of MOM
  • Lesson 20: Advantages of Asynchronous Communication (e.g. MOM)
  • Lesson 21: Advantages of Synchronous Communication (e.g. RMI/IIOP)
Module 9 : Java Connector Architecture (JCA)
  • Lesson 1: JCA Overview
  • Lesson 2: Resource Adapter
  • Lesson 3: System Contracts
  • Lesson 4: Outbound Contracts
  • Lesson 5: Inbound Contracts
  • Lesson 6: Lifecycle Contracts
  • Lesson 7: Common Client Interface (CCI)
  • Lesson 8: Advantages of JCA
  • Lesson 9: Resource Adapter Packaging
  • Lesson 10: Connection Management
  • Lesson 11: Transaction Management
  • Lesson 12: Transaction Scenario
  • Lesson 13: Client Interaction
Module 10 : SOA Concepts
  • Lesson 1: Service Oriented Architecture
  • Lesson 2: Componentizaton and Reuse
  • Lesson 3: Benefits of Service Orientation
  • Lesson 4: Defining SOA
  • Lesson 5: Aligning the Enterprise
  • Lesson 6: What is a Service?
  • Lesson 7: Service Actors
  • Lesson 8: Service Layering
  • Lesson 9: Service Orienting the Enterprise
  • Lesson 10: Service Oriented Thinking
Module 11 : JAX-WS Introduction
  • Lesson 1: JAX Attack
  • Lesson 2:  JAX-WS Origins
  • Lesson 3: JAX-WS Architecture and Tools
  • Lesson 4: Providing a Service
  • Lesson 5: Service Source (Option 1)
  • Lesson 6: Service-enabling Java
  • Lesson 7: Service Source (Option 2)
  • Lesson 8: Calling a Service
  • Lesson 9: Client Source (Option 1)
  • Lesson 10: Client Source (Option 2)
  • Lesson 12: Advanced Features
Module 12 : Java EE Security
  • Lesson 1: JEE Authentication mechanisms
  • Lesson 2: Basic authentication
  • Lesson 3: Form-based authentication
  • Lesson 4: Client certificate authentication
  • Lesson 5: JEE Authorization
  • Lesson 6: Declarative security on Web Resources
  • Lesson 7: Programmatic security on Web Resources
  • Lesson 8: Security role reference
  • Lesson 9: Defining security roles using annotations
  • Lesson 10: Delegation
  • Lesson 11: Declarative security on EJB Resources
  • Lesson 12: Protecting beans using annotations
  • Lesson 13: Protecting beans using the deployment descriptor
  • Lesson 14: Programmatic security on EJB Applications
  • Lesson 15: Delegation
Module 13 : Web Services Security (WS-Security)
  • Lesson 1: The Challenges
  • Lesson 2: Public Key Infrastructure (PKI)
  • Lesson 3: Digital Signature
  • Lesson 4: Certificates
  • Lesson 5: Overview of Web Services Security
  • Lesson 6: SOAP Message Security
  • Lesson 7: Message Integrity
  • Lesson 8: Message Confidentiality
  • Lesson 9: Symmetric Encryption Example
  • Lesson 10: Authentication Using Identity Token
  • Lesson 11: Authentication
  • Lesson 12: Transport Level Security
  • Lesson 13: Audit Tracking
  • Lesson 14: Identity Assertion using SAML
  • Lesson 15: SAML SOAP Example
Module 14 : Prototypes
  • Lesson 1: What is a Prototype?
  • Lesson 2: Conceptual Prototypes
  • Lesson 3: Architectural Prototypes
  • Lesson 4: Advantages of Prototyping
  • Lesson 5: Deciding Whether to Build a Prototype or Not
  • Lesson 6: Prototypes and the Software Development Lifecycle
  • Lesson 7: Prototype Roles and Responsibilities
  • Lesson 8: Throw-away vs. Evolutionary Prototypes
  • Lesson 9: Spikes
  • Lesson 10: Testing a Prototype
Module 15 : Describing and Evaluating Software Architecture
  • Lesson 1: Architecture Description
  • Lesson 2: Architectural Views
  • Lesson 3: Subsystems
  • Lesson 4: Layers
  • Lesson 5: Components
  • Lesson 6: Decomposing the System Into Components
  • Lesson 7: Software Partitioning Strategies
  • Lesson 8: Managing Dependencies
  • Lesson 9: Component Diagrams
  • Lesson 10: Deployment Diagrams
  • Lesson 11: Tiered Architectures
  • Lesson 12: Managing Complexity
  • Lesson 13: Evaluating the Architecture
Appendix A: Data Transfer in Distributed Computing
  • Data Transfer in Java Local Computing
  •  Data Transfer in Java Distributed Computing
  •  Comparing Data Transfer in Local and Distributed Computing
Appendix B: Transactions
  • Need for Transactions
  • Transactions
  • ACID Properties
  • Transaction Components
  • Distributed Transactions
  • Distributed Transaction Components – Two Phase Commit
  • Java Transaction API (JTA)
  • Object Transaction
  • EJB Transactions Basics
  • Transaction Propagation
  • Transaction Outcome
  • Container Managed Transaction
  • Container Managed Transaction Settings
  • Interacting with Container Managed Transactions
  • Transaction Attributes Support
  • Bean Managed Transaction
  • Client Managed Transaction
  • Transaction Isolation
  • Isolation Level
Appendix C: Business and Integration Tier Patterns
  • Business Delegate Pattern
  • How it Works
  • Data Transfer Object Pattern
  • DTO Example (Output)
  • DTO Example (Input)
  • Role of DTO in MVC
  • Access Beans
  • Types of Access Beans
  • Data Class Access Bean
  • Data Class Programming Model
  • Access Bean Constructor
  • Generating Access Beans
  • Generating a Data Class
  • Generating an EJB Factory
  • Using EJB Factory and Data Class
  • Deleting the Access Bean
  • Value Object Pattern
  • Multiple Value Objects
  • Best Practice derive EJB from the value object
  • Composite Entity Pattern
  • Class Diagram
  • How the client interacts
  • Value Object Assembler
  • Value List Handler
  • How Does it Work?
  • Design Considerations
  • Service Locator
  • Data Access Object (DAO)
  • DAO Implementation Guidelines
  • Service Activator
  • MDB – Integrating JMS and EJB
  • Message-Driven Beans are Different from other EJBs
  • Message-Driven Beans are Stateless
  • Message-Driven Bean Interfaces
  • Message Counter
  • Class Message Counter
  • Processing the Message
  • Deployment Descriptor Entry

Documentation

  • Digital courseware included

Lab / Exercises

  • During the course participants are encouraged to actively participate in the learning experience by running example files during lectures and performing coding challenges during labs.
  • Each lab session allows you to compare your solution to the instructor’s

Exam

  • This course prepares you to the 1Z0-895 : Java Platform, Enterprise Edition 6 Enterprise JavaBeans Developer Certified Expert. If you wish to take this exam, please contact our secretariat who will let you know the cost of the exam and will take care of all the necessary administrative procedures for you

Complementary Courses

Eligible Funding

ITTA is a partner of a continuing education fund dedicated to temporary workers. This fund can subsidize your training, provided that you are subject to the “Service Provision” collective labor agreement (CCT) and meet certain conditions, including having worked at least 88 hours in the past 12 months.
Prix de l'inscription
CHF 2'900.-
Inclus dans ce cours
  • Training provided by a certified trainer
  • Preparation for the exam
  • Documentation and digital media
  • Achievement Badge
Mois actuel

No Events

Horaires d’ouverture

Du lundi au vendredi

de 8h30 à 18h00

Tél. 058 307 73 00

Contactez-Nous

ITTA
Route des jeunes 35
1227 Carouge, Suisse

Nous joindre par téléphone

Faire une demande

Formulaire de demande

Opening hours

Monday to Friday
8:30 AM to 6:00 PM
Tel. 058 307 73 00

Contact-us

ITTA
Route des jeunes 35
1227 Carouge, Suisse

Call Us Now

Make a request

Request Form

Opening hours

Monday to Friday, from 8:30 am to 06:00 pm.

Contact us

  • ITTA
    Route des Jeunes 35
    1227 Carouge, Suisse

Your request

  • ITTA
    Route des jeunes 33 Bis, Entrée B,
    1227 Carouge, Suisse