Le guide complet des annotations du Framework Spring

Le langage de programmation Java a pris en charge les annotations à partir de Java 5.0. Les principaux frameworks Java ont rapidement adopté les annotations, et Spring Framework a commencé à utiliser des annotations à partir de la version 2.5. En raison de la façon dont ils sont définis, les annotations fournissent beaucoup de contexte dans leur déclaration.

Avant les annotations, le comportement de Spring Framework était largement contrôlé via la configuration XML. Aujourd'hui, l'utilisation des annotations nous offre des capacités énormes dans la façon dont nous configurons les comportements de Spring Framework.

Dans cet article, nous examinerons les annotations disponibles dans Spring Framework.

Annotations du framework Spring Core 

@Required

Cette annotation est appliquée aux méthodes de définition de bean si vous envisagez un scénario dans lequel vous devez appliquer une propriété obligatoire. L'annotation @Required indique que le bean affecté doit être rempli au moment de la configuration avec la propriété requise. Sinon, une exception de type BeanInitializationException est levée.

@Autowired

Cette annotation est appliquée aux champs, aux méthodes de définition et aux constructeurs. L'annotation @Autowired injecte la dépendance d'objet implicitement.
Lorsque vous utilisez @Autowired sur des champs et que vous transmettez les valeurs des champs à l'aide du nom de la propriété, Spring affecte automatiquement les champs aux valeurs transmises.
Vous pouvez même utiliser @Autowired sur des propriétés privées, comme illustré ci-dessous. (Attention : ceci est une très mauvaise pratique !)

public class Customer {

    @Autowired                               

    private Person person;                   

    private int type;

}

Lorsque vous utilisez @Autowired sur les méthodes setter, Spring tente de l'exécuter par Type Autowired sur la méthode. Vous indiquez à Spring qu'il doit initier cette propriété à l'aide d'une méthode setter dans laquelle vous pouvez ajouter votre code personnalisé, comme l'initialisation de toute autre propriété avec cette propriété.

public class Customer {                                                                                         

    private Person person;

    @Autowired                                                                                                      

    public void setPerson (Person person) {

       this.person=person;

    }

}

Considérons un scénario dans lequel vous avez besoin d'une instance de classe A, mais vous ne stockez pas A dans le champ de la classe. Vous utilisez simplement A pour obtenir une instance de B, et vous stockez B dans ce champ. Dans ce cas, la méthode Setter Autowired vous conviendra mieux. Vous n'aurez pas de champs inutilisés au niveau de la classe.
Lorsque vous utilisez @Autowired sur un constructeur, l'injection du constructeur se produit au moment de la création de l'objet. Il dit au constructeur de s'auto-piloter lorsqu'il est utilisé comme un Bean. Une chose à noter ici est qu'un seul constructeur de n'importe quelle classe de bean peut porter l'annotation @Autowired.

@Component

public class Customer {

    private Person person;

    @Autowired

    public Customer (Person person) {     

        this.person=person;

    }

}

NB: Depuis Spring 4.3, @Autowired est devenu optionnel sur les classes avec un seul constructeur. Dans l'exemple ci-dessus, Spring injecterait toujours une instance de la classe Person si vous omettiez l'annotation @Autowired.

@Qualificatif

Cette annotation est utilisée avec l'annotation @Autowired. Lorsque vous avez besoin de plus de contrôle sur le processus d'injection de dépendances, @Qualifier peut être utilisé. @Qualifier peut être spécifié sur des arguments constructeurs individuels ou des paramètres de méthode. Cette annotation est utilisée pour éviter la confusion qui se produit lorsque vous créez plus d'un bean du même type et que vous souhaitez en câbler seulement un avec une propriété.

Considérons un exemple où une interface BeanInterface est implémentée par deux beans, BeanB1 et BeanB2.

@Component

public class BeanB1 implements BeanInterface {

    //

}

@Component

public class BeanB2 implements BeanInterface {

    //

}

Maintenant, si BeanA injecte cette interface, Spring ne saura pas laquelle des deux implémentations à injecter.
Une solution à ce problème est l'utilisation de l'annotation @Qualifier.

@Component

public class BeanA {

    @Autowired

    @Qualifier("beanB2")

    private IBean dependency;

    ...

}

Avec l'ajout de l'annotation @Qualifier, Spring va maintenant savoir quel bean doit être injecté, soit beanB2 qui est le nom de BeanB2.

@Configuration

Cette annotation est utilisée sur les classes qui définissent les beans. @Configuration est un analogue pour un fichier de configuration XML - c'est une configuration utilisant des classes Java. Une classe Java annotée avec @Configuration est une configuration en elle-même et aura des méthodes pour instancier et configurer les dépendances.

Voici un exemple:

@Configuartion

public class DataConfig {

    @Bean

    public DataSource source() {

        DataSource source = new OracleDataSource();

        source.setURL();

        source.setUser();

        return source;

    }

    @Bean

