Developing Java EE/Jakarta Applications

מידע וסילבוס - Developing Java EE Applications

Java Enterprise Edition (Java EE) provides an object‐oriented, distributed and cross‐platform framework for developing and deploying robust, secure and scalable E‐Business and E‐Commerce applications.

 

This course presents the Java EE architecture and key technologies and components to provides participoants with the knowledge to build enterprise applications  complying with current Java EE  technology standards.

 

This training program encompasses the latest Java EE specifications (Java EE 8 / Jakarta EE) and employs the most up-to-date Java EE standards compliance container (JBoss Wildfly 14.0) including Java SE 11 support on top of Eclipse Jee-2018 IDE with JBoss integration tools.

 

The training program includes roughly 30% hand on code experience with running examples and demos and exercises to complete in class.

 

The Java EE components & technologies discussed in this training program include: 

 

  • Java Servlets 4 and Java Server Pages (JSP) 2.3 with Expression Language (EL) 3.0 and Java Standard Tag Library (JSTL) 1.2
  • Enterprise JavaBeans (EJB) 3.2
  • Interceptors 1.2
  • Context and Dependency Injection (CDI) 2.0
  • Java Messaging Service (JMS) API 2.0
  • Java Transaction API (JTA) 1.2 
  • Bean Validation 2.0
  • Java Persistence 2.0
  • Java RESTful web services (JAX-RS) 2.1  
  • Java EE Security

As Java EE is composed of an enormous stack of technologies, this training program is split into an incremental ‘per-days’ modular structure. Participants may choose to extend their Java EE knowledge beyond the general 3 days training program. 

 

  • Day 1 – 3:  Comprehensive 3 days (24 hours) introduction to Java EE key technologies: 
    • Servlets – and related JSP/EL technologies
    • EJB’s session beans – Singleton, Stateless and Stateful
    • Message driven beans – Java Messaging Services / JNDI
    • CDI – context & dependency injection
    • JPA – working with the entity manager and entities
    • Transactions in Java EE
    • Security in Java EE




  • Day 4: Additional technologies & Enhancements of basic topics
    • Java EE Interceptors
        • RESTful web services with Java EE
        • Bean Validation
        • Internationalizing and localizing web applications
        • Enhancements
          • Servlets – asynchronous Processing
          • EJB – asynchronous method invocation
          • CDI – additional dependency injection options
          • JPA – entity relationships, inheritancem bi-directionality lifecycle and management 
          • Security – securing web-applications and securing EJB’s

      • Day 5: Advanced Java Persistence Topics
        • The Java Persistence Query Language (JPQL)
        • JPA Criteria API
        • Concurrent Access to Entity Data and Optimistic Locking
        • Creating Fetch Plans with Entity Graphs
        • 2nd level caching with JPA applications
  • familiarity with the Java programming language, generics and java 8 streams, and previous experience developing Java SE applications 
  • familiarity with web applications and the HTTP protocol
  • good knowledge of object oriented programming and GoF design patterns

 

  • general:    3 days (24 hours) 
  • enhanced:   4 days (32 hours)
  • full JPA:   5 days (40 hours)

