Archives des Java SE/Java EE - Page 2 sur 3

Hibernate + Webservices

Goals

- To be able to easily access the databases with Java

- To create a maintainable and efficient persistence structure

- To be able to use existing private or public web services

- To know how to create, set up and declare Web services in java

Program

Introduction

History and versions
Installation and handling of the environment
Reminders: JEE (J2EE), servlets, SQL, JDBC

Basic use

Principle of data access (ORM)
Correspondences between base and Java; site configuration and
Hibernate tools for web applications and heavy applications
Adding and reading any data
The relational structure: configuration and use

Practical workshop: a CMS with MySQL, Hibernate, servlets and JSP

Tools and environment

Configuration or SQL generation tools
Handling of DataSources
Use in the case study

Advanced elements of Hibernate

Full use of the Hibernate Query Language
Increase of the case study with free searches and filtering
Advanced configuration: performance and functionalities
Transactions, balance sheet of concurrency
Inheritance of tables and objects

Practical workshop: example of inheritance – a management mini-application

Introduction to Webservices

Presentation of web services Web
services and SOA
Advantages
Standards
Web service platforms
List of Java APIs

XML - JAVA

Reminders of fundamental concepts: Prolog, elements and attributes, namespaces
Schemas (XSD)
XML parsers: SAX, DOM
Push parsing and pull parsing (StAX)
Java API’s for parsing and XML
Mapping xml-object transformation

Protocols

SOAP (SIMPLE OBJECT ACCESS PROTOCOL)
– Operating principle
– SOAP RPC
– SOAP messages: structure and scope
– Encoding / Serialization of data (document / literal or RPC / encoded)
– SOAP via HTTP
– Error returns (faults)

WSDL (WEB SERVICE DESCRIPTION LANGUAGE)
– Operating principle
– Structure of a WSDL file

Implementation of web services

Development platforms
Choice of implementation: Axis, CXF, JBossWS, Metro …
JAX-RPC (JAVA API FOR XML RPC)
– Presentation
– Creation and deployment of web services
– Invocation of a web service (static and dynamic)

JAX-WS 2
– Presentation
– Service implementation (use of annotations)
– Deployment (on a SOAP engine or in standalone)
– Client creation

SAAJ (SOAP WITH ATTACHMENT API FOR JAVA)
– Presentation
– Building SOAP messages
– Attaching parts to a SOAP message
– Managing attachments on the server side
– SOAP
handlers – Implementing handlers on the client side and on the server side

JAXM (Java API for XML Messaging)
– Presentation
– Sample application

UDDI Directory (UNIVERSAL DESCRIPTION, DISCOVERY AND INTEGRATION)

Presentation – Available directories
JAXR API (Java API for Xml Registries)
– Connection to a directory service
– Finding a web service
– Registering a web service
Other alternatives: ebXML
Frameworks available for the implementation of a web service ‘phone book

Security of web services

Threats and concerns
Interaction levels (transport, messages, application)
JEE security mechanisms: mapping, authentication
Message security (Standards):
– WS-Security
– WS-Trust
– WS-Policy
– WS-Secure Conversation
– WS-Security Policy
– XML Digital Signatures
– XML Encryption
– SAML

Duration

5 days

Price

£ 2785

Audience

Java / JEE Developers – Project Managers

Prerequisites

Knowledge of Java and Servlets – Basic web programming

Reference

JAV566-F

Sessions

JPA EclipseLink

Goals

- Effectively manage data persistence

- Master the mechanisms of JPA

- Use of TopLink in a JEE application

Program

Introduction

Architecture of a JEE application
Contributions of Java 5 (annotations)
Java persistence techniques
Object-relational mapping
Existing frameworks (Hibernate, TopLink, EJB)
Presentation of JPA (Java Persistence API)
Integration of the JPA layer in a JEE application
TopLink implementation of JPA

Persistence with JPA / TopLink

Implementing a persistent class
Object-relational mapping using annotations
Configuration properties
JPA persistence engine (TopLink)
Queries (JPQL / EJB QL) and saving a persistent object

Object-relational mapping

Contributions of mapping with JPA
Development: Beans, serialization, associations
Mapping of classes: id and properties
Mapping of associations (embedded, one-to-one, one-to-many, …)
Mapping of inheritance

Handling persistent objects

Loading (reading techniques, strategies)
CRUD operations: insertion, reading, updating and deletion
Lifecycle of persistent objects
Synchronization with the database (flushing)
Persistence cascade (write)

JPQL / EJB QL

Language
overview Query queries and data operations
Subqueries and predicates
Queries with joins
Projections with JPQL / EJB QL and dynamic instantiation
Queries on sets

Advanced mapping concepts

Insertion / modification control
Mapping of classes and properties (composite keys, multi-tables)
Mapping of associations (list map, many-to-many)

Transactions and competition

Requirements
ACID Properties
Transaction Management (JTA)
Locking Techniques
Application Example

Duration

3 days

Price

£ 1700

Audience

All

Prerequisites

Knowledge of Java, SQL, XML (optional)

Reference

JAV223-F

Sessions

JPA Hibernate : Advanced

Goals

- Optimize the persistence layer of a Java EE / JPA / Hibernate application

Program

JPA Hibernate recalls

Structure of a JPA / Hibernate project
Mapping of entities and management of collections
Mapping of inheritance
Management of concurrency
Objects and Dao available

Workshop: Setting up the environment, presentation of the global JSP / Hibernate project

Master the object query language (JPQL / HQL)

Hibernate Query Language: presentation, functionalities
Basic selections, filters
Complex joins
Aggregation, string functions, …
Management of Lazy loads
Native SQL queries

Workshop: Realization of complex requests

Advanced elements of Hibernate

Entity lifecycle and validation
Interceptors, Event-listeners
Advanced configuration: performance and functionalities
Using the level 2 cache
Inversion of control with Spring ORM

Workshop: Cache management and Spring / Hibernate cohabitation

Duration

5 days

Price

£ 2300

Audience

Java SE / Java EE developers

Prerequisites

Mastery of object-oriented programming in JAVA – Notions of SQL

Reference

JAV100224-F

Sessions

JPA Hibernate : Initiation + Advanced

Goals

- Implement a powerful persistence layer with JPA / Hibernate

Program

Discover JPA Hibernate

JDBC reminders and DAO (Data Access Object) pattern
ORM (Object Relational Mapping ) frameworks:
JPA (Java Persistence API) contributions: specification,
Hibernate implementations : history, versions, functionalities
Dependencies, references
Global configuration of the project
Architecture of Hibernate objects / JPA equivalents

Workshop: Setting up the environment, creating an application using JPA / Hibernate, global configuration file

Carry out the mapping of entities and operations

Mapping tables and management of primary keys (simple, compound)
Mapping types of bases, column properties
Managing competition: optimistic (versioning), pessimistic
Relationship Management: OneToMany / ManyToOne, OneToOne, ManyToMany
Setting waterfalls
Collections Management : Map, Set, List, …
Inheritance mapping
Loading strategies: Lazy or Eager
Named queries
Management of stored procedures
Retrieving the Hibernate session and querying / modifying
available Dao data and essential methods

Workshop: Realization of a global mapping diagram of a database, CRUD operations (Create Read Update Delete)

Master the object query language (JPQL / HQL)

Hibernate Query Language: presentation, functionalities
Basic selections, filters
Complex joins
Aggregation, string functions, …
Management of Lazy loads
Native SQL queries

Workshop: Realization of complex requests

Advanced elements of Hibernate

Entity lifecycle and validation
Interceptors, Event-listeners
Advanced configuration: performance and functionalities
Using the level 2 cache
Inversion of control with Spring ORM

Workshop: Cache management and Spring / Hibernate cohabitation

Duration

5 days

Price

£ 2310

Audience

Java SE / Java EE developers

Prerequisites

Mastery of object-oriented programming in JAVA - Notions of SQL

Reference

JAV100222-F

Sessions

JPA Hibernate : Initiation

Goals

- Implement a powerful persistence layer with JPA / Hibernate

Program

Discover JPA Hibernate

Workshop: Setting up the environment, creating an application using JPA / Hibernate, global configuration file

Carry out the mapping of entities and operations

Workshop: Realization of a global mapping diagram of a database, CRUD operations (Create Read Update Delete)

Query the database

Hibernate Query Language: presentation, functionalities
Basic selections, filters
Joins
Native SQL queries

Workshop: Writing complex queries

Duration

3 days

Price

£ 1600

Audience

All

Prerequisites

Mastery of object-oriented programming in JAVA – Notions of SQL

Reference

JAV100223-F

Sessions

Struts 2 + Hibernate + Spring

Goals

- Build robust JEE applications based on Struts 2, Hibernate and Spring

Program

Introduction

Structure of a JEE web application
Principle of MVC and MVC 2 architectures Contribution of MVC 2
frameworks and positioning of Struts 2
Implementation of Struts 2
Organization of data access (Relational-Object Mapping – ORM)
Hibernate: principle , versions, implementation The inversion of control by injection of
Spring Ioc dependencies : concepts, implementation, structure of configuration files
Structure of a web project combining the 3 frameworks

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Struts2 / Hibernate3 / Spring Ioc project

Struts 2

Implementation of actions
Management of forms
Validation of forms and advanced interactions
Taglibs Struts
Management of types and conversions
Additional configuration of Struts
Messages and internationalization
Development of interceptors
Use of Ajax
Templating: principle, implementation

Practical workshop: Building a complete management application

Hibernate 3

Configuration of object relational mapping (XML or annotations)
Management of unique identifier
Relations between objects: OneToOne, OneToMany, ManyToOne, ManyToMany
Strategies for loading collections (lazy / eager loading)
Management of object inheritance
HQL language: syntax , use
Use of native SQL queries
Parameterized queries, sorting and paging
Transaction management
Best practices and caching

