collecter! Ce que Spring doit maîtriser

La colonne

tutoriel mysql présente ce que vous devez maîtriser sur Spring.

Bonjour à tous ! Je suis un membre enthousiaste du peuple Chaoyang.

Le framework Spring est une question incontournable lors des entretiens. Que contient-il exactement ? Jetons un coup d'oeil. C'est aussi une question que je pose souvent lors des entretiens, et elle reflète également la capacité d'un programmeur à comprendre le framework.

Présentation du framework Spring

Spring est un framework léger conçu pour améliorer le développement l'efficacité des développeurs et la maintenabilité du système.

Ce que nous appelons généralement Spring Framework est le Spring Framework. Il s'agit d'un ensemble de nombreux modules. L'utilisation de ces modules peut facilement nous aider dans le développement. Ces modules sont les modules Core Containers, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Tools, Messaging et Testing. Par exemple, le composant Core dans Core Container est le cœur de tous les composants Spring, les composants Beans et les composants Context sont la base de l'implémentation d'IOC et DI, et les composants AOP sont utilisés pour implémenter la programmation orientée aspect.

6 fonctionnalités de Spring :

• Technologies de base : Injection de dépendances (DI), AOP, événements, ressources, i18n, validation, liaison de données, conversion de type, SpEL
• Tests : objets simulés, framework TestContext, tests Spring MVC, WebTestClient ;
• Accès aux données : transactions, support DAO, JDBC, ORM, XML marshallé
• Support Web : framework Web Spring MVC et Spring WebFlux
• Intégration : remoting, JMS, JCA, JMX, email, tâches, planification, mise en cache
Langage : Kotlin, Groovy, langage dynamique

Listez quelques modules Spring importants L'image ci-dessous correspond à la version Spring 4.x Actuellement, le composant Portlet du module Web dans la dernière version 5.x a été abandonné, et un nouveau composant WebFlux pour les réactifs asynchrones. traitement.

• Spring Core : De base, on peut dire que toutes les autres fonctions de Spring dépendent de cette bibliothèque de classes. Fournit principalement des fonctions IOC et DI.
• Spring Aspects : Ce module fournit un support pour l'intégration avec AspectJ.
• Spring AOP : Fournit une implémentation de programmation orientée aspect.
• Spring JDBC : connexion à la base de données Java.
• Spring JMS : Service de messagerie Java.
• Spring ORM : utilisé pour prendre en charge les outils ORM tels que Hibernate.
• Spring Web : Fournit un support pour la création d'applications Web.
• Spring Test : fournit la prise en charge des tests JUnit et TestNG.

Parlez de votre compréhension du Spring IOC et de l'AOP

IOC

IOC (Inversion Of Controll, Inversion of Control) est une idée de conception, c'est-à-dire le le contrôle des objets créés manuellement dans le programme est confié au framework Spring. IOC est également utilisé dans d'autres langages et n'est pas spécifique à Spring. Le conteneur IOC est le support utilisé par Spring pour implémenter IOC. Le conteneur IOC est en fait une carte (clé, valeur) et divers objets sont stockés dans la carte.

Laissez l'interdépendance entre les objets être gérée par le conteneur IOC, et le conteneur IOC termine l'injection des objets. Cela peut grandement simplifier le développement d’applications et libérer des applications de dépendances complexes. Le conteneur IOC est comme une usine Lorsque nous devons créer un objet, il suffit de configurer le fichier de configuration/les annotations, sans penser à la façon dont l'objet est créé. Dans les projets réels, une classe Service peut avoir des centaines, voire des milliers de classes comme couche inférieure. Si nous devons instancier ce service, nous devrons peut-être déterminer les constructeurs de toutes les classes sous-jacentes de ce service à chaque fois, ce qui peut prêter à confusion. les gens. Si vous utilisez IOC, il vous suffit de le configurer et de le référencer si nécessaire, ce qui augmente considérablement la maintenabilité du projet et réduit la difficulté de développement.