    public PlatformTransactionManager manager() {

        PlatformTransactionManager manager = new BasicDataSourceTransactionManager();

        manager.setDataSource(source());

        return manager;

    }

}

@ComponentScan

Cette annotation est utilisée avec l'annotation @Configuration pour permettre à Spring de connaître les paquets à analyser pour les composants annotés. @ComponentScan est également utilisé pour spécifier les paquets de base en utilisant les attributs basePackageClasses ou basePackage à analyser. Si des packages spécifiques ne sont pas définis, l'analyse se produira à partir du package de la classe qui déclare cette annotation.

@Bean

Cette annotation est utilisée au niveau de la méthode. L'annotation @Bean fonctionne avec @Configuration pour créer des beans Spring. Comme mentionné précédemment, @Configuration aura des méthodes pour instancier et configurer les dépendances. Ces méthodes seront annotées avec @Bean. La méthode annotée avec cette annotation fonctionne comme l'identifiant du bean, et crée et renvoie le bean réel.

Voici un exemple:

@Configuration

public class AppConfig {

    @Bean

    public Person person() {

        return new Person(address());

    }

    @Bean

    public Address address() {

        return new Address();

    }

}

@Lazy

Cette annotation est utilisée sur les classes de composants. Par défaut, toutes les dépendances auto-générées sont créées et configurées au démarrage. Mais si vous voulez initialiser un bean paresseusement, vous pouvez utiliser l'annotation @Lazy sur la classe. Cela signifie que le bean sera créé et initialisé seulement quand il est demandé pour la première fois. Vous pouvez également utiliser cette annotation sur les classes @Configuration. Ceci indique que toutes les méthodes @Bean dans cette @Configuration doivent être initialisées paresseusement.

@Value

Cette annotation est utilisée au niveau du champ, du paramètre constructeur et des niveaux de paramètre de méthode. L'annotation @Value indique une expression de valeur par défaut pour le champ ou le paramètre avec lequel initialiser la propriété. Comme l'annotation @Autowired demande à Spring d'injecter un objet dans un autre lorsqu'il charge le contexte de votre application, vous pouvez également utiliser l'annotation @Value pour injecter des valeurs d'un fichier de propriétés dans l'attribut d'un bean. Il prend en charge les syntaxes réservés # {...} et $ {...}.

Annotations stéréotype de Spring

@Component

Cette annotation est utilisée sur les classes pour indiquer un composant Spring. L'annotation @Component marque la classe Java en tant que bean ou composant afin que le mécanisme d'analyse des composants de Spring puisse l'ajouter au contexte de l'application.

@Controller

L'annotation @Controller est utilisée pour indiquer que la classe est un contrôleur Spring. Cette annotation peut être utilisée pour identifier les contrôleurs pour Spring MVC ou Spring WebFlux.

@Service

Cette annotation est utilisée sur une classe. @Service marque une classe Java qui effectue certains traitements service, tels que l'exécution de la logique métier, l'exécution de calculs et l'appel d'API externes. Cette annotation est une forme spécialisée de l'annotation @Component destinée à être utilisée dans la couche de service.

@Repository

Cette annotation est utilisée sur les classes Java qui accèdent directement à la base de données. L'annotation @Repository fonctionne comme un marqueur pour toute classe remplissant le rôle de référentiel ou d'objet d'accès aux données.

Cette annotation a une fonction de traduction automatique. Par exemple, lorsqu'une exception se produit dans @Repository, il existe un gestionnaire pour cette exception et il n'est pas nécessaire d'ajouter un bloc try-catch.

Annotations de démarrage de printemps

@EnableAutoConfiguration

Cette annotation est généralement placée sur la classe d'application principale. L'annotation @EnableAutoConfiguration définit implicitement un "package de recherche" de base. Cette annotation indique à Spring Boot de commencer à ajouter des beans en fonction des paramètres de chemin de classe, d'autres beans et de divers paramètres de propriété.

@SpringBootApplication

Cette annotation est utilisée dans la classe d'application lors de la configuration d'un projet Spring Boot. La classe annotée avec @SpringBootApplication doit être conservée dans le package de base. La seule chose que fait @SpringBootApplication est une analyse de composant. Mais elle va scanner seulement ses sous-paquets. Par exemple, si vous mettez la classe annotée avec @SpringBootApplication dans com.exemple, alors @SpringBootApplication balaiera tous ses sous-packages, tels que com.exemple.a, com.exemple.b et com.exemple.a.x.

Le @SpringBootApplication est une annotation pratique qui ajoute tout ce qui suit:

• @Configuration
• @EnableAutoConfiguration
• @ComponentScan

Annotations Spring MVC et REST 

@Controller

Cette annotation est utilisée sur les classes Java qui jouent le rôle de contrôleur dans votre application. L'annotation @Controller permet l'auto-détection des classes de composants dans les définitions de chemin de classe et d'enregistrement automatique des beans. Pour activer l'auto-détection de ces contrôleurs annotés, vous pouvez ajouter l'analyse des composants à votre configuration. La classe Java annotée avec @Controller est capable de gérer plusieurs mapping de requêtes.
Cette annotation peut être utilisée avec Spring MVC et Spring WebFlux.

