Notes d'étude : Programmeur Dark Horse SpringMVC

1. Vue d'ensemble

Résumé des notes :

• Signification : SpringMVC : Spring MVC est un module de Spring Framework permettant de créer des applications Web basées sur Java . SpringMVC est une technologie de cadre de couche de présentation . SpringMVC est utilisé pour développer des fonctions de couche de présentation .
• MVC : modèle de conception qui divise une application en trois composants principaux : Model , View et Controller
• Caractéristiques:
  1. poids léger
  2. couplage lâche
  3. Hautement personnalisable
  4. Facile à tester
  5. Intégrer d'autres technologies
  6. Prise en charge RESTful

1.1 Signification

​ Spring MVC est un module de Spring Framework permettant de créer des applications Web basées sur Java. Il fournit une méthode de développement basée sur le modèle de conception MVC (Model-View-Controller) pour aider les développeurs à créer des applications Web flexibles et évolutives.

​ Spring MVC traite les requêtes Web en distribuant les requêtes et les réponses aux processeurs correspondants (contrôleurs) et présente les résultats du traitement à l'utilisateur. Il adopte une conception faiblement couplée qui permet aux développeurs de séparer la logique métier et l'interface utilisateur de l'application, offrant ainsi une meilleure organisation et maintenabilité du code.

illustrer:

• SpringMVC est un framework Web léger basé sur Java qui implémente le modèle MVC.

• avantage

  • Simple à utiliser et pratique à développer (par rapport à Servlet)
  • Grande flexibilité

• SpringMVC, Développement de servlet qui remplace la couche de présentation du serveur back-end

illustrer:

​ La méthode de performance de SpringMVC est plus concise que le développement de servlets

Modèle de conception 1.2MVC

​ MVC est un modèle de conception logicielle qui divise une application en trois composants principaux : le modèle, la vue et le contrôleur. L'objectif de ce modèle est de séparer la logique, les données et la présentation de l'application pour améliorer la maintenabilité , la réutilisabilité et la flexibilité du code .

• Modèle (Model) : Le modèle représente les données et la logique métier de l'application . Il gère la lecture, le stockage, la validation des données et la gestion des règles métier. Le modèle n'interagit pas directement avec la vue, mais transmet les données via le contrôleur
• Vue (View) : La vue est chargée d' afficher les données du modèle à l'utilisateur. Il fait généralement partie de l'interface utilisateur, qui peut être une page Web, une interface graphique, une interface de ligne de commande, etc. La vue reçoit les données du contrôleur et les présente à l'utilisateur
• Contrôleur : le contrôleur gère la demande de l'utilisateur et met à jour le modèle et la vue en conséquence . Il reçoit les entrées de l'utilisateur (comme cliquer sur un bouton, soumettre un formulaire, etc.), appelle la logique de modèle appropriée en fonction de l'entrée pour mettre à jour les données et envoie les données mises à jour à la vue pour affichage.

L'idée principale du modèle MVC est de séparer les différentes parties fonctionnelles de l'application et de les rendre indépendantes et remplaçables. Cette séparation rend le code plus facile à comprendre , à maintenir et à étendre . Cela favorise également le travail d'équipe car les développeurs peuvent travailler simultanément sur différentes parties du modèle, de la vue et du contrôleur sans interférer les uns avec les autres. Le modèle MVC est largement utilisé dans divers frameworks et technologies de développement logiciel, y compris les frameworks de développement Web tels que Spring MVC, Ruby on Rails, etc.

1.3Fonctionnalités SpringMVC

​ Spring MVC est un framework Web basé sur Java qui fait partie du framework Spring et est utilisé pour développer des applications Web flexibles et évolutives . Voici quelques fonctionnalités de Spring MVC :

1. Léger : Spring MVC adopte un modèle de développement basé sur POJO et ne s'appuie sur aucun serveur d'applications spécifique, il est donc très léger.

2. Couplage lâche : Spring MVC est étroitement intégré au framework Spring, tirant parti de l'injection de dépendances de Spring et des fonctionnalités de programmation orientées aspect pour obtenir un couplage lâche entre les composants.

3. Hautement personnalisable : Spring MVC fournit de riches options de configuration et des interfaces extensibles, et les développeurs peuvent personnaliser et configurer divers composants en fonction des besoins pour répondre aux exigences spécifiques des applications.

4. Facile à tester : Spring MVC adopte le modèle de conception MVC pour séparer la logique métier, le traitement des données et l'interface utilisateur, facilitant ainsi les tests unitaires et les tests d'intégration .

5. Traitement puissant des requêtes : Spring MVC fournit un mécanisme de traitement des requêtes flexible et puissant. Le mappage des requêtes, la liaison des paramètres, la vérification des données, l'analyse des vues, etc. peuvent être facilement définis via des annotations et des fichiers de configuration.

6. Diversité des technologies d'affichage : Spring MVC prend en charge une variété de technologies d'affichage, notamment JSP, Thymeleaf, Freemarker, Velocity, etc. Les développeurs peuvent choisir la technologie d'affichage appropriée en fonction des besoins du projet.

7. Intégrer d'autres technologies : Spring MVC peut être intégré de manière transparente à d'autres technologies et frameworks, tels que Spring Security pour implémenter l'authentification et l'autorisation de sécurité, Spring Data pour accéder aux bases de données, Spring Boot pour simplifier la configuration, etc.

8. Prise en charge de RESTful : Spring MVC offre une bonne prise en charge du développement de style RESTful, ce qui facilite la création et la gestion d'API de style RESTful.

Dans l'ensemble, Spring MVC présente les avantages de la flexibilité, de la personnalisation et de la testabilité, ce qui en fait l'un des frameworks préférés pour le développement d'applications Web.

2. Cas d'utilisation de base - Application de base SpringMVC

Résumé des notes :

• Pas
  1. Importation servlet-api, spring-webmvccoordonnées de dépendance
  2. Créer une classe de contrôleur SpringMVC (équivalent à la fonctionnalité Servlet)
  3. Créer une classe de fichier de configuration
  4. Initialisez le conteneur Servlet pour charger l'environnement SpringMVC et définissez les requêtes traitées par la technologie SpringMVC :
     • Description : héritez de AbstractDispatcherServletInitializercette classe, réécrivez trois méthodes abstraites et AnnotationConfigWebApplicationContextchargez le fichier du contrôleur SpringMVC via
• principe:
  • 
  • Veuillez consulter la section suivante pour plus de détails
• Utilisation des annotations :
  • @Controller : définissez le bean du contrôleur principal de SpringMVC
  • @RequestMapping : définissez le chemin d'accès à la demande de la méthode du contrôleur actuel
  • @ResponseBody : définissez le contenu de la réponse de la méthode du contrôleur actuel sur la valeur de retour actuelle , pas besoin d'analyser
  • @Configuration : identifie une classe comme classe de configuration Spring . Elle est généralement utilisée en conjonction avec d'autres annotations pour définir les informations de configuration de l'application.
  • @ComponentScan : dites à Spring d'analyser les composants (y compris les classes, les interfaces, les annotations, etc.) dans le package spécifié et de les enregistrer en tant que beans Spring.

Étape 1 : Pour utiliser la technologie SpringMVC, vous devez d'abord importer les coordonnées SpringMVC et les coordonnées du servlet

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

illustrer:

• Coordonnées SpringMVC, vous pouvez utiliser les fonctions et fonctionnalités fournies par Spring MVC, telles que le traitement des demandes, le routage, la liaison de données et l'analyse des vues.
• En introduisant les coordonnées du Servlet, les fonctions du conteneur Servlet peuvent être intégrées au projet, permettant au projet de traiter les requêtes HTTP et de générer des réponses .

Étape 2 : Créer une classe de contrôleur SpringMVC (équivalent à la fonction Servlet)

//定义表现层控制器bean
@Controller
public class UserController {
    
    

    //设置映射路径为/save，即外部访问路径
    @RequestMapping("/save")
    //设置当前操作返回结果为指定json数据（本质上是一个字符串信息）
    @ResponseBody
    public String save() {
    
    
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }

    //设置映射路径为/delete，即外部访问路径
    @RequestMapping("/delete")
    @ResponseBody
    public String delete() {
    
    
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

Remplir:

1. Nom : @Contrôleur

   • Type : annotation de classe

   • Emplacement : au-dessus de la définition de la classe du contrôleur SpringMVC

   • Fonction : définir le bean du contrôleur principal de SpringMVC

   • exemple:

     @Controller
     public class UserController {
              
              
     }
     
     

2. Nom : @RequestMapping

   • Type : annotation de méthode

   • Emplacement : au-dessus de la définition de la méthode du contrôleur SpringMVC

   • Fonction : définir le chemin d'accès actuel à la demande de méthode du contrôleur

   • exemple:

     @RequestMapping("/save")
     public void save(){
              
              
         System.out.println("user save ...");
     }
     

   • Propriétés associées

     • valeur (par défaut) : demander le chemin d'accès

3. Nom : @ResponseBody

   • Type : annotation de méthode

   • Emplacement : au-dessus de la définition de la méthode du contrôleur SpringMVC

   • Fonction : définissez le contenu de la réponse de la méthode du contrôleur actuel sur la valeur de retour actuelle , pas besoin d'analyser

   • exemple:

     @RequestMapping("/save")
     @ResponseBody
     public String save(){
              
              
         System.out.println("user save ...");
         return "{'info':'springmvc'}";
     }
     

Étape 3 : Créer une classe de fichier de configuration

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("love.ljtxy.controller")
public class SpringMvcConfig {
    
    
}

illustrer:

Initialisez l'environnement SpringMVC (identique à l'environnement Spring) et configurez SpringMVC pour charger les beans correspondants

Avis:

​ Ici, il vous suffit de changer la couche contrôleur en Bean, et aucun équipement supplémentaire n'est nécessaire pour analyser le package.

Étape 4 : Initialisez le conteneur Servlet pour charger l'environnement SpringMVC et définir les requêtes traitées par la technologie SpringMVC

//web容器配置类
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    
    
    //加载springmvc配置类，产生springmvc容器（本质还是spring容器）
    protected WebApplicationContext createServletApplicationContext() {
    
    
        //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置由springmvc控制器处理的请求映射路径
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }

    //加载spring配置类
    protected WebApplicationContext createRootApplicationContext() {
    
    
        return null;
    }
}

illustrer:

Définir une classe de configuration pour le démarrage du conteneur de servlet et y charger la configuration Spring

3. Principe du processus

Résumé des notes :

1. Démarrer le processus d'initialisation du serveur
2. Initialisation du conteneur Web
3. Initialisation du conteneur de servlets
4. Chargement de la classe de configuration SpringMVC
5. Chargez les beans correspondant à @ComponentScan
6. Chargement du bean de la couche de contrôle
7. Traitement des demandes

2. Processus de demande unique

3. Envoyer la demande

4. demande de distribution

5. Analyse de la demande

6. répartition des méthodes

7. exécution de la méthode

8. Traitement de la valeur de retour de la méthode

9. Utilisation des annotations :

• @ComponentScan : analyse automatiquement les classes du package spécifié et ses sous-packages et les identifie en tant que composants Spring. Injection de dépendances, assemblage automatique
  • includeFilters : exclut les beans chargés dans le chemin d'analyse, vous devez spécifier la catégorie (type) et les éléments spécifiques (classes)
  • includeFilters : pour charger le bean spécifié, vous devez spécifier la catégorie (type) et les éléments spécifiques (classes)

