Annotations communes pour les frameworks Spring, SpringMVC, SpringBoot et SpringCloud

Language 2023-07-21 07:31:21 views: null

Annotations communes du printemps

Remarques relatives à la classe de configuration de configuration

  • @Configuration : annoté sur la classe, déclarant la classe en tant que classe de configuration Spring

    Lorsque Spring démarre, il analyse et charge automatiquement toutes les classes de configuration, configure le conteneur Spring (contexte de l'application) et place le Bean dans la classe de configuration dans la gestion des conteneurs.

  • @Bean : annoté sur la méthode dans la classe de configuration Spring, enregistrant l'objet bean dans le conteneur IOC

    • attribut name : spécifiez un drapeau unique pour le bean généré

    Lorsque le conteneur Spring démarre, il analyse et exécute automatiquement toutes les méthodes configurées avec @Bean et stocke la valeur de retour dans le conteneur Spring.

    Avis:

    • La méthode marquée doit retourner une instance
    • La méthode marquée peut configurer les paramètres d'attribut dépendants, et Spring obtiendra automatiquement l'objet dépendant du conteneur et appellera automatiquement la méthode

  • @Primary : dans certains cas, plusieurs beans du même type doivent être enregistrés. À ce stade, @Primary peut être utilisé pour donner à un bean une priorité plus élevée

  • @ComponentScan : activez l'analyse des packages (prise en charge par les annotations Spring IOC) et analysez toutes les classes sous le package et les sous-packages actuels par défaut

    • Attribut basePackage : spécifie le chemin d'accès au package analysé. peut réduire le temps de chargement

    Si les annotations IOC sur la classe sont analysées, la classe actuelle sera transmise au conteneur IOC pour gestion. Au démarrage du conteneur, l'objet sera automatiquement créé et stocké dans le conteneur

    Si l'analyse trouve qu'il y a des annotations DI sur la propriété, injectez des valeurs dans la propriété selon les règles d'injection de dépendance

  • @PropertySource : Charger les fichiers de propriétés locaux dans la gestion des conteneurs Spring

    • attribut value : spécifiez le chemin des propriétés locales

  • @Import : Importe le contenu d'autres classes de configuration dans une classe de configuration

    • attribut value : spécifiez le chemin d'accès à la classe des autres classes de configuration

    Spring prend en charge plusieurs classes de configuration (modules de classes de configuration). Si la classe de configuration est gonflée, vous pouvez diviser la classe de configuration, puis introduire des classes de sous-configuration dans la classe de configuration principale (aucune annotation de configuration n'est requise sur les classes de sous-configuration).

  • @Conditionnel

    @Condition est une fonction de jugement de condition ajoutée dans Spring 4.0. Grâce à cette fonction, la création sélective d'opérations Bean peut être réalisée.

    @Conditional est marqué sur la classe de configuration ou sur la méthode de la classe de configuration. Il est utilisé conjointement avec @Configuration. Lorsque les conditions spécifiées par @Conditional sont remplies, le contenu de la classe de configuration prend effet

    Annotations de condition communes SpringBoot :

    • @ConditionalOnBean : le bean spécifié existe dans le conteneur

    • @ConditionalOnMissingBean : le bean spécifié n'existe pas dans le conteneur

      • attribut value : un tableau d'objets Class de la classe à utiliser comme condition
      • attribut type : tableau de noms de la classe comme condition (Class.getName())
      • propriété d'annotation : le bean a le tableau d'annotations spécifié
      • attribut name : le nom du bean dans le conteneur spring

    • @ConditionalOnProperty : Si la propriété spécifiée dans le système a la valeur spécifiée

      • attribut valeur / nom : nom de la configuration, nom complet ou nom partiel (le nom et la valeur ne peuvent pas être utilisés en même temps)

        Peut être utilisé avec le préfixe

        Vous pouvez passer un tableau pour prendre en charge la combinaison de plusieurs conditions (logique de condition multiple ET)

        Pour utiliser plusieurs OU conditionnels :

        • Méthode 1 : Utilisez @ConditionalOnExpression pour écrire des expressions "ou logiques"

          @ConditionalOnExpression("${app.dictionary:false} || ${app.all:false}")

        • Méthode 2 : Utilisez @ConditionalOnExpression pour écrire des expressions imbriquées "valeur par défaut"

          @ConditionalOnExpression("${app.dictionary:${app.all:false}}")

      • attribut de préfixe : préfixe de configuration (facultatif)

      • attribut havingValue : valeur de comparaison, utilisée en combinaison avec le nom, si la valeur est la même que la valeur dans la configuration, la configuration prendra effet, sinon la même, la configuration ne prendra pas effet

      • Attribut matchIfMissing : s'il peut être chargé lorsque cet attribut de configuration est manquant.

        Lorsque la configuration est manquante, true : charge normalement, false : signale une erreur. La valeur par défaut est false

    • @ConditionalOnClass : Il existe une classe spécifiée dans le système

    • @ConditionalOnMissingClass : la classe spécifiée n'existe pas dans le système

    • @ConditionalOnExpression : satisfait la spécification d'expression SpEL

    • @ConditionalOnSingleCandidate : il n'y a qu'un seul bean spécifié dans le conteneur, ou ce bean est le bean préféré

    • @ConditionalOnResource : si le fichier de ressources spécifié existe dans le chemin de classe

    • @ConditionalOnWebApplication : l'environnement web actuel

    • @ConditionalOnNotWebApplication : Actuellement pas un environnement web

    • @ConditionalOnJava : si la version Java du système répond aux exigences


Remarques sur IOC (conteneur)

  • @Controller : généralement marqué sur la classe de la couche présentation (couche web)
  • @Service : Généralement marqué sur la classe de la couche métier (couche service)
  • @Repository : Généralement marqué sur la classe de la couche de persistance (couche dao)
  • @Component : composant, utilisé sur les classes qui ne sont pas dans le cadre du modèle à trois niveaux

Descriptif :

  • Marqué sur la classe qui veut être gérée par le conteneur IOC, indiquant que la création de l'objet est confiée à la gestion du conteneur
  • Lorsque le conteneur Spring démarre, il analyse automatiquement les annotations IOC en fonction de la configuration d'analyse du package, crée les objets annotés par réflexion, les stocke dans le conteneur et délègue la gestion du conteneur.
  • L'id (identifiant unique) stocké dans le conteneur par défaut est les initiales minuscules du nom de la classe en cours. Vous pouvez personnaliser l'identifiant de l'objet stocké dans le conteneur via l'attribut value

Annotation @Import : importez la classe dans le conteneur Spring IOC

Il existe de nombreuses façons d'ajouter une classe à la gestion des conteneurs IOC, comme @Bean, @Component, etc. @Import est un autre moyen, plus rapide.

Trois méthodes sont prises en charge :

  • Classes de configuration avec @Configuration (seules les classes de configuration peuvent être importées avant la version 4.2, et les classes ordinaires peuvent également être importées après la version 4.2)
  • Implémentation d'ImportSelector
  • Implémentation de ImportBeanDefinitionRegistrar

Utilisation principale :

  • Remplissez directement le tableau de classe

    @Configuration
@Import({
      
      User.class})   // 大括号中可以添加多个类，使用逗号分隔，例如 {User.class,UserInfo.class}
public class UserConfig {
      
      }

  • Méthode ImportSelector (la couche inférieure de Spring Boot utilise de nombreuses méthodes)

    // 自定义ImportSelector
public class MyImportSelector implements ImportSelector {
      
      
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      
      
        // 返回的是需要加载的类名数组  注意这里需要的是类的全路径
        return new String[]{
      
      "com.itheima.redis.entity.User"};
    }
}

    @Configuration
@Import(MyImportSelector.class)
public class UserConfig {
      
      }

  • Méthode ImportBeanDefinitionRegistrarImportBeanDefinitionRegistrar method

    Cette méthode est similaire à la méthode ImportSelector, mais cette méthode peut personnaliser le nom du Bean dans le conteneur

    // 自定义ImportBeanDefinitionRegistrar
public class TestImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
      
      
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
      
      
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TestD.class);
        //自定义注册bean
        registry.registerBeanDefinition("testD1111",rootBeanDefinition);
    }
}

    @Import({
      
      TestImportBeanDefinitionRegistrar.class})
