Apprentissage du framework Java (1) Fondation JavaWeb : Maven, Spring, Tomcat, Mybatis, Springboot

Maven

Maven est un outil de gestion de projet qui comprend un modèle objet de projet (Project Object Model, fichier pom), un cycle de vie de projet (commande) et un système de gestion des dépendances (coordonnées).

Les avantages de l'utilisation de Maven :
1. Il est pratique de créer des modules pour le projet, de simplifier la structure du projet, de faciliter le développement de la division du travail et d'améliorer l'efficacité du développement.
2. Maven peut gérer les dépendances des différents systèmes de manière unifiée et peut transférer et hériter des dépendances, ce qui est pratique pour les mises à niveau de projets.
3. Maven dispose également de nombreux plug-ins, pratiques pour l'extension des fonctions, tels que maven-shade, qui est utilisé pour regrouper plusieurs packages jar dans un seul package jar ; maven-compiler-plugin, qui est utilisé pour compiler le code source. du projet, etc.

Dépôt Maven

L'entrepôt Maven est utilisé pour stocker des ressources et gérer divers packages jar.

Les entrepôts sont divisés en trois types :

1. Entrepôt central : le seul au monde entretenu par l'équipe Maven
2. Entrepôt local : un répertoire sur votre propre ordinateur
3. Entrepôt distant : un entrepôt privé généralement construit par l'équipe de l'entreprise

Coordonnées Maven

• groupId : ID d'organisation, qui définit le nom de l'organisation à laquelle appartient le projet Maven actuel (généralement nom de domaine inversé, par exemple : com.qjk)
• craftId : ID du projet, qui définit le nom du projet Maven actuel (généralement le nom du module, tel que order-service, marchandises-service)
• version : définit le numéro de version actuel du projet
• packaging : Définissez la façon dont le projet Maven est empaqueté. S'il n'y a pas d'empaquetage, la valeur par défaut est le package jar.
• classifier : cet élément est utilisé pour aider à définir certaines pièces jointes à la sortie de la construction. Les composants subsidiaires correspondent aux composants principaux.

Pourquoi Maven gère-t-il les dépendances, mais il existe toujours des conflits de dépendances ? Quel est le moyen de gérer les conflits de dépendances ?

Raisons des conflits de dépendances :

1. Les dépendances transitives entraînent des conflits entre les différentes versions des packages jar. Maven adopte le principe de proximité pour exclure les packages jar avec de longs chemins de dépendance, ce qui entraîne de ClassNotFoundtelles erreurs.
2. Différents packages jar ont le même chemin de classe.

Solutions aux conflits de packages jar :

• idea peut suivre le plugin Maven Helper pour aider à analyser les packages jar en conflit.
• Utilisez Ctrl + shift + alt + n pour rechercher le package jar où se trouve le chemin de classe et excluez le package jar correspondant du pom.

Parler en détail de la portée des dépendances de portée

• compile : la portée par défaut, qui est valide pendant l'exécution et doit être incluse dans le package
• test : valable uniquement dans le programme de test et ne sera pas inclus dans le package
• fourni : il est valide lors de la compilation, n'a pas besoin d'être fourni lors de l'exécution et ne sera pas inclus dans le package.
• runtime : non nécessaire lors de la compilation, valide pendant l'exécution et doit être inclus dans le package

Le cycle de vie de Maven

Le cycle de vie de Maven consiste à résumer et à unifier le processus de construction de tous les projets Maven.
Dans l’idée, on finit par se concentrer sur les 5 étapes suivantes (dans l’ordre) :

• clean : supprime les fichiers générés par la build précédente
• compiler : compiler le code source du projet
• test : utilisez un framework de tests unitaires approprié pour les tests, tel que Junit
• package : empaquetez le fichier compilé dans un package jar ou war
• installer : installer le projet dans l'entrepôt local

Remarque : Dans le même ensemble de cycles de vie, lorsque la dernière étape est exécutée, l'étape précédente sera exécutée.

Cliquer sur une certaine étape du cycle de vie sous cycle de vie dans l'idée est en fait complété par le plug-in Maven correspondant.

Maven Avancé

Conception de sous-modules

La conception modulaire facilite la division du travail lors du développement, la gestion, l'expansion et la maintenance de projets ultérieurs, ainsi que l'intégration des fonctions de module existantes dans d'autres projets. Lors de l'intégration, il vous suffit d'introduire les dépendances Maven correspondantes.

hériter

