Cet article présente cinq annotations Spring Boot essentielles qui permettent d'améliorer la manière de coder, rendant les applications plus maintenables, découplées et prêtes pour la production. Ces annotations sont particulièrement utiles aux développeurs débutants pour passer à un style de codage plus avancé, tout en proposant des éléments surprenants même pour les développeurs expérimentés.
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 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 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.
Cet article traite des problèmes de configuration CORS dans Spring Boot lorsque l'on tente d'accéder à une API depuis une application frontend construite avec React. L'auteur partage son expérience, soulignant que l'annotation standard pour activer CORS ne fonctionne pas toujours et que des configurations globales peuvent être nécessaires pour résoudre les erreurs d'accès. Il explique également les erreurs rencontrées et les solutions apportées pour que les requêtes fonctionnent correctement.
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.
Cet article explique comment une équipe a abandonné son wiki interne obsolète et a reconstruit sa documentation en utilisant des outils d'IA. Le besoin est apparu lorsque des développeurs n'ont pas pu accéder aux informations nécessaires, découvrant des données anciennes éparpillées dans différentes plateformes (Confluence, Notion, Slack). Cette situation a révélé que la documentation, bien que présente, était devenue peu fiable et manquait d'une source unique de vérité.
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.
