Dernières questions d'entrevue Java : partie du cadre Spring

1. Comment fonctionne SpringMVC ?

L'utilisateur envoie une requête au serveur, et la requête est capturée par le contrôleur frontal springMVC DispatchServlet ;

DispatcherServle analyse l'URL de la requête et obtient l'identifiant de la ressource de la requête ( URL), puis en fonction de l'URL, appelez HandlerMapping pour mapper la requête au processeur HandlerExcutionChain ;

DispatchServlet sélectionne un adaptateur HandlerAdapter approprié pour le traitement en fonction du gestionnaire obtenu

Une fois le gestionnaire terminé ; le traitement des données, il renverra un objet ModelAndView à DisPatchServlet ;

Le ModelAndView renvoyé par Handler n'est qu'une vue logique et non une vue formelle. DispatcherSevlet essaie d'analyser la vue logique en une vue réelle via ViewResolver ; 🎜>

DispatcherServle analyse ModelAndView() via le modèle. Les paramètres sont analysés et enfin la vue complète est affichée et renvoyée au client

2. Quelles sont les annotations courantes de SpringMVC ?

@RequestMapping est utilisé pour demander le mappage d'URL.

L'annotation @RequestBody implémente la réception des données json de la requête http et la conversion des données json en objet java.

L'annotation @ResponseBody convertit l'objet renvoyé par la méthode du contrôleur en une réponse json au client.

3. Comment activer le processeur d'annotation et l'adaptateur ?

Dans nos projets, nous activons généralement le processeur d'annotation et l'adaptateur en les activant dans springmvc.xml.

4. Comment résoudre le problème d'obtention et de publication de caractères tronqués ?

Pour résoudre la demande de publication tronquée : nous pouvons configurer un filtre CharacterEncodingFilter dans web.xml. Définir sur utf-8 Pour résoudre le code tronqué de la requête get : il existe deux méthodes. Il existe deux solutions aux paramètres chinois tronqués de la requête get :

Modifier le fichier de configuration Tomcat pour ajouter un encodage cohérent avec l'encodage d'ingénierie.

Une autre façon de réencoder les paramètres est String userName = new String(request.getParameter("userName").getBytes("ISO8859-1"), "utf-8");

5. Parlez-nous de votre compréhension de Spring ?

Spring est un framework open source créé pour simplifier le développement d'applications au niveau de l'entreprise. Spring peut permettre à de simples JavaBeans de réaliser des fonctions que seuls les EJB pouvaient réaliser auparavant. Spring est un framework de conteneurs IOC et AOP.

Le noyau principal du conteneur Spring est :

Inversion de contrôle (IOC) Dans le modèle de développement Java traditionnel, lorsqu'un objet est nécessaire, nous l'utiliserons. new nous-mêmes Ou getInstance, etc. appelle directement ou indirectement le constructeur pour créer un objet. Dans le modèle de développement Spring, le conteneur Spring utilise le modèle d'usine pour créer les objets requis pour nous. Nous n'avons pas besoin de les créer nous-mêmes. Nous pouvons appeler directement les objets fournis par Spring. de contrôle.

Injection de dépendance (DI), spring utilise la méthode set de l'objet JavaBean ou la méthode constructeur avec des paramètres pour définir automatiquement ses propriétés sur les valeurs requises lorsque nous créons l'objet requis. C'est l'idée de. injection de dépendances.

Programmation orientée aspect (AOP), dans l'idée de programmation orientée objet (oop), nous extrayons les choses verticalement dans les objets un par un. Dans la programmation orientée aspect, nous extrayons horizontalement certains aspects similaires de chaque objet en un aspect et effectuons certaines opérations courantes sur cet aspect, telles que le contrôle des autorisations, la gestion des transactions, la journalisation, etc. C'est l'idée de la programmation orientée aspect. programmation. La couche inférieure d'AOP est un proxy dynamique. Si l'interface utilise un proxy dynamique JDK, si la classe utilise CGLIB pour implémenter un proxy dynamique

6. Quels sont les modèles de conception dans Spring ?

Mode cas unique - deux méthodes proxy au printemps. Si l'objet cible implémente plusieurs interfaces, spring utilise le proxy de classe java.lang.reflect.Proxy de jdk. Si l'implémentation cible n'implémente aucune interface, Spring utilise la bibliothèque CGLIB pour générer une sous-classe de la classe cible. Mode Singleton - Définissez le bean par défaut en mode singleton dans le fichier de configuration Spring.

Mode Modèle - utilisé pour résoudre le problème de duplication de code. Par exemple : RestTemplate, JmsTemplate, JpaTemplate