Practical workshop: accessing data and using the HQL language

Spring Ioc

Configuration of beans and instantiation of the container
Dependency injection by mutator / constructor
Control of properties
Automatic linking of beans (XML configuration / annotations)
Configuration inheritance
Assignment of collections to the properties of a bean
Access to JNDI resources: configuration of data sources, email sessions
Transaction management

Practical workshop: Multiple bean configurations and JNDI access

Duration

5 days

Price

£ 2300

Audience

All

Prerequisites

Knowledge of servlets and JSP

Reference

JAV500-F

Sessions

Struts 1

Goals

- Learn about MVC and MVC architectures 2

- Learn to use the Struts Framework 1

Program

Discover Struts 1

Principle of MVC and MVC 2 architectures
Overview of MVC2 frameworks: Struts, JSF, …
Struts 1: presentation, architecture, version
Development environment, plugins, JEE application server

Workshop: Installation of the development environment

Set up Struts 1

Struts 1 project: libraries and dependencies
Log management
Configuration of the ActionServlet in the web.xml
Configuration of Struts taglibs Configuration
file struts-config.xml
Action-Model-Vue flow and configuration

Workshop: Creation and execution of a Struts 1 project

Define actions and manage forms

Struts 1 actions: types, implementation
Management of parameters, return values
Mapping of actions: results, parameters
Management of errors
Panorama of form tags
Integration of forms: ActionForm and mapping
Validation of forms
Management of error messages
Dynaforms (beans dynamics)
Upload
management Download management
Properties files and internationalization of views (i18n)
Integration of
Panorama plugins and integration of libraries: Struts Layout

Workshop: Implementation of several forms: creation, validation, processing

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Struts-Tiles: presentation, interest
Setup: configuration (tiles-def.xml)
Model page and use
Inheritance of Tiles
Forward
Other alternatives to Tiles: Sitemesh

Workshop: Integration of templates and use

Discover Struts 2

Struts 2: presentation, contributions
Struts 1 vs Struts 2
Migration process Demonstration

Workshop: presentation of a Struts 2 application

Duration

3 days

Price

£ 1600

Audience

Java / JEE Developers

Prerequisites

Knowledge of servlets and JSP

Reference

JAV1096-F

Sessions

Struts + Hibernate

Goals

- Learn to use Struts and Hibernate frameworks

- Be able to implement a complete site with JEE

Program

Introduction

History and versions
Eclipse installation and operations
Reminders: JEE, servlets, JSP

General architecture

Principle of MVC and MVC 2 architectures
Creation of a minimal interactive site with Struts, servlets and JSP
Handling and complete implementation with Eclipse

Main elements of the framework

Form validation and advanced interactions
Use of javabeans and full access to data
The main Struts Taglibs: a simple and clear presentation code
Additional configuration of Struts

Practical workshop: a directory with Struts

Persist data

Additional Taglibs for Struts
Site Internationalization; the messages
Application of internationalization to the
Struts and Hibernate or JDO case study : cooperation and optimization

Advanced points

Additional Taglibs for Struts
Site Internationalization; the messages
Application of internationalization to the
Struts and Hibernate or JDO case study : cooperation and optimization

Introduction to Hibernate

Principle of data access (ORM)
Reminders of SQL, JDBC
Correspondences between base and Java; site configuration and
Hibernate tools for web applications and heavy applications
Adding and reading any data
The relational structure: configuration and use
Various relationships between objects: OneToOne, OneToMany, ManyToOne, ManyToMany

Practical workshop: a CMS with MySQL, Hibernate, servlets and JSP

Advanced elements of Hibernate

Complete use of Hibernate Query Language
Increase of the case study with free searches and filtering
Advanced configuration: performance and functionalities
Collection loading strategies (lazy / eager loading)
Transactions, balance sheet of concurrency
Inheritance of tables and objects
Hibernate in collaboration with Struts

Practical workshop: example of inheritance – a management mini-application

Duration

5 days

Price

£ 2300

Audience

All

Prerequisites

Knowledge of servlets and JSP

Reference

JAV112-F

Sessions

JSF 2 + JPA 2

Goals

- Build robust JEE applications based on JSF 2 and JPA 2

Program

JSF 2

MVC 2: presentation of the pattern, available frameworks
Presentation of JSF: versions, functionalities, positioning, implementations
Implementation of JSF 2 in a web application
Lifecycle of a request and presentation of the JSF taglib
Graphic components, creation of
Managed forms Beans: creation, scopes, navigation rules
Form validation: JSF validators, Bean Validation (JSR 303)
Listeners,
Language EL interceptors : presentation, expressions, implicit objects
Internationalization (i18n) in a JSF application
JSF / Ajax: asynchronous components
Facelets: presentation, layouts and custom components
JSF / Spring Ioc integration

Workshops: Creation of a complete management application integrating: forms, lists with pagination, i18n, interceptors and validations

JPA 2 (Java Persistence API)

Java persistence techniques,
JPA object-relational mapping : presentation, versions (1.0 vs 2.0), existing frameworks (Hibernate, TopLink, EJB)
Integration of the JPA layer in a JEE application
Implementation of a persistent class, use of annotations
Development : Beans, serialization, associations Mapping of classes: id and properties, associations (embedded, one-to-one, one-to-many, …), inheritance etc …
Handling of persistent objects
Loading (reading techniques , strategies: lazy, eager)
Synchronization with the database (flushing)
Persistence cascade (write)
Queries (JPQL): queries, predications, projections, joins
Transactions and concurrency
Locking techniques

Workshops: Setting up a complete data access layer in a JSF 2 web application

Duration

5 days

Price

£ 2300

Audience

Java Developers

Prerequisites

Mastery of Java, knowledge of Servlets and JSP

Reference

JAV573-F

Sessions

Apache Hadoop

Goals

- Be able to create distributed applications in Java

- Know the challenges of using Apache Hadoop

Program

Introduction

Apache Hadoop Versions, and Alternatives
Related Principles, Why Use Hadoop
Preparing Test Data

Hadoop Filesystem

Principle of data distribution
Sending, modifying, reading data
Strategic choices

Workshop: setting up data, reading, etc.

MapReduce implementation

Job creation and tasks
Robustness, resumption of jobs
Scheduling
Other examples of Hadoop applications

Workshop: a real distributed application with Hadoop

Duration

2 days

Price

£ 1275

Audience

Java Developers

Prerequisites

Have followed the in-depth Java training or have equivalent knowledge

Reference

JAV505-F

Sessions

JBoss Seam

Goals

- Master web application development with JBoss Seam

Program

Introduction

JEE: architecture and components
Contributions of MVC 2 frameworks
JSF: basic principles, implementation
EJB 3: functionalities, use
JBoss Seam: presentation, contributions and architecture
Development environment (Eclipse / SeamGen)

Practical workshop: Setting up the environment – Multiple JSF, EJB3 / JPA reminders – First Seam example

JBoss Seam Applications

Integration of components: Facelets, Seam JSF components, …
Life cycle of Seam components
Validation of inputs
Request filters
Bijection and injection of dependencies
Business process
management PageFlows management (jPDL / Drools, Eclise IDE, returns)
Test expression : the SeamTest class, the embedded runtime
Packaging and deployment

Hands-on workshop: Implementing Seam in an application – using jPDL for navigation

Contextual model

EJB 3 Stateless vs Stateful: features, performance
Scope Conversation
Competition: contexts, management, exceptions
Definition of Workspace

Practical workshop: Using workspaces

Persistence management

JEE
EJB Entity / JPA persistence APIs , Hibernate
Transactions and concurrency
Cache usage

Practical workshop: Building a data access layer

Advanced notions

Using Seam without
JavaScript / Ajax EJBs (Seam POJO) and Seam Remoting
Internationalization (i18n)
Security in a Seam application

Practical workshop: application of advanced concepts: ajax, i18n

Duration

4 days

Price

£ 2475

Audience

Java Developers

Prerequisites

Mastery of Java language, knowledge of JEE (JSF, EJB 3), AJAX

Reference

JAV509-F

Sessions

JSF + AJAX

Goals

- Learn to use JSF

- Discover the essentials of the possibilities of this Framework

- Build AJAX / JSF applications

Program

Introduction

History and versions, the different standards
Principle of a framework and other choices
Handling of the development environment and the server
Reminders: servlets, JSP, JDBC, Javabeans, XML

General architecture

Principle of MVC architectures
Setting up a project
First displays
Facelets: facing JSPs, advantages, needs
Facelets and HTML, XHTML, HTML 5

Workshop: set up a project with Tomcat and test

Presentation in JSF

Summary of taglibs
Display and blend with HTML; the on-board resources system
Internationalization of a site
Display organization: panels, tables
Display organization: the layout system

Workshop: display a home page

Return any content (except HTML)

JavaBeans

Setting up JavaBeans, relations between objects
Properties and initialization
Displaying information from JavaBeans
Tests and loops on data

Workshop: display of texts, numbers, lists

Interaction in the site

From one page to another: navigation and creation of functional architectures
Parameterized links and retrieval
Creation of forms
Conversions and validation: several ways of doing
Conversions and validation: tailor-made methods
Assessment of interactions

Workshop: complete and complex site with JSF

JSF, extensions and frameworks

Some libraries: MyFaces, Struts-faces, RichFaces, Ajax4Jsf
JSF in relation with other frameworks

Workshop: link the site in JSF to a database using JDBC

AJAX and JSF

Introduction to Ajax, suitability of the two models
Perform Ajax requests from JSF elements
Complete the JavaScript

Workshop: a very practical form thanks to AJAX

Duration

3 days

Price

£ 1995

Audience

All

Prerequisites

Knowledge of servlets and JSP, JavaScript (optional)

Reference

JAV221-F

Sessions

JSF (Java Server Faces)

Goals

- Learn to use JSF

- Discover the essentials of the possibilities of this Framework

Program

Introduction