Différents modules peuvent devoir introduire les mêmes dépendances, afin que nous puissions extraire les dépendances publiques des modules et construire un projet parent, et les autres sous-modules qui ont besoin de cette dépendance n'ont besoin que d'hériter des dépendances du projet parent.

L'héritage du projet Maven est similaire à l'héritage en Java, et l'héritage multiple n'est pas autorisé, c'est-à-dire qu'un projet de module ne peut hériter que d'un seul projet parent.

Conseils : Résumé des méthodes d'empaquetage :

Par conséquent, lorsque nous utilisons Maven pour implémenter la relation d'héritage du projet, nous devons utiliser la méthode pom pour empaqueter :
utilisez l'étiquette <packaging> pom </packaging>pour spécifier, s'il n'est pas spécifié, la valeur par défaut est le package jar.

Mise en œuvre de la relation successorale :

verrouillage des versions

Dans le projet parent, la version de la dépendance est gérée uniformément via la balise < dependencyManagement >, de sorte que le sous-projet n'a pas besoin de spécifier le numéro de version. Lorsque la version doit être modifiée, il suffit de la modifier uniformément dans le projet parent.

La balise < dependencies > est une dépendance directe. Si la balise est configurée dans le projet parent, le projet enfant en héritera directement.

< dependencyManagement > est une version unifiée de gestion des dépendances qui n'en dépend pas directement. Si le sous-projet a besoin de cette dépendance, il faut l'introduire dans le fichier pom, mais il n'est pas nécessaire de préciser le numéro de version, et la version Le numéro spécifié dans le projet parent sera utilisé.

Cependant, dans le projet parent, les numéros de version de chaque dépendance sont également dispersés dans les balises de version de chaque dépendance, afin de gérer de manière centralisée les balises de version. Vous pouvez utiliser les fonctions fournies par Maven 自定义属性和引用属性.

polymérisation