@RequestMapping

Cette annotation est utilisée au niveau de la classe et de la méthode. L'annotation @RequestMapping est utilisée pour mapper des requêtes Web sur des classes et des méthodes de gestionnaires spécifiques. Lorsque @RequestMapping est utilisé au niveau de la classe, elle crée un URI de base pour lequel le contrôleur sera utilisé. Lorsque cette annotation est utilisée sur des méthodes, elle vous donnera l'URI sur lequel les méthodes du gestionnaire seront exécutées. À partir de là, vous pouvez déduire que le mapping de requête au niveau classe restera le même et que chaque méthode de gestionnaire aura sa propre requête mapping .

Parfois, vous voudrez peut-être effectuer différentes opérations en fonction de la méthode HTTP utilisée, même si l'URI de la requête peut rester la même. Dans de telles situations, vous pouvez utiliser l'attribut method de @RequestMapping avec une valeur de méthode HTTP pour restreindre les méthodes HTTP afin d'appeler les méthodes de votre classe.
Voici un exemple de base du fonctionnement d'un contrôleur avec les requêtes du mapping :

@Controller

@RequestMapping("/welcome")

public class WelcomeController {

    @RequestMapping(method = RequestMethod.GET)

    public String welcomeAll() {

        return "welcome all";

    }

}

Dans cet exemple, seules les requêtes GET à "/welcome" sont gérées par la méthode welcomeAll().

L'annotation @RequestMapping est très polyvalente. Cette annotation peut également être utilisée avec Spring MVC et Spring WebFlux.

@CookieValue

Cette annotation est utilisée au niveau du paramètre de méthode. @CookieValue est utilisé comme argument d'une méthode de mapping de requête. Le cookie HTTP est lié au paramètre @CookieValue pour un nom de cookie donné. Cette annotation est utilisée dans la méthode annotée avec @RequestMapping.

Considérons que la valeur de cookie suivante est reçue avec une requête HTTP:

JSESSIONID = 418AB76CD83EF94U85YD34W

Pour obtenir la valeur du cookie, utilisez @CookieValue comme ceci:

@ReuestMapping("/cookieValue")

    public void getCookieValue(@CookieValue "JSESSIONID" String cookie){

}

@CrossOrigin

Cette annotation est utilisée à la fois au niveau de la classe et de la méthode pour permettre les demandes d'origine croisée. Dans de nombreux cas, l'hôte qui sert JavaScript (front-end) sera différent de l'hôte qui sert les données (back-end). Dans un tel cas, le partage de ressources d'origine croisée (CORS) permet la communication entre domaines. Pour activer cette communication, il suffit d'ajouter l'annotation @CrossOrigin.

Par défaut, l'annotation @CrossOrigin autorise toutes les origines, tous les en-têtes, les méthodes HTTP spécifiées dans l'annotation @ RequestMapping et une valeur maxAge de 30 min. Vous pouvez personnaliser le comportement en spécifiant les valeurs d'attribut correspondantes.

Voici un exemple d'utilisation de @CrossOrigin aux niveaux de la méthode du contrôleur et du gestionnaire:

@CrossOrigin(maxAge = 3600)

@RestController

@RequestMapping("/account")

public class AccountController {

    @CrossOrigin(origins = "http://example.com")

    @RequestMapping("/message")

    public Message getMessage() {

        // ...

    }

    @RequestMapping("/note")

    public Note getNote() {

        // ...

    }

}

Dans cet exemple, les méthodes getExample () et getNote () auront une valeur maxAge de 3600 secondes. De plus, getExample () autorisera uniquement les requêtes d'origine croisée à partir de http://example.com, tandis que getNote () autorisera les demandes d'origine croisée provenant de tous les hôtes.

Composées variantes de @RequestMapping 

Spring framework 4.3 a introduit les variantes au niveau méthode de l'annotation @RequestMapping pour mieux exprimer la sémantique des méthodes annotées. L'utilisation de ces annotations est devenue la norme de définition des points de terminaison. Ils agissent comme des wrappers à @RequestMapping.

Ces annotations peuvent être utilisées avec Spring MVC et Spring WebFlux.

@GetMapping

Cette annotation est utilisée pour mapper des requêtes HTTP GET sur des méthodes de gestionnaire spécifiques. @GetMapping est une annotation composée qui agit comme un raccourci pour @RequestMapping (method = RequestMethod.GET).

@PostMapping

Cette annotation est utilisée pour mapper des requêtes HTTP POST sur des méthodes de gestionnaire spécifiques. @PostMapping est une annotation composée qui agit comme un raccourci pour @RequestMapping (method = RequestMethod.POST).

@PutMapping

Cette annotation est utilisée pour mapper les requêtes HTTP PUT sur des méthodes de gestionnaire spécifiques. @PutMapping est une annotation composée qui agit comme un raccourci pour @RequestMapping (method = RequestMethod.PUT).