3.1 Aperçu

​ Au démarrage de SpringMVC, le processus est grossièrement divisé en deux types, l'un est appelé processus d'initialisation du serveur de démarrage et l'autre est appelé processus de requête unique.

• Démarrer le processus d'initialisation du serveur
  1. Le serveur démarre, exécute la classe ServletContainersInitConfig et initialise le conteneur Web.
  2. Exécutez la méthode createServletApplicationContext pour créer l'objet WebApplicationContext
  3. Charger SpringMvcConfig
  4. Exécutez @ComponentScan pour charger le bean correspondant
  5. Chargez UserController, chaque nom @RequestMapping correspond à une méthode spécifique
  6. Exécutez la méthode getServletMappings et définissez toutes les requêtes via SpringMVC
• processus de demande unique
  1. Envoyer la demande localhost/save
  2. Le conteneur Web constate que toutes les requêtes passent par SpringMVC et transmet la requête à SpringMVC pour traitement.
  3. Analyser le chemin de la requête /save
  4. La méthode correspondante save() est exécutée par /save matching.
  5. Exécuter save()
  6. Il est détecté que @ResponseBody renvoie directement la valeur de retour de la méthode save() au demandeur en tant que corps de réponse.

illustrer:

L'objet créé WebApplicationContextsera placé dans le ServletContext de la grande requête Servelet

3.2SpringMVC et contrôle de chargement des beans Spring

​ Sous le package com.itheima, divers beans sont inclus, tels que la configuration, le contrôleur, etc. SpringMVC contrôle uniquement le développement de la couche Controller et Spring contrôle le développement des couches de configuration, de service et dao. Cependant, spécifier la plage d'analyse du package Spring comme com.itheimasous le package à ce moment entraînera le chargement par erreur des beans SpringMVC.

illustrer:

​ Exclure les beans contrôlés par SpringMVC lors du chargement des beans contrôlés par Spring, afin de résoudre le problème de savoir comment éviter que Spring charge incorrectement Bea dans SpringMVC en raison de différentes fonctions

​ Supplément :

• Beans liés à Spring MVC ( haricots de couche de présentation )
• Haricots contrôlés au printemps
  • Bean métier (Service)
  • Beans fonctionnels (DataSource, etc.)
• Contrôle de chargement de bean lié à SpringMVC
  • Les packages correspondant aux beans chargés par SpringMVC sont tous dans le package com.itheima.controller.
• Contrôle du chargement des beans lié au printemps
  • Méthode 1 : définissez la plage d'analyse des beans chargés par Spring sur com.itheima et excluez les beans du package du contrôleur.
  • Méthode 2 : définissez la plage d'analyse des beans chargés par Spring sur une plage précise , telle que les packages de services, les packages dao, etc.
  • Méthode 3 : ne faites pas de distinction entre les environnements Spring et SpringMVC, chargez-les dans le même environnement

3.3ServletContainersInitConfig.class

/**
 * Web容器配置类
 */
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    

    /**
     * 返回Spring应用程序的根配置类
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
    
    
        return new Class[]{
    
    SpringConfig.class};
    }

    /**
     * 返回Servlet的配置类
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
    
    
        return new Class[]{
    
    SpringMvcConfig.class};
    }

    /**
     * 返回DispatcherServlet的映射路径
     */
    @Override
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }
}

Avis:

​ Lorsque vous utilisez la méthode getServletConfigClasses, vous devez configurer la valeur de retour correspondante SpringMvcConfig.class, qui est la configuration au niveau de la couche de contrôle.

3.4SpringConfig.class

@Configuration
@ComponentScan(value = "love.ljtxy",
        excludeFilters = @ComponentScan.Filter(
                type = FilterType.ANNOTATION,
                classes = Controller.class
        ))
public class SpringConfig {
    
    
}

illustrer:

• Nom : @ComponentScan
• Type : annotation de classe
• Les attributs
  • includeFilters : exclut les beans chargés dans le chemin d'analyse, vous devez spécifier la catégorie (type) et les éléments spécifiques (classes)
  • includeFilters : chargez le bean spécifié , vous devez spécifier la catégorie (type) et les éléments spécifiques (classes)

détail:

​ Étant donné que cette annotation se trouve dans @ComponentScan, elle peut être @Filterdirectement utilisée comme annotation interne..

3.5SpringMvcConfig.class

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("love.ljtxy.controller")
public class SpringMvcConfig {
    
    

}

illustrer:

​ Ici, il vous suffit de configurer le contrôle SpringMVC pour analyser uniquement controllerles packages de la couche. Parce que la configuration de SpringMVC remplace la couche de contrôle dans Spring

4. Demande et réponse

Résumé des notes :

1. Chemin de mappage de la demande : @RequestMapping : définissez le chemin d'accès à la demande de la méthode du contrôleur actuel. S'il est défini, définissez le préfixe du chemin d'accès à la demande de la méthode du contrôleur actuel de manière uniforme sur la classe.

2. Méthode de demande :

• Obtenir les paramètres de la requête
• Paramètres de la demande de publication

3. Demande de publication de traitement tronqué en chinois

// AbstractAnnotationConfigDispatcherServletInitializer 是 Spring Framework 中的一个类，它用于配置和初始化基于注解的 Spring MVC 应用程序
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
     
     
    // 配字符编码过滤器
    protected Filter[] getServletFilters() {
     
     
        CharacterEncodingFilter filter = new CharacterEncodingFilter(); //添加过滤器
        filter.setEncoding("utf-8"); //指定过滤器字符集
        return new Filter[]{
     
     filter};
    }
}

4. Paramètres de la demande

5. Paramètres ordinaires - même nom : aucune configuration requise

6. Paramètres ordinaires - le nom est différent : vous devez utiliser **@RequestParam pour lier la relation des paramètres**

7. Paramètres POJO (point clé) : Définissez les paramètres formels de type POJO pour recevoir les paramètres directement sans configuration supplémentaire . Notez que les noms d'attributs dans la classe d'entité doivent être cohérents. Convient à la liaison de paramètres de forme régulière !

8. Paramètres POJO imbriqués : le nom du paramètre de demande est le même que le nom de l'attribut d'objet du paramètre formel , et les paramètres d'attribut POJO imbriqués peuvent être reçus en fonction de la relation hiérarchique de l'objet.

9. Paramètres du tableau : définissez les paramètres de type tableau pour recevoir plusieurs paramètres . Fonctionne très bien pour les liaisons de paramètres de formulaire standard !

10. La collection enregistre les paramètres ordinaires : @RequestParam lie les relations entre les paramètres, par exemple@RequestParam List<String> likes

11. Transmettre les données Json

    1. Importer les coordonnées :

    <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-databind</artifactId>
     <version>2.9.0</version>
    </dependency>
    

    2. Définir les paramètres de la demande

    3. Activer la prise en charge de la conversion automatique des données JSON

    @Configuration
    @ComponentScan("com.itheima.controller")
    @EnableWebMvc // 在SpringMVC中需要开启Json数据自动类型转换，与SpringBoot不同
    public class SpringMvcConfig {
           
           
    }
    

12. Passer des objets Json : définissez les paramètres de type POJO et utilisez des annotations @RequestBodypour recevoir les paramètres. Utilisé lors du traitement des données JSON ! !

13. Passer le tableau Json : Les données du tableau json ont le même nom que la propriété générique de la collection. Définissez le paramètre de type List pour recevoir les paramètres. Utilisé lors du traitement des données JSON ! !

14. Passage du paramètre de type de date :

• @DateTimeFormat (pattern = « aaaa - MM-jj ») : définit le format des données de date et d'heure

6. Explication des annotations :

• @RequestParam : lie la relation entre les paramètres de la requête et les paramètres de la méthode du processeur , souvent utilisée pour le traitement des données entre les formulaires.
• @EnableWebMvc : Activer plusieurs fonctions auxiliaires de SpringMVC
• @RequestBody : Transmettez les données contenues dans le corps de la requête dans la requête aux paramètres de la requête . Cette annotation ne peut être utilisée qu'une seule fois par méthode processeur. Couramment utilisé pour le traitement des données entre Json

7. réponse:

• Page de réponse : renvoie « page.jsp » ;
• Données de réponse :
  • Données texte : renvoie le « texte de réponse » ;
  • Données Json : utilisez **@ResponseBody** pour définir la réponse au format Json . La couche inférieure consiste à utiliser l'interface du convertisseur de type HttpMessageConverter pour correspondre aux différentes classes d'implémentation, puis à effectuer la conversion

4.1 Chemin de mappage de la demande

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
    
    
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
}

illustrer:

Nom : @RequestMapping

• Type : annotation de classe d'annotation de méthode

• Emplacement : au-dessus de la définition de la méthode du contrôleur SpringMVC

• Fonction : Définissez le chemin d'accès à la demande de la méthode du contrôleur actuel. S'il est défini, définissez le préfixe du chemin d'accès à la demande de la méthode du contrôleur actuel de manière uniforme sur la classe.

• Les attributs

  • valeur (par défaut) : demande de chemin d'accès ou préfixe du chemin d'accès

4.2 Méthode de requête

1.Obtenir les paramètres de la demande

2.Paramètres de la demande de publication

4.3 Post-demande Traitement tronqué en chinois

// AbstractAnnotationConfigDispatcherServletInitializer 是 Spring Framework 中的一个类，它用于配置和初始化基于注解的 Spring MVC 应用程序
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
    
    
    // 配字符编码过滤器
    protected Filter[] getServletFilters() {
    
    
        CharacterEncodingFilter filter = new CharacterEncodingFilter(); //添加过滤器
        filter.setEncoding("utf-8"); //指定过滤器字符集
        return new Filter[]{
    
    filter};
    }
}

illustrer:

​ Vous devez ajouter un filtre dans SpringMVC, tout comme dans la requête Servlet, vous devez ajouter un filtre avec des caractères de requête pour la requête de réponse.

détail:

​ Ajoutez un filtre au conteneur Web et spécifiez le jeu de caractères. Le package Spring-web fournit un filtre de caractères dédié.

Remplir:

Référence plus détaillée : Analyse de AbstractAnnotationConfigDispatcherServletInitializer_Yan Demon King's Blog-CSDN Blog

4.4 Paramètres de la requête

​ Les paramètres de requête sont des données envoyées par le client (navigateur, application mobile, etc.) au serveur pour indiquer au serveur quoi faire ou fournir les données requises.

4.4.1 Paramètres ordinaires - même nom

​ L'adresse URL est utilisée pour transmettre les paramètres. Le nom du paramètre d'adresse est le même que le nom de la variable du paramètre formel . Vous pouvez recevoir les paramètres en définissant le paramètre formel.

@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name ,int age){
    
    
    System.out.println("普通参数传递 name ==> "+name);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param'}";
}

4.4.2 Paramètres ordinaires - noms différents

​ Le nom du paramètre de requête est différent du nom de la variable de paramètre formel. Utilisez @RequestParam pour lier la relation du paramètre.

@RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(@RequestParam("name")String userName , int age){
    
    
    System.out.println("普通参数传递 userName ==> "+userName);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param different name'}";
}

détail:

​ Si le nom du paramètre de requête est différent du nom de la variable de paramètre formel, vous devez utiliser @RequestParam pour lier la relation de paramètre. S'ils sont identiques, pas besoin de le préciser

Remplir:

• Nom : @RequestParam
  • Type : annotation de paramètre formel
  • Position : avant la définition formelle des paramètres de la méthode du contrôleur SpringMVC
  • Fonction : lier la relation entre les paramètres de la requête et les paramètres de la méthode du processeur
• paramètre:
  • requis : s'il s'agit d'un paramètre obligatoire
  • defaultValue : valeur par défaut du paramètre

4.4.3Paramètres POJO (points clés)

​ Le nom du paramètre de requête est le même que le nom de la propriété de l'objet paramètre formel. Vous pouvez recevoir des paramètres en définissant un paramètre de type POJO. Convient à la liaison de paramètres de formulaire régulier

@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    
    
    System.out.println("pojo参数传递 user ==> "+user);
    return "{'module':'pojo param'}";
}

illustrer:

​ Lors de l'utilisation du transfert de paramètres PoJo, le paramètre qui doit être transmis par valeur correspond au nom de l'attribut dans l'objet et peut être reçu

détail:

​ Lors de l'utilisation de paramètres PoJo pour transmettre des paramètres, le framework SpringMVC obtiendra d'abord la méthode constructeur en fonction du type de PoJo, créera d'abord l'objet, puis le transmettra selon la méthode définie des paramètres.

4.4.4 Paramètres POJO imbriqués

​ Le nom du paramètre de demande est le même que le nom de l'attribut d'objet de paramètre formel, et les paramètres d'attribut POJO imbriqués peuvent être reçus en fonction de la relation hiérarchique des objets.

@RequestMapping("/pojoContainPojoParam")
@ResponseBody
public String pojoContainPojoParam(User user){
    
    
    System.out.println("pojo嵌套pojo参数传递 user ==> "+user);
    return "{'module':'pojo contain pojo param'}";
}

4.4.5 Paramètres du tableau

​ Le nom du paramètre de requête est le même que le nom de propriété de l'objet paramètre formel et il existe plusieurs paramètres de requête. Vous pouvez recevoir des paramètres en définissant un paramètre de type tableau

@RequestMapping("/arrayParam")
@ResponseBody
public String arrayParam(String[] likes){
    
    
    System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
    return "{'module':'array param'}";
}

4.4.6 La collecte enregistre les paramètres communs

​ Si le nom du paramètre de demande est le même que le nom de l'objet de collection de paramètres formel et qu'il existe plusieurs paramètres de demande, @RequestParam lie la relation des paramètres.

@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
    
    
    System.out.println("集合参数传递 likes ==> "+ likes);
    return "{'module':'list param'}";
}

Avis:

​ Si vous utilisez une collection pour enregistrer les paramètres communs, le framework SpringMVC transmettra cette collection en tant qu'objet PoJo. Et la collection n'a pas de méthode de construction, donc une erreur sera signalée.

À ce stade, @RequestParamaprès avoir ajouté des annotations, le framework SpringMVC placera directement les paramètres impliqués dans la requête dans la collection.

4.4.7 Cas d'utilisation de base : étapes de transmission des données Json

Étape 1 : Ajouter les coordonnées liées à la conversion de données JSON

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>

Étape 2 : Configurer l'envoi de données JSON (ajouter des données JSON dans le corps de la demande)

Étape 3 : Activer la prise en charge de la conversion automatique des données JSON

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc // 在SpringMVC中需要开启Json数据自动类型转换，与SpringBoot不同
public class SpringMvcConfig {
    
    
}

illustrer:

​ L'annotation @EnableWebMvc est puissante. Cette annotation intègre plusieurs fonctions. Seule une partie est utilisée ici, c'est-à-dire la conversion automatique de type des données json.

Remplir:

• Nom : @EnableWebMvc
  • Type : annotation de classe de configuration
  • Emplacement : au-dessus de la définition de la classe de configuration SpringMVC
  • Rôle : activer plusieurs fonctions auxiliaires de SpringMVC

Étape 4 : Configurer pour recevoir des données JSON

@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    
    
    System.out.println("list common(json)参数传递 list ==> "+likes);
    return "{'module':'list common for json param'}";
}

illustrer:

Nom : @RequestBody

• Type : annotation de paramètre formel
• Position : avant la définition formelle des paramètres de la méthode du contrôleur SpringMVC
• Fonction : Transmettre les données contenues dans le corps de la requête dans la requête aux paramètres de la requête. Cette annotation ne peut être utilisée qu'une seule fois par méthode processeur.

4.4.8 Passer l'objet Json (souligné)

​ Les données json ont le même nom de propriété que l'objet paramètre formel, et les paramètres peuvent être reçus en définissant le paramètre de type POJO. Utilisé lors du traitement des données JSON

prémisse:

• Ajouter les coordonnées liées à la conversion de données JSON
• Activer la prise en charge de la conversion automatique des données JSON

@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    
    
    System.out.println("pojo(json)参数传递 user ==> "+user);
    return "{'module':'pojo for json param'}";
}

4.4.9 Passer le tableau Json

​ Les données du tableau json ont le même nom que la propriété générique de la collection. Définissez le paramètre de type List pour recevoir les paramètres.

@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
    
    
    System.out.println("list pojo(json)参数传递 list ==> "+list);
    return "{'module':'list pojo for json param'}";
}

Remarque : Les conditions préalables suivantes sont requises

• Ajouter les coordonnées liées à la conversion de données JSON
• Activer la prise en charge de la conversion automatique des données JSON

4.5 Transfert des paramètres du type de date

• Les données de type date ont différents formats basés sur différents systèmes.
  • 2088-08-18
  • 2088/08/18
  • 18/08/2088
• Lors de la réception de paramètres formels, définissez différentes méthodes de réception en fonction de différents formats de date

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
                        @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss")Date date2){
    
    
    System.out.println("参数传递 date ==> "+date);
    System.out.println("参数传递 date(yyyy-MM-dd) ==> "+date1);
    System.out.println("参数传递 date(yyyy/MM/dd HH:mm:ss) ==> "+date2);
    return "{'module':'data param'}";
}

illustrer:

• demander:

  http://localhost/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08
  

Remplir:

• Nom : @DateTimeFormat
  • Type : annotation de paramètre formel
  • Position : devant les paramètres de la méthode du contrôleur SpringMVC
  • Fonction : définir le format des données de date et d'heure
  • Les attributs:
    • modèle : chaîne de format de date et d'heure

Remarque : La fonction de conversion de type doit être activée sur la classe de configuration

• Nom : @EnableWebMvc

• Fonction : Faire correspondre le convertisseur de type correspondant en fonction du type est l'une des fonctions de cette annotation

Extension : les paramètres sont transmis via des annotations et le travail interne est réellement implémenté via l'interface Converter.

• Interface du convertisseur

  public interface Converter<S, T> {
         
         
      @Nullable
      T convert(S var1);
  }
  

• Demander des données sur l'âge des paramètres (String → Integer)

• données json à objecter (json → POJO)

• Conversion du format de date (Chaîne → Date)

Convert a tellement de classes d'implémentation pour convertir les types de données

4.6 Réponse

4.6.1 Aperçu

​La réponse est le message renvoyé par le serveur au client pour fournir les données nécessaires à la requête ou le résultat de l'exécution de l'opération.

Catégories de réponses :

1. page de réponse
2. données de réponse
   • données texte
   • données json

4.6.2 Page de réponse (comprendre)

@RequestMapping("/toPage")
public String toPage(){
    
    
    return "page.jsp";
}

4.6.3 Données du texte de réponse (compréhension)

@RequestMapping("/toText")
@ResponseBody
public String toText(){
    
    
    return "response text";
}

Remplir:

• Nom : @ResponseBody
  • Type : annotation de méthode
  • Emplacement : au-dessus de la définition de la méthode du contrôleur SpringMVC
  • Fonction : définir la valeur de retour du contrôleur actuel comme corps de réponse

Avis:

​ Lorsque vous utilisez @ResponseBody pour répondre au contenu, vous devez ajouter

4.6.4 Répondre aux données Json (objecter à Json)

@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
    
    
    User user = new User();
    user.setName("赵云");
    user.setAge(41);
    return user;
}

Remplir:

• Convertisseur de types Interface HttpMessageConverter

  public interface HttpMessageConverter<T> {
         
         
     boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
     boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
     List<MediaType> getSupportedMediaTypes();
     T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
           throws IOException, HttpMessageNotReadableException;
     void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
           throws IOException, HttpMessageNotWritableException;
  }
  

  ​ Lorsque vous utilisez l'annotation @ResponseBody pour répondre au contenu, celui-ci n'est pas converti via l'interface Converter, mais via une nouvelle interface HttpMessageConverter接口.

4.6.5 Répondre aux données Json (convertir la collection d'objets en tableau Json)

@RequestMapping("/toJsonList")
@ResponseBody
public List<User> toJsonList(){
    
    
    User user1 = new User();
    user1.setName("赵云");
    user1.setAge(41);
    User user2 = new User();
    user2.setName("master 赵云");
    user2.setAge(40);
    List<User> userList = new ArrayList<User>();
    userList.add(user1);
    userList.add(user2);
    return userList;
}

5.style repos

Résumé des notes :

1. Présentation : REST (Representational State Transfer) est un style d'architecture logicielle qui se concentre sur l'état des ressources et l'interaction entre les ressources.

2. Définir l'action de la requête HTTP (verbe) : @RequestMapping(value = « xxx », method = RequestMethod.POST )

3. Définir les paramètres de la requête (variable de chemin) : @RequestMapping( value = “/users/{id}” , method = xxxx)

4. Développement rapide RESTful :

   • @RestController : définissez la classe de contrôleur actuelle sur le style RESTful, ce qui équivaut à la fonction combinée des annotations @Controller et @ResponseBody

     @RestController
     public class BookController {
              
              
     }
     

   • @GetMapping @PostMapping @PutMapping @DeleteMapping : Définissez le chemin d'accès à la demande de la méthode du contrôleur actuel et l'action de la demande

     @GetMapping("/{id}")
     public String getById(@PathVariable Integer id){
              
              }
     

5.1 Aperçu

REST (Representational State Transfer) est un style architectural logiciel utilisé pour concevoir des systèmes distribués pour les applications réseau. Il se concentre principalement sur l'état des ressources et l'interaction entre les ressources , obtenues grâce à l'utilisation d'une interface unifiée et de diverses méthodes du protocole HTTP.

• Formulaire de description de ressource de style traditionnel

  http://localhost/user/getById?id=1

  http://localhost/user/saveUser

• Formulaire de description du style REST

  http://localhost/user/1

  http://localhost/utilisateur

avantage:

• Masquer le comportement d'accès aux ressources. Il est impossible de savoir quelles opérations sont effectuées sur les ressources via l'adresse.
• Simplifier l'écriture

Introduction au style REST

5.2 Définir l'action de la requête HTTP (verbe)

@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
    
    
    System.out.println("user save..." + user);
    return "{'module':'user save'}";
}

@RequestMapping(value = "/users" ,method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user){
    
    
    System.out.println("user update..."+user);
    return "{'module':'user update'}";
}

Remplir:

• Nom : @RequestMapping
  • Type : annotation de méthode
  • Emplacement : au-dessus de la définition de la méthode du contrôleur SpringMVC
  • Fonction : définir le chemin d'accès actuel à la demande de méthode du contrôleur
  • Les attributs
    • valeur (par défaut) : demander le chemin d'accès
    • méthode : action de requête http, action standard (GET/POST/PUT/DELETE)

5.3 Définir les paramètres de la requête (variables de chemin)

@RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
    
    
    System.out.println("user delete..." + id);
    return "{'module':'user delete'}";
}

Remplir:

• Nom : @PathVariable
  • Type : annotation de paramètre formel
  • Position : avant la définition formelle des paramètres de la méthode du contrôleur SpringMVC
  • Fonction : lie la relation entre les paramètres de chemin et les paramètres formels de la méthode du processeur, nécessitant une correspondance biunivoque entre les noms de paramètres de chemin et les noms de paramètres formels.

5.4Développement rapide RESTful

Nom : @RestController

• Type : annotation de classe

• Position : au-dessus de la définition de la classe du contrôleur de développement RESTful basée sur SpringMVC

• Fonction : définissez la classe de contrôleur actuelle sur le style RESTful, ce qui équivaut à la fonction combinée des deux annotations @Controller et @ResponseBody.

• exemple:

  @RestController
  public class BookController {
        
        
  }
  

Nom : @GetMapping @PostMapping @PutMapping @DeleteMapping

• Type : annotation de méthode

• Emplacement : au-dessus de la définition de la méthode du contrôleur de développement RESTful basée sur SpringMVC

• Fonction : définissez le chemin d'accès à la demande de la méthode du contrôleur actuel et l'action de la demande, chacun correspondant à une action de demande, par exemple, @GetMapping correspond à la demande GET

• exemple:

  @GetMapping("/{id}")
  public String getById(@PathVariable Integer id){
        
        
      System.out.println("book getById..."+id);
      return "{'module':'book getById'}";
  }
  

• Attribut : valeur (par défaut) : chemin d'accès de la demande

5.5 Interaction de base entre les données de cas et la page RESTful

Étape zéro : créer l'environnement de base

Étape 1 : Créez un contrôleur SpringMVC et testez la fonction d'interface via PostMan

illustrer:

​ Le même 基本用例-SpringMVC基础应用processus ne sera pas présenté ici.

Étape 2 : Définir l'autorisation d'accès aux ressources statiques

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    
    
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        //当访问/pages/????时候，走/pages目录下的内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

illustrer:

​ Lors de l'accès aux ressources Web, étant donné que la classe ServletContainersInitConfig à l'étape 0 configure la méthode getServletMappings comme interception /et chemin, lors de l'accès aux ressources statiques dans le répertoire webapp, la demande sera interceptée par SpringMVC.

protected String[] getServletMappings() {
     
     
return new String[]{
     
     "/"};
}

À ce stade, il existe de nombreuses méthodes de traitement. Vous pouvez créer une nouvelle classe, hériter de WebMvcConfigurationSupport, puis remplacer la méthode addResourceHandlers pour ajouter des gestionnaires de ressources. Lors du traitement des ressources, accédez simplement /xx/**aux ressources sous le chemin d'accès vers /xx/le répertoire des ressources.

Avis:

​ Lorsque cette requête est configurée, SpringMVC doit être chargé pour charger cette configuration

Étape 3 : Charger la configuration de la demande de ressources

//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan({
    
    "love.ljtxy.controller","love.ljtxy.config"})
@EnableWebMvc
public class SpringMvcConfig {
    
    

}

illustrer:

À ce stade, ajoutez simplement une nouvelle classe de numérisation

6.Intégration SSM (clé)

Résumé des notes : Cette section est au centre de l'attention, veuillez consulter chaque section pour plus de détails

6.1 Aperçu

Résumé des notes :

• Signification : Le framework SSM est une intégration du framework Spring, Spring MVC et Mybatis et constitue un modèle MVC standard . Le framework SSM standard comporte quatre couches, à savoir la couche dao (mapper), la couche de service, la couche contrôleur et la couche View.

• Couche de persistance : La couche dao (mapper) est principalement responsable du travail de la couche de persistance des données. Certaines tâches responsables de la communication avec la base de données sont encapsulées ici.

• Couche métier : Couche de service. La couche Service est principalement responsable de la conception des applications logiques des modules métiers .

• Couche de présentation : Couche contrôleur (couche Handler), responsable du contrôle des processus spécifiques du module métier .

• Couche d'affichage : la couche d'affichage est principalement étroitement intégrée à la couche de contrôle et est principalement responsable de la représentation de la page jsp frontale .

• Diagramme d'interaction relationnelle :

  

​ Le framework SSM est une intégration du framework spring, spring MVC et mybatis. Il s'agit d'un modèle MVC standard. Le framework SSM standard comporte quatre couches, à savoir la couche dao (mapper), la couche de service, la couche contrôleur et la couche View. Utilisez Spring pour implémenter la gestion des objets métier, utilisez Spring MVC pour être responsable du transfert des demandes et de la gestion des vues, et mybatis comme moteur de persistance pour les objets de données.

1) Couche de persistance : Couche Dao (mapper)
Fonction : Principalement responsable du travail de la couche de persistance des données, certaines tâches responsables de la communication avec la base de données sont encapsulées ici.

• La couche Dao conçoit d'abord l'interface, puis définit la classe d'implémentation de l'interface dans le fichier de configuration Spring.
• Ensuite, l'interface peut être appelée dans le module pour traiter les données commerciales. (Vous ne vous souciez plus de la classe d'implémentation de l'interface)
• La configuration de la source de données et les paramètres liés à la connexion à la base de données sont configurés dans le fichier de configuration Spring.

2) Couche métier : Couche de service
Fonction : La couche Service est principalement responsable de la conception d'application logique du module métier.

• Concevez d'abord l'interface, puis concevez la classe réelle, puis configurez son association d'implémentation dans le fichier de configuration Spring. (L'implémentation de la couche logique métier doit appeler l'interface Dao qui a été définie par elle-même.) De cette façon, l'interface Service peut être appelée dans l'application pour le traitement métier.
• Après avoir établi Dao, établissez la couche service. La couche service doit être sous la couche contrôleur car elle doit non seulement appeler l'interface de la couche Dao mais également fournir l'interface avec la couche contrôleur. Chaque modèle possède une interface de service et chaque interface encapsule ses propres méthodes de traitement métier.

3) Couche de présentation : rôle de la couche contrôleur (couche gestionnaire)
 : responsable du contrôle des processus spécifiques du module métier .

• La configuration se fait également dans le fichier de configuration de Spring.
• Appelez l'interface fournie par la couche Service pour contrôler le processus métier.
• Différents processus métier auront différents contrôleurs. Dans un développement spécifique, nos processus peuvent être résumés de manière abstraite et des modules de processus sous-unitaires peuvent être conçus et réutilisés.

4) Fonction de la couche d'affichage
 : elle est principalement étroitement intégrée à la couche de contrôle et est principalement responsable de la présentation de la page jsp frontale.

6.2 Configuration intégrée

Résumé des notes :

• Étape 1 : Importer les dépendances
• Étape 2 : Créer la structure de répertoires de base
• Étape 3 : Écrivez la classe JdbcConfig
  • Créer DruidDataSource comme source de données
  • Créer DataSourceTransactionManager en tant que gestionnaire de transactions
• Étape 4 : Écrivez la classe MyBatisConfig
  • Configurer SqlSessionFactoryBean pour créer des instances SqlSessionFactory
  • Configurez MapperScannerConfigurer pour analyser et enregistrer automatiquement l'interface Mapper de MyBatis
• Étape 5 : Écrivez la classe ServletConfig
  • Obtenez la classe de configuration racine de Spring, utilisée pour configurer le conteneur Spring
  • Obtenez la classe de configuration SpringMVC, utilisée pour configurer le conteneur SpringMVC
  • Obtenez le chemin de mappage de DispatcherServlet
• Étape 6 : Écrivez la classe SpringConfig
  • Analyser les composants et les beans sous le package spécifié
  • Charger le fichier de propriétés jdbc.properties
  • Importer les classes de configuration JdbcConfig et MyBatisConfig
  • Transaction ouverte
• Étape 7 : Écrivez la classe SpringMvcConfig
  • Scannez le package où se trouve le composant du contrôleur
  • Activer la fonctionnalité Spring MVC

Veuillez consulter cette section pour plus de détails

Étape 1 : Importer les dépendances

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.15.0</version>
</dependency>

illustrer:

​ Voici quelques dépendances d'intégration SSM classiques, parmi lesquelles javax.servlet-api est une dépendance d'interaction de requête de servlet, spring-webmvc est une dépendance de remplacement de couche de contrôle, mybatis et mybatis-spring sont des dépendances d'intégration SpringMVC MyBatis, druid et spring-jdbc sont utilisé Spring fournit des dépendances de fonctionnement de la source de données, et jackson-core est utilisé pour convertir les données de réponse et les données reçues.

Étape 2 : Créer la structure de répertoires de base

Étape 3 : Écrivez la classe JdbcConfig

public class JdbcConfig {
    
    
    // 注入jdbc.driver配置项的值
    @Value("${jdbc.driver}")
    private String driver;
    // 注入jdbc.url配置项的值
    @Value("${jdbc.url}")
    private String url;
    // 注入jdbc.username配置项的值
    @Value("${jdbc.username}")
    private String username;
    // 注入jdbc.password配置项的值
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
    
    
        // 创建DruidDataSource作为数据源
        DruidDataSource dataSource = new DruidDataSource();
        // 配置数据源的驱动类
        dataSource.setDriverClassName(driver);
        // 配置数据源的URL
        dataSource.setUrl(url);
        // 配置数据源的用户名
        dataSource.setUsername(username);
        // 配置数据源的密码
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
    
    
        // 创建DataSourceTransactionManager作为事务管理器
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        // 设置事务管理器使用的数据源
        ds.setDataSource(dataSource);
        return ds;
    }
}

illustrer:

Grâce à l'opération d'injection ci-dessus, les valeurs d'attribut liées à la connexion à la base de données dans le fichier de configuration peuvent être injectées dans les champs correspondants. De cette manière, d'autres composants qui doivent utiliser la source de données peuvent obtenir le bean de source de données via l'injection de dépendances, obtenant ainsi la connexion à la base de données pour les opérations et la gestion des transactions.

Étape 4 : Écrivez la classe MyBatisConfig

public class MyBatisConfig {
    
    

    /**
     * 配置SqlSessionFactoryBean，用于创建SqlSessionFactory实例
     * @param dataSource 数据源
     * @return SqlSessionFactoryBean实例
     */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
    
    
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("love.ljtxy.entity"); // 设置实体类的别名包路径
        return factoryBean;
    }

    /**
     * 配置MapperScannerConfigurer，用于自动扫描并注册MyBatis的Mapper接口
     * @return MapperScannerConfigurer实例
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
    
    
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("love.ljtxy.mapper"); // 设置Mapper接口的包路径
        return msc;
    }
}

illustrer:

En introduisant cette classe de configuration dans le fichier de configuration Spring, la configuration pertinente de MyBatis peut être complétée, afin que les applications puissent facilement utiliser MyBatis pour les opérations de base de données.

Étape 5 : Écrivez la classe ServletConfig

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    

    /**
     * 获取Spring的根配置类，用于配置Spring容器
     * @return 根配置类数组
     */
    protected Class<?>[] getRootConfigClasses() {
    
    
        return new Class[]{
    
    SpringConfig.class};
    }

    /**
     * 获取SpringMVC的配置类，用于配置SpringMVC容器
     * @return SpringMVC配置类数组
     */
    protected Class<?>[] getServletConfigClasses() {
    
    
        return new Class[]{
    
    SpringMvcConfig.class};
    }

    /**
     * 获取DispatcherServlet的映射路径
     * @return 映射路径数组
     */
    protected String[] getServletMappings() {
    
    
        return new String[]{
    
    "/"};
    }
}

