Chapitre 21 — Livres

Resumes et analyses des livres fondamentaux pour l'ingenieur Java moderne

---

1. Effective Java (3rd Edition) — Joshua Bloch

Presentation

• Auteur : Joshua Bloch (ancien architecte Sun/Oracle, Google)
• Edition : 3e edition (2018), couvre Java 7-9
• Pages : 368
• Note : 4.9/5 — Reference absolue

Structure (90 items)

Le livre est organise en 12 chapitres, chacun contenant des "items" (conseils) :

Chapitre 2 : Creation et destruction d'objets

• Item 1 : Fabriques statiques vs constructeurs
• Item 2 : Builder pattern (quand de nombreux parametres)
• Item 3 : Enums pour les singletons
• Item 4 : Classes utilitaires avec constructeur prive
• Item 5 : Injection de dependances plutot que hard-coding
• Item 6 : Eviter la creation d'objets inutiles
• Item 7 : Eliminer les references obsoletes
• Item 8 : Eviter les finalizers et cleaners
• Item 9 : try-with-resources pour les ressources

Application Java 21 : Les records remplacent avantageusement les classes de donnees (Item 1, 2). Les fabriques statiques restent pertinentes.

Chapitre 3 : Methodes communes a tous les objets

• Item 10 : Respecter le contrat de equals()
• Item 11 : Toujours surcharger hashCode() avec equals()
• Item 12 : Toujours surcharger toString()
• Item 13 : Surcharger clone() avec prudence (ou ne pas surcharger)
• Item 14 : Implementer Comparable

Application Java 21 : Les records fournissent equals/hashCode/toString automatiquement (Item 10-12).

Chapitre 4 : Classes et interfaces

• Item 15 : Minimiser l'accessibilite
• Item 16 : Champs d'instance publics → getters
• Item 17 : Immutabilite minimale
• Item 18 : Favoriser la composition sur l'heritage
• Item 19 : Design pour l'heritage ou interdire
• Item 20 : Interfaces plutot que classes abstraites
• Item 21 : Interfaces fonctionnelles marquees avec @FunctionalInterface
• Item 22 : Interfaces seulement pour les types
• Item 23 : Hierarchies de types taggees → sealed classes
• Item 24 : Classes membres statiques plutot que non-statiques
• Item 25 : Un fichier source = une classe de haut niveau

Application Java 21 : Les sealed classes (Item 23) permettent des hierarchies controlees. Les records sont immutables (Item 17).

Chapitre 5 : Generiques

• Item 26 : Ne pas utiliser les raw types
• Item 27 : Supprimer les avertissements unchecked
• Item 28 : List plutot que Array
• Item 29 : Favoriser les types generiques
• Item 30 : Favoriser les methodes generiques
• Item 31 : Bornes bornees pour la flexibilite
• Item 32 : Utiliser varargs generiques avec prudence
• Item 33 : Conteneurs de types avec TypeToken

Chapitre 6 : Enums et annotations

• Item 34 : Enums au lieu de constantes int
• Item 35 : Champs d'instance au lieu d'ordinals
• Item 36 : EnumSet au lieu de bit fields
• Item 37 : EnumMap au lieu de tableaux indexes
• Item 38 : Enums extensibles avec interfaces
• Item 39 : Annotations > conventions de nommage
• Item 40 : @Override systematique
• Item 41 : Marqueur interfaces vs annotations

Chapitre 7 : Lambdas et Streams (Java 8+)

• Item 42 : Lambdas > classes anonymes
• Item 43 : Method references > lambdas
• Item 44 : Interfaces fonctionnelles standard
• Item 45 : Streams avec prudence
• Item 46 : Preferer les fonctions sans effet de bord dans les streams
• Item 47 : Stream comme type de retour
• Item 48 : Paralleliser les streams avec precaution

Chapitre 8 : Methodes

• Item 49 : Valider les parametres
• Item 50 : Defensive copies
• Item 51 : Signature de methode
• Item 52 : Surcharge intelligente
• Item 53 : Varargs avec prudence
• Item 54 : Collections vides plutot que null
• Item 55 : Optionals comme types de retour
• Item 56 : Javadoc pour toutes les API

Chapitre 9 : Programmation generale

• Item 57 : Portee minimale des variables locales
• Item 58 : for-each > for avec index
• Item 59 : Bibliotheques standard > reimplementation
• Item 60 : Eviter float/double pour les calculs exacts
• Item 61 : Boxing types avec prudence
• Item 62 : Strings pour les types appropries
• Item 63 : Concat vs StringBuilder
• Item 64 : Interfaces comme types
• Item 65 : Reflection pour l'infrastructure seulement
• Item 66 : Methodes natives avec prudence
• Item 67 : Optimisation avec parcimonie
• Item 68 : Conventions de nommage

