Le guide ultime pour créer des annotations personnalisées dans Spring Boot

De telles annotations remplissent l'intégralité du projet dans Spring Boot.

Mais savez-vous quels problèmes ces annotations résolvent ?

Pourquoi les annotations personnalisées ont-elles été introduites au départ ?

Comment créer des annotations personnalisées ?

Aujourd'hui, je couvrirai :

• Pourquoi créer des annotations personnalisées ?
• Quels sont les principaux avantages de l'utilisation de ces annotations ?
• Comment créer des annotations personnalisées ?
• Comment la méthode annotée est-elle invoquée ?
• Quand utiliser les annotations personnalisées ?
• Quand ne pas utiliser d'annotations personnalisées ?
• Quels sont les inconvénients de l'utilisation d'annotations personnalisées ?

? Pourquoi créer des annotations personnalisées ?

Dans Spring Boot, les annotations sont plus qu'un simple moyen d'ajouter des métadonnées. Ils

• Simplifiez les tâches complexes
• Réduire le code passe-partout
• Améliorer la lisibilité du code

Avant que Spring n'introduise les annotations personnalisées, les développeurs devaient gérer des configurations telles que la validation des e-mails à l'aide de fichiers de configuration XML.

La configuration XML définirait les beans, les validateurs et d'autres composants nécessaires pour effectuer des tâches telles que la validation des adresses e-mail.

Voici un exemple de la façon dont la validation des e-mails aurait pu être configurée à l'aide de XML dans une application Spring :

Comme vous pouvez le voir, cela peut facilement devenir un cauchemar lorsqu'il y a des centaines de classes dont beaucoup dépendent les unes des autres.

Cela signifiait également qu'un développeur devait rechercher ce XML à chaque fois qu'il devait ajouter une nouvelle dépendance.

Principaux avantages des annotations personnalisées

Simplification de la configuration

Spring a introduit des annotations personnalisées pour simplifier la configuration en permettant aux développeurs d'utiliser des annotations directement dans leur code.

Cela a réduit le besoin d'une configuration XML étendue, rendant la base de code plus propre et plus facile à maintenir.

Prise en charge de la programmation déclarative

Les annotations personnalisées dans Spring permettent une approche déclarative.

Les développeurs peuvent utiliser des annotations telles que @Transactional, @Cacheable ou @Scheduled pour déclarer les comportements souhaités sans écrire la logique sous-jacente.

Cela se traduit par un code plus lisible et maintenable.

Gérer les préoccupations transversales

Les annotations personnalisées de Spring, souvent utilisées avec la programmation orientée aspect (AOP), permettent aux développeurs de gérer les problèmes transversaux de manière centralisée.

Par exemple, l'annotation @Transactional gère les transactions sur plusieurs méthodes ou classes sans disperser la logique de gestion des transactions dans tout le code.

Réduire le code passe-partout

Il réduit le besoin de code passe-partout en encapsulant les comportements courants.

Par exemple, l'annotation @Autowired simplifie l'injection de dépendances, permettant à Spring d'injecter automatiquement des dépendances, plutôt que d'exiger des méthodes de constructeur ou de définition explicites

La question de savoir si vous devez utiliser @Autowired ou non est une autre discussion.

Améliorer la lisibilité et la cohérence du code

En résumant la configuration et les préoccupations transversales dans des annotations, Spring améliore la lisibilité du code.

Vous et vos pairs développeurs pouvez rapidement comprendre l'objectif d'une méthode ou d'une classe en examinant ses annotations, et les annotations aident à assurer la cohérence dans la base de code.

Flexibilité et extensibilité du framework

Les annotations personnalisées permettent aux développeurs de créer leurs annotations adaptées à des besoins spécifiques, étendant ainsi les fonctionnalités du framework de manière standardisée.

Cette flexibilité a aidé Spring à rester pertinent et puissant sur plusieurs applications et architectures.

? Comment créer une annotation personnalisée

Étape 1 : Définir l'annotation

• Créez une nouvelle annotation en définissant une interface.
• Utilisez @interface pour le déclarer.
• Ajoutez des méta-annotations pour spécifier comment l'annotation doit se comporter.

package co.officegeek.tokenratelimiter;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)  // Annotation available at runtime
@Target(ElementType.METHOD)          // Can be applied to methods
public @interface LogExecutionTime {
}

• @Target : indique où l'annotation peut être utilisée (par exemple, méthodes, classes).
• @Retention : indique la durée pendant laquelle l'annotation est conservée (par exemple, au moment de l'exécution, au moment de la compilation).

Étape 2 : Créer un aspect pour gérer l'annotation

Vous pouvez créer une logique personnalisée pour traiter l'annotation à l'aide de BeanPostProcessor, d'Aspect ou d'une logique de traitement d'annotation personnalisée de Spring.