illustrer:

En chargeant automatiquement la classe de configuration du servlet au démarrage du conteneur Web, l'initialisation et la configuration des conteneurs Spring et SpringMVC peuvent être complétées, afin que l'application puisse gérer les requêtes Web et effectuer le traitement correspondant.

Remplir:

​ Le conteneur SpringMVC peut accéder au conteneur Spring. Le conteneur Spring ne peut pas accéder au conteneur SpringMVC. Parce que le conteneur IOC de Spring est défini ici comme conteneur parent du conteneur IOC de Spring MVC

Étape 6 : Écrivez la classe SpringConfig

@Configuration
@ComponentScan("love.ljtxy.service") // 扫描指定包下的组件和Bean
@PropertySource("classpath:jdbc.properties") // 加载jdbc.properties属性文件
@Import({
    
    JdbcConfig.class, MyBatisConfig.class}) // 导入JdbcConfig和MyBatisConfig配置类
@EnableTransactionManagement //开启事务
public class SpringConfig {
    
    
}

Avis:

​ Lorsque Spring utilise des transactions, vous devez utiliser des annotations @EnableTransactionManagementpour activer les transactions

illustrer:

​ Grâce à ces configurations, le conteneur Spring peut charger et gérer des composants et des beans sous le chemin de package spécifié, et peut importer d'autres classes de configuration si nécessaire pour obtenir une configuration et un assemblage flexibles.

Remplir:

• @ImportL'annotation est une méta-annotation dans Spring Framework, qui est utilisée pour importer d'autres classes de configuration dans la classe de configuration actuelle afin de combiner les fonctions de plusieurs classes de configuration. Grâce @Importaux annotations, d'autres classes de configuration peuvent être chargées dans le conteneur Spring en tant que définitions de bean.
• Les annotations peuvent être utilisées @PropertySourcepour gérer et charger facilement les valeurs d'attribut dans les fichiers de propriétés, rendant les valeurs d'attribut dans les classes de configuration plus flexibles et configurables.

Étape 7 : Écrivez la classe SpringMvcConfig

@Configuration
@ComponentScan("love.ljtxy.controller") // 扫描控制器组件所在的包
@EnableWebMvc // 启用Spring MVC功能
public class SpringMvcConfig {
    
    
}

illustrer:

​ Grâce à la configuration ci-dessus, Spring MVC peut analyser automatiquement les classes de contrôleur sous le package spécifié et fournir un mappage de requêtes basé sur des annotations, une analyse de paramètres, une analyse de vues et d'autres fonctions, rendant le développement d'applications Web plus pratique et efficace.

6.3 Développement de modules fonctionnels

Résumé des notes :

• Étape 1 : Écrire la classe d'entité
• Étape 2 : Écrire l'interface de la couche Dao
  • @Insert, @Update, @Delete, @Selectles annotations associent les instructions SQL aux méthodes.
  • L'instruction SQL dans l'annotation utilise l'espace réservé #{propertyName}pour faire référence à la valeur d'attribut de l'objet afin de réaliser une liaison de paramètre dynamique.
• Étape 3 : Écrire l'interface du service
  • D'une manière générale, lors de l'écriture de la couche d'interface Service, vous devez connaître le nom et la signification.
  • D'une manière générale, lors de l'écriture d'une interface, vous devez renvoyer les résultats des opérations de ce service
• Étape 4 : Écrire la couche d'implémentation de l'interface de service
  • De manière générale, après avoir écrit la classe d'implémentation Service, vous pouvez tester les méthodes de la couche Service.
• Étape 5 : tester la couche de service
  • @RunWithLes annotations sont utilisées pour spécifier le lanceur de test (test runner), qui indique à JUnit d'utiliser un exécuteur spécifique pour exécuter le test lors de l'exécution du test.
  • @ContextConfigurationLes annotations sont utilisées pour spécifier les informations de configuration du conteneur Spring et indiquer à JUnit quelles configurations charger avant d'exécuter le test.
• Écrire la couche de présentation

Étape 1 : Écrire la classe d'entité

@Date
public class Book {
    
    
    private Integer id;
    private String type;
    private String name;
    private String description;
}

Étape 2 : Écrire l'interface de la couche Dao

public interface BookDao {
    
    

    // 插入书籍
    @Insert("insert into tbl_book (type, name, description) values (#{type}, #{name}, #{description})")
    public void save(Book book);

    // 更新书籍
    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public void update(Book book);

    // 删除书籍
    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);

    // 根据ID查询书籍
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    // 获取所有书籍
    @Select("select * from tbl_book")
    public List<Book> getAll();
}

illustrer:

• Ces méthodes utilisent la méthode d'annotation de MyBatis pour spécifier l'instruction SQL correspondante et associent l'instruction SQL à la méthode via @Insertles annotations @Update, @Deleteet . @SelectL'instruction SQL dans l'annotation utilise des espaces réservés #{propertyName}pour référencer les valeurs d'attribut de l'objet afin d'implémenter la liaison de paramètres dynamique.
• Utilisez ces méthodes pour effectuer facilement des opérations de base de données, telles que l'insertion de livres, la mise à jour des informations sur les livres, la suppression de livres, l'interrogation de livres individuels et l'obtention d'une liste de tous les livres.

Étape 3 : Écrire l'interface du service

@Transactional
public interface BookService {
    
    

    /**
     * 保存
     *
     * @param book
     * @return
     */
    public boolean saveBookInfo(Book book);

    /**
     * 修改
     *
     * @param book
     * @return
     */
    public boolean updateBookInfo(Book book);

    /**
     * 按id删除
     *
     * @param id
     * @return
     */
    public boolean deleteBookInfo(Integer id);

    /**
     * 按id查询
     *
     * @param id
     * @return
     */
    public Book getBookInfo(Integer id);

    /**
     * 查询全部
     *
     * @return
     */
    public List<Book> getBookAllInfo();
}

Avis:

  		当Spring使用了事务时，需要使用注解`@Transactional`来启用事务。若还需要对@Transactional做其余的配置，可以根据需求来进行决定

illustrer:

• D'une manière générale, lors de l'écriture de la couche d'interface Service, vous devez connaître le nom et la signification.
• D'une manière générale, lors de l'écriture d'une interface, vous devez renvoyer les résultats des opérations de ce service

Étape 4 : Écrire la couche d'implémentation de l'interface de service

@Service
public class BookServiceImpl implements BookService {
    
    
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
    
    
        bookDao.save(book);
        return true;
    }

    public boolean update(Book book) {
    
    
        bookDao.update(book);
        return true;
    }

    public boolean delete(Integer id) {
    
    
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
    
    
        return bookDao.getById(id);
    }

    public List<Book> getAll() {
    
    
        return bookDao.getAll();
    }
}

illustrer:

De manière générale, après avoir écrit la classe d'implémentation Service, vous pouvez tester les méthodes de la couche Service.

Étape 5 : tester la couche de service

@RunWith(SpringJUnit4ClassRunner.class) // 注解指定了运行测试的类为SpringJUnit4ClassRunner，这样就能够在测试过程中启动Spring容器。
@ContextConfiguration(classes = SpringConfig.class) //注解指定了使用哪个配置类来加载Spring容器。
public class BookServiceTest {
    
    

    @Autowired
    private BookService bookService;

    @Test
    public void testGetById(){
    
    
        // 测试根据ID获取图书信息的方法
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
    
    
        // 测试获取所有图书信息的方法
        List<Book> all = bookService.getAll();
        System.out.println(all);
    }
}

Remplir:

• @RunWithLes annotations sont utilisées pour spécifier le lanceur de test (test runner), qui indique à JUnit d'utiliser un exécuteur spécifique pour exécuter le test lors de l'exécution du test.
• @ContextConfigurationLes annotations sont utilisées pour spécifier les informations de configuration du conteneur Spring et indiquer à JUnit quelles configurations charger avant d'exécuter le test.

Étape 6 : Écrire la couche de présentation

@RestController
@RequestMapping("/books")
public class BookController {
    
    

    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book) {
    
    
        return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
    
    
        return bookService.update(book);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
    
    
        return bookService.delete(id);
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
    
    
        return bookService.getById(id);
    }

    @GetMapping
    public List<Book> getAll() {
    
    
        return bookService.getAll();
    }
}

6.4 Encapsulation des données de la couche présentation

Résumé des notes :

• Présentation : transfert de données et interaction entre le contrôleur (Controller) et la vue (View).

• Étape 1 : Définir la classe de résultats de retour des données unifiées

  • Le frontal reçoit le format de données - crée la classe de modèle de résultat et encapsule les données dans l'attribut de données
  • Format de données de réception frontale : encapsulation de messages spéciaux dans l'attribut message (msg)
  • Le frontal reçoit le format de données - encapsule les résultats de l'opération dans l'attribut code

• Étape 2 : Définir le code d'état de retour des données unifiées

  //状态码
  public class Code {
         
         
      public static final Integer SAVE_OK = 20011;
      public static final Integer DELETE_OK = 20021;
  }
  

• Étape 3 : Optimiser les classes de couche de présentation

  • Unifiez la valeur de retour de chaque méthode de contrôleur

​ Dans la couche de présentation (Presentation Layer), l'encapsulation des données fait référence à l'encapsulation et à la conversion appropriées des données de demande et des données de réponse pour faciliter le transfert de données et l'interaction entre le contrôleur (Contrôleur) et la vue (Vue).

Étape 1 : Définir la classe de résultats de retour des données unifiées

@Date
public class Result {
    
    
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;

    public Result() {
    
    
    }

    public Result(Integer code,Object data) {
    
    
        this.data = data;
        this.code = code;
    }

    public Result(Integer code, Object data, String msg) {
    
    
        this.data = data;
        this.code = code;
        this.msg = msg;
    }
}

illustrer:

Les champs de la classe Résultat ne sont pas fixes et peuvent être augmentés ou diminués selon les besoins. Plusieurs méthodes de construction sont proposées pour faciliter le fonctionnement.

• Le frontal reçoit le format de données - crée la classe de modèle de résultat et encapsule les données dans l'attribut de données
• Format de données de réception frontale : encapsulation de messages spéciaux dans l'attribut message (msg)
• Le frontal reçoit le format de données - encapsule les résultats de l'opération dans l'attribut code

Étape 2 : Définir le code d'état de retour des données unifiées

//状态码
public class Code {
    
    
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

Étape 3 : Optimiser les classes de couche de présentation

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {
    
    

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
    
    
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
    
    
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
    
    
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
    
    
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
    
    
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
    }
}

illustrer:

​ 通常来说，可以在表现层实现业务逻辑的处理，我们可以在此设置操作结果的返回处理

6.5异常处理器

笔记小结：

• 概述：异常处理器（Exception Handler）是一种用于捕获和处理应用程序中出现的异常的机制。
• 整合流程：
  • 步骤一：新建异常处理类
    • @RestControllerAdvice 是一个用于全局异常处理的注解。它可以在整个应用程序范围内捕获和处理异常，并将处理结果以统一的格式返回给客户端
    • @ExceptionHandler(Exception.class) 注解用于标识一个异常处理方法，指定了要捕获和处理的异常类型。在这里，它捕获的是 Exception 类型的异常。