Chapitre 10 : Exceptions

• Item 69 : Exceptions pour les conditions exceptionnelles
• Item 70 : Exceptions checked vs unchecked
• Item 71 : Eviter l'usage inutile des checked exceptions
• Item 72 : Standardiser l'usage des exceptions
• Item 73 : Exception qui preserve l'abstraction
• Item 74 : Documentation des exceptions
• Item 75 : Messages d'erreur detailles

Chapitre 11 : Concurrence

• Item 76 : Synchroniser l'acces aux donnees partagees
• Item 77 : Eviter les synchronisations excessives
• Item 78 : Executors, tasks, streams > threads
• Item 79 : Eviter les synchronisations dans les callbacks
• Item 80 : Preferer les executors, timers
• Item 81 : Preferer les utilitaires de concurrence (java.util.concurrent)
• Item 82 : Thread safety documentee
• Item 83 : Initialisation paresseuse avec prudence
• Item 84 : Eviter les thread groups

Chapitre 12 : Serialisation

• Item 85 : Alternatives a la serialisation Java
• Item 86 : Serializable avec precaution
• Item 87 : Personnaliser la serialisation
• Item 88 : readObject defensive
• Item 89 : Singleton avec enum
• Item 90 : Serialization proxy

Top takeaways pour l'ingenieur moderne

1. Records et Sealed classes (Java 17+) simplifient enormement les items sur equals/hashCode/heritage
2. Optional (Item 55) est la solution moderne aux nulls
3. Streams (Item 45-48) doivent etre utilises avec discernement
4. try-with-resources (Item 9) est systematique
5. Builder pattern (Item 2) reste pertinent malgre les records
6. Lambdas (Item 42) remplacent les classes anonymes

---

2. Java Concurrency in Practice — Brian Goetz

Presentation

• Auteurs : Brian Goetz (spec lead), Tim Peierls, Joshua Bloch
• Edition : 2006 (toujours d'actualite pour les fondamentaux)
• Pages : 384
• Note : 4.7/5 — Reference concurrency Java

Structure

Partie 1 : Fondamentaux

1. Thread Safety — Atomicite, visibilite, ordre
2. Partage d'objets — Publication, immutabilite, safe publication
3. Composition — Delegation, thread-safe classes
4. Blocs de construction — Synchronized collections, concurrent collections

Partie 2 : Structurer les applications concurrentes

5. Blocs de construction — Latches, barriers, semaphores
6. Task execution — ExecutorService, thread pools
7. Cancellation et shutdown — Interruption, flags
8. Thread pools — Taille, configuration, saturation
9. GUI applications — Event dispatch thread

Partie 3 : Performance et test

10. Performance — Cout du locking, scalability, Amdahl
11. Tests — Tests d'atomicite, tests de performance

Partie 4 : Themes avances

12. Cas explicites de synchronisation — ReentrantLock, ReadWriteLock
13. Atomiques et non-bloquants — CAS, AtomicInteger, volatiles
14. Modeles memoire — happens-before, reordering, visibility

Takeaways pour Java 21+

• Virtual threads (Loom) simplifient radicalement le modele de concurrence
• Structured concurrency (JEP 453) rend le code concurrent plus sur
• Scoped values (JEP 446) remplacent ThreadLocal
• Les fondamentaux de Goetz restent valables pour comprendre le modele memoire
• AtomicInteger, ReentrantLock, CountDownLatch toujours d'actualite

---

3. Spring in Action (6th Edition) — Craig Walls

Presentation

• Auteur : Craig Walls (VMware)
• Edition : 6e (2022), couvre Spring Boot 3.x
• Pages : 520
• Note : 4.6/5 — Guide pratique Spring

Resume par chapitre

Partie 1 : Fondamentaux Spring

1. Getting started — Spring Boot, Initializr, premiere app
2. Web avec Spring MVC — Controllers, REST, validation
3. Donnees avec Spring — JdbcTemplate, Spring Data JPA
4. Spring Security — Authentification, autorisation

Partie 2 : Spring Boot en pratique

5. Configuration — Properties, profiles, externalized config
6. Actuators — Health, metrics, info endpoints
7. Deploiement — JAR, WAR, Docker, Cloud

Partie 3 : Reactive Spring

8. Reactive — Reactor, WebFlux, reactive data
9. Reactive REST — WebClient, reactive repositories

Partie 4 : Cloud Native

10. Cloud — 12-factor app, Config, Discovery
11. Resilience — Circuit Breaker, Retry, Fallback
12. Tracing — Distributed tracing, monitoring

Partie 5 : Deploiement et operations

13. Kubernetes — Deploiement Spring sur K8s
14. Native — Spring Boot 3 + GraalVM native images
15. Testing — JUnit 5, Mockito, Testcontainers, Selenium

Takeaways

• Spring Boot 3.x requiert Java 17 minimum
• La configuration auto est puissante mais doit etre comprise
• Les actuators sont indispensables en production
• GraalVM native image reduit le demarrage de 5s a 100ms
• Spring Security 6.0 a change : SecurityFilterChain remplace WebSecurityConfigurerAdapter

---

4. Clean Code — Robert C. Martin

Presentation

• Auteur : Robert C. Martin ("Uncle Bob")
• Edition : 2008
• Pages : 464
• Note : 4.2/5 — Classique, parfois idealiste mais fondamental

Resume par chapitre

1. Clean Code — Qu'est-ce que le code propre
2. Noms significatifs — Intention-revealing names
3. Fonctions — Petites, une responsabilite
4. Commentaires — Le commentaire ment, le code reste
5. Formatage — Vertical/horizontal formatting
6. Objets et structures — Data/Object anti-symmetry
7. Gestion des erreurs — Exceptions, null handling
8. Limites — Integrating third-party code
9. Tests unitaires — TDD, F.I.R.S.T. principles
10. Classes — Organisation, cohesion
11. Systemes — Separation of concerns
12. Emergence — Simple design rules
13. Concurrence — Thread safety tips
14. Refactoring — Successive refinement

Principles F.I.R.S.T. pour les tests

• Fast — Tests rapides
• Independent — Tests independants
• Repeatable — Reproductibles
• Self-validating — Auto-validation (boolean)
• Timely — Ecrits au bon moment (TDD)

Application Java moderne

• Les records Java 21 rendent les classes de donnees beaucoup plus propres
• Les lambdas reduisent le bruit syntaxique
• Les Optional eliminent les null checks
• Les streams rendent les boucles plus declaratives
• Les methodes par defaut dans les interfaces evite les classes abstractes inutiles

---

5. Design Patterns (GoF) — Gamma, Helm, Johnson, Vlissides

Presentation

• Auteurs : Gang of Four (GoF)
• Edition : 1994 (toujours la reference)
• Pages : 416
• Note : 4.5/5 — Pattern design intemporels

Application Java moderne

Patterns creationnels

Patterns structurels

Patterns comportementaux

Pattern Matching comme "Visitor eliminator"

Avec sealed classes et pattern matching (Java 21), le Visitor pattern peut etre remplace :

sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
    };
}