History and versions, the different standards
Principle of a framework and other choices
Handling of the development environment and the server
Reminders: servlets, JSP, JDBC, Javabeans, XML

General architecture

Principle of MVC architectures
Setting up a project
First displays
Facelets: facing JSPs, advantages, needs
Facelets and HTML, XHTML, HTML 5

Workshop: set up a project with Tomcat and test

Presentation in JSF

Summary of taglibs
Display and blend with HTML; the on-board resources system
Internationalization of a site
Display organization: panels, tables
Display organization: the layout system

Workshop: display a home page

Return any content (except HTML)

JavaBeans

Setting up JavaBeans, relations between objects
Properties and initialization
Displaying information from JavaBeans
Tests and loops on data

Workshop: display of texts, numbers, lists

Interaction in the site

Workshop: complete and complex site with JSF

Duration

2 days

Price

£ 1495

Audience

All

Prerequisites

Knowledge of servlets and JSP

Reference

JAV152-F

Sessions

JSF 2 : Advanced

Goals

- Optimizing a JSF 2 application

- Coupling JSF 2 with Spring and JPA

Program

JSF 2 recalls

Principle of MVC and MVC 2 architectures
Implementation of JSF 2 in a web application
Development environment, plugins, Java EE application server

Workshop: Presentation of the complete structure of a JSF 2 application

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– JSF AJAX / jQuery tags

Workshop: Implementation of asynchronous actions and partial data loads

Coupling JSF 2 and Spring (inversion of control)

Presentation of Spring Core (IoC): interest, configuration
Dependency injection by Xml or annotations
Context retrieval and beans injection

Workshop: Coupling JSF 2 with Spring

Carry out a data mapping (JPA)

Java persistence techniques,
JPA object-relational mapping : presentation, versions (1.0 vs 2.0), existing frameworks (Hibernate, EclipseLink, EJB)
Integration of the JPA layer in a JEE application
Implementation of a persistent class, use of annotations
Development : Beans, serialization, associations Mapping of classes: id and properties, associations (embedded, one-to-one, one-to-many, …), inheritance etc …
Handling of persistent objects
Loading (reading techniques , strategies: lazy, eager)
Synchronization with the database (flushing)
Persistence cascade (write)
Queries (JPQL): queries, predications, projections, joins
Transactions and concurrency
Locking techniques

Workshops: Setting up a complete data access layer in a JSF 2 web application

Duration

2 days

Price

£ 1250

Audience

Java Developers

Prerequisites

Have taken the JSF 2 Initiation course or equivalent concepts

Reference

JAV100218-F

Sessions

JSF 2 : Initiation + Advanced

Goals

- Building robust JEE applications based on JSF 2

Program

Discover JSF 2

Principle of MVC and MVC 2 architectures
Overview of MVC2 frameworks: Struts, JSF, Spring MVC
Presentation of JSF: versions, functionalities, positioning, implementations
Implementation of JSF 2 in a web application
Development environment, plugins, Java application server EE

Workshop: Installation of the development environment

Set up JSF 2

JSF 2 project: libraries and dependencies
Log management
Configuration of the filter in the web.xml
Configuration of JSF 2 taglibs
file faces-config.xml
MVC chaining in JSF 2

Workshop: Creation and execution of a JSF 2 project

Process forms

Lifecycle of a request and presentation of the JSF taglib
Graphic components, creation of
Managed Beans forms : creation, scopes, navigation rules
Validation of forms: JSF validators, Bean Validation (JSR 303)
Management of
Listeners error messages ,
Language EL interceptors : presentation, expressions, implicit objects
Internationalization (i18n) in a JSF 2 application
Error
handling Properties files and internationalization of views (i18n)
Management of types and conversions
Definition and configuration of custom interceptors Upload
management

Workshop: Implementation of several forms: creation, validation, processing

Workshop: Using the available persistence spaces

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Facelets: presentation, layouts and custom components
Setup: configuration
Model page and use
Sitemesh: an alternative to Facelets

Workshop: Integration of templates and use

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– JSF AJAX / jQuery tags

Workshop: Implementation of asynchronous actions and partial data loads

Coupling JSF and Spring (inversion of control)

Presentation of Spring Core (IoC): interest, configuration
Dependency injection by Xml or annotations
Context retrieval and beans injection

Workshop: Coupling JSF with Spring

Carry out a data mapping (JPA)

Workshops: Setting up a complete data access layer in a JSF 2 web application

Duration

5 days

Price

£ 2695

Audience

Java Developers

Prerequisites

Proficient in Java

Reference

JAV100216-F

Sessions

JSF 2 : Initiation

Goals

- Building robust JEE applications based on JSF 2

Program

Discover JSF 2

Workshop: Installation of the development environment

Set up JSF 2

JSF 2 project: libraries and dependencies
Log management
Configuration of the filter in the web.xml
Configuration of JSF 2 taglibs
file faces-config.xml
MVC chaining in JSF 2

Workshop: Creation and execution of a JSF 2 project

Process forms

Workshop: Using the available persistence spaces

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Facelets: presentation, layouts and custom components
Setup: configuration
Model page and use
Sitemesh: an alternative to Facelets

Workshop: Integration of templates and use

Duration

3 days

Price

£ 1875

Audience

Java Developers

Prerequisites

Proficient in Java

Reference

JAV100217-F

Sessions

Struts 2: Initiation + Advanced

Goals

- Discover the MVC and MVC architectures 2

- Learn to use the Struts Framework

Program

Discover Struts 2

Principle of MVC and MVC 2 architectures
Overview of MVC2 frameworks: Struts, JSF, Spring MVC
Struts 2: presentation / history, architecture, version
Development environment, plugins, JEE application server

Workshop: Installation of the development environment

Set up Struts 2

Struts 2 project: libraries and dependencies
Log management
Configuration of the Struts 2 filter in the web.xml
Configuration of Struts taglibs
struts.xml file: structure, inclusions, constants, packages, actions
Sequence Action-Model-Vue and configuration

Workshop: Creation and execution of a Struts 2 project

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Define actions and manage forms

Struts 2 actions: types, implementation, constants
Management of parameters, return values
Mapping of actions by Xml
Mapping of actions by annotations
Dynamic management of the mapping
Types of results: dispatcher, redirect, redirectAction, chain, stream, …
Management of errors
Access to resources: request, response, context
Panorama of form tags
Integration of forms
Validation of forms
Management of error messages
Properties files and internationalization of views (i18n)
Management of types and conversions
Definition and configuration of custom interceptors
Management of the upload

Workshop: Implementation of several forms: creation, validation, processing

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– The Stream result action
– Struts AJAX / jQuery tags

Workshop: Implementation of asynchronous actions and partial data loads

Use templates

Struts-Tiles: presentation, interest
Setup: configuration
Page model and use
Legacy of Tiles
Forward
Sitemesh: an alternative to Tiles

Workshop: Integration of templates and use

Coupling Struts and Spring (inversion of control)

Presentation of Spring Core (IoC): interest, configuration
Dependency injection by Xml or annotations
Context retrieval and beans injection

Workshop: Coupling Struts with Spring

Carry out a data mapping (JPA)

JPA: presentation, interest, implementations
Configuration of persistence in a Struts project
Mapping of entities
Queries and processing of results
Optimizations

Workshop: Implementing a DAO layer with JPA / Hibernate or JPA / EclipseLink

Duration

5 days

Price

£ 2695

Audience

Java / JEE Developers

Prerequisites

Knowledge of servlets and JSP

Reference

JAV100215-F

Sessions

Struts 2: Advanced

Goals

- Mastering Struts 2

- Coupling Struts with other APIs: Spring, JPA

Program

Struts 2 reminders

Principle of MVC and MVC 2 architectures
Actions and management of forms
Data persistence
Use of templates

Workshop: Installation of the development environment – presentation of the structure of a complete project

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– The Stream result action
– Struts AJAX / jQuery tags

Workshop: Implementation of asynchronous actions and partial data loads

Coupling Struts and Spring (inversion of control)

Presentation of Spring Core (IoC): interest, configuration
Dependency injection by Xml or annotations
Context retrieval and beans injection

Workshop: Coupling Struts with Spring

Carry out a data mapping (JPA)

JPA: presentation, interest, implementations
Configuration of persistence in a Struts project
Mapping of entities
Queries and processing of results
Optimizations

Workshop: Implementing a DAO layer with JPA / Hibernate or JPA / EclipseLink

Use templates

Struts-Tiles: presentation, interest
Setup: configuration
Page model and use
Legacy of Tiles
Forward
Sitemesh: an alternative to Tiles

Workshop: Integration of templates and use

Duration

2 days

Price

£ 1250

Audience

Java / JEE Developers

Prerequisites

Have followed the Struts 2 Initiation course or equivalent concepts

Reference

JAV100214-F

Sessions

Struts 2: Initiation

Goals

- Discover the MVC and MVC architectures 2

- Learn to use the Struts Framework

Program

Discover Struts 2

Workshop: Installation of the development environment

Set up Struts 2

Workshop: Creation and execution of a Struts 2 project

Define actions and manage forms

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Struts-Tiles: presentation, interest
Setup: configuration
Page model and use
Legacy of Tiles
Forward
Sitemesh: an alternative to Tiles

Workshop: Integration of templates and use

Duration

3 days

Price

£ 1875

Audience

Java / JEE Developers

Prerequisites

Knowledge of servlets and JSP

Reference

JAV149-F

Sessions

Spring MVC + EJB 3

Goals

- Build robust JEE applications based on Spring MVC and EJB 3

Program

Introduction

Structure of a JEE web application
Principle of MVC and MVC 2
Spring architectures : presentation, building
blocks of Spring Ioc bases : concepts, implementation, structure of configuration files Contribution
of MVC 2 frameworks and positioning of Spring MVC
Implementation of Spring MVC
Organization of data access (Relational-Object Mapping – ORM)

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Spring MVC project