• 注解解释：
  • @RestControllerAdvice： 是一个用于全局异常处理的注解。为Rest风格开发的控制器类做增强
  • @ExceptionHandler：设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前方法执行

​ 异常处理器（Exception Handler）是一种用于捕获和处理应用程序中出现的异常的机制。在Java的Web应用中，异常处理器通常用于捕获控制器（Controller）中发生的异常，并根据需要进行适当的处理和响应。

出现异常现象的常见位置与常见诱因如下:

• 框架内部抛出的异常:因使用不合规导致
• 数据层抛出的异常:因外部服务器故障导致（例如:服务器访问超时)
• 业务层抛出的异常:因业务逻辑书写错误导致（例如:遍历业务书写操作，导致索引异常等)
• 表现层抛出的异常:因数据收集、校验等规则导致（例如:不匹配的数据类型间导致异常)
• Exceptions levées par les classes d'outils : causées par une écriture lâche de classes d'outils qui ne sont pas assez robustes (par exemple : les connexions qui doivent être libérées ne l'ont pas été depuis longtemps, etc.)

Étape 1 : Créer une nouvelle classe de gestion des exceptions

Sous le package du contrôleur, créez une nouvelle classe ProjectExceptionAdvice

@RestControllerAdvice
public class ProjectExceptionAdvice {
    
    

    /**
     * 全局异常处理方法
     * @param ex 异常对象
     * @return 自定义的结果对象
     */
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
    
    
        return new Result(666,null);
    }
}

illustrer:

• @RestControllerAdviceEst une annotation pour la gestion globale des exceptions. Il peut intercepter et gérer les exceptions dans toute l'application et renvoyer les résultats du traitement au client dans un format unifié.
• @ExceptionHandler(Exception.class)Les annotations sont utilisées pour identifier une méthode de gestion des exceptions et spécifier le type d'exception à intercepter et à gérer. Ici, il intercepte Exceptionune exception de type.

Remplir:

• Nom : @RestControllerAdvice

  • Type : annotation de classe

  • Position : au-dessus de la définition de la classe d'amélioration du contrôleur développée dans le style Rest

  • Fonction : Améliorer les classes de contrôleurs développées dans le style Rest

  • exemple:

    @RestControllerAdvice
    public class ProjectExceptionAdvice {
             
             }
    

  • illustrer:

    • Cette annotation est livrée avec l'annotation @ResponseBody et l'annotation @Component, qui ont des fonctions correspondantes.

• Nom : @ExceptionHandler

  • Type : annotation de méthode

  • Emplacement : Au dessus de la méthode du contrôleur dédiée à la gestion des exceptions

  • Fonction : définit le plan de traitement pour l'exception spécifiée . La fonction est équivalente à la méthode du contrôleur. Après qu'une exception se produit, l'exécution initiale du contrôleur est terminée et transférée à l'exécution de la méthode actuelle.

  • exemple:

    @RestControllerAdvice
    public class ProjectExceptionAdvice {
             
             
        @ExceptionHandler(Exception.class)
        public Result doException(Exception ex){
             
             
            return new Result(666,null);
        }
    

  • Ce type de méthode permet de créer plusieurs méthodes pour gérer les exceptions correspondantes en fonction des différentes exceptions traitées.

6.6 Gestion des exceptions du projet

Résumé des notes :

• Présentation : la gestion des exceptions du projet fait référence à un mécanisme permettant de capturer, de traiter et de renvoyer diverses situations anormales au cours du processus de développement .
• Solution:
  • BusinessException : causée par des opérations utilisateur irrégulières
  • SystemException : exception d'opération de code attendue
  • Autres exceptions (Exception) : exceptions inattendues
• Pas
  • Étape 1 : Personnaliser les exceptions au niveau du système du projet
    • Hériter de la classe d'exception d'exécution RuntimeException
    • Implémentez la méthode de construction en fonction du métier, par exemple : SystemException(Integer code, String message), SystemException(Integer code, String message, Throwable cause)
  • Étape 2 : Personnaliser les exceptions au niveau métier du projet
    • Hériter de la classe d'exception d'exécution RuntimeException
    • Implémentez la méthode de construction en fonction du métier, par exemple : BusinessException(Integer code, String message), BusinessException(Integer code, String message, Throwable cause)
  • Étape 3 : Personnaliser le codage des exceptions (ajout continu)
  • Étape 4 : Déclenchez une exception personnalisée
  • Étape 5 : Intercepter et gérer les exceptions (points clés)
    • Définir le plan de gestion des exceptions du projet et utiliser @ExceptionHandlercette annotation pour gérer les exceptions

​ La gestion des exceptions du projet fait référence à un mécanisme permettant de capturer, gérer et fournir des commentaires sur diverses situations anormales au cours du processus de développement. Le but de la gestion des exceptions est d’assurer la stabilité et la fiabilité du système afin d’offrir une bonne expérience utilisateur.

Plan de gestion des exceptions du projet

• BusinessException
  • Envoyer des messages correspondants aux utilisateurs pour leur rappeler les opérations standardisées
• Exception système
  • Envoyer des messages fixes aux utilisateurs pour les apaiser
  • Envoyer des messages spécifiques au personnel d'exploitation et de maintenance pour rappeler la maintenance
  • enregistrement
• Autres exceptions (Exception)
  • Envoyer des messages fixes aux utilisateurs pour les apaiser
  • Envoyer des messages spécifiques aux programmeurs pour rappeler la maintenance (dans le cadre prévu)
  • enregistrement

Étape 1 : Personnaliser les exceptions au niveau du système du projet

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException{
    
    
    private Integer code;

    public Integer getCode() {
    
    
        return code;
    }

    public void setCode(Integer code) {
    
    
        this.code = code;
    }

    public SystemException(Integer code, String message) {
    
    
        super(message);
        this.code = code;
    }

    // Throwable为异常报错的对象
    public SystemException(Integer code, String message, Throwable cause) {
    
    
        super(message, cause);
        this.code = code;
    }
}

illustrer:

• Les exceptions au niveau du système peuvent être provoquées par des erreurs provoquées par des erreurs des programmeurs.
• Pour les variables membres code, il vous suffit d’implémenter la méthode de code Set. Lors d'une utilisation ultérieure, il vous suffira d'obtenir le Code de cet objet.

Étape 2 : Personnaliser les exceptions au niveau métier du projet

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    
    
    private Integer code;

    public Integer getCode() {
    
    
        return code;
    }

    public void setCode(Integer code) {
    
    
        this.code = code;
    }

    public BusinessException(Integer code, String message) {
    
    
        super(message);
        this.code = code;
    }

    // Throwable为异常报错的对象
    public BusinessException(Integer code, String message, Throwable cause) {
    
    
        super(message, cause);
        this.code = code;
    }
}

illustrer:

• Les exceptions au niveau du système peuvent être provoquées par des problèmes de système d'exploitation ou un échec de connexion à la base de données.

Étape 3 : Personnaliser le codage des exceptions (ajout continu)

public static final Integer SYSTEM_ERR = 50001;
public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
public static final Integer SYSTEM_UNKNOW_ERR = 59999;

public static final Integer BUSINESS_ERR = 60002;

Étape 4 : Déclencher une exception personnalisée

illustrer:

​ Grâce à la simulation, seule la classification et la levée d'exceptions

Étape 5 : Intercepter et gérer les exceptions

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    
    
    // 用于处理用户操作不当而导致的异常
    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
    
    
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
    
    
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
    
    
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
    }
}

Étape 6 : Comparaison des effets du gestionnaire d’exceptions

illustrer:

On peut voir que le système logiciel peut émettre des invites précises lorsque l'accès aux ressources est normal ou anormal.

7. Intercepteur

Résumé des notes :

1. Aperçu:

• Définition : L'intercepteur est une technologie couramment utilisée dans le développement Web, qui permet d' intercepter et de traiter les requêtes pendant le traitement des requêtes.

• Fonction : Exécuter le code prédéfini avant et après l'appel de la méthode spécifiée et empêcher l'exécution de la méthode d'origine

• La différence entre les intercepteurs et les filtres :

  • Différentes affaires
  • Le contenu bloqué est différent
  • ……

  

2. Cas d'utilisation de base :

• Étape 1 : déclarer le bean intercepteur et implémenter l'interface HandlerInterceptor (remarque : analyser et charger les beans)
• Étape 2 : Définir la classe de configuration
  • Méthode 1 : définissez la classe de configuration, héritez de WebMvcConfigurationSupport et implémentez la méthode addInterceptor (remarque : analysez pour charger la configuration)
  • Méthode 2 : Implémenter l' interface standard webMvcConfigurer pour simplifier le développement (note : plus intrusive)
• Remplir:
  • Configurer le mappage de ressources statiques : addResourceHandlers, addResourceLocations
  • Configurer les intercepteurs pour les ressources dynamiques : addInterceptors, addPathPatterns

3. Paramètres de l'intercepteur :

• Pré-traitement : certains traitements sont effectués avant l'interception de la demande
• Post-traitement : certains traitements effectués après l'interception de la demande

4. Flux de travail de l'intercepteur :

• Intercepteur : traitement d'un seul intercepteur

  

• Chaîne d'interception : traitement de plusieurs intercepteurs

  

7.1 Aperçu

7.1.1 Définition

​L'intercepteur est une technologie couramment utilisée dans le développement Web, qui permet d'intercepter et de traiter les requêtes pendant le traitement des requêtes. L'intercepteur peut exécuter une logique personnalisée avant ou après que la requête entre dans le contrôleur pour traitement, telle que la journalisation, la vérification des autorisations, le prétraitement des paramètres de requête, etc.

7.1.2 Fonction

Exécute le code prédéfini avant et après l'appel de méthode spécifié et empêche l'exécution de la méthode d'origine. Les fonctions sont les suivantes :

1. Vérification des autorisations : les intercepteurs peuvent être utilisés pour vérifier les autorisations des utilisateurs, par exemple vérifier si l'utilisateur est connecté, s'il a l'autorisation d'effectuer une opération, etc. Si la vérification des autorisations échoue, vous pouvez interrompre la demande ou effectuer le traitement correspondant.
2. Journalisation : l'intercepteur peut être utilisé pour enregistrer les informations de journal de la demande, y compris l'URL demandée, les paramètres de la demande, l'heure de la demande, etc., afin de faciliter l'analyse statistique ultérieure, le dépannage des erreurs et d'autres travaux.
3. Prétraitement des paramètres de demande : l'intercepteur peut prétraiter les paramètres de la demande avant que la demande n'entre dans le contrôleur, par exemple en vérifiant, en formatant et en cryptant les paramètres pour garantir l'exactitude et la sécurité des paramètres.
4. Gestion des exceptions : les intercepteurs peuvent être utilisés pour capturer les exceptions émises dans le contrôleur et effectuer une gestion unifiée des exceptions, comme le renvoi d'une page de message d'erreur unifiée, l'enregistrement de journaux d'exceptions, etc.
5. Traitement de la réponse à la demande : l'intercepteur peut traiter la réponse une fois le traitement de la demande terminé, par exemple en définissant les informations d'en-tête de réponse, en modifiant le contenu de la réponse, etc.
6. Contrôle du cache : les intercepteurs peuvent être utilisés pour contrôler la stratégie de mise en cache de la réponse, comme la définition de la durée du cache de la réponse, la vérification de la validité du cache, etc.

Normalement, dans le développement réel, les intercepteurs sont généralement utilisés pour les autorisations de jetons.