À l'ère Spring, nous configurions généralement les beans via des fichiers XML. Plus tard, les développeurs ont estimé qu'il n'était pas bon d'utiliser des fichiers XML pour configurer les beans, donc la configuration des annotations Spring Boot est progressivement devenue populaire.

AOP

AOP (Programmation orientée aspect, programmation orientée aspect programmation ) peut encapsuler la logique ou les responsabilités (telles que le traitement des transactions, la gestion des journaux, le contrôle des autorisations, etc.) qui n'ont rien à voir avec le métier mais qui sont communément appelées par les modules métier, de manière à réduire la duplication de code dans le système, réduisent le couplage entre les modules et sont propices à l'évolutivité et à la maintenabilité futures.

Spring AOP est basé sur un proxy dynamique. Si l'objet à proxy implémente une certaine interface, alors Spring AOP utilisera le proxy dynamique JDK pour créer l'objet proxy, mais pour les objets qui n'implémentent pas l'interface, il le fera. ne peut pas être utilisé. Le proxy dynamique JDK utilise à la place le proxy dynamique CGlib pour générer une sous-classe de l'objet proxy en tant que proxy.

Bien sûr, vous pouvez également utiliser AspectJ. Spring AOP a intégré AspectJ. AspectJ doit être considéré comme le framework AOP le plus complet de l'écosystème Java. Après avoir utilisé AOP, nous pouvons extraire certaines fonctions courantes et les utiliser directement là où elles sont nécessaires, ce qui peut grandement simplifier la quantité de code. Nous devons ajouter de nouvelles fonctions de manière pratique et améliorer l'évolutivité du système. AOP est utilisé dans des scénarios tels que la fonction de journalisation, la gestion des transactions et la gestion des autorisations.

La différence entre Spring AOP et AspectJ AOP

Spring AOP est une amélioration du runtime , et AspectJ est une amélioration au moment de la compilation. Spring AOP est basé sur le proxy, tandis qu'AspectJ est basé sur la manipulation de bytecode.

Spring AOP a intégré AspectJ, qui doit être considéré comme le framework AOP le plus complet de l'écosystème Java. AspectJ est plus puissant que Spring AOP, mais Spring AOP est relativement plus simple.

Si nous avons moins d'aspects, il y aura peu de différence de performances entre les deux. Cependant, lorsqu’il y a trop d’aspects, il est préférable de choisir AspectJ, qui est bien plus rapide que SpringAOP.

Quelles sont les portées des haricots au printemps ?

1. singleton : la seule instance de bean, les beans au printemps sont tous des singletons par défaut.
2. prototype : Une nouvelle instance de bean sera créée à chaque requête.
3. requête : Chaque requête HTTP générera un nouveau bean, qui n'est valable que dans la requête HTTP en cours.
4. session : Chaque requête HTTP générera un nouveau bean, qui n'est valable que dans la session HTTP en cours.
5. global-session : la portée de session globale n'a de sens que dans les applications Web basées sur des portlets et n'est plus disponible dans Spring 5. Les portlets sont de petits plug-ins Web Java capables de générer des extraits de code sémantique (tel que HTML). Ils sont basés sur des conteneurs de portlets et peuvent gérer les requêtes HTTP comme les servlets. Mais contrairement aux Servlets, chaque Portlet possède une session différente.

Comprenez-vous les problèmes de sécurité des threads des beans singleton au printemps ?

La plupart du temps, nous n'utilisons pas le multi-threading dans le système, donc peu de gens prêtent attention à ce problème. Les beans Singleton ont des problèmes de thread, principalement parce que lorsque plusieurs threads exploitent le même objet, l'écriture d'opérations sur les variables membres non statiques de cet objet entraînera des problèmes de sécurité des threads.

Il existe deux solutions courantes :

1. Essayez d'éviter de définir des variables membres mutables dans l'objet bean (pas très réaliste).
2. Définissez une variable membre ThreadLocal dans la classe et enregistrez les variables membres variables requises dans ThreadLocal (méthode recommandée).

Le cycle de vie du haricot au printemps ?