@PatchMapping

Cette annotation est utilisée pour mapper des requêtes HTTP PATCH sur des méthodes de gestionnaire spécifiques. @PatchMapping est une annotation composée qui agit comme un raccourci pour @RequestMapping (method = RequestMethod.PATCH).

@DeleteMapping

Cette annotation est utilisée pour mapper des requêtes HTTP DELETE sur des méthodes de gestionnaire spécifiques. @DeleteMapping est une annotation composée qui agit comme un raccourci pour @RequestMapping (method = RequestMethod.DELETE).

@ExceptionHandler

Cette annotation est utilisée aux niveaux de la méthode pour gérer les exceptions au niveau du contrôleur. L'annotation @ExceptionHandler est utilisée pour définir la classe d'exception qu'il va catcher. Vous pouvez utiliser cette annotation sur les méthodes qui doivent être appelées pour gérer une exception. Les valeurs @ExceptionHandler peuvent être définies sur un tableau de types Exception. Si une exception est renvoyée correspondant à l'un des types de la liste, la méthode annotée avec le @ExceptionHandler correspondant sera invoquée.

@InitBinder

Cette annotation est une annotation au niveau de la méthode qui joue le rôle d'identifier les méthodes qui initialisent theWebDataBinder - un DataBinder permet de lier le paramètre de requête aux objets JavaBean. Pour personnaliser la liaison des données de paramètre de requête, vous pouvez utiliser des méthodes annotées @InitBinder dans notre contrôleur. Les méthodes annotées avec @InitBinder incluent tous les types d'arguments supportés par les méthodes de gestionnaire.

Les méthodes annotées @InitBinder seront appelées pour chaque requête HTTP si vous ne spécifiez pas l'élément value de cette annotation. L'élément de valeur peut être un ou plusieurs noms de formulaire ou des paramètres de requête auxquels la méthode de lieur init est appliquée.

@Mappings et @Mapping

Cette annotation est utilisée dans les champs. L'annotation @Mapping est une méta-annotation qui indique une annotation de mappage Web. Lors du mappage de différents noms de champs, vous devez configurer le champ source sur son champ cible, et pour ce faire, vous devez ajouter l'annotation @Mappings. Cette annotation accepte un tableau de @Mapping ayant les champs source et cible.

@MatrixVariable

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes afin que Spring puisse injecter les bits pertinents d'une URI matricielle. Les variables matricielles peuvent apparaître sur n'importe quel segment séparé par un point-virgule. Si une URL contient des variables matricielles, le modèle de mappage de demande doit les représenter avec un modèle d'URI. L'annotation @MatrixVariable garantit que la requête est mise en correspondance avec les variables matricielles correctes de l'URI.

@PathVariable

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes. L'annotation @RequestMapping peut être utilisée pour gérer les changements dynamiques dans l'URI où une certaine valeur d'URI agit comme un paramètre. Vous pouvez spécifier ce paramètre en utilisant une expression régulière. L'annotation @PathVariable peut être utilisée pour déclarer ce paramètre.

@RequestAttribute

Cette annotation est utilisée pour lier l'attribut de requête à un paramètre de méthode de gestionnaire. Spring récupère la valeur de l'attribut nommé pour remplir le paramètre annoté avec @RequestAttribute. Alors que @RequestParam est utilisé pour lier les valeurs de paramètre à partir d'une chaîne de requête, @RequestAttribute est utilisé pour accéder aux objets qui ont été renseignés côté serveur.

@RequestBody

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes. L'annotation @RequestBody indique qu'un paramètre de méthode doit être lié à la valeur du corps de la requête HTTP. Le HttpMessageConveter est responsable de la conversion du message de requête HTTP en objet.

@RequestHeader

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes. L'annotation @RequestHeader est utilisée pour mapper le paramètre du contrôleur pour demander la valeur de l'en-tête. Lorsque Spring mappe la requête, @RequestHeader vérifie l'en-tête avec le nom spécifié dans l'annotation et lie sa valeur au paramètre de méthode de gestionnaire. Cette annotation vous aide à obtenir les détails d'en-tête dans la classe de contrôleur.

@RequestParam

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes. Parfois, vous obtenez les paramètres dans l'URL de la requête, principalement dans les requêtes GET. Dans ce cas, avec l'annotation @RequestMapping, vous pouvez utiliser l'annotation @RequestParam pour récupérer le paramètre d'URL et l'associer à l'argument de la méthode. L'annotation @ RequestParam est utilisée pour lier les paramètres de requête à un paramètre de méthode dans votre contrôleur.

@RequestPart

Cette annotation est utilisée pour annoter les arguments de la méthode du gestionnaire de requêtes. L'annotation @RequestPart peut être utilisée à la place de @RequestParam pour obtenir le contenu d'une multipart spécifique et la lier à l'argument de méthode annoté avec @RequestPart. Cette annotation prend en compte l'en-tête "Content-Type" dans la multipart (partie de requête).

@ResponseBody