Spring Ioc

Practical workshop: Multiple bean configurations and JNDI access

Spring MVC

Implementation of actions
Management of forms
Validation of forms and advanced interactions
Taglibs Spring
Management of types and conversions
Messages and internationalization
Development of interceptors
Use of Ajax
Templating: principle, implementation

Practical workshop: Building a complete management application

EJB3

Presentation of EJBs: history and versions
Life cycle of EJBs
Application servers: JBoss, GlassFish, WebSphere, …
Structure of a web module based on EJBs, packaging and deployment
Types of EJBs: session, entity, message-driven
EJB calls (RMI / IIOP protocol), clients (heavy / light)
The Pattern Chain of Responsibility and presentation of interceptors (bean, interface, annotations)

EJBs Session:
– Implementations (stateless, stateful)
– Access to a EJB Session: visibility (local / remote / webService), choice of access type
– Concurrent access and optimizations at the container level
– Implementation of interceptors, change of default configurations
–

Entity EJBs service timers:
– Object relational mapping, ORM specification and frameworks
– Entity EJBs: functionalities, access
– JPA (Java Persistence API) annotations
– Context / persistence unit
– Management of the state of an EJB Entity
– Relations between entity beans (associations), cascading processing
– Inheritance management: SINGLE_TABLE, TABLE_PER_CLASS, JOINED
– EJB-QL (EJB Query Language): presentation, syntax and constructions of

EJB-MDB (Message-Driven Beans) requests :
– Definition
– Architecture (MOM, message models)
– Available APIs
– Overview of server implementations

Advanced concepts

Application security: presentation of APIs, management of users and
EJB roles and web services, protocols and clients (static / dynamic, synchronous / asynchronous)

Practical workshop: Deployment of web services based on EJB3 and writing of several clients – security of a distributed application

Duration

5 days

Price

£ 2307

Audience

Java Developers

Prerequisites

Mastery of Java, knowledge of Servlets and JSP

Reference

JAV572-F

Sessions

Spring MVC + Hibernate

Goals

- Building robust JEE applications with Spring MVC and Hibernate

Program

Introduction

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Spring MVC / Hibernate3 project

Spring Ioc

Practical workshop: Multiple bean configurations and JNDI access

Spring MVC

Practical workshop: Building a complete management application

Hibernate 3

Practical workshop: accessing data and using the HQL language

Duration

5 days

Price

£ 2307

Audience

All

Prerequisites

Knowledge of Servlets and JSP

Reference

JAV501-F

Sessions

Spring MVC: Advanced

Goals

- Building robust Java EE applications based on Spring MVC and Spring ORM

- Implementing REST web services

Program

Discover Spring MVC

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Spring MVC project

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– Specific tags

Workshop: Implementation of asynchronous actions and partial data loads

Implement REST web services

REST architecture: operation, HTTP methods
Spring RestController: annotations, mappings
Return of
interceptor objects and security
Writing REST clients

Workshop: REST web services with @RestController

Perform a data mapping with Spring ORM

Java persistence techniques,
JPA object-relational mapping : presentation, versions (1.0 vs 2.0), existing frameworks (Hibernate, EclipseLink, EJB)
Integration of the JPA layer in a Java EE application
Implementation of a persistent class, use of annotations
Development: Beans, serialization, associations Mapping of classes: id and properties, associations (embedded, one-to-one, one-to-many, …), inheritance etc …
Handling of persistent objects
Loading (techniques of reading, strategies: lazy, eager)
Synchronization with the database (flushing)
Persistence cascade (writing)
Queries (JPQL): queries, predications, projections, joins
Transactions and competition
Locking techniques

Workshops: Setting up a complete data access layer in a Spring MVC web application

Duration

2 days

Price

£ 1070

Audience

Java EE Developers

Prerequisites

Have taken Spring MVC Initiation training or equivalent concepts

Reference

JAV100221-F

Sessions

Spring MVC: Initiation

Goals

- Building robust Java EE applications based on Spring MVC

Program

Discover Spring MVC

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Spring MVC project

Configure beans

Beans configuration and dependency injection
Control of properties
Configuration inheritance
Assigning collections to the properties of a bean
Access to JNDI resources: configuration of data sources, email sessions

Practical workshop: Multiple bean configurations

Implement controllers

Lifecycle of a request and presentation of the Spring taglib
Graphic components, creation of forms
Spring MVC controllers: creation, mapping of actions
Validation of forms: JSF validators, Bean Validation (JSR 303)
Management of error messages
Listeners, Interceptors
Language EL: presentation, expressions, implicit objects
Internationalization (i18n) in a Spring MVC application
Error
handling Type and conversion management
Definition and configuration of custom interceptors Upload
management

Workshop: Implementation of several forms: creation, validation, processing

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Presentation of templating solutions, layouts and custom components
Setup: configuration
Model page and use

Workshop: Integration of templates and use

Duration

3 days

Price

£ 1605

Audience

Java Developers

Prerequisites

Mastery of Java, knowledge of Servlets and JSP

Reference

JAV100220-F

Sessions

Spring MVC: Initiation + Advanced

Goals

- Building robust Java EE applications based on Spring MVC and Spring ORM

- Implementing REST web services

Program

Discover Spring MVC

Practical workshop: installation of the development and execution environment – construction of the minimal structure of a Spring MVC project

Configure beans

Implement controllers

Persist data

Persistence spaces: page, request, session, application Session
handling: adding and retrieving attributes
Defining and using application variables
Creating and retrieving cookies

Workshop: Using the available persistence spaces

Use templates

Presentation of templating solutions, layouts and custom components
Setup: configuration
Model page and use

Workshop: Integration of templates and use

Optimize page loading

Management of page loading
Asynchronous requests:
– Communication (XMLHttpRequest object)
– Sending / processing of the response
– Specific tags

Workshop: Implementation of asynchronous actions and partial data loads

Implement REST web services

REST architecture: operation, HTTP methods
Spring RestController: annotations, mappings
Return of
interceptor objects and security
Writing REST clients

Workshop: REST web services with @RestController

Perform a data mapping with Spring ORM

Java persistence techniques,
JPA object-relational mapping : presentation, versions (1.0 vs 2.0), existing frameworks (Hibernate, EclipseLink, EJB)
Integration of the JPA layer in a Java EE application
Implementation of a persistent class, use of annotations
Development: Beans, serialization, associations Mapping of classes: id and properties, associations (embedded, one-to-one, one-to-many, …), inheritance etc …
Handling of persistent objects
Loading (techniques of reading, strategies: lazy, eager)
Synchronization with the database (flushing)
Persistence cascade (writing)
Queries (JPQL): queries, predications, projections, joins
Transactions and competition
Locking techniques

Workshops: Setting up a complete data access layer in a Spring MVC web application

Duration

5 days

Price

£ 2564

Audience

Java Developers

Prerequisites

Mastery of Java, knowledge of Servlets and JSP

Reference

JAV100219-F

Sessions

Spring Security

Goals

- Building Secure Java EE Applications with Spring Security

Program

Discover Spring Security

Security aspects in a Java EE
Spring Security application: presentation, functions
Framework architecture
Dependencies, configuration (XML or annotations)

Implement authentication with Spring Security

Authentication mechanisms (authenticationProvider):
– users in memory
– link to a database
– link to an LDAP directory
Login / logout pages
Spring objects: SecurityContext, Authentication

Configure roles and manage permissions

Implementation of web filters:
– main filters
– Basic vs Digest authentication
– Implementation of a Remember Me
– anonymous authentications Session
management: information, concurrency
Authorization management:
– on requests
– on objects and methods
– by role and by authentication type

Guard against attacks

Integration with the Servlet API
Password encoding
Localization of
Taglib Spring Security
Injection messages in a test context
Securing WebSockets
Management of CSRF (Cross Site Request Forgery) attacks
Configuration of http response headers: security, cache

Spring Data MongoDB

Relational model vs document-oriented model (NoSQL)
MongoDB: presentation, functionalities, configuration
MangoDB infrastructure: definition, optimization
Mongo repositories
Inserting and modifying
Spring data MongoDB data: principle, functionalities
MongoDB – Spring coupling: dependencies, configuration
Queries and results processing
Management errors

Duration

2 days

Price

£ 1241

Audience

Java EE Developers

Prerequisites

Master object-oriented programming in Java

Reference

JAV100309-F

Sessions

Spring Batch

Goals

- Process data in batches with Spring Batch

Program

Understand batch data processing

Batch processing: principle and objectives, Java EE 7 standard
Batch processing implementations; Quartz, scripts, Spring Batch
Spring Batch: presentation, functionalities
Dependencies with Spring
Associated tools
Global architecture: Job, Step, Parameter
Fundamental objects of the framework (Executer, Launcher, Repository)
Installation and configuration of Spring Batch

Implement and configure batches

Basic classes and interfaces
Job structure and sequence of steps
Implementation techniques
Reading, transforming and writing data (LTE); readers, processors, writers
Development of specific implementations
Access to data for batch processing
DAOs and templates provided by Spring Framework
Exception management and recovery after errors
Transaction management (job, step)
Batch historization: JobRepository, schema, interactions

Launch batches

Batch execution parameters
Available classes
Asynchronous batch launch

Duration

2 days

Price

£ 1241

Audience

Java EE Developers

Prerequisites

Master object-oriented programming in Java

Reference

JAV100310-F

Sessions

Spring Data

Goals

- Integrate different Spring Data modules into a Java SE / EE application

Program

Discover Spring Data

Galaxie Spring
Contribution of Spring Core
Spring Data: principle, features
Panorama of Spring Data modules:
– Main modules: Commons, Gemfire, JPA, JDBC, KeyValue, LDAP, MongoDB, REST, Redis, Cassandra, Solr
– Community modules: Aerospike, ArangoDB , Couchbase, Azure DocumentDB, DynamoDB, Elasticsearch, Hazelcast, Jest, Neo4j, Vault
– Others: JDBC Extensions, Spring for Apache Hadoop, Content
Environment installation and dependency configuration

