Préparation à la certification professionnelle du printemps. Conteneur, IoC, haricots

1. Souvent, les informations qu'ils contiennent ne sont ni structurées, ni collectées, ni pertinentes
   
2. Les jeunes développeurs ne connaissent peut-être pas l'anglais. Ce cycle peut être utilisé non seulement pour la certification, mais aussi pour l'autoformation / répétition des matériels.
   
3. Ces documents peuvent être utilisés pour préparer l'entretien, comme ils sont organisés sous forme de questions et réponses.
   
4. Un avantage important et le plus important est que cet AQ est composé de questions du Guide officiel d' étude pivot.
   

• J'ai délibérément manqué des questions qui me semblaient superflues ou qui n'étaient pas dans le guide .

1. Injection de dépendance, conteneur, IoC, haricots
2. AOP (programmation orientée aspect)
3. JDBC, transactions, JPA, données de printemps
4. Botte de printemps
5. Spring mvc
6. Sécurité printanière
7. REPOS
8. Test

• Printemps 5 modèles de conception
  
• Spring in Action 4e édition
  
• Spring Security - Third Edition
  
• La certification Core Spring 5 en détail par Ivan Krizsan
  
• Documentation Spring et javadocs API Spring
  

L'injection de dépendance est un modèle spécial qui réduit la communication entre les composants Spring. Ainsi, lors de l'application de DI, votre code devient plus propre, plus simple, il devient plus facile à comprendre et à tester.
Selon le modèle DI, la création d'objets pour les dépendances est transférée à l'usine ou donnée à un tiers. Cela signifie que nous pouvons nous concentrer sur l'utilisation de ces objets au lieu de les créer.

• Amélioration des tests. Dans les tests, le bean peut être remplacé par un objet spécial (mock ou stub) qui implémente l'interface du bean.
  
• Vous permet d'utiliser le mécanisme de proxy dynamique à partir du JDK (par exemple, lors de la création d'un référentiel via Spring Data)
  
• Vous permet de masquer l'implémentation
  

Dans Spring Framework, l'interface org.springframework.factory.BeanFactory fournit une fabrique de org.springframework.factory.BeanFactory , qui est en même temps un conteneur IoC pour l'application. La gestion des beans est basée sur la configuration (java ou xml).

L'interface org.springframework.context.ApplicationContext est un wrapper sur une fabrique de beans qui fournit des fonctionnalités supplémentaires, telles que AOP, transactions, sécurité, i18n, etc.

La base du Spring Framework est un conteneur, et nos objets "vivent" dans ce conteneur.
Un conteneur crée généralement de nombreux objets en fonction de leurs configurations et gère leur cycle de vie, de la création d'un objet à sa destruction.

Un conteneur est un objet qui implémente l'interface ApplicationContext .

Le printemps propose plusieurs variantes de contexte.

Il existe plusieurs implémentations de base de l'interface ApplicationContext:

• FileSystemXmlApplicationContext
  
• ClassPathXmlApplicationContext
  
• AnnotationConfigApplicationContext
  
• XmlWebApplicationContext
  
• AnnotationConfigWebApplicationContext
  

Exemples de création d'un contexte:

 ApplicationContext ctx = new FileSystemXmlApplicationContext(                                     "c:/bean_properties.xml"); ApplicationContext ctx = new AnnotationConfigApplicationContext(                            "com.springdemoapp.JavaConfig.class"); 