Interbit certificate

  • What is Java EE – Introduction
  • Distributed Multitiered Applications
  • Java EE Application Model
  • Java EE Containers
  • Java EE Application Assembly and Deployment
  • Java EE 8 APIs and Technologies
  • Introduction to Servlets
  • Servlet life cycle and life cycle events
  • Handling Servlet Errors
  • Sharing Information using scoped objects
  • Creating and initializing a servlet
  • Writing service methods
  • Filtering requests and responses
    • Programming and mapping filters
  • Maintaining client state – 
    • accessing a session
    • associating objects with session
    • session management
    • session tracking
  • Introduction to JavaServer Pages
    • JSP Syntax and Semantics
    • JSP and JavaBeans
    • JSP Expression Language
  • Overview of CDI
  • About Bean and CDI Managed Beans
  • Beans as Injectable Objects
  • Using Qualifiers
  • Injecting Beans
  • Using Scopes
  • Giving Beans EL Names
  • Adding Setter and Getter Methods
  • Injecting Objects by Using Producer Methods
  • Configuring a CDI Application
  • What is a Java EE web application?
  • Deploying web applications
  • The optional deployment descriptor file web.xml
  • Session Beans Introduction
  • Stateful Session Beans
  • Stateless Session Beans
  • Singleton Session Beans
  • More Annotations
  • JNDI Overview
  • JMS Overview
  • MDB Introduction
  • Developing an MDB
  • Developing an MDB Client
  • packaging applications
  • packaging enterprise beans
  • packaging web archives
  • packaging resource adapter archives
  • packaging CDI applications
  • Overview of the Java Persistence API
  • Entities
      • Requirements for Entity Classes
      • Persistent Fields and Properties in Entity Classes
        • Persistent Fields
        • Persistent Properties
        • Using Collections in Entity Fields and Properties
        • Validating Persistent Fields and Properties
    • Primary Keys in Entities
  • Embeddable Classes in Entities – introduction
  • Entity Inheritance – introduction
  • Managing Entities
    • The EntityManager Interface
      • Finding Entities Using the EntityManager
      • Persisting Entity Instances
      • Removing Entity Instances
    • Persistence Units
  • Querying Entities
  • Introduction to Transactions in Java EE Applications
  • Container Managed Transactions
    • Transaction Attributes
    • Setting Transaction Attributes
    • Rolling Back a CMT
    • Synchronizing a Session Bean’s instance variable
    • Methods not allowed in CMT
  • Bean Managed Transactions
    • JTA Transactions
    • Returning without committing 
    • Methods not allowed in BMT
  • Transaction Timeouts
  • Transactions in Web Components
  • Introduction to Security – Security Mechanisms
    • Java SE Security Mechanisms
    • Java EE Security Mechanisms
      • Application Layer Security
      • Transport Layer Security
      • Message Layer Security
    • Working with Realms, Users, Groups, and Roles
    • Mapping Roles to Users and Groups
  • Declarative and Programmatic Security
  • Securing Web Applications
  • Securing Enterprise Applications
  • Interceptors Overview
  • Defining Interceptors
  • Interceptor Classes
  • Interceptors for Lifecycle Methods
  • Developing RESTful Web Services with JAX-RS
  • Overview of a JAX-RS Application
  • The @Path Annotation and URI Path Templates
  • Responding to HTTP Methods and Requests
  • Using @Consumes and @Produces to Customize Requests and Responses
  • Extracting Request Parameters
  • Configuring JAX-RS Applications
  • Overview of Bean Validation
  • Using Bean Validation Constraints
  • Validating Null and Empty Strings
  • Validating Constructors and Methods
  • Cross-Parameter Constraints
  • Identifying Parameter Constraint Violations
  • Adding Constraints to Method Return Values
  • Java Platform Localization Classes
  • Providing Localized Messages and Labels
    • Establishing the Locale
    • Setting the Resource Bundle
    • Retrieving Localized Messages
  • Date and Number Formatting
  • Character Sets and Encodings
    • Character Sets
    • Character Encoding
  • (advanced) Asynchronous processing
    • Asynchronous processing in servlets
    • waiting for a resource
  • (advanced) Non blocking I/O
    • read large request/response with none blocking I/O
  • Using Asynchronous Method Invocation in Session Beans
  • Creating an Asynchronous Business Method
  • Calling Asynchronous Methods from Enterprise Bean Clients
  • Retrieving the Final Result from an Asynchronous Method Invocation
  • Canceling an Asynchronous Method Invocation
  • Checking the Status of an Asynchronous Method Invocation
  • Using the @PostConstruct and @PreDestroy Annotations with CDI Managed Bean Classes
  • Using Alternatives in CDI Applications
    • Using Specialization
  • Using Producer Methods, Producer Fields, and Disposer Methods in CDI Applications
    • Using Producer Methods
    • Using Producer Fields to Generate Resources
    • Using a Disposer Method
  • Using Predefined Beans in CDI Applications
  • Using Events in CDI Applications
    • Defining Events
    • Using Observer Methods to Handle Events
    • Firing Events
  • 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
  • Entities
    • Persistent Fields and Properties in Entity Classes
        • Using Collections in Entity Fields and Properties
        • Validating Persistent Fields and Properties
    • Multiplicity in Entity Relationships
    • Direction in Entity Relationships
      • Bidirectional Relationships
      • Unidirectional Relationships
      • Queries and Relationship Direction
      • Cascade Operations and Relationships
      • Orphan Removal in Relationships
    • Embeddable Classes in Entities
  • Entity Inheritance
    • Abstract Entities
    • Mapped Superclasses
    • Non-Entity Superclasses
    • Entity Inheritance Mapping Strategies
        • The Single Table per Class Hierarchy Strategy
        • The Table per Concrete Class Strategy
        • The Joined Subclass Strategy
  • Managing Entities
    • The EntityManager Interface
      • Container-Managed Entity Managers
      • Application-Managed Entity Managers
      • Finding Entities Using the EntityManager
      • Managing an Entity Instance’s Lifecycle
      • Persisting Entity Instances
      • Removing Entity Instances
      • Synchronizing Entity Data to the Database
  • Database Schema Creation
    • Configuring an Application to Create or Drop Database Tables
    • Loading Data Using SQL Scripts

 

  • Securing Web Applications
    • Specifying Security Constraints
    • Specifying a Web Resource Collection
    • Specifying an Authorization Constraint
    • Specifying a Secure Connection
    • Specifying Security Constraints for Resources
    • Specifying Authentication Mechanisms
      • HTTP Basic Authentication
      • Form-Based Authentication
      • Digest Authentication
    • Specifying an Authentication Mechanism in the Deployment Descriptor
    • Declaring Security Roles
    • Using Programmatic Security with Web Applications
      • Authenticating Users Programmatically
      • Checking Caller Identity Programmatically
      • Testing Access to a Resource Programmatically
  • Securing Enterprise Applications
    • Securing Enterprise Beans
      • Securing an Enterprise Bean Using Declarative Security
        • Specifying Authorized Users by Declaring Security Roles
        • Specifying an Authentication Mechanism and Secure Connection
      • Securing an Enterprise Bean Programmatically
      • Propagating a Security Identity (Run-As)
        • Configuring a Component’s Propagated Security Identity
        • Trust between Containers
      • Deploying Secure Enterprise Beans

 

  • 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
    • Simple Queries
      • A Basic Select Query
      • Eliminating Duplicate Values
      • Using Named Parameters
    • Queries That Navigate to Related Entities
      • A Simple Query with Relationships
      • Navigating to Single-Valued Relationship Fields
      • Traversing Relationships with an Input Parameter
      • Traversing Multiple Relationships
      • Navigating According to Related Fields
    • Queries with Other Conditional Expressions
      • The LIKE Expression
      • The IS NULL Expression
      • The IS EMPTY Expression
      • The BETWEEN Expression
      • Comparison Operators
    • Bulk Updates and Deletes
      • Update Queries
      • Delete Queries
  • Full Query Language Syntax
    • BNF Symbols
    • BNF Grammar of the Java Persistence Query Language
    • FROM Clause
      • Identifiers
      • Identification Variables
      • Range Variable Declarations
      • Collection Member Declarations
      • Joins
    • Path Expressions
      • Examples of Path Expressions
      • Expression Types
      • Navigation
    • WHERE Clause
      • Literals
      • Input Parameters
      • Conditional Expressions
      • Operators and Their Precedence
      • BETWEEN Expressions
      • IN Expressions
      • LIKE Expressions
      • NULL Comparison Expressions
      • Empty Collection Comparison Expressions
      • Collection Member Expressions
      • Subqueries
      • Functional Expressions
      • Case Expressions
      • NULL Values
      • Equality Semantics
    • SELECT Clause
      • Return Types
      • The DISTINCT Keyword
      • Constructor Expressions
    • ORDER BY Clause
    • GROUP BY and HAVING Clauses

 

  • 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
    • Creating a Criteria Query
    • Query Roots
    • Querying Relationships Using Joins
    • Path Navigation in Criteria Queries
    • Restricting Criteria Query Results
      • The Expression Interface Methods
      • Expression Methods in the CriteriaBuilder Interface
    • Managing Criteria Query Results
      • Ordering Results
      • Grouping Results
    • Executing Queries
      • Single-Valued Query Results
      • Collection-Valued Query Results

 

Overview of Entity Locking and Concurrency

  • Using Optimistic Locking

Lock Modes

  • Setting the Lock Mode
  • Using Pessimistic Locking
  • Pessimistic Locking Timeouts
  • 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
  • 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
      • Cache Retrieval Mode
      • Cache Store Mode
      • Setting the Cache Retrieval or Store Mode
    • Controlling the Second-Level Cache Programmatically
      • Overview of the javax.persistence.Cache Interface
      • Checking whether an Entity’s Data Is Cached
      • Removing an Entity from the Cache
      • Removing All Data from the Cache

לשיחה / תאום פגישה עם יועץ לימודים:

  • הנני מעוניין/ת שנציג של מכללת אינטרביט יצור עימי קשר וישלח לי מידע רלוונטי על קורסים והשתלמויות של המכללה