Implement a persistence layer with Spring Data JDBC

JDBC
Pattern DAO (Data Access Object) reminders
Spring Data JDBC: inputs, dependencies, configuration
Spring DAO input (JdbcTemplate)
Configuration of data sources and access to JNDI resources
Writing queries
Processing results
Managing transactions
Managing errors

Coupling an ORM framework with Spring Data JPA

Object Relational Mapping (ORM): principle, JPA (Java Persistence API) standard JPA
implementations: Hibernate, EclipseLink, OpenJPA, …
Implementation of JPA / Hibernate in a project: dependencies, configuration
Mapping of entities: keys, fields , association, inheritance
EntityManagerFactory, EntityManager, EntityTransaction, … Objects
Spring Data JPA: principle, contributions
Transposition of the configuration of the persistence unit in Spring Data JPA
Presentation of the available DAOs
Writing of requests and exploitation of results
Management of transactions by annotations
Exception management

Spring Data LDAP

LDAP: directory principle,
Spring structure LDAP: principle, contributions
Management of access to an LDAP directory
Spring Data LDAP: data integration with Spring LDAP
Manipulation of the directory and recovery of Java objects
Error management

Spring Data MongoDB

Duration

3 days

Price

£ 1840

Audience

Java EE Developers

Prerequisites

-Master object-oriented programming in Java
- Notions of SQL
- Notions of Spring Core

Reference

JAV100312-F

Sessions

Microservices Architecture with Spring Boot

Goals

- Master the use of Spring Boot for building web services

Program

Discover Spring Boot

Galaxie Spring: presentation,
Spring Core contributions : inversion of control and injection of
Spring Boot dependencies : principle, functionalities, prerequisites
Creation of a project with Spring Initializr
Integration with Maven
Structure of a Spring Boot application: standalone, webapp
The starters , Auto-configuration
Presentation of Spring CLI
Setting up the environment
Running a Spring Boot application via Spring CLI, via STS or Maven
Workshop: Installation of the IDE (Eclipse STS), definition of projects and use of starters

Configure Spring Boot

Options for configuration (.properties vs YAML)
ASCII banner
Default properties
Automatic start
Debug, Configuration of traces
Management of hot reloading
Persistence of sessions between restarts
Workshop: configuration of projects (.properties) and management of reloading

Mapping entities with Spring Data JPA

JPA: presentation, contributions
Available Providers: Hibernate, Eclipse Link
Configuration of Spring Boot properties
Mapping of entities
Mapping of properties: primary keys, column
Concurrency management: version, lock
Mapping of relations: OneToMany / ManyToOne, OneToOne, ManyToMany
Management of loading collections: lazy vs eager
Inheritance management: strategies, workshop implementation
: mapping of several physical data models

Implement queries on database data

Creation of data access classes: @Repository
Learning the JPA-QL language
Implementation of personalized requests
Use of stored procedures
Organization of application layers: presentation / services / data access
Workshop: Implementation of a complete persistence layer

Develop micro-services with Spring Web

Use of RestController
Parameter and mapping
management Return type
management Error management
Web service documentation

Workshop: Writing micro-services with Spring web

Secure a web service

Header data
management Security
management with Spring Security User and role management.

Workshop: Spring Security Integration

Test a Spring Boot application

Test strategies, types supported
Application configuration
Mocking of application layers
Self-configured tests
Execution and reporting

Workshop: implementation and execution of tests

Put a service into production

Cache
management Log management
Deployment: packaging, execution, profiles, Spring Boot Actuator

Workshop: deployment of micro-services

Write web service clients

Jersey API
Using the client class
Managing the sending of parameters and types of returns

Workshop: implementing Java clients for a REST service

Duration

5 days

Price

£ 2975

Audience

Java EE Developers

Prerequisites

- Master object-oriented programming in Java
- Mastery Spring Core

Reference

JAV100901-F

Sessions

Spring Boot

Goals

- Master the use of Spring Boot in a Java EE application

Program

Discover Spring Boot

Galaxie Spring: presentation,
Spring Core contributions : inversion of control and injection of dependencies
Spring Boot: principle, functionalities, prerequisites
Creation of a project with Spring Initializr
Integration with Maven
Structure of a Spring Boot application: standalone, webapp
The starters , Auto-configuration
Presentation of Spring CLI
Setting up the environment
Running a Spring Boot application via Spring CLI, via STS or Maven

Configure Spring Boot

Options for the configuration (.properties vs YAML)
ASCII banner
Default properties
Automatic start
Debug, Configuration of traces
Management of hot reloading
Persistence of sessions between restarts
Configuration of a Java EE application via YAML

Use Spring Boot features

Data persistence with Spring Data JPA
Security management with Spring Security
REST web services support
Planning
Cache
management Log management
Deployment: packaging, execution, profiles, Spring Boot Actuator

Test a Spring Boot application

Test strategies, types supported
Application configuration
Mocking of application layers
Self-configured tests
Execution and reporting

Duration

2 days

Price

£ 1412

Audience

Java EE Developers

Prerequisites

- Master object-oriented programming in Java
- Mastery Spring Core

Reference

JAV100315-F

Sessions

Spring Advanced

Goals

- Use Spring in any environments in order to have an efficient architecture

- Realize a dynamic website quickly with Spring

- Ensure that this site is maintainable and efficient

Program

Introduction

Reminders of the fundamental mechanisms

Create an MVC web application (Spring MVC)

Spring MVC architecture
Implementation of actions
Management of forms
Validation of forms and advanced interactions
Taglibs Spring
Management of types and conversions
Messages and internationalization
Development of interceptors
Use of Ajax
Templating: principle, implementation

Workshop: Building a management application

Discover other Spring APIs

Spring Security: management of authentication and authorizations
Spring Remoting: remote access, WebServices
Spring JMS: management of
Spring JMX messages : administration

Workshop: Using advanced APIs

Duration

2 days

Price

£ 963

Audience

All

Prerequisites

Have followed the "Spring Initiation" training or have equivalent knowledge

Reference

JAV279-F

Sessions

Spring Initiation

Goals

- Build a dynamic website quickly with Spring

Program

Discover the Spring galaxy

Inversion Of Control (dependency injection)
Role of a light container, frameworks available
Presentation of Spring, versions, uses
Panorama of the different bricks: Core, Web, ORM, AOP, …
Setting up the environment, necessary libraries

Workshop: Installation of the environment (Spring STS) and configuration of a Spring project

Configure beans, inject dependencies (Spring Core)

Workshop: Multiple creations and configurations of beans, instantiations

Perform tests

JUnit unit tests, Mocks
Configuration by announcements
Execution, reports

Workshop: Implementation of Spring JUnit unit tests

Set up Spring in the data access layer (Spring DAO, Spring ORM)

Reminders of JDBC and Pattern DAO (Data Access Object)
Contribution of Spring DAO (JdbcTemplate)
Configuration of data sources and access to JNDI resources
Coupling of Spring with ORM frameworks
Transaction management by annotations

Workshop: Spring DAO implementation, Spring / JPA-Hibernate coupling

Duration

3 days

Price

£ 1605

Audience

All

Prerequisites

Knowledge of servlets and JSP

Reference

JAV280-F

Sessions

Spring Initiation + Advanced

Goals

- Use Spring in any environments in order to have an efficient architecture

- Realize a dynamic website quickly with Spring

- Ensure that this site is maintainable and efficient

Program

Discover the Spring galaxy

Workshop: Installation of the environment (Spring STS) and configuration of a Spring project

Configure beans, inject dependencies (Spring Core)

Workshop: Multiple creations and configurations of beans, instantiations

Perform tests

JUnit unit tests, Mocks
Configuration by announcements
Execution, reports

Workshop: Implementation of Spring JUnit unit tests

Set up Spring in the data access layer (Spring DAO, Spring ORM)

Workshop: Spring DAO implementation, Spring / JPA-Hibernate coupling

Create an MVC web application (Spring MVC)

Workshop: Building a management application

Discover other Spring APIs

Spring Security: management of authentication and authorizations
Spring Remoting: remote access, WebServices
Spring JMS: management of
Spring JMX messages : administration

Workshop: Using advanced APIs

Duration

5 days

Price

£ 2307

Audience

All

Prerequisites

Mastery of object programming in Java - Web concepts

Reference

JAV278-F

Sessions

We tackled all the necessary themes that allow us to be autonomous. The trainer oriented the examples well in relation to my expressed needs.

Trainer: Very educator, very welcome

Trainer: Excellent

We tackled all the necessary themes that allow us to be autonomous. The trainer oriented the examples well in relation to my expressed needs.

Trainer: Very educator, very welcome

Java EE 7 : Web applications

Goals

- Discover and implement what's new in Java EE 7

Program

Discover JEE 7

Enterprise application architecture
Java EE 7 specification: new features, evolutions
JEE 7 servers

Workshop: Installation of the development environment: IDE, application server, database server

Use new features

Batch Applications: process manipulations Batch
Java API for JSON: main interfaces, creation / parsing of
Java API for WebSocket flows : presentation, communication, creation of EndPoints
Concurrency Utilities: Executors, Thread Pooling

Workshop: Implementing WebSocket – Using the JSON API – creating tasks

Develop REST web services (JAX-RS 2.0)

Web services: architectures (SOAP / RESTful)
Java API for RESTful Web Services 2.0: API and annotations, implementation
Creation of a web service client
Processing of a JSON response

Workshop: Implementation of RESTful web services and queries

Implement message-oriented communication (JMS 2.0)

Asynchronous communication and JMS
EJB MD and JMS 2.0 new features
Sending JMS messages to a topic or a queue
Consuming messages