Cette annotation est utilisée pour annoter les méthodes du gestionnaire de requêtes. L'annotation @ResponseBody est similaire à l'annotation @ RequestBody. L'annotation @ResponseBody indique que le type de résultat doit être écrit directement dans le corps de la réponse dans le format que vous spécifiez comme JSON ou XML. Spring convertit l'objet retourné dans un corps de réponse en utilisant HttpMessageConveter.

@ResponseStatus

Cette annotation est utilisée sur les méthodes et les classes d'exception. @ResponseStatus marque une méthode ou une classe d'exception avec un code d'état et une raison qui doit être renvoyée. Lorsque la méthode gestionnaire est appelée, le code d'état est défini sur la réponse HTTP qui remplace les informations d'état fournies par tout autre moyen. Une classe de contrôleur peut également être annotée avec @ResponseStatus, qui est ensuite héritée par toutes les méthodes @RequestMapping.

@ControllerAdvice

Cette annotation est appliquée au niveau de la classe. Comme expliqué précédemment, pour chaque contrôleur, vous pouvez utiliser @ExceptionHandler sur une méthode qui sera appelée lorsqu'une exception donnée se produit. Mais cela ne gère que les exceptions qui se produisent dans le contrôleur dans lequel il est défini. Pour résoudre ce problème, vous pouvez maintenant utiliser l'annotation @ ControllerAdvice. Cette annotation est utilisée pour définir les méthodes @ExceptionHandler, @InitBinder et @ModelAttribute qui s'appliquent à toutes les méthodes @RequestMapping. Ainsi, si vous définissez l'annotation @ExceptionHandler sur une méthode dans une classe @ControllerAdvice, elle sera appliquée à tous les contrôleurs.

@RestController

Cette annotation est utilisée au niveau de la classe. L'annotation @RestController marque la classe en tant que contrôleur où chaque méthode renvoie un objet de domaine au lieu d'une vue. En annotant une classe avec, vous n'avez plus besoin d'ajouter @ResponseBody à toutes les méthodes RequestMapping. Cela signifie que vous n'utiliserez plus de view-resolvers ou d'envoyer du HTML en réponse. Vous venez d'envoyer l'objet de domaine en tant que réponse HTTP dans le format qui est compris par les consommateurs, comme JSON.

@RestController est une annotation de commodité qui combine @Controller et @ResponseBody.

@RestControllerAdvice

Cette annotation est appliquée aux classes Java. @RestControllerAdvice est une annotation de commodité qui combine @ControllerAdvice et @ResponseBody. Cette annotation est utilisée avec l'annotation @ExceptionHandler pour gérer les exceptions qui se produisent dans le contrôleur.

@SessionAttribute

Cette annotation est utilisée au niveau du paramètre de méthode. L'annotation @SessionAttribute est utilisée pour lier le paramètre de méthode à un attribut de session. Cette annotation fournit un accès pratique aux attributs de session existants ou permanents.

@SessionAttributes

Cette annotation est appliquée au niveau du type pour un gestionnaire spécifique. L'annotation @SessionAtrributes est utilisée lorsque vous souhaitez ajouter un objet JavaBean dans une session. Ceci est utilisé lorsque vous voulez garder l'objet en session pour une courte durée de vie. @SessionAttributes est utilisé avec @ModelAttribute.

Prenons cet exemple:

@ModelAttribute("person")

public Person getPerson() {}

// within the same controller as above snippet

@Controller

@SeesionAttributes(value = "person", types = {

    Person.class

})

public class PersonController {}

Le nom @ModelAttribute est affecté à @SessionAttributes en tant que valeur. Le @SessionAttributes a deux éléments. L'élément value est le nom de la session dans le modèle et l'élément types est le type d'attributs de session dans le modèle.

Annotations de Spring Cloud

@EnableConfigServer

Cette annotation est utilisée au niveau de la classe. Lorsque vous développez un projet avec un certain nombre de services, vous devez disposer d'une méthode centralisée et simple pour configurer et récupérer les configurations de tous les services que vous allez développer. L'un des avantages de l'utilisation d'un serveur de configuration centralisé est que vous n'avez pas besoin de vous rappeler où chaque configuration est répartie entre plusieurs composants distribués.

Vous pouvez utiliser l'annotation @EnableConfigServer de Spring Cloud pour démarrer un serveur de configuration auquel les autres applications peuvent s'adresser.

@EnableEurekaServer

Cette annotation est appliquée aux classes Java. Un problème que vous pouvez rencontrer lors de la décomposition de votre application en microservices est qu'il devient difficile pour chaque service de connaître l'adresse de tous les autres services dont il dépend. Et l'a le rôle de ce service de découverte qui est chargé de suivre les emplacements de tous les autres microservices.
Eureka de Netflix est une implémentation d'un serveur de découverte et l'intégration est fournie par Spring Boot. Spring Boot a facilité la création d'un serveur Eureka en annotant simplement la classe d'entrée avec @EnableEurekaServer.

