Cet article présente les meilleures pratiques pour containeriser des applications Spring Boot en 2025 en utilisant Docker. Il aborde des techniques éprouvées pour créer des images Docker lean, sécurisées et performantes, tout en soulignant l'importance de bien comprendre les objectifs de la containerisation. L'accent est mis sur l'adoption de Java 21 et les perspectives futures avec Java 25.
Cet article aborde des techniques avancées pour la gestion des threads en Java, en se concentrant sur les mécanismes de contrôle de la concurrence et les meilleures pratiques pour assurer la sécurité des threads. Il couvre des concepts tels que le service d'exécution, les défis de verrouillage, les techniques de sécurité des threads, et l'utilisation de verrous intrinsèques ainsi que la programmation sans verrou en utilisant des opérations atomiques.
Cet article explore la programmation réactive en Java, en mettant l'accent sur son utilité pour les applications modernes exigeant réactivité et scalabilité. Il aborde les scénarios appropriés pour utiliser cette approche, tels que les applications à haute concurrence, les services liés aux entrées/sorties et le traitement de flux de données. L'article s'adresse aux développeurs ayant une expérience pratique et vise à expliquer les raisons d'opter pour la programmation réactive avant de passer à sa mise en œuvre.
Cet article raconte l'expérience de l'auteur lors de son premier entretien d'embauche en Java. Bien qu'il maîtrise le langage, il n'était pas préparé aux questions spécifiques liées au développement avec Spring Boot, ce qui a conduit à son échec. Il souligne la différence entre savoir coder et réussir un entretien, en mentionnant des questions techniques sur la gestion des transactions et le débogage en_applications Spring Boot. L'auteur partage des conseils pour mieux se préparer aux entretiens Java.
Cet article explique pourquoi l'auteur a abandonné l'utilisation des couches DTO (Data Transfer Object) dans son architecture logicielle. Au lieu de complexifier le code avec des mappers et des DTO pour chaque changement, il plaide pour une communication directe en langage de domaine entre les services. Cela vise à réduire la duplication, les frictions et les bugs associés au modèle DTO, tout en maintenant l'intégrité du modèle de domaine.
L'article explique pourquoi l'utilisation de l'annotation @Builder de Lombok pour la création d'entités JPA a été abandonnée au profit des méthodes de création basées sur les constructeurs. Cette décision a été motivée par des problèmes rencontrés en production, tels que des champs manquants et des enregistrements d'audit avec des timestamps vides, rendant le processus de création d'entités dangereux et sujet aux erreurs.
Cet article explique pourquoi une équipe de développement a abandonné l'utilisation des @EntityListeners pour l'audit des changements d'entités en Java. Ils ont réalisé que ces hooks automatiques étaient fragiles et pouvaient mener à des bugs ou à une corruption des données. En conséquence, ils ont opté pour un système où les données d'audit étaient définies explicitement, ce qui a permis d'éviter des surprises et des erreurs.
L'article aborde les frustrations rencontrées par des développeurs après avoir largement utilisé l'annotation @Value dans leurs classes de configuration Spring. À l'origine, cette méthode semblait simple et efficace, permettant de réduire le boilerplate. Cependant, avec le temps, ils ont réalisé que son utilisation excessive avait conduit à des problèmes, notamment un manque de comportement 'fail-fast', rendant la maintenance difficile et entraînant des erreurs à travers plusieurs environnements et déploiements.
Cet article traite des erreurs de mémoire les plus courantes en Java, à savoir OutOfMemoryError et StackOverflowError. Il explique comment la gestion de la mémoire est cruciale dans le développement Java et les causes de ces erreurs, notamment lorsqu'elles se produisent à cause d'un manque d'espace dans le tas ou d'appels de méthode excessifs. Comprendre ces erreurs et leurs causes est essentiel pour créer des applications Java fiables.
L'article aborde le débat actuel sur l'avenir de Java, souvent considéré comme obsolète par certains développeurs au profit de nouveaux langages comme Rust et Kotlin. Cependant, l'auteur affirme que Java n'est pas mort et continue d'évoluer. Il souligne l'importance pour les développeurs de ne pas s'en tenir uniquement à Java et d'explorer d'autres langages tout en reconnaissant la place que Java occupe encore dans l'écosystème technologique mondial.