Le but de l'agrégation est d'organiser plusieurs modules en un tout, afin que les opérations du cycle de vie de Maven (telles que le package d'installation de test de compilation propre) puissent être exécutées en un seul clic.

Similitudes et différences entre l'héritage et l'agrégation dans Maven

serveur privé

Le serveur privé est la bibliothèque de dépendances Maven qui est gérée de manière uniforme au sein de l'entreprise.

Ce processus est similaire au référentiel distant Github. . .

Étape 1 : Définissez le nom d'utilisateur et le mot de passe pour l'accès au serveur privé : utilisez l'étiquette du serveur

Étape 2 : Spécifiez l'adresse de téléchargement (publication) de la configuration.

Étape 3 : Définissez l'adresse du groupe d'entrepôts dont dépend le serveur privé pour le téléchargement

Dans le même temps, il est configuré pour autoriser le téléchargement à partir de serveurs privés. (Par défaut, la version des instantanés ne peut pas être téléchargée à partir de serveurs privés.)

Matou

Tomcat est un serveur Web léger, également connu sous le nom de conteneur Web, conteneur de servlets, le serveur Web encapsule les opérations du protocole HTTP, simplifie le développement de programmes Web, est utilisé pour déployer des projets Web et fournit des services de navigation d'informations en ligne.

servlet

Découplage en couches

Architecture à trois niveaux

Basée sur le principe de responsabilité unique, une architecture à trois niveaux est adoptée pour compléter les fonctions back-end d'accès aux données métier, de traitement logique et de réponse.

• Contrôleur : la couche de contrôle, qui reçoit la requête envoyée par le front-end, traite la requête et répond aux données.
• Service : couche de logique métier, qui gère une logique métier spécifique.
• Dao : (objet d'accès aux données, couche d'objets d'accès aux données), responsable des opérations d'accès aux données, notamment l'ajout, la suppression, la vérification et la modification de la base de données.

Selon l'idée d'une architecture à trois niveaux, la requête frontale passe d'abord par la couche Contrôleur, reçoit la requête, puis effectue un traitement logique via la couche Service. Les objets traités logiquement par la couche Service doivent obtenir des objets de données. via la couche Dao.Une fois l'opération commerciale terminée, la couche contrôleur répond aux données vers le front-end.

IOC (Inversion de Contrôle) et DI (Injection de Dépendances)

Selon le code écrit dans l'architecture à trois niveaux, la couche de service intermédiaire est respectivement couplée à la couche contrôleur supérieure et à la couche Dao inférieure.

Afin de réaliser un découplage en couches, Spring propose une technologie d'inversion de contrôle (inversion de contrôle, IOC) et d'injection de dépendances (injection de dépendances, DI).

L'inversion du contrôle transfère les objets vers la gestion des conteneurs et l'injection de dépendances injecte les objets là où ils doivent être utilisés.

• Inversion de contrôle (IOC) : le contrôle de la création d'objets est transféré du programme vers l'extérieur (conteneur).
• Injection de dépendances (DI) : le conteneur fournit les ressources dont dépend l'application au moment de l'exécution.
• Les objets créés et gérés dans le conteneur sont appelésbean

Le processus spécifique de mise en œuvre :

1. Utilisez @Componentdes annotations pour transmettre les classes d'implémentation de la couche de service et de la couche dao au conteneur IOC pour la gestion.
2. Lorsque la couche contrôleur doit s'appuyer sur la classe d'implémentation de la couche service et lorsque la couche service doit s'appuyer sur la classe d'implémentation de la couche dao, utilisez des @Autowiredannotations.

Explication détaillée du CIO

IOC consiste à confier les objets à la gestion des conteneurs.Dans le développement réel, en plus des annotations utilisées ci-dessus, @Componenten fait, nous utilisons davantage d'annotations comme @Controller, @Service, @Repository, qui correspondent respectivement à la couche contrôleur, à la couche service et à la couche dao.

En regardant @Servicel'annotation, vous constaterez qu'elle est @Componentcomposée d'annotations et de méta-annotations, il s'agit donc en fait d'une annotation dérivée de Component.

• L'utilisation d'annotations déclarera un objet bean Java dans le conteneur. Lors de la déclaration d'un bean, vous pouvez spécifier le nom du bean via l'attribut value. S'il n'est pas spécifié, la valeur par défaut est la première lettre du nom de classe en minuscule.
• Les beans peuvent être déclarés à l'aide des quatre annotations ci-dessus, mais dans le développement Web intégré Springboot, le contrôleur déclaré par le bean ne peut être utilisé. De plus, puisque @Controllerl'annotation @RestControllerest une annotation composite intégrée @Controllerà et @Requestbody, elle peut également être utilisée pour déclarer le bean de l'objet de type contrôleur.

Analyse des composants du bean

• Les quatre annotations majeures du bean déclaré doivent être @ComponentScananalysées par les annotations d'analyse des composants si elles veulent prendre effet.
• @ComponentScanBien que l'annotation n'affiche pas la configuration, elle est en fait incluse dans l'annotation de déclaration de classe de démarrage @SpringBootApplication.La portée de l'analyse par défaut est le package dans lequel se trouve la classe de démarrage et ses sous-packages.

Si vous souhaitez analyser les composants du bean en dehors du package où se trouve la classe de démarrage, vous devez utiliser des annotations au niveau de la classe de démarrage @ComponentScanet le paramètre est le nom du package. Notez que l'utilisation d'annotations @ComponentScaninvalidera les annotations par défaut, vous devez donc re -spécifiez le package où se trouve la classe de démarrage.

Explication détaillée de DI

L' @Autowiredannotation d'injection de dépendance DI consiste à obtenir l'objet bean correspondant en fonction du type à partir du conteneur. S'il y a plusieurs beans du même type, une erreur sera signalée : résolvez-la

via les solutions suivantes ;

• @Primary : Lorsqu'il existe plusieurs annotations du même type, l'objet bean déclaré avec cette annotation est injecté en premier.
• @Qualifier : utilisez cette annotation avec l'annotation @autowired pour spécifier le nom du bean.
• @Resource : utilisez cette annotation seule pour spécifier le nom du bean.

@AutowiredDifférences avec @Resourceles annotations :

• @AutowiredC'est l'annotation fournie par le framework spring, @Resourcemais l'annotation fournie par JDK
• @AutowiredLa valeur par défaut est d'injecter par type, @Resourcemais d'injecter par nom par défaut

Ma chaussure

• MyBatis est un excellent framework de couche de persistance
• MyBatis évite presque tout le code JDBC (Java Database Connect) et le processus de définition manuelle des paramètres et d'obtention d'ensembles de résultats
• MyBatis peut utiliser du XML simple ou des annotations pour configurer et mapper des informations natives, et mapper des interfaces et des classes d'entités Java [Plain Old Java Objects, objets Java ordinaires] dans des enregistrements de la base de données.
• MyBatis était à l'origine un projet open source d'Apache, ibatis. En 2010, ce projet a été migré d'Apache vers le code Google et renommé MyBatis.
• Document officiel de Mybatis : http://www.mybatis.org/mybatis-3/zh/index.html
• GitHub : https://github.com/mybatis/mybatis-3

processus de configuration

@MapperL'annotation gérera la classe d'implémentation de l'interface dans le conteneur, donc lorsque nous voulons utiliser l'objet de classe d'implémentation de l'interface, il nous suffit de déclarer un objet de classe d'implémentation et d'utiliser l'annotation pour injecter automatiquement, et nous obtiendrons l'objet déclaré par @Autowiredl' Mapperannotation .

JDBC (Connectivité de la base de données Java)

Les opérations jdbc traditionnelles comportent de nombreux blocs de code répétitifs, tels que l'encapsulation lors de la récupération des données, l'établissement de la connexion à la base de données, etc., et le rôle de Mybatis est d'aider les programmeurs à stocker les données dans la base de données et à récupérer les données de la base de données en fonction du framework.

pool de connexions à la base de données

boîte à outils lombok

@DataSimplifiez l'écriture des classes d'entités grâce aux annotations .

Fonctionnement de base de Mybatis

Il existe deux manières de configurer les instructions SQL dans Mybatis :

• basé sur des annotations
• Fichier de mappage basé sur XML

supprimer

SQL précompilé

• Le SQL précompilé offre de meilleures performances. Par exemple, pour le même SQL, seuls les paramètres sont différents. L'utilisation du SQL précompilé peut mettre en cache le SQL, appliquer le cache pour remplacer les paramètres et l'exécuter directement. L'utilisation du cache peut ignorer la vérification de l'analyse syntaxique SQL, l'optimisation SQL et la compilation SQL, de sorte que les performances sont plus élevées.
• Empêchez l'injection SQL, plus sécurisée.L'injection SQL est une méthode de modification de l'instruction SQL prédéfinie en manipulant les données d'entrée pour exécuter le code afin d'attaquer le serveur.

Cas d'attaque par injection SQL :
entrez dans le login : le nom du compte est arbitraire, le mot de passe est 'or '1' = '1'

lors de la vérification en arrière-plan :

vous pouvez voir que ==ou '1' = '1'== est toujours établi, alors naturellement vous pouvez toujours vous connecter avec succès!

En plus d'utiliser #des espaces réservés pour les paramètres, vous pouvez également utiliser $des espaces réservés. Les différences sont les suivantes :

Ajouter

Retour de clé primaire :
utilisez @Optionsles annotations, useGeneratedKeys = true, attribuez la clé primaire à l'attribut id.

Réviser

Renseigner

Encapsulation des données :

lorsque le nom d'attribut de la classe d'entité est incohérent avec le nom du champ, la valeur du champ ne peut pas être automatiquement encapsulée dans la valeur d'attribut de la classe.

La solution est la suivante :

1. Solution 1 : Alias ​​​​le champ pour que l'alias soit cohérent avec l'attribut de la classe d'entité.
2. Solution 2 : mapper et encapsuler manuellement via l'annotation @Result
3. Solution 3 : dans le fichier de configuration Spring ( application.properties), activez le commutateur de mappage automatique de la dénomination de la bosse mybatismybatis.configuration.map-underscore-to-camel-case =true

Lorsque vous utilisez %des caractères génériques dans des requêtes floues, vous devez utiliser l'épissage de guillemets simples et #les caractères génériques utilisés ne peuvent pas exister entre guillemets. Afin de continuer à utiliser la #fonction de précompilation SQL fournie, utilisez concatla méthode d'épissage de caractères.

Fichier de mappage XML

Les fichiers de mappage XML peuvent également être utilisés pour configurer SQL.

Le fichier XML écrit selon la spécification peut être normalement localisé et l'instruction SQL qu'il contient peut être exécutée.

L'utilisation des annotations mybatis sert principalement à compléter certaines fonctions simples d'ajout, de suppression, de modification et de requête. Si vous devez implémenter des fonctions SQL complexes, il est recommandé d'utiliser XML pour configurer les instructions SQL.

SQL dynamique Mybatis

Les instructions SQL qui changent en fonction des entrées de l'utilisateur ou des modifications des conditions externes sont appelées SQL dynamique.

L'écriture de SQL dynamique repose principalement sur certaines instructions d'étiquette :

• < if > : utilisé pour juger si la condition est vraie, utilisez l'attribut test pour juger la condition, si la condition est vraie, épissage SQL.
• <where > : L'élément Where insérera la clause Where uniquement lorsque l'élément enfant a du contenu, et supprimera automatiquement le et ou ou au début de la clause.

• < set > : insère dynamiquement le mot-clé set au début de la ligne, et supprime la virgule supplémentaire. (utilisé dans l'instruction de mise à jour)
  
• < foreach >：
  • collection : la collection à parcourir
  • item : éléments traversés
  • séparateur: séparateur
  • open : fragment SQL épissé avant le début de la traversée
  • close : Fragment SQL épissé après traversée.
    Cette balise est principalement utilisée dans les scénarios qui nécessitent des opérations par lots, comme l'exemple suivant de suppression de fatigue :
    
• <sql> et <include> : pour un grand nombre d'utilisations répétées de fragments SQL, vous pouvez utiliser la balise <sql> pour extraire les balises répétées à haute fréquence et définir le nom de l'identifiant. Lorsqu'il doit être utilisé, utilisez le < include> tag et définissez refid sur id Name, remplacement de référence.

API de style reposant

Representation State Transfer, transition d'état de représentation, un style architectural logiciel.

Utilisez l'URL pour localiser la ressource et le verbe HTTP (méthode de requête) pour décrire l'opération :

• Requête : Obtenir
• Ajouté : Publier
• Modification : Mettre
• Supprimer : Supprimer

fichier de configuration des propriétés

configuration des paramètres

Définissez les valeurs d'attribut des informations de configuration dans le fichier application.properties et @Valueinjectez les valeurs d'attribut du fichier de configuration externe via des annotations dans le fichier Java.

fichier de configuration yml

L'utilisation de fichiers de configuration au format yml ou yaml est plus concise et la structure hiérarchique est plus claire.

Propriétés de configuration

Utiliser @Valueles propriétés de configuration injectées est fastidieux, existe-t-il une possibilité de simplifier cette étape ?

Grâce @ConfigurationPropertiesaux annotations, les valeurs des propriétés​​dans le fichier de configuration sont injectées dans l'objet.

Des dépendances peuvent être ajoutées à Maven :

Implémentation du cas - vérification de la connexion

Lorsque le serveur reçoit la requête, il vérifie s'il est en état de connexion. Si c'est le cas, il traite la requête normalement. Dans le cas contraire, il l'intercepte.

Le serveur adopte généralement une interception unifiée pour réaliser la fonction de vérification de connexion et le marque s'il est connecté.

technologie conversationnelle

biscuit

Cookie : technologie de suivi de session client, technologie prise en charge par le protocole http. Après une connexion réussie, le serveur répond avec set-cookie et envoie le cookie au navigateur. Le navigateur met en cache le cookie localement et les en-têtes de requête suivants contiennent le cookie. Vérifier la connexion statut.

Inconvénients des cookies :

• L'application mobile n'est pas disponible
• Non sécurisé, l'utilisateur peut désactiver les cookies
• Les cookies ne peuvent pas traverser les domaines
  • Le cross-domain est divisé en trois dimensions : protocole, IP, port

session

Session est une technologie de suivi de session côté serveur. La session est stockée côté serveur et sa couche inférieure est toujours basée sur des cookies.

Le principe du suivi de session :
La demande de connexion du navigateur donne JSESSION, c'est-à-dire l'identifiant de session, le serveur définit l'identifiant de session via set-cookie, et l'enregistre sur le serveur, puis vérifie l'identifiant de session dans le cookie porté par le navigateur lors de l'envoi de la demande. Sa cohérence avec celle enregistrée par le serveur peut déterminer s'il s'agit d'une session.

Inconvénients de la session :
La session étant stockée sur le serveur, elle ne peut pas être utilisée dans le cluster de serveurs.

technologie de jeton

Une fois que le navigateur s'est connecté avec succès, le serveur génère un jeton pour le client et le client enregistre le jeton, qui est transporté dans les requêtes suivantes. Si des informations doivent être partagées au cours de la même session, les informations sont stockées dans le jeton.

avantage:

• Le jeton peut être stocké dans un cookie ou localement côté client, il prend donc en charge les PC et les terminaux mobiles.
• Cela peut résoudre le problème d'authentification dans l'environnement de cluster.

Inconvénient : le jeton doit être implémenté par vous-même

Jeton JWT

JWT (Json Web Token), jeton de réseau json, définit un format autonome concis] pour transmettre en toute sécurité des informations au format de données json entre deux parties communicantes. En raison de l'existence de signatures numériques, ces messages sont fiables.

Un token JWT se compose principalement de trois parties, .reliées par deux points :

• en-tête (en-tête), type de jeton d'enregistrement, algorithme de signature
• charge utile (charge utile), transportant des informations personnalisées, informations par défaut.
• signature (signature), pour empêcher la falsification du jeton, pour garantir la sécurité, ajoutez l'en-tête et la charge utile à la clé secrète spécifiée et calculez-la via l'algorithme de signature spécifié.

JWT est à l'origine un json, comment est-il converti en chaîne ?

Grâce au codage base64, le codage dit base64 est une méthode de codage composée de 64 caractères (0-9, az, AZ, +, /). Toutes les données codées en base64 seront converties en une chaîne de 64 caractères.

L'encodage et le décodage en base64 des tokens jwt peuvent être effectués sur le site suivant :
https://jwt.io/

Générez JWT basé sur du code Java :
la partie charge utile est stockée dans une table de hachage et construite en mode constructeur.

Le JWT généré peut être analysé par la clé secrète dans le délai d'expiration :

si le jeton expire ou est falsifié, ce sera une erreur !

Filtre

Filtre : filtre qui intercepte les demandes de ressources pour réaliser certaines fonctions spéciales. Les filtres effectuent généralement certaines opérations courantes, telles que : la vérification de la connexion, le traitement Unicode, le traitement des caractères sensibles, etc.

Étapes pour créer une interception :

1. Définir un filtre : définissez la classe Filter pour implémenter l'interface Filter et réécrire toutes ses méthodes.
2. Configurer le filtre : ajoutez l'annotation @WebFilter à la classe Filter, configurez le chemin des ressources d'interception et ajoutez @ServletComponentScan à la classe de démarrage (où se trouve la fonction principale) pour activer la prise en charge des composants Servlet.

Ajoutez des attributs à l'annotation @WebFilter urlPatternspour configurer le chemin de la requête interceptée.

Explication détaillée du processus d'exécution du filtre

L'interface Filter nous oblige à réécrire trois méthodes :

• init : initialisation, exécutée une seule fois
• doFilter : Appelé après avoir intercepté la demande, il peut être appelé plusieurs fois et la demande de libération peut être exécutée ici chain.doFilter().
• destroy : La méthode de destruction n’est appelée qu’une seule fois.
  
  

chaîne de filtre

La priorité de l'ordre d'exécution de la chaîne de filtres est conforme à l'ordre naturel du nom de la classe de filtre (chaîne)

Processus de filtrage de vérification de connexion

intercepteur

Un intercepteur est un mécanisme similaire à un filtre, mais l'intercepteur est fourni dans le framework Spring.

Utiliser des intercepteurs en Java :

1. Définissez la classe d'intercepteur pour implémenter l'interface HandlerInterceptor et remplacez la méthode. Étant donné que l'intercepteur est fourni par le framework Spring, @Componentles annotations peuvent être utilisées directement pour transmettre la classe au conteneur pour la gestion.
2. Enregistrez l'intercepteur : utilisez l'annotation @Configuration pour déclarer une classe de configuration, implémentez l'interface dans cette classe de configuration WebMvcConfigurer, injectez la classe d'intercepteur ci-dessus à l'aide de l'annotation AutoWired, puis ajoutez le mode chemin d'interception à la classe d'intercepteur dans la méthode addInterceptors.
   
   Mode intercepteur :
   

La différence entre les filtres et les intercepteurs

• La spécification de l'interface est différente : le filtre implémente l'interface Filter et l'intercepteur implémente l'interface HandlerInterceptor.
• La portée de l'interception est différente : le filtre filtre interceptera toutes les ressources, et l'intercepteur n'interceptera que les ressources dans l'environnement Spring. S'il y a à la fois des filtres et des intercepteurs dans le projet, le filtre filtre sera exécuté en premier.

gestion des exceptions

Dans le framework Spring, si une exception se produit, elle aura un impact entre les couches. Il est recommandé d'utiliser un gestionnaire d'exceptions global pour gérer les exceptions de manière uniforme.

gestionnaire d'exceptions global

Utilisez l'annotation @RestControllerAdvice.

Gestion des transactions de printemps

Cas d'application : lors de la suppression d'un département, tous les employés du département doivent être supprimés en même temps.

Méthode d'implémentation : utilisation d'annotations.Les @Transactional
annotations sont placées sur les méthodes, classes et interfaces de la couche métier (Service).
Fonction : Transmettre la méthode actuelle à Spring pour la gestion des transactions. Avant que la méthode ne soit exécutée, démarrez la transaction. Après une exécution réussie, soumettez la transaction. Si une exception se produit, annulez la transaction.

Activer la configuration des journaux pour la gestion des transactions :

Affaires avancées

Dans le cas ci-dessus, nous utilisons directement l'annotation @Transactional sur la méthode delete pour démarrer une transaction.

Par défaut, l'exception est annulée uniquement lorsqu'une exception d'exécution se produit. La spécification des attributs dans @Transactional rollbackForpeut être utilisée pour contrôler le type d'exception qui se produit et annuler la transaction.

En plus des rollbackForattributs, l'annotation de transaction @Transactional peut également spécifier propagationdes attributs de comportement de propagation.

Le comportement de propagation de transaction par défaut consiste à ajouter la méthode à la transaction existante s'il existe une transaction et à créer une nouvelle transaction s'il n'y a pas de transaction.

Quel est le problème?
Tenez compte des exigences suivantes :

étant donné que le journal des opérations est requis quel que soit le succès ou l'échec de la transaction, nous devons alors mettre la méthode du journal des opérations dans la finale dans try-catch-finally pour y parvenir.

Cependant, dans le processus d'exécution réel, si l'exécution de la transaction échoue, provoquant une restauration, la méthode d'exécution du journal des opérations dans le bloc de code final sera également annulée !

La solution est :
l'annotation de transaction de la méthode d'insertion de l'opération dans le journal, et spécifier le mode de propagation comme propagation = Propgation.REQUEST_NEW.
De cette façon, la méthode d'exploitation du journal démarrera une nouvelle transaction et ne sera pas affectée par l'annulation de la transaction ayant échoué.

AOP (programmation orientée aspect)

L'AOP (Aspect Oriented Programming, programmation orientée aspect) est en fait une programmation pour une méthode spécifique, qui peut être une amélioration de la méthode originale ou une adaptation de la méthode originale.

La programmation orientée aspect AOP est réalisée via le mode proxy dynamique.

Concept de base de l'AOP

• Point de connexion : JoinPoint, une méthode contrôlable par AOP (implique des informations pertinentes lors de l'exécution de la méthode)
• Notification : Conseil, qui fait référence à la logique répétée, c'est-à-dire à la fonction commune (finalement incarnée comme méthode)
• Pointcut : PointCut, correspondant à la condition du point de jointure, les conseils ne seront appliqués que lorsque la méthode pointcut est exécutée. Habituellement, les expressions de point de coupure sont utilisées pour correspondre à la méthode de coupure.
• Aspect : Aspect décrivant la relation correspondante entre la notification et le point d'entrée (notification + point d'entrée)
• Objet cible : cible, l'objet auquel la notification s'applique.

AOP avancé

type de notification

@PointcutLes expressions Pointcut peuvent être extraites via des annotations . Réutilisez ensuite si nécessaire :

ordre de notification

expression de point de coupe

exécution

Faites correspondre la valeur de retour, le nom du package, le nom de la classe, le nom de la méthode, les paramètres de la méthode et d'autres informations de la méthode, et utilisez le

caractère générique d'expression du point d'entrée d'exécution :

annotation

Une annotation est utilisée pour faire correspondre les méthodes identifiées avec une annotation spécifique.

Définir une annotation :

ajoutez cette annotation à la méthode qui doit être notifiée :

Jonction

Utilisé pour obtenir des informations sur la méthode d'exécution réelle.

Printemps

priorité de configuration

Configuration des attributs Spring :

Gestion des haricots

Obtenez un haricot

Étapes réelles :

1. Le applicationContext de l'objet conteneur IOC est obtenu par injection (à l'aide de l'annotation @Autowired).
2. L'API fournie par l'objet applicationContext obtient le bean.
   

portée du haricot

L'objet bean obtenu créé par la portée par défaut est un singleton et vous pouvez utiliser l'annotation @Scope pour configurer la portée.

haricots tiers

Les dépendances tierces peuvent également générer des beans. Besoin d'utiliser l'annotation @Bean.

Principes de Spring Boot

SpringBoot simplifie le Spring Framework. Le principe principal est que la couche inférieure fournit les dépendances de démarrage et la configuration automatique.

Le principe du démarrage des dépendances est le transfert de dépendances de Maven.

Principe de configuration automatique

La classe de démarrage du projet Spring ajoutera par défaut des annotations à la classe de démarrage @ComponentScan, analysera les annotations sous le package où se trouve la classe de démarrage Componentet ajoutera la classe avec l'annotation au conteneur IOC.

Ensuite, si la classe de configuration de la bibliothèque tierce souhaite réaliser un assemblage automatique, la première solution consiste à utiliser @ComponentScanl'analyse des composants d'annotation.

Mais l'inconvénient de cette solution est que chaque fois qu'une annotation est déclarée @ComponentScan, tous les fichiers d'un package doivent être analysés, ce qui est fastidieux à utiliser et peu performant.

Option 2 : utilisez l'annotation @Import.

• @Import peut être déclaré sur une classe normale ou sur une classe de configuration annotée par @Configuration. peuvent être directement importés dans le conteneur IOC.
• Créez une classe d'importation et implémentez l'interface ImportSelecter. Les méthodes fournies par cette interface doivent être réécrites pour renvoyer le tableau de chaînes de nom de classe complet qui doit être importé dans le conteneur IOC.
• Dans la méthode ci-dessus, nous devons savoir exactement quelles classes doivent être importées dans le conteneur IOC. Les dépendances tierces sont en fait les classes les plus claires qui doivent être importées dans le conteneur IOC. Par conséquent, les dépendances tierces peuvent fournir des annotations @EnableXxxx, qui encapsulent @Importles annotations. Lorsque nous l'utilisons, il suffit d'ajouter des annotations à la classe de démarrage @EnableXxxx.
  

@SpringBootConfiguration

@SpringBootConfiguration :

• L'annotation @ComponentScan est intégrée, de sorte que toutes les classes contenant l'annotation @Component dans le package où réside la classe de démarrage et les sous-packages sont analysées.
• Intégrez l'annotation @Configuration, vous pouvez donc également configurer @Bean pour les déclarations de dépendances tierces dans la classe de démarrage, qui est également une annotation de configuration.
• Le plus important : il contient l'annotation EnableAutoConfiguration, qui implémente le retour des deux fichiers sous le package spring-boot-autoconfigure sous la forme d'une liste de chaînes, et les enregistrements de ces deux fichiers doivent être importés dans IOC. nom de classe qualifié de la classe du conteneur.
  

@Conditionnel

À en juger par certaines conditions, l'objet bean ne sera enregistré dans le conteneur IOC de Spring qu'une fois que les conditions données seront remplies.

• ConditionalOnClass : déterminez si le fichier de bytecode existe dans l'environnement, puis ajoutez le Bean au conteneur IOC.
  
• ConditionalOnMissingBean : déterminez si le bean existe dans l'environnement, et sinon, le bean sera enregistré dans le conteneur IOC.Généralement utilisé pour la déclaration Bean par défaut
• ConditionalOnProperty : qu'il existe des propriétés et des valeurs correspondantes dans le fichier de configuration, le Bean est enregistré dans le conteneur IOC.

démarreur personnalisé

Convention de dénomination :
Spring-boot-starter-function est le nom du package de dépendances de démarrage officiellement fourni par Spring.
Le nom du package dépendant du démarrage fourni par d'autres technologies mettra le nom de la fonction en premier : function-spring-boot-starter

Un démarreur personnalisé doit compléter deux packages : les dépendances de démarrage et la configuration automatique, qui complètent respectivement la fonction de gestion des dépendances et la fonction de configuration automatique.

Cas : personnalisation du lanceur Alibaba Cloud OSS

Étape 1 : Créez deux modules, Enabler et Autoconfig.

Le lanceur dépend de la configuration automatique :

Étape 2 : Terminez la mise en œuvre des fonctions logiques d'Alibaba Cloud OSS.

Importez d'abord les dépendances, y compris les dépendances spring-web et Alibaba Cloud oss :

réalisez l'écriture de la classe AliOSSUtills, qui doit transmettre des informations de configuration lors de son utilisation.

Les informations de configuration doivent également personnaliser un objet de classe, et ses valeurs d'attribut @ConfigurationPropertiesfont référence aux attributs d'objet préfixés par « aliyun.oss » dans le fichier de configuration via des annotations.

Étape 3 : Créez la classe de configuration automatique.

Utilisez l'annotation @EnableConfigurationProperties pour suivre le chemin de configuration automatique de Spring, créer un fichier de configuration et répertorier les noms de classe qui doivent être enregistrés dans le conteneur : Étape 4 : Tester l'utilisation Le module de test n'a besoin que d'introduire la dépendance du module de

démarrage
. maintenant.

Dans le fichier de configuration, configurez les propriétés de configuration d'Alibaba Cloud oss ​​:

il pourra ensuite être injecté directement lors de son utilisation !

Résumer