7.1.3 La différence entre les intercepteurs et les filtres

Interceptor et Filter sont tous deux des composants utilisés pour traiter les requêtes dans le développement Web, mais ils présentent les différences suivantes :

1. Le champ d'application est différent : l'intercepteur est destiné au framework Spring MVC . Il s'agit d'une interception basée sur une méthode et ne peut intercepter que la méthode de traitement des demandes dans le contrôleur. Le filtre est défini par la spécification Servlet. Il est basé sur l'interception de modèles d'URL et peut intercepter toutes les requêtes, y compris les ressources statiques et les requêtes Servlet.

2. L'ordre d'exécution est différent : l'intercepteur est exécuté avant ou après le processeur (Contrôleur), et peut pré-traiter ou post-traiter la requête. Les filtres sont exécutés avant ou après que la requête entre dans le conteneur de servlet et peuvent filtrer, modifier ou empaqueter la requête.

3. Différentes fonctions : Les intercepteurs sont principalement utilisés pour traiter la logique métier des requêtes , telles que la vérification des autorisations, la journalisation, la gestion des exceptions, etc. Les filtres sont principalement utilisés pour filtrer et modifier les requêtes , telles que la conversion du codage de caractères, le conditionnement des requêtes, le traitement des paramètres de requête, etc.

4. Les méthodes de configuration sont différentes : la configuration de l'intercepteur est effectuée dans le fichier de configuration Spring MVC et les règles de correspondance d'ordre et de chemin des intercepteurs doivent être configurées manuellement. La configuration du filtre est effectuée dans le fichier web.xml , et le chemin d'interception et l'ordre du filtre sont spécifiés en configurant le modèle d'URL.

5. Propriété différente : Le filtre appartient à la technologie Servlet , Interceptor appartient à la technologie SpringMVC

6. Le contenu de l'interception est différent : Filter améliore tous les accès et Interceptor n'améliore que l'accès springMVC.

​ De manière générale, les intercepteurs sont plus flexibles et raffinés, adaptés au traitement de la logique métier ; les filtres sont plus généraux, adaptés au filtrage et à la modification des requêtes. Lors de son utilisation, vous pouvez sélectionner des intercepteurs ou des filtres en fonction de besoins spécifiques pour mettre en œuvre les fonctions correspondantes.

7.2 Implémentation de base d'un cas d'utilisation-intercepteur

Étape 1 : Définir l'intercepteur

• Déclarez le Bean de l'intercepteur et implémentez l'interface HandlerInterceptor

Avis:

Scannez et chargez les beans, n'oubliez pas d'ajouter @Componentdes annotations

@Component //拦截器
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    
    
    @Override
    //原始方法调用前执行的内容
    //返回值类型可以拦截控制的执行，true放行，false终止
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        System.out.println("preHandle..."+contentType);
        return true;
    }

    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        System.out.println("afterCompletion...");
    }
}

illustrer:

De manière générale, les intercepteurs sont utilisés pour le traitement de la couche de présentation, ils sont donc placés sous le package Controller.

Étape 2 : Définir la classe de configuration

Méthode 1 : définissez la classe de configuration, héritez-en WebMvcConfigurationSupportet implémentez la méthode addInterceptor (remarque : analysez et chargez la configuration)

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    
    
    @Autowired
    private ProjectInterceptor projectInterceptor;

    /**
     * 配置静态资源映射
     */
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
    }

    /**
     * 配置动态资源的拦截器
     */
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
    
    
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

illustrer:

• Grâce à la configuration ci-dessus, l'accès aux ressources statiques et la configuration de l'intercepteur pour le chemin spécifié sont obtenus.
• Ajoutez un intercepteur et définissez le chemin d'accès intercepté. Plusieurs chemins peuvent être définis via des paramètres variables.

Méthode 2 : implémenter des interfaces standards webMvcConfigurerpour simplifier le développement (remarque : plus intrusive)

@Configuration
@ComponentScan({
    
    "com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    
    
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    
        //配置多拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

illustrer:

En implémentant l'interface WebMvcConfigurer, vous pouvez également obtenir l'effet d'hériter de la classe de configuration WebMvcConfigurationSupport pour implémenter l'interception des ressources.

Avis:

​ Implémenter l'intercepteur en implémentant l'interface WebMvcConfigurer est très intrusif.

7.3 Paramètres de l'intercepteur

7.3.1 Prétraitement

Le prétraitement est un traitement effectué avant l'interception de la demande

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    
    
    @Override
    //原始方法调用前执行的内容
    //返回值类型可以拦截控制的执行，true放行，false终止
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        String contentType = request.getHeader("Content-Type");
        HandlerMethod hm = (HandlerMethod)handler;
        System.out.println("preHandle..."+contentType);
        return true;
    }
}

illustrer:

​ Les informations contenues dans l'en-tête de la demande peuvent être obtenues à partir de la demande et peuvent être extraites pour une utilisation facile.

Remplir:

• paramètre:
  • requête : objet de requête
  • réponse : objet de réponse
  • gestionnaire : l'objet gestionnaire appelé est essentiellement un objet méthode, qui reconditionne l'objet méthode dans la technologie de réflexion.
• valeur de retour
  • La valeur de retour est fausse et le processeur intercepté ne sera pas exécuté.

7.3.2 Post-traitement

public void postHandle(HttpServletRequest request,
                       HttpservletResponse response,
                       object handler,
                       ModelAndview modelAndView) throws Exception {
    
    
    System.out.println( "postHandle..." );
}

Remplir:

modelAndView : si l'exécution du processeur est terminée et que le résultat est renvoyé, les données correspondantes et les informations de page peuvent être lues et ajustées.

7.4 Flux de travail de l'intercepteur (points clés)

7.4.1Processus de base

illustrer:

• Lorsqu'il n'y a pas d'intercepteur, la requête traverse la couche de présentation sans aucune interception.
• Lorsqu'il y a un intercepteur, la requête sera interprétée comme interceptant et traitant le contenu exécuté avant l'appel de la méthode d'origine, le contenu exécuté après l'appel de la méthode d'origine et le contenu exécuté après l'appel de la méthode d'origine.
• Si la réponse est True après le traitement de l'interception, cela signifie que la requête est libérée ; si la réponse est False, cela signifie que le contenu de la requête est intercepté.

7.4.2 Chaîne d'interception

illustrer:

• Si le troisième intercepteur renvoie False, seuls les post-processeurs des première et deuxième interceptions seront exécutés.
• Si le deuxième intercepteur renvoie False, seul le post-processeur de la première interception sera exécuté.
• Si le premier intercepteur renvoie False, aucun des post-processeurs interceptés ne s'exécutera.

8. Processus d'exécution

Résumé des notes :

​ Cette section est plus compliquée, on peut se référer à des notes externes pour étude : springmvc notes (Silicon Valley)_blog qui ne sait pas taper 314-CSDN blog

8.1 Composants communs de SpringMVC

• DispatcherServlet : DispatcherServlet est le contrôleur frontal du framework Spring MVC . Il est responsable de la réception de toutes les requêtes HTTP et de la distribution des requêtes au processeur correspondant pour traitement. DispatcherServlet est le composant principal du framework Spring MVC, qui répartit tous les aspects du processus de traitement des demandes.
• HandlerMapping : HandlerMapping est une implémentation du mappeur de processeur. Il mappe sur un processeur spécifique (Controller) en fonction du chemin URL demandé et détermine le processeur correspondant à la requête . HandlerMapping peut être configuré selon différentes stratégies de mappage, telles que basées sur des chemins d'URL, basées sur des annotations, etc.
• Handler : Handler signifie processeur , également connu sous le nom de contrôleur . Il s'agit de l'exécuteur spécifique de la logique métier, responsable du traitement des requêtes et du renvoi des résultats du traitement. Dans Spring MVC, Handler peut être une classe POJO ordinaire qui gère les requêtes via des méthodes.
• HandlerAdapter : HandlerAdapter est un adaptateur de processeur utilisé pour exécuter les méthodes du processeur et adapter les paramètres de la requête afin qu'il puisse gérer correctement la requête. HandlerAdapter sélectionne l'adaptateur approprié pour exécuter la méthode de processeur en fonction du type de processeur et du type de paramètre de la méthode de traitement.
• ViewResolver : ViewResolver est un résolveur de vue utilisé pour restituer les résultats du traitement dans la vue finale. Il résout des objets de vue spécifiques en fonction du nom de vue logique renvoyé par le processeur, tel que ThymeleafView, InternalResourceView, RedirectView, etc. ViewResolver est chargé de transmettre les données du modèle à la vue, qui est finalement présentée à l'utilisateur.
• View : View signifie view , qui est responsable de l'affichage des résultats finaux du traitement à l'utilisateur. Les vues peuvent être des pages HTML, des données JSON, des documents XML, etc. Dans Spring MVC, la vue est généralement rendue par le moteur de modèle et les données du modèle sont renseignées dans le modèle pour générer la vue finale.

​ 这些组件共同协作，完成请求的处理和响应的生成。DispatcherServlet作为前端控制器接收请求，HandlerMapping确定请求对应的处理器，HandlerAdapter执行处理器方法，ViewResolver解析视图，View负责最终的呈现。这个处理流程是Spring MVC框架中的核心机制，通过配置和组合这些组件，可以灵活地实现不同的请求处理和视图渲染逻辑。

8.2DispatcherServlet初始化过程

​ DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度

说明：

1.GenericServlet类会实现Service接口并重写Init方法

说明：

• 因为Servler为接口，因此GenericServlet类会实现Service接口并重写Init方法
• 因为HttpServlet类跟GenericSerlver为继承的关系，因此GenericServlet类中的两个init方法，会保留在HttpServlet类中

2.HttpServlet类没有重写GenericServlet类中的init方法

说明：

​ HttpServlet类虽然继承了GenericServlet类，但并没有重写GenericServlet类中的init方法

3.HttpServletBean类重写了GenericServlet类中的init方法，并调用了initServletBean方法

说明：

​ HttpServletBean类重写了GenericServlet类中的init方法

说明：

​ HttpServletBean类在init方法中，调用了一个重要的方法initServletBean方法，来初始化ServletBean

4.FrameworkServler类重写了HttpServletBean类中的initServletBean方法

说明：

La classe FrameworkServler appelle la méthode d'initialisation du conteneur SpringMVC IOC this.initWebApplicationContext(); dans la méthode initServletBean ;

5. Dans la classe FrameworkServler, la méthode initWebApplicationContext sera appelée

illustrer:

​ Parce que lorsque cette méthode est exécutée pour la première fois, le WebApplicationContext créé est vide, donc this.createWebApplicationContext(rootContext) ; cette méthode sera appelée pour créer le WebApplicationContext.

5.1. Dans la classe FrameworkServler, appelez la méthode createWebApplicationContext pour créer un WebApplicationContext

illustrer:

​ Appelez la méthode wac.setParent(parent); dans la classe FrameworkServler pour définir le conteneur Spring IOC comme conteneur parent de Spring MVC.

5.2 Dans la classe FrameworkServler, appelez les méthodes this.onRefresh(wac) et this.getServletContext().setAttribute(attrName, wac);

illustrer:

• L’appel de la méthode this.onRefresh(wac) exécutera la méthode OnRefresh dans la sous-classe DispatcherServlet pour initialiser la stratégie.

  

• Appelez la méthode this.getServletContext().setAttribute(attrName, wac); pour partager l'objet webApplicationContext dans le domaine d'application