@EnableDiscoveryClient

Cette annotation est appliquée aux classes Java. Pour indiquer à une application de s'enregistrer auprès d'Eureka, il suffit d'ajouter @EnableDiscoveryClient au point d'entrée de l'application. L'application désormais enregistrée auprès d'Eureka utilise l'abstraction Spring Cloud Discovery Client pour interroger le registre sur son propre hôte et port.

@EnableCircuitBreaker

Cette annotation est appliquée aux classes Java qui peuvent agir comme disjoncteur. Le modèle de disjoncteur peut permettre à un microservice de continuer à fonctionner lorsqu'un service connexe tombe en panne, empêchant ainsi la défaillance de tomber en cascade. Cela donne également un délai de récupération au service défaillant.

La classe annotée avec @EnableCircuitBreaker surveille, ouvre et ferme le disjoncteur.

@HystrixCommand

Cette annotation est utilisée au niveau de la méthode. La bibliothèque Hystrix de Netflix fournit la mise en œuvre d'un modèle de disjoncteur. Lorsque vous appliquez le disjoncteur à une méthode, Hystrix surveille les défaillances de la méthode. Une fois que les défaillances atteignent un seuil, Hystrix ouvre le circuit de sorte que les appels suivants échouent également. Maintenant, Hystrix redirige les appels vers la méthode et les transmet aux méthodes de secours spécifiées.

Hystrix recherche toute méthode annotée avec l'annotation @HystrixCommand et l'enveloppe dans un proxy connecté à un disjoncteur afin que Hystrix puisse le surveiller.

Prenons l'exemple suivant:

@Service

public class BookService {

    private final RestTemplate restTemplate;

    public BookService(RestTemplate rest) {

        this.restTemplate = rest;

    }

    @HystrixCommand(fallbackMethod = "newList") public String bookList() {

        URI uri = URI.create("http://localhost:8081/recommended");

        return this.restTemplate.getForObject(uri, String.class);

    }

    public String newList() {

        return "Cloud native Java";

    }

}

Ici, @HystrixCommand est appliqué à la méthode originale bookList(). L'annotation @HystrixCommand a newList() comme méthode de secours. Donc, pour une raison quelconque, si Hystrix ouvre le circuit sur bookList(), vous aurez une liste de livres réservés pour les utilisateurs.

Annotations Spring DataAccess

@Transactional

Cette annotation est placée avant une définition d'interface, une méthode sur une interface, une définition de classe ou une méthode publique sur une classe. La simple présence de @Transactional n'est pas suffisante pour activer le comportement transactionnel. Le @Transactional est simplement des métadonnées qui peuvent être consommées par certaines infrastructures d'exécution. Cette infrastructure utilise les métadonnées pour configurer les beans appropriés avec un comportement transactionnel.

L'annotation prend en charge la configuration comme:

• Le type de propagation de la transaction
• Le niveau d'isolement de la transaction
• Un délai d'attente pour l'opération enveloppée par la transaction
• Un indicateur en lecture seule - un indice pour le fournisseur de persistance que la transaction doit être lue uniquement 
• Les règles de restauration de la transaction

Annotations basées sur le cache

@Cacheable

Cette annotation est utilisée pour les méthodes. Le moyen le plus simple d'activer le comportement du cache pour une méthode est de l'annoter avec @Cacheable et de le paramétrer avec le nom du cache où les résultats seront stockés.

@Cacheable("addresses")

public String getAddress(Book book){...}

Dans l'extrait ci-dessus, la méthode getAddress est associée au cache nommé addresses. Chaque fois que la méthode est appelée, le cache est vérifié pour voir si l'invocation a déjà été exécutée et ne doit pas être répétée.

@CachePut

Cette annotation est utilisée pour les méthodes. Chaque fois que vous devez mettre à jour le cache sans interférer avec l'exécution de la méthode, vous pouvez utiliser l'annotation @CachePut. Autrement dit, la méthode sera toujours exécutée et le résultat mis en cache.

@CachePut("addresses")

public String getAddress(Book book){...}

L'utilisation de @CachePut et de @Cacheable sur la même méthode est fortement déconseillée, car la première force l'exécution afin d'exécuter une mise à jour du cache, cette dernière provoque l'exécution de l'exécution de la méthode en utilisant le cache.

@CacheEvict

Cette annotation est utilisée pour les méthodes. Vous ne voulez pas toujours peupler le cache avec de plus en plus de données. Parfois, vous voudrez peut-être supprimer des données de cache afin de pouvoir remplir le cache avec des valeurs fraîches. Dans ce cas, utilisez l'annotation @CacheEvict.

@CacheEvict(value="addresses", allEntries="true")

public String getAddress(Book book){...}

Ici, un élément supplémentaire, allEntries, est utilisé avec le nom du cache à vider. Il est défini sur true afin qu'il efface toutes les valeurs et se prépare à stocker de nouvelles données.

@CacheConfig