Mode contrôleur frontal - Spring fournit le contrôleur frontal DispatherServlet pour distribuer les requêtes.

View helper - spring fournit une série de balises JSP et de macros efficaces pour aider à intégrer du code dispersé dans la vue.

Injection de dépendances - le concept de base qui traverse l'interface BeanFactory/ApplacationContext.

Modèle d'usine - Dans le modèle d'usine, nous n'exposons pas la logique de création au client lors de la création d'un objet et pointons vers l'objet nouvellement créé en utilisant la même interface. BeanFactory est utilisé dans Spring pour créer des instances d'objets.

7. Annotations communes pour le printemps ?

Spring a commencé à prendre en charge les annotations pour configurer l'injection de dépendances après la version 2.5. Les annotations peuvent être utilisées pour remplacer les descriptions de beans en XML. L'injection d'annotation sera traitée par le conteneur avant l'injection XML, cette dernière écrasera donc les résultats du traitement de la première pour le même attribut.

L'assemblage d'annotations est désactivé par défaut au printemps. Par conséquent, vous devez le configurer dans le fichier de configuration Spring Core pour utiliser le mode d'assemblage basé sur les annotations. La méthode de configuration est la suivante :

Annotations couramment utilisées :

@Required : Cette annotation s'applique à la méthode de définition des valeurs.

@Autowired : Cette annotation s'applique aux méthodes setter valorisées, aux méthodes non setter, aux constructeurs et aux variables.

@Qualifier : Cette annotation est utilisée en conjonction avec @Autowired pour lever l'ambiguïté du câblage automatique de beans spécifiques.

8. Présenter brièvement le cycle de vie des beans printaniers

Définition du bean : utilisée dans le fichier de configuration pour la définition.

Initialisation du bean : il existe deux manières d'initialiser : cela se fait en spécifiant l'attribut init-method dans le fichier de configuration. Implémente l'interface org.springframework.beans.factory.InitializingBean.

Appel du bean : il existe trois façons d'obtenir une instance du bean et de l'appeler.

Destruction du bean : il existe deux façons de détruire : utilisez l'attribut destroy-method spécifié dans le fichier de configuration. Implémente org.springframework.bean.factory.DisposeableBean.

9. Comprenez-vous le schéma de structure Spring ?

Conteneur Core : comprenant les modules Core, Beans, Context et EL. Module de base : encapsule la partie de niveau le plus bas des dépendances du framework, y compris l'accès aux ressources, la conversion de type et certaines classes d'outils courantes.

Module Beans : fournit les parties de base du framework, y compris l'inversion du contrôle et l'injection de dépendances. Parmi eux, BeanFactory est le cœur du conteneur. Il s'agit essentiellement de la mise en œuvre du « modèle de conception d'usine » et ne nécessite pas de programmation pour implémenter le « modèle de conception de cas unique ». Le cas unique est entièrement contrôlé par le conteneur et préconise l'interface. Programmation orientée plutôt que programmation orientée implémentation ; tous les objets d'application et les relations entre les objets sont gérés par le framework, qui extrait véritablement les dépendances entre les objets maintenus de la logique du programme. Toutes ces dépendances sont maintenues par BeanFactory.

Module contextuel : basé sur Core et Beans, il intègre les fonctions du module Beans et ajoute la liaison de ressources, la vérification des données, l'internationalisation, la prise en charge de JavaEE, le cycle de vie des conteneurs, la propagation des événements, etc. ; l'interface principale est ApplicationContext.

Module EL : fournit une prise en charge puissante du langage d'expression, prend en charge l'accès et la modification des valeurs d'attribut, des appels de méthode, prend en charge l'accès et la modification des tableaux, des conteneurs et des indexeurs, des variables nommées, prend en charge les opérations arithmétiques et logiques et prend en charge l'exécution à partir de Spring. Le conteneur obtient le Bean, qui prend également en charge la projection, la sélection et l'agrégation générale de listes.

Module AOP, Aspects : module AOP : le module Spring AOP fournit une implémentation de programmation orientée aspect conforme à la spécification AOPAlliance, fournissant des fonctions communes telles que la journalisation, le contrôle des autorisations, les statistiques de performances, etc. et la technologie de séparation de la logique métier , et peut ajouter dynamiquement ces fonctions au code requis ; de cette manière, chacune est dédiée à ses propres tâches et réduit le couplage entre la logique métier et les fonctions générales.

Module Aspects : Fournit l'intégration d'AspectJ, qui fournit des fonctions plus puissantes que SpringASP. Module d'accès/intégration des données : Ce module comprend JDBC, ORM, OXM, JMS et la gestion des transactions.