package co.officegeek.tokenratelimiter;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogExecutionTimeAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}

Étape 3 : appliquer l'annotation

Appliquez votre annotation personnalisée aux méthodes, champs ou classes tels que définis.

package co.officegeek.tokenratelimiter;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    @LogExecutionTime
    public void serve() throws InterruptedException {
        // Simulate some work
        Thread.sleep(2000);
    }
}

How It Works:

• The @LogExecutionTime annotation doesn't cause any method to be called directly.
• The Spring AOP framework detects that a method has the @LogExecutionTime annotation using reflection.
• The LogExecutionTimeAspect aspect is configured to apply around advice when a method with the @LogExecutionTime annotation is called.
• The logExecutionTime method in the aspect is executed before and after the annotated method (serve), logging the execution time.

---

How does the annotated method get invoked?

When you apply a custom annotation to a method, class, or field, the annotation itself doesn't directly cause any method to be called.

Instead, the logic associated with the annotation is typically implemented using reflection or aspect-oriented programming (AOP) in frameworks like Spring.

Here's a breakdown of how the compiler and runtime environment know what method to call when an annotation is applied:

1. Compile-Time Processing (Annotation Processors)

Some annotations are handled at compile time by annotation processors.

Java's javax.annotation.processing package allows developers to create custom annotation processors that generate code, validate annotations, or even modify the abstract syntax tree (AST) of the code being compiled.

The annotation processor reads the annotations during compilation and executes code based on those annotations.

This can include generating new classes or methods that the code will use later.

The @Override annotation is a compile-time annotation that doesn't invoke a method but instead tells the compiler to check if the method actually overrides a superclass method.

How It Works:

• You define a custom annotation processor by extending AbstractProcessor and overriding the process method.
• The processor will be invoked by the compiler when it encounters your annotation, allowing you to generate code or perform other tasks.

2. Runtime Processing (Reflection)

Custom annotations can be processed at runtime using reflection.

The runtime system (e.g., a framework like Spring) uses reflection to detect the presence of annotations on methods, classes, or fields, and then applies the corresponding behavior.

A custom annotation like @LogExecutionTime doesn't directly trigger any method call.

Instead, an aspect or some other reflective mechanism checks for the presence of the annotation at runtime and then wraps the method call with additional logic.

How It Works:

• At runtime, you use Java's reflection API to check if a method or class has a specific annotation using methods like isAnnotationPresent.
• Once detected, you can invoke methods or execute logic associated with that annotation.  For example, if a method has a @LogExecutionTime annotation, you might measure the time before and after the method call.

3. Aspect-Oriented Programming (AOP)

In frameworks like Spring, AOP is commonly used to handle custom annotations.

AOP allows you to define "aspects" that can intercept method calls and perform additional processing before or after the method execution.

When the AOP framework (e.g. Spring AOP) detects an annotation, it triggers the execution of an advice method associated with the aspect.

This advice method contains the logic that the AOP framework executes when the annotated method is called.

A @Transactional annotation in Spring doesn't execute any logic by itself.

Instead, the Spring framework's AOP infrastructure intercepts calls to methods annotated with @Transactional and wraps them with transaction management logic.

How It Works:

• You define an aspect class with advice methods that are associated with specific pointcuts (join points where you want to apply the advice).
• The aspect uses annotations like @Around or @Before to specify when the advice should be executed.
• The AOP framework ensures that when a method with a custom annotation is called, the corresponding advice is executed automatically.

Use Cases Where Custom Annotations Are a Good Approach

Cross-Cutting Concerns

Custom annotations are ideal for handling cross-cutting concerns like logging, security, transaction management, and caching.

These are concerns that affect multiple parts of an application but are not related to the core business logic.

L'annotation @LogExecutionTime ci-dessus est un bon exemple car elle peut être utilisée dans toutes les méthodes et elle n'a aucune logique métier.

Programmation déclarative

Lorsque vous souhaitez spécifier ce qui doit se produire plutôt que comment cela doit se produire, les annotations personnalisées constituent un moyen propre et expressif de le faire.

Des annotations telles que @Cacheable ou @Retry permettent aux développeurs d'activer la mise en cache ou de réessayer la logique de manière déclarative, sans écrire le code d'implémentation manuellement.

Intégration d'un framework ou d'une bibliothèque

Les annotations personnalisées peuvent simplifier l'intégration de frameworks ou de bibliothèques en masquant la complexité derrière une annotation facile à utiliser.

Des annotations comme @Autowired in Spring aident à injecter des dépendances sans avoir à les instancier manuellement.

Encapsulation de logique complexe

Lorsqu'une logique complexe doit être encapsulée de manière réutilisable, les annotations personnalisées peuvent fournir une API propre pour appliquer cette logique.