@Configuration
public class ImportConfig {
      
      }
  • Remarque : Les trois méthodes d'utilisation peuvent être utilisées dans un @Import. Il convient de noter que dans la méthode de tableau de classe et la méthode ImportSelector, le nom du bean dans le conteneur IOC est le nom de classe complet de la classe, tandis que la méthode ImportBeanDefinitionRegistrar est un nom personnalisé.

Notes relatives à l'injection de dépendance (DI)

Les annotations DI sont équivalentes à l'attribution directe de valeurs aux attributs sans recourir à des méthodes d'ensemble ou à des constructeurs

  • @Autowired

    Usage 1 : marque sur l'attribut

    • Attribuez des valeurs directement aux propriétés (via l'injection de dépendance @Autowired, pas besoin de configurer les méthodes set)
    • La valeur par défaut consiste à rechercher l'objet à partir du conteneur IOC sous la forme de par type (selon le type, c'est-à-dire le type d'interface) et à injecter des valeurs dans les propriétés
    • S'il existe plusieurs objets du même type que l'attribut dans le conteneur IOC (une interface a plusieurs classes d'implémentation),
      • La valeur par défaut consiste à rechercher l'objet à partir du conteneur en fonction du nom de l'attribut (par nom) en tant qu'identifiant unique et à injecter la valeur dans l'attribut
      • Peut être utilisé avec l'annotation @Qualifier pour spécifier un indicateur unique pour trouver des objets du conteneur et injecter des valeurs aux propriétés
        • value : spécifie l'identifiant unique (id) de l'objet dans le conteneur IOC

    Usage 2 : marqué sur la méthode

    • Indique que la méthode actuelle est exécutée automatiquement. Si la méthode a des paramètres, elle trouvera automatiquement des objets du même type dans le conteneur IOC pour passer des valeurs aux paramètres.
    • Vous pouvez également ajouter l'annotation @Qualifier("object id in the IOC container") au paramètre pour rechercher l'objet par son nom et transmettre la valeur au paramètre

    Précautions d'emploi

    1. L'annotation @Autowired ne peut être utilisée que dans les classes gérées par le conteneur Spring (annotées avec des annotations IOC telles que @Controller)

    2. L'injection automatique n'a rien à voir avec les modificateurs d'autorisation, même les champs modifiés privés peuvent être automatiquement injectés

    3. Par défaut, les propriétés automatiquement injectées à l'aide de l'annotation @Autowired doivent être assemblées (hébergement de conteneurs Spring)

      Si aucune fève de ce type ne peut être trouvée dans le conteneur pour injection, une erreur sera signalée

      S'il n'est pas autorisé à être assemblé, vous pouvez définir l'attribut requis de @Autowired sur false

    4. @Autowired est une injection basée sur le type. Si la propriété de type actuelle n'a qu'un seul bean dans le conteneur, le nom de la propriété n'est pas limité, mais il est généralement recommandé de suivre la règle de la première lettre minuscule du nom de la classe

    5. Si le type de propriété actuel a plusieurs beans dans le conteneur, le nom du bean doit être spécifié par le nom de la propriété ou l'annotation @Qualifier en même temps

  • @Qualifier : Lorsqu'il y a plusieurs beans du même type, @Qualifier("name") peut être utilisé pour spécifier. Ne peut être utilisé qu'avec @Autowired

  • @value : Il peut être utilisé pour l'injection de types de données simples, mais il n'est généralement pas utilisé de cette manière. marqué sur la propriété.

    Généralement utilisé pour analyser le contenu du fichier de configuration des propriétés ou du fichier de configuration du registre

    • Obtenez la valeur correspondante en fonction de la valeur de la clé, règles de syntaxe : @Value("${key}")
    • Étapes d'utilisation :
      1. Le fichier de configuration des propriétés est remis à la gestion du conteneur Spring
      2. Via @Value, récupérez l'élément de configuration du conteneur et injectez-le

  • @Resource (comprendre)

    Annotation d'injection de dépendance fournie par jdk, cette annotation a été supprimée dans jdk9 et supérieur

    • Ne peut être marqué que sur les propriétés des classes gérées par le conteneur Spring
    • Indique qu'il faut d'abord faire correspondre l'identifiant de l'objet dans le conteneur IOC en fonction du nom de l'attribut pour injecter une valeur dans l'attribut [par nom]
    • En cas d'échec, il continuera à injecter des valeurs en fonction du type de l'attribut actuel pour correspondre au même type d'objet dans le conteneur IOC [par type]
    • Si l'attribut name @Resource(name="object id") est spécifié, la valeur ne peut être injectée qu'en fonction de l'id de l'objet

Notes relatives à l'AOP (amélioration de la méthode)

  • @EnableAspectJAutoProxy : marqué sur la classe de configuration pour activer le support des annotations aop

  • @Aspect : annoté sur la classe personnalisée, déclarant la classe d'aspect

    Remarque : La classe d'aspect doit également être annotée avec les annotations IOC (@Component) et transmise à la gestion des conteneurs Spring.

  • Configurez le type de notification par annotation sur la méthode de notification (amélioration) dans la classe d'aspect :

    • @Before : pré-conseil
    • @AfterReturning : publier une notification
    • @AfterThrowing : notification d'exception
    • @After : notification finale
    • @Around : Autour de la notification

    Attributs des annotations de notification :

    • attribut value / argNames : expression pointcut ou nom de méthode annoté par @Pointcut()

      	@Around("pt()")
    public Object around(ProceedingJoinPoint pjp)

  • @Pointcut : Annoté sur la méthode vide dans la classe d'aspect, en extrayant l'expression publique pointcut

    • attribut value/argNames : expression pointcut
    • Le nom de la méthode de configuration d'annotation de notification () peut introduire des expressions de point de coupure publiques
        @Pointcut(value="execution(* cn.test.service.impl.*.*(..))")
    public void pt() {
      
      }

Notes sur la gestion des transactions

  • @EnableTransactionManagement : marqué sur la classe de configuration pour activer la prise en charge des annotations de transaction

  • @Transactional : configurer les transactions

    Propriétés communes :

    • Attribut rollbackFor : définit le tableau de classes d'exceptions à annuler. Lorsqu'une exception dans le tableau d'exceptions spécifié est levée dans la méthode, la transaction est annulée.

      • Spécifiez une seule classe d'exception : @Transactional(rollbackFor=Exception.class)

      • Spécifiez plusieurs classes d'exception : @Transactional(rollbackFor={RuntimeException.class, Exception.class})

    • attribut readOnly : s'il faut une transaction en lecture seule ( true | false (valeur par défaut) )

    • attribut de propagation : comportement de propagation des transactions ( SUPPORTS | REQUIRED (valeur par défaut) )

    • Attribut transactionManager : lorsque plusieurs gestionnaires de transactions sont hébergés dans le conteneur Spring, spécifiez le nom du bean du gestionnaire de transactions

    • attribut d'isolement : définit le niveau d'isolement des transactions de la base de données sous-jacente, qui est utilisé pour gérer la simultanéité de plusieurs transactions

      Habituellement, le niveau d'isolement par défaut de la base de données peut être utilisé, et il n'est fondamentalement pas nécessaire de le définir

    • Attribut noRollbackFor : définit le tableau de classes d'exceptions qui n'a pas besoin d'être annulé. Lorsque l'exception dans le tableau d'exceptions spécifié est levée dans la méthode, la transaction ne sera pas annulée.

    Description du poste d'étiquetage :

    • Marqué sur la classe : toutes les méthodes de cette classe ont la même configuration de transaction
    • Annoté sur la méthode : la méthode a une configuration de transaction
    • Marquer sur la classe et la méthode en même temps : le principe de proximité (la configuration transactionnelle sur la méthode prend effet)

Remarques sur le cycle de vie

  • @Scope : configure la portée de l'objet sur la classe

    Spécifiez la portée (singleton|prototype) via l'attribut value, et la valeur par défaut est singleton (singleton)

  • @PostConstruct : l'action de déclenchement après la création de l'objet de configuration

    Lorsque l'objet est créé, la méthode est automatiquement exécutée

  • @PreDestroy : L'action du déclencheur avant la destruction de l'objet de configuration (valide uniquement lorsque Scope = singleton)

    La méthode exécutée avant la fermeture du conteneur et la destruction de l'objet


Remarques sur les tests unitaires

  • @RunWith : définissez l'exécuteur du test unitaire et spécifiez l'environnement d'exécution du test unitaire via l'attribut value

    • SpringJUnit4ClassRunner.class : environnement de test Spring
    • SpringRunner.class : environnement de test Spring

    Note:

    • SpringRunner étend SpringJUnit4ClassRunner.class

    • SpringRunner et SpringJUnit4ClassRunner peuvent être utilisés avec JUnit4.12 ou version ultérieure

      Mais il est recommandé d'utiliser SpringRunner, type final, sûr

    • Les versions inférieures à JUnit 4.12 ne peuvent utiliser SpringJUnit4ClassRunner

  • @ContextConfiguration : Spécifie les informations de configuration du conteneur

    • attribut localtions : chemin du fichier de configuration
    • attribut classes : classe de configuration

Remarques sur les appels asynchrones

  • @EnableAsync : annoté sur la classe de démarrage ou la classe de configuration pour que l'annotation @Async prenne effet

  • @Async : annoté sur une méthode pointcut asynchrone, indiquant que la méthode est appelée de manière asynchrone

    Lorsque cette méthode est appelée, il faudra un thread du propre pool de threads de Spring pour exécuter cette méthode au lieu d'utiliser le thread dans le pool de threads Web, de sorte que le thread dans le pool de threads Web puisse être utilisé pour continuer à servir d'autres nouvelles demandes client

    Remarque :

    • La classe où réside cette méthode doit être gérée par le conteneur Spring

    • La fonction modifiée ne doit pas être définie comme un type statique, sinon l'appel asynchrone ne prendra pas effet

    • Valeur de retour : si vous n'avez pas besoin d'une valeur de retour, utilisez void directement ; si vous avez besoin d'une valeur de retour, utilisez AsyncResult ou CompletableFuture

    • Vous pouvez spécifier un exécuteur personnalisé (pool de threads), par exemple : @Async("otherExecutor") (personnaliser un pool de threads via @bean)

      • Si vous utilisez l'annotation @Async seule dans Spring, vous devez spécifier l'exécuteur (c'est-à-dire configurer le pool de threads), sinon une erreur sera signalée :

        org.springframework.aop.interceptor.AsyncExecutionAspectSupport getDefaultExecutor

      • Dans SpringBoot, en raison de la configuration automatique, un pool de threads SimpleAsyncTaskExecutor est directement configuré par défaut.

    • La méthode marquée par @Async doit être appelée entre différentes classes : Classe A ==> Méthode classe B.C () (@Async est marqué sur la méthode C de la classe B)

      S'il est appelé dans la même classe, il sera exécuté de manière synchrone, par exemple : Class A.B() ==> Class A.@Async C method()

      La raison est la suivante : l'implémentation sous-jacente est implémentée par les annotations d'analyse du proxy, il n'y a pas d'annotation sur la méthode B et aucune classe proxy correspondante n'est générée. (Bien sûr, ajouter @Async à la classe peut aussi le résoudre, mais toutes les méthodes sont asynchrones, ce qui n'est généralement pas utilisé !)


Annotations communes Spring MVC

Lié au contrôleur

  • @RequestMapping : utilisé pour établir la relation de mappage entre l'URL de la demande et la méthode de traitement, et peut également faire diverses restrictions sur la demande via ses attributs

    Elle peut être marquée sur les classes et les méthodes. Si elle est utilisée sur une classe, cela signifie que toutes les méthodes de la classe qui répondent aux requêtes utilisent cette adresse comme chemin parent.

    Les attributs:

    • attribut value / path : spécifiez l'adresse de requête du mappage, et l'adresse spécifiée peut être un mode de modèle d'URI
    • attribut method : spécifiez le type de méthode de la requête, GET, POST, PUT, DELETE, etc., exemple : RequestMethod.post
    • Attribut params : spécifiez les paramètres qui doivent être inclus dans la requête. Si la requête ne contient pas les paramètres spécifiés, une exception sera levée
    • Attribut headers : spécifie que la requête doit contenir certaines valeurs d'en-tête spécifiées pour que la méthode traite la requête.
    • consomme l'attribut : spécifie le type de contenu soumis (Content-Type) pour le traitement des requêtes, telles que application/json, text/html ;
    • produit un attribut : spécifie le type de contenu renvoyé et renvoie uniquement si le type (Accepter) dans l'en-tête de la requête contient le type spécifié

  • @RequestParam : Annoté avant les paramètres de la méthode Controller, utilisé pour faire quelques restrictions sur les paramètres communs passés par l'url dans la requête

    Trois propriétés sont prises en charge :

    • attribut value / name : attribut par défaut, utilisé pour lier le nom du paramètre passé par la requête. Il est généralement utilisé lorsque le paramètre de requête est incohérent avec le paramètre d'entrée de la méthode Controller
    • attribut requis : permet de préciser si ce paramètre doit être passé
      • Le paramètre modifié par @RequestParam doit passer une valeur par défaut, et vous pouvez utiliser required = false pour spécifier une valeur facultative
    • attribut defaultValue : précisez la valeur par défaut du paramètre (lorsque le paramètre n'est pas obligatoire et que la requête ne passe pas en paramètre, la valeur par défaut est utilisée)

    Sans annotation @RequestParam :

    • Le nom du paramètre frontal doit être cohérent avec le nom de la variable du contrôleur principal pour prendre effet
    • Le paramètre est facultatif

  • @PathVariable : espace réservé pour le mappage des liaisons d'URL

    L'URL avec espace réservé est une nouvelle fonctionnalité de Spring 3.0

    Le paramètre d'espace réservé {xxx} dans l'URL peut être lié au paramètre d'entrée de la méthode de traitement du contrôleur via @PathVariable("xxx")

    	@RequestMapping("/testPathVariable/{id}")
    public String testPathVariable(@PathVariable("id") Integer id)
    {
      
      
        System.out.println("testPathVariable:"+id);
        return SUCCESS;
    }

Traitement global des données (@ControllerAdvice)

  • @ControllerAdvice : Définissez la classe globale de traitement des données de la couche Contrôleur. Agit sur la méthode du contrôleur annotée avec @RequestMapping

    Contient l'annotation @Component, qui peut être scannée

    Généralement utilisé avec les annotations suivantes

    • @ExceptionHandler (gestion des exceptions)
    • @ModelAttribute (liaison de données)
    • @InitBinder (prétraitement des données)
    • **Remarque :** Ces trois annotations peuvent être utilisées sur des classes de contrôleur ordinaires, et ControllerAdvice n'a qu'une portée qui peut être personnalisée (toutes par défaut)

    Attributs de support :

    • attribut value / basePackages : type de tableau, spécifiant un ou plusieurs packages, utilisé pour spécifier le package de base pouvant être utilisé

      Agira sur le contrôleur sous le package spécifié et sur le contrôleur sous ses sous-packages

      S'il n'est pas spécifié, la valeur par défaut est tous les packages analysés

    • Attribut basePackageClasses : il s'agit d'une variante de basePackages, un type de tableau, spécifiant une ou plusieurs classes de contrôleurs, et tous les contrôleurs sous les packages et sous-packages de ces classes sont gérés par ce @ControllerAdvice

    • attribut assignableTypes : type de tableau, utilisé pour spécifier un type de contrôleur spécifique, il peut s'agir d'une interface commune ou d'une classe parente, etc.

    • attribut annotations : Spécifiez une ou plusieurs annotations, le Controller marqué par ces annotations sera géré par le @ControllerAdvice

  • @RestControllerAdvice : Définir la classe globale de traitement des données de la couche Contrôleur

    Annotations combinées, composées des annotations @ControllerAdvice et @ResponseBody

  • @ExceptionHandler : utilisé pour capturer différents types d'exceptions levées dans le contrôleur

    Souvent utilisé en conjonction avec l'annotation @ControllerAdvice pour obtenir une gestion globale des exceptions

  • @ModelAttribute : La méthode marquée par celui-ci sera exécutée avant d'exécuter la méthode cible du contrôleur

    Souvent utilisée en conjonction avec l'annotation @ControllerAdvice, la méthode globale @RequestMapping peut obtenir les paires clé-valeur définies ici

  • @InitBinder : utilisé pour définir WebDataBinder pour le prétraitement des données de requête


Annotations communes de Spring Boot

  • @SpringBootApplication : annotations combinées, généralement marquées sur la classe de démarrage

    • @Configuration : Déclarez cette classe en tant que classe de configuration Spring et chargez les beans définis dans cette classe dans le conteneur Spring.

    • @EnableAutoConfiguration : charge automatiquement toutes les configurations @Configuration éligibles dans l'environnement SpringBoot actuel

      Par exemple : si vous ajoutez une dépendance spring-boot-starter-web, puisqu'elle utilise Tomcat et Spring MVC, la configuration automatique supposera qu'une application Web est en cours de développement et définira Spring en conséquence.

    • @ComponentScan : Activer l'analyse des packages (prise en charge des annotations IOC), analyser toutes les classes sous le package actuel et les sous-packages par défaut

      Le chemin du package analysé peut être spécifié via l'attribut basePackage pour réduire le temps de chargement

  • @SpringBootTest : Lecture des propriétés du fichier de configuration. Marquer sur la classe de test basée sur l'exécution de SpringBoot

    • Utilisez SpringBootContextLoader comme ContextLoader par défaut lorsqu'il est défini sans @ContextConfiguration(loader=…) spécifique
    • Rechercher automatiquement @SpringBootConfiguration lorsque @Configuration imbriquée n'est pas utilisée et qu'aucune classe explicite n'est spécifiée
    • Permet de définir des propriétés d'environnement personnalisées à l'aide de l'attribut properties
    • Fournit la prise en charge de différents modes d'environnement Web, y compris le démarrage d'un serveur Web en cours d'exécution à l'écoute sur un port défini ou aléatoire.
    • Enregistrer un bean TestRestTemplate ou WebTestClient pour utiliser un serveur Web entièrement en cours d'exécution dans les tests Web

  • @ConfigurationProperties : pour les liaisons de configuration automatique

    Attributs de support :

    • attribut value / prefix : le préfixe de l'élément de configuration du fichier de configuration
    • attribut ignoreInvalidFields : la valeur par défaut est false, si le type de valeur ne correspond pas, une exception sera levée
    • attribut ignoreUnknownFields : la valeur par défaut est true, ignorant les champs inconnus dans l'objet

    Utilisation 1 : marquer sur la classe, convertir l'élément de configuration du fichier de configuration en un objet bean

    • Avis:
      • Les classes annotées avec @ConfigurationProperties doivent être enregistrées dans le conteneur Spring de deux manières :
        • Méthode 1 : utiliser @componet et d'autres annotations IOC sur les classes marquées avec des annotations @ConfigurationProperties
        • Méthode 2 : marquez @EnableConfigurationProperties(bean class name.class) sur la classe marquée avec des annotations IOC telles que @componet ou sur la classe de configuration
      • Nécessite un constructeur sans argument, des méthodes getter et setter
    @Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "app.mycar")
public class Car {
      
      
    private int price;
    private String brand;
}

    @Configuration
@EnableConfigurationProperties(Car.class) 
public class Config {
      
      
}

    Utilisation 2 : marquez la méthode de la classe de configuration, utilisez-la avec @bean et liez les propriétés tierces

    @Configuration
public class DbConfig {
      
      
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource datasource(){
      
      
        return new DruidDataSource();
    }
}

  • @EnableConfigurationProperties : Activez l'annotation @ConfigurationProperties pour qu'elle prenne effet et injecte automatiquement cette classe dans le conteneur IOC

    Annoté sur les classes avec des annotations IOC telles que @componet ou sur les classes de configuration

    Attributs de support :

    • attribut value : tableau Class<?>[], c'est-à-dire le tableau Class de la classe annotée avec l'annotation @ConfigurationProperties

Annotations communes du nuage de printemps

Enregistrement de service / Découverte de service / Centre de configuration

  • @EnableEurekaClient : Activer l'enregistrement de service et la découverte de service

    Basé sur spring-cloud-netflix, si le centre d'enregistrement sélectionné est eureka, il est recommandé d'utiliser cette annotation

  • @EnableDiscoveryClient : Activer l'enregistrement de service et la découverte de service

    Basé sur spring-cloud-commons, s'il s'agit d'un autre centre d'enregistrement, il est recommandé d'utiliser cette annotation

  • @EnableEurekaServer : annotez la classe de démarrage ou la classe de configuration pour identifier le service en tant que serveur eureka

  • @EnableConfigServer : annotez la classe de démarrage ou la classe de configuration pour identifier le service en tant que serveur du centre de service

  • @RefreshScope : Annoté sur la classe pour actualiser automatiquement les données obtenues du centre de configuration

    Seulement en ajoutant cette annotation, lorsque les données du centre de configuration seront actualisées, l'objet de cette classe sera automatiquement rechargé, et les données automatiquement mises à jour seront injectées dans @value


Faux composants

  • @EnableFeignClients : Active les annotations Feign. Marqué sur la classe de démarrage ou la classe de configuration

    Au démarrage du projet, un composant FeignSterter sera démarré, ce qui créera des objets proxy pour les classes qui utilisent @FeignClient dans le projet

  • @FeignClient : déclarer qu'il s'agit d'un client Feign, et spécifier le nom du service via l'attribut name/value

    • Il ne peut être marqué que sur l'interface appelée par le service distant

      (L'annotation FeignClient est modifiée par @Target(ElementType.TYPE), indiquant que la cible de l'annotation FeignClient se trouve sur l'interface)

    • Lorsque SpringCloud scanne l'interface identifiée par @FeignClient, la couche inférieure créera un objet proxy de classe d'implémentation (proxy jdk) pour celle-ci et le remettra à la gestion du conteneur Spring (register IOC container) ; le nom de l'objet Bean créé est spécifié par le nom ou l'attribut de valeur de l'annotation. Si deux interfaces d'appel de service distant sont créées pour le même service, une erreur sera signalée

    • Les méthodes définies dans l'interface utilisent pleinement les annotations SpringMVC, Feign générera des URL en fonction des annotations et accédera aux résultats

    • La classe de démarrage ou la classe de configuration du service doit être marquée avec l'annotation @EnableFeignClients pour que Fegin prenne effet

    Les attributs communs de l'annotation @FeignClient sont les suivants :

    • attribut name / value : spécifiez le nom de FeignClient. Si le projet utilise le ruban (centre d'enregistrement), l'attribut name sera utilisé comme nom du microservice pour la découverte de service

    • attribut url : généralement utilisé pour le débogage, vous pouvez spécifier manuellement l'adresse appelée par @FeignClient. vide par défaut

      • L'url peut être obtenue à partir du fichier de configuration, s'il y en a, elle sera appelée via l'url, sinon, elle sera appelée selon le nom du service.

        le format esturl = "${xxx.xxx.xxx: }"

    • attribut de configuration : classe de configuration Feign, vous pouvez personnaliser l'encodeur, le décodeur, le niveau de journalisation, le contrat de Feign et vous pouvez spécifier différentes configurations pour chaque client factice

    • attribut fallback : définit la classe de traitement tolérante aux pannes. Lorsque l'appel à l'interface distante échoue ou expire, la logique tolérante aux pannes de l'interface correspondante sera invoquée. La classe spécifiée par fallback doit implémenter l'interface marquée par @FeignClient

    • attribut fallbackFactory : classe d'usine, utilisée pour générer des exemples de classe de secours, grâce à cet attribut, la logique commune de tolérance aux pannes de chaque interface peut être réalisée et la duplication de code peut être réduite

    • attribut path : définit le préfixe unifié du FeignClient actuel, utilisé lorsque server.context-path, server.servlet-path sont configurés dans le projet

    • attribut decode404 : lorsqu'une erreur http 404 se produit, si le champ est vrai, le décodeur sera appelé pour le décodage, sinon une FeignException sera levée


autres notes

  • @LoadBalanced : Activer la fonction d'équilibrage de charge du ruban

    Ajoutez un LoadBalancerClient à RestTemplate pour réaliser l'équilibrage de charge client via le ruban

    • Annoté sur l'objet RestTemplate, fourni par le module commons de SpringCloud

    Principe : lors de l'utilisation de l'objet RestTemplate pour appeler un service, la couche inférieure du système interceptera le service. Après avoir intercepté l'url, il obtiendra une instance de service spécifique basée sur le nom de service de l'url, puis reconstruira l'url basée sur l'instance de service, puis effectuera un appel de service basé sur la nouvelle url

  • @EnableCircuitBreaker : active la fonction disjoncteur

  • @EnableHystrixDashboard : marquez la classe de démarrage ou la classe de configuration, identifiez le service en tant que service Hystrix-Dashboard (tableau de bord) et surveillez le trafic du serveur

  • @EnableTurbine : marquez la classe de démarrage ou la classe de configuration pour identifier le service en tant que service Turbine et surveiller le trafic de plusieurs serveurs en même temps

  • @EnableZuulProxy : utilisez cette annotation dans la classe de démarrage principale ou la classe de configuration pour identifier le service en tant que service de passerelle Zuul


Annotations courantes pour le lombok

  • @Data : annoté sur la classe ; fournit les méthodes getter, setter, equals, canEqual, hashCode, toString

  • @Setter : annoté sur la propriété ; fournit une méthode de définition pour la propriété

  • @Getter : annoté sur la propriété ; fournit une méthode getter pour la propriété

  • @NoArgsConstructor : annoté sur la classe ; fournit un constructeur sans paramètre pour la classe

  • @AllArgsConstructor : annoté sur la classe ; fournit un constructeur de paramètres complet pour la classe

  • @EqualsAndHashCode : implémente la méthode equals() et la méthode hashCode()

  • @ToString : Implémente la méthode toString()

  • @Slf4j : annoté sur la classe ; fournissez un objet log log4j avec un attribut nommé log pour la classe

    slf4j est un adaptateur, lorsque l'application modifie une source de journal, il n'est pas nécessaire de modifier le code

  • @Log4j : annoté sur la classe ; fournissez à la classe un objet de journal avec un attribut nommé log

    log4j est un produit qui implémente véritablement la fonction log

  • @Cleanup : fermer le flux

  • @Synchronized : synchronisation d'objet

  • @SneakyThrows : lève une exception

Je suppose que tu aimes

Origine blog.csdn.net/footless_bird/article/details/128704278
conseillé
Classement
du quotidien
Plus
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)

Code World

© 2018 codetd.com