Lorsque vous utilisez le projet SpringBoot, vous constaterez que quoi que vous fassiez, la classe de démarrage est indissociable.C'est le seul point d'entrée du programme, alors qu'a-t-il fait pour nous? Cet article analyse principalement @SpringBootApplication.
table des matières
1. Démarrage
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
}
二 、 @ SpringBootApplication
@SpringBootApplication: l'annotation d'application Spring Boot sur une certaine classe indique que cette classe est la classe de configuration principale de SpringBoot.
SpringBoot doit exécuter la méthode principale de cette classe pour démarrer l'application SpringBoot;
Le démarrage de la configuration pertinente est effectué par cette annotation pour nous aider à terminer, cliquez pour le découvrir
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}
En cliquant sur, vous constaterez qu'il y a encore de nombreuses annotations dans sa classe d'annotations, qui est une annotation de combinaison personnalisée.
Ensuite, expliquons une à une les annotations de sa combinaison.
1 、 @ Cible (ElementType.TYPE)
@Target explique la plage d'objets modifiés par Annotation. Les
valeurs (ElementType) sont les suivantes:
1. CONSTRUCTOR: utilisé pour décrire le constructeur
2. CHAMP: utilisé pour décrire le domaine
3. LOCAL_VARIABLE: utilisé pour décrire les variables locales
4. METHOD: utilisé pour décrire la méthode
5. PACKAGE: utilisé pour décrire le package
6. PARAMETER: utilisé pour décrire les paramètres
7.TYPE: utilisé pour décrire la classe, l'interface (y compris le type d'annotation) ou l'instruction enum
2 、 @ Rétention (RetentionPolicy.RUNTIME)
Les annotations peuvent être divisées en 3 catégories selon le cycle de vie:
1. RetentionPolicy.SOURCE: L'annotation n'est conservée que dans le fichier source. Lorsque le fichier Java est compilé dans un fichier de classe, l'annotation est abandonnée;
2. RetentionPolicy.CLASS: L'annotation est conservée dans le fichier de classe, mais le jvm est abandonné lorsque le fichier de classe est chargé. Il s'agit du cycle de vie par défaut
3. RetentionPolicy.RUNTIME: L'annotation n'est pas seulement enregistrée dans le fichier de classe, mais existe toujours après que la JVM ait chargé le fichier de classe;
3 、 @ Documenté
Cette annotation est uniquement utilisée pour indiquer si elle sera enregistrée lors de la génération de javadoc.
Vous pouvez utiliser @Documented pour annoter lors de la personnalisation des annotations. Si vous utilisez @Documented pour annoter, les annotations @Documented seront affichées lors de la génération de javadoc.
4 、 @ hérité
@Inherited est un logo utilisé pour modifier les annotations, qui sera utilisé dans les annotations personnalisées
Personnalisez d'abord une annotation
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface ATable {
public String name() default "";
}
Voici un scénario dans lequel des annotations personnalisées sont utilisées.
Le rôle de @Inherited dans la
relation d'héritage de classe Dans la relation d'héritage de classe, la sous-classe héritera des annotations modifiées par @Inherited dans les annotations utilisées par la classe parente
@ATable
public class InheritedBase {
}
public class MyInheritedClass extends InheritedBase {
}
Le rôle de @Inherited dans la
relation d'héritage d'interface Dans la relation d'héritage d'interface, l'interface enfant n'héritera d'aucune annotation dans l'interface parent, que les annotations utilisées dans l'interface parent soient ou non modifiées par @Inherited
@ATable
public interface IInheritedInterface {
}
public interface IInheritedInterfaceChild extends IInheritedInterface {
}
Le rôle de @Inherited dans la relation d'interface d'implémentation de classe Lorsque la
classe implémente l'interface, elle n'hérite pas des annotations définies dans l'interface.
@ATable
public interface IInheritedInterface {
}
public class MyInheritedClassUseInterface implements IInheritedInterface {
}
5 、 @ SpringBootConfiguration
Marqué sur une certaine classe, indiquant qu'il s'agit d'une classe de configuration Spring Boot
Cliquez et vous constaterez qu'il s'agit en fait d'une annotation personnalisée
@Configuration learning spring devrait lui être familier.
Rôle: Spécifiez que la classe courante est une classe de configuration. Lors de l'utilisation de spring, c'est toute la configuration xml au début. C'est cette annotation qui ouvre la méthode de configuration de classe.
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}
6 、 @ EnableAutoConfiguration
Ce que nous devons configurer avant, Spring Boot le configurera automatiquement pour nous;
@EnableAutoConfiguration indique à SpringBoot d'activer la fonction de configuration automatique afin que la configuration automatique puisse prendre effet;
Cliquez dessus et vous trouverez @Import. Pour le dire franchement, il utilise le support de @Import pour collecter et enregistrer des définitions de bean liées à des scénarios spécifiques.
@Import role: utilisé pour importer d'autres classes de configuration
Et @EnableAutoConfiguration utilise également l'aide de @Import pour charger toutes les définitions de bean qui répondent aux conditions de configuration automatique dans le conteneur IoC, rien de plus!
@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}
EnableAutoConfigurationImportSelector: le sélecteur dont les composants
sont importés, de nombreuses classes de configuration automatique (xxxAutoConfiguration) seront importées dans le conteneur;
Le processus approximatif est:
Lorsque Spring Boot démarre, via la classe EnableAutoConfigurationImportSelector,
la valeur spécifiée par EnableAutoConfiguration est obtenue à partir de META-INF / spring.factories sous le chemin de classe (la capture d'écran ci-dessus),
et ces valeurs sont utilisées comme configuration automatique en créant le nom complet de la classe réflexion Importez la classe dans le conteneur, et la classe de configuration automatique prendra effet,
nous aidant avec le travail de configuration automatique;
Avant de devoir configurer les choses par nous-mêmes, les classes de configuration automatique ont été configurées pour nous. C'est la raison pour laquelle spring est utilisé avec springboot, et springmvc n'a pas besoin de configurer les résolveurs de vues, les pools de connexion à la base de données, les transactions et autres configurations. Configuré pour fonctionner immédiatement.
Bien sûr, springboot m'a également fourni un moyen de modifier la configuration, c'est-à-dire via le fichier yml ou propriété pour modifier la valeur par défaut de la configuration que springboot a configurée pour nous.
7 、 @ ComponentScan
Fonction: Utilisé pour spécifier le package que Spring analysera lors de la création d'un conteneur via des annotations
Nous pouvons personnaliser avec précision la portée de l'analyse automatique @ComponentScan via des attributs tels que basePackages. Si elle n'est pas spécifiée, l'implémentation par défaut du framework Spring analysera à partir du package où la classe @ComponentScan est déclarée.
@ComponentScan("com.gzl")
C'est pourquoi la classe de démarrage springboot est placée en dehors du package.
3. Pouvez-vous démarrer le projet sans utiliser cette annotation?
Remplacez @SpringBootApplication par les trois annotations suivantes, et il peut toujours démarrer normalement.
package com.gzl.cn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
}