Workshop: Implementation of sending and consuming JMS messages

Master the use of the EL 3.0 expression language

JSP 2.2: specification, new features
New EL 3.0 operators
Static elements and method references
Custom converters
Lambda expressions
Building and operations on collections

Workshop: Multiple examples of using EL 3.0

Discover the updates in JEE 7

Servlet 3.1: asynchronous request (Non-blocking I / O), HttpUpgradeHandler interfaces, WebConnection, security,
JPA 2.1 reset : callback, converters, update / delete criteria, stored procedures, EntityListeners, …
EJB 3.2: evolution, types, communication asynchronous,
CDI 1.1 timers : dependency injection, scopes, interceptors, decorators
JSF 2.2: HTML5 support, multi-templating, Faces Flows, Stateless views

Lab: EJB Lite component implementation – database mapping (JPA) – JSF views implementation

Duration

5 days

Price

£ 2050

Audience

Java / JEE developers, architects

Prerequisites

Mastery of the object in Java - knowledge of JSP and Servlet

Reference

JAV830-F

Sessions

Java EE 6 : Architecture of an application

Goals

- Discover the new features of JEE 6 - Successfully migrate to JEE 6

Program

JEE6

Overview of JEE’s contributions 6
Cost of migration: project, learning, constraints

EJB 3.1 contributions

Organization of the
EJB Singleton
EJB Lite interfaces
Simplification of the packaging
New in the Timer Service
JNDI naming
EJB invocations: asynchronous, without container

JavaBeans Validation

Presentation of the
Panorama API of available tags
Customization of error messages

JPA 2.0 contributions

Advanced support for collections (map)
Management of compound keys and sequences
Management of aggregations (nested embeddable)
Mapping of collections (Basic, Embeddable) and sorts (OrderColumn)
OneToMany Undirectionel
Automatic deletion of objects removed from relationships (Orphan removal)
Locks on objects (Pessimistic Locking)
Changes to the EntityManager API
Using the Cache API
Using properties to configure the
Criterias persistence unit
What’s new in JPQL

Introduction to REST Web Services

REST architecture: presentation, components and characteristics
The JAX-RS API, JSR-311
JAX-RS vs JAX-WS
Contexts of use
REST service implementation, description (WADL) and deployment
Implementation of a REST service client
Advanced concepts : exceptions, selections, context, security

Duration

2 days

Price

£ 1091

Audience

Java / JEE Developers

Prerequisites

Mastery of Java, Notions of Servlet / JSP, MVC frameworks and data persistence

Reference

JAV569-F

Sessions

EJB 3 Initiation + Advanced

Goals

- Master the development of EJB 3 - Manage the performance of a distributed application

- Set up a complete JEE architecture

Program

Introduction

JEE specifications: components, containers
Principle of n-tier architectures (distributed applications), solutions
Annotations
Presentation of EJBs: history and versions
Life cycle of EJBs
Application servers: JBoss, GlassFish, WebSphere, …

Setting up

Choice of the development environment (Eclipse / Netbeans), available plugins
Installation of the runtime environment, specific contributions to each container
Structure of a web module based on EJBs, packaging and deployment
Reminders on servlets and JSPs (chaining, persistence in memory, …)

Practical workshop: preparation of a development / test platform – handling of the environment – multiple examples: java (annotations), servlets and jsp

EJB 3 specifications

Architecture (bean, interfaces, annotations), role of object container
EJB types: session, entity, message-driven
EJB calls (RMI / IIOP protol), clients (heavy / light)
JNDI (Java Naming and Directory Interface) and collaboration between tools (localization of resources)
The Pattern Chain of Responsibility and presentation of interceptors (bean, interface, annotations)

Practical workshop: implementation of the design pattern chain of responsibility – introduction to interceptors

EJBs Session

Definition, interaction and calculations
Available types (stateless, stateful), life cycle
Access to an EJB Session: visibility (local / remote / webService), choice of access type
Concurrent access and optimizations at the container level
Implementation of interceptors, change of default configurations
Timers services

Practical workshop: implementation of several Session EJBs (stateless / stateful) + interceptor – deployment and writing of various types of clients

Entity EJBs

Object relational mapping, specification and ORM frameworks
EJBs entities: functionalities, access
JPA annotations (Java Persistence API)
Context / persistence unit
Management of the state of an EJB Entity
Relations between entity beans (associations), cascading processes
Management of the ‘inheritance: SINGLE_TABLE, TABLE_PER_CLASS, JOINED
EJB-QL (EJB Query Language): presentation, syntax and constructs of queries

Practical workshop: Development of MVC web applications with interactions between session EJBs and various Entity beans – use of the EJB-QL language

EJB-MDB (Message-Driven Beans)

Definition, Architecture (MOM, message models), APIs available
Overview of server implementations
Implementation of message exchanges (destination, sending, reception, recovery by injection)
Transaction management

Practical workshop: Setting up an application based on EJB messages, multiple exchanges and transactions

Advanced concepts

Application security: presentation of APIs, user and role management
Securing access to interfaces of EJBs
EJB and web services, protocols and clients (static / dynamic, synchronous / asynchronous)
EJB2 and EJB3: differences, choices, evolution (migration)

Practical workshop: Deployment of web services based on EJB3 and writing of several clients – security of a distributed application

Duration

5 days

Price

£ 2307

Audience

All

Prerequisites

Knowledge of servlets and JSP - Mastery of Java language

Reference

JAV113-F

Sessions

EJB 3 Advanced

Goals

- Obtain a maintainable and efficient EJB system

- Set up a complete JEE architecture with JBoss or Glassfish

Program

Introduction

Reminders of EJB 3 specifications: architecture (bean, interfaces, annotations), role of the object container
The Pattern Chain of Responsibility and presentation of interceptors (bean, interface, annotations)

Practical workshop: implementation of the design pattern chain of responsibility – introduction to interceptors

EJBs Session

Reminder of the basics: implementation, access
Implementation of interceptors, change of default configurations
Timers services

Practical workshop: implementation of several Session EJBs (stateless / stateful) + interceptor

Entity EJBs - advanced concepts

Managing the state of an Entity EJB and concurrent access
Advanced relationships between entity beans (associations), cascading processes
Managing inheritance: SINGLE_TABLE, TABLE_PER_CLASS, JOINED
EJB-QL (EJB Query Language): presentation, syntax and constructions requests

Practical workshop: Development of MVC web applications with interactions between session EJBs and various Entity beans – use of the EJB-QL language

EJB-MDB (Message-Driven Beans)

Practical workshop: Setting up an application based on EJB messages, multiple exchanges and transactions

Advanced concepts

Practical workshop: Deployment of web services based on EJB3 and writing of several clients – security of a distributed application

Duration

2 days

Price

£ 963

Audience

All

Prerequisites

Have taken the JEE - EJB course or equivalent knowledge

Reference

JAV114-F

Sessions

EJB 3 Initiation

Goals

- Master the development of EJB 3

- Manage the performance of a distributed application

- Set up a complete JEE architecture

Program

Introduction

Setting up

Choice of the development environment (Eclipse / Netbeans), available plugins
Installation of the runtime environment, specific contributions to each container
Structure of a web module based on EJBs, packaging and deployment
Reminders on Servlets and JSPs (chaining, persistence in memory, …)

Practical workshop: preparation of a development / test platform – handling of the environment – multiple examples: java (annotations), Servlets and JSP

EJB 3 specifications

EJBs Session

Definition, interaction and calculations
Available types (stateless, stateful), lifecycle
Access to an EJB Session: visibility (local / remote / webService), choice of access type
Concurrent access and optimizations at the container level

Practical workshop: implementation of several Session EJBs (stateless / stateful) – deployment and writing of various types of clients

Entity EJBs

Object relational mapping, specification and ORM frameworks
Entity EJBs: functionalities, access
JPA annotations (Java Persistence API)
Context / persistence unit
Management of the state of an Entity EJB
Relations between entity beans (associations), cascading processes

Practical workshop: Development of MVC web applications with interactions between session EJBs and various Entity beans

Duration

3 days

Price

£ 1605

Audience

All

Prerequisites

Knowledge of servlets and JSP - Mastery of Java language

Reference

Sessions

Java EE – Servlets and JSP Initiation + Advanced

Goals

- Know how to architect and design high-performance JEE web projects based on Servlets and JSP

- Set up the MVC pattern

Program

Introduction

Development of dynamic web applications: overview of existing technologies
JEE platform: architecture, APIs and runtime environment
Servlets and JSP compared to other web services

Setting up

Development environment (Eclipse / NetBeans)
Basic elements and development optimization
Servlet and JSP engines: presentation, choice (Tomcat, GlassFish, …)
Structure of a web module; component lifecycle
Packaging and deploying a web application

Practical workshop: installation of development and execution environments; first minimal web project

Servlets

Specification and lifecycle Page
chaining: links and forms
Reminder of the interaction mechanisms and standards of the HTTP protocol
Handling of http errors and logging
Sessions, cookies and other
JDBC persistence spaces for accessing a database from a
JavaMail servlet for sending mail from a
Multi-threading form with servlets
Advanced deployment configurations

Practical workshop: creation, deployment and testing of a complete Servlet-based project including management features with access to a database, use of the session and sending emails

JSP (Java Server Pages)

General principle and comparison with Servlets
Expressions: display dynamic data in the middle of XHTML
Scriptlets – use and limits
Declarations and directives: the JSP is a class
Inclusions and reuse mechanisms
Javabeans: presentation, creation
Access and manipulation of Javabeans from JSP and Servlets
MVC model
Complete case study – Servlets and JSP in collaboration
Server memory organization
Error handling

Practical workshop: Development of web applications with an MVC architecture and an advanced presentation based on JSP

Tag libraries (Taglibs)