Une annotation comme @RateLimit pourrait encapsuler une logique pour limiter le nombre de fois qu'une méthode peut être appelée, sans encombrer le corps de la méthode avec cette logique.

Cas d'utilisation dans lesquels les annotations personnalisées ne doivent pas être utilisées

Logique simple ou ponctuelle

Si la logique est simple ou ne doit être appliquée qu'à un seul endroit, la création d'une annotation personnalisée est excessive et peut inutilement compliquer le code.

Logique qui nécessite un comportement dynamique

Les annotations sont définies statiquement au moment de la compilation, ce qui les rend inadaptées aux scénarios dans lesquels le comportement doit être déterminé dynamiquement au moment de l'exécution.

Si le comportement d'une méthode doit changer en fonction de la saisie de l'utilisateur ou d'une configuration externe, gérer cela avec des annotations personnalisées peut conduire à des solutions complexes.

Logique métier

La logique métier de base ne doit pas être résumée dans des annotations personnalisées, car cela peut rendre la logique moins transparente et plus difficile à maintenir.

L'utilisation d'une annotation pour encapsuler un processus métier tel que @ProcessOrder peut masquer des règles métier importantes, rendant le code plus difficile à comprendre et à maintenir.

Interactions complexes entre les annotations

Si le comportement dépend d'interactions complexes entre plusieurs annotations, cela peut conduire à des résultats inattendus et rendre le code difficile à comprendre et à déboguer.

La combinaison de plusieurs annotations personnalisées affectant la même méthode (par exemple, @Retry, @Cacheable, @LogExecutionTime) peut entraîner un comportement imprévisible et est difficile à gérer

Code critique pour les performances

Les annotations personnalisées reposent souvent sur des mécanismes de réflexion ou de proxy, ce qui peut entraîner une surcharge en termes de performances.

Ils ne doivent pas être utilisés dans les sections de code critiques en termes de performances.

L'utilisation d'une annotation personnalisée pour ajouter la journalisation à une méthode appelée des millions de fois en boucle serrée pourrait dégrader considérablement les performances.

? Résumé - Quand utiliser les annotations personnalisées

Les annotations personnalisées sont parfaites pour gérer des problèmes transversaux tels que la journalisation, la sécurité et la gestion des transactions.

Ils sont également parfaits pour les scénarios dans lesquels vous devez appliquer le même comportement dans plusieurs parties de votre application.

Cependant, pour une logique simple et ponctuelle, ou lorsqu'un contrôle précis et une flexibilité sont requis, les annotations personnalisées ne sont peut-être pas la meilleure approche.

Considérez les compromis avant de décider de les mettre en œuvre.

? Réflexions finales

Les annotations personnalisées sont un outil puissant dans votre arsenal Spring Boot, mais comme tout outil, elles doivent être utilisées judicieusement.

Ils offrent un moyen propre et réutilisable de gérer les tâches répétitives et d'assurer la cohérence dans votre base de code.

Mais soyez conscient des inconvénients potentiels, notamment en termes de complexité et de performances.

---

?? Annonce

Je lance un cours de cohorte de 10 jours destiné aux développeurs de logiciels et aux futurs architectes de microservices sur la conception et la mise en œuvre d'un service de limitation de débit à l'aide de Spring Boot et Bucket4j.

Vous apprendrez :

✅ Comment concevoir et créer un microservice prêt pour la production

✅ Connaissance approfondie des algorithmes de limitation de débit et de leur mise en œuvre

✅ Meilleures pratiques en matière de développement, de tests et de conteneurisation Spring Boot

Mais il s'agit aussi

✅ décomposer le projet en tâches précises

✅ Être responsable envers soi-même

✅ Concevoir et construire correctement le projet

Il s'adresse aux développeurs de logiciels qui souhaitent concevoir et développer un microservice qui constitue un cas d'utilisation pertinent pour la plupart des entreprises.

C'est PARTICULIÈREMENT destiné à ceux qui sont plus tôt dans leur carrière de développeur de logiciels et qui n'ont peut-être pas « d'expérience en matière de projet », mais des tonnes de passion et d'ambition.

Si vous pensez que cela vous aidera ou même si vous êtes simplement curieux d'en savoir plus :

Inscrivez votre intérêt et je vous informerai des détails de l'atelier.

---

Ceci a été publié pour la première fois sur mon Substack. Abonnez-vous à mon Substack - Week-end Developer pour obtenir les mises à jour en premier.

Êtes-vous un développeur qui a besoin de commentaires sur le code que vous écrivez ?

Ou voulez-vous que quelqu'un révise votre code afin que vous fassiez les bonnes choses ?

J'aide les gens avec des sessions gratuites de révision de code afin qu'ils puissent obtenir des commentaires précoces et écrire un meilleur code

Envoyez-moi un message privé sur Twitter (X) ou sur LinkedIn et je vous aiderai avec votre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!