Cette annotation est une annotation au niveau de la classe. L'annotation @CacheConfig permet de rationaliser certaines informations de cache à un endroit. Placer cette annotation sur une classe n'active aucune opération de mise en cache. Cela vous permet de stocker la configuration du cache au niveau de la classe afin que vous n'ayez pas à déclarer les choses plusieurs fois.

Exécution de tâches et annotations de planification

@Scheduled

Cette annotation est une annotation au niveau de la méthode. L'annotation @Scheduled est utilisée sur les méthodes avec les métadonnées du déclencheur. Une méthode avec @Scheduled doit avoir un type de retour void et ne doit pas accepter de paramètre.
Il existe différentes manières d'utiliser l'annotation @Scheduled:

@Scheduled(fixedDelay=5000)

public void doSomething() {

    // something that should execute periodically   

}

Dans ce cas, la durée entre la fin de la dernière exécution et le début de la prochaine exécution est fixée. Les tâches attendent toujours jusqu'à ce que la précédente soit terminée.

@Scheduled(fixedRate=5000)

public void doSomething() { 

    // something that should execute periodically 

}

Dans ce cas, le début de l'exécution de la tâche n'attend pas l'achèvement de l'exécution précédente.

@Scheduled(initialDelay=1000,fixedRate=5000)

public void doSomething() { 

   // something that should execute periodically after an initial delay  

}

La tâche est exécutée initialement avec un délai, puis continue avec le taux fixe spécifié.

@Async

Cette annotation est utilisée sur les méthodes pour exécuter chaque méthode dans un thread séparé. L'annotation @Async est fournie sur une méthode afin que l'appel de cette méthode se produise de manière asynchrone. Contrairement aux méthodes annotées avec @Scheduled, les méthodes annotées avec @Async peuvent prendre des arguments. Ils seront invoqués normalement par les appelants au moment de l'exécution plutôt que par une tâche planifiée.

@Async peut être utilisé avec les méthodes de type void return et les méthodes qui renvoient une valeur. Cependant, les méthodes avec des valeurs de retour doivent avoir une future valeur de retour typée.

Annotations de test de Spring

@BootstrapWith

Cette annotation est une annotation au niveau de la classe. L'annotation @BootstrapWith est utilisée pour configurer l'amorçage de Spring TestContext Framework. Cette annotation est utilisée en tant que métadonnées pour créer des annotations composées personnalisées et réduire la duplication de configuration dans une suite de tests.

@ContextConfiguration

Cette annotation est une annotation de niveau classe qui définit les métadonnées utilisées pour déterminer les fichiers de configuration à utiliser pour charger le ApplicationContext pour votre test. Plus précisément, @ContextConfiguration déclare les classes annotées qui seront utilisées pour charger le contexte. Vous pouvez également indiquer à Spring où trouver le fichier.

@ContextConfiguration(locations={"example/test-context.xml", loader = Custom ContextLoader.class})

@WebAppConfiguration

Cette annotation est une annotation au niveau de la classe. La @WebAppConfiguration est utilisée pour déclarer que ApplicationContext, chargé pour un test d'intégration, doit être un WebApplicationContext. Cette annotation est utilisée pour créer la version Web du contexte d'application. Il est important de noter que cette annotation doit être utilisée avec l'annotation @ContextConfiguration. Le chemin d'accès par défaut à la racine de l'application Web est src / main / webapp. Vous pouvez le remplacer en transmettant un chemin différent au @WebAppConfiguration

@Timed

Cette annotation est utilisée pour les méthodes. L'annotation @Timed indique que la méthode de test annotée doit terminer son exécution à la période spécifiée (en millisecondes). Si l'exécution dépasse l'heure spécifiée dans l'annotation, le test échoue.

@Timed(millis=10000)

public void testLongRunningProcess() {  ... }

Dans cet exemple, le test échouera s'il dépasse 10 secondes d'exécution.

@Repeat

Cette annotation est utilisée pour les méthodes de test. Si vous souhaitez exécuter une méthode de test plusieurs fois de suite automatiquement, vous pouvez utiliser l'annotation @Repeat. Le nombre de fois que la méthode de test doit être exécutée est spécifié dans l'annotation.

@Repeat(10)

@Test

public void testProcessRepeatedly() {  ... }

Dans cet exemple, le test sera exécuté 10 fois.

@Commit

Cette annotation peut être utilisée à la fois comme annotation au niveau de la classe ou au niveau de la méthode. Après l'exécution d'une méthode de test, la transaction de la méthode de test transactionnelle peut être validée à l'aide de l'annotation @Commit. Cette annotation exprime explicitement l'intention du code. Lorsqu'elle est utilisée au niveau de la classe, cette annotation définit la validation de toutes les méthodes de test dans la classe. Lorsqu'il est déclaré en tant qu'annotation au niveau de la méthode, @Commit spécifie la validation pour des méthodes de test spécifiques remplaçant la validation au niveau de la classe.

@RollBack