1. Chargement des descriptions de bacs, création d'un graphique de dépendance (entre les beans)
2. Création et BeanFactoryPostProcessors
3. Créer des haricots
4. Spring injecte des valeurs et des dépendances dans les propriétés du bean
5. Si le bean implémente la méthode setBeanName() partir de l'interface NameBeanAware, l'ID du bean est transmis à la méthode
6. Si le bean implémente BeanFactoryAware, Spring établit une référence à la fabrique de bean via setBeanFactory() partir de cette interface.
7. Si le bean implémente l'interface ApplicationContextAware, Spring établit une référence à ApplicationContext via setApplicationContext() .
8. BeanPostProcessor est une interface spéciale (à ce sujet ci-dessous), et Spring permet aux beans d'implémenter cette interface. En implémentant la méthode postProcessBeforeInitialization() , vous pouvez modifier l'instance du bean avant de l'initialiser (le bean) (définition des propriétés, etc.)
9. Si des méthodes de rappel sont définies, Spring les appelle. Par exemple, il s'agit d'une méthode annotée par @PostConstruct ou la méthode initMethod partir d'une annotation @Bean .
10. Le haricot est maintenant prêt à l'emploi. Il peut être obtenu à l'aide de la méthode ApplicationContext#getBean() .
11. Une fois le contexte fermé (méthode close() d'ApplicationContext), le bean est détruit.
12. Si le bean a une méthode annotée par @PreDestroy , cette méthode sera appelée avant la destruction. Si le bean implémente DisposibleBean, Spring appellera la méthode destroy() pour effacer les ressources ou tuer les processus dans l'application. Si la méthode @Bean est définie dans l' destroyMethod , elle est également appelée.
    

Si vous utilisez JUnit 5, vous devez spécifier 2 annotations:

• @ExtendWith (TestClass.class) - utilisé pour indiquer une classe de test
  
• @ContextConfoguration (classes = JavaConfig.class) - charge la configuration java / xml pour créer le contexte dans le test
  

Vous pouvez utiliser l'annotation @SpringJUnitConfig , qui combine ces deux annotations.
Vous pouvez utiliser l'annotation @SpringJUnitWebConfig pour tester la couche Web.

S'il ne s'agit pas d'une application Web, il existe deux façons:

• Enregistrez shutdown-hook à l'aide de l'appel de méthode registerShutdownHook() , il est également implémenté dans la classe AbstractApplicationContext. C'est la méthode préférée.
• Vous pouvez appeler la méthode close() partir de la classe AbstractApplicationContext.

Dans l'application Spring Boot:

• Spring Boot enregistrera le crochet d'arrêt pour vous tout seul.

Pour créer une classe avec une configuration basée sur du code Java, vous devez l'annoter avec
@Configuration .
Cette classe contiendra des méthodes d'usine pour créer des beans dans le conteneur.
Ces méthodes doivent être annotées avec l'annotation @Bean .

Un exemple:

 @Configuration public class DSConfig {  @Bean  public DataSource dataSource() {      return DataSourceBuilder          .create()          .username("")          .password("")          .url("")          .driverClassName("")          .build();  } } 

Cette classe placera une instance de la classe DataSource dans le conteneur. Plus tard, il peut être utilisé lors de l'accès à la base de données.

Analyse des composants - Spring détecte automatiquement les grains qui seront dans le conteneur. Ce sont des bacs avec des annotations-stéréotypes.

Cependant, l'analyse des composants n'est pas activée par défaut.
Pour activer l'analyse, @ComponentScanning classe @ Configuration avec l'annotation @ComponentScanning . Spring analysera automatiquement le package contenant cette classe et tous ses sous-packages.
Vous pouvez spécifier d'autres packages pour l'analyse, et même des classes:

 // 2  @Configuration(basePackages = {"soundsystem", "video"}) 

 //  @Configuration(basePackageClasses = "MyClass.class") 

Câblage automatique - Spring injectera automatiquement les dépendances lors de la numérisation ou du placement d'un bac dans un conteneur.
L'injection de dépendances utilise l'annotation @Autowire .

Les stéréotypes sont des annotations indiquant une fonctionnalité spéciale.
Tous les stéréotypes incluent l'annotation @Component .

Portée - portée. Il existe 2 étendues par défaut.

Et 4 étendues dans une application Web.

La portée est indiquée à l'aide de l'annotation @Bean sur les méthodes @Bean .

La portée du prototype n'est pas sûre pour les threads car cela ne garantit pas que la même instance sera appelée uniquement dans 1 thread.

Par contre, Singleton Scope est thread-safe.

Les beans singleton sont généralement créés immédiatement après l'analyse.
Les beans prototypes sont généralement créés uniquement sur demande.

Vous pouvez utiliser l'annotation @Lazy pour indiquer comment initialiser.
Il est placé sur les méthodes @ Bean, sur les classes @ Configuration ou sur les classes @ Component.
Selon le paramètre (vrai ou faux) accepté par l'annotation, l'initialisation sera paresseuse ou se fera immédiatement. Par défaut (c'est-à-dire sans spécifier de paramètre), true est utilisé.

Le bean singleton peut être intégré à n'importe quel autre bean.

Seul le prototype ou le singleton peut être intégré au singleton .
Si vous implémentez un prototype, un prototype unique sera créé pour chaque singleton.

Le prototype peut être une dépendance pour n'importe quel bean.
Vous ne pouvez implémenter que singleton ou prototype.

• BeanFactoryPostProcessor fonctionne sur les descriptions de BeanFactoryPostProcessor ou les métadonnées de configuration avant la création du bac.
• Spring fournit plusieurs implémentations BeanFactoryPostProcessor utiles, par exemple, en lisant des fichiers de propriétés et en obtenant des propriétés de BeanFactoryPostProcessor .
• Vous pouvez écrire votre propre implémentation de BFPP.

Afin d'utiliser BFPP personnalisé. Vous pouvez remplacer le mécanisme d'obtention des données à partir des métafichiers.

 @Bean public static PropertySourcesPlaceholderConfigurer pspc() {    //,    pspc } 

• destroyMethod - pointe vers une méthode de rappel. La méthode est dans le bac.
• initMethod - pointe vers une méthode de rappel. La méthode est dans le bac.
• name - le nom du bean. Par défaut, le nom du bean est le nom de la méthode.
• value - alias pour nom ()

Spring utilise plusieurs BeanPostProcessors.
Par exemple, CommonAnnotationPostProcessor ou AutowiredAnnotationBeanPostProcessor .
BPP fonctionne avec les instances de bean, c'est-à-dire le conteneur crée le bac, puis BPP démarre.

Il existe 3 options pour créer de telles méthodes:

• @PreDestroy et @PostConstruct
• Les destroyMethod initMethod et destroyMethod dans l'annotation destroyMethod qui pointent vers des méthodes de la classe bean
• InitializingBean#afterPropertiesSet() et DisposableBean#destroy() . Pour remplacer ces méthodes, vous devez implémenter les interfaces correspondantes.

Voici les types d'ID pouvant être utilisés dans votre application:

• Constructeur DI
• Setter di
• Champ di

DI via le constructeur est considéré comme le meilleur moyen, car pour lui, il n'est pas nécessaire d'utiliser la réflexion, et il n'a pas non plus les inconvénients de DI à travers le passeur.
DI à travers le champ n'est pas recommandé, car Pour cela, une réflexion est utilisée qui réduit la productivité.
DI via le constructeur peut conduire à des dépendances circulaires . Pour éviter cela, vous pouvez utiliser l'initialisation paresseuse des beans ou DI via le setter.

1. Le conteneur détermine le type d'objet à incorporer.
2. Un conteneur recherche des beans dans un contexte (aka un conteneur) qui correspond au type souhaité
3. S'il y a plusieurs candidats et que l'un d'eux est marqué comme @Primary , alors il est implémenté
4. Si des annotations @Autowire + Qualifier sont utilisées, le conteneur utilisera les informations de @Qualifier pour déterminer quel composant déployer
5. Sinon, le conteneur tentera d'injecter le composant en fonction de son nom ou de son ID.
6. Si aucune des méthodes n'a fonctionné, une exception sera levée

Le conteneur gère l' ID à l' aide d'un AutowiredAnnotationBeanPostProcessor . À cet égard, l'annotation ne peut être utilisée dans aucun BeanFactoryPP ou BeanPP.

Si l'objet injecté est un tableau, une collection ou une carte avec un générique, Spring incorporera tous les beans de type dans ce tableau (ou une autre structure de données). Dans le cas de la carte, la clé sera le nom du bean.

 // ,   DI @Authowired(required = true/false) 

Vous pouvez utiliser différents types d'implémentation:

• Constructeur
• Setter
• Injection sur le terrain
• Valeur

Spring fournit une annotation Qualifier pour surmonter le problème d'ambiguïté DI.

 @Bean @Qualifier("SomeClass1") public SomeClass getField() {...} //… @Autowire @Qualifier("SomeField1") public SomeClass someField; 

Si le conteneur a plusieurs cases du même type (SomeClass), alors le conteneur implémentera exactement cette case, au-dessus de la méthode @ Bean dont il existe un qualificatif approprié. Vous ne pouvez pas non plus mettre de qualificatif sur une méthode, mais utiliser le nom du bean comme paramètre de qualificatif.
Le nom du bean peut être spécifié via le paramètre d'annotation Bean , et par défaut c'est le nom de la méthode d'usine.

Un proxy est un objet spécial qui a les mêmes méthodes publiques que le bean, mais qui a des fonctionnalités supplémentaires.
Deux types de procurations:

• JDK-proxy - proxy dynamique. Les API sont intégrées au JDK. Il a besoin d'une interface
• Proxy CGLib - non intégré au JDK. Utilisé lorsque l'interface d'un objet n'est pas disponible.

Avantages des objets proxy:

• Laisser ajouter un supplément. logique - gestion des transactions, sécurité, journalisation
• Sépare du code (journalisation, etc.) de la logique principale

S'il n'y a pas d'instance de bean dans le conteneur, la méthode @ Bean est appelée. S'il existe une instance de bean, le bean déjà créé est renvoyé.

Lorsque vous utilisez la configuration Java, vous pouvez utiliser l'annotation @Profile .
Il vous permet d'utiliser différents paramètres pour Spring, en fonction du profil spécifié.
Il peut être placé sur les classes @Configuration et Component , ainsi que sur les méthodes Bean .

 Profile("!test") //   ,   

 @Bean("dataSource") @Profile("production") public DataSource jndiDataSource() {...} @Bean("dataSource") @Profile("development") public DataSource standaloneDataSource() {...} 

Vous pouvez utiliser l'annotation @Value pour @Value .
Ces valeurs peuvent être obtenues à partir de fichiers de propriétés, de bacs, etc.

 @Value("$some.key") public String stringWithDefaultValue; 

Une chaîne sera incorporée dans cette variable, par exemple, à partir d'une propriété ou d'une vue.