Module de transaction : ce module est utilisé pour les transactions de gestion Spring. Tant que Spring gère les objets, ils peuvent bénéficier des avantages des transactions de gestion Spring. Il n'est pas nécessaire de contrôler les transactions dans le code et il prend en charge la programmation. et la gestion déclarative des transactions.

Module JDBC : fournit un exemple de modèle JBDC. L'utilisation de ces modèles peut éliminer le long codage JDBC traditionnel et le contrôle des transactions nécessaire, et vous pouvez profiter des avantages de la gestion des transactions de Spring.

Module ORM : fournit une intégration transparente avec les frameworks de mappage "objet-relationnel" populaires, notamment Hibernate, JPA, MyBatis, etc. Et vous pouvez utiliser la gestion des transactions Spring sans contrôle supplémentaire des transactions.

Module OXM : fournit une implémentation du mappage objet/XML, mappant des objets Java en données XML ou mappant des données XML en objets Java. Les implémentations de mappage objet/XML incluent JAXB, Castor, XMLBeans et XStream.

Module JMS : utilisé pour JMS (JavaMessagingService), fournissant un ensemble de modèles "producteur de messages, consommateur de messages" pour une utilisation plus simple de JMS est utilisé entre deux applications ou pour envoyer des messages dans des systèmes distribués pour une communication asynchrone. . Module Web/Remoting : Le module Web/Remoting comprend les modules Web, Web-Servlet, Web-Struts et Web-Porlet.

Module Web : Fournit des fonctions Web de base. Par exemple, plusieurs téléchargements de fichiers, des conteneurs IoC intégrés, un accès aux processus à distance (RMI, Hessian, Burlap) et la prise en charge de WebService, ainsi qu'une classe RestTemplate sont fournis pour fournir un accès pratique aux services Restful.

Module Web-Servlet : fournit une implémentation du framework SpringMVCWeb. Le framework SpringMVC fournit une injection de ressources de requête basée sur des annotations, une liaison de données plus simple, une validation des données, etc. et un ensemble de balises JSP très faciles à utiliser, qui coopèrent de manière totalement transparente avec d'autres technologies Spring.

Module Web-Struts : fournit une intégration transparente avec Struts1.x et Struts2.x. Module de test : Spring prend en charge les frameworks de test Junit et TestNG et fournit également des fonctions de test supplémentaires basées sur Spring, telles que. comme simulant la fonction des requêtes HTTP lors du test des frameworks Web.

10. En quoi le printemps peut-il nous aider ?

Spring peut nous aider à créer et assembler des dépendances entre objets en fonction de fichiers de configuration.

Spring crée et assemble des dépendances entre les objets en fonction du fichier de configuration.

La programmation orientée aspect Spring peut nous aider à implémenter la journalisation sans couplage. Statistiques de performances, contrôle de sécurité.

La programmation orientée aspect Spring peut fournir une meilleure façon de le compléter, généralement via la configuration, et ne nécessite pas l'ajout de code supplémentaire au code existant. Le code existant se concentre sur la logique métier.

Spring peut nous aider à gérer très facilement les transactions de bases de données.

Avec Spring, il nous suffit d'obtenir la connexion et d'exécuter SQL, et toutes les autres choses associées sont gérées par Spring.

Spring peut également être intégré de manière transparente à des frameworks d'accès à des bases de données tiers (tels que Hibernate, JPA), et il fournit également un ensemble de modèles d'accès JDBC pour faciliter l'accès aux bases de données.

Spring peut également être intégré de manière transparente à des frameworks Web tiers (tels que Struts, JSF), et il fournit également un ensemble de framework SpringMVC pour faciliter la construction de la couche Web.

Spring peut être facilement intégré à JavaEE (comme JavaMail, la planification des tâches) et à d'autres technologies (telles que le framework de mise en cache).

11. Veuillez décrire les affaires de Spring ?

Définition de la gestion déclarative des transactions : utilisez le traitement déclaratif des transactions dans les fichiers de configuration Spring au lieu des transactions de traitement de code. L'avantage est que la gestion des transactions n'empiète pas sur les composants développés. Plus précisément, les objets de logique métier ne se rendront pas compte qu'ils sont gérés par la transaction. En fait, cela devrait être le cas, car la gestion des transactions est un service. au niveau du système, pas au niveau de l'entreprise. Si vous souhaitez modifier le plan de gestion des transactions dans le cadre de la logique, il vous suffit de le reconfigurer dans le fichier de définition, ce qui est extrêmement pratique à maintenir.