Cette annotation peut être utilisée à la fois comme annotation au niveau de la classe et au niveau de la méthode. L'annotation @RollBack indique si la transaction d'une méthode de test transactionnelle doit être annulée une fois le test terminé. Si cela est vrai, @Rollback (true), la transaction est annulée. Sinon, la transaction est validée. @Commit est utilisé à la place de @RollBack (false).
Lorsqu'elle est utilisée au niveau de la classe, cette annotation définit la restauration pour toutes les méthodes de test de la classe.
Lorsqu'elle est déclarée en tant qu'annotation de niveau méthode, @RollBack spécifie l'annulation pour des méthodes de test spécifiques remplaçant la sémantique de restauration de niveau classe.

@DirtiesContext

Cette annotation est utilisée à la fois comme annotation au niveau de la classe et au niveau de la méthode. @DirtiesContext indique que Spring ApplicationContext a été modifié ou corrompu d'une manière ou d'une autre et qu'il doit être fermé. Cela déclenchera le rechargement du contexte avant l'exécution du test suivant. L'ApplicationContext est marqué comme dirty avant ou après toute méthode annotée ainsi qu'avant ou après la classe de test en cours.

L'annotation @DirtiesContext prend en charge les modes BEFORE_METHOD, BEFORE_CLASS et BEFORE_EACH_TEST_METHOD pour fermer ApplicationContext avant un test.

REMARQUE: évitez d'utiliser trop cette annotation. C'est une opération coûteuse et si abusée, elle peut vraiment ralentir votre suite de tests.

@BeforeTransaction

Cette annotation est utilisée pour annoter les méthodes void dans la classe de test. Les méthodes annotées @BeforeTransaction indiquent qu'elles doivent être exécutées avant l'exécution de toute transaction. Cela signifie que la méthode annotée avec @BeforeTransaction doit être exécutée avant toute méthode annotée avec @Transactional.

@AfterTransaction

Cette annotation est utilisée pour annoter les méthodes void dans la classe de test. Les méthodes annotées @AfterTransaction indiquent qu'elles doivent être exécutées après la fin d'une transaction pour les méthodes de test. Cela signifie que la méthode annotée avec @AfterTransaction doit être exécutée après la méthode annotée avec @Transactional.

@Sql

Cette annotation peut être déclarée sur une classe de test ou une méthode de test pour exécuter des scripts SQL sur une base de données. L'annotation @Sql configure le chemin de ressource vers les scripts SQL qui doivent être exécutés sur une base de données donnée avant ou après une méthode de test d'intégration. Lorsque @Sql est utilisé au niveau de la méthode, il remplace tout @Sql defini au niveau de la classe.

@SqlConfig

Cette annotation est utilisée avec l'annotation @Sql. L'annotation @SqlConfig définit les métadonnées utilisées pour déterminer comment analyser et exécuter les scripts SQL configurés via l'annotation @Sql. Lorsqu'elle est utilisée au niveau de la classe, cette annotation sert de configuration globale pour tous les scripts SQL de la classe de test. Mais lorsqu'elle est utilisée directement avec l'attribut config de @Sql, @SqlConfig sert de configuration locale pour les scripts SQL déclarés.

@SqlGroup

Cette annotation est utilisée pour les méthodes. L'annotation @SqlGroup est une annotation de conteneur pouvant contenir plusieurs annotations @SQL. Cette annotation peut déclarer des annotations @Sql imbriquées.

En outre, @SqlGroup est utilisé comme une méta-annotation pour créer des annotations composées personnalisées. Cette annotation peut également être utilisée avec des annotations répétables, où @Sql peut être déclaré plusieurs fois sur la même méthode ou classe.

@SpringBootTest

Cette annotation est utilisée pour démarrer le contexte Spring pour les tests d'intégration. Cela fera apparaître le contexte complet d'autoconfiguration.

@DataJpaTest

L'annotation @DataJpaTest ne fournira que l'auto-configuration requise pour tester Spring Data JPA à l'aide d'une base de données en mémoire telle que H2.

Cette annotation est utilisée à la place de @SpringBootTest

@DataMongoTest

@DataMongoTest fournira une auto-configuration minimale et un MongoDB intégré pour exécuter des tests d'intégration avec Spring Data sur MongoDB.

@WebMVCTest

@WebMVCTest affichera un contexte de servlet simulé pour tester la couche MVC. Les services et composants ne sont pas chargés dans le contexte. L'annotation @MockBean est généralement utilisée pour fournir ces dépendances pour les tests,

@AutoConfigureMockMVC

L'annotation @AutoConfigureMockMVC fonctionne de manière très similaire à l'annotation @WebMVCTest, mais le contexte Spring Boot complet est démarré.

@MockBean

Crée et injecte un Mockito Mock pour la dépendance donnée.

@JsonTest

Limitera la configuration automatique de Spring Boot aux composants pertinents pour le traitement de JSON.

Cette annotation va également configurer automatiquement une instance de JacksonTester ou GsonTester.

@TestPropertySource

Annotation au niveau de la classe utilisée pour spécifier les sources de propriété pour la classe de test.