1. Le conteneur Bean trouve la définition Spring Bean dans le fichier de configuration.
2. Le conteneur Bean utilise l'API Java Reflection pour créer une instance Bean.
3. Si certaines valeurs d'attribut sont impliquées, utilisez la méthode set() pour définir certaines valeurs d'attribut.
4. Si le Bean implémente l'interface BeanNameAware, appelez la méthode setBeanName() et transmettez le nom du Bean.
5. Si le Bean implémente l'interface BeanClassLoaderAware, appelez la méthode setBeanClassLoader() et transmettez l'instance de l'objet ClassLoader.
6. Si le Bean implémente l'interface BeanFactoryAware, appelez la méthode setBeanClassFacotory() et transmettez l'instance de l'objet ClassLoader.
7. Semblable à ce qui précède, si d'autres interfaces *Aware sont implémentées, les méthodes correspondantes sont appelées.
8. S'il existe un objet BeanPostProcessor lié au conteneur Spring qui charge ce bean, exécutez la méthode postProcessBeforeInitialization().
9. Si le Bean implémente l'interface InitializingBean, exécutez la méthode afeterPropertiesSet().
10. Si la définition du Bean dans le fichier de configuration contient l'attribut init-method, exécutez la méthode spécifiée.
11. S'il existe un objet BeanPostProcess lié au conteneur Spring qui charge ce bean, exécutez la méthode postProcessAfterInitialization().
12. Lorsque le Bean est détruit, si le Bean implémente l'interface DisposableBean, exécutez la méthode destroy().
13. Lorsqu'un Bean doit être détruit, si la définition du Bean dans le fichier de configuration contient l'attribut destroy-method, exécutez la méthode spécifiée.

Dites-moi ce que vous savez sur Spring MVC ?

En parlant de ce problème, nous devons mentionner les époques précédentes de Model1 et Model2 sans Spring MVC.

**Ère Model1 :** De nombreux programmeurs back-end qui ont appris Java tardivement n'ont peut-être pas été exposés au développement d'applications JavaWeb en mode Model1. En mode Model1, l'ensemble de l'application Web est presque entièrement composé de pages JSP, et seul un petit nombre de JavaBeans sont utilisés pour gérer la connexion, l'accès et d'autres opérations à la base de données. Dans ce mode, JSP est à la fois la couche de contrôle et la couche de présentation. Évidemment, ce modèle présente de nombreux problèmes. Par exemple, la logique de contrôle et la logique de performance sont mélangées, ce qui entraîne un taux de réutilisation du code extrêmement faible ; un autre exemple est que le front-end et le back-end sont interdépendants, ce qui rend les tests difficiles et l'efficacité du développement est extrêmement faible.

Ère Model2 : Les amis qui ont appris Servlet et réalisé des démos associées devraient comprendre le modèle de développement de Java Bean (Modèle) + JSP (Vue) + Servlet (Contrôleur). étape du modèle de développement Java Web MVC. Le modèle correspond aux données impliquées dans le système, c'est-à-dire les dao et les beans ; View est utilisé pour afficher les données dans le modèle, uniquement à des fins d'affichage ; le contrôleur envoie les demandes des utilisateurs au servlet pour traitement, renvoie les données à JSP et les affiche au utilisateur.

Il y a encore de nombreux problèmes dans le mode Model2. Le degré d'abstraction et d'encapsulation de Model2 est loin d'être suffisant. Lors du développement avec Model2, il est inévitable de réinventer la roue, ce qui réduit considérablement la maintenabilité et la fiabilité de Model2. le programme. En conséquence, de nombreux frameworks MVC liés au développement Web Java ont vu le jour, tels que Struts2. Cependant, comme Struts2 est relativement lourd et avec la popularité du framework de développement léger Spring, le framework Spring MVC est apparu dans l'écosystème Spring. Spring MVC est actuellement le meilleur framework MVC Par rapport à Struts2, Spring MVC est plus simple et plus pratique à utiliser, a une efficacité de développement plus élevée et Spring MVC s'exécute plus rapidement.

