🔹 Java 8 → 21 : Nouveautés, Exemples et Cas d’usage
🔸 Java 8 (2014)
Nouveautés : Lambdas, Streams, Optional, Functional Interfaces, nouvelle Date/Time
API.
Exemple :
List<String> names = Arrays.asList("Ali", "Mohamed", "Sara");
names.stream()
.filter(name -> name.startsWith("A"))
.forEach(System.out::println);
Pourquoi ? :
o Approche fonctionnelle = code plus concis.
o Streams permettent de manipuler les collections de manière déclarative.
🔸 Java 11 (2018)
Nouveautés : var (typage implicite), HttpClient, nouvelles méthodes String (isBlank,
lines), suppression des modules Java EE.
Exemple :
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com"))
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
Pourquoi ? :
o HttpClient plus moderne, supporte asynchrone.
o var améliore la lisibilité dans les méthodes complexes.
🔸 Java 17 (2021 - LTS)
Nouveautés : record, sealed classes, pattern matching, nouveaux GC (G1, ZGC).
Exemple :
public record User(String name, int age) {}
User user = new User("Ala", 30);
Pourquoi ? :
o record = POJO immuable avec moins de boilerplate.
o sealed classes limitent les extensions non contrôlées (API plus sûre).
🔸 Java 21 (2023 - LTS)
Nouveautés : Virtual Threads, String Templates (preview), Scoped Values,
Structured Concurrency.
Exemple - Virtual Thread :
Thread.startVirtualThread(() -> {
System.out.println("Running in virtual thread");
});
Pourquoi ? :
o Concurrence massive à moindre coût.
o Remplace ExecutorService classique dans les applications réactives.
🔹 Spring 5, Spring 6 et Spring Boot : Fonctionnalités,
Versions, Cas d’usage
🔸 Spring 5 (2017)
Nouveautés :
o Support du paradigme réactif (WebFlux).
o Intégration avec Java 8 (Optional, Streams, CompletableFuture).
o Compatibilité avec JDK 9+.
Use Case :
o Application réactive non bloquante avec Mono et Flux.
@GetMapping("/user")
public Mono<User> getUser() {
return userService.findByIdAsync();
}
Pourquoi ? :
o Optimisation des ressources pour les applications à forte charge (ex: services de
streaming).
🔸 Spring 6 (2022)
Nouveautés :
o Support natif de GraalVM (AOT compilation).
o Nécessite Java 17+ et Jakarta EE 9+ (javax → jakarta).
o API sécurisée via ProblemDetail et gestion centralisée des erreurs.
Use Case :
o Microservice léger compilé en natif avec GraalVM pour startup rapide.
Pourquoi ? :
o Permet d'atteindre des objectifs Cloud-Native : rapidité, faible empreinte
mémoire.
🔸 Spring Boot (v2.7 à 3.x)
Spring Boot 2.7 : dernière version compatible avec Spring 5 et Java 8-11.
Spring Boot 3.0+ : basé sur Spring 6, Java 17+, Jakarta EE 9+.
Fonctionnalités clés :
o Démarrage rapide (@SpringBootApplication), autoconfiguration.
o Actuator (monitoring), DevTools, profils (application-{profile}.yml).
o Starter dependencies (ex: spring-boot-starter-web, -data-jpa, etc.)
Use Case :
@RestController
@RequestMapping("/api")
public class ProductController {
@GetMapping("/products")
public List<Product> all() {
return productRepository.findAll();
}
}
Pourquoi ? :
o Moins de configuration manuelle → gain de temps.
o Structuration rapide de microservices ou APIs REST.
🔹 Spring Security : Versions, Concepts, Cas d’usage
🔸 Concepts Clés
Authentication vs Authorization :
o Authentication = prouver l'identité.
o Authorization = accès aux ressources.
Filter Chain : enchaînement de filtres qui interceptent les requêtes HTTP.
SecurityContext : contient les détails de l’utilisateur connecté (Authentication).
GrantedAuthority : rôles/permissions.
🔸 Évolution par version
Spring Security 5.x :
o Support de OAuth 2.0 & OIDC.
o Password encoder obligatoire (BCryptPasswordEncoder).
o API reactive (SecurityWebFilterChain).
Spring Security 6.x (Spring Boot 3+):
o Migration complète vers jakarta.*
o Nouveau DSL avec lambdas (authorizeHttpRequests() au lieu de
antMatchers).
🔸 Exemple classique (Spring Boot 2.x - Security 5.x)
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
.and()
.formLogin();
}
}
🔸 Exemple moderne (Spring Boot 3.x - Security 6.x)
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws
Exception {
return http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
)
.formLogin(Customizer.withDefaults())
.build();
}
🔸 Pourquoi ?
Sécurité robuste et configurable à tous les niveaux.
Intégration native avec OAuth2 / JWT / LDAP.
Personnalisation facile pour rôles, endpoints, CORS, CSRF, etc.
Nouvelle API (Spring 6) plus lisible, moins verbeuse.
🔹 Spring Data, JPA, Hibernate, EntityManager : Concepts
et Exemples
🔸 Spring Data JPA
But : Simplifier l'accès aux données via des interfaces sans implémentation explicite.
Exemple :
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByEmail(String email);
}
Pourquoi ? :
o Pas besoin d’écrire de requêtes SQL ou JPQL pour les opérations courantes.
o Génération dynamique des requêtes à partir du nom de la méthode.
🔸 JPA vs Hibernate
JPA : Spécification Java EE (maintenant Jakarta EE) pour la persistance.
Hibernate : Implémentation concrète de JPA (la plus populaire).
🔸 EntityManager
Utilisé dans : approche plus bas niveau que Spring Data.
@PersistenceContext
private EntityManager em;
public List<User> getAllUsers() {
return em.createQuery("SELECT u FROM User u",
User.class).getResultList();
}
Pourquoi ? :
o Contrôle fin sur les requêtes et le cycle de vie des entités.
🔸 Cas d’usage pratique
Utiliser JpaRepository pour la majorité des cas.
Utiliser EntityManager pour :
o Requêtes complexes.
o Transactions manuelles.
o Performance tuning.
🔹 Kafka : Messaging, Topics, Producers & Consumers
🔸 Concepts
Producer : envoie des messages dans un topic.
Consumer : lit les messages d’un topic.
Topic : canal de diffusion des messages.
Broker : instance Kafka.
🔸 Exemple (Spring Boot Kafka)
@Service
public class ProducerService {
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
public void send(String topic, String message) {
kafkaTemplate.send(topic, message);
}
}
@KafkaListener(topics = "my-topic", groupId = "group_id")
public void listen(String message) {
System.out.println("Received: " + message);
}
🔸 Pourquoi ?
Kafka est ultra performant pour des architectures microservices.
Asynchrone, scalable, tolérant aux pannes.
Idéal pour Event Sourcing, CQRS, logs distribués.
🔹 API First & OpenAPI : Conception et Documentation
🔸 API First
Principe : concevoir l’API avant d’implémenter le code.
Pourquoi ? :
o Permet la collaboration (frontend/backend/devOps) dès le début.
o Favorise la conformité, la réutilisabilité et le mock.
🔸 OpenAPI (ex-Swagger)
Spécification : décrit les endpoints, modèles, réponses HTTP.
Outils : Swagger UI, Swagger Editor, Springdoc-openapi.
🔸 Exemple YAML (OpenAPI 3.0)
openapi: 3.0.1
info:
title: Product API
version: 1.0.0
paths:
/products:
get:
summary: Get all products
responses:
'200':
description: A list of products
🔸 Spring Boot + OpenAPI
@OpenAPIDefinition(info = @Info(title = "Product API", version = "v1"))
@SpringBootApplication
public class App {}
🔹 JUnit, Mockito, TDD, BDD
🔸 JUnit 5
Annotations : @Test, @BeforeEach, @AfterEach, @Nested.
Assertion : assertEquals, assertThrows, assertTrue.
🔸 Mockito
Usage : simuler le comportement des dépendances.
@Mock
UserService userService;
@Test
void testUser() {
when(userService.getName()).thenReturn("Ala");
assertEquals("Ala", userService.getName());
}
🔸 TDD (Test Driven Development)
Cycle : Écrire un test → Écrire le code minimal → Refactoriser.
Pourquoi ? : Moins de bugs, design plus propre.
🔸 BDD (Behavior Driven Development)
Outils : Cucumber, JBehave.
Structure : Given / When / Then.
Feature: Login
Scenario: Successful login
Given user is on login page
When they enter valid credentials
Then they see the dashboard
🔹 Architecture Hexagonale & Microservices
🔸 Hexagonal Architecture (Ports & Adapters)
Principe : séparer la logique métier du monde extérieur.
Composants :
o Domaine (métier pur).
o Ports (interfaces).
o Adapters (implémentations concrètes : REST, DB).
🔸 Pourquoi ?
Testabilité, maintenabilité.
Facile à remplacer une technologie sans toucher à la logique métier.
🔸 Exemple :
interface UserRepositoryPort {
User findById(Long id);
}
class UserService {
UserRepositoryPort port;
// logique métier
}
🔸 Microservices : Concepts & Patterns
Définition : petite application indépendante qui communique via API.
Avantages : Scalabilité, indépendance de déploiement, résilience.
🔸 Patterns courants :
API Gateway : Point d’entrée unique (ex: Spring Cloud Gateway).
Service Registry : Découverte de service (ex: Eureka).
Circuit Breaker : Résilience (ex: Resilience4j).
Event Sourcing / CQRS : Meilleure séparation des responsabilités.
🔸 Use Case
Plateforme e-commerce : services pour commandes, stock, paiement, utilisateur, etc.
🔹 Jenkins & Docker : CI/CD et Conteneurisation
🔸 Jenkins
Fonction : automatisation de build, test, déploiement.
Pipeline :
pipeline {
agent any
stages {
stage('Build') {
steps {
sh 'mvn clean install'
}
}
stage('Test') {
steps {
sh 'mvn test'
}
}
}
}
Plugins : GitHub, Docker, SonarQube, Slack.
🔸 Docker
Concepts : Image, Container, Dockerfile.
Exemple Dockerfile :
FROM openjdk:17-jdk
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]
🔸 Pourquoi ?
Déploiement cohérent sur toutes les machines.
Isolation, rapidité, portabilité (dev → test → prod).
Tout cela permet une architecture moderne, modulaire, testable et facilement déployable dans un
contexte cloud/microservices.
🔹 Angular : RxJS, Signals, Binding, Pipes, Directives
🔸 RxJS
Observable : flux de données asynchrones.
Operators : map, filter, switchMap, etc.
this.http.get('/api/users').pipe(map(data =>
data.name)).subscribe(console.log);
Use case : appels API, formulaires réactifs, WebSockets.
🔸 Signals (Angular 16+)
Nouveau modèle réactif basé sur des signaux (comme SolidJS).
const counter = signal(0);
const doubled = computed(() => counter() * 2);
Pourquoi ? :
o Remplace BehaviorSubject, ReplaySubject dans certains cas.
o Meilleure lisibilité, pas de subscribe/unsubscribe.
🔸 Data Binding
One-way : [value]="user.name"
Two-way : [(ngModel)]="user.name"
🔸 Pipes
Fonction : transformer la donnée dans le template.
{{ birthday | date:'shortDate' }}
Custom Pipe :
@Pipe({name: 'capitalize'})
export class CapitalizePipe implements PipeTransform {
transform(value: string): string {
return value.charAt(0).toUpperCase() + value.slice(1);
}
}
🔸 Directives
Structurelles : *ngIf, *ngFor
Attributs : [ngClass], [ngStyle]
Custom Directive :
@Directive({ selector: '[appHighlight]' })
export class HighlightDirective {
constructor(el: ElementRef) {
el.nativeElement.style.backgroundColor = 'yellow';
}
}