Plus besoin du Visitor traditionnel. Le pattern matching + sealed classes est plus propre, plus type-safe, et plus maintenable.

---

6. Domain-Driven Design — Eric Evans

Presentation

• Auteur : Eric Evans ("Eric Evans")
• Edition : 2003 (reste la reference DDD)
• Pages : 560
• Note : 4.2/5 — Complexe mais transformateur

Les 4 couches DDD

1. Ubiquitous Language — Langage commun equipe/domaine
2. Bounded Context — Limites explicites du modele
3. Entities — Objets avec identite continue
4. Value Objects — Objets definis par leurs attributs

Tactical Patterns

• Entity : @Entity JPA, identite, mutable
• Value Object : record, immutable
• Aggregate : Cluster de coherence transactionnelle
• Repository : JpaRepository<T,ID>
• Domain Service : Logique sans etat
• Domain Event : Evenements du domaine
• Factory : Creation d'objets complexes
• Specification : Regles metier reutilisables

Application avec Spring Boot

// Value Object
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0)
            throw new IllegalArgumentException("Negative amount");
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency))
            throw new IllegalArgumentException("Currency mismatch");
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

// Entity
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    @Embedded
    private Money total;
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    @OneToMany(cascade = CascadeType.ALL)
    private List<OrderLine> lines;

    public void addProduct(Product product, int quantity) {
        OrderLine line = new OrderLine(product, quantity);
        lines.add(line);
        total = total.add(line.subtotal());
    }
}

// Aggregate Root
// L'Order est l'Aggregate Root. Toute modification passe par l'Order.
// Les OrderLine ne sont accessibles que via l'Order.

// Domain Service
@Service
public class PricingService {
    public Money calculatePrice(Order order, Customer customer) {
        Money basePrice = order.getTotal();
        if (customer.isPremium()) {
            return basePrice.applyDiscount(0.10);
        }
        return basePrice;
    }
}

// Domain Event
public record OrderConfirmedEvent(Long orderId, LocalDateTime confirmedAt) {}

Hexagonal Architecture avec DDD

[Controllers] → [Application Services] → [Domain] → [Repository Interfaces]
                                              ↓
                                    [Repository Implementations]
                                              ↓
                                      [Database/JPA]

DDD + architecture hexagonale = separation parfaite entre domaine et infrastructure.

---

Conclusion : Par ou commencer ?

Lecture recommandee : Effective Java d'abord, puis Spring in Action, puis Clean Code, puis DDD/GoF/JCIP selon les besoins.