Gestion déclarative des transactions basée sur TransactionInterceptor : deux attributs principaux : transactionManager, utilisé pour spécifier un gestionnaire de transactions et lui confier des opérations spécifiques liées aux transactions ; l'autre est l'attribut transactionAttributes de type Properties, dans chaque clé ; -value paire de cet attribut, la clé spécifie le nom de la méthode, le nom de la méthode peut utiliser des caractères génériques et la valeur représente l'attribut de transaction utilisé par la méthode correspondante.

<beans>
    ......
    <bean id="transactionInterceptor"
          class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="transfer">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
    <bean id="bankServiceTarget"
          class="footmark.spring.core.tx.declare.origin.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <bean id="bankService"
          class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="bankServiceTarget"/>
        <property name="interceptorNames">
            <list>
                <idref bean="transactionInterceptor"/>
            </list>
        </property>
    </bean>
</beans>

Gestion déclarative des transactions basée sur TransactionProxyFactoryBean : La configuration des fichiers de configuration est beaucoup plus simple qu'avant. Nous appelons ce type de format de fichier de configuration la gestion déclarative classique des transactions de Spring.

<beans>
    ......
    <bean id="bankServiceTarget"
          class="footmark.spring.core.tx.declare.classic.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <bean id="bankService"
          class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="target" ref="bankServiceTarget"/>
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="transfer">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
</beans>

Gestion déclarative des transactions basée sur l'espace de noms : basé sur les deux premières méthodes, Spring 2.x introduit l'espace de noms et utilise l'espace de noms en combinaison pour offrir aux développeurs la possibilité de configurer des transactions déclaratives. Une nouvelle expérience.

<beans>
    ......
    <bean id="bankService"
          class="footmark.spring.core.tx.declare.namespace.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <tx:advice id="bankAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="bankPointcut" expression="execution(* *.transfer(..))"/>
        <aop:advisor advice-ref="bankAdvice" pointcut-ref="bankPointcut"/>
    </aop:config>
    ......
</beans>

Gestion déclarative des transactions basée sur @Transactional : Spring 2.x introduit également une approche basée sur l'annotation, qui implique principalement l'annotation @Transactional. @Transactional peut être appliqué aux interfaces, aux méthodes d'interface, aux classes et aux méthodes de classe. Lorsque le calcul est appliqué à une classe, toutes les méthodes publiques de la classe auront des attributs de transaction de ce type.

@Transactional(propagation = Propagation.REQUIRED)
public boolean transfer(Long fromId, Long toId, double amount) {
    return bankDao.transfer(fromId, toId, amount);
}

La définition de la gestion programmatique des transactions : appeler explicitement beginTransaction(), commit(), rollback() et d'autres méthodes liées à la gestion des transactions dans le code, il s'agit de la gestion programmatique des transactions. La gestion programmatique des objets de Spring comporte deux méthodes : la gestion programmatique basée sur l'API sous-jacente et la gestion programmatique des transactions basée sur TransactionTemplate.

Gestion programmatique basée sur l'API sous-jacente : Credentials PlatformTransactionManager, TransactionDefinition et TransactionStatus, trois interfaces principales pour mettre en œuvre la gestion programmatique des transactions.

public class BankServiceImpl implements BankService {
    private BanckDao bankDao;
    private TransactionDefinition txDefinition;
    private PlatformTransactionManager txManager;

    public boolean transfer(Long fromId, Long toId, double amount) {
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        boolean result = false;
        try {
            result = bankDao.transfer(fromId, toId, amount);
            txManager.commit(txStatus);
        } catch (Exception e) {
            result = false;
            txManager.rollback(txStatus);
            System.out.println("Transfer Error!");
        }
        return result;
    }
}

Gestion programmatique des transactions basée sur TransactionTemplate : afin de ne pas endommager l'organisation originale du code et d'éviter le phénomène selon lequel chaque méthode inclut le même code passe-partout pour démarrer, soumettre et annuler des choses, Spring fournit Le modèle transactionTemplate est utilisé pour implémenter la gestion programmatique des transactions.

public class BankServiceImpl implements BankService {
    private BankDao bankDao;
    private TransactionTemplate transactionTemplate;

    public boolean transfer(final Long fromId, final Long toId, final double amount) {
        return (Boolean) transactionTemplate.execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                Object result;
                try {
                    result = bankDao.transfer(fromId, toId, amount);
                } catch (Exception e) {
                    status.setRollbackOnly();
                    result = false;
                    System.out.println("Transfer Error!");
                }
                return result;
            }
        });
    }
}

La différence entre les transactions programmatiques et les transactions déclaratives :

Les transactions programmatiques consistent à écrire vous-même la classe de traitement des transactions, puis à l'appeler.

Les transactions déclaratives sont configurées dans les fichiers de configuration et sont généralement utilisées dans les frameworks.

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!