6. Dans la classe DispatcherServler, la méthode onRefresh de la classe FrameworkServler sera remplacée.

illustrer:

​ Les différents conteneurs initialisés à l'intérieur sont effectivement chargés lorsque DispatcherServlet est initialisé.

8.3Processus du serviceDispatcherServlet

1. La classe GenericServlet implémentera l'interface Service et héritera de cette méthode Service.

illustrer:

Dans la classe GenericServlet, la méthode de service dans l'interface Service n'est pas remplacée, mais directement héritée.

2. Dans la classe HttpServlet, la méthode Service de la classe GenericServlet est réécrite.

illustrer:

​ Dans la méthode Service de la classe HttpServlet, convertissez les objets ServletRequest et ServletResponse en sous-classes HttpServletRequest et HttpServletRequest, et en objets HttpServletResponse.

3. Dans la méthode de service de la classe HttpServlet, distribuez la requête

illustrer:

​ Différentes méthodes s'exécutent correspondant à différentes fonctions

4. Dans HttpServletBean, la méthode de service de la classe HttpServlet et la méthode commençant par do ne sont pas réécrites.

illustrer:

Dans la classe HttpServlet, la méthode de service de la classe HttpServlet et la méthode commençant par do ne sont pas réécrites.

5. Dans la classe FramesServlet, la méthode this.processRequest de cette classe sera quand même exécutée

illustrer:

La méthode super.service(request,response) exécutera la méthode de service dans HttpServlet, pas la classe HttpServiceBean, car la classe HttpServiceBean n'implémente aucune méthode de service.

illustrer:

Une méthode importante doService est implémentée dans la méthode processRequest de la classe FramesServlet

illustrer:

​ Dans la méthode doService de la classe FramesServlet, on constate que doService est une méthode de classe abstraite. Par conséquent, nous devons voir comment implémenter cette méthode dans une sous-classe de la classe FramesServlet.

6. Dans la classe DispatcherServlet, la méthode this.doDispatch(request, réponse); sera éventuellement exécutée pour traiter le service.

8.4Le processus du composant appelant DisPatcheServlet pour traiter la demande

1. Dans la classe DispatcherServlet, attribuez des valeurs à la chaîne d'exécution du traitement via mappedHandler = this.getHandler(processedRequest);

illustrer:

• À la ligne 472 HandlerExecutionChain mappedHandler = null;, mappedHandler est appelé la chaîne d'exécution, comprenant les méthodes de contrôleur (processeurs), les collections d'intercepteurs et les index d'intercepteur.

  

illustrer:

• HandlerAdapter est utilisé pour appeler les méthodes du contrôleur

  

illustrer:

La méthode ha.handle est utilisée dans l'adaptateur pour traiter les types de paramètres, les en-têtes de requête et les cookies de requête de la méthode de requête.

illustrer:

On peut constater que dans la méthode doDispatch de la classe DispatcherServler, il n'existe aucune méthode pour restituer la vue. En fait, la méthode this.processDispatchResult est une méthode utilisée pour traiter les étapes suivantes. Dans cette méthode, la vue sera ensuite traitée.

8.5 Processus d'exécution (compréhension)

Être ajouté……

Station-service de connaissances (points clés)

1.La différence entre @RequestBody et @RequestParam

• la différence
  • @RequestParam est utilisé pour recevoir les paramètres de transmission de l'adresse URL, les paramètres de transmission du formulaire [application/x-www-form-urlencoded]
  • @RequestBody est utilisé pour recevoir des données json [application/json]
• application
  • Lors du développement ultérieur, les données au format json sont principalement envoyées et @RequestBody est largement utilisé.
  • Si vous envoyez des données au format non-json, utilisez @RequestParam pour recevoir les paramètres de requête

2. Dans Idea, ouvrez le diagramme d'héritage des relations de classe

Touche de raccourci : Ctrl+H

3.@RequestBody @RequestParam @PathVariable différence

• la différence
  • @RequestParam est utilisé pour recevoir des paramètres d'adresse URL ou des paramètres de formulaire.
  • @RequestBody est utilisé pour recevoir des données json
  • @PathVariable est utilisé pour recevoir les paramètres de chemin, utilisez {nom du paramètre} pour décrire les paramètres de chemin
• application
  • Dans le développement ultérieur, lors de l'envoi de plus d'un paramètre de requête, le format json est le principal et @RequestBody est largement utilisé.
  • Si vous envoyez des données au format non-json, utilisez @RequestParam pour recevoir les paramètres de requête
  • Utilisez RESTful pour le développement. Lorsque le nombre de paramètres est petit, par exemple 1, vous pouvez utiliser @PathVariable pour recevoir la variable de chemin de requête, qui est généralement utilisée pour transmettre la valeur de l'identifiant.

4.@RestControllerAdvice 和 @ControllerAdvice 区别

@RestControllerAdvice 和 @ControllerAdvice 是Spring MVC中用于全局异常处理和全局数据绑定的注解，它们的区别如下：

1. @RestControllerAdvice 是 @ControllerAdvice 和 @ResponseBody 的组合注解，表示一个控制器增强器，用于全局异常处理和全局数据绑定，并将结果以JSON格式返回给客户端。
2. @ControllerAdvice 是一个控制器增强器，用于全局异常处理和全局数据绑定，它可以应用于所有使用 @Controller 或 @RestController 注解的控制器类。
3. 使用 @RestControllerAdvice 注解的类，可以在方法上使用 @ExceptionHandler、@InitBinder 和 @ModelAttribute 注解，实现全局的异常处理、数据绑定和预处理。
4. 使用 @ControllerAdvice 注解的类，可以在方法上使用 @ExceptionHandler、@InitBinder 和 @ModelAttribute 注解，实现全局的异常处理、数据绑定和预处理。但是返回的结果需要通过 @ResponseBody 注解或其他方式转换为JSON格式。

综上所述，主要区别在于返回结果的格式。@RestControllerAdvice 注解的类返回的结果会直接以JSON格式返回给客户端，而 @ControllerAdvice 注解的类需要通过 @ResponseBody 注解或其他方式将结果转换为JSON格式后返回给客户端。

5.SpringMVC支持ant风格的路径

？：表示任意的单个字符

*：表示任意的0个或多个字符

**：表示任意的一层或多层目录

注意：在使用时，只能使用//xxx的方式

6.Model、Map、ModelMap、ModelAndView间的关系

7.AbstractAnnotationConfigDispatcherServletInitializer et AbstractDispatcherServletInitializer

AbstractAnnotationConfigDispatcherServletInitializeret AbstractDispatcherServletInitializersont des classes abstraites utilisées pour configurer et initialiser DispatcherServlet dans Spring MVC.

1. AbstractAnnotationConfigDispatcherServletInitializer：
   • AbstractAnnotationConfigDispatcherServletInitializerest une classe abstraite qui hérite de AbstractDispatcherServletInitializer.
   • Cette classe est utilisée pour configurer et initialiser DispatcherServlet en fonction de la configuration Java.
   • En héritant de cette classe et en implémentant ses méthodes abstraites, vous pouvez configurer les classes liées à RootConfig et ServletConfig, ainsi que les chemins de mappage des servlets, etc.
   • Il utilise AnnotationConfigWebApplicationContextpour charger la classe de configuration et l'associer à DispatcherServlet.
2. AbstractDispatcherServletInitializer：
   • AbstractDispatcherServletInitializerC'est une classe abstraite, qui est WebApplicationInitializerla classe d'implémentation de l'interface.
   • Cette classe est utilisée pour configurer et initialiser DispatcherServlet sur la base d'une configuration XML traditionnelle.
   • Il peut être utilisé pour créer et enregistrer DispatcherServlet, configurer le chemin de mappage du servlet, etc.
   • En héritant de cette classe et en implémentant les méthodes abstraites, vous pouvez configurer les chemins d'accès aux fichiers de configuration XML pertinents de RootConfig et ServletConfig.

Résumé : AbstractAnnotationConfigDispatcherServletInitializerLa classe abstraite de DispatcherServlet est configurée et initialisée sur la base d'une configuration Java, AbstractDispatcherServletInitializermais classe abstraite de DispatcherServlet est configurée et initialisée sur la base d'une configuration XML traditionnelle. Ils proposent différentes manières de configurer et d'initialiser DispatcherServlet, permettant aux développeurs de choisir la méthode appropriée en fonction de leurs préférences et des besoins du projet.

8.Annotation @RequestHeader (souligné)

@RequestHeaderLes annotations sont utilisées pour lier les valeurs des en-têtes de requête aux paramètres de méthode. Il peut être utilisé pour obtenir la valeur d'un en-tête de requête spécifique ou pour obtenir la valeur de tous les en-têtes de requête. Cette annotation peut être appliquée aux paramètres de méthode, aux méthodes et aux méthodes de gestionnaire au niveau de la classe.

• Obtenir la valeur d'un en-tête de requête spécifique

@GetMapping("/example")
public void exampleMethod(@RequestHeader("User-Agent") String userAgent) {
    
    
    // 处理方法逻辑
}

• Obtenez les valeurs de tous les en-têtes de requête

@GetMapping("/init2")
public void init2(@RequestHeader Map<String, String> headerMap) {
    
    
    
    // 使用Map接收所有的请求头
    System.out.println(headerMap);
    // js中使用header名为addressList,使用map接收后需要使用addresslist
    System.out.println(headerMap.get("addresslist"));  
    
}

9.Annotation @CookieValue (souligné)

@CookieValueLes annotations sont utilisées pour lier les valeurs des cookies aux paramètres de la méthode. Il peut être utilisé pour obtenir la valeur d'un cookie spécifique ou pour obtenir la valeur de tous les cookies. Cette annotation peut être appliquée aux paramètres de méthode, aux méthodes et aux méthodes de gestionnaire au niveau de la classe.

• Obtenir la valeur d'un en-tête de requête spécifique

@GetMapping("/example")
public void exampleMethod(@CookieValue("sessionId") String sessionId) {
    
    
    // 处理方法逻辑
}

• Obtenez les valeurs de tous les en-têtes de requête

@GetMapping("/example")
public void exampleMethod(@CookieValue Map<String, String> cookies) {
    
    
    // 处理方法逻辑
    for (Map.Entry<String, String> entry : cookies.entrySet()) {
    
    
        String cookieName = entry.getKey();
        String cookieValue = entry.getValue();
        // 处理每个Cookie的逻辑
    }
}

10.Le conteneur HttpServlet répond au processus de demande du client Web

1) Le client Web émet une requête Http au conteneur Servlet ;

2) Le conteneur Servlet analyse la requête HTTP du client Web ;

3) Le conteneur Servlet crée un objet HttpRequest et encapsule les informations de la requête Http dans cet objet ;

4) Le conteneur Servlet crée un objet HttpResponse ;

5) Le conteneur Servlet appelle la méthode de service de HttpServlet. Dans cette méthode, il jugera s'il faut exécuter doGet ou doPost selon la méthode de la requête, et transmettra les objets HttpRequest et HttpResponse comme paramètres de la méthode de service à l'objet HttpServlet. ;

6) HttpServlet appelle les méthodes pertinentes de HttpRequest pour obtenir les informations de la requête HTTP ;

7) HttpServlet appelle les méthodes pertinentes de HttpResponse pour générer des données de réponse ;

8) Le conteneur Servlet transmet le résultat de la réponse de HttpServlet au client Web.