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
Temptraining funding
ITTA is a partner of Temptraining, the continuing education fund for temporary workers. This training fund can subsidize continuing education for anyone who works for an employer subject to the Collective Work Agreement (CCT) Rental of services.