MVC est un modèle de conception et Spring MVC est un excellent framework MVC. Spring MVC peut nous aider à développer une couche Web plus concise, et elle est naturellement intégrée au framework Spring. Sous Spring MVC, nous divisons généralement les projets back-end en couche Service (activité de traitement), couche Dao (opérations de base de données), couche Entité (classes d'entité) et couche Contrôleur (couche de contrôle, renvoyant les données à la page frontale).

Le schéma schématique simple de Spring MVC est le suivant :

Parlez du principe de fonctionnement de Spring MVC

Description du processus :

1. Le client (navigateur) envoie une requête directement au DispatcherServlet.

2. DispatcherServlet appelle HandlerMapping en fonction des informations de la demande et analyse le gestionnaire correspondant à la demande.

3. Analysez le gestionnaire correspondant (qui est ce que nous appelons habituellement le contrôleur).

4.HandlerAdapter appellera le processeur réel basé sur le gestionnaire pour traiter la demande et exécuter la logique métier correspondante.

5. Une fois que le processeur a fini de traiter l'entreprise, il renverra un objet ModelAndView. Model est l'objet de données renvoyé et View est la vue logique.

6. ViewResolver trouvera la vue réelle en fonction de la vue logique.

7.DispatcherServlet transmet le modèle renvoyé à la vue (rendu de la vue).

8. Renvoyez la vue au demandeur (navigateur).

##Quels modèles de conception sont utilisés dans le framework Spring ?

1. Modèle de conception d'usine : Spring utilise le modèle d'usine pour créer des objets bean via BeanFactory et ApplicationContext.
2. Modèle de conception proxy : implémentation de la fonctionnalité Spring AOP.
3. Modèle de conception Singleton : les beans in Spring sont tous des singletons par défaut.
4. Modèle de méthode Template : jdbcTemplate, hibernateTemplate et d'autres classes se terminant par Template in Spring qui opèrent sur la base de données utilisent le modèle de modèle.
5. Modèle de conception du wrapper : notre projet doit se connecter à plusieurs bases de données, et différents clients accéderont à différentes bases de données en fonction de leurs besoins lors de chaque visite. Ce modèle nous permet de basculer dynamiquement entre différentes sources de données en fonction des besoins des clients.
6. Modèle d'observateur : le modèle événementiel Spring est une application classique du modèle d'observateur.
7. Mode adaptateur : l'amélioration ou le conseil (Advice) de Spring AOP utilise le mode adaptateur, et Spring MVC utilise également le mode adaptateur pour adapter le contrôleur.

Quelle est la différence entre @Component et @Bean ?

1. Il fonctionne sur différents objets. L'annotation @Component agit sur les classes, tandis que l'annotation @Bean agit sur les méthodes.
2. L'annotation @Component est généralement automatiquement détectée et automatiquement assemblée dans le conteneur Spring via l'analyse du chemin de classe (nous pouvons utiliser l'annotation @ComponentScan pour définir le chemin à analyser). L'annotation @Bean est généralement définie dans la méthode marquée avec l'annotation pour générer ce bean, indiquant à Spring qu'il s'agit d'une instance d'une certaine classe et qui me est renvoyée lorsque j'ai besoin de l'utiliser.
3. L'annotation @Bean est plus personnalisable que l'annotation @Component, et dans de nombreux endroits, les beans ne peuvent être enregistrés que via l'annotation @Bean. Par exemple, lorsqu'une classe faisant référence à une bibliothèque tierce doit être assemblée dans un conteneur Spring, cela ne peut être réalisé que via l'annotation @Bean.

Exemple d'utilisation de l'annotation @Bean :

@Configurationpublic class AppConfig {    @Bean    public TransferService transferService() {        return new TransferServiceImpl();    }}复制代码

Le code ci-dessus est équivalent à la configuration XML suivante :

<beans>    <bean id="transferService" class="com.common.TransferServiceImpl"/></beans>复制代码

L'exemple suivant ne peut pas transmettre @ Implémenté par l'annotation du composant :

@Beanpublic OneService getService(status) {    case (status)  {        when 1:                return new serviceImpl1();        when 2:                return new serviceImpl2();        when 3:                return new serviceImpl3();    }}复制代码

将一个类声明为Spring的bean的注解有哪些？

我们一般使用@Autowired注解去自动装配bean。而想要把一个类标识为可以用@Autowired注解自动装配的bean，可以采用以下的注解实现：

1. @Component注解。通用的注解，可标注任意类为Spring组件。如果一个Bean不知道属于哪一个层，可以使用@Component注解标注。
2. @Repository注解。对应持久层，即Dao层，主要用于数据库相关操作。
3. @Service注解。对应服务层，即Service层，主要涉及一些复杂的逻辑，需要用到Dao层（注入）。
4. @Controller注解。对应Spring MVC的控制层，即Controller层，主要用于接受用户请求并调用Service层的方法返回数据给前端页面。

Spring事务管理的方式有几种？

1. 编程式事务：在代码中硬编码（不推荐使用）。
2. 声明式事务：在配置文件中配置（推荐使用），分为基于XML的声明式事务和基于注解的声明式事务。

Spring事务中的隔离级别有哪几种？

在TransactionDefinition接口中定义了五个表示隔离级别的常量：

**ISOLATION_DEFAULT：**使用后端数据库默认的隔离级别，Mysql默认采用的REPEATABLE_READ隔离级别；Oracle默认采用的READ_COMMITTED隔离级别。

**ISOLATION_READ_UNCOMMITTED：**最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。

**ISOLATION_READ_COMMITTED : **Autorise la lecture des données qui ont été validées par des transactions simultanées, ce qui peut empêcher les lectures sales, mais des lectures fantômes ou non répétables peuvent toujours se produire

**ISOLATION_REPEATABLE_READ : ** Pour le même champ, les résultats de plusieurs lectures sont cohérents, à moins que les données ne soient modifiées par la propre transaction elle-même, ce qui peut empêcher les lectures incorrectes et les lectures non répétables, mais des lectures fantômes peuvent toujours se produire.

**ISOLATION_SERIALIZABLE : **Le niveau d'isolement le plus élevé, entièrement conforme au niveau d'isolement ACID. Toutes les transactions sont exécutées une par une dans l'ordre, de sorte qu'il n'y a aucune possibilité d'interférence entre les transactions. En d'autres termes, ce niveau peut empêcher les lectures incorrectes, les lectures non répétables et les lectures fantômes. Mais cela affectera sérieusement les performances du programme. Normalement, ce niveau n'est pas utilisé.

Quels sont les types de comportements de propagation des transactions dans les transactions Spring ?

Huit constantes représentant le comportement de propagation des transactions sont définies dans l'interface TransactionDefinition.

Supporter la transaction en cours :

**PROPAGATION_REQUIRED : **Si une transaction existe actuellement, rejoignez cette transaction ; s'il n'y a actuellement aucune transaction, créez une nouvelle transaction.

PROPAGATION_SUPPORTS : S'il y a actuellement une transaction, rejoignez la transaction ; s'il n'y a actuellement aucune transaction, continuez à l'exécuter de manière non transactionnelle.

PROPAGATION_MANDATORY : Si une transaction existe actuellement, rejoignez la transaction ; s'il n'y a pas de transaction actuellement, lancez une exception. (obligatoire : obligatoire).

Si la transaction en cours n'est pas prise en charge :

PROPAGATION_REQUIRES_NEW : Créer une nouvelle transaction , si une transaction existe actuellement, suspendez la transaction en cours.

PROPAGATION_NOT_SUPPORTED : Exécuté en mode non transactionnel Si une transaction existe actuellement, la transaction en cours sera suspendue.

PROPAGATION_NEVER : S'exécute en mode non transactionnel, générant une exception si une transaction existe actuellement.

###Autres cas :

PROPAGATION_NESTED : Si une transaction existe actuellement, créez une transaction à exécuter comme une transaction imbriquée de la transaction en cours s'il y en a actuellement ; aucune transaction, alors cette valeur est équivalente à PROPAGATION_REQUIRED.

Fin

J'espère que vous pourrez maîtriser ces contenus et continuer à me soutenir, merci.

Plus de recommandations d'apprentissage gratuites associées : tutoriel mysql(vidéo)

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