Overview of available taglibs
Installation, use of a
JSTL tag library (JSP Standard Tag Lib): presentation and test
The language of expressions (EL)
Definition of functions, creation of TLDs and calls from a JSP
Creation of taglibs: principle and apis available

Practical workshop: integration of taglibs in JSPs – implementation of a custom library of tags

Advanced concepts

Templating: mechanism, available
JNDI frameworks and configuration of resources (JDBC, mails, etc.) at the application server level Application
security: presentation of APIs, user and role
management Management of a web project: from analysis to test

Practical workshop: server configuration and use of JNDI resources – Using a template engine

Duration

5 days

Price

£ 2136

Audience

All

Prerequisites

Mastery of the basics of Java language and knowledge of XHTML

Reference

JAV116-F

Sessions

Java EE : Servlets and JSP Advanced

Goals

- Know how to architect and design high-performance JEE web projects based on Servlets and JSP

- Set up the MVC pattern

Program

Introduction

JEE platform: architecture, APIs and runtime environment
Reminders of Servlets and JSPs

Servlets

Sessions, cookies and other
JDBC persistence spaces for accessing a database from a
JavaMail servlet for sending mail from a form
Handling http errors and logging
Multi-threading with servlets
Advanced deployment configurations

Practical workshop: creation, deployment and testing of a complete servlet-based project including management features with access to a database, use of the session and sending emails

Advanced JSP

Javabeans: presentation, creation
Access and manipulation of Javabeans from JSP and servlets
MVC model
Complete case study – Servlets and JSP in collaboration
Server memory organization
Error management

Practical workshop: Development of web applications with an MVC architecture and an advanced presentation based on JSP

Tag libraries (Taglibs)

Overview of available taglibs
Installation, use of a
JSTL tag library (JSP Standard Tag Lib): presentation and test
The expression language (EL)
Definition of functions, creation of TLDs and calls from a JSP
Creation of taglibs: principle and apis available

Practical workshop: integration of taglibs in JSPs – implementation of a custom library of tags

Advanced concepts

Practical workshop: server configuration and use of JNDI resources – Using a template engine

Duration

2 days

Price

£ 963

Audience

All

Prerequisites

Have taken the JEE initiation course or equivalent knowledge

Reference

JAV117-F

Sessions

Java EE: Servlets and JSP Initiation

Goals

- Know how to architect and design high-performance JEE web projects based on Servlets and JSP

- Set up the MVC pattern

Program

Introduction

Development of dynamic web applications: overview of existing technologies
JEE platform: architecture, APIs and runtime environment
Servlets and JSP compared to other web services

Setting up

Practical workshop: installation of development and execution environments; first minimal web project

Servlets

Practical workshop: creation, deployment and testing of a complete servlet-based project including management features

JSP (Java Server Pages)

Practical workshop: Development of web applications with an MVC architecture

Duration

3 days

Price

£ 1391

Audience

All

Prerequisites

Mastery of the basics of Java language and knowledge of XHTML

Reference

JAV154-F

Sessions

Trainer: very available, and attentive

Well suited to my knowledge Trainer: Competent and clear

Trainer: Good adaptation to the level of each of the participants

It's good to handle throughout the course

The progress of the course is made so that we understand why we do such and such a thing, it is very good, it allows to understand well. Trainer: Patient, educator, available and explicit in his explanations. Nothing to say. And know the java language very well. Thanks to him.

Trainer: very available, and attentive

Well suited to my knowledge Trainer: Competent and clear

Java SE 8 to 12

Goals

- Master the changes brought about by the new versions of Java

- Be able to migrate code from version 8 to 12

Program

General information on release frequency and support for post Java 8 versions

History, versions
Java editions: Java SE, Java EE, Java ME
Compilation and interpretation by the JVM (Java Virtual Machine)
Java technologies / frameworks and positioning
Development environment
Packaging and deployment of a Java application

Workshop: Installation of the JDK (Java Development Kit) and an IDE (Eclipse / NetBeans) – Structure of a project, buildPath, …

See what's new in Java 9

Modularity of the JDK (JEP 200 – Jigsaw / JSR 376)
Inference of the type of variable (JEP 193)
Improvement of the use of collections (JEP 269)
New in the API of processes (JEP 202)
Depreciation management (JEP 277 )
Improvement on threads: spin-wait (JEP 285)
Variables and methods Handle (JEP 193, 274) Support of HTTP2 and WebSockets (JEP 110)
JavaScript engine: ES 6 (JEP 236, 292)
Improvements of Javadoc for the support de HTML5 (JEP 224, 225, 254)
Image support: multi-resolution (JEP 251), formats (JEP 262)
API for accessing the specifications of the OS desktop (JEP 272)
Improvements made to JavaFx
Log unification (JEP 158, 264, 271)

Use Java 10 enhancements

Variable type inference (JEP 286)
Application Class-Data Sharing (JEP 310)
Release versioning (JEP 322)
Improvements related to Garbage Collector (JEP 307, JEP 304)
JEP 319: Root Certificates
New methods in the Collectors class
New method in the Optional class
New methods in the Objects class

See what's new in Java 11

Marketing of JDK 11 by Oracle
Consequences of Long Term Support of Oracle
JDK11 of Oracle vs Open JDK 11
Use of var in lambdas
Standardization of the new HTTP client
Direct execution of a source file
Removal of JavaFX, Java EE and CORBA modules

See what's new in Java 12

Collectors: Teeing Collector Improvements on character strings File comparison Compact number formatting Unicode 11 adoption Unicode 11 preview Functions and APIs removed: Java6, finalization methods, …

Code migration from Java 8 to 12

Duration

3 days

Price

£ 1685

Audience

Java Developers

Prerequisites

Knowledge of Java object-oriented programming

Reference

JAV100684-F

Sessions

Java SE 7

Goals

- Master the evolutions brought by Java 7

Program

Introduction

Java 7: presentation, evolutions
Syntactic contributions:
– Use of strings in the switch control structure
– Operators and numeric literals
– Exception management
– …

Practical workshop: Overview of the novelties of the language

Graphical interfaces

New in Swing
Theme management (look and feel)
Appearance / transparency management
Components and JLayer

Practical workshop: Creation of a graphical application implementing the new Swing features in Java 7

File management (NIO 2)

Presentation of the new classes (java.nio.file)
Path processing
Managing access to files
Notification of changes to a file

Practical workshop: Advanced flow manipulation

Changes in JDBC 4.1

Driver loading
Improved exception
handling Using javax.sql.rowset

Practical workshop: Application of the contributions of JDBC 4.1

Advanced notions

Process management (Fork and Join)
Internationalization in Java 7
Application security and cryptography
Network programming
Class loading
Improvement of the JVM and invocation of dynamic languages

Practical workshop: Multiple examples of use

Duration

3 days

Price

£ 2785

Audience

Java Developers

Prerequisites

Knowledge of Java 5/6

Reference

JAV517-F

Sessions

Java SE / Java EE Security

Goals

- Know the security risks of a site made with JEE

- Know how to set up and maintain the security of a JEE application

Program

Why security?

Theoretical needs
Safety policy
Risk assessment
General methods

Basic commands

JDK
JVM tools Compile
Cycle

Follow-up commands

Process
Memory
Parameters
Monitoring software

JVM security

Java
security JVM security under Java
SecurityManager
Access rights of an applet

Encryption

Hash
Encryption
Asymmetric encryption
Bouncy Castle

JCE (Java Cryptography Extension)

Definition
Security provider

ACL (Access Control List)

Definition
Use

Signatures and certificates

Need
Digital signature
Certificates
Example X509
Extraction from the
JarSigner keystore

Obfuscation

Principle
Obfuscation techniques
Commercial solutions

JAAS

JAAS presentation
Definitions
Operation

Java EE authentication

JAAS
WEB and EJB security
Securing a WEB application
Securing an EJB

High availability

Presentation
The notion of cluster
Level 7 routing
Example with Apache front-end
Concept of distributed sessions and replicated sessions
Example with a cluster of Tomcat servers
Replication of EJBs in cluster mode.

Duration

2 days

Price

£ 1275

Audience

All

Prerequisites

Knowledge of Java, notions of JEE

Reference

JAV138-F

Sessions

Multi-threading and memory management in Java

Goals

- Master the implementation of multi-threading in Java

- Effectively manage concurrency and memory

Program

Implement multi-threading in Java

Notions of threads and processes
The Switching Context: operation, consequences
Parallelism and concurrent access
Java synchronization: locks, synchronized, volatile
Good synchronization practices and errors to avoid (Deadlock)
Implementation of coordination of threads
Immutability: publications, encapusulation, confinement
Synchronized collections, competing collections
Atomics
Lock, Semaphore
CountDownLatch
Pooling of threads, executors

Workshop: implementation of multi-threaded scenarios, synchronization – use of executors.

Efficiently manage memory within the JVM

JVM memory organization: stack, heap
Presentation of the garbage collector mechanism
Operation of the Garbage
Collector Generational
Garbage Collectors Garbage Collector and memory leaks
JVM configuration to optimize the memory footprint
Presentation of the JVM tools to monitor an application : jConsole, jVisualVM

Workshop: optimization of the JVM for an application – monitoring: dump and code analysis.

Duration

2 days

Price

£ 1085

Audience

Java developers and analysts

Prerequisites

Have followed the « Java initiation » course or have equivalent knowledge

Reference

JAV1065-F

Sessions

Advanced Java

Goals

- Know and master advanced language concepts

Program

Discover the new features of the language since Java 8

Permgen space disappearance Default
methods
Repeated annotations, type annotations Method references, Interface with default
methods Interface private methods Freeing
resources
CompletableFuture API
Garbage collector improvements
Modularity of the jdk

Workshop: Environment installation – functionalities demonstration – code profiling and performance improvement.

Manipulating dates

Handling dates and durations with the new time API
Weaknesses of the current library
New classes and interfaces
Technical choice between durations, instants and local dates
Management of time zones
Formatting

