Créé par Sun Microsystems (aujourd’hui Oracle), Java est un langage orienté objet, compilé en bytecode exécuté par la JVM (Java Virtual Machine). Cette abstraction permet aux applications Java de tourner sur n’importe quel système (Windows, Linux, macOS) sans recompilation. Les caractéristiques clés : gestion automatique de la mémoire (garbage collector), vérification stricte des types, bibliothèque standard massive (JDK). ISOSET propose des cursus complets pour maîtriser la syntaxe et les concepts avancés (génériques, streams, threads).

• JVM (Java Virtual Machine) – exécute le bytecode, offre la portabilité.
• Garbage Collector – libère automatiquement la mémoire inutilisée.
• API standard (JDK) – collections, I/O, concurrence, réseau, JDBC, etc.
• Versions LTS – Java 8, 11, 17, 21 (recommandées pour la production).

// Exemple Java moderne (record, switch expression)
public record Personne(String nom, int age) {}
public static void main(String[] args) {
    var p = new Personne("Alice", 30);
    System.out.println(switch(p.age()) {
        case 18 -> "Nouveau majeur";
        case 30 -> "Plein d'énergie";
        default -> "Âge classique";
    });
}

Java est purement orienté objet (sauf les types primitifs). Les concepts : classes, héritage (extends), polymorphisme, encapsulation et interfaces. Les collections (List, Set, Map) sont omniprésentes, avec les implémentations ArrayList, HashSet, HashMap. Depuis Java 8, l’API Stream permet des traitements déclaratifs (map‑filter‑reduce).

// Streams et lambdas
List personnes = ...;
double ageMoyen = personnes.stream()
    .filter(p -> p.age() > 18)
    .mapToInt(Personne::age)
    .average()
    .orElse(0);

ISOSET aide les équipes à adopter les bonnes pratiques de modélisation objet et d’utilisation des collections.

J2EE (Java 2 Platform, Enterprise Edition) a été renommé Java EE, puis aujourd’hui Jakarta EE (sous la fondation Eclipse). Cette plateforme définit des API pour construire des applications d’entreprise robustes, scalables et transactionnelles. Les spécifications majeures : Servlets, JSP, EJB, JPA, JTA, JMS, CDI, JAX‑RS, etc. Les serveurs d’application compatibles : WildFly, Payara, WebLogic, WebSphere, GlassFish, TomEE.

• Servlets – composants Java qui répondent à des requêtes HTTP.
• JSP (JavaServer Pages) – pages HTML dynamiques avec du code Java (aujourd’hui moins utilisé, remplacé par les templates ou les APIs REST).
• EJB (Enterprise JavaBeans) – composants métier avec gestion automatique des transactions et de la sécurité.
• JPA (Java Persistence API) – ORM pour accéder aux bases de données relationnelles.
• CDI (Contexts and Dependency Injection) – injection de dépendances standardisée.

// Exemple de Servlet (JAX‑RS)
@Path("/hello")
public class HelloResource {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String sayHello() {
        return "Hello from Jakarta EE!";
    }
}

ISOSET forme à la conception d’architectures Jakarta EE avec les bonnes pratiques d’injection et de couches métier.

Les Servlets sont des classes Java qui étendent `HttpServlet` et redéfinissent les méthodes `doGet()`, `doPost()`. Les JSP permettaient d’intégrer du code Java dans des pages HTML, mais sont aujourd’hui supplantées par les vues basées sur des templates (Facelets) ou des frameworks front‑end. Néanmoins, la base reste importante pour comprendre le fonctionnement des conteneurs web (Tomcat, Jetty).

// Servlet simple
@WebServlet("/hello")
public class BonjourServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.getWriter().print("
Bonjour depuis Servlet
");
    }
}

Les EJB (Enterprise JavaBeans) prennent en charge automatiquement les transactions, la gestion des threads et la sécurité. On distingue les Session Beans (stateless, stateful) et les Message‑Driven Beans (asynchrones). JPA (Java Persistence API) est le standard ORM : on mappe des classes Java vers des tables SQL via des annotations (`@Entity`, `@Id`, `@OneToMany`).

// Entité JPA
@Entity
@Table(name = "produits")
public class Produit {
    @Id @GeneratedValue
    private Long id;
    private String nom;
    private double prix;
    // getters/setters
}
// EJB Stateless
@Stateless
public class ProduitService {
    @PersistenceContext
    private EntityManager em;
    public Produit trouver(Long id) { return em.find(Produit.class, id); }
}

ISOSET propose des ateliers pratiques sur JPA (relations, JPQL, lazy loading) et les patterns de transaction.

La plateforme offre plusieurs mécanismes : JAAS (Java Authentication and Authorization Service), JACC (Java Authorization Contract for Containers), et l’intégration avec les serveurs d’application (fichier de configuration des rôles). Dans les architectures modernes, on utilise souvent JWT (JSON Web Tokens) avec des frameworks comme MicroProfile JWT ou Spring Security. Les anotations `@RolesAllowed`, `@PermitAll` et `@DenyAll` définissent les permissions sur les endpoints.

// Restriction d’accès avec @RolesAllowed
@Path("/admin")
@RolesAllowed("ADMIN")
public class AdminResource {
    @GET
    public String adminOnly() {
        return "Réservé aux administrateurs";
    }
}

ISOSET initie les jeunes à la cybersécurité Java via des ateliers de durcissement d’applications.

Bien que Jakarta EE soit un standard robuste, beaucoup d’entreprises adoptent Spring Framework (et Spring Boot) pour sa simplicité de configuration (auto‑configuration), son écosystème (Spring Data, Spring Security, Spring Cloud) et sa rapidité de développement. Spring Boot embarque un serveur web intégré (Tomcat, Jetty, Netty).

• Spring Boot Starter – démarrage rapide avec des dépendances pré‑configurées.
• Spring Data JPA – implémentation de JPA avec des repositories (CRUD, méthodes dérivées).
• Spring MVC – contrôleurs REST annotés avec `@RestController`.
• Spring Security – gestion fine des authentifications et autorisations.

// Contrôleur REST Spring Boot
@RestController
@RequestMapping("/api")
public class DemoController {
    @GetMapping("/hello")
    public String hello() { return "Hello Spring Boot"; }
}

Les formations ISOSET couvrent aussi bien Jakarta EE que Spring Boot, selon les besoins des entreprises.

• Respecter les conventions de nommage (camelCase pour les variables, PascalCase pour les classes).
• Programmer par interfaces – facilite les tests unitaires (mock) et l’injection de dépendances.
• Séparer les couches – contrôleur (web), service (métier), repository (persistance).
• Utiliser un framework de test (JUnit, Mockito) pour les tests unitaires et d’intégration.
• Gérer correctement les ressources (try‑with‑ressources, pools de connexions).
• Préférer l’immutabilité et les records pour les DTO.

Les témoignages d’anciens élèves d’ISOSET confirment l’efficacité de la formation : *« Après le module Java EE, j’ai pu reprendre un projet legacy et le faire évoluer en Spring Boot. Les concepts de servlets, JPA et CDI étaient parfaitement clairs. »*