0. SOIN AOP
La programmation orientée vers l'aspect (AOP) est un sujet brûlant dans le développement de logiciels et une partie importante du framework Spring. Les différentes parties de la logique commerciale peuvent être isolées en utilisant AOP, réduisant ainsi le couplage entre les différentes parties de la logique métier, améliorant la réutilisabilité du programme et améliorant l'efficacité du développement.
AOP est une continuation de la POO.
Les principales fonctions sont les suivantes: journalisation, statistiques de performance, contrôle de sécurité, traitement des transactions, gestion des exceptions, etc.
L'intention principale est de diviser les codes tels que la journalisation, les statistiques de performance, le contrôle de sécurité, le traitement des transactions, la gestion des exceptions, etc. à partir du code de logique métier. En séparant ces comportements, nous espérons les séparer en méthodes de logique métier non guidant, puis modifier ces comportements sans affecter le code de la logique métier.
Une technologie qui ajoute dynamiquement des fonctions aux programmes sans modifier le code source peut être réalisée grâce à des méthodes de précompilation et à une proxyme dynamique pendant l'exécution. AOP est en fait une continuation du modèle de conception GoF. Le modèle de conception poursuit le découplage entre l'appelant et la Callee, améliorant la flexibilité et l'évolutivité du code. AOP peut être considéré comme une mise en œuvre de cet objectif.
Fournit un support riche pour la programmation orientée vers l'aspect au printemps, permettant le développement cohérent en séparant la logique métier de l'application des services au niveau du système tels que l'audit et la gestion des transactions. Les objets d'application implémentent uniquement ce qu'ils devraient faire - une logique commerciale complète - c'est tout. Ils ne sont pas responsables (ni même conscients) d'autres préoccupations au niveau du système, telles que l'exploitation forestière ou le support de transaction.
1. Chargez d'autres fichiers de configuration externes ou fichiers de propriété à Spring via PropertyPlaceHolderConfigurer:
Dans de nombreux projets Javaee, le rôle du printemps est très important. Il s'agit d'un récipient léger qui gère d'autres modules et composants. Spring a souvent besoin de gérer les entretoises, les ibatis, l'hibernate, etc. Les fichiers de configuration de ces cadres open source sont chargés à Spring via PropertyPlaceHolder Concerning pour la gestion. En outre, les informations de connexion de la base de données, les fichiers de propriété d'informations de connexion JNDI, etc. peuvent également être chargés dans le ressort via PropertyPlaceHolderConfigurer pour la gestion. L'utilisation est la suivante:
(1). Chargez d'autres fichiers dans Spring via PropertyPlaceHolderConfigurer:
Ajoutez la configuration suivante dans le fichier de configuration de ressort:
<bean class = "org.springframework.beans.factory.config.propertyplaceholderconfigurer"> <propriété name = "Locations"> <value> classpath: nom de fichier à charger </value>… </prophe> </Ean>
(2). Le fichier de configuration ou d'attribut à charger via la configuration en (1) est chargé dans le ressort. Si vous avez également besoin d'utiliser des informations sur la configuration ou le fichier de données chargé à l'exécution, comme utiliser des informations de connexion de base de données ou des informations de connexion JNDI, vous pouvez utiliser la syntaxe des expressions EL de type à référence, par exemple: par exemple:
<bean id = ”dataSource” destrement-méthod = ”close" class = "org.apache.common.dbcp.basicDatasource"> <! - Supposons que les informations de connexion de la base de données soient écrites dans un fichier de propriété externe et ont été chargés par Spring -> <propriété name = "DriverClassName" Value = "$ {driver}" /> <propriété name = "url" value = ”$ {url}” /> <propriété name = ”username” value = ”$ {username}” /> <propriété name = ”mot de passe” value = ”$ {mot de passe}” /> </ bean>
Remarque: vous pouvez également utiliser <Context: Property-placeholderLocation = "ClassPath: nom de fichier à charger" />
2. Proxy dynamique pour Java:
Le principe de mise en œuvre sous-jacent de Spring est un proxy dynamique, vous devez donc d'abord comprendre la procuration dynamique avant d'apprendre la programmation orientée vers l'aspect.
Le proxy dynamique est largement utilisé dans Java, et le proxy dynamique est l'un des modèles de conception classiques qui sont très couramment utilisés dans les modèles de conception en 23. Le principe de proxy dynamique est que lorsqu'un objet cible ou sa méthode doit être appelé, le système ne renvoie pas directement l'objet cible, mais renvoie un objet proxy et accéde à l'objet ou la méthode cible de l'objet cible par cet objet proxy.
Le principe simple du proxy dynamique est le suivant:
Client Caller -> Objet proxy -> appelé objet cible.
Lorsque le client appelle l'objet Proxy, l'objet Proxy délègue l'objet cible pour appeler sa méthode commerciale.
Le proxy dynamique est divisé en deux types: proxy dynamique pour les interfaces et proxy dynamique pour les classes ordinaires. Le proxy dynamique dans Java est un indicateur dynamique pour les interfaces réelles. CGLIB est un proxy dynamique pour les classes ordinaires. Le package de dépendance Javaee Target et le package de pot à ressort contiennent déjà des packages JAR liés à CGLIB, vous pouvez donc proxie dynamiquement les classes proxy ou ordinaires.
(1) Proxy dynamique de Java pour les interfaces:
Le proxy dynamique en Java ne peut être que dynamiquement proxyé pour les interfaces. Par conséquent, l'objet cible doit implémenter les interfaces et l'objet proxy doit implémenter toutes les interfaces de l'objet cible. Le workflow est le suivant:
un. Écriture dynamique de la classe proxy:
Remarque: Dynamic Proxy doit implémenter l'interface InvocationHandler et implémenter les méthodes suivantes:
La copie de code est la suivante:
Object Invoke (objetm proxy instance, instance de méthode de la méthode d'interface appelée instance proxy de méthode, objet [] un tableau d'objet de valeurs de paramètres transmis dans l'instance proxy);
La documentation pour l'installation de JDK est expliquée. Cette méthode est utilisée pour passer l'instance proxy, identifier l'objet java.lang.reflect.method qui appelle la méthode et un tableau de types de type d'objets contenant des paramètres. Le gestionnaire d'appel gère l'appel de méthode codé de manière appropriée, et le résultat qu'il renvoie sera renvoyé à la suite de l'appel de la méthode sur l'instance proxy.
né Créer un objet proxy:
Proxy.newproxyinstance (chargeur de classe, classe <?> [] Array d'interface, objet proxy de rappel (généralement ceci))
Lorsque la méthode de l'objet cible est appelée, l'objet proxy de l'objet cible est créé via la méthode. L'objet proxy appellera automatiquement sa méthode invoquée pour appeler l'objet cible et renvoyer le résultat de l'appel.
(2) .Cglib est un proxy dynamique pour les classes Java ordinaires:
Lorsque CGLIB crée un proxy dynamique, il ne nécessite pas que la classe cible implémente une interface. Son workflow est le suivant:
un. Écriture dynamique de la classe proxy:
Enhancer Enhancer = New Enhancer (); // Définissez la classe parent de la classe cible sur son propre améliorateur.SetSuperclass (cible class object.getClass ()); // Définissez l'objet de rappel sur l'objet proxy dynamique lui-même Enhancer.SetCallback (this);
né Implémentez l'interface MethodInterceptor:
Implémentez la méthode suivante:
Intercept d'objet (objectm proxy instance, instance de méthode de la méthode d'interface appelée instance proxy de méthode, objet [] un tableau d'objet de valeurs de paramètres transmis à l'appel de méthode sur l'instance proxy, instance proxy de méthode méthode méthode);
Remarque: CGLIB peut non seulement proxy dynamiquement pour les classes, mais également proxy dynamiquement pour les méthodes.
3. Concepts de base de la programmation orientée (AOP):
Prenez une méthode Java ordinaire comme exemple
Nom de la méthode du type de retour publique (Liste des paramètres) {-> Notation surround Méthode Méthode Code de prétraitement -> Pré-notification Try {méthode Implementation spécifique (Body Method Body) ... Méthode Code post-processus -> Post-notification} Catch (Type d'exception E)
un. Préoccupation croisée: par exemple, dans les 5 emplacements de notification ci-dessus, dans les objets Java, ces objets avec une logique de traitement commun similaire qui peuvent être ajoutés à la logique de traitement tels que la vérification de l'autorisation, le traitement des choses, la journalisation, etc. sont appelés préoccupations croisées. L'objectif de la programmation orientée objet (POO) est de résumer verticalement les choses dans le monde réel en un modèle d'objet de programmation. L'objectif de la programmation orientée vers l'aspect (AOP) est horizontal, ce qui résume les lieux similaires à la logique de traitement dans le modèle d'objet de programmation pour former une tangente, tandis que la logique de traitement dans l'objet de programmation est une mise au point tangente horizontale.
né Aspect: Résumé Les préoccupations transversales consistent à former une section, ce qui est similaire à la classe. Les deux ont des préoccupations différentes. Les classes sont des abstractions des caractéristiques des choses, et les sections sont des abstractions de préoccupations croisées.
c. JoinPoint: Le point qui est intercepté est mentionné dans le printemps, car Spring ne prend en charge que les points de connexion de type méthode, c'est-à-dire la méthode interceptée. Méthode comme indiqué dans l'exemple ci-dessus.
d. PointCut: fait référence à la définition de l'interception d'un point de connexion, qui est une collection de points de connexion, c'est-à-dire une collection d'une série de méthodes interceptées.
e. Conseil: fait référence à ce qu'il faut faire après avoir intercepté le point de connexion, c'est-à-dire un traitement logique après l'interception. La vérification de l'autorisation habituelle, le traitement des choses, l'exploitation forestière et d'autres opérations sont définies et terminées dans les notifications.
f. Cible: l'objet cible du proxy, c'est-à-dire l'objet intercepté. Comme dans l'exemple ci-dessus, l'objet où se trouve la méthode.
g. TEAVE: fait référence au processus d'application d'une section à l'objet cible et à provoquer la création d'un objet proxy.
h. Introduction: Sans modifier le code, l'introduction peut ajouter dynamiquement certaines méthodes et champs à la classe pendant l'exécution.
4. Spring prend en charge les dépendances qui prennent en charge la programmation orientée (AOP):
Les 3 forfaits suivants du répertoire après le printemps sont décompressés:
lib / aspectj / aspectjweaver.jarlib / aspectj / aspectjrt.jarlib / cglib / cglib-nodep-2.1-3.jar
5.
xmlns: aop = ”http://www.springframework.org/schema/aop" "http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd »
Remarque: Spring 2.5 fournit deux méthodes AOP, à savoir, sur la base du fichier de configuration XML et de la méthode d'annotation Java.
Pour utiliser la méthode d'annotation AOP, vous devez ajouter la prise en charge de la méthode d'annotation d'objet suivant dans le fichier de configuration de ressort:
<aop: aspectj-autoproxy />
6. Classe d'emballage Javabean - Beanwrapper:
Le printemps résume le comportement d'un Javabean via la classe Beanwrapper, et peut définir et obtenir ses valeurs d'attribut, telles que:
Beanwrapper wrapper classe objet = beanwrapperImpl (new ending class ()); wrapper class object.setPropertyValue ("nom de propriété", "valeur de propriété");
Cette méthode vous permet de définir des propriétés sur la classe enveloppée.
7. Développement de programmation orientée vers l'orientation (AOP) basée sur l'annotation:
(1). Ajoutez une prise en charge AOP pour les méthodes d'annotation dans le fichier de configuration de ressort.
(2). Définissez la section:
Semblable à la création d'une classe normale, l'ajout de l'annotation "@aspect" avant la classe indique que la classe est une section.
(3). Ajoutez des points d'entrée à la surface de coupe:
Un point de coupe ponctuel est une collection de méthodes d'objets interceptées. Habituellement, le point de coupe ponctuel est défini dans une méthode de traitement du point de coupe ponctuel dans la section. Utilisez l'annotation "@pointcut", et la syntaxe est la suivante:
@PointCut ("EXECUTION (* com.Test.Service .. *. * (..))") public void anyMethod () {// La méthode est appelée "Point-Cut" et "Point-Cut" Processing}
Explication détaillée des paramètres de syntaxe:
un. Le premier "*": signifie que la méthode en cours d'interception est un type de retour arbitraire.
né com.test.service: voici un exemple simple, indiquant le nom du package à intercepter, c'est-à-dire le paquet à intercepter.
c. Les deux ".." après le nom de paquet intercepté: signifie que les sous-paquets sous le paquet intercepté sont également interceptés récursivement, c'est-à-dire le sous-packet intercepté.
d. "*" After "..": représente toutes les classes sous le paquet intercepté et son sous-package, c'est-à-dire la classe interceptée.
e. Le dernier "*": représente toutes les méthodes de la classe interceptée, c'est-à-dire la méthode interceptée.
f. "(..)": signifie que la méthode interceptée reçoit tous les paramètres, c'est-à-dire les paramètres interceptés.
Remarque: La syntaxe de définition point-point peut prendre en charge les caractères génériques, mais vous devez strictement suivre les règles de syntaxe. comme:
@Pointcut ("EXECUTION (* com.test.service .. *. Add * (..))") Cela signifie intercepter les méthodes en commençant par "ajouter" dans toutes les classes dans le package com.test.service et son sous-package.
(4). Ajouter des notifications à la section:
Pour les emplacements de notification au printemps, veuillez vous référer aux petits exemples en 3.
Annotation "@before": déclarer une pré-notification.
Annotation "@afterrutruning": déclarer après la notification.
Annotation "@after": déclarer l'avis final.
Annotation "@afterthrowing": déclarer la notification d'exception.
Annotation "@around": déclare les notifications environnantes.
Un exemple de définition des notifications est la suivante:
@Before ("anyMethod () (le nom du point d'entrée déclaré dans le visage fendu)") public void doaccesscheck () {...}
Remarque: La notification surround est légèrement différente des 4 autres types de notifications. La notification surround est définie de manière spéciale. La notification surround fonctionnera avant et après l'appel entier de la méthode, de sorte que l'objet de point de connexion doit être utilisé pour indiquer le point de connexion pour poursuivre son traitement logique après le traitement de la notification surround. Sa définition est la suivante:
@Around (recherche dans le nom de point) objet public dobasicprofiling (procédingjoinpoint pjp) lève throwsable {... return pjp.proceed (); // Cette phrase indique au point de connexion pour continuer à effectuer d'autres opérations} 8. Quelques conseils pour le développement de la programmation orientée vers l'aspect (AOP) basé sur l'annotation:
(1). Obtenez des paramètres d'entrée:
comme:
@Before ("Inscrivez le nom du point et les args (nom du paramètre d'entrée)") public void dosomething (chaîne Nom du paramètre d'entrée) {...}
(2). Obtenez le résultat de retour:
comme:
@Afterreturning (Pointcut = ”Sign in Point Nom”, return = ”return Nom du résultat”) public void dosomething (Nom du résultat de la chaîne) {…}
9. Développement de la programmation orientée section (AOP) basée sur XML:
(1). Définissez la classe Facet et ajoutez des notifications à la classe Facet.
(2). Configurez la classe Facet dans le fichier de configuration de ressort comme la classe Java ordinaire.
(3). Ajoutez une configuration AOP dans le fichier de configuration de ressort comme suit:
<aop: config> <! - Section de configuration -> <aop: aspect id = "section id" ref = "id de la classe de section dans le fichier de configuration de printemps"> <! - Point de configuration -> <aop: Pointcut id = "section id" expression = "EXECUTION (* com.test.service .. *. * (..))" /> <! - Configuration idtification -> <aop: before PointCut-ré) Méthodes dans la classe de section "/> <aop: après… />… </aop: aspect> </ aop: config>
10. Traitement des transactions de Spring (traitement de la transaction déclarative de Spring):
Autrement dit, une transaction fait référence à l'une des opérations les plus élémentaires de la base de données. Une explication détaillée de la transaction sera expliquée en détail dans le résumé lié à la base de données. L'une des applications les plus importantes de la programmation orientée vers l'orientation de Spring (AOP) est la gestion des transactions. La gestion des transactions des versions Spring 2.5 et ultérieures prend en charge deux types de méthodes basées sur l'annotation et les méthodes basées sur des fichiers XML:
(1). Gestion des transactions basée sur la méthode d'annotation:
un. Ajouter l'espace de noms de gestion des transactions dans le fichier de configuration de Spring comme suit:
xmlns: ts = http: //www.springframework.org/schema/tx http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
né Configurez le gestionnaire de transaction dans le fichier de configuration de Spring comme suit:
<bean id = ”txManager” class = ”org.springframework.jdbc.datasource.datasourcetransactionManager"> <propriété name = ”dataSource" ref = "id de la source de données Configuration dans Spring" />
c. Ajouter des éléments de configuration de transaction qui prennent en charge les méthodes d'annotation dans le fichier de configuration de ressort sont les suivants:
<TX: Annotation-DriventRansaction-Manager-TX: Annotation-DriventRansaction-Manager = ”TxManager (ID du gestionnaire de transaction configuré dans le printemps)» />
d. Utiliser la gestion des transactions basée sur l'annotation:
Dans le projet Javaee géré par Spring, la logique métier de la transaction doit être ajoutée avec l'annotation "@Transactional".
(2). Gestion des transactions basée sur la méthode du fichier XML:
un. Configurez le gestionnaire de transaction dans le fichier de configuration de Spring comme suit:
<bean id = ”txManager” class = ”org.springframework.jdbc.datasource.datasourcetransactionManager"> <propriété name = ”dataSource" ref = "id de la source de données Configuration dans Spring" />
né Ajoutez les sections de gestion suivantes dans le fichier de configuration de ressort:
<aop: config> <! - Configurer le point de saisie des transactions -> <aop: Pointcut id = ”TransactionPointcut” Expression = ”EXECUTION (* com.test.service .. *. * (..)))" /> <! - Configurer la notification de transaction -> <aop: conseillère conseil-ref = ”txadvice" PointCut-ref = "transactionpointcut" /> </ aop: config> Configinc. Ajoutez les fonctionnalités suivantes pour les notifications de transaction dans le fichier de configuration de Spring:
<tx: conseils id = ”txadvice” transactionManager = ”txManager”> <tx: attributs> <! - Voici un exemple pour définir la méthode de requête en commençant par Get To Readly = ”Propagation des transactions" Not_Supports "Get * - Autres méthodes sont des méthodes pour Spring To Spring = <Tx" name = ”*” /> </ tx: attributs> </ tx: conseils>