Workshop: Use and formatting of dates, operations on dates and durations

Master Lambda expressions and functional interfaces

Lambda expressions: definition, interest
Writing rules, declarations
Functional interface: principle, compatibility
Access to the state encompassing a lambda expression
Implementation and performance.
Evolution of the Atelier Collection API

: use of new patterns and functional interfaces introduced since Java 8

Handling collections with streams

New features
Use of Patterns for-each, replace-if, do-if-absent, do-if-present
Merging of
Stream API collections : principle, interest
Patterns for creating streams
Intermediate and terminal operations on streams
Management of specific cases: empty streams, optional
Use of parallel streams

Workshop: use of streams with different collectors – use of resources with parallel streams – use of patterns

Factorize code using genericity and reflection

Genericity: typing principle, uses
Generic classes and constraints on types
Implementation of generic methods Generic
interfaces and polymorphism
Reflection and available classes
Dynamic introspection of objects
Invocation of members of an object
Dynamic instantiation of objects

Workshop: writing generic methods to manage imports / exports and serializations of data – Patterns and genericity

Processing JavaScript

Nashorn: presentation, use case
jjs command line
JavaScript code interpretation
Calling Java code from JavaScript

Workshop: Instantiating and using the Nashorn engine, using Java objects in JavaScript – calling JavaScript functions and managing parameters

Manipulate concurrent processes and threads

Process
initiation ProcessHandle and ProcessHandle.inf
The concurrency API: different types of executors
Choice of interfaces Runnable, Future, Callable
Multithreading application and use of Lambda expressions
ComposableFuture
Asynchronous mode and timeout management
Queues and classes atomic
Thread Pool Management

Lab: Coding of scheduled tasks using executors – multitasking implementation with the use of threads and synchronization

Duration

5 days

Price

£ 2540

Audience

Java Developers

Prerequisites

Have followed the « Java initiation + deepening » course or have equivalent knowledge

Reference

JAV100573-F

Sessions

Java SE 8 + Eclipse (Advanced Use)

Goals

- Master the evolutions brought by Java 8

- Master the Eclipse environment: configuration, unit tests, version management, task automation

Program

See what's new in Java 8

JavaScript processing for Java (Nashorn)
Disappearance of permgen space
The new API for handling dates / times
Default methods
Repeated annotations, type annotations Method references
Lambdas expressions

Workshop: Multiple demonstrations of new features of the Java 8 language

Manipulating dates and durations with the new time API

Weaknesses of the current library
New classes and interfaces introduced by Java 8
Technical choice between durations, instants and local dates
Formatting

Workshop: Use and formatting of dates, operations on dates and durations

Use Lambdas Expressions in Detail

Presentation of the syntax and interests
Labdas expressions in the
Streams collections and functional interfaces

Lab: Using Lambdas expressions, flows with collections

Other developments

What’s New in JavaFX
Deploying Applications with Compact Profiles

Workshop: Running JavaScript code from a Java application, deploying applications

Discover the features of Eclipse

Environment and views
Perspectives
Properties: character encoding, JRE, servers, shortcuts, …
Launching Eclipse with different JREs
Creation and configuration of projects
IDE help, research
Addition of
Eclipse Plugins and Features and UML modeling

Workshop: Eclipse configuration, creation of projects, addition of plugins

Write, debug and test your code

Code organization, editing (opening modes)
Configuration of libraries (buildPath) and associated JavaDoc (online / archive)
Completion, access to the JavaDoc and assisted correction
Refactoring functions
Debug your code: breakpoints, variable inspection , execution stack
Unit tests with jUnit: TestCase, TestSuite, execution

Workshop: Putting into practice the different functions in an application

Interconnect Eclipse and a source repository for version management

Software configuration management (SCM): presentation, positioning, tools
GCL terminology: Branch, Tag, Checkout, Commit, Merge, …
SCM (SVN, Git, TFS): functionalities, components
Global architecture and implementation of a data repository
SCM clients, plugins for Eclipse
Perspectives, Eclipse operations, conflict management

Workshop: Version management of an application

Automate tasks with Maven

Where to use Maven? Where not to use it?
Eclipse plugins: m2Eclipse or q4e
Principle of repositories; choice of a simple physical architecture
Setting up a project, structure
Accessing the project
Building the project
User systematisms; additional actions available
Dependencies between projects
Predefined tasks: compilation, generation of archives …

Workshop: Application building with Eclipse / Maven

Passing the certification (if provided for in the funding)

Passing of the certification (if foreseen in the financing).

Duration

4 days

Price

£ 2195

Audience

Java developers

Prerequisites

Knowledge of Java object-oriented programming

Reference

JAV100261-F

Sessions

Eclipse : Advanced use

Goals

- Master the Eclipse environment: configuration, unit tests, version management, task automation

Program

Discover the functionalities

Workshop: Eclipse configuration, creation of projects, addition of plugins

Write, debug and test your code

Workshop: Putting into practice the different functions in an application

Interconnect Eclipse and a source repository for version management

Workshop: Version management of an application

Automate tasks with Maven

Workshop: Application building with Eclipse / Maven

Duration

2 days

Price

£ 1085

Audience

Java Developers

Prerequisites

Knowledge of Java

Reference

JAV769-F

Sessions

Java SE 8

Goals

- Master the changes brought by Java 8

Program

See what's new in Java 8

Workshop: Multiple demonstrations of new features of the Java 8 language

Manipulating dates and durations with the new time API

Weaknesses of the current library
New classes and interfaces introduced by Java 8
Technical choice between durations, instants and local dates
Formatting

Workshop: Use and formatting of dates, operations on dates and durations

Use Lambdas Expressions in Detail

Presentation of the syntax and interests
Labdas expressions in the
Streams collections and functional interfaces

Lab: Using Lambdas expressions, flows with collections

Other developments

What’s New in JavaFX
Deploying Applications with Compact Profiles

Workshop: Running JavaScript code from a Java application, deploying applications

Passing the certification (if provided for in the funding)

Passing of the certification (if foreseen in the financing).

Duration

2 days

Price

£ 1085

Audience

Java Developers

Prerequisites

Knowledge of Java object-oriented programming

Reference

JAV843-F

Sessions

Java Initiation: Programming as an object

Goals

- Great beginners: discover object-oriented programming through the Java language Build a first complete application

Program

Discover the Java platform

Workshop: Installation of the JDK (Java Development Kit) and an IDE (Eclipse / NetBeans) – Structure of a project, buildPath, …

Discover the development environment

Configuration
Main views, perspectives
Useful shortcuts
Using the debugger
Using the IDE to increase productivity: snippets, refactoring, automatic code generation

Master the basics

Use of variables, constants, operators
Simple types and reference types
Explicit, implicit cast, wrappers
Execution priorities
Condition expression: if / else, switch, ternary operator
Use of loops: for, while, do while Array
manipulation
Code factorization with
Overload methods , variable arguments, recursion
Comment and document code

Workshop: Multiple examples of manipulation of control structures and functions

Learn the object

Definition of classes, POJO vs JavaBean
Declaration of instance / class members (static)
Constructors and instantiation
Lifecycle of an object in memory
Class diagram (UML)
Aggregation of objects (association)
Encapsulation: getters and setters
Extension of classes (Inheritance)
Object comparison
Abstract classes
Interfaces and implementation
Polymorphism

Workshop: Modeling of problems into objects

Manage errors

Definition, types of exceptions
Catch and process an exception (try / catch / finally)
Throw / Raise an exception (throw / throws)
Create exceptions

Workshop: Managing exceptions that may be triggered in an application

Use collections

Presentation of the available API,
Comparative generics , choice of a type of collection
Essential classes: ArrayList, HashMap, … Browsing
, operations on collections and sorting

Workshop: Handling of collections of objects

Manipulate files

Binary / character
streams Reading and writing of files
Using buffers
Manipulating paths, directories, monitoring
Serialization of objects: binary, XML
Externalization of configuration in .properties
Log management: java.util.logging, Log4j

Workshop: Implementation of exports and imports from files

Use basic Git functions in Eclipse

Notions on data repository and branches
Challenges of configuration management
Check the status of the working copy: status
Index your modifications: add
Validate your modifications: commit
Pull, push and delete a remote branch

Advanced notions

Network communications
Process management
JVM options
Code optimization, genericity
Introspection (Reflection API)

Workshop: code optimization and deployments

Passing the certification (if provided for in the funding)

Passing of the certification (if foreseen in the financing).

Duration

5 days

Price

£ 2025

Audience

All

Prerequisites

Basic computer knowledge, elementary algorithmic knowledge

Reference

JAV100976-F

Sessions

Swing / MVC: creation of graphical interfaces

Goals

- Develop graphical interfaces with Swing

- Carry out unit tests for HMI

Program

Introduction

Presentation of the Java Foundation Classes:
(AWT, Swing, Java2D, DragAndDrop, Accessibility and Internationalization)
Comparison of AWT and SWING models
Reminders of the main design patterns used in Java

Swing

The fundamental bases
The MVC pattern (Model-View-Controller)
Parametrization of graphic charters (Pluggable look and feel)
Organization of graphical interfaces with event management
Construction of GUI with NetBeans

Containers

Principle
High level
containers Utility containers (general and specific)

Components (widgets)

Principle
Overview of available components
Construction of multiple graphical interfaces

Positioning management

Layouts managers: definition
The most common managers (absolute, BorderLayout, FlowLayout, GridLayout, ..)
Other managers used in WYSIWYG

Event management

Principle
Fundamental classes
Available listeners
Separation presentation / treatment
Performances
Multiple examples

Advanced concepts

Unit tests with JFC Unit
Customizations, internationalization
Print and copy management

Case study

Architecture and implementation of a complete application

Duration

3 days

Price

£ 1385

Audience

All

Prerequisites

Know the basics of Java

Reference

JAV222-F